@davidorex/pi-workflows 0.2.0 → 0.3.1

package/src/step-shared.test.ts

@@ -1,355 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import nunjucks from "nunjucks";
-import {
-  SIGKILL_GRACE_MS,
-  WIDGET_ID,
-  DEFAULT_MAX_ATTEMPTS,
-  zeroUsage,
-  addUsage,
-  resolveSchemaPath,
-  buildPrompt,
-  persistStep,
-  compileAgentSpec,
-} from "./step-shared.ts";
-import type { StepUsage, StepResult, ExecutionState, AgentSpec } from "./types.ts";
-
-describe("constants", () => {
-  it("SIGKILL_GRACE_MS is 3000", () => {
-    assert.strictEqual(SIGKILL_GRACE_MS, 3000);
-  });
-
-  it("WIDGET_ID is 'workflow-progress'", () => {
-    assert.strictEqual(WIDGET_ID, "workflow-progress");
-  });
-
-  it("DEFAULT_MAX_ATTEMPTS is 3", () => {
-    assert.strictEqual(DEFAULT_MAX_ATTEMPTS, 3);
-  });
-});
-
-describe("zeroUsage", () => {
-  it("returns all-zero StepUsage with correct keys", () => {
-    const u = zeroUsage();
-    assert.strictEqual(u.input, 0);
-    assert.strictEqual(u.output, 0);
-    assert.strictEqual(u.cacheRead, 0);
-    assert.strictEqual(u.cacheWrite, 0);
-    assert.strictEqual(u.cost, 0);
-    assert.strictEqual(u.turns, 0);
-    assert.deepStrictEqual(Object.keys(u).sort(), ["cacheRead", "cacheWrite", "cost", "input", "output", "turns"]);
-  });
-
-  it("returns a fresh object each call (no shared reference)", () => {
-    const a = zeroUsage();
-    const b = zeroUsage();
-    assert.notStrictEqual(a, b);
-    a.input = 999;
-    assert.strictEqual(b.input, 0);
-  });
-});
-
-describe("addUsage", () => {
-  it("accumulates all six fields into total", () => {
-    const total = zeroUsage();
-    const step: StepUsage = { input: 10, output: 20, cacheRead: 30, cacheWrite: 40, cost: 0.5, turns: 2 };
-    addUsage(total, step);
-    assert.strictEqual(total.input, 10);
-    assert.strictEqual(total.output, 20);
-    assert.strictEqual(total.cacheRead, 30);
-    assert.strictEqual(total.cacheWrite, 40);
-    assert.strictEqual(total.cost, 0.5);
-    assert.strictEqual(total.turns, 2);
-  });
-
-  it("handles adding zero usage (no change)", () => {
-    const total: StepUsage = { input: 5, output: 10, cacheRead: 15, cacheWrite: 20, cost: 0.1, turns: 1 };
-    addUsage(total, zeroUsage());
-    assert.strictEqual(total.input, 5);
-    assert.strictEqual(total.output, 10);
-    assert.strictEqual(total.cacheRead, 15);
-    assert.strictEqual(total.cacheWrite, 20);
-    assert.strictEqual(total.cost, 0.1);
-    assert.strictEqual(total.turns, 1);
-  });
-
-  it("accumulates across multiple additions", () => {
-    const total = zeroUsage();
-    addUsage(total, { input: 10, output: 5, cacheRead: 0, cacheWrite: 0, cost: 0.1, turns: 1 });
-    addUsage(total, { input: 20, output: 15, cacheRead: 5, cacheWrite: 3, cost: 0.2, turns: 2 });
-    addUsage(total, { input: 30, output: 25, cacheRead: 10, cacheWrite: 7, cost: 0.3, turns: 3 });
-    assert.strictEqual(total.input, 60);
-    assert.strictEqual(total.output, 45);
-    assert.strictEqual(total.cacheRead, 15);
-    assert.strictEqual(total.cacheWrite, 10);
-    assert.strictEqual(total.cost, 0.1 + 0.2 + 0.3);
-    assert.strictEqual(total.turns, 6);
-  });
-});
-
-describe("resolveSchemaPath", () => {
-  it("returns absolute path unchanged", () => {
-    assert.strictEqual(resolveSchemaPath("/abs/path/schema.json", "/some/spec.yaml"), "/abs/path/schema.json");
-  });
-
-  it("resolves relative path against spec file directory", () => {
-    const result = resolveSchemaPath("schema.json", "/project/specs/workflow.yaml");
-    assert.strictEqual(result, path.resolve("/project/specs", "schema.json"));
-  });
-
-  it("handles spec file in nested directory", () => {
-    const result = resolveSchemaPath("schemas/output.json", "/a/b/c/spec.yaml");
-    assert.strictEqual(result, path.resolve("/a/b/c", "schemas/output.json"));
-  });
-
-  it("handles schema path with parent traversal (../schemas/out.json)", () => {
-    const result = resolveSchemaPath("../schemas/out.json", "/project/specs/workflow.yaml");
-    assert.strictEqual(result, path.resolve("/project/specs", "../schemas/out.json"));
-  });
-});
-
-describe("buildPrompt", () => {
-  it("includes task template when agentSpec.taskTemplate is set", () => {
-    const step = { agent: "test" };
-    const agentSpec: AgentSpec = { name: "test", taskTemplate: "Do this task with {{ data }}" };
-    const prompt = buildPrompt(step, agentSpec, {}, "/tmp/run", "step1");
-    assert.ok(prompt.includes("Do this task with {{ data }}"));
-  });
-
-  it("serializes non-empty object input as JSON code block when no task template", () => {
-    const step = { agent: "test" };
-    const agentSpec: AgentSpec = { name: "test" };
-    const prompt = buildPrompt(step, agentSpec, { key: "value" }, "/tmp/run", "step1");
-    assert.ok(prompt.includes("## Input"));
-    assert.ok(prompt.includes("```json"));
-    assert.ok(prompt.includes('"key": "value"'));
-    assert.ok(prompt.includes("```"));
-  });
-
-  it("passes through string input directly when no task template", () => {
-    const step = { agent: "test" };
-    const agentSpec: AgentSpec = { name: "test" };
-    const prompt = buildPrompt(step, agentSpec, "raw string input", "/tmp/run", "step1");
-    assert.ok(prompt.includes("raw string input"));
-    assert.ok(!prompt.includes("## Input"));
-  });
-
-  it("produces empty-ish prompt for empty object input with no task template", () => {
-    const step = { agent: "test" };
-    const agentSpec: AgentSpec = { name: "test" };
-    const prompt = buildPrompt(step, agentSpec, {}, "/tmp/run", "step1");
-    assert.ok(!prompt.includes("## Input"));
-    assert.ok(!prompt.includes("```json"));
-  });
-
-  it("appends output instructions when output.format is json", () => {
-    const step = { agent: "test", output: { format: "json" as const } };
-    const agentSpec: AgentSpec = { name: "test" };
-    const prompt = buildPrompt(step, agentSpec, {}, "/tmp/run", "step1");
-    assert.ok(prompt.includes("**Output:**"));
-    assert.ok(prompt.includes("step1.json"));
-  });
-
-  it("appends output instructions with schema path when output.schema is set", () => {
-    const step = { agent: "test", output: { schema: "schemas/out.json" } };
-    const agentSpec: AgentSpec = { name: "test" };
-    const prompt = buildPrompt(step, agentSpec, {}, "/tmp/run", "step1");
-    assert.ok(prompt.includes("**Output:**"));
-    assert.ok(prompt.includes("JSON Schema"));
-    assert.ok(prompt.includes("schemas/out.json"));
-  });
-
-  it("omits output instructions when no output spec", () => {
-    const step = { agent: "test" };
-    const agentSpec: AgentSpec = { name: "test" };
-    const prompt = buildPrompt(step, agentSpec, {}, "/tmp/run", "step1");
-    assert.ok(!prompt.includes("**Output:**"));
-  });
-
-  it("combines task template with output instructions", () => {
-    const step = { agent: "test", output: { format: "json" as const } };
-    const agentSpec: AgentSpec = { name: "test", taskTemplate: "Analyze this" };
-    const prompt = buildPrompt(step, agentSpec, {}, "/tmp/run", "step1");
-    assert.ok(prompt.includes("Analyze this"));
-    assert.ok(prompt.includes("**Output:**"));
-  });
-});
-
-describe("persistStep", () => {
-  it("writes result into state.steps[stepName]", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-persist-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const result: StepResult = {
-      step: "myStep",
-      agent: "test-agent",
-      status: "completed",
-      usage: zeroUsage(),
-      durationMs: 100,
-    };
-    const widgetState = {
-      spec: { name: "test", description: "", steps: {}, source: "project" as const, filePath: "" },
-      state,
-      startTime: Date.now(),
-    };
-    const ctx = { hasUI: false, ui: { setWidget: () => {}, notify: () => {} } };
-
-    persistStep(state, "myStep", result, tmpDir, widgetState, ctx);
-    assert.strictEqual(state.steps.myStep, result);
-  });
-
-  it("calls writeState (state.json is written to disk)", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-persist-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const result: StepResult = {
-      step: "s1",
-      agent: "agent",
-      status: "completed",
-      usage: zeroUsage(),
-      durationMs: 50,
-    };
-    const widgetState = {
-      spec: { name: "test", description: "", steps: {}, source: "project" as const, filePath: "" },
-      state,
-      startTime: Date.now(),
-    };
-    const ctx = { hasUI: false, ui: { setWidget: () => {}, notify: () => {} } };
-
-    persistStep(state, "s1", result, tmpDir, widgetState, ctx);
-    assert.ok(fs.existsSync(path.join(tmpDir, "state.json")));
-    const written = JSON.parse(fs.readFileSync(path.join(tmpDir, "state.json"), "utf-8"));
-    assert.ok(written.steps.s1);
-    assert.strictEqual(written.steps.s1.status, "completed");
-  });
-
-  it("calls ctx.ui.setWidget when ctx.hasUI is true", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-persist-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const result: StepResult = {
-      step: "s1",
-      agent: "agent",
-      status: "completed",
-      usage: zeroUsage(),
-      durationMs: 50,
-    };
-    const widgetState = {
-      spec: { name: "test", description: "", steps: {}, source: "project" as const, filePath: "" },
-      state,
-      startTime: Date.now(),
-    };
-    let widgetCalled = false;
-    const ctx = {
-      hasUI: true,
-      ui: {
-        setWidget: (id: string, _w: unknown) => {
-          widgetCalled = true;
-          assert.strictEqual(id, WIDGET_ID);
-        },
-        notify: () => {},
-      },
-    };
-
-    persistStep(state, "s1", result, tmpDir, widgetState, ctx);
-    assert.ok(widgetCalled, "setWidget should have been called");
-  });
-
-  it("does not call ctx.ui.setWidget when ctx.hasUI is false", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-persist-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const result: StepResult = {
-      step: "s1",
-      agent: "agent",
-      status: "completed",
-      usage: zeroUsage(),
-      durationMs: 50,
-    };
-    const widgetState = {
-      spec: { name: "test", description: "", steps: {}, source: "project" as const, filePath: "" },
-      state,
-      startTime: Date.now(),
-    };
-    let widgetCalled = false;
-    const ctx = {
-      hasUI: false,
-      ui: {
-        setWidget: () => { widgetCalled = true; },
-        notify: () => {},
-      },
-    };
-
-    persistStep(state, "s1", result, tmpDir, widgetState, ctx);
-    assert.ok(!widgetCalled, "setWidget should not have been called");
-  });
-});
-
-describe("compileAgentSpec", () => {
-  it("returns agentSpec unchanged when no templateEnv", () => {
-    const agentSpec: AgentSpec = { name: "test", systemPrompt: "Hello {{ name }}" };
-    const result = compileAgentSpec(agentSpec, { name: "world" });
-    assert.strictEqual(result, agentSpec);
-    assert.strictEqual(result.systemPrompt, "Hello {{ name }}");
-  });
-
-  it("renders inline systemPrompt through Nunjucks with input context", () => {
-    const env = new nunjucks.Environment(undefined, { autoescape: false, throwOnUndefined: false });
-    const agentSpec: AgentSpec = { name: "test", systemPrompt: "Hello {{ name }}" };
-    const result = compileAgentSpec(agentSpec, { name: "world" }, env);
-    assert.strictEqual(result.systemPrompt, "Hello world");
-  });
-
-  it("renders promptTemplate file path through Nunjucks (replaces with rendered text, clears promptTemplate)", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-compile-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    fs.writeFileSync(path.join(tmpDir, "system.md"), "System for {{ role }}");
-    const env = new nunjucks.Environment(new nunjucks.FileSystemLoader(tmpDir), {
-      autoescape: false,
-      throwOnUndefined: false,
-    });
-
-    const agentSpec: AgentSpec = { name: "test", promptTemplate: "system.md" };
-    const result = compileAgentSpec(agentSpec, { role: "analyzer" }, env);
-    assert.strictEqual(result.systemPrompt, "System for analyzer");
-    assert.strictEqual(result.promptTemplate, undefined);
-  });
-
-  it("renders taskTemplate file path through Nunjucks", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-compile-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    fs.writeFileSync(path.join(tmpDir, "task.md"), "Analyze {{ target }}");
-    const env = new nunjucks.Environment(new nunjucks.FileSystemLoader(tmpDir), {
-      autoescape: false,
-      throwOnUndefined: false,
-    });
-
-    const agentSpec: AgentSpec = { name: "test", taskTemplate: "task.md" };
-    const result = compileAgentSpec(agentSpec, { target: "codebase" }, env);
-    assert.strictEqual(result.taskTemplate, "Analyze codebase");
-  });
-
-  it("handles non-object resolvedInput (uses empty context)", () => {
-    const env = new nunjucks.Environment(undefined, { autoescape: false, throwOnUndefined: false });
-    const agentSpec: AgentSpec = { name: "test", systemPrompt: "Hello {{ name }}" };
-    const result = compileAgentSpec(agentSpec, "string input", env);
-    // {{ name }} renders to "" with throwOnUndefined: false
-    assert.strictEqual(result.systemPrompt, "Hello ");
-  });
-
-  it("handles null resolvedInput", () => {
-    const env = new nunjucks.Environment(undefined, { autoescape: false, throwOnUndefined: false });
-    const agentSpec: AgentSpec = { name: "test", systemPrompt: "Hello {{ name }}" };
-    const result = compileAgentSpec(agentSpec, null, env);
-    assert.strictEqual(result.systemPrompt, "Hello ");
-  });
-});

package/src/step-shared.ts

@@ -1,157 +0,0 @@
-/**
- * Shared helpers for step executors — constants, usage aggregation,
- * prompt building, schema resolution, state persistence, and template resolution.
- */
-import path from "node:path";
-import type { StepUsage, StepResult, ExecutionState, AgentSpec } from "./types.ts";
-import type { ProgressWidgetState } from "./tui.ts";
-import { writeState } from "./state.ts";
-import { createProgressWidget } from "./tui.ts";
-import { renderTemplate, renderTemplateFile } from "./template.ts";
-import type nunjucks from "nunjucks";
-
-/** Grace period (ms) between SIGTERM and SIGKILL when killing subprocesses. */
-export const SIGKILL_GRACE_MS = 3000;
-
-/** Widget ID used for the workflow progress widget. */
-export const WIDGET_ID = "workflow-progress";
-
-/** Default max loop attempts when not specified. */
-export const DEFAULT_MAX_ATTEMPTS = 3;
-
-/**
- * Helper that returns a StepUsage with all zeroes.
- */
-export function zeroUsage(): StepUsage {
-  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
-}
-
-/**
- * Add step usage into a running total (mutates `total`).
- */
-export function addUsage(total: StepUsage, step: StepUsage): void {
-  total.input += step.input;
-  total.output += step.output;
-  total.cacheRead += step.cacheRead;
-  total.cacheWrite += step.cacheWrite;
-  total.cost += step.cost;
-  total.turns += step.turns;
-}
-
-/**
- * Resolve a schema path relative to the workflow spec file.
- * If the schema path is absolute, return as-is.
- * If relative, resolve against the directory containing the workflow spec.
- */
-export function resolveSchemaPath(schemaPath: string, specFilePath: string): string {
-  if (path.isAbsolute(schemaPath)) return schemaPath;
-  return path.resolve(path.dirname(specFilePath), schemaPath);
-}
-
-/**
- * Build the prompt string sent to the subprocess.
- *
- * The prompt includes:
- * 1. The compiled task template (if set), or the resolved input as context
- * 2. Output instructions (if schema-bound)
- */
-export function buildPrompt(
-  step: { agent?: string; input?: Record<string, unknown>; output?: { format?: string; schema?: string } },
-  agentSpec: AgentSpec,
-  resolvedInput: unknown,
-  runDir: string,
-  stepName: string,
-): string {
-  const parts: string[] = [];
-
-  // Task template was compiled by compileAgentSpec — use it
-  if (agentSpec.taskTemplate) {
-    parts.push(agentSpec.taskTemplate);
-  } else if (resolvedInput && typeof resolvedInput === "object" && Object.keys(resolvedInput).length > 0) {
-    // No task template — serialize input as JSON
-    parts.push("## Input\n");
-    parts.push("```json");
-    parts.push(JSON.stringify(resolvedInput, null, 2));
-    parts.push("```\n");
-  } else if (typeof resolvedInput === "string") {
-    parts.push(resolvedInput);
-  }
-
-  // Output instructions (if schema-bound)
-  if (step.output?.format === "json" || step.output?.schema) {
-    const outputPath = path.join(runDir, "outputs", `${stepName}.json`);
-    parts.push("\n---");
-    parts.push(`**Output:** Write your result as valid JSON to: ${outputPath}`);
-    if (step.output.schema) {
-      parts.push(`The output must conform to the JSON Schema at: ${resolveSchemaPath(step.output.schema, "")}`);
-    }
-  }
-
-  return parts.join("\n");
-}
-
-/**
- * Persist step result to state and update TUI widget.
- * Replaces the repeated writeState + setWidget pattern.
- */
-export function persistStep(
-  state: ExecutionState,
-  stepName: string,
-  result: StepResult,
-  runDir: string,
-  widgetState: ProgressWidgetState,
-  ctx: { hasUI: boolean; ui: { setWidget(id: string, w: unknown): void; notify?(msg: string, level: string): void } },
-): void {
-  state.steps[stepName] = result;
-  // Clear activity buffer for completed step
-  widgetState.activities?.delete(stepName);
-  try {
-    writeState(runDir, state);
-  } catch (err) {
-    if (ctx.hasUI && ctx.ui.notify) {
-      const msg = err instanceof Error ? err.message : String(err);
-      ctx.ui.notify(`State write failed after step '${stepName}': ${msg}`, "error");
-    }
-    throw err;  // re-throw — state write failure is fatal
-  }
-  if (ctx.hasUI) {
-    ctx.ui.setWidget(WIDGET_ID, createProgressWidget(widgetState));
-  }
-}
-
-/**
- * Compile an agent spec: render system and task templates through Nunjucks.
- *
- * Every agent's prompts go through Nunjucks. Plain text without template
- * tags renders to itself. The .md that pi receives is compiled output.
- */
-export function compileAgentSpec(
-  agentSpec: AgentSpec,
-  resolvedInput: unknown,
-  templateEnv?: nunjucks.Environment,
-): AgentSpec {
-  if (!templateEnv) return agentSpec;
-
-  const ctx = typeof resolvedInput === "object" && resolvedInput !== null
-    ? resolvedInput as Record<string, unknown>
-    : {};
-
-  let result = agentSpec;
-
-  // System prompt: file template or inline — always rendered
-  if (agentSpec.promptTemplate) {
-    const rendered = renderTemplateFile(templateEnv, agentSpec.promptTemplate, ctx);
-    result = { ...result, systemPrompt: rendered, promptTemplate: undefined };
-  } else if (agentSpec.systemPrompt) {
-    const rendered = renderTemplate(templateEnv, agentSpec.systemPrompt, ctx);
-    result = { ...result, systemPrompt: rendered };
-  }
-
-  // Task prompt: file template — rendered from typed input
-  if (agentSpec.taskTemplate) {
-    const rendered = renderTemplateFile(templateEnv, agentSpec.taskTemplate, ctx);
-    result = { ...result, taskTemplate: rendered };
-  }
-
-  return result;
-}

package/src/step-transform.test.ts

@@ -1,155 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import { executeTransform } from "./step-transform.ts";
-import { zeroUsage } from "./step-shared.ts";
-
-describe("executeTransform", () => {
-  // Happy path
-  it("resolves simple mapping to output object", () => {
-    const result = executeTransform({ mapping: { greeting: "hello" } }, "step1", {});
-    assert.strictEqual(result.status, "completed");
-    assert.deepStrictEqual(result.output, { greeting: "hello" });
-  });
-
-  it("resolves ${{ }} expressions in mapping values", () => {
-    const result = executeTransform(
-      { mapping: { name: "${{ input.name }}" } },
-      "step1",
-      { input: { name: "Alice" } },
-    );
-    assert.strictEqual(result.status, "completed");
-    assert.strictEqual((result.output as any).name, "Alice");
-  });
-
-  it("resolves nested expressions", () => {
-    const result = executeTransform(
-      { mapping: { val: "${{ steps.x.output.field }}" } },
-      "step1",
-      {
-        input: {},
-        steps: {
-          x: {
-            step: "x",
-            agent: "test",
-            status: "completed",
-            output: { field: "deep-value" },
-            usage: zeroUsage(),
-            durationMs: 0,
-          },
-        },
-      },
-    );
-    assert.strictEqual(result.status, "completed");
-    assert.strictEqual((result.output as any).val, "deep-value");
-  });
-
-  it("preserves non-expression values (numbers, booleans, null)", () => {
-    const result = executeTransform(
-      { mapping: { count: 42, flag: true, empty: null } },
-      "step1",
-      {},
-    );
-    assert.strictEqual(result.status, "completed");
-    const output = result.output as any;
-    assert.strictEqual(output.count, 42);
-    assert.strictEqual(output.flag, true);
-    assert.strictEqual(output.empty, null);
-  });
-
-  it("sets agent to 'transform'", () => {
-    const result = executeTransform({ mapping: {} }, "step1", {});
-    assert.strictEqual(result.agent, "transform");
-  });
-
-  it("sets step name correctly", () => {
-    const result = executeTransform({ mapping: {} }, "my-transform", {});
-    assert.strictEqual(result.step, "my-transform");
-  });
-
-  it("has zero usage", () => {
-    const result = executeTransform({ mapping: {} }, "step1", {});
-    assert.deepStrictEqual(result.usage, zeroUsage());
-  });
-
-  it("has non-negative durationMs", () => {
-    const result = executeTransform({ mapping: {} }, "step1", {});
-    assert.ok(result.durationMs >= 0);
-  });
-
-  it("includes textOutput as JSON-stringified output", () => {
-    const result = executeTransform({ mapping: { a: 1 } }, "step1", {});
-    assert.strictEqual(result.textOutput, JSON.stringify({ a: 1 }, null, 2));
-  });
-
-  // Output persistence
-  it("persists output to runDir when runDir is provided", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-transform-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    const result = executeTransform({ mapping: { x: 1 } }, "step1", {}, tmpDir);
-    assert.ok(result.outputPath);
-    assert.ok(fs.existsSync(result.outputPath!));
-    const persisted = JSON.parse(fs.readFileSync(result.outputPath!, "utf-8"));
-    assert.deepStrictEqual(persisted, { x: 1 });
-  });
-
-  it("persists output to outputPath when provided", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-transform-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    const customPath = path.join(tmpDir, "custom-out.json");
-    const result = executeTransform({ mapping: { y: 2 } }, "step1", {}, tmpDir, customPath);
-    assert.strictEqual(result.outputPath, customPath);
-    assert.ok(fs.existsSync(customPath));
-  });
-
-  it("does not persist when runDir is omitted", () => {
-    const result = executeTransform({ mapping: { z: 3 } }, "step1", {});
-    assert.strictEqual(result.outputPath, undefined);
-  });
-
-  // Error paths
-  it("returns failed status when expression resolution throws", () => {
-    const result = executeTransform(
-      { mapping: { bad: "${{ steps.nonexistent.output }}" } },
-      "step1",
-      { input: {}, steps: {} },
-    );
-    assert.strictEqual(result.status, "failed");
-    assert.ok(result.error);
-    assert.ok(result.error!.length > 0);
-  });
-
-  it("returns failed status with error message string", () => {
-    const result = executeTransform(
-      { mapping: { bad: "${{ steps.nonexistent.output }}" } },
-      "step1",
-      { input: {}, steps: {} },
-    );
-    assert.strictEqual(result.status, "failed");
-    assert.strictEqual(typeof result.error, "string");
-    assert.ok(result.error!.includes("nonexistent"));
-  });
-
-  // Edge cases
-  it("handles empty mapping object", () => {
-    const result = executeTransform({ mapping: {} }, "step1", {});
-    assert.strictEqual(result.status, "completed");
-    assert.deepStrictEqual(result.output, {});
-  });
-
-  it("handles mapping with mixed expressions and literals", () => {
-    const result = executeTransform(
-      { mapping: { resolved: "${{ input.x }}", literal: "plain" } },
-      "step1",
-      { input: { x: 42 } },
-    );
-    assert.strictEqual(result.status, "completed");
-    const output = result.output as any;
-    assert.strictEqual(output.resolved, 42);
-    assert.strictEqual(output.literal, "plain");
-  });
-});