keystone-cli 1.0.2 → 1.1.0

package/src/parser/workflow-parser.test.ts

@@ -82,6 +82,30 @@ steps:
       expect(workflow.steps.length).toBeGreaterThan(0);
     });
 
+    test('should expand matrix strategy into foreach', () => {
+      const content = `
+name: matrix-workflow
+steps:
+  - id: test_matrix
+    type: shell
+    run: echo test
+    strategy:
+      matrix:
+        node: [18, 20]
+        os: [ubuntu, macos]
+`;
+      const filePath = join(tempDir, 'matrix.yaml');
+      writeFileSync(filePath, content);
+      const workflow = WorkflowParser.loadWorkflow(filePath);
+      const step = workflow.steps[0] as { foreach?: string; strategy?: unknown };
+      expect(step.foreach).toBeDefined();
+      const items = JSON.parse(step.foreach || '[]') as Array<Record<string, unknown>>;
+      expect(items).toHaveLength(4);
+      expect(items[0]).toHaveProperty('node');
+      expect(items[0]).toHaveProperty('os');
+      expect(step.strategy).toBeUndefined();
+    });
+
     test('should throw on invalid schema', () => {
       const content = `
 name: invalid

package/src/parser/workflow-parser.ts

@@ -22,6 +22,9 @@ export class WorkflowParser {
       const workflow = WorkflowSchema.parse(raw);
       const workflowDir = dirname(path);
 
+      // Expand matrix strategies into foreach items
+      WorkflowParser.applyMatrixStrategies(workflow);
+
       // Resolve implicit dependencies from expressions
       WorkflowParser.resolveImplicitDependencies(workflow);
 
@@ -31,6 +34,9 @@ export class WorkflowParser {
       // Validate agents exist
       WorkflowParser.validateAgents(workflow, workflowDir);
 
+      // Validate artifact steps
+      WorkflowParser.validateArtifacts(workflow);
+
       // Validate errors block
       WorkflowParser.validateErrors(workflow);
 
@@ -77,6 +83,43 @@ export class WorkflowParser {
     }
   }
 
+  /**
+   * Expand step.strategy.matrix into foreach expressions.
+   */
+  private static applyMatrixStrategies(workflow: Workflow): void {
+    const allSteps = [...workflow.steps, ...(workflow.errors || []), ...(workflow.finally || [])];
+    for (const step of allSteps) {
+      if (!step.strategy?.matrix) continue;
+
+      if (step.foreach) {
+        throw new Error(`Step "${step.id}" cannot use both foreach and strategy.matrix`);
+      }
+
+      const matrix = step.strategy.matrix;
+      const keys = Object.keys(matrix);
+      if (keys.length === 0) {
+        throw new Error(`Step "${step.id}" matrix must define at least one axis`);
+      }
+
+      let combos: Array<Record<string, unknown>> = [{}];
+      for (const key of keys) {
+        const values = matrix[key];
+        if (!Array.isArray(values) || values.length === 0) {
+          throw new Error(`Step "${step.id}" matrix axis "${key}" must have at least one value`);
+        }
+        combos = combos.flatMap((combo) =>
+          values.map((value) => ({
+            ...combo,
+            [key]: value,
+          }))
+        );
+      }
+
+      step.foreach = JSON.stringify(combos);
+      step.strategy = undefined;
+    }
+  }
+
   /**
    * Automatically detect step dependencies from expressions
    */
@@ -172,6 +215,22 @@ export class WorkflowParser {
     }
   }
 
+  /**
+   * Validate artifact steps have the required fields for their operation.
+   */
+  private static validateArtifacts(workflow: Workflow): void {
+    const allSteps = [...workflow.steps, ...(workflow.errors || []), ...(workflow.finally || [])];
+    for (const step of allSteps) {
+      if (step.type !== 'artifact') continue;
+      if (step.op === 'upload' && (!step.paths || step.paths.length === 0)) {
+        throw new Error(`Artifact step "${step.id}" requires paths for upload`);
+      }
+      if (step.op === 'download' && !step.path) {
+        throw new Error(`Artifact step "${step.id}" requires path for download`);
+      }
+    }
+  }
+
   /**
    * Validate finally block
    */
@@ -244,7 +303,8 @@ export class WorkflowParser {
 
     // Validate all dependencies exist before sorting
     for (const step of workflow.steps) {
-      for (const dep of step.needs) {
+      const needs = step.needs || [];
+      for (const dep of needs) {
         if (!stepMap.has(dep)) {
           throw new Error(`Step "${step.id}" depends on non-existent step "${dep}"`);
         }
@@ -254,13 +314,15 @@ export class WorkflowParser {
     // Calculate in-degree
     // In-degree = number of dependencies a step has
     for (const step of workflow.steps) {
-      inDegree.set(step.id, step.needs.length);
+      const needs = step.needs || [];
+      inDegree.set(step.id, needs.length);
     }
 
     // Build reverse dependency map for O(1) lookups instead of O(n)
     const dependents = new Map<string, string[]>();
     for (const step of workflow.steps) {
-      for (const dep of step.needs) {
+      const needs = step.needs || [];
+      for (const dep of needs) {
         if (!dependents.has(dep)) dependents.set(dep, []);
         dependents.get(dep)?.push(step.id);
       }

package/src/runner/auto-heal.test.ts

@@ -29,8 +29,7 @@ describe('WorkflowRunner Auto-Heal', () => {
       dbPath: ':memory:',
     });
 
-    // biome-ignore lint/suspicious/noExplicitAny: Accessing private property for testing
-    const db = (runner as any).db;
+    const db = (runner as unknown as { db: any }).db;
     await db.createRun(runner.runId, workflow.name, {});
 
     const spy = jest.spyOn(StepExecutor, 'executeStep');
@@ -44,8 +43,7 @@ describe('WorkflowRunner Auto-Heal', () => {
       }
 
       if (step.id === 'fail-step') {
-        // biome-ignore lint/suspicious/noExplicitAny: Accessing run property dynamically
-        if ((step as any).run === 'echo "fixed"') {
+        if ((step as unknown as { run: string }).run === 'echo "fixed"') {
           return { status: 'success', output: 'fixed' };
         }
         return { status: 'failed', output: null, error: 'Command failed' };
@@ -54,8 +52,9 @@ describe('WorkflowRunner Auto-Heal', () => {
       return { status: 'failed', output: null, error: 'Unknown step' };
     });
 
-    // biome-ignore lint/suspicious/noExplicitAny: Accessing private property for testing
-    await (runner as any).executeStepWithForeach(workflow.steps[0]);
+    await (
+      runner as unknown as { executeStepWithForeach: (step: Step) => Promise<void> }
+    ).executeStepWithForeach(workflow.steps[0]);
 
     expect(spy).toHaveBeenCalledTimes(3);
 

package/src/runner/blueprint-executor.test.ts

@@ -4,8 +4,8 @@ import * as path from 'node:path';
 import type { ExpressionContext } from '../expression/evaluator';
 import type { Blueprint, BlueprintStep, Step } from '../parser/schema';
 import type { Logger } from '../utils/logger';
-import { executeBlueprintStep } from './blueprint-executor';
-import type { executeLlmStep } from './llm-executor';
+import { executeBlueprintStep } from './executors/blueprint-executor.ts';
+import type { executeLlmStep } from './executors/llm-executor.ts';
 import type { StepResult } from './step-executor';
 
 describe('BlueprintExecutor', () => {

package/src/runner/debug-repl.test.ts

@@ -96,10 +96,9 @@ describe('DebugRepl', () => {
     await new Promise((r) => setTimeout(r, 10));
 
     expect(mockLogger.log).toHaveBeenCalled();
-    // biome-ignore lint/suspicious/noExplicitAny: accessing mock property
-    const lastCall = (mockLogger.log as unknown as any).mock.calls.find((call: any[]) =>
-      String(call[0]).includes('foo')
-    );
+    const lastCall = (
+      (mockLogger.log as unknown as { mock: { calls: any[][] } }).mock.calls as any[][]
+    ).find((call: any[]) => String(call[0]).includes('foo'));
     expect(lastCall?.[0]).toContain('bar');
     input.write('exit\n');
   });
@@ -233,8 +232,7 @@ describe('DebugRepl', () => {
     const repl = new DebugRepl(mockContext, mockStep, mockError, mockLogger, input, output);
 
     const spySpawnSync = spyOn(cp, 'spawnSync').mockImplementation(
-      // biome-ignore lint/suspicious/noExplicitAny: mocking child_process
-      () => ({ error: null, status: 0 }) as any
+      () => ({ error: null, status: 0 }) as unknown as cp.SpawnSyncReturns<Buffer>
     );
     const spyWriteFileSync = spyOn(fs, 'writeFileSync').mockImplementation(() => {});
     const updatedStep = { ...mockStep, run: 'echo "fixed"' };
@@ -276,8 +274,7 @@ describe('DebugRepl', () => {
     const repl = new DebugRepl(mockContext, mockStep, mockError, mockLogger, input, output);
 
     const spySpawnSync = spyOn(cp, 'spawnSync').mockImplementation(
-      // biome-ignore lint/suspicious/noExplicitAny: mocking child_process
-      () => ({ error: null, status: 0 }) as any
+      () => ({ error: null, status: 0 }) as unknown as cp.SpawnSyncReturns<Buffer>
     );
     const spyWriteFileSync = spyOn(fs, 'writeFileSync').mockImplementation(() => {});
     const spyReadFileSync = spyOn(fs, 'readFileSync').mockImplementation(

package/src/runner/debug-repl.ts

@@ -12,9 +12,16 @@ import { ConsoleLogger, type Logger } from '../utils/logger.ts';
 
 export type DebugAction =
   | { type: 'retry'; modifiedStep?: Step }
+  | { type: 'continue'; modifiedStep?: Step }
   | { type: 'skip' }
   | { type: 'continue_failure' }; // Default behavior (exit debug mode, let it fail)
 
+export type DebugReplMode = 'error' | 'breakpoint';
+
+export interface DebugReplOptions {
+  mode?: DebugReplMode;
+}
+
 export class DebugRepl {
   constructor(
     private context: ExpressionContext,
@@ -22,21 +29,35 @@ export class DebugRepl {
     private error: unknown,
     private logger: Logger = new ConsoleLogger(),
     private inputStream: NodeJS.ReadableStream = process.stdin,
-    private outputStream: NodeJS.WritableStream = process.stdout
+    private outputStream: NodeJS.WritableStream = process.stdout,
+    private options: DebugReplOptions = {}
   ) {}
 
   public async start(): Promise<DebugAction> {
-    this.logger.error(`\n❌ Step '${this.step.id}' failed.`);
-    this.logger.error(
-      `   Error: ${this.error instanceof Error ? this.error.message : String(this.error)}`
-    );
-    this.logger.log('\nEntering Debug Mode. Available commands:');
-    this.logger.log('  > context      (view current inputs/outputs involved in this step)');
-    this.logger.log('  > retry        (re-run step, optionally with edited definition)');
-    this.logger.log('  > edit         (edit the step definition in your $EDITOR)');
-    this.logger.log('  > skip         (skip this step and proceed)');
-    this.logger.log('  > eval <code>  (run JS expression against context)');
-    this.logger.log('  > exit         (resume failure/exit)');
+    const mode = this.options.mode || 'error';
+
+    if (mode === 'breakpoint') {
+      this.logger.log(`\n⛔ Breakpoint hit before step '${this.step.id}'.`);
+      this.logger.log('\nEntering Debug Mode. Available commands:');
+      this.logger.log('  > context      (view current inputs/outputs involved in this step)');
+      this.logger.log('  > continue     (run the step, optionally with edited definition)');
+      this.logger.log('  > edit         (edit the step definition in your $EDITOR)');
+      this.logger.log('  > skip         (skip this step and proceed)');
+      this.logger.log('  > eval <code>  (run JS expression against context)');
+      this.logger.log('  > exit         (continue without changes)');
+    } else {
+      this.logger.error(`\n❌ Step '${this.step.id}' failed.`);
+      this.logger.error(
+        `   Error: ${this.error instanceof Error ? this.error.message : String(this.error)}`
+      );
+      this.logger.log('\nEntering Debug Mode. Available commands:');
+      this.logger.log('  > context      (view current inputs/outputs involved in this step)');
+      this.logger.log('  > retry        (re-run step, optionally with edited definition)');
+      this.logger.log('  > edit         (edit the step definition in your $EDITOR)');
+      this.logger.log('  > skip         (skip this step and proceed)');
+      this.logger.log('  > eval <code>  (run JS expression against context)');
+      this.logger.log('  > exit         (resume failure/exit)');
+    }
 
     const rl = readline.createInterface({
       input: this.inputStream,
@@ -74,8 +95,21 @@ export class DebugRepl {
             break;
 
           case 'retry':
-            resolveOnce({ type: 'retry', modifiedStep: this.step });
-            rl.close();
+            if (mode === 'breakpoint') {
+              resolveOnce({ type: 'continue', modifiedStep: this.step });
+              rl.close();
+            } else {
+              resolveOnce({ type: 'retry', modifiedStep: this.step });
+              rl.close();
+            }
+            break;
+
+          case 'continue':
+          case 'run':
+            if (mode === 'breakpoint') {
+              resolveOnce({ type: 'continue', modifiedStep: this.step });
+              rl.close();
+            }
             break;
 
           case 'skip':
@@ -85,7 +119,11 @@ export class DebugRepl {
 
           case 'exit':
           case 'quit':
-            resolveOnce({ type: 'continue_failure' });
+            if (mode === 'breakpoint') {
+              resolveOnce({ type: 'continue', modifiedStep: this.step });
+            } else {
+              resolveOnce({ type: 'continue_failure' });
+            }
             rl.close();
             break;
 
@@ -125,7 +163,12 @@ export class DebugRepl {
             break;
         }
 
-        if (cmd !== 'retry' && cmd !== 'skip' && cmd !== 'exit' && cmd !== 'quit') {
+        const terminalCommands =
+          mode === 'breakpoint'
+            ? new Set(['retry', 'continue', 'run', 'skip', 'exit', 'quit'])
+            : new Set(['retry', 'skip', 'exit', 'quit']);
+
+        if (!terminalCommands.has(cmd)) {
           rl.prompt();
         }
       });

package/src/runner/durable-timers.test.ts

@@ -174,10 +174,17 @@ describe('Durable Timers Integration', () => {
     }
 
     // Manually backdate the timer in the DB to simulate elapsed time
-    const pastDate = new Date(Date.now() - 1000).toISOString();
+    const pastDate = new Date(Date.now() - 10000).toISOString();
     const { Database } = require('bun:sqlite');
     const sqlite = new Database(dbPath);
     sqlite.prepare('UPDATE durable_timers SET wake_at = ? WHERE id = ?').run(pastDate, timer.id);
+
+    // Also need to update the step_executions output, as WorkflowState hydrates from there
+    const newOutput = JSON.stringify({ durable: true, wakeAt: pastDate, durationMs: 120000 });
+    sqlite
+      .prepare('UPDATE step_executions SET output = ? WHERE run_id = ? AND step_id = ?')
+      .run(newOutput, runId, 'wait');
+
     sqlite.close();
 
     const resumeRunner = new WorkflowRunner(sleepWorkflow, {
@@ -192,7 +199,9 @@ describe('Durable Timers Integration', () => {
     expect(run?.status).toBe(WorkflowStatus.SUCCESS);
 
     const steps = await db.getStepsByRun(runId);
-    expect(steps[0].status).toBe(StepStatus.SUCCESS);
+    const waitStep = steps.find((s) => s.step_id === 'wait' && s.status === StepStatus.SUCCESS);
+    expect(waitStep).toBeDefined();
+    expect(waitStep?.status).toBe(StepStatus.SUCCESS);
 
     const finalTimer = await db.getTimer(timer.id);
     expect(finalTimer?.completed_at).not.toBeNull();

package/src/runner/engine-executor.test.ts

@@ -3,7 +3,7 @@ import { mkdirSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import type { EngineStep } from '../parser/schema';
-import { executeEngineStep } from './engine-executor';
+import { executeEngineStep } from './executors/engine-executor.ts';
 
 // Helper to create a minimal valid EngineStep for testing
 const createStep = (overrides: Partial<EngineStep>): EngineStep =>

package/src/runner/events.ts

@@ -0,0 +1,57 @@
+import type { StepStatusType, WorkflowStatusType } from '../types/status.ts';
+
+export type StepPhase = 'main' | 'errors' | 'finally';
+
+export type WorkflowEvent =
+  | {
+      type: 'workflow.start';
+      timestamp: string;
+      runId: string;
+      workflow: string;
+      inputs?: Record<string, unknown>;
+    }
+  | {
+      type: 'step.start';
+      timestamp: string;
+      runId: string;
+      workflow: string;
+      stepId: string;
+      stepType: string;
+      phase: StepPhase;
+      stepIndex?: number;
+      totalSteps?: number;
+    }
+  | {
+      type: 'step.end';
+      timestamp: string;
+      runId: string;
+      workflow: string;
+      stepId: string;
+      stepType: string;
+      phase: StepPhase;
+      status: StepStatusType;
+      durationMs?: number;
+      error?: string;
+      stepIndex?: number;
+      totalSteps?: number;
+    }
+  | {
+      type: 'llm.thought';
+      timestamp: string;
+      runId: string;
+      workflow: string;
+      stepId: string;
+      content: string;
+      source: 'thinking' | 'reasoning';
+    }
+  | {
+      type: 'workflow.complete';
+      timestamp: string;
+      runId: string;
+      workflow: string;
+      status: WorkflowStatusType;
+      outputs?: Record<string, unknown>;
+      error?: string;
+    };
+
+export type EventHandler = (event: WorkflowEvent) => void;

package/src/runner/executors/artifact-executor.ts

@@ -0,0 +1,166 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { globSync } from 'glob';
+import type { ExpressionContext } from '../../expression/evaluator.ts';
+import { ExpressionEvaluator } from '../../expression/evaluator.ts';
+import type { ArtifactStep } from '../../parser/schema.ts';
+import type { Logger } from '../../utils/logger.ts';
+import type { StepResult } from './types.ts';
+
+function normalizePath(rawPath: string): string {
+  const trimmed = rawPath.trim();
+  return trimmed.length > 0 ? trimmed : '.';
+}
+
+function assertWithinBaseDir(
+  baseDir: string,
+  targetPath: string,
+  allowOutsideCwd?: boolean,
+  label = 'Path'
+): void {
+  if (allowOutsideCwd) return;
+  const realBase = fs.realpathSync(baseDir);
+  const normalizedPath = normalizePath(targetPath);
+  const resolvedPath = path.resolve(baseDir, normalizedPath);
+
+  let current = resolvedPath;
+  while (current !== path.dirname(current) && !fs.existsSync(current)) {
+    current = path.dirname(current);
+  }
+  const realTarget = fs.existsSync(current) ? fs.realpathSync(current) : current;
+  const relativePath = path.relative(realBase, realTarget);
+  if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+    throw new Error(
+      `Access denied: ${label} '${normalizedPath}' resolves outside the working directory. Use 'allowOutsideCwd: true' to override.`
+    );
+  }
+}
+
+function resolveSafeRelativePath(baseDir: string, absolutePath: string): string {
+  const relativeToBase = path.relative(baseDir, absolutePath);
+  if (!relativeToBase.startsWith('..') && !path.isAbsolute(relativeToBase)) {
+    return relativeToBase;
+  }
+  const root = path.parse(absolutePath).root;
+  return path.relative(root, absolutePath);
+}
+
+/**
+ * Execute an artifact step (upload/download)
+ */
+export async function executeArtifactStep(
+  step: ArtifactStep,
+  context: ExpressionContext,
+  logger: Logger,
+  options: {
+    artifactRoot?: string;
+    workflowDir?: string;
+    runId?: string;
+    abortSignal?: AbortSignal;
+  }
+): Promise<StepResult> {
+  if (options.abortSignal?.aborted) {
+    throw new Error('Artifact operation aborted');
+  }
+  const baseDir = options.workflowDir || process.cwd();
+  const rawName = ExpressionEvaluator.evaluateString(step.name, context);
+  if (typeof rawName !== 'string' || rawName.trim().length === 0) {
+    throw new Error('Artifact name must be a non-empty string');
+  }
+  const sanitizedName = rawName.replace(/[^a-zA-Z0-9._-]/g, '_');
+  if (sanitizedName !== rawName) {
+    logger.warn(
+      `⚠️  Artifact name "${rawName}" contained unsafe characters. Using "${sanitizedName}".`
+    );
+  }
+
+  const artifactRoot = options.artifactRoot || path.join(process.cwd(), '.keystone', 'artifacts');
+  const runDir = options.runId ? path.join(artifactRoot, options.runId) : artifactRoot;
+
+  if (!fs.existsSync(runDir)) {
+    fs.mkdirSync(runDir, { recursive: true });
+  }
+
+  const artifactPath = path.join(runDir, sanitizedName);
+
+  if (step.op === 'upload') {
+    const patterns = (
+      step.paths && step.paths.length > 0 ? step.paths : step.path ? [step.path] : []
+    ).map((value) => ExpressionEvaluator.evaluateString(value, context));
+    if (patterns.length === 0) {
+      throw new Error('Artifact upload requires at least one path');
+    }
+
+    const matchedFiles = new Set<string>();
+    for (const pattern of patterns) {
+      const matches = globSync(pattern, {
+        cwd: baseDir,
+        absolute: true,
+        dot: true,
+        nodir: true,
+      });
+      for (const match of matches) {
+        matchedFiles.add(match);
+      }
+    }
+
+    if (matchedFiles.size === 0) {
+      throw new Error(`No files matched for artifact "${rawName}"`);
+    }
+
+    await fs.promises.rm(artifactPath, { recursive: true, force: true });
+    fs.mkdirSync(artifactPath, { recursive: true });
+
+    const files: string[] = [];
+    for (const filePath of matchedFiles) {
+      if (options.abortSignal?.aborted) {
+        throw new Error('Artifact upload aborted');
+      }
+      assertWithinBaseDir(baseDir, filePath, step.allowOutsideCwd);
+      const relativePath = resolveSafeRelativePath(baseDir, filePath);
+      const destination = path.join(artifactPath, relativePath);
+      const relativeToArtifact = path.relative(artifactPath, destination);
+      if (relativeToArtifact.startsWith('..') || path.isAbsolute(relativeToArtifact)) {
+        throw new Error(`Artifact path escape detected for "${relativePath}"`);
+      }
+      fs.mkdirSync(path.dirname(destination), { recursive: true });
+      await fs.promises.copyFile(filePath, destination);
+      files.push(relativePath);
+    }
+
+    return {
+      output: {
+        name: sanitizedName,
+        op: 'upload',
+        artifactPath,
+        files,
+        fileCount: files.length,
+      },
+      status: 'success',
+    };
+  }
+  // download
+  if (!step.path) {
+    throw new Error(`Artifact download requires a destination path for "${rawName}"`);
+  }
+  const dest = ExpressionEvaluator.evaluateString(step.path, context);
+  const destPath = path.isAbsolute(dest) ? dest : path.join(baseDir, dest);
+  assertWithinBaseDir(baseDir, destPath, step.allowOutsideCwd);
+
+  if (!fs.existsSync(artifactPath)) {
+    throw new Error(`Artifact not found for download: ${sanitizedName}`);
+  }
+
+  // ensure dest dir exists
+  const destDir = path.dirname(destPath);
+  if (!fs.existsSync(destDir)) {
+    fs.mkdirSync(destDir, { recursive: true });
+  }
+
+  await fs.promises.cp(artifactPath, destPath, { recursive: true, force: true });
+
+  return {
+    output: { name: sanitizedName, path: destPath, op: 'download', artifactPath },
+    status: 'success',
+  };
+}

package/src/runner/{blueprint-executor.ts → executors/blueprint-executor.ts}

@@ -1,12 +1,13 @@
 import { mkdirSync } from 'node:fs';
 import * as path from 'node:path';
-import type { ExpressionContext } from '../expression/evaluator.ts';
-import type { Blueprint, BlueprintStep, LlmStep, Step } from '../parser/schema.ts';
-import { BlueprintUtils } from '../utils/blueprint-utils.ts';
-import type { Logger } from '../utils/logger.ts';
+import type { ExpressionContext } from '../../expression/evaluator.ts';
+import type { Blueprint, BlueprintStep, LlmStep, Step } from '../../parser/schema.ts';
+import { BlueprintUtils } from '../../utils/blueprint-utils.ts';
+import type { Logger } from '../../utils/logger.ts';
+import type { WorkflowEvent } from '../events.ts';
+import type { MCPManager } from '../mcp-manager.ts';
 import { executeLlmStep } from './llm-executor.ts';
-import type { MCPManager } from './mcp-manager.ts';
-import type { StepResult } from './step-executor.ts';
+import type { StepResult } from './types.ts';
 
 /**
  * Execute a blueprint step
@@ -23,6 +24,8 @@ export async function executeBlueprintStep(
     runId?: string;
     artifactRoot?: string;
     executeLlmStep?: typeof executeLlmStep;
+    emitEvent?: (event: WorkflowEvent) => void;
+    workflowName?: string;
   }
 ): Promise<StepResult> {
   const {
@@ -32,6 +35,8 @@ export async function executeBlueprintStep(
     runId,
     artifactRoot,
     executeLlmStep: injected,
+    emitEvent,
+    workflowName,
   } = options;
   const runLlmStep = injected || executeLlmStep;
 
@@ -123,7 +128,10 @@ export async function executeBlueprintStep(
     logger,
     mcpManager,
     workflowDir,
-    abortSignal
+    abortSignal,
+    undefined,
+    emitEvent,
+    workflowName ? { runId, workflow: workflowName } : undefined
   );
 
   if (llmResult.status !== 'success') {