@fitchmultz/pi-subagents 0.44.7 → 0.45.0

package/dist/runs/foreground/clarification-draft.js

@@ -0,0 +1,87 @@
+/** Owns replace-only preview values and downstream output/read dependencies. */
+function resolveList(value) {
+    return value === false ? false : [...value];
+}
+export class ClarificationDraft {
+    templateValues;
+    get templates() {
+        return this.templateValues;
+    }
+    behaviors;
+    overrides = new Map();
+    constructor(templates, behaviors) {
+        this.templateValues = [...templates];
+        this.behaviors = behaviors;
+    }
+    behavior(index) {
+        const base = this.behaviors.at(index);
+        if (!base) {
+            throw new Error(`Missing clarification behavior for step ${index}.`);
+        }
+        const override = this.overrides.get(index);
+        return {
+            ...base,
+            ...override,
+            reads: resolveList(override?.reads ?? base.reads),
+            skills: resolveList(override?.skills ?? base.skills),
+        };
+    }
+    override(index) {
+        return this.overrides.get(index);
+    }
+    update(index, override) {
+        this.overrides.set(index, { ...this.overrides.get(index), ...override });
+    }
+    toggleProgress() {
+        const enabled = this.behaviors.some((_, index) => this.behavior(index).progress);
+        this.behaviors.forEach((_, index) => {
+            this.update(index, { progress: !enabled });
+        });
+    }
+    save(index, field, text) {
+        if (field === "template") {
+            const lines = (this.templateValues[index] ?? "").split("\n");
+            lines[0] = text;
+            this.templateValues[index] = lines.join("\n");
+            return;
+        }
+        if (field === "reads") {
+            const reads = text
+                .trim()
+                .split(",")
+                .map((file) => file.trim())
+                .filter((file) => file.length > 0);
+            this.update(index, { reads: reads.length > 0 ? reads : false });
+            return;
+        }
+        if (field === "output") {
+            this.saveOutput(index, text.trim());
+        }
+    }
+    saveOutput(index, text) {
+        const previous = this.behavior(index).output;
+        const output = text.length === 0 ? false : text;
+        this.update(index, { output });
+        if (typeof previous === "string" &&
+            previous.length > 0 &&
+            typeof output === "string" &&
+            previous !== output) {
+            this.propagateOutput(index, previous, output);
+        }
+    }
+    propagateOutput(index, previous, output) {
+        for (let next = index + 1; next < this.behaviors.length; next++) {
+            const reads = this.behavior(next).reads;
+            if (reads === false) {
+                continue;
+            }
+            const found = reads.indexOf(previous);
+            if (found < 0) {
+                continue;
+            }
+            const updated = [...reads];
+            updated[found] = output;
+            this.update(next, { reads: updated });
+        }
+    }
+}

package/dist/runs/foreground/clarify-contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/runs/foreground/clarify-invocation.js

@@ -1,30 +1,106 @@
 import { discoverAvailableSkills, normalizeSkillInput } from "../../agents/skills.js";
 import { validateForkContextModelPolicy } from "../../shared/agent-context-policy.js";
 import { toModelInfo } from "../../shared/model-info.js";
-import { createChainDir, isDynamicParallelStep, isParallelStep, removeChainDir, resolveChainTemplates, resolveStepBehavior } from "../../shared/settings.js";
+import { createChainDir, isDynamicParallelStep, isParallelStep, removeChainDir, resolveChainTemplates, resolveStepBehavior, } from "../../shared/settings.js";
 import { resolveModelCandidate } from "../shared/model-fallback.js";
 import { normalizeSingleOutputOverride } from "../shared/single-output.js";
 import { ChainClarifyComponent } from "./chain-clarify.js";
+function previewSteps(params) {
+    if (params.chain) {
+        return params.chain.map((step) => {
+            if (isParallelStep(step) || isDynamicParallelStep(step)) {
+                throw new Error("Parallel groups cannot use the sequential preview.");
+            }
+            return step;
+        });
+    }
+    if (params.tasks) {
+        return params.tasks;
+    }
+    if (params.agent === undefined) {
+        throw new Error("Clarification requires an agent.");
+    }
+    return [{ ...params, agent: params.agent }];
+}
+function applyPreview(step, result, index) {
+    const override = result.behaviorOverrides[index];
+    const updated = { ...step, task: result.templates[index] ?? "" };
+    return Object.assign(updated, overrideFields(override));
+}
+function overrideFields(override) {
+    if (!override) {
+        return {};
+    }
+    return {
+        ...(override.model !== undefined && override.model.length > 0 ? { model: override.model } : {}),
+        ...(override.output !== undefined ? { output: override.output } : {}),
+        ...(override.reads !== undefined
+            ? { reads: override.reads === false ? false : [...override.reads] }
+            : {}),
+        ...(override.progress !== undefined ? { progress: override.progress } : {}),
+        ...(override.skills !== undefined
+            ? { skill: override.skills === false ? false : [...override.skills] }
+            : {}),
+    };
+}
+function applyInvocationPreview(params, result) {
+    const updated = previewSteps(params).map((step, index) => applyPreview(step, result, index));
+    const confirmed = { clarify: false, async: result.runInBackground === true };
+    if (params.chain) {
+        return { ...params, chain: updated.map(toSequentialStep), ...confirmed };
+    }
+    if (params.tasks) {
+        return {
+            ...params,
+            tasks: updated.map((step) => ({ ...step, task: step.task ?? "" })),
+            ...confirmed,
+        };
+    }
+    return { ...params, ...updated[0], ...confirmed };
+}
 /** Preview changes launch input only; waiting and background runs share the same owner. */
-export async function clarifyInvocation(input) {
-    const { params, agents, ctx, cwd, runId } = input;
-    if (params.clarify !== true || !ctx.hasUI)
-        return params;
-    if (params.chain?.some((step) => isParallelStep(step) || isDynamicParallelStep(step)))
-        return params;
-    const mode = params.chain ? "chain" : params.tasks ? "parallel" : "single";
-    const steps = params.chain ?? params.tasks ?? [{ ...params, agent: params.agent, reads: undefined }];
+function toSequentialStep(step) {
+    return {
+        ...step,
+        output: step.output === true ? undefined : step.output,
+        reads: step.reads === true ? undefined : step.reads,
+        skill: step.skill === true ? undefined : step.skill,
+    };
+}
+function sequentialTemplates(params, steps) {
+    if (!params.chain) {
+        return steps.map((step) => step.task ?? "");
+    }
+    return resolveChainTemplates(params.chain).map((template) => {
+        if (typeof template !== "string") {
+            throw new Error("Sequential preview received parallel templates.");
+        }
+        return template;
+    });
+}
+function preparePreview(params, agents) {
+    const steps = previewSteps(params);
     const profiles = steps.map((step) => {
         const profile = agents.find((agent) => agent.name === step.agent);
-        if (!profile)
+        if (!profile) {
             throw new Error(`Unknown agent: ${step.agent}`);
+        }
         return profile;
     });
-    const templates = params.chain ? resolveChainTemplates(params.chain) : steps.map((step) => step.task ?? "");
-    const originalTask = params.task ?? (mode === "chain" ? templates[0] ?? "" : "");
-    const chainSkills = mode === "chain" ? normalizeSkillInput(params.skill) ?? [] : [];
-    const behaviors = profiles.map((profile, index) => {
-        const step = steps[index];
+    let mode = "single";
+    if (params.chain) {
+        mode = "chain";
+    }
+    else if (params.tasks) {
+        mode = "parallel";
+    }
+    const templates = sequentialTemplates(params, steps);
+    const chainSkills = mode === "chain" ? (normalizeSkillInput(params.skill) ?? []) : [];
+    const behaviors = steps.map((step, index) => {
+        const profile = profiles.at(index);
+        if (!profile) {
+            throw new Error(`Missing profile for clarification step ${index}.`);
+        }
         return resolveStepBehavior(profile, {
             output: normalizeSingleOutputOverride(step.output, profile.output),
             outputMode: step.outputMode,
@@ -34,39 +110,54 @@ export async function clarifyInvocation(input) {
             model: step.model,
         }, chainSkills);
     });
+    return {
+        mode,
+        profiles,
+        templates,
+        behaviors,
+        originalTask: params.task ?? (mode === "chain" ? (templates[0] ?? "") : ""),
+    };
+}
+export function canClarifyInvocation(params, ctx) {
+    return (params.clarify === true &&
+        ctx.hasUI &&
+        ctx.mode === "tui" &&
+        params.chain?.some((step) => isParallelStep(step) || isDynamicParallelStep(step)) !== true);
+}
+export async function clarifyInvocation(input) {
+    const { params, agents, ctx, cwd, runId } = input;
+    if (!canClarifyInvocation(params, ctx)) {
+        return params;
+    }
+    const preview = preparePreview(params, agents);
     const models = ctx.modelRegistry.getAvailable().map(toModelInfo);
     const skills = discoverAvailableSkills(cwd, { projectTrusted: ctx.isProjectTrusted() });
-    const chainDir = mode === "chain" ? createChainDir(runId, params.chainDir, cwd) : undefined;
+    const chainDir = preview.mode === "chain" ? createChainDir(runId, params.chainDir, cwd) : undefined;
     let confirmed = false;
     try {
-        const result = await ctx.ui.custom((tui, theme, _kb, done) => new ChainClarifyComponent(tui, theme, profiles, templates, originalTask, chainDir, behaviors, models, ctx.model?.provider, skills, done, mode), { overlay: true, overlayOptions: { anchor: "center", width: 84, maxHeight: "80%" } });
-        if (!result?.confirmed)
-            return undefined;
-        const updated = steps.map((step, index) => {
-            const override = result.behaviorOverrides[index];
-            return {
-                ...step, task: result.templates[index],
-                ...(override?.model ? { model: override.model } : {}),
-                ...(override?.output !== undefined ? { output: override.output } : {}),
-                ...(override?.reads !== undefined ? { reads: override.reads } : {}),
-                ...(override?.progress !== undefined ? { progress: override.progress } : {}),
-                ...(override?.skills !== undefined ? { skill: override.skills } : {}),
-            };
-        });
-        const next = {
-            ...params,
-            ...(mode === "chain" ? { chain: updated }
-                : mode === "parallel" ? { tasks: updated } : updated[0]),
-            clarify: false, async: result.runInBackground === true,
-        };
+        const result = await ctx.ui.custom((tui, theme, _kb, done) => new ChainClarifyComponent(tui, theme, {
+            ...preview,
+            agentConfigs: preview.profiles,
+            chainDir,
+            resolvedBehaviors: preview.behaviors,
+            availableModels: models,
+            preferredProvider: ctx.model?.provider,
+            availableSkills: skills,
+        }, done), { overlay: true, overlayOptions: { anchor: "center", width: 84, maxHeight: "80%" } });
+        if (!result.confirmed) {
+            return;
+        }
+        const next = applyInvocationPreview(params, result);
         const error = validateForkContextModelPolicy(next, agents, (model) => resolveModelCandidate(model, models, ctx.model?.provider));
-        if (error)
+        if (error !== undefined && error.length > 0) {
             throw new Error(error);
+        }
         confirmed = true;
         return next;
     }
     finally {
-        if (!confirmed && chainDir)
+        if (!confirmed && chainDir !== undefined && chainDir.length > 0) {
             removeChainDir(chainDir);
+        }
     }
 }

package/dist/runs/foreground/clarify-text-editor.js

@@ -0,0 +1,210 @@
+import { matchesKey, visibleWidth } from "@earendil-works/pi-tui";
+function wrapSegment(segment, width) {
+    const lines = [], starts = [];
+    let start = 0, offset = 0, columns = 0;
+    for (const char of segment) {
+        const charWidth = visibleWidth(char);
+        if (columns > 0 && columns + charWidth > width) {
+            lines.push(segment.slice(start, offset));
+            starts.push(start);
+            start = offset;
+            columns = 0;
+        }
+        offset += char.length;
+        columns += charWidth;
+    }
+    lines.push(segment.slice(start));
+    starts.push(start);
+    return { lines, starts };
+}
+function wrapText(text, width) {
+    if (width <= 0) {
+        return { lines: [text], starts: [0] };
+    }
+    const lines = [], starts = [];
+    let offset = 0;
+    for (const segment of text.split("\n")) {
+        const wrapped = wrapSegment(segment, width);
+        lines.push(...wrapped.lines);
+        starts.push(...wrapped.starts.map((start) => start + offset));
+        offset += segment.length + 1;
+    }
+    if (!text.endsWith("\n") && text.length > 0 && visibleWidth(lines.at(-1) ?? "") === width) {
+        starts.push(text.length);
+        lines.push("");
+    }
+    return { lines, starts };
+}
+function cursorPosition(cursor, starts) {
+    const line = Math.max(0, starts.findLastIndex((start) => cursor >= start));
+    return { line, col: cursor - (starts[line] ?? 0) };
+}
+function isWordChar(char) {
+    return /[A-Za-z0-9_]/.test(char);
+}
+function wordBackward(buffer, cursor) {
+    let position = cursor;
+    while (position > 0 && !isWordChar(buffer[position - 1] ?? "")) {
+        position--;
+    }
+    while (position > 0 && isWordChar(buffer[position - 1] ?? "")) {
+        position--;
+    }
+    return position;
+}
+function wordForward(buffer, cursor) {
+    let position = cursor;
+    while (position < buffer.length && isWordChar(buffer[position] ?? "")) {
+        position++;
+    }
+    while (position < buffer.length && !isWordChar(buffer[position] ?? "")) {
+        position++;
+    }
+    return position;
+}
+function insertText(data) {
+    const text = data
+        .split("\x1b[200~")
+        .join("")
+        .split("\x1b[201~")
+        .join("")
+        .replace(/\r\n?/g, "\n")
+        .split("\n")[0]
+        ?.replace(/\t/g, "    ") ?? "";
+    if (text.length === 0 || Array.from(text).some((char) => char.charCodeAt(0) < 32)) {
+        return;
+    }
+    return text;
+}
+/** Owns the single-line draft and its viewport; the caller decides commit versus discard. */
+export class ClarifyTextEditor {
+    buffer = "";
+    cursor = 0;
+    viewportOffset = 0;
+    setText(text) {
+        this.buffer = text;
+        this.cursor = 0;
+        this.viewportOffset = 0;
+    }
+    getText() {
+        return this.buffer;
+    }
+    handleInput(data, width) {
+        if (matchesKey(data, "return") || matchesKey(data, "tab")) {
+            return;
+        }
+        if (this.moveCursor(data, width) || this.deleteText(data)) {
+            return;
+        }
+        const text = insertText(data);
+        if (text !== undefined) {
+            this.buffer = this.buffer.slice(0, this.cursor) + text + this.buffer.slice(this.cursor);
+            this.cursor += text.length;
+        }
+    }
+    moveCursor(data, width) {
+        if (matchesKey(data, "alt+left") || matchesKey(data, "ctrl+left")) {
+            this.cursor = wordBackward(this.buffer, this.cursor);
+            return true;
+        }
+        if (matchesKey(data, "alt+right") || matchesKey(data, "ctrl+right")) {
+            this.cursor = wordForward(this.buffer, this.cursor);
+            return true;
+        }
+        if (matchesKey(data, "left")) {
+            this.cursor = Math.max(0, this.cursor - 1);
+            return true;
+        }
+        if (matchesKey(data, "right")) {
+            this.cursor = Math.min(this.buffer.length, this.cursor + 1);
+            return true;
+        }
+        if (matchesKey(data, "ctrl+home")) {
+            this.cursor = 0;
+            return true;
+        }
+        if (matchesKey(data, "ctrl+end")) {
+            this.cursor = this.buffer.length;
+            return true;
+        }
+        return this.moveVisualCursor(data, width);
+    }
+    moveVisualCursor(data, width) {
+        const { lines, starts } = wrapText(this.buffer, width);
+        const position = cursorPosition(this.cursor, starts);
+        if (matchesKey(data, "home")) {
+            this.cursor = starts[position.line] ?? 0;
+            return true;
+        }
+        if (matchesKey(data, "end")) {
+            this.cursor = (starts[position.line] ?? 0) + (lines[position.line]?.length ?? 0);
+            return true;
+        }
+        const delta = verticalDelta(data);
+        if (delta === 0) {
+            return false;
+        }
+        const line = Math.max(0, Math.min(lines.length - 1, position.line + delta));
+        this.cursor = visualCursor(line, position.col, { lines, starts });
+        return true;
+    }
+    deleteText(data) {
+        if (matchesKey(data, "alt+backspace")) {
+            const target = wordBackward(this.buffer, this.cursor);
+            this.buffer = this.buffer.slice(0, target) + this.buffer.slice(this.cursor);
+            this.cursor = target;
+            return true;
+        }
+        if (matchesKey(data, "backspace")) {
+            if (this.cursor > 0) {
+                this.buffer = this.buffer.slice(0, this.cursor - 1) + this.buffer.slice(this.cursor);
+                this.cursor--;
+            }
+            return true;
+        }
+        if (matchesKey(data, "delete")) {
+            this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.slice(this.cursor + 1);
+            return true;
+        }
+        return false;
+    }
+    render(width, height) {
+        const { lines, starts } = wrapText(this.buffer, width);
+        const position = cursorPosition(this.cursor, starts);
+        if (position.line < this.viewportOffset) {
+            this.viewportOffset = position.line;
+        }
+        if (position.line >= this.viewportOffset + height) {
+            this.viewportOffset = Math.max(0, position.line - height + 1);
+        }
+        const rendered = Array.from({ length: height }, (_, index) => {
+            const line = this.viewportOffset + index;
+            const text = lines[line] ?? "";
+            if (line !== position.line) {
+                return text;
+            }
+            return `${text.slice(0, position.col)}\x1b[7m${text[position.col] ?? " "}\x1b[27m${text.slice(position.col + 1)}`;
+        });
+        const below = lines.length - this.viewportOffset - height;
+        const scrollInfo = `${this.viewportOffset > 0 ? "↑" : ""}${below > 0 ? `↓ ${below}+` : ""}`;
+        return { lines: rendered, scrollInfo };
+    }
+}
+function visualCursor(line, column, wrapped) {
+    return (wrapped.starts[line] ?? 0) + Math.min(column, wrapped.lines[line]?.length ?? 0);
+}
+function verticalDelta(data) {
+    if (matchesKey(data, "up")) {
+        return -1;
+    }
+    if (matchesKey(data, "down")) {
+        return 1;
+    }
+    if (matchesKey(data, "shift+up") || matchesKey(data, "pageUp")) {
+        return -12;
+    }
+    if (matchesKey(data, "shift+down") || matchesKey(data, "pageDown")) {
+        return 12;
+    }
+    return 0;
+}

package/dist/runs/foreground/clarify-view.js

@@ -0,0 +1,167 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+/** Stateless presentation of clarification snapshots; it cannot change draft or launch state. */
+export class ClarifyView {
+    theme;
+    width;
+    constructor(theme, width) {
+        this.theme = theme;
+        this.width = width;
+    }
+    row(content) {
+        const inner = this.width - 2;
+        const clipped = truncateToWidth(content, inner, "…", true);
+        return (this.theme.fg("border", "│") +
+            clipped +
+            " ".repeat(Math.max(0, inner - visibleWidth(clipped))) +
+            this.theme.fg("border", "│"));
+    }
+    border(text, footer = false) {
+        const inner = this.width - 2;
+        const clipped = truncateToWidth(` ${text} `, inner, "", true);
+        const padding = Math.max(0, inner - visibleWidth(clipped));
+        const left = Math.floor(padding / 2);
+        return (this.theme.fg("border", `${footer ? "╰" : "╭"}${"─".repeat(left)}`) +
+            this.theme.fg(footer ? "dim" : "accent", clipped) +
+            this.theme.fg("border", `${"─".repeat(padding - left)}${footer ? "╯" : "╮"}`));
+    }
+    editor(title, preview) {
+        const footer = preview.scrollInfo.length > 0
+            ? `[Esc] Done • [Ctrl+C] Discard • ${preview.scrollInfo}`
+            : "[Esc] Done • [Ctrl+C] Discard";
+        return [
+            this.border(title),
+            this.row(""),
+            ...preview.lines.map((line) => this.row(` ${line}`)),
+            this.row(""),
+            this.border(footer, true),
+        ];
+    }
+    selector(input) {
+        const lines = [
+            this.border(input.title),
+            ...input.subtitles.map((line) => this.row(` ${line}`)),
+            this.row(""),
+            ...this.choices(input.choices, input.selected),
+        ];
+        const height = input.targetHeight ?? 18;
+        while (lines.length < height) {
+            lines.push(this.row(""));
+        }
+        lines.push(this.border(input.footer, true));
+        return lines;
+    }
+    thinking(input) {
+        const descriptions = {
+            off: "No extended thinking",
+            minimal: "Brief reasoning",
+            low: "Light reasoning",
+            medium: "Moderate reasoning",
+            high: "Deep reasoning",
+            xhigh: "Extra-high reasoning (ultrathink)",
+            max: "Maximum reasoning",
+        };
+        return this.selector({
+            title: `Thinking Level (${input.step})`,
+            subtitles: [`Model: ${input.model}`],
+            choices: input.levels.map((level) => `${level} - ${descriptions[level]}`),
+            selected: input.selected,
+            footer: "[Enter] Select • [Esc] Cancel • ↑↓ Navigate",
+            targetHeight: 16,
+        });
+    }
+    choices(choices, selected) {
+        if (choices.length === 0) {
+            return [this.row(" No matching choices")];
+        }
+        const start = Math.min(Math.max(0, selected - 5), Math.max(0, choices.length - 10));
+        const lines = [];
+        if (start > 0) {
+            lines.push(this.row(`   ↑ ${start} more`));
+        }
+        choices.slice(start, start + 10).forEach((choice, index) => {
+            const active = start + index === selected;
+            lines.push(this.row(` ${active ? "→ " : "  "}${this.theme.fg(active ? "accent" : "text", choice)}`));
+        });
+        const remaining = choices.length - start - 10;
+        if (remaining > 0) {
+            lines.push(this.row(`   ↓ ${remaining} more`));
+        }
+        return lines;
+    }
+    overview(input) {
+        const lines = [this.border(this.title(input)), this.row("")];
+        if (input.mode === "chain") {
+            lines.push(this.row(` Original Task: ${input.originalTask}`), this.row(` Chain Dir: ${input.chainDir ?? ""}`), this.row(` Progress: ${input.progress ? "enabled" : "disabled"} (press [p] to toggle)`), this.row(""));
+        }
+        input.steps.forEach((step, index) => {
+            lines.push(...this.step(step, index, input));
+        });
+        if (input.notice !== undefined) {
+            lines.push(this.row(` ${this.theme.fg("success", input.notice)}`));
+        }
+        const fields = this.shortcuts(input.mode);
+        const navigation = input.mode === "single" ? "" : " • ↑↓ Nav";
+        lines.push(this.border(`[Enter] Run • [Esc] Cancel • ${fields} [b]g${input.background ? ":ON" : ""}${navigation}`, true));
+        return lines;
+    }
+    title(input) {
+        if (input.mode === "parallel") {
+            return `Parallel Tasks (${input.steps.length})`;
+        }
+        const label = input.mode === "single" ? "Agent" : "Chain";
+        return `${label}: ${input.steps.map((step) => step.name).join(" → ")}`;
+    }
+    shortcuts(mode) {
+        if (mode === "chain") {
+            return "e m t w r p s";
+        }
+        return mode === "single" ? "e m t w s" : "e m t s";
+    }
+    stepHeading(label, active) {
+        return this.theme.fg(active ? "accent" : "dim", `${active ? "▶ " : "  "}${label}`);
+    }
+    step(step, index, input) {
+        const heading = this.stepHeading(step.label, index === input.selected);
+        const task = input.mode === "chain"
+            ? step.template
+                .replace(/\{task\}/g, this.theme.fg("success", "{task}"))
+                .replace(/\{previous\}/g, this.theme.fg("warning", "{previous}"))
+                .replace(/\{chain_dir\}/g, this.theme.fg("accent", "{chain_dir}"))
+            : step.template;
+        const model = step.modelOverridden
+            ? this.theme.fg("warning", step.model) + this.theme.fg("dim", " ✎")
+            : step.model;
+        const lines = [
+            this.row(` ${heading}`),
+            this.row(`     task: ${task}`),
+            this.row(`     model: ${model}`),
+        ];
+        if (input.mode !== "parallel") {
+            lines.push(this.row(`     writes: ${displayOutput(step.behavior.output)}`));
+        }
+        if (input.mode === "chain") {
+            lines.push(this.row(`     reads: ${displayList(step.behavior.reads)}`));
+        }
+        lines.push(this.row(`     skills: ${displayList(step.behavior.skills)}`));
+        if (input.mode === "chain" && input.progress) {
+            lines.push(this.row(`     progress: ${index === 0 ? "writes" : "reads"} progress.md`));
+        }
+        if (input.mode === "chain" && step.nextUsesPrevious) {
+            lines.push(this.row("     ↳ response → {previous}"));
+        }
+        lines.push(this.row(""));
+        return lines;
+    }
+}
+function displayOutput(output) {
+    if (output === false) {
+        return "(disabled)";
+    }
+    return output === undefined || output.length === 0 ? "(none)" : output;
+}
+function displayList(values) {
+    if (values === false) {
+        return "(disabled)";
+    }
+    return values.length > 0 ? values.join(", ") : "(none)";
+}