@davidorex/pi-workflows 0.2.0 → 0.3.0

package/src/step-transform.ts

@@ -1,47 +0,0 @@
-/**
- * Transform step executor — produces output by resolving expressions in a mapping.
- * No LLM call, no subprocess, no shell command — pure expression resolution.
- */
-import type { TransformSpec, StepResult } from "./types.ts";
-import { resolveExpressions } from "./expression.ts";
-import { zeroUsage } from "./step-shared.ts";
-import { persistStepOutput } from "./output.ts";
-
-/**
- * Execute a transform step: produces output by resolving expressions in the mapping.
- * No LLM call, no subprocess, no shell command — pure expression resolution.
- */
-export function executeTransform(
-  transform: TransformSpec,
-  stepName: string,
-  scope: Record<string, unknown>,
-  runDir?: string,
-  outputPath?: string,
-): StepResult {
-  const startTime = Date.now();
-  try {
-    const output = resolveExpressions(transform.mapping, scope);
-    const result: StepResult = {
-      step: stepName,
-      agent: "transform",
-      status: "completed",
-      output,
-      textOutput: JSON.stringify(output, null, 2),
-      usage: zeroUsage(),
-      durationMs: Date.now() - startTime,
-    };
-    if (runDir) {
-      result.outputPath = persistStepOutput(runDir, stepName, output, undefined, outputPath);
-    }
-    return result;
-  } catch (err) {
-    return {
-      step: stepName,
-      agent: "transform",
-      status: "failed",
-      usage: zeroUsage(),
-      durationMs: Date.now() - startTime,
-      error: err instanceof Error ? err.message : String(err),
-    };
-  }
-}

package/src/template-integration.test.ts

@@ -1,72 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { createTemplateEnv, renderTemplateFile } from "./template.ts";
-import path from "node:path";
-import fs from "node:fs";
-import os from "node:os";
-
-describe("analyzer template inheritance", () => {
-  const builtinDir = path.resolve(import.meta.dirname, "..", "templates");
-
-  it("structure analyzer inherits base and overrides blocks", () => {
-    const env = createTemplateEnv("/nonexistent", builtinDir);
-    const result = renderTemplateFile(env, "analyzers/structure.md", {});
-    assert.ok(result.includes("code structure analyst"));
-    assert.ok(result.includes("Architecture"));
-    assert.ok(result.includes("Module boundaries"));
-    assert.ok(!result.includes("Test coverage"));
-  });
-
-  it("quality analyzer inherits base and overrides blocks", () => {
-    const env = createTemplateEnv("/nonexistent", builtinDir);
-    const result = renderTemplateFile(env, "analyzers/quality.md", {});
-    assert.ok(result.includes("code quality analyst"));
-    assert.ok(result.includes("Test coverage"));
-    assert.ok(!result.includes("Architecture"));
-  });
-
-  it("pattern analyzer inherits base and overrides blocks", () => {
-    const env = createTemplateEnv("/nonexistent", builtinDir);
-    const result = renderTemplateFile(env, "analyzers/patterns.md", {});
-    assert.ok(result.includes("design pattern analyst"));
-    assert.ok(result.includes("Design patterns"));
-    assert.ok(result.includes("Anti-patterns"));
-  });
-
-  it("all three produce different output from the same base", () => {
-    const env = createTemplateEnv("/nonexistent", builtinDir);
-    const s = renderTemplateFile(env, "analyzers/structure.md", {});
-    const q = renderTemplateFile(env, "analyzers/quality.md", {});
-    const p = renderTemplateFile(env, "analyzers/patterns.md", {});
-    // All contain the shared preamble pattern
-    assert.ok(s.includes("Given an exploration summary"));
-    assert.ok(q.includes("Given an exploration summary"));
-    assert.ok(p.includes("Given an exploration summary"));
-    // But different identities
-    assert.ok(s.includes("structure"));
-    assert.ok(q.includes("quality"));
-    assert.ok(p.includes("pattern"));
-  });
-
-  it("project template shadows builtin", () => {
-    const tmpProject = fs.mkdtempSync(path.join(os.tmpdir(), "pi-tmpl-proj-"));
-    const projectTemplates = path.join(tmpProject, ".pi", "templates", "analyzers");
-    fs.mkdirSync(projectTemplates, { recursive: true });
-
-    fs.writeFileSync(path.join(projectTemplates, "structure.md"), [
-      '{% extends "analyzers/base-analyzer.md" %}',
-      "{% block identity %}You are a CUSTOM structure analyst.{% endblock %}",
-      "{% block checklist %}",
-      "1. **Custom**: Project-specific check",
-      "{% endblock %}",
-    ].join("\n"));
-
-    const env = createTemplateEnv(tmpProject, builtinDir);
-    const result = renderTemplateFile(env, "analyzers/structure.md", {});
-    assert.ok(result.includes("CUSTOM structure analyst"));
-    assert.ok(result.includes("Project-specific check"));
-    assert.ok(!result.includes("Module boundaries"));
-
-    fs.rmSync(tmpProject, { recursive: true });
-  });
-});

package/src/template.test.ts

@@ -1,162 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { createTemplateEnv, renderTemplate, renderTemplateFile } from "./template.ts";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-
-describe("renderTemplate", () => {
-  it("renders variable substitution", () => {
-    const env = createTemplateEnv("/nonexistent");
-    const result = renderTemplate(env, "Hello {{ name }}, you are {{ role }}", { name: "Alice", role: "analyst" });
-    assert.strictEqual(result, "Hello Alice, you are analyst");
-  });
-
-  it("passes through plain text unchanged", () => {
-    const env = createTemplateEnv("/nonexistent");
-    const result = renderTemplate(env, "No templates here. Just markdown.", {});
-    assert.strictEqual(result, "No templates here. Just markdown.");
-  });
-
-  it("renders if/else conditionals", () => {
-    const env = createTemplateEnv("/nonexistent");
-    const tmpl = "{% if verbose %}Detailed output{% else %}Brief output{% endif %}";
-    assert.strictEqual(renderTemplate(env, tmpl, { verbose: true }), "Detailed output");
-    assert.strictEqual(renderTemplate(env, tmpl, { verbose: false }), "Brief output");
-  });
-
-  it("renders for loops", () => {
-    const env = createTemplateEnv("/nonexistent");
-    const tmpl = "{% for item in items %}- {{ item }}\n{% endfor %}";
-    const result = renderTemplate(env, tmpl, { items: ["a", "b", "c"] });
-    assert.ok(result.includes("- a"));
-    assert.ok(result.includes("- b"));
-    assert.ok(result.includes("- c"));
-  });
-
-  it("handles undefined variables gracefully (empty string)", () => {
-    const env = createTemplateEnv("/nonexistent");
-    const result = renderTemplate(env, "Hello {{ name }}", {});
-    assert.strictEqual(result, "Hello ");
-  });
-
-  it("preserves ${{ }} workflow expressions (not interpreted)", () => {
-    const env = createTemplateEnv("/nonexistent");
-    const result = renderTemplate(env, "Use ${{ steps.explore.output }}", {});
-    assert.strictEqual(result, "Use ${{ steps.explore.output }}");
-  });
-
-  it("renders nested object access", () => {
-    const env = createTemplateEnv("/nonexistent");
-    const result = renderTemplate(env, "File: {{ context.file }}", { context: { file: "main.ts" } });
-    assert.strictEqual(result, "File: main.ts");
-  });
-});
-
-describe("renderTemplateFile", () => {
-  it("renders a template file from the search path", () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-tmpl-test-"));
-    fs.writeFileSync(path.join(tmpDir, "test.md"), "Hello {{ name }}");
-
-    const env = createTemplateEnv("/nonexistent", tmpDir);
-    const result = renderTemplateFile(env, "test.md", { name: "World" });
-    assert.strictEqual(result, "Hello World");
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it("supports {% extends %} inheritance", () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-tmpl-test-"));
-
-    fs.writeFileSync(path.join(tmpDir, "base.md"), [
-      "# {{ title }}",
-      "{% block intro %}Default intro{% endblock %}",
-      "{% block body %}Default body{% endblock %}",
-    ].join("\n"));
-
-    fs.writeFileSync(path.join(tmpDir, "child.md"), [
-      '{% extends "base.md" %}',
-      "{% block body %}Custom body for {{ focus }}{% endblock %}",
-    ].join("\n"));
-
-    const env = createTemplateEnv("/nonexistent", tmpDir);
-    const result = renderTemplateFile(env, "child.md", { title: "Report", focus: "security" });
-    assert.ok(result.includes("# Report"), "should render parent title");
-    assert.ok(result.includes("Default intro"), "should inherit intro block");
-    assert.ok(result.includes("Custom body for security"), "should override body block");
-    assert.ok(!result.includes("Default body"), "should NOT include default body");
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it("supports {% include %}", () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-tmpl-test-"));
-
-    fs.writeFileSync(path.join(tmpDir, "fragment.md"), "This is a reusable fragment.");
-    fs.writeFileSync(path.join(tmpDir, "main.md"), [
-      "# Main",
-      '{% include "fragment.md" %}',
-      "End.",
-    ].join("\n"));
-
-    const env = createTemplateEnv("/nonexistent", tmpDir);
-    const result = renderTemplateFile(env, "main.md", {});
-    assert.ok(result.includes("# Main"));
-    assert.ok(result.includes("This is a reusable fragment."));
-    assert.ok(result.includes("End."));
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it("supports {% macro %}", () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-tmpl-test-"));
-
-    fs.writeFileSync(path.join(tmpDir, "macros.md"), [
-      "{% macro greeting(name) %}Hello, {{ name }}!{% endmacro %}",
-    ].join("\n"));
-    fs.writeFileSync(path.join(tmpDir, "main.md"), [
-      '{% from "macros.md" import greeting %}',
-      "{{ greeting('Alice') }}",
-      "{{ greeting('Bob') }}",
-    ].join("\n"));
-
-    const env = createTemplateEnv("/nonexistent", tmpDir);
-    const result = renderTemplateFile(env, "main.md", {});
-    assert.ok(result.includes("Hello, Alice!"));
-    assert.ok(result.includes("Hello, Bob!"));
-
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  it("project templates shadow builtin templates", () => {
-    const builtinDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-tmpl-builtin-"));
-    const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-tmpl-project-"));
-
-    const projectTemplates = path.join(projectDir, ".pi", "templates");
-    fs.mkdirSync(projectTemplates, { recursive: true });
-
-    fs.writeFileSync(path.join(builtinDir, "shared.md"), "BUILTIN version");
-    fs.writeFileSync(path.join(projectTemplates, "shared.md"), "PROJECT version");
-
-    const env = createTemplateEnv(projectDir, builtinDir);
-    const result = renderTemplateFile(env, "shared.md", {});
-    assert.strictEqual(result, "PROJECT version");
-
-    fs.rmSync(builtinDir, { recursive: true });
-    fs.rmSync(projectDir, { recursive: true });
-  });
-});
-
-describe("createTemplateEnv", () => {
-  it("creates an environment that renders plain text unchanged", () => {
-    const env = createTemplateEnv("/nonexistent");
-    const result = renderTemplate(env, "Just plain text", {});
-    assert.strictEqual(result, "Just plain text");
-  });
-
-  it("works when no template directories exist", () => {
-    const env = createTemplateEnv("/definitely/does/not/exist");
-    const result = renderTemplate(env, "Still works: {{ x }}", { x: 42 });
-    assert.strictEqual(result, "Still works: 42");
-  });
-});

package/src/test-helpers.ts

@@ -1,51 +0,0 @@
-/**
- * Shared test helpers — mock factories for ctx, pi, and workflow specs.
- */
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import type { WorkflowSpec, StepSpec } from "./types.ts";
-
-/**
- * Create a mock extension context for testing.
- */
-export function mockCtx(cwd: string) {
-  return {
-    cwd,
-    hasUI: false,
-    ui: {
-      setWidget: () => {},
-      notify: () => {},
-      setStatus: () => {},
-    },
-  } as any;
-}
-
-/**
- * Create a mock pi API for testing.
- */
-export function mockPi() {
-  const messages: any[] = [];
-  return {
-    sendMessage: (msg: any, opts: any) => messages.push({ msg, opts }),
-    _messages: messages,
-  } as any;
-}
-
-/**
- * Create a minimal WorkflowSpec for testing.
- * A fresh temp directory is created for filePath.
- */
-export function makeSpec(
-  overrides: Partial<WorkflowSpec> & { steps: Record<string, StepSpec> },
-): WorkflowSpec {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-test-"));
-  return {
-    name: "test-workflow",
-    description: "Test workflow",
-    version: "1",
-    source: "project" as const,
-    filePath: path.join(tmpDir, "test.workflow.yaml"),
-    ...overrides,
-  };
-}

package/src/tui.test.ts

@@ -1,355 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import type { Theme } from "@mariozechner/pi-coding-agent";
-import type { TUI } from "@mariozechner/pi-tui";
-import { createProgressWidget, type ProgressWidgetState } from "./tui.ts";
-import type { WorkflowSpec, StepUsage } from "./types.ts";
-
-/**
- * Minimal Theme mock — passes through text unchanged so we can assert on content
- * without dealing with ANSI codes. Mocks exactly the methods tui.ts calls.
- */
-function mockTheme(): Theme {
-  return {
-    bold: (s: string) => s,
-    fg: (_color: string, s: string) => s,
-    dim: (s: string) => s,
-  } as unknown as Theme;
-}
-
-/**
- * Minimal TUI mock — just needs requestRender().
- */
-function mockTUI(): TUI {
-  return {
-    requestRender: () => {},
-  } as unknown as TUI;
-}
-
-function zeroUsage(): StepUsage {
-  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
-}
-
-function makeWidgetState(overrides: Partial<ProgressWidgetState> = {}): ProgressWidgetState {
-  const spec: WorkflowSpec = {
-    name: "test-workflow",
-    description: "test",
-    steps: {
-      explore: { agent: "explorer" },
-      analyze: { agent: "analyzer" },
-      report: { agent: "reporter" },
-    },
-    source: "project",
-    filePath: "/test.yaml",
-  };
-
-  return {
-    spec,
-    state: { input: {}, steps: {}, status: "running" },
-    startTime: Date.now(),
-    ...overrides,
-  };
-}
-
-describe("createProgressWidget", () => {
-  it("returns a factory function", () => {
-    const factory = createProgressWidget(makeWidgetState());
-    assert.strictEqual(typeof factory, "function");
-  });
-
-  it("factory creates a component with render and dispose", () => {
-    const factory = createProgressWidget(makeWidgetState());
-    const component = factory(mockTUI(), mockTheme());
-    assert.strictEqual(typeof component.render, "function");
-    assert.strictEqual(typeof component.dispose, "function");
-    component.dispose!();
-  });
-
-  it("renders header with workflow name and step count", () => {
-    const widgetState = makeWidgetState({ currentStep: "explore" });
-    const factory = createProgressWidget(widgetState);
-    const component = factory(mockTUI(), mockTheme());
-    const lines = component.render(120);
-    component.dispose!();
-
-    assert.ok(lines[0].includes("test-workflow"), "header should include workflow name");
-    assert.ok(lines[0].includes("1/3"), "header should show step 1/3");
-  });
-
-  it("renders pending steps with dot indicator", () => {
-    const widgetState = makeWidgetState();
-    const factory = createProgressWidget(widgetState);
-    const component = factory(mockTUI(), mockTheme());
-    const lines = component.render(120);
-    component.dispose!();
-
-    assert.ok(lines.some(l => l.includes("·") && l.includes("explore")));
-    assert.ok(lines.some(l => l.includes("·") && l.includes("analyze")));
-    assert.ok(lines.some(l => l.includes("·") && l.includes("report")));
-  });
-
-  it("renders running step with triangle indicator", () => {
-    const widgetState = makeWidgetState({ currentStep: "analyze" });
-    const factory = createProgressWidget(widgetState);
-    const component = factory(mockTUI(), mockTheme());
-    const lines = component.render(120);
-    component.dispose!();
-
-    assert.ok(lines.some(l => l.includes("▸") && l.includes("analyze")));
-  });
-
-  it("renders completed step with checkmark, duration, cost, tokens", () => {
-    const widgetState = makeWidgetState({ currentStep: "analyze" });
-    widgetState.state.steps.explore = {
-      step: "explore",
-      agent: "explorer",
-      status: "completed",
-      usage: { input: 5000, output: 2000, cacheRead: 0, cacheWrite: 0, cost: 0.03, turns: 1 },
-      durationMs: 42000,
-    };
-    const factory = createProgressWidget(widgetState);
-    const component = factory(mockTUI(), mockTheme());
-    const lines = component.render(120);
-    component.dispose!();
-
-    const exploreLine = lines.find(l => l.includes("explore"));
-    assert.ok(exploreLine, "should have explore line");
-    assert.ok(exploreLine.includes("✓"), "completed should have checkmark");
-    assert.ok(exploreLine.includes("42s"), "should show duration");
-    assert.ok(exploreLine.includes("$0.03"), "should show cost");
-    assert.ok(exploreLine.includes("7.0k tok"), "should show token count");
-  });
-
-  it("renders failed step with X indicator and error", () => {
-    const widgetState = makeWidgetState();
-    widgetState.state.steps.explore = {
-      step: "explore",
-      agent: "explorer",
-      status: "failed",
-      usage: zeroUsage(),
-      durationMs: 5000,
-      error: "Agent crashed",
-    };
-    const factory = createProgressWidget(widgetState);
-    const component = factory(mockTUI(), mockTheme());
-    const lines = component.render(120);
-    component.dispose!();
-
-    const exploreLine = lines.find(l => l.includes("explore"));
-    assert.ok(exploreLine, "should have explore line");
-    assert.ok(exploreLine.includes("✗"), "failed should have X");
-    assert.ok(exploreLine.includes("Agent crashed"), "should show error");
-  });
-
-  it("renders skipped step with circle indicator", () => {
-    const widgetState = makeWidgetState();
-    widgetState.state.steps.explore = {
-      step: "explore",
-      agent: "skipped",
-      status: "skipped",
-      usage: zeroUsage(),
-      durationMs: 0,
-    };
-    const factory = createProgressWidget(widgetState);
-    const component = factory(mockTUI(), mockTheme());
-    const lines = component.render(120);
-    component.dispose!();
-
-    const exploreLine = lines.find(l => l.includes("explore"));
-    assert.ok(exploreLine, "should have explore line");
-    assert.ok(exploreLine.includes("⊘"), "skipped should have ⊘");
-    assert.ok(exploreLine.includes("[skipped]"), "should show [skipped] tag");
-  });
-
-  it("renders gate step with [gate] tag", () => {
-    const widgetState = makeWidgetState();
-    widgetState.state.steps.explore = {
-      step: "explore",
-      agent: "gate",
-      status: "completed",
-      output: { passed: true, exitCode: 0, output: "ok" },
-      usage: zeroUsage(),
-      durationMs: 100,
-    };
-    const factory = createProgressWidget(widgetState);
-    const component = factory(mockTUI(), mockTheme());
-    const lines = component.render(120);
-    component.dispose!();
-
-    const exploreLine = lines.find(l => l.includes("explore"));
-    assert.ok(exploreLine?.includes("[gate]"), "gate step should show [gate] tag");
-  });
-
-  it("renders transform step with [transform] tag", () => {
-    const widgetState = makeWidgetState();
-    widgetState.state.steps.explore = {
-      step: "explore",
-      agent: "transform",
-      status: "completed",
-      output: { merged: true },
-      usage: zeroUsage(),
-      durationMs: 1,
-    };
-    const factory = createProgressWidget(widgetState);
-    const component = factory(mockTUI(), mockTheme());
-    const lines = component.render(120);
-    component.dispose!();
-
-    const exploreLine = lines.find(l => l.includes("explore"));
-    assert.ok(exploreLine?.includes("[transform]"), "transform step should show [transform] tag");
-  });
-
-  it("shows parallel count in header for multiple concurrent steps", () => {
-    const widgetState = makeWidgetState({ currentStep: "explore, analyze" });
-    const factory = createProgressWidget(widgetState);
-    const component = factory(mockTUI(), mockTheme());
-    const lines = component.render(120);
-    component.dispose!();
-
-    assert.ok(lines[0].includes("[2 parallel]"), "header should show parallel count");
-  });
-
-  it("shows multiple running indicators for parallel steps", () => {
-    const widgetState = makeWidgetState({ currentStep: "explore, analyze" });
-    const factory = createProgressWidget(widgetState);
-    const component = factory(mockTUI(), mockTheme());
-    const lines = component.render(120);
-    component.dispose!();
-
-    const runningLines = lines.filter(l => l.includes("▸"));
-    assert.strictEqual(runningLines.length, 2, "should have 2 running step indicators");
-  });
-
-  it("renders correct number of lines (header + one per step)", () => {
-    const widgetState = makeWidgetState();
-    const factory = createProgressWidget(widgetState);
-    const component = factory(mockTUI(), mockTheme());
-    const lines = component.render(120);
-    component.dispose!();
-
-    // 1 header + 3 steps = 4 lines
-    assert.strictEqual(lines.length, 4);
-  });
-
-  it("truncates lines to width", () => {
-    const widgetState = makeWidgetState({ currentStep: "explore" });
-    const factory = createProgressWidget(widgetState);
-    const component = factory(mockTUI(), mockTheme());
-    const lines = component.render(20);
-    component.dispose!();
-
-    for (const line of lines) {
-      assert.ok(line.length <= 20, `line exceeds width: "${line}" (${line.length})`);
-    }
-  });
-
-  it("renders resumed indicator when resumedSteps is set", () => {
-    const widgetState = makeWidgetState({ resumedSteps: 3, currentStep: "report" });
-    widgetState.state.steps.explore = {
-      step: "explore",
-      agent: "explorer",
-      status: "completed",
-      usage: zeroUsage(),
-      durationMs: 10000,
-    };
-    widgetState.state.steps.analyze = {
-      step: "analyze",
-      agent: "analyzer",
-      status: "completed",
-      usage: zeroUsage(),
-      durationMs: 20000,
-    };
-    const factory = createProgressWidget(widgetState);
-    const component = factory(mockTUI(), mockTheme());
-    const lines = component.render(120);
-    component.dispose!();
-
-    const resumedLine = lines.find(l => l.includes("Resumed"));
-    assert.ok(resumedLine, "should have a resumed indicator line");
-    assert.ok(resumedLine.includes("↻"), "should have ↻ symbol");
-    assert.ok(resumedLine.includes("3 steps from prior run"), "should show step count");
-    // Header + resumed line + 3 steps = 5 lines
-    assert.strictEqual(lines.length, 5);
-  });
-
-  it("renders paused indicator when state status is paused", () => {
-    const widgetState = makeWidgetState();
-    widgetState.state.status = "paused";
-    widgetState.state.steps.explore = {
-      step: "explore",
-      agent: "explorer",
-      status: "completed",
-      usage: zeroUsage(),
-      durationMs: 10000,
-    };
-    const factory = createProgressWidget(widgetState);
-    const component = factory(mockTUI(), mockTheme());
-    const lines = component.render(120);
-    component.dispose!();
-
-    const pausedLine = lines.find(l => l.includes("Paused"));
-    assert.ok(pausedLine, "should have a paused indicator line");
-    assert.ok(pausedLine.includes("⏸"), "should have ⏸ symbol");
-  });
-
-  it("does not render resumed indicator when resumedSteps is not set", () => {
-    const widgetState = makeWidgetState();
-    const factory = createProgressWidget(widgetState);
-    const component = factory(mockTUI(), mockTheme());
-    const lines = component.render(120);
-    component.dispose!();
-
-    assert.ok(!lines.some(l => l.includes("Resumed")), "should not have resumed indicator");
-  });
-
-  it("shows [truncated] indicator for truncated step", () => {
-    const widgetState = makeWidgetState({ currentStep: "analyze" });
-    widgetState.state.steps.explore = {
-      step: "explore",
-      agent: "explorer",
-      status: "completed",
-      usage: { input: 1000, output: 500, cacheRead: 0, cacheWrite: 0, cost: 0.01, turns: 1 },
-      durationMs: 5000,
-      truncated: true,
-      warnings: ["Stdout exceeded 10MB limit"],
-    };
-    const factory = createProgressWidget(widgetState);
-    const component = factory(mockTUI(), mockTheme());
-    const lines = component.render(120);
-    component.dispose!();
-
-    // Find the explore line and verify it contains a truncated indicator
-    const exploreLine = lines.find(l => l.includes("explore"));
-    assert.ok(exploreLine, "explore line should exist");
-    assert.ok(exploreLine.includes("truncated"), "Truncated step should show [truncated] indicator");
-  });
-
-  it("does not show [truncated] indicator for non-truncated step", () => {
-    const widgetState = makeWidgetState({ currentStep: "analyze" });
-    widgetState.state.steps.explore = {
-      step: "explore",
-      agent: "explorer",
-      status: "completed",
-      usage: { input: 1000, output: 500, cacheRead: 0, cacheWrite: 0, cost: 0.01, turns: 1 },
-      durationMs: 5000,
-    };
-    const factory = createProgressWidget(widgetState);
-    const component = factory(mockTUI(), mockTheme());
-    const lines = component.render(120);
-    component.dispose!();
-
-    const exploreLine = lines.find(l => l.includes("explore"));
-    assert.ok(exploreLine, "explore line should exist");
-    assert.ok(!exploreLine.includes("truncated"), "Non-truncated step should not show [truncated]");
-  });
-
-  it("dispose clears the pulse interval", () => {
-    const widgetState = makeWidgetState();
-    const factory = createProgressWidget(widgetState);
-    const component = factory(mockTUI(), mockTheme());
-
-    // Should not throw; if dispose didn't clear the interval,
-    // the test process would hang (node:test waits for timers to drain)
-    component.dispose!();
-  });
-});