@davidorex/pi-workflows 0.2.0 → 0.3.1

package/src/step-parallel.test.ts

@@ -1,475 +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 { executeParallelLayer, executeParallelStep } from "./step-parallel.ts";
-import type { ParallelOptions, SingleStepExecutor } from "./step-parallel.ts";
-import type { ExecutionLayer } from "./dag.ts";
-import { zeroUsage, WIDGET_ID } from "./step-shared.ts";
-import type { StepSpec, StepResult, ExecutionState, WorkflowSpec } from "./types.ts";
-import { mockCtx, mockPi, makeSpec } from "./test-helpers.ts";
-
-function makeTmpDir(t: any): string {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-parallel-"));
-  fs.mkdirSync(path.join(tmpDir, "outputs"), { recursive: true });
-  fs.mkdirSync(path.join(tmpDir, "sessions"), { recursive: true });
-  t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-  return tmpDir;
-}
-
-function makeParallelOptions(tmpDir: string, overrides?: Partial<ParallelOptions>): ParallelOptions {
-  return {
-    ctx: mockCtx(tmpDir),
-    pi: mockPi(),
-    loadAgent: () => ({ name: "default" }),
-    runDir: tmpDir,
-    spec: makeSpec({
-      steps: {
-        a: { agent: "test" },
-        b: { agent: "test" },
-        c: { agent: "test" },
-      },
-    }),
-    widgetState: {
-      spec: makeSpec({ steps: { a: { agent: "test" }, b: { agent: "test" }, c: { agent: "test" } } }),
-      state: { input: {}, steps: {}, status: "running" },
-      startTime: Date.now(),
-    },
-    ...overrides,
-  };
-}
-
-/**
- * Mock executor factory: controls behavior per step name.
- */
-function mockExecutor(
-  behavior: Record<string, { success: boolean; output?: unknown; delayMs?: number; usage?: any }> = {},
-): SingleStepExecutor {
-  return async (stepName, stepSpec, state, options) => {
-    const b = behavior[stepName] ?? { success: true };
-    if (b.delayMs) await new Promise((r) => setTimeout(r, b.delayMs));
-    // Check abort signal to simulate cancellation
-    if (options.signal?.aborted) {
-      state.steps[stepName] = {
-        step: stepName,
-        agent: stepSpec.agent ?? "mock",
-        status: "failed",
-        output: undefined,
-        usage: zeroUsage(),
-        durationMs: 0,
-        error: "aborted",
-      };
-      return false;
-    }
-    state.steps[stepName] = {
-      step: stepName,
-      agent: stepSpec.agent ?? "mock",
-      status: b.success ? "completed" : "failed",
-      output: b.output ?? { mock: true },
-      usage: b.usage ?? zeroUsage(),
-      durationMs: b.delayMs ?? 0,
-      error: b.success ? undefined : "mock failure",
-    };
-    return b.success;
-  };
-}
-
-describe("executeParallelLayer", () => {
-  it("executes all steps in the layer", async (t) => {
-    const tmpDir = makeTmpDir(t);
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const spec = makeSpec({
-      steps: {
-        a: { agent: "test" },
-        b: { agent: "test" },
-        c: { agent: "test" },
-      },
-    });
-    const layer: ExecutionLayer = { steps: ["a", "b", "c"] };
-    const options = makeParallelOptions(tmpDir, { spec });
-
-    await executeParallelLayer(layer, spec, state, mockExecutor({
-      a: { success: true },
-      b: { success: true },
-      c: { success: true },
-    }), options);
-
-    assert.ok(state.steps.a);
-    assert.ok(state.steps.b);
-    assert.ok(state.steps.c);
-    assert.strictEqual(state.steps.a.status, "completed");
-    assert.strictEqual(state.steps.b.status, "completed");
-    assert.strictEqual(state.steps.c.status, "completed");
-  });
-
-  it("sets state.status to failed when any step fails", async (t) => {
-    const tmpDir = makeTmpDir(t);
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const spec = makeSpec({
-      steps: {
-        a: { agent: "test" },
-        b: { agent: "test" },
-      },
-    });
-    const layer: ExecutionLayer = { steps: ["a", "b"] };
-    const options = makeParallelOptions(tmpDir, { spec });
-
-    await executeParallelLayer(layer, spec, state, mockExecutor({
-      a: { success: true },
-      b: { success: false },
-    }), options);
-
-    assert.strictEqual(state.status, "failed");
-  });
-
-  it("cancels remaining steps when one fails (abort signal)", async (t) => {
-    const tmpDir = makeTmpDir(t);
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const spec = makeSpec({
-      steps: {
-        slow: { agent: "test" },
-        fast_fail: { agent: "test" },
-      },
-    });
-    const layer: ExecutionLayer = { steps: ["slow", "fast_fail"] };
-    const options = makeParallelOptions(tmpDir, { spec });
-
-    await executeParallelLayer(layer, spec, state, mockExecutor({
-      slow: { success: true, delayMs: 200 },
-      fast_fail: { success: false, delayMs: 10 },
-    }), options);
-
-    assert.strictEqual(state.status, "failed");
-    // The slow step may have been aborted — it should still have a result
-    assert.ok(state.steps.fast_fail);
-    assert.strictEqual(state.steps.fast_fail.status, "failed");
-  });
-
-  it("respects pre-aborted parent signal", async (t) => {
-    const tmpDir = makeTmpDir(t);
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const spec = makeSpec({
-      steps: { a: { agent: "test" } },
-    });
-    const layer: ExecutionLayer = { steps: ["a"] };
-    const controller = new AbortController();
-    controller.abort();
-    const options = makeParallelOptions(tmpDir, { spec, signal: controller.signal });
-
-    await executeParallelLayer(layer, spec, state, mockExecutor({
-      a: { success: true },
-    }), options);
-
-    // Step should see aborted signal
-    if (state.steps.a) {
-      // If it ran at all, it should have seen the abort
-      assert.ok(true);
-    }
-  });
-
-  it("updates widgetState.currentStep with all layer step names", async (t) => {
-    const tmpDir = makeTmpDir(t);
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const spec = makeSpec({
-      steps: { x: { agent: "test" }, y: { agent: "test" } },
-    });
-    const layer: ExecutionLayer = { steps: ["x", "y"] };
-    const widgetState = {
-      spec,
-      state,
-      startTime: Date.now(),
-      currentStep: undefined as string | undefined,
-    };
-    const options = makeParallelOptions(tmpDir, { spec, widgetState });
-
-    await executeParallelLayer(layer, spec, state, mockExecutor({
-      x: { success: true },
-      y: { success: true },
-    }), options);
-
-    assert.strictEqual(widgetState.currentStep, "x, y");
-  });
-
-  it("handles single-step layer (degenerate case)", async (t) => {
-    const tmpDir = makeTmpDir(t);
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const spec = makeSpec({ steps: { only: { agent: "test" } } });
-    const layer: ExecutionLayer = { steps: ["only"] };
-    const options = makeParallelOptions(tmpDir, { spec });
-
-    await executeParallelLayer(layer, spec, state, mockExecutor({
-      only: { success: true },
-    }), options);
-
-    assert.ok(state.steps.only);
-    assert.strictEqual(state.steps.only.status, "completed");
-  });
-
-  it("handles empty layer (no steps)", async (t) => {
-    const tmpDir = makeTmpDir(t);
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const spec = makeSpec({ steps: {} });
-    const layer: ExecutionLayer = { steps: [] };
-    const options = makeParallelOptions(tmpDir, { spec });
-
-    await executeParallelLayer(layer, spec, state, mockExecutor(), options);
-
-    // No errors, no state changes
-    assert.strictEqual(Object.keys(state.steps).length, 0);
-  });
-
-  it("does not set state.status on all-success", async (t) => {
-    const tmpDir = makeTmpDir(t);
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const spec = makeSpec({
-      steps: { a: { agent: "test" }, b: { agent: "test" } },
-    });
-    const layer: ExecutionLayer = { steps: ["a", "b"] };
-    const options = makeParallelOptions(tmpDir, { spec });
-
-    await executeParallelLayer(layer, spec, state, mockExecutor({
-      a: { success: true },
-      b: { success: true },
-    }), options);
-
-    // Status should remain "running" — setting to "completed" is the executor's job
-    assert.strictEqual(state.status, "running");
-  });
-
-  it("collects results via Promise.allSettled (no unhandled rejections)", async (t) => {
-    const tmpDir = makeTmpDir(t);
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const spec = makeSpec({
-      steps: { a: { agent: "test" }, b: { agent: "test" } },
-    });
-    const layer: ExecutionLayer = { steps: ["a", "b"] };
-    const options = makeParallelOptions(tmpDir, { spec });
-
-    // Mock executor that throws an exception for step "b"
-    const executor: SingleStepExecutor = async (stepName, stepSpec, execState, opts) => {
-      if (stepName === "b") throw new Error("unexpected crash");
-      execState.steps[stepName] = {
-        step: stepName,
-        agent: "mock",
-        status: "completed",
-        output: {},
-        usage: zeroUsage(),
-        durationMs: 0,
-      };
-      return true;
-    };
-
-    await executeParallelLayer(layer, spec, state, executor, options);
-
-    assert.strictEqual(state.status, "failed");
-  });
-});
-
-describe("executeParallelStep", () => {
-  it("returns completed result with aggregated sub-outputs", async (t) => {
-    const tmpDir = makeTmpDir(t);
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const parallelSpec: Record<string, StepSpec> = {
-      sub1: { agent: "test" },
-      sub2: { agent: "test" },
-    };
-    const options = makeParallelOptions(tmpDir);
-
-    const result = await executeParallelStep(parallelSpec, "parallel1", state, mockExecutor({
-      sub1: { success: true, output: { data: "from-sub1" } },
-      sub2: { success: true, output: { data: "from-sub2" } },
-    }), options);
-
-    assert.strictEqual(result.status, "completed");
-    const output = result.output as any;
-    assert.ok(output.sub1);
-    assert.ok(output.sub2);
-    assert.deepStrictEqual(output.sub1, { data: "from-sub1" });
-    assert.deepStrictEqual(output.sub2, { data: "from-sub2" });
-  });
-
-  it("returns failed result when any sub-step fails", async (t) => {
-    const tmpDir = makeTmpDir(t);
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const parallelSpec: Record<string, StepSpec> = {
-      sub1: { agent: "test" },
-      sub2: { agent: "test" },
-    };
-    const options = makeParallelOptions(tmpDir);
-
-    const result = await executeParallelStep(parallelSpec, "parallel1", state, mockExecutor({
-      sub1: { success: true },
-      sub2: { success: false },
-    }), options);
-
-    assert.strictEqual(result.status, "failed");
-  });
-
-  it("aggregates usage across sub-steps", async (t) => {
-    const tmpDir = makeTmpDir(t);
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const parallelSpec: Record<string, StepSpec> = {
-      sub1: { agent: "test" },
-      sub2: { agent: "test" },
-    };
-    const options = makeParallelOptions(tmpDir);
-
-    const result = await executeParallelStep(parallelSpec, "parallel1", state, mockExecutor({
-      sub1: { success: true, usage: { input: 100, output: 50, cacheRead: 0, cacheWrite: 0, cost: 0.01, turns: 1 } },
-      sub2: { success: true, usage: { input: 200, output: 100, cacheRead: 10, cacheWrite: 5, cost: 0.02, turns: 2 } },
-    }), options);
-
-    assert.strictEqual(result.usage.input, 300);
-    assert.strictEqual(result.usage.output, 150);
-    assert.strictEqual(result.usage.cacheRead, 10);
-    assert.strictEqual(result.usage.cacheWrite, 5);
-    assert.strictEqual(result.usage.cost, 0.03);
-    assert.strictEqual(result.usage.turns, 3);
-  });
-
-  it("cancels remaining sub-steps when one fails", async (t) => {
-    const tmpDir = makeTmpDir(t);
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const parallelSpec: Record<string, StepSpec> = {
-      slow: { agent: "test" },
-      fast_fail: { agent: "test" },
-    };
-    const options = makeParallelOptions(tmpDir);
-
-    const result = await executeParallelStep(parallelSpec, "parallel1", state, mockExecutor({
-      slow: { success: true, delayMs: 200 },
-      fast_fail: { success: false, delayMs: 10 },
-    }), options);
-
-    assert.strictEqual(result.status, "failed");
-  });
-
-  it("respects pre-aborted signal", async (t) => {
-    const tmpDir = makeTmpDir(t);
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const parallelSpec: Record<string, StepSpec> = { sub1: { agent: "test" } };
-    const controller = new AbortController();
-    controller.abort();
-    const options = makeParallelOptions(tmpDir, { signal: controller.signal });
-
-    const result = await executeParallelStep(parallelSpec, "parallel1", state, mockExecutor({
-      sub1: { success: true },
-    }), options);
-
-    // Should complete without hanging — the abort is propagated to sub-steps
-    assert.ok(result);
-  });
-
-  it("sets agent to 'parallel'", async (t) => {
-    const tmpDir = makeTmpDir(t);
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const parallelSpec: Record<string, StepSpec> = { sub1: { agent: "test" } };
-    const options = makeParallelOptions(tmpDir);
-
-    const result = await executeParallelStep(parallelSpec, "parallel1", state, mockExecutor({
-      sub1: { success: true },
-    }), options);
-
-    assert.strictEqual(result.agent, "parallel");
-  });
-
-  it("sets step name correctly", async (t) => {
-    const tmpDir = makeTmpDir(t);
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const parallelSpec: Record<string, StepSpec> = { sub1: { agent: "test" } };
-    const options = makeParallelOptions(tmpDir);
-
-    const result = await executeParallelStep(parallelSpec, "my-parallel", state, mockExecutor({
-      sub1: { success: true },
-    }), options);
-
-    assert.strictEqual(result.step, "my-parallel");
-  });
-
-  it("includes textOutput as JSON stringified sub-outputs", async (t) => {
-    const tmpDir = makeTmpDir(t);
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const parallelSpec: Record<string, StepSpec> = { sub1: { agent: "test" } };
-    const options = makeParallelOptions(tmpDir);
-
-    const result = await executeParallelStep(parallelSpec, "parallel1", state, mockExecutor({
-      sub1: { success: true, output: { val: 1 } },
-    }), options);
-
-    assert.ok(result.textOutput);
-    const parsed = JSON.parse(result.textOutput!);
-    assert.deepStrictEqual(parsed.sub1, { val: 1 });
-  });
-
-  it("records positive durationMs", async (t) => {
-    const tmpDir = makeTmpDir(t);
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const parallelSpec: Record<string, StepSpec> = { sub1: { agent: "test" } };
-    const options = makeParallelOptions(tmpDir);
-
-    const result = await executeParallelStep(parallelSpec, "parallel1", state, mockExecutor({
-      sub1: { success: true },
-    }), options);
-
-    assert.ok(result.durationMs >= 0);
-  });
-
-  it("handles single sub-step", async (t) => {
-    const tmpDir = makeTmpDir(t);
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const parallelSpec: Record<string, StepSpec> = { only: { agent: "test" } };
-    const options = makeParallelOptions(tmpDir);
-
-    const result = await executeParallelStep(parallelSpec, "parallel1", state, mockExecutor({
-      only: { success: true, output: { single: true } },
-    }), options);
-
-    assert.strictEqual(result.status, "completed");
-    assert.deepStrictEqual((result.output as any).only, { single: true });
-  });
-
-  it("handles all sub-steps failing", async (t) => {
-    const tmpDir = makeTmpDir(t);
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const parallelSpec: Record<string, StepSpec> = {
-      sub1: { agent: "test" },
-      sub2: { agent: "test" },
-    };
-    const options = makeParallelOptions(tmpDir);
-
-    const result = await executeParallelStep(parallelSpec, "parallel1", state, mockExecutor({
-      sub1: { success: false },
-      sub2: { success: false },
-    }), options);
-
-    assert.strictEqual(result.status, "failed");
-  });
-
-  it("handles rejected promise from executor (exception, not false return)", async (t) => {
-    const tmpDir = makeTmpDir(t);
-    const state: ExecutionState = { input: {}, steps: {}, status: "running" };
-    const parallelSpec: Record<string, StepSpec> = {
-      sub1: { agent: "test" },
-      sub2: { agent: "test" },
-    };
-    const options = makeParallelOptions(tmpDir);
-
-    const executor: SingleStepExecutor = async (stepName, stepSpec, execState, opts) => {
-      if (stepName === "sub2") throw new Error("boom");
-      execState.steps[stepName] = {
-        step: stepName,
-        agent: "mock",
-        status: "completed",
-        output: {},
-        usage: zeroUsage(),
-        durationMs: 0,
-      };
-      return true;
-    };
-
-    const result = await executeParallelStep(parallelSpec, "parallel1", state, executor, options);
-
-    assert.strictEqual(result.status, "failed");
-  });
-});

package/src/step-parallel.ts

@@ -1,168 +0,0 @@
-/**
- * Parallel step executors — concurrent step execution within a layer
- * or within a single parallel step declaration.
- */
-import type { StepResult, StepSpec, ExecutionState, WorkflowSpec } from "./types.ts";
-import type { ProgressWidgetState } from "./tui.ts";
-import type { ExecutionLayer } from "./dag.ts";
-import { createProgressWidget } from "./tui.ts";
-import type nunjucks from "nunjucks";
-import { zeroUsage, addUsage, WIDGET_ID } from "./step-shared.ts";
-
-/** Options shared by parallel execution helpers. */
-export interface ParallelOptions {
-  ctx: any;
-  pi: any;
-  signal?: AbortSignal;
-  loadAgent: (name: string) => any;
-  runDir: string;
-  spec: WorkflowSpec;
-  widgetState: ProgressWidgetState;
-  templateEnv?: nunjucks.Environment;
-}
-
-/** Callback type for executing a single step — injected to avoid circular imports. */
-export type SingleStepExecutor = (
-  stepName: string,
-  stepSpec: StepSpec,
-  state: ExecutionState,
-  options: ParallelOptions,
-) => Promise<boolean>;
-
-/**
- * Execute all steps in a layer concurrently.
- *
- * All steps start at the same time. If any step fails, remaining steps
- * are cancelled via a shared AbortController. All results are collected
- * before proceeding to the next layer.
- *
- * Parallel steps write to distinct keys in `state.steps`, which is safe
- * in single-threaded Node.js. `writeState` uses atomic write (tmp + rename),
- * so concurrent calls are safe — last one wins.
- */
-export async function executeParallelLayer(
-  layer: ExecutionLayer,
-  spec: WorkflowSpec,
-  state: ExecutionState,
-  executeSingleStep: SingleStepExecutor,
-  options: ParallelOptions,
-): Promise<void> {
-  const { ctx, signal, widgetState } = options;
-
-  // Create a child AbortController to cancel siblings on failure
-  const layerController = new AbortController();
-  if (signal) {
-    if (signal.aborted) {
-      layerController.abort(signal.reason);
-    } else {
-      signal.addEventListener("abort", () => layerController.abort(signal.reason), { once: true });
-    }
-  }
-
-  // Update widget to show all parallel steps as running
-  widgetState.currentStep = layer.steps.join(", ");
-  if (ctx.hasUI) {
-    ctx.ui.setWidget(WIDGET_ID, createProgressWidget(widgetState));
-  }
-
-  // Launch all steps concurrently
-  const promises = layer.steps.map(async (stepName) => {
-    const stepSpec = spec.steps[stepName];
-    const success = await executeSingleStep(stepName, stepSpec, state, {
-      ...options,
-      signal: layerController.signal,
-    });
-    if (!success && !layerController.signal.aborted) {
-      layerController.abort(new Error(`Step '${stepName}' failed`));
-    }
-    return { stepName, success };
-  });
-
-  const results = await Promise.allSettled(promises);
-
-  // Check for failures
-  for (const result of results) {
-    if (result.status === "rejected") {
-      state.status = "failed";
-      break;
-    }
-    if (result.status === "fulfilled" && !result.value.success) {
-      state.status = "failed";
-      break;
-    }
-  }
-}
-
-/**
- * Execute a parallel step — runs all named sub-steps concurrently.
- *
- * Similar to executeParallelLayer but operates on sub-steps within
- * a single declared step. The parallel step's result aggregates
- * all sub-step results. Sub-step outputs are accessible via
- * `${{ steps.<parallelStepName>.output.<subStepName> }}`.
- */
-export async function executeParallelStep(
-  parallelSpec: Record<string, StepSpec>,
-  stepName: string,
-  state: ExecutionState,
-  executeSingleStep: SingleStepExecutor,
-  options: ParallelOptions,
-): Promise<StepResult> {
-  const startTime = Date.now();
-  const { signal } = options;
-
-  const parallelController = new AbortController();
-  if (signal) {
-    if (signal.aborted) {
-      parallelController.abort(signal.reason);
-    } else {
-      signal.addEventListener("abort", () => parallelController.abort(signal.reason), { once: true });
-    }
-  }
-
-  // Sub-steps share the outer state for reading but write to their own keys
-  const subResults: Record<string, StepResult> = {};
-
-  const subPromises = Object.entries(parallelSpec).map(async ([subName, subSpec]) => {
-    const success = await executeSingleStep(subName, subSpec, state, {
-      ...options,
-      signal: parallelController.signal,
-    });
-    subResults[subName] = state.steps[subName];
-    if (!success && !parallelController.signal.aborted) {
-      parallelController.abort(new Error(`Sub-step '${subName}' failed`));
-    }
-    return success;
-  });
-
-  const settled = await Promise.allSettled(subPromises);
-
-  // Aggregate usage and outputs
-  const totalUsage = zeroUsage();
-  const subOutputs: Record<string, unknown> = {};
-  let anyFailed = false;
-
-  for (const [subName] of Object.entries(parallelSpec)) {
-    const sub = subResults[subName];
-    if (sub) {
-      addUsage(totalUsage, sub.usage);
-      subOutputs[subName] = sub.output ?? sub.textOutput;
-      if (sub.status === "failed") anyFailed = true;
-    }
-  }
-
-  // Check for rejected promises too
-  for (const s of settled) {
-    if (s.status === "rejected") anyFailed = true;
-  }
-
-  return {
-    step: stepName,
-    agent: "parallel",
-    status: anyFailed ? "failed" : "completed",
-    output: subOutputs,
-    textOutput: JSON.stringify(subOutputs, null, 2),
-    usage: totalUsage,
-    durationMs: Date.now() - startTime,
-  };
-}

package/src/step-pause.test.ts

@@ -1,30 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { executePause } from "./step-pause.ts";
-
-describe("executePause", () => {
-  it("returns completed result with message", () => {
-    const result = executePause("review-point", "Review exploration results");
-    assert.strictEqual(result.status, "completed");
-    assert.strictEqual(result.step, "review-point");
-    assert.strictEqual(result.agent, "pause");
-    assert.strictEqual(result.textOutput, "Review exploration results");
-    assert.deepStrictEqual(result.output, { message: "Review exploration results" });
-    assert.strictEqual(result.durationMs, 0);
-  });
-
-  it("returns completed result without message (boolean true)", () => {
-    const result = executePause("checkpoint");
-    assert.strictEqual(result.status, "completed");
-    assert.strictEqual(result.textOutput, "Workflow paused");
-    assert.strictEqual(result.output, undefined);
-  });
-
-  it("has zero usage", () => {
-    const result = executePause("p");
-    assert.strictEqual(result.usage.cost, 0);
-    assert.strictEqual(result.usage.turns, 0);
-    assert.strictEqual(result.usage.input, 0);
-    assert.strictEqual(result.usage.output, 0);
-  });
-});