@davidorex/pi-workflows 0.2.0 → 0.3.1

package/src/output.test.ts

@@ -1,213 +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 { persistStepOutput } from "./output.ts";
-
-describe("persistStepOutput", () => {
-  it("writes structured output as JSON", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-output-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-    fs.mkdirSync(path.join(tmpDir, "outputs"), { recursive: true });
-
-    const result = persistStepOutput(tmpDir, "analyze", { findings: ["a", "b"] });
-    assert.ok(result);
-    assert.ok(result.endsWith("analyze.json"));
-    const content = JSON.parse(fs.readFileSync(result, "utf-8"));
-    assert.deepStrictEqual(content, { findings: ["a", "b"] });
-  });
-
-  it("wraps string output as JSON", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-output-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-    fs.mkdirSync(path.join(tmpDir, "outputs"), { recursive: true });
-
-    const result = persistStepOutput(tmpDir, "explore", undefined, "Found patterns");
-    assert.ok(result);
-    assert.ok(result.endsWith("explore.json"));
-    const content = JSON.parse(fs.readFileSync(result, "utf-8"));
-    assert.deepStrictEqual(content, { text: "Found patterns" });
-  });
-
-  it("prefers structured output over textOutput", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-output-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-    fs.mkdirSync(path.join(tmpDir, "outputs"), { recursive: true });
-
-    const result = persistStepOutput(tmpDir, "step1", { key: "val" }, "text fallback");
-    assert.ok(result);
-    const content = JSON.parse(fs.readFileSync(result, "utf-8"));
-    assert.deepStrictEqual(content, { key: "val" });
-  });
-
-  it("wraps string output field as JSON", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-output-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-    fs.mkdirSync(path.join(tmpDir, "outputs"), { recursive: true });
-
-    const result = persistStepOutput(tmpDir, "step1", "plain string");
-    assert.ok(result);
-    assert.ok(result.endsWith(".json"));
-    const content = JSON.parse(fs.readFileSync(result, "utf-8"));
-    assert.deepStrictEqual(content, { text: "plain string" });
-  });
-
-  it("returns undefined when nothing to write", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-output-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-    fs.mkdirSync(path.join(tmpDir, "outputs"), { recursive: true });
-    assert.strictEqual(persistStepOutput(tmpDir, "empty", undefined, undefined), undefined);
-  });
-
-  it("returns undefined for empty string", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-output-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-    fs.mkdirSync(path.join(tmpDir, "outputs"), { recursive: true });
-    assert.strictEqual(persistStepOutput(tmpDir, "empty", undefined, ""), undefined);
-  });
-
-  it("writes array output as JSON", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-output-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-    fs.mkdirSync(path.join(tmpDir, "outputs"), { recursive: true });
-
-    const result = persistStepOutput(tmpDir, "items", ["a", "b", "c"]);
-    assert.ok(result);
-    assert.ok(result.endsWith(".json"));
-    assert.deepStrictEqual(JSON.parse(fs.readFileSync(result, "utf-8")), ["a", "b", "c"]);
-  });
-
-  it("all outputs are JSON regardless of input type", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-output-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-    fs.mkdirSync(path.join(tmpDir, "outputs"), { recursive: true });
-
-    const r1 = persistStepOutput(tmpDir, "s1", { a: 1 });
-    const r2 = persistStepOutput(tmpDir, "s2", "hello");
-    const r3 = persistStepOutput(tmpDir, "s3", undefined, "world");
-    assert.ok(r1!.endsWith(".json"));
-    assert.ok(r2!.endsWith(".json"));
-    assert.ok(r3!.endsWith(".json"));
-  });
-
-  it("creates outputs directory if missing", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-output-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-    // Don't create outputs/ — persistStepOutput should handle it
-
-    const result = persistStepOutput(tmpDir, "auto", { data: true });
-    assert.ok(result);
-    assert.ok(fs.existsSync(result));
-    assert.deepStrictEqual(JSON.parse(fs.readFileSync(result, "utf-8")), { data: true });
-  });
-
-  it("writes to author-declared output path", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-output-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    const customPath = path.join(tmpDir, "reports", "analysis", "structure.json");
-    const result = persistStepOutput(tmpDir, "step1", { key: "val" }, undefined, customPath);
-    assert.strictEqual(result, customPath);
-    assert.ok(fs.existsSync(customPath));
-    assert.deepStrictEqual(JSON.parse(fs.readFileSync(customPath, "utf-8")), { key: "val" });
-  });
-
-  it("creates parent directories for author-declared path", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-output-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    const deepPath = path.join(tmpDir, "a", "b", "c", "result.json");
-    const result = persistStepOutput(tmpDir, "step1", ["x"], undefined, deepPath);
-    assert.strictEqual(result, deepPath);
-    assert.deepStrictEqual(JSON.parse(fs.readFileSync(deepPath, "utf-8")), ["x"]);
-  });
-
-  it("defaults to run dir when no output path declared", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-output-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    const result = persistStepOutput(tmpDir, "my-step", { a: 1 });
-    assert.ok(result);
-    assert.strictEqual(result, path.join(tmpDir, "outputs", "my-step.json"));
-  });
-});
-
-describe("persistStepOutput error handling", () => {
-  it("returns undefined when directory creation fails", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-output-err-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    // Create a file where the outputs directory should be — mkdirSync will fail with ENOTDIR
-    const blocker = path.join(tmpDir, "outputs");
-    fs.writeFileSync(blocker, "not a directory");
-
-    const result = persistStepOutput(tmpDir, "step1", { data: true });
-    assert.strictEqual(result, undefined);
-  });
-
-  it("returns undefined when write to author-declared path fails", (t) => {
-    // Use /dev/null/impossible on unix — a known-bad path
-    const result = persistStepOutput(
-      "/tmp", "step1", { data: true }, undefined,
-      "/dev/null/impossible/path/output.json",
-    );
-    assert.strictEqual(result, undefined);
-  });
-
-  it("returns undefined when file write fails due to unwritable directory", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-output-err-"));
-    t.after(() => {
-      // Restore permissions for cleanup
-      try { fs.chmodSync(path.join(tmpDir, "outputs"), 0o755); } catch { /* ignore */ }
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    });
-
-    // Create outputs dir then make it read-only
-    const outputsDir = path.join(tmpDir, "outputs");
-    fs.mkdirSync(outputsDir, { recursive: true });
-    fs.chmodSync(outputsDir, 0o444);
-
-    const result = persistStepOutput(tmpDir, "step1", { data: true });
-    assert.strictEqual(result, undefined);
-  });
-
-  it("writes warning to stderr on failure", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-output-err-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    // Create a file where outputs dir should be
-    fs.writeFileSync(path.join(tmpDir, "outputs"), "blocker");
-
-    // Capture stderr
-    const originalWrite = process.stderr.write;
-    let captured = "";
-    process.stderr.write = ((chunk: string) => {
-      captured += chunk;
-      return true;
-    }) as typeof process.stderr.write;
-    t.after(() => { process.stderr.write = originalWrite; });
-
-    persistStepOutput(tmpDir, "step1", { data: true });
-    assert.ok(captured.includes("step1"));
-    assert.ok(captured.includes("[pi-workflows]"));
-  });
-
-  it("returns undefined for string output when directory creation fails", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-output-err-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    // Create a file where the outputs directory should be
-    fs.writeFileSync(path.join(tmpDir, "outputs"), "not a directory");
-
-    const result = persistStepOutput(tmpDir, "step1", undefined, "some text");
-    assert.strictEqual(result, undefined);
-  });
-
-  it("does not throw on write failure — existing tests still pass", () => {
-    // Verify that all the existing happy-path tests still work unchanged.
-    // This test is a meta-check — if output.test.ts runs without error,
-    // the non-throwing behavior is confirmed alongside existing behavior.
-    assert.ok(true);
-  });
-});

package/src/output.ts

@@ -1,70 +0,0 @@
-/**
- * Step output persistence.
- *
- * Every step that produces output writes it as JSON to disk.
- * The workflow author controls the output path via the step spec's
- * output.path field. When no path is declared, defaults to
- * outputs/<stepName>.json in the run directory.
- *
- * JSON is the intermediate representation between steps — structured,
- * validated, consumable by templates, filterable by transforms, mergeable
- * across parallel runs. Text is rendered FROM JSON via templates. It's
- * never the data format.
- */
-import fs from "node:fs";
-import path from "node:path";
-
-/**
- * Persist a step's output as JSON to disk.
- *
- * @param runDir - workflow run directory (default location for outputs)
- * @param stepName - step name (used for default filename)
- * @param output - structured output (object/array) or string
- * @param textOutput - fallback text output if output is undefined
- * @param outputPath - author-declared output path (from step spec output.path, already resolved)
- * @returns absolute path to the written JSON file, or undefined if nothing to write
- */
-export function persistStepOutput(
-  runDir: string,
-  stepName: string,
-  output: unknown,
-  textOutput?: string,
-  outputPath?: string,
-): string | undefined {
-  // Author-declared path takes priority; default to run dir
-  const filePath = outputPath ?? path.join(runDir, "outputs", `${stepName}.json`);
-  const dir = path.dirname(filePath);
-
-  // Structured output — the primary case
-  if (output !== undefined && output !== null && typeof output === "object") {
-    try {
-      fs.mkdirSync(dir, { recursive: true });
-      fs.writeFileSync(filePath, JSON.stringify(output, null, 2), "utf-8");
-      return filePath;
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      process.stderr.write(
-        `[pi-workflows] Warning: failed to persist output for step '${stepName}' to ${filePath}: ${msg}\n`,
-      );
-      return undefined;
-    }
-  }
-
-  // String output — wrap in JSON to maintain uniform contract
-  const text = typeof output === "string" ? output : textOutput;
-  if (text) {
-    try {
-      fs.mkdirSync(dir, { recursive: true });
-      fs.writeFileSync(filePath, JSON.stringify({ text }, null, 2), "utf-8");
-      return filePath;
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      process.stderr.write(
-        `[pi-workflows] Warning: failed to persist output for step '${stepName}' to ${filePath}: ${msg}\n`,
-      );
-      return undefined;
-    }
-  }
-
-  return undefined;
-}

package/src/parallel-integration.test.ts

@@ -1,175 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { buildExecutionPlan } from "./dag.ts";
-import { parseWorkflowSpec } from "./workflow-spec.ts";
-import { executeWorkflow } from "./workflow-executor.ts";
-import type { WorkflowSpec } from "./types.ts";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-
-// Mock ExtensionContext and ExtensionAPI for testing
-function mockCtx(cwd: string) {
-  return {
-    cwd,
-    hasUI: false,
-    ui: {
-      setWidget: () => {},
-      notify: () => {},
-      setStatus: () => {},
-    },
-  } as any;
-}
-
-function mockPi() {
-  const messages: any[] = [];
-  return {
-    sendMessage: (msg: any, opts: any) => messages.push({ msg, opts }),
-    _messages: messages,
-  } as any;
-}
-
-function mockOptions(tmpDir?: string) {
-  const cwd = tmpDir ?? fs.mkdtempSync(path.join(os.tmpdir(), "wf-parallel-"));
-  return {
-    ctx: mockCtx(cwd),
-    pi: mockPi(),
-    loadAgent: (name: string) => ({ name }),
-  };
-}
-
-function makeSpec(overrides: Partial<WorkflowSpec> & { steps: WorkflowSpec["steps"] }): WorkflowSpec {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-parallel-"));
-  return {
-    name: "test-parallel",
-    description: "test",
-    source: "project" as const,
-    filePath: path.join(tmpDir, "test.workflow.yaml"),
-    ...overrides,
-  };
-}
-
-describe("parallel integration — DAG analysis", () => {
-  it("DAG-inferred parallel workflow produces correct execution plan", () => {
-    const yaml = fs.readFileSync(
-      path.resolve(import.meta.dirname, "../workflows/parallel-analysis.workflow.yaml"),
-      "utf-8",
-    );
-    const spec = parseWorkflowSpec(yaml, "parallel-analysis.workflow.yaml", "project");
-    const plan = buildExecutionPlan(spec);
-
-    // Layer 0: explore (no deps)
-    assert.deepStrictEqual(plan[0].steps, ["explore"]);
-
-    // Layer 1: three analyzers (all depend only on explore)
-    assert.strictEqual(plan[1].steps.length, 3);
-    assert.ok(plan[1].steps.includes("analyze-structure"));
-    assert.ok(plan[1].steps.includes("analyze-quality"));
-    assert.ok(plan[1].steps.includes("analyze-patterns"));
-
-    // Layer 2: synthesize (depends on all three analyzers)
-    assert.deepStrictEqual(plan[2].steps, ["synthesize"]);
-  });
-
-  it("explicit parallel workflow parses correctly", () => {
-    const yaml = fs.readFileSync(
-      path.resolve(import.meta.dirname, "../workflows/parallel-explicit.workflow.yaml"),
-      "utf-8",
-    );
-    const spec = parseWorkflowSpec(yaml, "parallel-explicit.workflow.yaml", "project");
-
-    assert.ok(spec.steps.analyzers);
-    assert.ok(spec.steps.analyzers.parallel);
-    assert.ok(spec.steps.analyzers.parallel!.structure);
-    assert.ok(spec.steps.analyzers.parallel!.quality);
-  });
-});
-
-describe("parallel integration — execution", () => {
-  it("parallel gate steps complete faster than sequential", async () => {
-    // Two 2-second sleeps in parallel should take ~2s, not ~4s.
-    // Steps need explicit ${{ steps.X }} deps to be parallelized
-    // (conservative plan adds implicit sequential deps for steps without them).
-    const spec = makeSpec({
-      name: "timing-test",
-      steps: {
-        source: {
-          transform: { mapping: { ready: true } },
-        },
-        a: {
-          gate: { check: "sleep 2 && echo done-a" },
-          input: { trigger: "${{ steps.source.output.ready }}" },
-        },
-        b: {
-          gate: { check: "sleep 2 && echo done-b" },
-          input: { trigger: "${{ steps.source.output.ready }}" },
-        },
-      },
-    });
-
-    const startTime = Date.now();
-    const result = await executeWorkflow(spec, {}, mockOptions());
-    const elapsed = Date.now() - startTime;
-
-    assert.strictEqual(result.status, "completed");
-    // If parallel: ~2s. If sequential: ~4s. Allow margin.
-    assert.ok(elapsed < 3500, `Expected parallel execution (~2s) but took ${elapsed}ms`);
-  });
-
-  it("timeout kills a slow gate step", async () => {
-    const spec = makeSpec({
-      name: "timeout-test",
-      steps: {
-        slow: {
-          gate: { check: "sleep 60 && echo done" },
-          timeout: { seconds: 2 },
-        },
-      },
-    });
-
-    const startTime = Date.now();
-    const result = await executeWorkflow(spec, {}, mockOptions());
-    const elapsed = Date.now() - startTime;
-
-    // Gate check failed because process was killed by timeout
-    assert.strictEqual(result.status, "failed");
-    assert.ok(elapsed < 10000, `Timeout should have killed step quickly, took ${elapsed}ms`);
-  });
-
-  it("parallel step failure cancels siblings", async () => {
-    // fast_fail and slow_success both depend on source → parallel layer.
-    // fast_fail exits immediately with error → slow_success should be cancelled.
-    const spec = makeSpec({
-      name: "cancel-test",
-      steps: {
-        source: {
-          transform: { mapping: { ready: true } },
-        },
-        fast_fail: {
-          gate: { check: "exit 1", onFail: "fail" },
-          input: { trigger: "${{ steps.source.output.ready }}" },
-        },
-        slow_success: {
-          gate: { check: "sleep 10 && echo done" },
-          input: { trigger: "${{ steps.source.output.ready }}" },
-        },
-        after: {
-          transform: {
-            mapping: {
-              a: "${{ steps.fast_fail.output }}",
-              b: "${{ steps.slow_success.output }}",
-            },
-          },
-        },
-      },
-    });
-
-    const startTime = Date.now();
-    const result = await executeWorkflow(spec, {}, mockOptions());
-    const elapsed = Date.now() - startTime;
-
-    assert.strictEqual(result.status, "failed");
-    // Should not have waited 10s for slow_success
-    assert.ok(elapsed < 5000, `Should have cancelled quickly, took ${elapsed}ms`);
-  });
-});

package/src/resume.test.ts

@@ -1,192 +0,0 @@
-/**
- * Integration tests for checkpoint/resume — proves the full cycle
- * using mock dispatch (no real subprocesses).
- */
-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 { executeWorkflow, requestPause } from "./workflow-executor.ts";
-import { readState } from "./state.ts";
-import { mockCtx, mockPi, makeSpec } from "./test-helpers.ts";
-import type { StepResult, StepUsage } from "./types.ts";
-
-const zeroUsage: StepUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
-
-function mockResult(stepName: string, text: string): StepResult {
-  return {
-    step: stepName,
-    agent: "mock",
-    status: "completed" as const,
-    textOutput: text,
-    usage: { ...zeroUsage },
-    durationMs: 100,
-  };
-}
-
-describe("resume: crash recovery", () => {
-  it("skips completed steps when resuming after failure", async (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-resume-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    const dispatched: string[] = [];
-
-    const spec = makeSpec({
-      steps: {
-        step1: { agent: "a" },
-        step2: { agent: "b" },
-        step3: { agent: "c" },
-      },
-    });
-
-    // First run: step1 succeeds, step2 fails
-    const failDispatch = async (_step: any, _agent: any, _prompt: string, opts: any) => {
-      dispatched.push(opts.stepName);
-      if (opts.stepName === "step2") {
-        return {
-          ...mockResult(opts.stepName, ""),
-          status: "failed" as const,
-          error: "Simulated failure",
-        };
-      }
-      return mockResult(opts.stepName, `output-${opts.stepName}`);
-    };
-
-    const result1 = await executeWorkflow(spec, {}, {
-      ctx: mockCtx(tmpDir),
-      pi: mockPi(),
-      loadAgent: () => ({ name: "mock" }),
-      dispatchFn: failDispatch,
-    });
-
-    assert.strictEqual(result1.status, "failed");
-    assert.ok(dispatched.includes("step1"));
-    assert.ok(dispatched.includes("step2"));
-
-    // Verify state on disk
-    const savedState = readState(result1.runDir)!;
-    assert.ok(savedState, "state should be persisted");
-    assert.strictEqual(savedState.steps.step1.status, "completed");
-    assert.strictEqual(savedState.steps.step2.status, "failed");
-
-    // Second run: resume — step1 NOT dispatched, step2 re-runs successfully, step3 runs
-    dispatched.length = 0;
-    const successDispatch = async (_step: any, _agent: any, _prompt: string, opts: any) => {
-      dispatched.push(opts.stepName);
-      return mockResult(opts.stepName, `output-${opts.stepName}`);
-    };
-
-    const result2 = await executeWorkflow(spec, {}, {
-      ctx: mockCtx(tmpDir),
-      pi: mockPi(),
-      loadAgent: () => ({ name: "mock" }),
-      dispatchFn: successDispatch,
-      resume: {
-        runId: result1.runId,
-        runDir: result1.runDir,
-        state: savedState,
-      },
-    });
-
-    assert.strictEqual(result2.status, "completed");
-    assert.ok(!dispatched.includes("step1"), "step1 should be skipped on resume");
-    assert.ok(dispatched.includes("step2"), "step2 should re-run");
-    assert.ok(dispatched.includes("step3"), "step3 should run");
-  });
-});
-
-describe("resume: pause step", () => {
-  it("pauses at a pause step and resumes from the next step", async (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-resume-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    const dispatched: string[] = [];
-    const mockDispatch = async (_step: any, _agent: any, _prompt: string, opts: any) => {
-      dispatched.push(opts.stepName);
-      return mockResult(opts.stepName, `output-${opts.stepName}`);
-    };
-
-    const spec = makeSpec({
-      steps: {
-        step1: { agent: "a" },
-        checkpoint: { pause: "Review step1 results" },
-        step2: { agent: "b" },
-      },
-    });
-
-    // Run 1: should pause after step1 + checkpoint
-    const result1 = await executeWorkflow(spec, {}, {
-      ctx: mockCtx(tmpDir),
-      pi: mockPi(),
-      loadAgent: () => ({ name: "mock" }),
-      dispatchFn: mockDispatch,
-    });
-
-    assert.strictEqual(result1.status, "paused");
-    assert.ok(dispatched.includes("step1"));
-    assert.ok(!dispatched.includes("step2"), "step2 should not run before resume");
-
-    // Verify state on disk
-    const savedState = readState(result1.runDir)!;
-    assert.ok(savedState, "state should be persisted");
-    assert.strictEqual(savedState.status, "paused");
-    assert.strictEqual(savedState.steps.step1.status, "completed");
-    assert.strictEqual(savedState.steps.checkpoint.status, "completed");
-
-    // Run 2: resume — step1 and checkpoint skipped, step2 runs
-    dispatched.length = 0;
-    const result2 = await executeWorkflow(spec, {}, {
-      ctx: mockCtx(tmpDir),
-      pi: mockPi(),
-      loadAgent: () => ({ name: "mock" }),
-      dispatchFn: mockDispatch,
-      resume: {
-        runId: result1.runId,
-        runDir: result1.runDir,
-        state: savedState,
-      },
-    });
-
-    assert.strictEqual(result2.status, "completed");
-    assert.ok(!dispatched.includes("step1"), "step1 should be skipped");
-    assert.ok(!dispatched.includes("checkpoint"), "checkpoint should be skipped");
-    assert.ok(dispatched.includes("step2"), "step2 should run");
-  });
-});
-
-describe("resume: keybinding-initiated pause", () => {
-  it("pauses between steps when requestPause is called", async (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-resume-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    const dispatched: string[] = [];
-    const mockDispatch = async (_step: any, _agent: any, _prompt: string, opts: any) => {
-      dispatched.push(opts.stepName);
-      // After step1 dispatch, request pause
-      if (opts.stepName === "step1") {
-        requestPause();
-      }
-      return mockResult(opts.stepName, `output-${opts.stepName}`);
-    };
-
-    const spec = makeSpec({
-      steps: {
-        step1: { agent: "a" },
-        step2: { agent: "b" },
-        step3: { agent: "c" },
-      },
-    });
-
-    const result = await executeWorkflow(spec, {}, {
-      ctx: mockCtx(tmpDir),
-      pi: mockPi(),
-      loadAgent: () => ({ name: "mock" }),
-      dispatchFn: mockDispatch,
-    });
-
-    assert.strictEqual(result.status, "paused");
-    assert.ok(dispatched.includes("step1"));
-    assert.ok(!dispatched.includes("step2"), "step2 should not run — paused after step1");
-  });
-});