@bastani/atomic 0.8.28-alpha.1 → 0.8.28-alpha.2

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,6 +6,14 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.8.28-alpha.2] - 2026-06-10
+
+### Fixed
+
+- Fixed the builtin `open-claude-design` workflow not installing the browser skill's `browse` CLI before it is needed. The workflow now runs an initial deterministic, best-effort setup step that probes `PATH` (`which`/`where browse`) and installs the CLI with `npm install -g browse` when missing (skipped under automated tests); per-run bootstrap guidance is derived from the outcome and injected into every browser-using stage (assume-available when ensured, with concrete recovery steps surfaced when the install failed), the install outcome is exposed via a new `browse_cli_status` output, and the read-only `read`/`grep`/`ls` tools are granted to the refinement and pre-export decision gates so they can inspect `preview.html` without mutating it. The step never throws or blocks the run, so stages keep their graceful-degradation fallback ([#1327](https://github.com/bastani-inc/atomic/issues/1327)).
+- Fixed paused workflow run detail cards to surface the natural `workflow resume` action hint while preserving the interrupt hint for non-paused active runs ([#1283](https://github.com/bastani-inc/atomic/issues/1283)).
+- Fixed paused workflow runs being counted as running and displayed as pending/running in `/workflow status` and `/workflow status <id>`, with paused runs now shown separately as `❚❚ paused` ([#1283](https://github.com/bastani-inc/atomic/issues/1283)).
+
 ## [0.8.28-alpha.1] - 2026-06-09
 
 ### Added

package/dist/builtin/workflows/builtin/open-claude-design.ts

@@ -23,7 +23,10 @@
  * a real HTML page on disk (`preview.html`). The workflow attempts to open it
  * through the `browser` skill so the user can interactively review;
  * when browser automation is unavailable, the file path is surfaced so the user
- * can open it manually. The final exporter produces a rich `spec.html` that
+ * can open it manually. Before any stage runs, an initial deterministic setup
+ * step ensures the browser skill's `browse` CLI is available (`which browse`,
+ * then `npm install -g browse` when missing); it is best-effort and never
+ * blocks the run. The final exporter produces a rich `spec.html` that
  * embeds the agreed-upon design alongside the implementation handoff.
  */
 
@@ -33,6 +36,7 @@ import type {
   WorkflowTaskResult,
   WorkflowTaskStep,
 } from "../src/shared/types.js";
+import { spawnSync } from "node:child_process";
 import { mkdirSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -49,6 +53,15 @@ type OutputType = (typeof OUTPUT_TYPES)[number];
 const DEFAULT_OUTPUT_TYPE: OutputType = "prototype";
 const DEFAULT_MAX_REFINEMENTS = 3;
 
+/**
+ * Read-only builtin tools granted to the structured-decision stages
+ * (user-feedback refinement gate and pre-export gate) so they can actually
+ * inspect the on-disk `preview.html` before emitting their decision. The
+ * artifact stays immutable here — writes/edits belong to apply-changes and
+ * forced-fix, so this list deliberately excludes write/edit/bash.
+ */
+const READ_ONLY_TOOLS = ["read", "grep", "ls"] as const;
+
 type PromptSection = readonly [tag: string, content: string];
 
 function taggedPrompt(sections: readonly PromptSection[]): string {
@@ -275,11 +288,126 @@ const ANTI_SLOP_RULES = [
   "Commit to a specific aesthetic direction; do not hedge with generic SaaS defaults.",
 ].join("\n");
 
-const BROWSER_USE_BOOTSTRAP_RULES = [
-  "Probe for the browser skill's `browse` CLI with `which browse`; if it is unavailable, install the CLI with `npm install -g browse` as documented by the skill, then retry once. Do not add project dependencies.",
-  "Use `browse open <url> --local --headed` when a generated local preview should be visible to the user, and use `browse snapshot` plus `browse screenshot --path <file>` for review evidence.",
-  "If `browse` is unavailable after three attempts or the browser runtime still fails, degrade gracefully and surface the manual file path / URL.",
-].join("\n");
+type BrowseCliStatus = {
+  /** Whether the `browse` CLI is expected to be available to downstream stages. */
+  readonly available: boolean;
+  /** True when the CLI was already on PATH and no install was attempted. */
+  readonly alreadyPresent: boolean;
+  /** True when this step installed the CLI via `npm install -g browse`. */
+  readonly installed: boolean;
+  /** Human-readable, single-line outcome surfaced as a workflow output. */
+  readonly summary: string;
+  /** Raw failure reason when the install could not complete; absent on success. */
+  readonly error?: string;
+};
+
+/**
+ * Initial deterministic setup step (no LLM): ensure the browser skill's `browse`
+ * CLI is available before any design stage runs. Mirrors the browser skill's
+ * documented bootstrap (`which browse || npm install -g browse`) but performs it
+ * once, deterministically, instead of relying on each stage to probe/install it.
+ * The PATH probe always runs, but the actual global install is skipped under
+ * automated tests (`NODE_ENV=test`) to avoid slow, networked, environment-
+ * mutating side effects.
+ *
+ * Best-effort by contract: it never throws and never blocks the workflow. When
+ * the CLI cannot be located or installed, downstream stages keep their graceful
+ * degradation path (surface the manual preview path / URL).
+ */
+function ensureBrowseCli(): BrowseCliStatus {
+  const isWindows = process.platform === "win32";
+  const onPath = (): boolean => {
+    try {
+      const probe = spawnSync(isWindows ? "where" : "which", ["browse"], {
+        stdio: "ignore",
+        timeout: 15_000,
+        shell: isWindows,
+      });
+      return probe.status === 0;
+    } catch {
+      return false;
+    }
+  };
+
+  if (onPath()) {
+    return {
+      available: true,
+      alreadyPresent: true,
+      installed: false,
+      summary: "browse CLI already on PATH; skipped install.",
+    };
+  }
+
+  // Never perform a real global `npm install` during automated tests: it is
+  // slow, network-dependent, and would mutate the test runner's global
+  // environment. The PATH probe above and the prompt guidance below are still
+  // exercised; only the install side effect is skipped.
+  if (process.env.NODE_ENV === "test") {
+    return {
+      available: false,
+      alreadyPresent: false,
+      installed: false,
+      summary:
+        "browse CLI not found; skipped global install under the test environment.",
+      error: "global install skipped during tests",
+    };
+  }
+
+  try {
+    const install = spawnSync("npm", ["install", "-g", "browse"], {
+      stdio: "ignore",
+      timeout: 180_000,
+      shell: isWindows,
+    });
+    if (install.status === 0) {
+      return {
+        available: true,
+        alreadyPresent: false,
+        installed: true,
+        summary: "Installed browse CLI via `npm install -g browse`.",
+      };
+    }
+    const reason =
+      install.error?.message ??
+      (typeof install.status === "number"
+        ? `npm install -g browse exited with code ${install.status}`
+        : "npm install -g browse did not complete");
+    return {
+      available: false,
+      alreadyPresent: false,
+      installed: false,
+      summary: `Could not install browse CLI (${reason}); stages will degrade gracefully.`,
+      error: reason,
+    };
+  } catch (error) {
+    const reason =
+      error instanceof Error ? error.message : String(error);
+    return {
+      available: false,
+      alreadyPresent: false,
+      installed: false,
+      summary: `Could not install browse CLI (${reason}); stages will degrade gracefully.`,
+      error: reason,
+    };
+  }
+}
+
+/**
+ * Build the per-run browser bootstrap guidance injected into stage prompts.
+ * When the deterministic setup step already ensured `browse` is installed, the
+ * guidance tells stages to assume availability and not waste turns reinstalling;
+ * otherwise it retains the original probe-and-install fallback.
+ */
+function buildBrowserBootstrapRules(status: BrowseCliStatus): string {
+  const probeRule = status.available
+    ? "The workflow's deterministic setup step already ensured the browser skill's `browse` CLI is installed and on PATH; assume it is available and do NOT reinstall it. Only if a `browse` command reports the executable as missing should you re-probe with `which browse` and run `npm install -g browse` once before retrying. Do not add project dependencies."
+    : `The workflow's deterministic setup step attempted to install the browser skill's \`browse\` CLI but it FAILED with: "${status.error ?? "unknown error"}". Treat this as a known starting condition to work around, not a hard blocker. Probe with \`which browse\` and retry once with \`npm install -g browse\`; if it still fails, use the error above to diagnose a workaround (for example: EACCES/permission errors → retry with a user-writable global prefix; missing npm/Node → report it plainly; network/registry errors → surface them). If the CLI still cannot be made available, degrade gracefully and surface the manual file path / URL. Do not add project dependencies.`;
+  return [
+    probeRule,
+    "Use `browse open <url> --local --headed` when a generated local preview should be visible to the user, and use `browse snapshot` plus `browse screenshot --path <file>` for review evidence.",
+    "If `browse` is unavailable after three attempts or the browser runtime still fails, degrade gracefully and surface the manual file path / URL.",
+  ].join("\n");
+}
 
 export default defineWorkflow("open-claude-design")
   .description(
@@ -316,7 +444,15 @@ export default defineWorkflow("open-claude-design")
   .output("preview_file_url", Type.Optional(Type.String({ description: "file:// URL for the generated preview.html file." })))
   .output("spec_path", Type.Optional(Type.String({ description: "Absolute path to the generated spec.html file." })))
   .output("spec_file_url", Type.Optional(Type.String({ description: "file:// URL for the generated spec.html file." })))
+  .output("browse_cli_status", Type.Optional(Type.String({ description: "Outcome of the initial deterministic step that ensures the browser skill's `browse` CLI is installed." })))
   .run(async (ctx) => {
+    // Initial deterministic setup step (no LLM): ensure the browser skill's
+    // `browse` CLI is installed before any design stage runs. Best-effort —
+    // a failed install never blocks the workflow; downstream stages keep their
+    // graceful-degradation fallback (surface the manual preview path / URL).
+    const browseCli = ensureBrowseCli();
+    const browserBootstrapRules = buildBrowserBootstrapRules(browseCli);
+
     const inputs = ctx.inputs;
 
     const prompt = inputs.prompt;
@@ -344,12 +480,12 @@ export default defineWorkflow("open-claude-design")
     };
     const refinementDecisionConfig = {
       ...designModelConfig,
-      tools: [refinementDecisionTool.name],
+      tools: [...READ_ONLY_TOOLS, refinementDecisionTool.name],
       customTools: [refinementDecisionTool],
     };
     const exportGateDecisionConfig = {
       ...designModelConfig,
-      tools: [exportGateDecisionTool.name],
+      tools: [...READ_ONLY_TOOLS, exportGateDecisionTool.name],
       customTools: [exportGateDecisionTool],
     };
 
@@ -551,7 +687,7 @@ export default defineWorkflow("open-claude-design")
             `Capture transferable design intent from this reference for: ${prompt}. Apply the impeccable \`extract\` sub-skill to lift concrete, citable design traits from the reference URL. Use browser/screenshot tooling if available; never guess about visual traits without observable evidence.`,
           ],
           ["reference_url", reference],
-          ["browser_use_guidelines", BROWSER_USE_BOOTSTRAP_RULES],
+          ["browser_use_guidelines", browserBootstrapRules],
           [
             "instructions",
             [
@@ -671,7 +807,7 @@ export default defineWorkflow("open-claude-design")
           ],
           ["preview_path", previewPath],
           ["preview_file_url", previewFileUrl],
-          ["browser_use_guidelines", BROWSER_USE_BOOTSTRAP_RULES],
+          ["browser_use_guidelines", browserBootstrapRules],
           [
             "instructions",
             [
@@ -794,7 +930,7 @@ export default defineWorkflow("open-claude-design")
               ["current_design_and_feedback", "{previous}"],
               [
                 "browser_use_guidelines",
-                BROWSER_USE_BOOTSTRAP_RULES,
+                browserBootstrapRules,
               ],
               [
                 "instructions",
@@ -881,7 +1017,7 @@ export default defineWorkflow("open-claude-design")
             ["preview_file_url", previewFileUrl],
             [
               "browser_use_bootstrap",
-              BROWSER_USE_BOOTSTRAP_RULES,
+              browserBootstrapRules,
             ],
             [
               "instructions",
@@ -1044,7 +1180,7 @@ export default defineWorkflow("open-claude-design")
           ["spec_file_url", specFileUrl],
           ["preview_path", previewPath],
           ["preview_file_url", previewFileUrl],
-          ["browser_use_guidelines", BROWSER_USE_BOOTSTRAP_RULES],
+          ["browser_use_guidelines", browserBootstrapRules],
           [
             "instructions",
             [
@@ -1078,6 +1214,7 @@ export default defineWorkflow("open-claude-design")
       preview_file_url: previewFileUrl,
       spec_path: specPath,
       spec_file_url: specFileUrl,
+      browse_cli_status: browseCli.summary,
     };
   })
   .compile();

package/dist/builtin/workflows/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/workflows",
-  "version": "0.8.28-alpha.1",
+  "version": "0.8.28-alpha.2",
   "private": true,
   "description": "Atomic extension for multi-stage workflow authoring and execution.",
   "contributors": [

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/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/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 */