@davidorex/pi-workflows 0.2.0 → 0.3.1

package/src/dag.ts

@@ -1,219 +0,0 @@
-/**
- * DAG dependency analysis and execution planning for workflow steps.
- * Extracts `${{ steps.X }}` references, builds a dependency graph,
- * and produces layered execution plans for parallel dispatch.
- */
-import type { WorkflowSpec, StepSpec } from "./types.ts";
-
-/**
- * A single layer in the execution plan.
- * All steps in a layer are independent and can run concurrently.
- */
-export interface ExecutionLayer {
-  steps: string[];  // step names in this layer
-}
-
-/**
- * The full execution plan: an ordered list of layers.
- * Steps in the same layer have no mutual dependencies.
- * Steps in layer N depend only on steps in layers 0..N-1.
- */
-export type ExecutionPlan = ExecutionLayer[];
-
-/**
- * Extract all step dependencies from a workflow spec.
- *
- * Scans all expression-bearing fields in each step:
- * - `input` values (recursive — expressions can be nested in objects/arrays)
- * - `when` condition
- * - `gate.check` (may contain ${{ }})
- * - `transform.mapping` values (recursive)
- * - `loop.attempts` (may be an expression)
- *
- * Does NOT descend into loop sub-steps — a loop step's internal steps
- * are the loop's own concern, not part of the top-level DAG.
- *
- * Returns a map: stepName → Set of step names it depends on.
- */
-export function extractDependencies(spec: WorkflowSpec): Map<string, Set<string>> {
-  const stepNames = new Set(Object.keys(spec.steps));
-  const deps = new Map<string, Set<string>>();
-
-  for (const [name, step] of Object.entries(spec.steps)) {
-    const stepDeps = new Set<string>();
-
-    // Collect all expression strings from this step
-    const expressions = collectExpressions(step);
-
-    // Parse each expression for `steps.<name>` references
-    for (const expr of expressions) {
-      const referenced = extractStepReferences(expr, stepNames);
-      for (const ref of referenced) {
-        if (ref !== name) {  // no self-dependencies
-          stepDeps.add(ref);
-        }
-      }
-    }
-
-    deps.set(name, stepDeps);
-  }
-
-  return deps;
-}
-
-/**
- * Collect all raw expression strings from a step spec.
- * Walks `input`, `when`, `gate.check`, `transform.mapping`, `loop.attempts`.
- */
-function collectExpressions(step: StepSpec): string[] {
-  const exprs: string[] = [];
-
-  // input values (recursive)
-  if (step.input) {
-    collectExpressionsFromValue(step.input, exprs);
-  }
-
-  // when condition
-  if (step.when) {
-    exprs.push(step.when);
-  }
-
-  // gate check
-  if (step.gate) {
-    collectExpressionsFromValue(step.gate.check, exprs);
-  }
-
-  // transform mapping (recursive)
-  if (step.transform) {
-    collectExpressionsFromValue(step.transform.mapping, exprs);
-  }
-
-  // loop attempts expression
-  if (step.loop?.attempts) {
-    exprs.push(step.loop.attempts);
-  }
-
-  // forEach expression
-  if (step.forEach) {
-    collectExpressionsFromValue(step.forEach, exprs);
-  }
-
-  // command expression (may contain ${{ }} references)
-  if (step.command) {
-    collectExpressionsFromValue(step.command, exprs);
-  }
-
-  return exprs;
-}
-
-/**
- * Recursively collect expression strings from a value.
- * Walks objects, arrays, and strings looking for ${{ }} patterns.
- */
-function collectExpressionsFromValue(value: unknown, exprs: string[]): void {
-  if (typeof value === "string") {
-    // Extract all ${{ ... }} patterns from the string
-    const regex = /\$\{\{([^}]+)\}\}/g;
-    let match: RegExpExecArray | null;
-    while ((match = regex.exec(value)) !== null) {
-      exprs.push(match[1].trim());
-    }
-    // Also handle bare expressions (no ${{ }} wrapper, e.g. in `when`)
-    if (!value.includes("${{") && value.includes("steps.")) {
-      exprs.push(value);
-    }
-  } else if (Array.isArray(value)) {
-    for (const item of value) {
-      collectExpressionsFromValue(item, exprs);
-    }
-  } else if (value !== null && typeof value === "object") {
-    for (const v of Object.values(value)) {
-      collectExpressionsFromValue(v, exprs);
-    }
-  }
-}
-
-/**
- * Extract step name references from an expression string.
- *
- * Looks for patterns like:
- * - `steps.diagnose.output`
- * - `steps.diagnose.textOutput`
- * - `steps.diagnose.status`
- *
- * Returns the set of step names referenced.
- */
-function extractStepReferences(expr: string, validStepNames: Set<string>): Set<string> {
-  const refs = new Set<string>();
-  // Match `steps.<name>` — name is a word (alphanumeric + underscore + hyphen)
-  const regex = /steps\.([a-zA-Z_][\w-]*)/g;
-  let match: RegExpExecArray | null;
-  while ((match = regex.exec(expr)) !== null) {
-    const name = match[1];
-    if (validStepNames.has(name)) {
-      refs.add(name);
-    }
-  }
-  return refs;
-}
-
-/**
- * Build an execution plan from a pre-computed dependency map.
- * Performs topological sort, grouping independent steps into layers.
- * Throws if the dependency graph contains a cycle.
- */
-export function buildPlanFromDeps(
-  allSteps: string[],
-  deps: Map<string, Set<string>>,
-): ExecutionPlan {
-  const plan: ExecutionPlan = [];
-  const placed = new Set<string>();
-
-  while (placed.size < allSteps.length) {
-    const layer: string[] = [];
-
-    for (const step of allSteps) {
-      if (placed.has(step)) continue;
-
-      const stepDeps = deps.get(step) ?? new Set();
-      if ([...stepDeps].every((d) => placed.has(d))) {
-        layer.push(step);
-      }
-    }
-
-    if (layer.length === 0) {
-      const remaining = allSteps.filter((s) => !placed.has(s));
-      throw new Error(
-        `Dependency cycle detected among steps: ${remaining.join(", ")}`,
-      );
-    }
-
-    plan.push({ steps: layer });
-    for (const s of layer) {
-      placed.add(s);
-    }
-  }
-
-  return plan;
-}
-
-/**
- * Build an execution plan from a workflow spec.
- *
- * Performs topological sort, grouping independent steps into layers.
- * Steps within a layer can execute concurrently.
- *
- * Throws if the dependency graph contains a cycle.
- */
-export function buildExecutionPlan(spec: WorkflowSpec): ExecutionPlan {
-  const deps = extractDependencies(spec);
-  return buildPlanFromDeps(Object.keys(spec.steps), deps);
-}
-
-/**
- * Check if an execution plan is fully sequential
- * (every layer has exactly one step).
- */
-export function isSequential(plan: ExecutionPlan): boolean {
-  return plan.every((layer) => layer.steps.length === 1);
-}

package/src/dispatch.test.ts

@@ -1,475 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { dispatch, buildArgs, extractText, extractToolArgsPreview } from "./dispatch.ts";
-import type { StepSpec, AgentSpec, StepResult } from "./types.ts";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-
-// Skip integration tests unless RUN_INTEGRATION=1 and pi is available
-let hasPi = false;
-if (process.env.RUN_INTEGRATION === "1") {
-  try {
-    const { execSync } = await import("node:child_process");
-    execSync("pi --version", { stdio: "ignore" });
-    hasPi = true;
-  } catch {}
-}
-
-// ── Unit tests: extractText ──
-
-describe("extractText", () => {
-  it("extracts text from a content array with a text block", () => {
-    const content = [{ type: "text", text: "Hello world" }];
-    assert.strictEqual(extractText(content), "Hello world");
-  });
-
-  it("returns empty string for empty array", () => {
-    assert.strictEqual(extractText([]), "");
-  });
-
-  it("returns empty string for null/undefined", () => {
-    assert.strictEqual(extractText(null), "");
-    assert.strictEqual(extractText(undefined), "");
-  });
-
-  it("returns empty string for non-array", () => {
-    assert.strictEqual(extractText("just a string"), "");
-    assert.strictEqual(extractText(42), "");
-  });
-
-  it("returns first text block when multiple exist", () => {
-    const content = [
-      { type: "text", text: "First" },
-      { type: "text", text: "Second" },
-    ];
-    assert.strictEqual(extractText(content), "First");
-  });
-
-  it("skips non-text blocks", () => {
-    const content = [
-      { type: "tool_use", name: "bash" },
-      { type: "text", text: "After tool" },
-    ];
-    assert.strictEqual(extractText(content), "After tool");
-  });
-
-  it("returns empty string for array with no text blocks", () => {
-    const content = [
-      { type: "tool_use", name: "bash" },
-      { type: "image", source: {} },
-    ];
-    assert.strictEqual(extractText(content), "");
-  });
-});
-
-// ── Unit tests: extractToolArgsPreview ──
-
-describe("extractToolArgsPreview", () => {
-  it("returns empty string for null/undefined", () => {
-    assert.strictEqual(extractToolArgsPreview(null), "");
-    assert.strictEqual(extractToolArgsPreview(undefined), "");
-  });
-
-  it("returns empty string for non-object", () => {
-    assert.strictEqual(extractToolArgsPreview("string"), "");
-    assert.strictEqual(extractToolArgsPreview(42), "");
-  });
-
-  it("extracts command arg", () => {
-    assert.strictEqual(extractToolArgsPreview({ command: "ls -la" }), "ls -la");
-  });
-
-  it("extracts path arg", () => {
-    assert.strictEqual(extractToolArgsPreview({ path: "/foo/bar.ts" }), "/foo/bar.ts");
-  });
-
-  it("extracts pattern arg", () => {
-    assert.strictEqual(extractToolArgsPreview({ pattern: "*.ts" }), "*.ts");
-  });
-
-  it("extracts query arg", () => {
-    assert.strictEqual(extractToolArgsPreview({ query: "SELECT 1" }), "SELECT 1");
-  });
-
-  it("extracts task arg", () => {
-    assert.strictEqual(extractToolArgsPreview({ task: "do something" }), "do something");
-  });
-
-  it("prefers command over other keys", () => {
-    assert.strictEqual(
-      extractToolArgsPreview({ command: "npm test", path: "/foo" }),
-      "npm test",
-    );
-  });
-
-  it("truncates long values to 60 chars", () => {
-    const longVal = "a".repeat(100);
-    const result = extractToolArgsPreview({ command: longVal });
-    assert.strictEqual(result.length, 60);
-    assert.ok(result.endsWith("..."));
-    assert.strictEqual(result, "a".repeat(57) + "...");
-  });
-
-  it("does not truncate values at exactly 60 chars", () => {
-    const val60 = "b".repeat(60);
-    assert.strictEqual(extractToolArgsPreview({ command: val60 }), val60);
-  });
-
-  it("returns empty string when no recognized keys present", () => {
-    assert.strictEqual(extractToolArgsPreview({ foo: "bar", baz: 42 }), "");
-  });
-
-  it("skips non-string values for recognized keys", () => {
-    assert.strictEqual(extractToolArgsPreview({ command: 123, path: true }), "");
-  });
-});
-
-// ── Unit tests: buildArgs ──
-
-describe("buildArgs", () => {
-  const baseOptions = {
-    cwd: "/tmp",
-    sessionLogDir: "/tmp/sessions",
-    stepName: "test-step",
-  };
-
-  it("produces minimal args for a bare step and agent", () => {
-    const step: StepSpec = { agent: "default" };
-    const agent: AgentSpec = { name: "default" };
-    const args = buildArgs(step, agent, "hello", baseOptions);
-
-    assert.deepStrictEqual(args.slice(0, 2), ["--mode", "json"]);
-    assert.ok(args.includes("--session-dir"));
-    assert.ok(args.includes("/tmp/sessions"));
-    // Ends with -p hello
-    assert.strictEqual(args[args.length - 2], "-p");
-    assert.strictEqual(args[args.length - 1], "hello");
-    // No model args
-    assert.ok(!args.includes("--models"));
-  });
-
-  it("includes model from agent spec", () => {
-    const step: StepSpec = { agent: "coder" };
-    const agent: AgentSpec = { name: "coder", model: "claude-sonnet-4-20250514" };
-    const args = buildArgs(step, agent, "do it", baseOptions);
-
-    const idx = args.indexOf("--models");
-    assert.ok(idx >= 0);
-    assert.strictEqual(args[idx + 1], "claude-sonnet-4-20250514:off");
-  });
-
-  it("step model overrides agent model", () => {
-    const step: StepSpec = { agent: "coder", model: "claude-opus-4-20250514" };
-    const agent: AgentSpec = { name: "coder", model: "claude-sonnet-4-20250514" };
-    const args = buildArgs(step, agent, "do it", baseOptions);
-
-    const idx = args.indexOf("--models");
-    assert.strictEqual(args[idx + 1], "claude-opus-4-20250514:off");
-  });
-
-  it("appends thinking suffix to model", () => {
-    const step: StepSpec = { agent: "coder" };
-    const agent: AgentSpec = { name: "coder", model: "claude-sonnet-4-20250514", thinking: "16k" };
-    const args = buildArgs(step, agent, "do it", baseOptions);
-
-    const idx = args.indexOf("--models");
-    assert.strictEqual(args[idx + 1], "claude-sonnet-4-20250514:16k");
-  });
-
-  it("resolves model from modelConfig by role when agent has no model", () => {
-    const step: StepSpec = { agent: "coder" };
-    const agent: AgentSpec = { name: "coder", role: "action" };
-    const opts = { ...baseOptions, modelConfig: { default: "fallback-model", by_role: { action: "opus-4" } } };
-    const args = buildArgs(step, agent, "do it", opts);
-
-    const idx = args.indexOf("--models");
-    assert.ok(idx >= 0);
-    assert.strictEqual(args[idx + 1], "opus-4:off");
-  });
-
-  it("resolves model from modelConfig default when no role match", () => {
-    const step: StepSpec = { agent: "coder" };
-    const agent: AgentSpec = { name: "coder", role: "unknown-role" };
-    const opts = { ...baseOptions, modelConfig: { default: "fallback-model", by_role: { action: "opus-4" } } };
-    const args = buildArgs(step, agent, "do it", opts);
-
-    const idx = args.indexOf("--models");
-    assert.ok(idx >= 0);
-    assert.strictEqual(args[idx + 1], "fallback-model:off");
-  });
-
-  it("step model overrides modelConfig", () => {
-    const step: StepSpec = { agent: "coder", model: "step-override" };
-    const agent: AgentSpec = { name: "coder", role: "action" };
-    const opts = { ...baseOptions, modelConfig: { default: "fallback-model", by_role: { action: "opus-4" } } };
-    const args = buildArgs(step, agent, "do it", opts);
-
-    const idx = args.indexOf("--models");
-    assert.strictEqual(args[idx + 1], "step-override:off");
-  });
-
-  it("agent model overrides modelConfig", () => {
-    const step: StepSpec = { agent: "coder" };
-    const agent: AgentSpec = { name: "coder", model: "agent-model", role: "action" };
-    const opts = { ...baseOptions, modelConfig: { default: "fallback-model", by_role: { action: "opus-4" } } };
-    const args = buildArgs(step, agent, "do it", opts);
-
-    const idx = args.indexOf("--models");
-    assert.strictEqual(args[idx + 1], "agent-model:off");
-  });
-
-  it("handles builtin tools", () => {
-    const step: StepSpec = { agent: "coder" };
-    const agent: AgentSpec = { name: "coder", tools: ["bash", "read", "write"] };
-    const args = buildArgs(step, agent, "do it", baseOptions);
-
-    const idx = args.indexOf("--tools");
-    assert.ok(idx >= 0);
-    assert.strictEqual(args[idx + 1], "bash,read,write");
-  });
-
-  it("handles extension tool paths", () => {
-    const step: StepSpec = { agent: "coder" };
-    const agent: AgentSpec = { name: "coder", tools: ["bash", "./ext/my-tool.ts", "/abs/tool.js"] };
-    const args = buildArgs(step, agent, "do it", baseOptions);
-
-    const toolsIdx = args.indexOf("--tools");
-    assert.ok(toolsIdx >= 0);
-    assert.strictEqual(args[toolsIdx + 1], "bash");
-
-    // Should have two --extension entries for the paths
-    const extIndices = args.reduce<number[]>((acc, a, i) => {
-      if (a === "--extension") acc.push(i);
-      return acc;
-    }, []);
-    assert.strictEqual(extIndices.length, 2);
-    assert.strictEqual(args[extIndices[0] + 1], "./ext/my-tool.ts");
-    assert.strictEqual(args[extIndices[1] + 1], "/abs/tool.js");
-  });
-
-  it("handles extensions scoping", () => {
-    const step: StepSpec = { agent: "coder" };
-    const agent: AgentSpec = { name: "coder", extensions: ["./ext1.ts", "./ext2.ts"] };
-    const args = buildArgs(step, agent, "do it", baseOptions);
-
-    assert.ok(args.includes("--no-extensions"));
-    const extIndices = args.reduce<number[]>((acc, a, i) => {
-      if (a === "--extension") acc.push(i);
-      return acc;
-    }, []);
-    assert.strictEqual(extIndices.length, 2);
-  });
-
-  it("handles skills scoping", () => {
-    const step: StepSpec = { agent: "coder" };
-    const agent: AgentSpec = { name: "coder", skills: ["coding", "testing"] };
-    const args = buildArgs(step, agent, "do it", baseOptions);
-
-    assert.ok(args.includes("--no-skills"));
-  });
-});
-
-// ── Integration tests: dispatch (require pi on PATH) ──
-
-describe("dispatch", { skip: !hasPi ? "pi not available" : undefined }, () => {
-  it("runs a simple prompt and returns text output", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-dispatch-"));
-    const sessDir = path.join(tmpDir, "sessions");
-    fs.mkdirSync(sessDir, { recursive: true });
-
-    const result = await dispatch(
-      { agent: "default" },     // no specific agent — use pi defaults
-      { name: "default" },      // minimal agent spec
-      "Respond with exactly: HELLO WORKFLOW",
-      { cwd: process.cwd(), sessionLogDir: sessDir, stepName: "test" },
-    );
-
-    assert.strictEqual(result.status, "completed");
-    assert.ok(result.textOutput.includes("HELLO WORKFLOW"));
-    assert.ok(result.usage.turns >= 1);
-    assert.ok(result.durationMs > 0);
-
-    fs.rmSync(tmpDir, { recursive: true });
-  }, { timeout: 60000 });
-
-  it("returns failed status on bad prompt/agent", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-dispatch-"));
-    const sessDir = path.join(tmpDir, "sessions");
-    fs.mkdirSync(sessDir, { recursive: true });
-
-    // --tools none should cause pi to fail or at least limit capabilities
-    const result = await dispatch(
-      { agent: "nonexistent-agent-xyz" },
-      { name: "nonexistent-agent-xyz" },
-      "This should fail",
-      { cwd: process.cwd(), sessionLogDir: sessDir, stepName: "test" },
-    );
-
-    // Exact failure mode depends on pi behavior with unknown agents
-    // At minimum we should get a result back (not throw)
-    assert.ok(result.durationMs > 0);
-
-    fs.rmSync(tmpDir, { recursive: true });
-  }, { timeout: 30000 });
-
-  it("supports cancellation via AbortSignal", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-dispatch-"));
-    const sessDir = path.join(tmpDir, "sessions");
-    fs.mkdirSync(sessDir, { recursive: true });
-
-    const controller = new AbortController();
-
-    // Cancel after 2 seconds
-    setTimeout(() => controller.abort(), 2000);
-
-    const result = await dispatch(
-      { agent: "default" },
-      { name: "default" },
-      "Write a very long essay about the history of computing. Make it at least 5000 words.",
-      { cwd: process.cwd(), sessionLogDir: sessDir, stepName: "test", signal: controller.signal },
-    );
-
-    assert.strictEqual(result.status, "failed");
-
-    fs.rmSync(tmpDir, { recursive: true });
-  }, { timeout: 30000 });
-
-  it("fires onEvent callback for process events", async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-dispatch-"));
-    const sessDir = path.join(tmpDir, "sessions");
-    fs.mkdirSync(sessDir, { recursive: true });
-
-    const events: string[] = [];
-
-    const result = await dispatch(
-      { agent: "default" },
-      { name: "default" },
-      "Respond with exactly: TEST",
-      {
-        cwd: process.cwd(),
-        sessionLogDir: sessDir,
-        stepName: "test",
-        onEvent: (evt) => events.push(evt.type),
-      },
-    );
-
-    assert.ok(events.includes("agent_start"));
-    assert.ok(events.includes("message_end"));
-
-    fs.rmSync(tmpDir, { recursive: true });
-  }, { timeout: 60000 });
-});
-
-// ── Unit tests: StepResult truncation fields ──
-
-describe("StepResult truncation fields", () => {
-  it("truncated and warnings are optional on StepResult", () => {
-    // Verify the type contract: a StepResult without truncated/warnings is valid
-    const result: StepResult = {
-      step: "test",
-      agent: "agent",
-      status: "completed",
-      usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
-      durationMs: 0,
-    };
-    assert.strictEqual(result.truncated, undefined);
-    assert.strictEqual(result.warnings, undefined);
-
-    // A truncated result is also valid
-    const truncResult: StepResult = {
-      ...result,
-      truncated: true,
-      warnings: ["Stdout exceeded 10MB limit"],
-    };
-    assert.strictEqual(truncResult.truncated, true);
-    assert.strictEqual(truncResult.warnings!.length, 1);
-  });
-});
-
-// ── Unit tests: truncation detection logic ──
-
-describe("truncation detection logic", () => {
-  it("sets truncated flag when accumulated bytes exceed threshold", () => {
-    // Simulate the accumulation logic from dispatch's data handler
-    const MAX = 100; // small threshold for testing
-    let bufBytes = 0;
-    let stdoutTruncated = false;
-    const processedLines: string[] = [];
-    let buf = "";
-
-    function handleChunk(chunk: string) {
-      bufBytes += Buffer.byteLength(chunk);
-      if (bufBytes > MAX) {
-        if (!stdoutTruncated) {
-          stdoutTruncated = true;
-          if (buf.trim()) {
-            processedLines.push(buf.trim());
-            buf = "";
-          }
-        }
-        return;
-      }
-      buf += chunk;
-      const lines = buf.split("\n");
-      buf = lines.pop() || "";
-      for (const line of lines) {
-        if (line.trim()) processedLines.push(line.trim());
-      }
-    }
-
-    // Send chunks that total over 100 bytes
-    handleChunk('{"type":"event1"}\n');  // ~18 bytes
-    handleChunk('{"type":"event2"}\n');  // ~36 total
-    handleChunk('{"type":"event3"}\n');  // ~54 total
-    handleChunk('{"type":"event4"}\n');  // ~72 total
-    handleChunk('{"type":"event5"}\n');  // ~90 total
-    handleChunk('{"type":"event6"}\n');  // ~108 total — exceeds 100
-
-    assert.strictEqual(stdoutTruncated, true);
-    // Events before the threshold should have been processed
-    assert.ok(processedLines.length >= 4);
-    assert.ok(processedLines.length < 6, "Post-threshold events should not be processed");
-  });
-
-  it("does not set truncated flag when under threshold", () => {
-    const MAX = 10000;
-    let bufBytes = 0;
-    let stdoutTruncated = false;
-
-    function handleChunk(chunk: string) {
-      bufBytes += Buffer.byteLength(chunk);
-      if (bufBytes > MAX) {
-        stdoutTruncated = true;
-        return;
-      }
-    }
-
-    handleChunk('{"type":"small"}\n');
-    assert.strictEqual(stdoutTruncated, false);
-  });
-});
-
-// ── Integration test: dispatch truncation contract ──
-
-describe("dispatch truncation", { skip: !hasPi ? "pi not available" : undefined }, () => {
-  it("sets truncated flag when stdout exceeds buffer limit", async () => {
-    // A normal-sized response should NOT have truncated set.
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-dispatch-trunc-"));
-    const sessDir = path.join(tmpDir, "sessions");
-    fs.mkdirSync(sessDir, { recursive: true });
-
-    const result = await dispatch(
-      { agent: "default" },
-      { name: "default" },
-      "Respond with exactly: OK",
-      { cwd: process.cwd(), sessionLogDir: sessDir, stepName: "test" },
-    );
-
-    assert.strictEqual(result.status, "completed");
-    assert.strictEqual(result.truncated, undefined, "Normal response should not be truncated");
-    assert.strictEqual(result.warnings, undefined, "Normal response should have no warnings");
-
-    fs.rmSync(tmpDir, { recursive: true });
-  }, { timeout: 60000 });
-});