@davidorex/pi-workflows 0.2.0 → 0.3.1

package/src/dispatch.ts

@@ -1,353 +0,0 @@
-/**
- * Subprocess dispatch for workflow steps — spawns pi in JSON mode,
- * collects events, usage, and output. Supports cancellation and timeout.
- */
-import { spawn } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import type { StepSpec, StepResult, StepUsage, AgentSpec } from "./types.ts";
-import { SIGKILL_GRACE_MS } from "./step-shared.ts";
-
-export interface ModelConfig {
-  default?: string;
-  by_role?: Record<string, string>;
-}
-
-export interface DispatchOptions {
-  cwd: string;
-  sessionLogDir: string;      // directory for session log file (e.g. <runDir>/sessions/)
-  stepName: string;            // used for naming the session log file
-  signal?: AbortSignal;        // for cancellation
-  timeoutMs?: number;          // timeout in milliseconds — kills subprocess after deadline
-  onEvent?: (event: ProcessEvent) => void;  // live event callback for TUI updates
-  modelConfig?: ModelConfig;   // project-level model assignments by role
-}
-
-export interface ProcessEvent {
-  type: string;
-  raw: unknown;                // the parsed JSON line
-  // Extracted fields for common events:
-  toolName?: string;           // for tool_execution_start/end
-  toolArgs?: string;           // preview string for tool_execution_start
-  messageText?: string;        // text content for message_end (assistant messages)
-  usage?: Partial<StepUsage>;  // usage delta for message_end
-}
-
-/**
- * Prompt length threshold (chars) for switching to @file argument passing.
- * Avoids OS-level argument length limits (typically 128–256 KB) with headroom
- * for the rest of the CLI args. 8000 chars is well under all limits while
- * keeping short prompts as direct args for simplicity.
- */
-const PROMPT_ARG_LIMIT = 8000;
-
-/** Maximum stdout buffer size (10 MB) to prevent OOM from runaway subprocesses. */
-const MAX_STDOUT_BYTES = 10 * 1024 * 1024;
-
-export function extractText(content: unknown): string {
-  if (!content || !Array.isArray(content)) return "";
-  for (const part of content) {
-    if (part && typeof part === "object" && "type" in part && part.type === "text" && "text" in part) {
-      return String(part.text);
-    }
-  }
-  return "";
-}
-
-export function extractToolArgsPreview(args: unknown): string {
-  if (!args || typeof args !== "object") return "";
-  const obj = args as Record<string, unknown>;
-  for (const key of ["command", "path", "pattern", "query", "task"]) {
-    if (typeof obj[key] === "string") {
-      const val = obj[key] as string;
-      return val.length > 60 ? val.slice(0, 57) + "..." : val;
-    }
-  }
-  return "";
-}
-
-export function buildArgs(step: StepSpec, agentSpec: AgentSpec, prompt: string, options: DispatchOptions): string[] {
-  const args = ["--mode", "json"];
-
-  // Session log
-  args.push("--session-dir", options.sessionLogDir);
-
-  // Model: step > agent spec > model-config by role > model-config default
-  const model = step.model ?? agentSpec.model
-    ?? (agentSpec.role && options.modelConfig?.by_role?.[agentSpec.role])
-    ?? options.modelConfig?.default;
-  if (model) {
-    const modelArg = `${model}:${agentSpec.thinking ?? "off"}`;
-    args.push("--models", modelArg);
-  }
-
-  // Tool filtering
-  if (agentSpec.tools?.length) {
-    const builtinTools: string[] = [];
-    const extensionPaths: string[] = [];
-    for (const tool of agentSpec.tools) {
-      if (tool.includes("/") || tool.endsWith(".ts") || tool.endsWith(".js")) {
-        extensionPaths.push(tool);
-      } else {
-        builtinTools.push(tool);
-      }
-    }
-    if (builtinTools.length > 0) args.push("--tools", builtinTools.join(","));
-    for (const ext of extensionPaths) args.push("--extension", ext);
-  }
-
-  // Extension scoping
-  if (agentSpec.extensions !== undefined) {
-    args.push("--no-extensions");
-    for (const ext of agentSpec.extensions) args.push("--extension", ext);
-  }
-
-  // Skill scoping
-  if (agentSpec.skills?.length) {
-    args.push("--no-skills");
-    // Skills are injected via --append-system-prompt, not CLI flags
-  }
-
-  // System prompt (if agent spec has one)
-  // Write to temp file if present, pass via --append-system-prompt
-  // (handled in dispatch() body, not buildArgs)
-
-  // Prompt — use @file for long prompts
-  args.push("-p");
-  args.push(prompt);  // or @<tmpfile> if prompt > 8000 chars
-
-  return args;
-}
-
-/**
- * Spawn a pi subprocess for a workflow step and collect the result.
- *
- * Builds CLI args from the step spec and agent spec.
- * Streams stdout as newline-delimited JSON.
- * Collects messages, usage, timing.
- * Returns StepResult when the process exits.
- */
-export async function dispatch(
-  step: StepSpec,
-  agentSpec: AgentSpec,
-  prompt: string,
-  options: DispatchOptions,
-): Promise<StepResult> {
-  const startTime = Date.now();
-  const args = buildArgs(step, agentSpec, prompt, options);
-
-  // Handle long prompts: write to temp file
-  let tmpDir: string | null = null;
-  if (prompt.length > PROMPT_ARG_LIMIT) {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wf-"));
-    const promptFile = path.join(tmpDir, "prompt.md");
-    fs.writeFileSync(promptFile, prompt, { mode: 0o600 });
-    // Replace last two args ("-p", prompt) with ("-p", "@<file>")
-    args[args.length - 1] = `@${promptFile}`;
-  }
-
-  // Handle system prompt: write to temp file
-  if (agentSpec.systemPrompt) {
-    if (!tmpDir) tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wf-"));
-    const sysFile = path.join(tmpDir, "system.md");
-    fs.writeFileSync(sysFile, agentSpec.systemPrompt, { mode: 0o600 });
-    // Insert before -p flag
-    const pIdx = args.indexOf("-p");
-    args.splice(pIdx, 0, "--append-system-prompt", sysFile);
-  }
-
-  const proc = spawn("pi", args, {
-    cwd: options.cwd,
-    env: process.env,
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-
-  // Cancellation support
-  if (options.signal) {
-    const kill = () => {
-      proc.kill("SIGTERM");
-      setTimeout(() => { if (!proc.killed) proc.kill("SIGKILL"); }, SIGKILL_GRACE_MS);
-    };
-    if (options.signal.aborted) kill();
-    else options.signal.addEventListener("abort", kill, { once: true });
-  }
-
-  // Timeout support: SIGTERM after deadline, SIGKILL after 5s grace
-  let timedOut = false;
-  let timeoutTimer: ReturnType<typeof setTimeout> | undefined;
-  let killTimer: ReturnType<typeof setTimeout> | undefined;
-  if (options.timeoutMs) {
-    timeoutTimer = setTimeout(() => {
-      timedOut = true;
-      proc.kill("SIGTERM");
-      killTimer = setTimeout(() => {
-        if (!proc.killed) proc.kill("SIGKILL");
-      }, SIGKILL_GRACE_MS);
-    }, options.timeoutMs);
-  }
-
-  // Collect result
-  const messages: unknown[] = [];
-  const usage: StepUsage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
-  let lastAssistantText = "";
-  let stderrBuf = "";
-
-  function processEvent(evt: { type?: string; message?: any; toolName?: string; args?: any }) {
-    // Track messages
-    if (evt.type === "message_end" && evt.message) {
-      messages.push(evt.message);
-      if (evt.message.role === "assistant") {
-        usage.turns++;
-        const u = evt.message.usage;
-        if (u) {
-          usage.input += u.input || 0;
-          usage.output += u.output || 0;
-          usage.cacheRead += u.cacheRead || 0;
-          usage.cacheWrite += u.cacheWrite || 0;
-          usage.cost += u.cost?.total || 0;
-        }
-        // Extract text from last assistant message
-        const text = extractText(evt.message.content);
-        if (text) lastAssistantText = text;
-      }
-    }
-
-    // Forward to TUI callback
-    if (options.onEvent) {
-      options.onEvent({
-        type: evt.type || "unknown",
-        raw: evt,
-        toolName: evt.type === "tool_execution_start" ? evt.toolName : undefined,
-        toolArgs: evt.type === "tool_execution_start" ? extractToolArgsPreview(evt.args) : undefined,
-        messageText: evt.type === "message_end" && evt.message?.role === "assistant"
-          ? extractText(evt.message.content)
-          : undefined,
-        usage: evt.type === "message_end" && evt.message?.role === "assistant" && evt.message.usage
-          ? {
-              input: evt.message.usage.input,
-              output: evt.message.usage.output,
-              cost: evt.message.usage.cost?.total,
-            }
-          : undefined,
-      });
-    }
-  }
-
-  // Stream stdout as newline-delimited JSON
-  let buf = "";
-  let bufBytes = 0;
-  let stdoutTruncated = false;
-  proc.stdout!.on("data", (chunk: Buffer) => {
-    bufBytes += chunk.length;
-    if (bufBytes > MAX_STDOUT_BYTES) {
-      if (!stdoutTruncated) {
-        stdoutTruncated = true;
-        // Process any remaining partial line in buf before discarding
-        if (buf.trim()) {
-          try {
-            const evt = JSON.parse(buf);
-            processEvent(evt);
-          } catch {
-            // incomplete JSON line — discard
-          }
-          buf = "";
-        }
-      }
-      return;
-    }
-    buf += chunk.toString();
-    const lines = buf.split("\n");
-    buf = lines.pop() || "";
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      try {
-        const evt = JSON.parse(line);
-        processEvent(evt);
-      } catch {
-        // Skip unparseable lines
-      }
-    }
-  });
-
-  proc.stderr!.on("data", (chunk: Buffer) => {
-    stderrBuf += chunk.toString();
-  });
-
-  // Wait for process to exit
-  const exitCode = await new Promise<number | null>((resolve) => {
-    proc.on("close", (code) => {
-      // Process remaining buffer
-      if (buf.trim()) {
-        try {
-          const evt = JSON.parse(buf);
-          processEvent(evt);
-        } catch {
-          // Skip unparseable remainder
-        }
-      }
-      resolve(code);
-    });
-  });
-
-  // Clear timeout timers
-  if (timeoutTimer) clearTimeout(timeoutTimer);
-  if (killTimer) clearTimeout(killTimer);
-
-  // Cleanup temp files
-  if (tmpDir) {
-    try {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    } catch {
-      // Best-effort cleanup
-    }
-  }
-
-  // Timeout overrides exit code interpretation
-  if (timedOut) {
-    const warnings: string[] = [];
-    if (stdoutTruncated) {
-      warnings.push(
-        `Stdout exceeded ${MAX_STDOUT_BYTES / (1024 * 1024)}MB limit — ` +
-        `output stream was truncated at ${bufBytes} bytes. ` +
-        `Usage counters (tokens, cost, turns) and textOutput may be incomplete.`
-      );
-    }
-    return {
-      step: options.stepName,
-      agent: step.agent,
-      status: "failed",
-      output: undefined,
-      textOutput: lastAssistantText,
-      sessionLog: options.sessionLogDir,
-      usage,
-      durationMs: Date.now() - startTime,
-      error: `Step timed out after ${options.timeoutMs! / 1000}s`,
-      truncated: stdoutTruncated || undefined,
-      warnings: warnings.length > 0 ? warnings : undefined,
-    };
-  }
-
-  const warnings: string[] = [];
-  if (stdoutTruncated) {
-    warnings.push(
-      `Stdout exceeded ${MAX_STDOUT_BYTES / (1024 * 1024)}MB limit — ` +
-      `output stream was truncated at ${bufBytes} bytes. ` +
-      `Usage counters (tokens, cost, turns) and textOutput may be incomplete.`
-    );
-  }
-
-  return {
-    step: options.stepName,
-    agent: step.agent,
-    status: exitCode === 0 ? "completed" : "failed",
-    output: undefined,          // structured output handled by caller (workflow-executor)
-    textOutput: lastAssistantText,
-    sessionLog: options.sessionLogDir,
-    usage,
-    durationMs: Date.now() - startTime,
-    error: exitCode !== 0 ? (stderrBuf.trim() || "Process exited with code " + exitCode) : undefined,
-    truncated: stdoutTruncated || undefined,
-    warnings: warnings.length > 0 ? warnings : undefined,
-  };
-}

package/src/expression.test.ts

@@ -1,353 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { resolveExpressions, resolveExpression, evaluateCondition, ExpressionError } from "./expression.ts";
-import type { ExpressionScope, CompletionScope } from "./types.ts";
-
-const scope: ExpressionScope = {
-  input: {
-    description: "null pointer in login",
-    maxAttempts: 3,
-    tags: ["auth", "critical"],
-  },
-  steps: {
-    diagnose: {
-      step: "diagnose",
-      agent: "diagnostician",
-      status: "completed",
-      output: {
-        summary: "NPE in UserService.login()",
-        rootCause: "session param is null",
-        fixLocation: { file: "src/auth/user-service.ts", line: 47 },
-        reproCommand: "npm test -- --grep login",
-      },
-      textOutput: "Found the bug...",
-      usage: { input: 1000, output: 500, cacheRead: 0, cacheWrite: 0, cost: 0.03, turns: 2 },
-      durationMs: 42000,
-    },
-  },
-};
-
-describe("resolveExpression", () => {
-  it("resolves input properties", () => {
-    assert.strictEqual(resolveExpression("input.description", scope), "null pointer in login");
-  });
-
-  it("resolves input number", () => {
-    assert.strictEqual(resolveExpression("input.maxAttempts", scope), 3);
-  });
-
-  it("resolves step output object", () => {
-    const result = resolveExpression("steps.diagnose.output", scope);
-    assert.strictEqual(typeof result, "object");
-    assert.strictEqual((result as any).summary, "NPE in UserService.login()");
-  });
-
-  it("resolves nested step output", () => {
-    assert.strictEqual(
-      resolveExpression("steps.diagnose.output.fixLocation.file", scope),
-      "src/auth/user-service.ts",
-    );
-  });
-
-  it("resolves step metadata", () => {
-    assert.strictEqual(resolveExpression("steps.diagnose.status", scope), "completed");
-    assert.strictEqual(resolveExpression("steps.diagnose.usage.cost", scope), 0.03);
-  });
-
-  it("returns undefined for missing optional property on input", () => {
-    assert.strictEqual(resolveExpression("input.nonexistent", scope), undefined);
-  });
-
-  it("returns undefined for missing optional property on step output", () => {
-    assert.strictEqual(resolveExpression("steps.diagnose.output.missingField", scope), undefined);
-  });
-
-  it("throws on unexecuted step", () => {
-    assert.throws(
-      () => resolveExpression("steps.fix.output", scope),
-      (err: unknown) => err instanceof ExpressionError && err.message.includes("fix"),
-    );
-  });
-
-  it("throws on invalid root path", () => {
-    assert.throws(
-      () => resolveExpression("typo.something", scope),
-      (err: unknown) => err instanceof ExpressionError,
-    );
-  });
-});
-
-// ── Filter tests ──
-
-describe("resolveExpression filters", () => {
-  it("applies duration filter", () => {
-    assert.strictEqual(
-      resolveExpression("steps.diagnose.durationMs | duration", scope),
-      "42s",
-    );
-  });
-
-  it("applies currency filter", () => {
-    assert.strictEqual(
-      resolveExpression("steps.diagnose.usage.cost | currency", scope),
-      "$0.03",
-    );
-  });
-
-  it("applies json filter", () => {
-    const result = resolveExpression("steps.diagnose.output.fixLocation | json", scope);
-    assert.strictEqual(typeof result, "string");
-    const parsed = JSON.parse(result as string);
-    assert.strictEqual(parsed.file, "src/auth/user-service.ts");
-    assert.strictEqual(parsed.line, 47);
-  });
-
-  it("applies length filter to array", () => {
-    const result = resolveExpression("input.tags | length", scope);
-    assert.strictEqual(result, 2);
-  });
-
-  it("applies length filter to string", () => {
-    const result = resolveExpression("input.description | length", scope);
-    assert.strictEqual(result, 21);
-  });
-
-  it("applies length filter to non-array/string returns 0", () => {
-    const result = resolveExpression("input.maxAttempts | length", scope);
-    assert.strictEqual(result, 0);
-  });
-
-  it("applies keys filter to object", () => {
-    const result = resolveExpression("steps.diagnose.output.fixLocation | keys", scope);
-    assert.ok(Array.isArray(result));
-    assert.ok((result as string[]).includes("file"));
-    assert.ok((result as string[]).includes("line"));
-  });
-
-  it("applies filter filter removes falsy values", () => {
-    const scopeWithFalsy = {
-      ...scope,
-      input: { ...scope.input, items: [1, 0, null, "hello", "", false, true] },
-    };
-    const result = resolveExpression("input.items | filter", scopeWithFalsy);
-    assert.deepStrictEqual(result, [1, "hello", true]);
-  });
-
-  it("handles whitespace around pipe", () => {
-    assert.strictEqual(
-      resolveExpression("steps.diagnose.durationMs  |  duration", scope),
-      "42s",
-    );
-  });
-
-  it("throws on unknown filter", () => {
-    assert.throws(
-      () => resolveExpression("steps.diagnose.durationMs | bogus", scope),
-      (err: unknown) => err instanceof ExpressionError && err.message.includes("bogus"),
-    );
-  });
-
-  it("applies filter in embedded expression", () => {
-    const result = resolveExpressions(
-      "Took ${{ steps.diagnose.durationMs | duration }}, cost ${{ steps.diagnose.usage.cost | currency }}",
-      scope,
-    );
-    assert.strictEqual(result, "Took 42s, cost $0.03");
-  });
-
-  it("applies filter in whole-value expression", () => {
-    const result = resolveExpressions("${{ steps.diagnose.durationMs | duration }}", scope);
-    assert.strictEqual(result, "42s");
-  });
-});
-
-// ── Wider scope (CompletionScope) tests ──
-
-describe("resolveExpression with CompletionScope", () => {
-  const completionScope: CompletionScope = {
-    input: { path: "/src" },
-    steps: scope.steps,
-    totalUsage: { input: 1500, output: 700, cacheRead: 0, cacheWrite: 0, cost: 0.05, turns: 3 },
-    totalDurationMs: 92000,
-    runDir: "/tmp/runs/test-run",
-    runId: "test-20260313-120000-abcd",
-    workflow: "explore-summarize",
-    status: "completed",
-    output: "Final summary text",
-  };
-
-  it("resolves root-level completion fields", () => {
-    assert.strictEqual(resolveExpression("workflow", completionScope), "explore-summarize");
-    assert.strictEqual(resolveExpression("status", completionScope), "completed");
-    assert.strictEqual(resolveExpression("runDir", completionScope), "/tmp/runs/test-run");
-    assert.strictEqual(resolveExpression("runId", completionScope), "test-20260313-120000-abcd");
-  });
-
-  it("resolves totalUsage fields", () => {
-    assert.strictEqual(
-      resolveExpression("totalUsage.cost", completionScope),
-      0.05,
-    );
-  });
-
-  it("applies filters on completion fields", () => {
-    assert.strictEqual(
-      resolveExpression("totalDurationMs | duration", completionScope),
-      "1m32s",
-    );
-    assert.strictEqual(
-      resolveExpression("totalUsage.cost | currency", completionScope),
-      "$0.05",
-    );
-  });
-
-  it("still resolves input and steps from completion scope", () => {
-    assert.strictEqual(
-      resolveExpression("input.path", completionScope),
-      "/src",
-    );
-    assert.strictEqual(
-      resolveExpression("steps.diagnose.status", completionScope),
-      "completed",
-    );
-  });
-});
-
-// ── evaluateCondition tests ──
-
-describe("evaluateCondition", () => {
-  it("returns true for truthy value", () => {
-    assert.strictEqual(evaluateCondition("input.description", scope), true);
-  });
-
-  it("returns true for truthy number", () => {
-    assert.strictEqual(evaluateCondition("input.maxAttempts", scope), true);
-  });
-
-  it("returns false for undefined (missing optional field)", () => {
-    assert.strictEqual(evaluateCondition("input.nonexistent", scope), false);
-  });
-
-  it("supports negation with ! prefix", () => {
-    assert.strictEqual(evaluateCondition("!input.nonexistent", scope), true);
-    assert.strictEqual(evaluateCondition("!input.description", scope), false);
-  });
-
-  it("supports equality with string literal", () => {
-    assert.strictEqual(evaluateCondition("input.description == 'null pointer in login'", scope), true);
-    assert.strictEqual(evaluateCondition("input.description == 'something else'", scope), false);
-  });
-
-  it("supports numeric comparison", () => {
-    assert.strictEqual(evaluateCondition("input.maxAttempts > 2", scope), true);
-    assert.strictEqual(evaluateCondition("input.maxAttempts > 5", scope), false);
-    assert.strictEqual(evaluateCondition("input.maxAttempts >= 3", scope), true);
-    assert.strictEqual(evaluateCondition("input.maxAttempts < 10", scope), true);
-    assert.strictEqual(evaluateCondition("input.maxAttempts <= 3", scope), true);
-  });
-
-  it("treats boolean false as falsy", () => {
-    const boolScope = { flag: false } as unknown as Record<string, unknown>;
-    assert.strictEqual(evaluateCondition("flag", boolScope), false);
-  });
-
-  it("supports != operator", () => {
-    assert.strictEqual(evaluateCondition("steps.diagnose.status != 'failed'", scope), true);
-    assert.strictEqual(evaluateCondition("steps.diagnose.status != 'completed'", scope), false);
-  });
-
-  it("supports comparison with boolean literal", () => {
-    const boolScope = { enabled: true } as unknown as Record<string, unknown>;
-    assert.strictEqual(evaluateCondition("enabled == true", boolScope), true);
-    assert.strictEqual(evaluateCondition("enabled == false", boolScope), false);
-  });
-});
-
-describe("resolveExpressions", () => {
-  it("resolves whole-value expression preserving type", () => {
-    const result = resolveExpressions("${{ steps.diagnose.output }}", scope);
-    assert.strictEqual(typeof result, "object");
-    assert.strictEqual((result as any).summary, "NPE in UserService.login()");
-  });
-
-  it("resolves whole-value expression preserving number", () => {
-    const result = resolveExpressions("${{ input.maxAttempts }}", scope);
-    assert.strictEqual(result, 3);
-  });
-
-  it("resolves whole-value expression preserving array", () => {
-    const result = resolveExpressions("${{ input.tags }}", scope);
-    assert.ok(Array.isArray(result));
-    assert.deepStrictEqual(result, ["auth", "critical"]);
-  });
-
-  it("resolves embedded expression as string interpolation", () => {
-    const result = resolveExpressions(
-      "Bug in ${{ steps.diagnose.output.fixLocation.file }} at line ${{ steps.diagnose.output.fixLocation.line }}",
-      scope,
-    );
-    assert.strictEqual(result, "Bug in src/auth/user-service.ts at line 47");
-  });
-
-  it("resolves object values recursively", () => {
-    const input = {
-      description: "${{ input.description }}",
-      diagnosis: "${{ steps.diagnose.output }}",
-      nested: {
-        file: "${{ steps.diagnose.output.fixLocation.file }}",
-        plain: "no expression here",
-      },
-    };
-    const result = resolveExpressions(input, scope) as any;
-    assert.strictEqual(result.description, "null pointer in login");
-    assert.strictEqual(typeof result.diagnosis, "object");
-    assert.strictEqual(result.nested.file, "src/auth/user-service.ts");
-    assert.strictEqual(result.nested.plain, "no expression here");
-  });
-
-  it("resolves array elements", () => {
-    const input = ["${{ input.description }}", "${{ input.maxAttempts }}"];
-    const result = resolveExpressions(input, scope) as unknown[];
-    assert.strictEqual(result[0], "null pointer in login");
-    assert.strictEqual(result[1], 3);
-  });
-
-  it("passes through non-string primitives", () => {
-    assert.strictEqual(resolveExpressions(42, scope), 42);
-    assert.strictEqual(resolveExpressions(true, scope), true);
-    assert.strictEqual(resolveExpressions(null, scope), null);
-  });
-
-  it("passes through strings with no expressions", () => {
-    assert.strictEqual(resolveExpressions("plain string", scope), "plain string");
-  });
-
-  it("handles whitespace in expressions", () => {
-    assert.strictEqual(
-      resolveExpressions("${{   input.description   }}", scope),
-      "null pointer in login",
-    );
-  });
-
-  it("renders undefined as empty string in embedded expressions", () => {
-    const result = resolveExpressions(
-      "Question: ${{ input.nonexistent }}",
-      scope,
-    );
-    assert.strictEqual(result, "Question: ");
-  });
-
-  it("resolves whole-value undefined for missing optional field", () => {
-    const result = resolveExpressions("${{ input.nonexistent }}", scope);
-    assert.strictEqual(result, undefined);
-  });
-
-  it("stringifies objects in embedded expressions", () => {
-    const result = resolveExpressions(
-      "Location: ${{ steps.diagnose.output.fixLocation }}",
-      scope,
-    );
-    assert.ok(typeof result === "string");
-    assert.ok((result as string).includes("src/auth/user-service.ts"));
-  });
-});