@bastani/atomic 0.8.13-0 → 0.8.14-0

package/dist/builtin/workflows/src/runs/foreground/stage-control-registry.ts

@@ -34,7 +34,8 @@ export type StageControlStatus =
   | "paused"
   | "blocked"
   | "completed"
-  | "failed";
+  | "failed"
+  | "skipped";
 
 export type AgentSessionEventListener = (event: AgentSessionEvent) => void;
 
@@ -53,6 +54,8 @@ export interface StageControlHandle {
   readonly sessionId: string | undefined;
   readonly sessionFile: string | undefined;
   readonly isStreaming: boolean;
+  /** True after the executor has released the live SDK session behind this handle. */
+  readonly isDisposed?: boolean;
   readonly messages: AgentSession["messages"];
   /** Live coding-agent session when available, used by embedded chat/footer UI. */
   readonly agentSession?: AgentSession;
@@ -190,7 +193,7 @@ export function createStageControlRegistry(): StageControlRegistry {
         );
         for (const handle of targets) {
           if (handle.status === "paused") continue;
-          if (handle.status === "completed" || handle.status === "failed") continue;
+          if (handle.status === "completed" || handle.status === "failed" || handle.status === "skipped") continue;
           await handle.pause();
         }
         return controlledEntries(runId)

package/dist/builtin/workflows/src/runs/foreground/stage-runner.ts

@@ -45,6 +45,8 @@ export interface StageSessionRuntime {
   readonly thinkingLevel: AgentSession["thinkingLevel"];
   readonly messages: AgentSession["messages"];
   readonly isStreaming: AgentSession["isStreaming"];
+  /** Number of SDK-level queued steering/follow-up messages, when supported. */
+  readonly pendingMessageCount?: number;
   navigateTree: AgentSession["navigateTree"];
   compact: AgentSession["compact"];
   abortCompaction(): void;
@@ -114,6 +116,8 @@ export interface InternalStageContext extends StageContext {
   __sessionMeta(): { sessionId: string | undefined; sessionFile: string | undefined };
   /** Internal: live coding-agent session when the adapter returned one. */
   __agentSession(): AgentSession | undefined;
+  /** Internal: SDK queued steering/follow-up message count, when available. */
+  __pendingMessageCount(): number;
   /** Internal: selected/effective model and fallback attempt metadata. */
   __modelFallbackMeta(): StageModelFallbackMeta;
   /**
@@ -711,6 +715,10 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
       return asAgentSession(session);
     },
 
+    __pendingMessageCount() {
+      return typeof session?.pendingMessageCount === "number" ? session.pendingMessageCount : 0;
+    },
+
     __modelFallbackMeta() {
       const attemptedModels = modelAttempts.map((attempt) => attempt.model);
       const model = selectedModel ?? workflowModelId(session?.model);

package/dist/builtin/workflows/src/runs/shared/model-fallback.ts

@@ -214,13 +214,15 @@ export async function validateWorkflowModels(input: {
   };
 
   const failures: ModelResolutionFailure[] = [];
-  const availableModels = input.catalog === undefined ? undefined : await input.catalog.listModels().catch(() => undefined);
-  if (input.catalog !== undefined && availableModels === undefined) {
-    if (input.catalog.currentModel !== undefined) {
+  let availableModels: readonly WorkflowModelInfo[] | undefined;
+  if (input.catalog !== undefined) {
+    try {
+      availableModels = await input.catalog.listModels();
+    } catch (err) {
+      if (input.catalog.currentModel === undefined) throw err;
       recordWarning(catalogUnavailableWarning());
       return warnings;
     }
-    throw new WorkflowModelValidationError([{ input: "model catalog", reason: "unavailable and no current model is configured" }]);
   }
 
   for (const request of relevant) {

package/dist/builtin/workflows/src/runs/shared/worktree.ts

@@ -2,6 +2,7 @@ import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { APP_NAME } from "@bastani/atomic";
 
 export interface WorktreeSetup {
 	cwd: string;
@@ -149,11 +150,11 @@ function safePatchAgentName(agent: string): string {
 }
 
 function buildWorktreeBranch(runId: string, index: number): string {
-	return `pi-parallel-${runId}-${index}`;
+	return `${APP_NAME}-parallel-${runId}-${index}`;
 }
 
 function buildWorktreePath(runId: string, index: number): string {
-	return path.join(os.tmpdir(), `pi-worktree-${runId}-${index}`);
+	return path.join(os.tmpdir(), `${APP_NAME}-worktree-${runId}-${index}`);
 }
 
 function resolveRepoCwdRelative(cwd: string): string {

package/dist/builtin/workflows/src/shared/persistence-restore.ts

@@ -7,7 +7,8 @@
  */
 
 import type { Store } from "./store.js";
-import type { RunSnapshot, StageSnapshot } from "./store-types.js";
+import type { RunSnapshot, StageSnapshot, StageStatus } from "./store-types.js";
+import { isWorkflowFailureKind } from "./workflow-failures.js";
 
 // ---------------------------------------------------------------------------
 // Config option
@@ -161,10 +162,15 @@ export function restoreOnSessionStart(
   if (typeof getEntries !== "function") return;
 
   const entries = getEntries.call(sessionManager);
-  const inFlight = scanInFlightRuns(entries as readonly SessionEntry[]);
+  const sessionEntries = entries as readonly SessionEntry[];
+  restoreEndedFailedRuns(sessionEntries, store);
+  const inFlight = scanInFlightRuns(sessionEntries);
   if (inFlight.length === 0) return;
 
   for (const run of inFlight) {
+    const runMeta = findRunStartMetadata(sessionEntries, run.runId);
+    const stages = _buildStageSnapshots(sessionEntries, run.runId);
+
     if (config.resumeInFlight === "auto") {
       // Re-hydrate the run into the store as "running"
       const runSnapshot: RunSnapshot = {
@@ -172,8 +178,10 @@ export function restoreOnSessionStart(
         name: run.name,
         inputs: run.inputs,
         status: "running",
-        stages: _buildStageSnapshots(entries as readonly SessionEntry[], run.runId),
+        stages,
         startedAt: run.startTs,
+        ...(runMeta.resumedFromRunId !== undefined ? { resumedFromRunId: runMeta.resumedFromRunId } : {}),
+        ...(runMeta.resumeFromStageId !== undefined ? { resumeFromStageId: runMeta.resumeFromStageId } : {}),
       };
       store.recordRunStart(runSnapshot);
       callbacks.onResume?.(run);
@@ -184,10 +192,14 @@ export function restoreOnSessionStart(
         name: run.name,
         inputs: run.inputs,
         status: "failed",
-        stages: _buildStageSnapshots(entries as readonly SessionEntry[], run.runId),
+        stages,
         startedAt: run.startTs,
         endedAt: Date.now(),
         error: "Run did not complete — process was interrupted.",
+        failureKind: "unknown",
+        resumable: false,
+        ...(runMeta.resumedFromRunId !== undefined ? { resumedFromRunId: runMeta.resumedFromRunId } : {}),
+        ...(runMeta.resumeFromStageId !== undefined ? { resumeFromStageId: runMeta.resumeFromStageId } : {}),
       };
       store.recordRunStart(runSnapshot);
       store.recordRunEnd(run.runId, "failed");
@@ -224,6 +236,7 @@ function _buildStageSnapshots(
           status: "running",
           parentIds: Array.isArray(parentIds) ? (parentIds as string[]) : [],
           startedAt: typeof ts === "number" ? ts : undefined,
+          ...replayMetadata(entry.payload),
           toolEvents: [],
         });
       }
@@ -234,13 +247,22 @@ function _buildStageSnapshots(
       const status = entry.payload["status"];
       const durationMs = entry.payload["durationMs"];
       const summary = entry.payload["summary"];
+      const error = entry.payload["error"];
+      const failureKind = entry.payload["failureKind"];
+      const failureMessage = entry.payload["failureMessage"];
+      const skippedReason = entry.payload["skippedReason"];
       if (typeof stageId !== "string") continue;
       endedStages.add(stageId);
       const snap = stageMap.get(stageId);
       if (snap) {
-        snap.status = (status === "completed" || status === "failed") ? status : "failed";
+        snap.status = restoreStageStatus(status);
         if (typeof durationMs === "number") snap.durationMs = durationMs;
         if (typeof summary === "string") snap.result = summary;
+        if (typeof error === "string") snap.error = error;
+        if (typeof failureKind === "string" && isWorkflowFailureKind(failureKind)) snap.failureKind = failureKind;
+        if (typeof failureMessage === "string") snap.failureMessage = failureMessage;
+        if (typeof skippedReason === "string") snap.skippedReason = skippedReason;
+        Object.assign(snap, replayMetadata(entry.payload));
       }
     }
   }
@@ -255,3 +277,114 @@ function _buildStageSnapshots(
 
   return [...stageMap.values()];
 }
+
+function replayMetadata(payload: Record<string, unknown>): Pick<StageSnapshot, "replayedFromStageId" | "replayed"> {
+  const replayedFromStageId = payload["replayedFromStageId"];
+  const replayed = payload["replayed"];
+  return {
+    ...(typeof replayedFromStageId === "string" ? { replayedFromStageId } : {}),
+    ...(typeof replayed === "boolean" ? { replayed } : {}),
+  };
+}
+
+function restoreStageStatus(status: unknown): StageStatus {
+  switch (status) {
+    case "completed":
+    case "failed":
+    case "skipped":
+      return status;
+    default:
+      return "failed";
+  }
+}
+
+function restoreEndedFailedRuns(entries: readonly SessionEntry[], store: Store): void {
+  const started = new Map<string, { readonly name: string; readonly inputs: Readonly<Record<string, unknown>>; readonly startTs: number }>();
+  const ended = new Map<string, Record<string, unknown>>();
+
+  for (const entry of entries) {
+    if (entry.type === "workflow.run.start") {
+      const runId = entry.payload["runId"];
+      const name = entry.payload["name"];
+      const inputs = entry.payload["inputs"];
+      const ts = entry.payload["ts"];
+      if (typeof runId === "string" && typeof name === "string" && typeof ts === "number") {
+        started.set(runId, {
+          name,
+          inputs: (inputs !== null && typeof inputs === "object" && !Array.isArray(inputs))
+            ? (inputs as Record<string, unknown>)
+            : {},
+          startTs: ts,
+        });
+      }
+    }
+    if (entry.type === "workflow.run.end") {
+      const runId = entry.payload["runId"];
+      if (typeof runId === "string") ended.set(runId, entry.payload);
+    }
+  }
+
+  for (const [runId, start] of started) {
+    if (store.runs().some((run) => run.id === runId)) continue;
+    const end = ended.get(runId);
+    const status = restoreTerminalRunStatus(end?.["status"]);
+    if (end === undefined || status === undefined) continue;
+
+    const runMeta = findRunStartMetadata(entries, runId);
+    const stages = _buildStageSnapshots(entries, runId);
+    store.recordRunStart({
+      id: runId,
+      name: start.name,
+      inputs: start.inputs,
+      status: "running",
+      stages,
+      startedAt: start.startTs,
+      ...(runMeta.resumedFromRunId !== undefined ? { resumedFromRunId: runMeta.resumedFromRunId } : {}),
+      ...(runMeta.resumeFromStageId !== undefined ? { resumeFromStageId: runMeta.resumeFromStageId } : {}),
+    });
+
+    const error = end["error"];
+    const failureKind = end["failureKind"];
+    const failureMessage = end["failureMessage"];
+    const failedStageId = end["failedStageId"];
+    const resumable = end["resumable"];
+    store.recordRunEnd(
+      runId,
+      status,
+      undefined,
+      typeof error === "string" ? error : undefined,
+      {
+        ...(typeof failureKind === "string" && isWorkflowFailureKind(failureKind) ? { failureKind } : {}),
+        ...(typeof failureMessage === "string" ? { failureMessage } : {}),
+        ...(typeof failedStageId === "string" ? { failedStageId } : {}),
+        ...(typeof resumable === "boolean" ? { resumable } : {}),
+      },
+    );
+  }
+}
+
+function restoreTerminalRunStatus(status: unknown): "failed" | "killed" | undefined {
+  switch (status) {
+    case "failed":
+    case "killed":
+      return status;
+    default:
+      return undefined;
+  }
+}
+
+function findRunStartMetadata(
+  entries: readonly SessionEntry[],
+  runId: string,
+): { readonly resumedFromRunId?: string; readonly resumeFromStageId?: string } {
+  for (const entry of entries) {
+    if (entry.type !== "workflow.run.start" || entry.payload["runId"] !== runId) continue;
+    const resumedFromRunId = entry.payload["resumedFromRunId"];
+    const resumeFromStageId = entry.payload["resumeFromStageId"];
+    return {
+      ...(typeof resumedFromRunId === "string" ? { resumedFromRunId } : {}),
+      ...(typeof resumeFromStageId === "string" ? { resumeFromStageId } : {}),
+    };
+  }
+  return {};
+}

package/dist/builtin/workflows/src/shared/persistence-session-entries.ts

@@ -31,6 +31,8 @@ export interface RunStartPayload {
   readonly runId: string;
   readonly name: string;
   readonly inputs: Readonly<Record<string, unknown>>;
+  readonly resumedFromRunId?: string;
+  readonly resumeFromStageId?: string;
   readonly ts: number;
 }
 
@@ -40,6 +42,8 @@ export interface StageStartPayload {
   readonly name: string;
   readonly parentIds: readonly string[];
   readonly model?: string;
+  readonly replayedFromStageId?: string;
+  readonly replayed?: boolean;
   readonly ts: number;
 }
 
@@ -56,12 +60,23 @@ export interface StageEndPayload {
   readonly status: string;
   readonly durationMs?: number;
   readonly summary?: string;
+  readonly error?: string;
+  readonly failureKind?: string;
+  readonly failureMessage?: string;
+  readonly skippedReason?: string;
+  readonly replayedFromStageId?: string;
+  readonly replayed?: boolean;
 }
 
 export interface RunEndPayload {
   readonly runId: string;
   readonly status: string;
   readonly result?: unknown;
+  readonly error?: string;
+  readonly failureKind?: string;
+  readonly failureMessage?: string;
+  readonly failedStageId?: string;
+  readonly resumable?: boolean;
   readonly ts: number;
 }
 
@@ -79,6 +94,8 @@ export function appendRunStart(api: PersistenceAPI, payload: RunStartPayload): v
     runId: payload.runId,
     name: payload.name,
     inputs: payload.inputs,
+    ...(payload.resumedFromRunId !== undefined ? { resumedFromRunId: payload.resumedFromRunId } : {}),
+    ...(payload.resumeFromStageId !== undefined ? { resumeFromStageId: payload.resumeFromStageId } : {}),
     ts: payload.ts,
   });
   if (entryId && typeof api.setLabel === "function") {
@@ -96,6 +113,8 @@ export function appendStageStart(api: PersistenceAPI, payload: StageStartPayload
     name: payload.name,
     parentIds: [...payload.parentIds],
     ...(payload.model !== undefined ? { model: payload.model } : {}),
+    ...(payload.replayedFromStageId !== undefined ? { replayedFromStageId: payload.replayedFromStageId } : {}),
+    ...(payload.replayed !== undefined ? { replayed: payload.replayed } : {}),
     ts: payload.ts,
   });
 }
@@ -124,6 +143,12 @@ export function appendStageEnd(
     status: payload.status,
     ...(payload.durationMs !== undefined ? { durationMs: payload.durationMs } : {}),
     ...(payload.summary !== undefined ? { summary: payload.summary } : {}),
+    ...(payload.error !== undefined ? { error: payload.error } : {}),
+    ...(payload.failureKind !== undefined ? { failureKind: payload.failureKind } : {}),
+    ...(payload.failureMessage !== undefined ? { failureMessage: payload.failureMessage } : {}),
+    ...(payload.skippedReason !== undefined ? { skippedReason: payload.skippedReason } : {}),
+    ...(payload.replayedFromStageId !== undefined ? { replayedFromStageId: payload.replayedFromStageId } : {}),
+    ...(payload.replayed !== undefined ? { replayed: payload.replayed } : {}),
   });
   if (opts?.emitMessage === true && payload.summary && typeof api.appendCustomMessageEntry === "function") {
     api.appendCustomMessageEntry(
@@ -140,6 +165,11 @@ export function appendRunEnd(api: PersistenceAPI, payload: RunEndPayload): void
     runId: payload.runId,
     status: payload.status,
     ...(payload.result !== undefined ? { result: payload.result as Record<string, unknown> } : {}),
+    ...(payload.error !== undefined ? { error: payload.error } : {}),
+    ...(payload.failureKind !== undefined ? { failureKind: payload.failureKind } : {}),
+    ...(payload.failureMessage !== undefined ? { failureMessage: payload.failureMessage } : {}),
+    ...(payload.failedStageId !== undefined ? { failedStageId: payload.failedStageId } : {}),
+    ...(payload.resumable !== undefined ? { resumable: payload.resumable } : {}),
     ts: payload.ts,
   });
 }

package/dist/builtin/workflows/src/shared/render-inputs-schema.ts

@@ -11,7 +11,7 @@
  * The renderer has two output modes:
  *
  *   - **pretty** (default when a GraphTheme is supplied) — emits ANSI-coloured
- *     blocks that match the `▎ INPUTS` aesthetic established in
+ *     blocks that match the indented `INPUTS` aesthetic established in
  *     `src/tui/session-list.ts`. Drawn for any interactive surface where the
  *     terminal supports colour.
  *   - **plain**  (used when no theme is supplied)         — emits the
@@ -22,7 +22,7 @@
  * The layout in pretty mode mirrors flora131/atomic's `renderInputsText` so a
  * dev moving between the atomic CLI and the pi extension feels at home:
  *
- *   ▎ INPUTS FOR ralph
+ *     INPUTS FOR ralph
  *
  *     prompt          text · required
  *       The high-level task to plan and execute.
@@ -41,11 +41,12 @@
 
 import type { GraphTheme } from "../tui/graph-theme.js";
 import { paint } from "../tui/color-utils.js";
+import { renderRoundedBox, chatWidth } from "../tui/chat-surface.js";
 import { truncateToWidth } from "../tui/text-helpers.js";
 import type { WorkflowInputEntry } from "../extension/render-result.js";
 
 export interface RenderInputsSchemaOptions {
-  /** When provided, output uses ANSI colours and the `▎ INPUTS` chrome. */
+  /** When provided, output uses ANSI colours and indented `INPUTS` chrome. */
   theme?: GraphTheme;
   /** Optional host render width in terminal cells. */
   width?: number;
@@ -61,49 +62,42 @@ export function renderInputsSchema(
   inputs: WorkflowInputEntry[],
   opts: RenderInputsSchemaOptions = {},
 ): string {
-  if (inputs.length === 0) {
-    return fitBlock(`Workflow "${name}" has no declared inputs.`, opts.width);
-  }
-  const rendered = opts.theme === undefined
-    ? renderPlain(name, inputs)
-    : renderPretty(name, inputs, opts.theme);
-  return fitBlock(rendered, opts.width);
-}
-
-function fitBlock(block: string, width?: number): string {
-  if (width === undefined || width <= 0) return block;
-  return block
-    .split("\n")
-    .map((line) => truncateToWidth(line, width, "…"))
-    .join("\n");
+  return opts.theme === undefined
+    ? renderPlain(name, inputs, opts.width)
+    : renderPretty(name, inputs, opts.theme, opts.width);
 }
 
 // ---------------------------------------------------------------------------
-// Plain renderer — historical shape preserved for the LLM tool path and
-// non-TTY consumers. Stable byte-for-byte so existing snapshots keep passing.
+// Plain renderer — rounded, marker-free workflow-tool output without ANSI.
 // ---------------------------------------------------------------------------
 
-function renderPlain(name: string, inputs: WorkflowInputEntry[]): string {
-  const lines = inputs.map((inp) => {
-    const req = inp.required ? " (required)" : "";
-    const def =
-      inp.default !== undefined ? ` [default: ${JSON.stringify(inp.default)}]` : "";
-    const choices =
-      inp.choices && inp.choices.length > 0
-        ? ` {choices: ${inp.choices.join(", ")}}`
-        : "";
-    const desc = inp.description ? ` — ${inp.description}` : "";
-    return `  ${inp.name}: ${inp.type}${req}${def}${choices}${desc}`;
+function renderPlain(name: string, inputs: WorkflowInputEntry[], width?: number): string {
+  const boxWidth = chatWidth(width);
+  const body: string[] = [];
+
+  if (inputs.length === 0) {
+    body.push(` Workflow has no declared inputs. Workflow: "${name}". `);
+  } else {
+    for (let i = 0; i < inputs.length; i++) {
+      if (i > 0) body.push("");
+      body.push(...renderInputRows(inputs[i]!));
+    }
+    body.push("");
+    body.push(` ${inputsSummary(name, inputs)} `);
+  }
+
+  return renderRoundedBox({
+    title: `INPUTS FOR ${name}`,
+    bodyLines: body,
+    width: boxWidth,
   });
-  return `Inputs for "${name}":\n${lines.join("\n")}`;
 }
 
 // ---------------------------------------------------------------------------
 // Pretty renderer — ANSI-coloured, themed, matches the session-list aesthetic.
 //
-// Section labels lead with `▎ ` in mauve (the same glyph used across the
-// extension's TUI surfaces) and the field name is rendered bold-bright so
-// the eye scans the form top-to-bottom. The `required` tag is yellow
+// Section labels lead with a two-cell indent and the field name is rendered
+// bold-bright so the eye scans the form top-to-bottom. The `required` tag is yellow
 // (theme.warning) — yellow draws attention to "you must fill this in"
 // without being alarming the way red would.
 // ---------------------------------------------------------------------------
@@ -112,100 +106,64 @@ function renderPretty(
   name: string,
   inputs: WorkflowInputEntry[],
   theme: GraphTheme,
+  width?: number,
 ): string {
-  const out: string[] = [];
-
-  // Section header — mauve indicator bar + bold caps label, matching
-  // session-list.ts. Includes the workflow name so the block is
-  // self-titling when printed inline in a chat surface.
-  out.push("");
-  out.push(
-    `${paint("▎", theme.mauve)} ${paint(
-      `INPUTS FOR ${name.toUpperCase()}`,
-      theme.textMuted,
-      { bold: true },
-    )}`,
-  );
-  out.push("");
-
-  // Compute a stable left column for the name so types/required tags
-  // line up vertically — the form should *look* like a form, not a
-  // ragged paragraph. Cap at 24 chars so a stray long input name
-  // doesn't push everything off the right edge.
-  const nameWidth = Math.min(
-    24,
-    Math.max(...inputs.map((i) => i.name.length)),
-  );
-  const dimDot = paint("  ·  ", theme.dim);
-
-  for (const field of inputs) {
-    const namePad = field.name.padEnd(nameWidth);
-    const tagColour = field.required ? theme.warning : theme.dim;
-    const tagLabel = field.required ? "required" : "optional";
-
-    // Row 1: name · type · required|optional
-    out.push(
-      "  " +
-        paint(namePad, theme.text, { bold: true }) +
-        "  " +
-        paint(field.type, theme.dim) +
-        dimDot +
-        paint(tagLabel, tagColour),
-    );
-
-    // Row 2: description (when present)
-    if (field.description) {
-      out.push("    " + paint(field.description, theme.textMuted));
-    }
-
-    // Row 3: choices for selects — dot-separator style so the values
-    // read as a clear closed set.
-    if (field.choices && field.choices.length > 0) {
-      const joined = field.choices
-        .map((v) => paint(v, theme.text))
-        .join(dimDot);
-      out.push("    " + paint("values: ", theme.dim) + joined);
-    }
+  const boxWidth = chatWidth(width);
+  const body: string[] = [];
 
-    // Row 4: default (when present)
-    if (field.default !== undefined) {
-      out.push(
-        "    " +
-          paint("default: ", theme.dim) +
-          paint(String(field.default), theme.text),
-      );
+  if (inputs.length === 0) {
+    body.push(` ${paint(`Workflow has no declared inputs. Workflow: "${name}".`, theme.dim)} `);
+  } else {
+    for (let i = 0; i < inputs.length; i++) {
+      if (i > 0) body.push("");
+      body.push(...renderInputRows(inputs[i]!, theme));
     }
+    body.push("");
+    body.push(` ${paint(inputsSummary(name, inputs), theme.dim)} `);
+  }
 
-    // Row 5: placeholder hint (optional, mostly used by the picker)
-    if (field.placeholder) {
-      out.push(
-        "    " +
-          paint("placeholder: ", theme.dim) +
-          paint(field.placeholder, theme.textMuted),
-      );
-    }
+  return renderRoundedBox({
+    title: `INPUTS FOR ${name.toUpperCase()}`,
+    bodyLines: body,
+    accent: theme.mauve,
+    theme,
+    width: boxWidth,
+  });
+}
 
-    out.push(""); // spacer between fields
+function renderInputRows(
+  field: WorkflowInputEntry,
+  theme?: GraphTheme,
+): string[] {
+  const tagLabel = field.required ? "required" : "optional";
+  const heading = theme
+    ? ` ${paint(field.name, theme.text, { bold: true })}  ${paint(field.type, theme.dim)}  ·  ${paint(tagLabel, field.required ? theme.warning : theme.dim)} `
+    : ` ${field.name}  ${field.type}  ·  ${tagLabel} `;
+  const lines: string[] = [heading];
+
+  if (field.description) {
+    lines.push(`   ${theme ? paint(field.description, theme.textMuted) : field.description} `);
+  }
+  if (field.choices && field.choices.length > 0) {
+    const values = field.choices.join("  ·  ");
+    lines.push(`   ${theme ? paint("values: ", theme.dim) + paint(values, theme.text) : `values: ${values}`} `);
+  }
+  if (field.default !== undefined) {
+    const value = JSON.stringify(field.default);
+    lines.push(`   ${theme ? paint("default: ", theme.dim) + paint(value, theme.text) : `default: ${value}`} `);
+  }
+  if (field.placeholder) {
+    lines.push(`   ${theme ? paint("placeholder: ", theme.dim) + paint(field.placeholder, theme.textMuted) : `placeholder: ${field.placeholder}`} `);
   }
 
-  // Summary footer — total/required count + the two-path hint that
-  // teaches the slash key=value form and the picker fallback in one line.
+  return lines;
+}
+
+function inputsSummary(name: string, inputs: readonly WorkflowInputEntry[]): string {
   const required = inputs.filter((i) => i.required).length;
   const total = inputs.length;
   const totalLabel = `${total} input${total === 1 ? "" : "s"}`;
   const reqLabel = `${required} required`;
-  out.push(
-    "  " +
-      paint(totalLabel, theme.dim) +
-      dimDot +
-      paint(reqLabel, theme.dim) +
-      dimDot +
-      paint(
-        `pass via key=value or run \`/workflow ${name}\` with no args for picker`,
-        theme.dim,
-      ),
-  );
-  out.push("");
-
-  return out.join("\n");
+  return `${totalLabel}  ·  ${reqLabel}  ·  pass via key=value or run \`/workflow ${name}\` with no args for picker`;
 }
+