@bastani/atomic 0.8.27 → 0.8.28-alpha.2

package/dist/builtin/workflows/src/shared/authoring-contract.d.ts

@@ -1,10 +1,13 @@
 /**
- * Dependency-light workflow authoring contract shared by the runtime type graph
- * and the standalone package typing surface.
+ * Workflow authoring contract shared by the runtime type graph and the
+ * standalone package typing surface.
  *
- * This module intentionally imports only TypeBox types. Do not import
- * @bastani/atomic, executor internals, stores, or runtime graph modules here.
+ * This module intentionally avoids executor internals, stores, or runtime graph
+ * modules here. Public custom-TUI types are type-only imports from the same
+ * extension-compatible surfaces used by Atomic extension UI.
  */
+import type { KeybindingsManager, Theme } from "@bastani/atomic";
+import type { Component, OverlayHandle, OverlayOptions, TUI } from "@earendil-works/pi-tui";
 import type { Static, TOptional, TSchema } from "typebox";
 export type { Static, TSchema };
 export type WorkflowSerializablePrimitive = string | number | boolean | null;
@@ -335,13 +338,47 @@ export interface WorkflowChildResult<TOutputs extends WorkflowOutputValues = Wor
     readonly status: "completed";
     readonly outputs: TOutputs;
 }
+export type WorkflowCustomUiComponent = Component & {
+    dispose?(): void;
+};
+export type WorkflowCustomUiTui = TUI;
+export type WorkflowCustomUiTheme = Theme;
+export type WorkflowCustomUiKeybindings = KeybindingsManager;
+export type WorkflowCustomUiOverlayOptions = OverlayOptions;
+export type WorkflowCustomUiOverlayHandle = OverlayHandle;
+export type WorkflowCustomUiFactory<T> = (tui: TUI, theme: Theme, keybindings: KeybindingsManager, done: (value: T) => void) => WorkflowCustomUiComponent | Promise<WorkflowCustomUiComponent>;
+export interface WorkflowCustomUiOptions {
+    /** Render as a nested overlay. Workflow graph hosts may reject this when unsupported. */
+    readonly overlay?: boolean;
+    /** AbortSignal to programmatically dismiss the custom UI. */
+    readonly signal?: AbortSignal;
+    /** Overlay positioning/sizing options. Can be static or a function for dynamic updates. */
+    readonly overlayOptions?: OverlayOptions | (() => OverlayOptions);
+    /** Called with the real overlay handle after an overlay is shown. */
+    readonly onHandle?: (handle: OverlayHandle) => void;
+    /**
+     * Workflow-only replay identity. Recommended whenever widget state or
+     * semantics can change without the callsite changing. Do not include secrets;
+     * the runtime stores only a hash.
+     */
+    readonly replayIdentity?: string;
+    /** Safe display-only label for graph/status surfaces. Defaults to "Custom TUI prompt". Not part of replay identity. */
+    readonly label?: string;
+}
 export interface WorkflowUIContext {
     input(prompt: string): Promise<string>;
     confirm(message: string): Promise<boolean>;
     select<T extends string>(message: string, options: readonly T[]): Promise<T>;
     editor(initial?: string): Promise<string>;
+    custom<T>(factory: WorkflowCustomUiFactory<T>, options?: WorkflowCustomUiOptions): Promise<T>;
+}
+export interface WorkflowUIAdapter {
+    input(prompt: string): Promise<string>;
+    confirm(message: string): Promise<boolean>;
+    select<T extends string>(message: string, options: readonly T[]): Promise<T>;
+    editor(initial?: string): Promise<string>;
+    custom?<T>(factory: WorkflowCustomUiFactory<T>, options?: WorkflowCustomUiOptions): Promise<T>;
 }
-export type WorkflowUIAdapter = WorkflowUIContext;
 export interface WorkflowRunContext<TInputs extends WorkflowInputValues = WorkflowInputValues, TDefinitionBrand extends object = {}> {
     readonly inputs: Readonly<TInputs>;
     readonly cwd?: string;

package/dist/builtin/workflows/src/shared/store-types.ts

@@ -32,10 +32,12 @@ export type WorkflowFailureCode =
   | "unknown";
 
 /**
- * Human-in-the-loop prompt kind. Mirrors the four `WorkflowUIContext` methods.
+ * Human-in-the-loop prompt kind. Mirrors the `WorkflowUIContext` methods.
  * cross-ref: src/shared/types.ts WorkflowUIContext
  */
-export type PromptKind = "input" | "confirm" | "select" | "editor";
+export type PromptKind = "input" | "confirm" | "select" | "editor" | "custom";
+
+export type CustomPromptIdentitySource = "caller" | "factory" | "callsite";
 
 /**
  * A pending HIL prompt awaiting user response. Surfaced through the graph
@@ -53,6 +55,10 @@ export interface PendingPrompt {
   readonly choices?: readonly string[];
   /** Initial value for `kind: "input"` and `kind: "editor"`. */
   readonly initial?: string;
+  /** Hash of caller-supplied or derived replay identity for `kind: "custom"`. */
+  readonly customIdentityHash?: string;
+  /** Explains how a custom prompt replay identity was derived without storing the raw identity. */
+  readonly customIdentitySource?: CustomPromptIdentitySource;
   /** Issue timestamp (ms since epoch). */
   readonly createdAt: number;
 }

package/dist/builtin/workflows/src/shared/store.ts

@@ -119,6 +119,11 @@ export interface ResolveStagePendingPromptOptions {
   readonly answerSource?: StagePromptAnswerSource;
 }
 
+export interface RecordStagePromptAnswerOptions {
+  /** Identifies who answered the prompt so notification code can avoid echoing workflow-tool answers. */
+  readonly answerSource?: StagePromptAnswerSource;
+}
+
 export interface Store {
   runs(): readonly RunSnapshot[];
   notices(): readonly WorkflowNotice[];
@@ -206,6 +211,19 @@ export interface Store {
   ): boolean;
   /** Wait for a stage/node-scoped HIL prompt to resolve. */
   awaitStagePendingPrompt(runId: string, stageId: string, promptId: string): Promise<unknown>;
+  /**
+   * Record a live-only prompt answer for prompt-node UIs that do not use
+   * `stage.pendingPrompt` (notably arbitrary `ctx.ui.custom<T>` widgets).
+   * The raw value stays in the private answer ledger and is never serialized
+   * into snapshots or persistence.
+   */
+  recordStagePromptAnswer(
+    runId: string,
+    stageId: string,
+    prompt: PendingPrompt,
+    response: unknown,
+    options?: RecordStagePromptAnswerOptions,
+  ): boolean;
   /**
    * Record a live-only draft for an active stage-local input/editor prompt.
    * Draft text may contain secrets and must never be copied into snapshots,
@@ -774,6 +792,39 @@ export function createStore(): Store {
       });
     },
 
+    recordStagePromptAnswer(
+      runId: string,
+      stageId: string,
+      prompt: PendingPrompt,
+      response: unknown,
+      options: RecordStagePromptAnswerOptions = {},
+    ): boolean {
+      const run = findRun(runId);
+      if (!run) return false;
+      if (TERMINAL_STATUSES.has(run.status)) return false;
+      const stage = findStage(run, stageId);
+      if (!stage) return false;
+      if (isTerminalStageStatus(stage.status)) return false;
+      _stagePromptAnswers.set(stagePromptAnswerKey(runId, stageId), {
+        runId,
+        stageId,
+        promptId: prompt.id,
+        kind: prompt.kind,
+        value: response,
+        answeredAt: Date.now(),
+        ...(options.answerSource !== undefined ? { answerSource: options.answerSource } : {}),
+      });
+      if (stage.promptFootprint === undefined) stage.promptFootprint = { ...prompt };
+      stage.promptAnswerState = "available";
+      if (stage.status === "awaiting_input") {
+        stage.status = "running";
+        delete stage.awaitingInputSince;
+      }
+      _version++;
+      notify();
+      return true;
+    },
+
     recordStagePromptDraft(runId: string, stageId: string, promptId: string, text: string): boolean {
       if (stageHasActiveTextPrompt(runId, stageId, promptId) === undefined) return false;
       _stagePromptDrafts.set(stagePromptDraftKey(runId, stageId, promptId), text);

package/dist/builtin/workflows/src/shared/types.ts

@@ -116,14 +116,24 @@ export interface WorkflowChildResult<TOutputs extends WorkflowOutputValues = Wor
  * Each primitive suspends the current stage until the user responds.
  * Mirrors pi ctx.ui.input / confirm / select / editor methods.
  */
-export type WorkflowUIContext = AuthoringContract.WorkflowUIContext;
+export type WorkflowCustomUiComponent = AuthoringContract.WorkflowCustomUiComponent;
+export type WorkflowCustomUiTui = AuthoringContract.WorkflowCustomUiTui;
+export type WorkflowCustomUiTheme = AuthoringContract.WorkflowCustomUiTheme;
+export type WorkflowCustomUiKeybindings = AuthoringContract.WorkflowCustomUiKeybindings;
+export type WorkflowCustomUiOverlayOptions = AuthoringContract.WorkflowCustomUiOverlayOptions;
+export type WorkflowCustomUiOverlayHandle = AuthoringContract.WorkflowCustomUiOverlayHandle;
+export type WorkflowCustomUiFactory<T> = AuthoringContract.WorkflowCustomUiFactory<T>;
+export type WorkflowCustomUiOptions = AuthoringContract.WorkflowCustomUiOptions;
+
+export interface WorkflowUIContext extends AuthoringContract.WorkflowUIContext {}
 
 /**
  * Adapter supplied by the pi runtime (or test harness) to back the HIL
- * primitives.  Must implement the same surface as WorkflowUIContext so that
- * the executor can delegate directly.
+ * primitives.  The custom-widget method is optional for compatibility with
+ * existing primitive-only adapters; the executor normalizes a missing custom
+ * method to the same unavailable-UI rejection used in headless mode.
  */
-export type WorkflowUIAdapter = AuthoringContract.WorkflowUIAdapter;
+export interface WorkflowUIAdapter extends AuthoringContract.WorkflowUIAdapter {}
 
 // ---------------------------------------------------------------------------
 // StageOptions — per-stage configuration + pi SDK session options

package/dist/builtin/workflows/src/tui/chat-surface.ts

@@ -11,9 +11,11 @@
  *    left, a `surface0` tag carrying the runId / workflow name, a
  *    bolded title beside it, and one optional second row indented past
  *    the stripe.
- *  - **Progress strip**: bracketed `[✓]` / `[●]` / `[○]` / `[✗]` cells,
- *    coloured by stage status. Truncates with a trailing `…` when the
- *    rendered cells exceed the available budget.
+ *  - **Progress strip**: bracketed status cells such as `[✓]`, `[●]`,
+ *    `[○]`, `[✗]`, and `[❚❚]`, coloured by stage status. Cells are
+ *    measured by visible width per rendered glyph rather than assumed to
+ *    be a fixed 3 columns, and the strip truncates with a trailing `…`
+ *    when the rendered cells exceed the available budget.
  *  - **Hint rows**: a single grammar — `▸ /slash command  verb-phrase
  *    hint`.
  *
@@ -440,7 +442,7 @@ function renderTaggedCardPlain(opts: RenderTaggedCardOpts, width: number): strin
 }
 
 // ---------------------------------------------------------------------------
-// Progress strip — `[✓][●][○][✗]` cells, coloured by stage status
+// Progress strip — variable-width bracketed cells, coloured by stage status
 // ---------------------------------------------------------------------------
 
 export interface ProgressCell {
@@ -449,45 +451,40 @@ export interface ProgressCell {
 
 /**
  * Render a progress strip whose visible width is at most `budget` cells.
- * Each cell renders as a 3-character bracket-glyph-bracket sequence
- * (`[✓]`). When the strip would exceed the budget, the rendered output
- * is truncated and a trailing `…` is appended.
+ * Each cell renders as a bracketed status glyph whose visible width can
+ * vary by status (`[✓]` is 3 cells, `[❚❚]` is 4 cells). Truncation uses
+ * the measured width of each rendered cell and appends a trailing `…`
+ * when the next whole cell would exceed the budget.
  *
  * Themed mode colours the glyphs by status; plain mode emits the same
- * ASCII shape so logs remain readable.
+ * bracketed shape so logs remain readable.
  */
 export function progressStrip(
   cells: readonly ProgressCell[],
   budget: number,
   theme?: GraphTheme,
 ): string {
-  const CELL_WIDTH = 3;
   const usable = Math.max(0, Math.floor(budget));
-  const maxCells = Math.max(0, Math.floor(usable / CELL_WIDTH));
-  if (maxCells === 0 || cells.length === 0) return "";
-
-  const truncated = cells.length > maxCells;
-  // Reserve 1 cell of width for the trailing ellipsis if truncating, so the
-  // rendered output still fits.
-  const visibleCount = truncated
-    ? Math.max(0, Math.floor((usable - 1) / CELL_WIDTH))
-    : cells.length;
-  const slice = cells.slice(0, visibleCount);
-
-  let out = "";
-  if (theme) {
-    for (const cell of slice) {
-      out += renderCellThemed(cell.status, theme);
-    }
-  } else {
-    for (const cell of slice) {
-      out += renderCellPlain(cell.status);
-    }
+  if (usable < 3 || cells.length === 0) return "";
+
+  const ellipsisWidth = visibleWidth(ELLIPSIS);
+  const out: string[] = [];
+  let used = 0;
+
+  for (let i = 0; i < cells.length; i++) {
+    const rendered = theme ? renderCellThemed(cells[i]!.status, theme) : renderCellPlain(cells[i]!.status);
+    const renderedWidth = visibleWidth(rendered);
+    const isLast = i === cells.length - 1;
+    const reserved = isLast ? 0 : ellipsisWidth;
+    if (used + renderedWidth + reserved > usable) break;
+    out.push(rendered);
+    used += renderedWidth;
+    if (isLast) return out.join("");
   }
-  if (truncated) {
-    out += theme ? `${hexToAnsi(theme.dim)}${ELLIPSIS}${RESET}` : ELLIPSIS;
-  }
-  return out;
+
+  if (out.length === 0 && ellipsisWidth > usable) return "";
+  const suffix = theme ? `${hexToAnsi(theme.dim)}${ELLIPSIS}${RESET}` : ELLIPSIS;
+  return `${out.join("")}${suffix}`;
 }
 
 function renderCellThemed(status: StageStatus, theme: GraphTheme): string {
@@ -506,6 +503,7 @@ function stageGlyph(status: StageStatus): string {
   switch (status) {
     case "completed": return "✓";
     case "running":   return "●";
+    case "paused":    return "❚❚";
     case "failed":    return "✗";
     case "awaiting_input": return "？";
     case "skipped":   return "⊘";
@@ -518,6 +516,7 @@ function stageColor(status: StageStatus, theme: GraphTheme): string {
   switch (status) {
     case "completed": return hexToAnsi(theme.success);
     case "running":   return hexToAnsi(theme.warning);
+    case "paused":    return hexToAnsi(theme.warning);
     case "failed":    return hexToAnsi(theme.error);
     case "awaiting_input": return hexToAnsi(theme.info);
     case "skipped":   return hexToAnsi(theme.dim);

package/dist/builtin/workflows/src/tui/graph-view.ts

@@ -357,7 +357,10 @@ export class GraphView implements Component {
       ? expandWorkflowGraph(this.currentSnapshot, run.id)
       : { stages: [], targets: new Map() };
     const stages = [...this.expandedGraph.stages];
-    const hasStagePrompt = stages.some((stage) => stage.pendingPrompt !== undefined);
+    const hasStagePrompt = stages.some((stage) =>
+      stage.pendingPrompt !== undefined ||
+      (stage.status === "awaiting_input" && stage.promptFootprint?.kind === "custom")
+    );
     if (!hasStagePrompt) return stages;
     return stages.filter((stage) => {
       // Prompt-node injection can leave unstarted author stages in the store

package/dist/builtin/workflows/src/tui/prompt-card.ts

@@ -130,6 +130,8 @@ export function handlePromptCardInput(
       return handleInput(data, state, keybindings);
     case "editor":
       return handleEditor(data, state, keybindings);
+    case "custom":
+      return { kind: "noop" };
   }
 }
 
@@ -436,6 +438,8 @@ export function defaultResponseFor(prompt: PendingPrompt): unknown {
       return false;
     case "select":
       return prompt.choices?.[0] ?? "";
+    case "custom":
+      return undefined;
   }
 }
 
@@ -669,6 +673,8 @@ function renderResponseField(
       return [renderInputRow(state, theme, usable, cursorOn)];
     case "editor":
       return renderEditorRows(state, theme, usable, cursorOn);
+    case "custom":
+      return [padToUsable("", usable)];
   }
 }
 

package/dist/builtin/workflows/src/tui/run-detail.ts

@@ -90,7 +90,10 @@ function renderPlain(detail: RunDetail, now: number, width: number): string {
   }
 
   if (detail.endedAt === undefined) {
-    out.push(truncateToWidth(` ▸ workflow interrupt   id=${sid}    cancel `, width - 2, "…"));
+    const hint = detail.status === "paused"
+      ? ` ▸ workflow resume id=${sid}    continue workflow `
+      : ` ▸ workflow interrupt   id=${sid}    cancel `;
+    out.push(truncateToWidth(hint, width - 2, "…"));
   } else {
     out.push(truncateToWidth(` ▸ workflow resume id=${sid}    reopen graph `, width - 2, "…"));
   }
@@ -143,9 +146,10 @@ function renderThemed(detail: RunDetail, now: number, theme: GraphTheme, width:
   }
 
   if (detail.endedAt === undefined) {
-    out.push(
-      truncateToWidth(` ${dim}▸${RESET} ${accent}workflow interrupt   id=${sid}${RESET}${dim}    cancel${RESET} `, width - 2, "…"),
-    );
+    const hint = detail.status === "paused"
+      ? ` ${dim}▸${RESET} ${accent}workflow resume id=${sid}${RESET}${dim}    continue workflow${RESET} `
+      : ` ${dim}▸${RESET} ${accent}workflow interrupt   id=${sid}${RESET}${dim}    cancel${RESET} `;
+    out.push(truncateToWidth(hint, width - 2, "…"));
   } else {
     out.push(
       truncateToWidth(` ${dim}▸${RESET} ${accent}workflow resume id=${sid}${RESET}${dim}    reopen graph${RESET} `, width - 2, "…"),
@@ -295,6 +299,8 @@ function stateBadges(detail: RunDetail, theme: GraphTheme): FlatBandBadge[] {
   switch (detail.status) {
     case "running":
       return [{ text: "● running", fg: theme.warning }];
+    case "paused":
+      return [{ text: "❚❚ paused", fg: theme.warning }];
     case "completed":
       return [{ text: "✓ completed", fg: theme.success }];
     case "failed":
@@ -310,6 +316,7 @@ function stateBadges(detail: RunDetail, theme: GraphTheme): FlatBandBadge[] {
 function stateLabel(detail: RunDetail): string {
   switch (detail.status) {
     case "running": return "● running";
+    case "paused": return "❚❚ paused";
     case "completed": return "✓ completed";
     case "failed": return "✗ failed";
     case "killed": return "⊘ killed";

package/dist/builtin/workflows/src/tui/stage-chat-view.ts

@@ -424,6 +424,14 @@ export class StageChatView implements Component, Focusable {
       );
       return;
     }
+    if (request.options?.overlay === true) {
+      this.mountingRequestId = null;
+      this.stageUiBroker.reject(
+        request,
+        new Error("atomic-workflows: ctx.ui.custom overlay mode is unavailable in the workflow graph viewer"),
+      );
+      return;
+    }
     try {
       const mounted = await mountStageCustomUi(
         request,
@@ -1595,7 +1603,6 @@ function transcriptDebugText(entry: TranscriptEntry): string {
       case "custom":
         return extractMessageText(entry.message.content);
       case "branchSummary":
-      case "compactionSummary":
         return entry.message.summary;
     }
   }
@@ -1850,6 +1857,9 @@ function renderHintsForPrompt(kind: PendingPrompt["kind"], theme: GraphTheme): s
   if (kind === "input" || kind === "editor") {
     return `${paint("enter", theme.textMuted, { bold: true })} Submit · ${paint("ctrl+c", theme.textMuted, { bold: true })} Skip`;
   }
+  if (kind === "custom") {
+    return `${paint("ctrl+d", theme.textMuted, { bold: true })} Graph · ${paint("ctrl+c", theme.textMuted, { bold: true })} Close`;
+  }
   return `${paint("enter", theme.textMuted, { bold: true })} Select · ${paint("ctrl+c", theme.textMuted, { bold: true })} Skip`;
 }
 

package/dist/builtin/workflows/src/tui/status-list.ts

@@ -160,6 +160,7 @@ function runAccent(run: RunSnapshot, theme?: GraphTheme): string {
   switch (run.status) {
     case "completed": return theme.success;
     case "running":   return theme.warning;
+    case "paused":    return theme.warning;
     case "failed":    return theme.error;
     case "killed":    return theme.error;
     case "pending":
@@ -171,6 +172,7 @@ function runTrailing(run: RunSnapshot, theme?: GraphTheme): { text: string; fg?:
   switch (run.status) {
     case "completed": return { text: "✓ completed", fg: theme?.success };
     case "running":   return { text: "● running", fg: theme?.warning };
+    case "paused":    return { text: "❚❚ paused", fg: theme?.warning };
     case "failed":    return { text: "✗ failed", fg: theme?.error };
     case "killed":    return { text: "⊘ killed", fg: theme?.error };
     case "pending":
@@ -181,6 +183,7 @@ function runTrailing(run: RunSnapshot, theme?: GraphTheme): { text: string; fg?:
 function runCardMeta(run: RunSnapshot, now: number): string {
   // Builds the right-aligned meta tail.
   //   running  → `3/8 · review-a · 1m42s`
+  //   paused   → `3/8 · review-a · 1m42s` (elapsed is frozen by pausedAt)
   //   failed   → `failed at partition · 4m24s ago`
   //   killed   → `<stage> · <duration> · <when>` (mirrors mockup §2)
   //   completed→ `<stage> · <duration> · <when>`
@@ -204,6 +207,14 @@ function runCardMeta(run: RunSnapshot, now: number): string {
     return parts.join(" · ");
   }
 
+  if (run.status === "paused") {
+    if (isChain) parts.push(`${done}/${total}`);
+    const labels = pausedStageLabels(run);
+    if (labels) parts.push(labels);
+    if (ago) parts.push(ago);
+    return parts.join(" · ");
+  }
+
   if (run.status === "failed" || run.status === "killed") {
     const failed = run.stages.find((s) => s.status === "failed");
     if (failed && isChain) parts.push(`failed at ${failed.name}`);
@@ -235,6 +246,13 @@ function runningStageLabels(run: RunSnapshot): string | undefined {
   return truncateToWidth(joined, STAGE_LABEL_BUDGET, ELLIPSIS);
 }
 
+function pausedStageLabels(run: RunSnapshot): string | undefined {
+  const paused = run.stages.filter((s) => s.status === "paused").map((s) => s.name);
+  if (paused.length === 0) return undefined;
+  const joined = paused.join(", ");
+  return truncateToWidth(joined, STAGE_LABEL_BUDGET, ELLIPSIS);
+}
+
 function lastStageDuration(run: RunSnapshot, now: number): string | undefined {
   // Pick a representative stage duration: the most-recent terminal stage,
   // or the running stage if everything's still in flight.
@@ -263,6 +281,7 @@ function stageStatusFromRun(run: RunSnapshot): StageStatus {
   switch (run.status) {
     case "completed": return "completed";
     case "running":   return "running";
+    case "paused":    return "paused";
     case "failed":    return "failed";
     case "killed":    return "failed";
     case "pending":
@@ -285,17 +304,21 @@ function effectiveWidth(width?: number): number {
 
 interface Counts {
   active: number;
+  paused: number;
   completed: number;
   failed: number;
   pending: number;
 }
 
 function countBuckets(runs: readonly RunSnapshot[]): Counts {
-  const c: Counts = { active: 0, completed: 0, failed: 0, pending: 0 };
+  const c: Counts = { active: 0, paused: 0, completed: 0, failed: 0, pending: 0 };
   for (const r of runs) {
     if (r.endedAt === undefined) {
       if (r.status === "pending") c.pending++;
-      else c.active++;
+      else if (r.status === "paused") c.paused++;
+      else if (r.status === "running") c.active++;
+      else if (r.status === "completed") c.completed++;
+      else c.failed++;
     } else if (r.status === "completed") c.completed++;
     else c.failed++;
   }
@@ -306,6 +329,9 @@ function themedBadges(c: Counts, theme: GraphTheme): FlatBandBadge[] {
   const out: FlatBandBadge[] = [];
   if (c.completed > 0) out.push({ text: `✓ ${c.completed}`, fg: theme.success });
   if (c.active > 0) out.push({ text: `● ${c.active}`, fg: theme.warning });
+  // Keep the word label: the pause glyph is less familiar than the other
+  // status glyphs, so this intentional asymmetry improves scanability.
+  if (c.paused > 0) out.push({ text: `❚❚ ${c.paused} paused`, fg: theme.warning });
   if (c.pending > 0) out.push({ text: `○ ${c.pending}`, fg: theme.dim });
   if (c.failed > 0) out.push({ text: `⊘ ${c.failed}`, fg: theme.error });
   return out;
@@ -315,6 +341,9 @@ function plainBadges(c: Counts): FlatBandBadge[] {
   const out: FlatBandBadge[] = [];
   if (c.completed > 0) out.push({ text: `✓ ${c.completed}` });
   if (c.active > 0) out.push({ text: `● ${c.active}` });
+  // Keep the word label: the pause glyph is less familiar than the other
+  // status glyphs, so this intentional asymmetry improves scanability.
+  if (c.paused > 0) out.push({ text: `❚❚ ${c.paused} paused` });
   if (c.pending > 0) out.push({ text: `○ ${c.pending}` });
   if (c.failed > 0) out.push({ text: `⊘ ${c.failed}` });
   return out;
@@ -344,6 +373,7 @@ function statusIconForRun(run: RunSnapshot): string {
   switch (run.status) {
     case "completed": return "✓";
     case "running": return "●";
+    case "paused": return "❚❚";
     case "failed": return "✗";
     case "killed": return "⊘";
     case "pending":

package/dist/cli/args.d.ts

@@ -16,12 +16,15 @@ export interface Args {
     help?: boolean;
     version?: boolean;
     mode?: Mode;
+    name?: string;
     noSession?: boolean;
     session?: string;
+    sessionId?: string;
     fork?: string;
     sessionDir?: string;
     models?: string[];
     tools?: string[];
+    excludeTools?: string[];
     noTools?: boolean;
     noBuiltinTools?: boolean;
     extensions?: string[];
@@ -38,6 +41,7 @@ export interface Args {
     listModels?: string | true;
     offline?: boolean;
     verbose?: boolean;
+    projectTrustOverride?: boolean;
     messages: string[];
     fileArgs: string[];
     /** Unknown flags (potentially extension flags) - map of flag name to value */