@bastani/atomic 0.9.9 → 0.9.10-alpha.1

package/dist/builtin/workflows/src/extension/workflow-schema.ts

@@ -1,116 +1,4 @@
-import type { CreateAgentSessionOptions } from "@bastani/atomic";
 import { Type, type Static } from "typebox";
-import type { WorkflowModelValue } from "../shared/types.js";
-
-type ArrayElement<T> = T extends readonly (infer Element)[] ? Element : never;
-
-const SdkSessionOptionSchema = <Key extends keyof CreateAgentSessionOptions>(_key: Key) =>
-  Type.Unsafe<NonNullable<CreateAgentSessionOptions[Key]>>({});
-
-const SdkSessionOptionArrayElementSchema = <Key extends keyof CreateAgentSessionOptions>(_key: Key) =>
-  Type.Unsafe<ArrayElement<NonNullable<CreateAgentSessionOptions[Key]>>>({});
-
-const IntercomOptionsSchema = Type.Object({
-  enabled: Type.Optional(Type.Boolean()),
-  delivery: Type.Optional(Type.Union([
-    Type.Literal("off"),
-    Type.Literal("notify"),
-    Type.Literal("result"),
-    Type.Literal("control-and-result"),
-  ])),
-  parentSession: Type.Optional(Type.String()),
-  notifyOn: Type.Optional(Type.Array(Type.Union([
-    Type.Literal("active_long_running"),
-    Type.Literal("needs_attention"),
-    Type.Literal("completed"),
-    Type.Literal("failed"),
-  ]))),
-});
-
-const MaxOutputSchema = Type.Object({
-  bytes: Type.Optional(Type.Number()),
-  lines: Type.Optional(Type.Number()),
-});
-
-const McpOptionsSchema = Type.Object({
-  allow: Type.Optional(Type.Array(Type.String())),
-  deny: Type.Optional(Type.Array(Type.String())),
-});
-
-const JsonSchemaObject = Type.Unsafe<Record<string, unknown>>({
-  type: "object",
-  additionalProperties: true,
-  description: "Plain JSON Schema used as final-answer tool arguments for this workflow item.",
-});
-
-const StageSessionOptionProperties = {
-  schema: Type.Optional(JsonSchemaObject),
-  cwd: Type.Optional(Type.String({ description: "Starting directory only; does not provide worktree isolation." })),
-  agentDir: Type.Optional(Type.String()),
-  authStorage: Type.Optional(SdkSessionOptionSchema("authStorage")),
-  modelRegistry: Type.Optional(SdkSessionOptionSchema("modelRegistry")),
-  model: Type.Optional(Type.Unsafe<WorkflowModelValue>({ description: "Primary model id or SDK model object. String ids may include a reasoning suffix, e.g. openai/gpt-5:high; valid levels: off|minimal|low|medium|high|xhigh|max. A parenthesized context-window token may precede or follow the suffix, e.g. github-copilot/claude-opus-4.8 (1m):xhigh or github-copilot/claude-opus-4.8:xhigh (1m). Use (long) for a generic long-context marker, or a rounded size matching the model's long tier (e.g. (1m) or (1.1m)); both select the model's advertised long tier." })),
-  contextWindow: Type.Optional(Type.Number({ description: "Context-window token budget for the stage session (e.g. 1000000). Non-strict by default: an unsupported value keeps the model's default window. Prefer the per-model `(1m)` token in a model/fallbackModels entry when only specific models should use a larger window." })),
-  contextWindowStrict: Type.Optional(Type.Boolean({ description: "Treat an unsupported contextWindow as an error instead of falling back to the model's default window." })),
-  thinkingLevel: Type.Optional(SdkSessionOptionSchema("thinkingLevel")),
-  scopedModels: Type.Optional(Type.Array(SdkSessionOptionArrayElementSchema("scopedModels"))),
-  noTools: Type.Optional(Type.Unsafe<NonNullable<CreateAgentSessionOptions["noTools"]>>({
-    enum: ["all", "builtin"],
-  })),
-  tools: Type.Optional(Type.Array(Type.String())),
-  customTools: Type.Optional(Type.Array(SdkSessionOptionArrayElementSchema("customTools"))),
-  resourceLoader: Type.Optional(SdkSessionOptionSchema("resourceLoader")),
-  sessionManager: Type.Optional(SdkSessionOptionSchema("sessionManager")),
-  settingsManager: Type.Optional(SdkSessionOptionSchema("settingsManager")),
-  sessionStartEvent: Type.Optional(SdkSessionOptionSchema("sessionStartEvent")),
-  fallbackModels: Type.Optional(Type.Array(Type.String({ description: "Fallback model id; may include a reasoning suffix like :low or :off." }))),
-  fallbackThinkingLevels: Type.Optional(Type.Array(Type.String({ description: "Deprecated compatibility helper aligned to fallbackModels; ignored when the fallback model has a :level suffix." }))),
-  mcp: Type.Optional(McpOptionsSchema),
-  sessionDir: Type.Optional(Type.String()),
-  context: Type.Optional(Type.Union([Type.Literal("fresh"), Type.Literal("fork")])),
-  forkFromSessionFile: Type.Optional(Type.String()),
-};
-
-// Keep this union opaque to Value.Convert: branch ordering otherwise coerces
-// boolean false to "false", or the legitimate string path "false" to false.
-const WorkflowOutputSchema = Type.Unsafe<string | false>({
-  not: {
-    not: {
-      anyOf: [
-        { type: "string" },
-        { const: false },
-      ],
-    },
-  },
-});
-
-const WorkflowTaskOptionProperties = {
-  output: Type.Optional(WorkflowOutputSchema),
-  outputMode: Type.Optional(Type.Union([Type.Literal("inline"), Type.Literal("file-only")])),
-  reads: Type.Optional(Type.Union([Type.Array(Type.String()), Type.Literal(false)])),
-  worktree: Type.Optional(Type.Boolean({ description: "Runner-managed temporary per-task worktree isolation for direct runs." })),
-  gitWorktreeDir: Type.Optional(Type.String({ description: "Runner-managed reusable worktree; natural-language worktree instructions do not set this option." })),
-  baseBranch: Type.Optional(Type.String()),
-  maxOutput: Type.Optional(MaxOutputSchema),
-  artifacts: Type.Optional(Type.Boolean()),
-};
-
-const DirectTaskSchema = Type.Object({
-  name: Type.String({ description: "Task/stage label." }),
-  prompt: Type.Optional(Type.String({ description: "Prompt text for this task." })),
-  task: Type.Optional(Type.String({ description: "Task text for this task." })),
-  ...StageSessionOptionProperties,
-  ...WorkflowTaskOptionProperties,
-});
-
-const ParallelChainStepSchema = Type.Object({
-  parallel: Type.Array(DirectTaskSchema),
-  concurrency: Type.Optional(Type.Number()),
-  failFast: Type.Optional(Type.Boolean()),
-  worktree: Type.Optional(Type.Boolean({ description: "Runner-managed temporary per-task worktree isolation for direct runs." })),
-  gitWorktreeDir: Type.Optional(Type.String({ description: "Runner-managed reusable worktree; natural-language worktree instructions do not set this option." })),
-  baseBranch: Type.Optional(Type.String()),
-});
 
 export const WorkflowParametersSchema = Type.Object({
   workflow: Type.Optional(Type.String({
@@ -132,17 +20,17 @@ export const WorkflowParametersSchema = Type.Object({
     Type.Literal("send"),
     Type.Literal("pause"),
     Type.Literal("interrupt"),
-    Type.Literal("kill"),
+    Type.Literal("quit"),
     Type.Literal("resume"),
     Type.Literal("reload"),
   ], {
-    description: "Workflow action: run/list/get/inputs/status, inspect stage metadata, send messages or prompt answers, pause/resume/interrupt/kill runs, or reload workflow resources. For transcript inspection, prefer status/stages/stage first to get sessionFile/transcriptPath, quote the exact path without rewriting separators (Windows backslashes are valid), then search it with rg/grep and read small ranges; transcript is path-only by default when sessionFile/transcriptPath exists, explicit tail/limit returns bounded previews, and missing transcript paths fall back to a small preview.",
+    description: "Workflow action: run/list/get/inputs/status, inspect stage metadata, send messages or prompt answers, pause/resume/interrupt/quit runs, or reload workflow resources. 'status' without runId lists every workflow run in the current session with concise per-run summaries (status, timing, active stages, awaiting-input prompts); filter the listing with statusFilter. 'status' with runId returns one run's full detail. For transcript inspection, prefer status/stages/stage first to get sessionFile/transcriptPath, quote the exact path without rewriting separators (Windows backslashes are valid), then search it with rg/grep and read small ranges; transcript is path-only by default when sessionFile/transcriptPath exists, explicit tail/limit returns bounded previews, and missing transcript paths fall back to a small preview.",
   })),
   runId: Type.Optional(Type.String({
-    description: "Run identifier or unique prefix for status/stages/stage/transcript/send/pause/resume/interrupt/kill. Use '--all' or all:true for supported bulk run-control actions.",
+    description: "Run identifier or unique prefix for status/stages/stage/transcript/send/pause/resume/interrupt/quit. Omit runId with action 'status' to list all session runs and their statuses. Use '--all' or all:true for supported bulk run-control actions.",
   })),
   all: Type.Optional(Type.Boolean({
-    description: "Apply supported run-control actions (pause/interrupt/kill) to all in-flight runs instead of one run; cannot be combined with stageId.",
+    description: "Apply supported run-control actions (pause/interrupt/quit) to all in-flight runs instead of one run; cannot be combined with stageId.",
   })),
   stageId: Type.Optional(Type.String({
     description: "Stage id, unique prefix, or stage name for stage-scoped inspection, transcript, send, pause, or resume.",
@@ -159,12 +47,14 @@ export const WorkflowParametersSchema = Type.Object({
     Type.Literal("completed"),
     Type.Literal("failed"),
     Type.Literal("skipped"),
+    Type.Literal("cancelled"),
+    Type.Literal("killed"),
     Type.Literal("all"),
   ], {
-    description: "Filter stages by status for the stages action; use 'all' to include every stage.",
+    description: "Filter stages (stages action) or listed runs (status action without runId) by status; 'all' (default) includes everything. For the status listing, run statuses match directly, 'awaiting_input' selects runs with at least one stage awaiting input or pending human prompt, and in-flight runs are listed first.",
   })),
   format: Type.Optional(Type.Union([Type.Literal("text"), Type.Literal("json")], {
-    description: "Agent-visible output format for data-bearing inspection actions.",
+    description: "Agent-visible output format for data-bearing inspection actions (status, stages, stage, transcript); 'json' returns the full structured result.",
   })),
   limit: Type.Optional(Type.Integer({
     minimum: 0,
@@ -199,20 +89,6 @@ export const WorkflowParametersSchema = Type.Object({
   reason: Type.Optional(Type.String({
     description: "Human-readable reason for the reload action, echoed in the reload result.",
   })),
-  task: Type.Optional(Type.Union([
-    DirectTaskSchema,
-    Type.String({ description: "Root task text for direct chain/parallel execution." }),
-  ])),
-  chainName: Type.Optional(Type.String()),
-  tasks: Type.Optional(Type.Array(DirectTaskSchema)),
-  chain: Type.Optional(Type.Array(Type.Union([DirectTaskSchema, ParallelChainStepSchema]))),
-  concurrency: Type.Optional(Type.Number()),
-  failFast: Type.Optional(Type.Boolean()),
-  async: Type.Optional(Type.Boolean()),
-  intercom: Type.Optional(IntercomOptionsSchema),
-  ...StageSessionOptionProperties,
-  ...WorkflowTaskOptionProperties,
-  chainDir: Type.Optional(Type.String()),
-});
+}, { additionalProperties: false });
 
 export type WorkflowParameters = Static<typeof WorkflowParametersSchema>;

package/dist/builtin/workflows/src/extension/workflow-status-summary.ts

@@ -0,0 +1,189 @@
+/**
+ * Concise per-run summaries for the workflow tool `status` listing.
+ *
+ * `workflow({ action: "status" })` without a `runId` lists every top-level
+ * run in the session. Each run is reduced to an agent-friendly summary that
+ * carries status, timing, active stages, and awaiting-input/pending-prompt
+ * information plus the identifiers needed to feed `pause`/`resume`/
+ * `interrupt`/`quit`/`send` directly.
+ *
+ * cross-ref:
+ *  - src/extension/workflow-tool.ts        `case "status"` (listing path)
+ *  - src/extension/workflow-tool-content.ts agent-visible text rendering
+ *  - src/extension/workflow-targets.ts      topLevelExpandedSnapshots()
+ */
+
+import type {
+  PendingPrompt,
+  RunSnapshot,
+  RunStatus,
+  StageInputRequest,
+  StageSnapshot,
+  StageStatus,
+} from "../shared/store-types.js";
+import { effectiveRunStatus } from "../shared/returned-run-status.js";
+import { elapsedRunMs } from "../shared/timing.js";
+
+/**
+ * Status filter accepted by the `status` run listing (and the `stages`
+ * action). Run-level statuses match runs directly; `awaiting_input` selects
+ * runs with at least one stage awaiting input or pending human prompt;
+ * `all` (the default) includes everything.
+ */
+export type WorkflowRunStatusFilter = StageStatus | RunStatus | "all";
+
+const RUN_ID_PREFIX_LEN = 8;
+
+/** A currently active (running or awaiting-input) stage within a run. */
+export interface WorkflowStatusActiveStage {
+  /** Expanded-graph stage id; valid for stage-scoped send/pause/resume. */
+  readonly stageId: string;
+  readonly name: string;
+  readonly status: StageStatus;
+}
+
+/** One stage (or run-level) pending human-input descriptor. */
+export interface WorkflowStatusAwaitingInput {
+  /** Absent for a run-level HIL prompt. */
+  readonly stageId?: string;
+  readonly stageName?: string;
+  /** Pending prompt id; pass as `promptId` to `send` when answering. */
+  readonly promptId?: string;
+  readonly promptKind?: string;
+  readonly message?: string;
+}
+
+/**
+ * Concise, JSON-stable summary of one top-level run for the `status`
+ * listing. `runId` feeds pause/resume/interrupt/quit/send directly;
+ * `awaitingInput` entries carry the stage/prompt ids that `send` accepts.
+ */
+export interface WorkflowRunStatusSummary {
+  readonly runId: string;
+  /** Abbreviated run id as printed by status surfaces; a valid prefix input. */
+  readonly runIdPrefix: string;
+  /** Workflow/run name. */
+  readonly name: string;
+  readonly status: RunStatus;
+  readonly startedAt: number;
+  readonly endedAt?: number;
+  /** Pause-adjusted elapsed milliseconds (prior sessions included). */
+  readonly elapsedMs: number;
+  readonly activeStages: readonly WorkflowStatusActiveStage[];
+  readonly awaitingInputCount: number;
+  readonly awaitingInput: readonly WorkflowStatusAwaitingInput[];
+  readonly exitReason?: string;
+  readonly error?: string;
+}
+
+/** Filtered, ordered status listing: `runs[i]` summarizes `snapshots[i]`. */
+export interface WorkflowStatusListing {
+  readonly filter: WorkflowRunStatusFilter;
+  readonly runs: WorkflowRunStatusSummary[];
+  readonly snapshots: RunSnapshot[];
+}
+
+function stageIsActive(stage: StageSnapshot): boolean {
+  return stage.status === "running" || stage.status === "awaiting_input";
+}
+
+function stageAwaitingInput(stage: StageSnapshot): boolean {
+  return (
+    stage.status === "awaiting_input" ||
+    stage.awaitingInputSince !== undefined ||
+    stage.pendingPrompt !== undefined ||
+    stage.inputRequest !== undefined
+  );
+}
+
+function promptMessage(
+  prompt: PendingPrompt | undefined,
+  request: StageInputRequest | undefined,
+): string | undefined {
+  if (prompt !== undefined) return prompt.message;
+  return request?.questions[0]?.question;
+}
+
+function awaitingInputEntries(run: RunSnapshot): WorkflowStatusAwaitingInput[] {
+  const entries: WorkflowStatusAwaitingInput[] = [];
+  if (run.pendingPrompt !== undefined) {
+    entries.push({
+      promptId: run.pendingPrompt.id,
+      promptKind: run.pendingPrompt.kind,
+      message: run.pendingPrompt.message,
+    });
+  }
+  for (const stage of run.stages) {
+    if (!stageAwaitingInput(stage)) continue;
+    const entry: WorkflowStatusAwaitingInput = {
+      stageId: stage.id,
+      stageName: stage.name,
+      promptId: stage.pendingPrompt?.id ?? stage.inputRequest?.id,
+      promptKind: stage.pendingPrompt?.kind ?? stage.inputRequest?.kind,
+      message: promptMessage(stage.pendingPrompt, stage.inputRequest),
+    };
+    entries.push(entry);
+  }
+  return entries;
+}
+
+/** Reduce one run snapshot to its concise status summary. */
+export function summarizeRunSnapshot(
+  run: RunSnapshot,
+  now = Date.now(),
+): WorkflowRunStatusSummary {
+  const awaitingInput = awaitingInputEntries(run);
+  return {
+    runId: run.id,
+    runIdPrefix: run.id.slice(0, RUN_ID_PREFIX_LEN),
+    name: run.name,
+    status: effectiveRunStatus(run),
+    startedAt: run.startedAt,
+    endedAt: run.endedAt,
+    elapsedMs: elapsedRunMs(run, now),
+    activeStages: run.stages.filter(stageIsActive).map((stage) => ({
+      stageId: stage.id,
+      name: stage.name,
+      status: stage.status,
+    })),
+    awaitingInputCount: awaitingInput.length,
+    awaitingInput,
+    exitReason: run.exitReason,
+    error: run.error,
+  };
+}
+
+/** True when the summarized run passes the status filter. */
+export function runMatchesStatusFilter(
+  summary: WorkflowRunStatusSummary,
+  filter: WorkflowRunStatusFilter,
+): boolean {
+  if (filter === "all") return true;
+  if (filter === "awaiting_input") return summary.awaitingInputCount > 0;
+  return summary.status === filter;
+}
+
+/**
+ * Build the filtered `status` run listing: summaries and their matching
+ * snapshots, in-flight runs first, then each bucket by startedAt descending.
+ */
+export function buildWorkflowStatusListing(
+  snapshots: readonly RunSnapshot[],
+  filter: WorkflowRunStatusFilter = "all",
+  now = Date.now(),
+): WorkflowStatusListing {
+  const paired = snapshots
+    .map((snapshot) => ({ snapshot, summary: summarizeRunSnapshot(snapshot, now) }))
+    .filter(({ summary }) => runMatchesStatusFilter(summary, filter));
+  paired.sort((a, b) => {
+    const aEnded = a.snapshot.endedAt === undefined ? 0 : 1;
+    const bEnded = b.snapshot.endedAt === undefined ? 0 : 1;
+    if (aEnded !== bEnded) return aEnded - bEnded;
+    return b.snapshot.startedAt - a.snapshot.startedAt;
+  });
+  return {
+    filter,
+    runs: paired.map((pair) => pair.summary),
+    snapshots: paired.map((pair) => pair.snapshot),
+  };
+}

package/dist/builtin/workflows/src/extension/workflow-targets.ts

@@ -42,7 +42,7 @@ export function topLevelExpandedSnapshots() {
 }
 
 
-export function allStageConflictMessage(action: "pause" | "interrupt" | "kill"): string {
+export function allStageConflictMessage(action: "pause" | "interrupt" | "quit"): string {
   return `Cannot ${action} --all with a stageId; omit stageId or target a single run.`;
 }
 

package/dist/builtin/workflows/src/extension/workflow-tool-content.ts

@@ -1,8 +1,13 @@
 import { deriveInputFields } from "../shared/schema-introspection.js";
 import type { WorkflowSerializableValue } from "../shared/types.js";
+import { fmtDuration } from "../tui/status-helpers.js";
 import type { ExtensionRuntime } from "./runtime.js";
 import type { WorkflowToolResult } from "./render-result.js";
 import type { WorkflowToolArgs } from "./public-types.js";
+import type {
+  WorkflowRunStatusSummary,
+  WorkflowStatusAwaitingInput,
+} from "./workflow-status-summary.js";
 
 function stringifyWorkflowToolResult(result: WorkflowToolResult): string {
   return JSON.stringify(result, null, 2);
@@ -10,7 +15,7 @@ function stringifyWorkflowToolResult(result: WorkflowToolResult): string {
 
 function compactWorkflowToolMessage(
   result: Extract<WorkflowToolResult, {
-    action: "send" | "pause" | "reload" | "interrupt" | "kill" | "resume";
+    action: "send" | "pause" | "reload" | "interrupt" | "quit" | "resume";
   }>,
 ): string {
   if (result.action === "reload") {
@@ -24,6 +29,75 @@ function compactWorkflowToolMessage(
   return `${result.action}:${target ? ` ${target}` : ""} ${result.status} — ${result.message}`;
 }
 
+const STATUS_MESSAGE_CHAR_LIMIT = 120;
+
+function truncateStatusText(text: string): string {
+  const flattened = text.replace(/\s+/g, " ").trim();
+  return flattened.length > STATUS_MESSAGE_CHAR_LIMIT
+    ? `${flattened.slice(0, STATUS_MESSAGE_CHAR_LIMIT - 1)}…`
+    : flattened;
+}
+
+function statusRunHint(run: WorkflowRunStatusSummary): string | undefined {
+  if (run.awaitingInputCount > 0) {
+    const stages = run.awaitingInput
+      .map((entry) => entry.stageName ?? entry.stageId)
+      .filter((name): name is string => name !== undefined && name.length > 0);
+    const suffix = stages.length > 0 ? `: ${stages.join(", ")}` : "";
+    return `awaiting input (${run.awaitingInputCount})${suffix}`;
+  }
+  if (run.status === "paused") return "awaiting resume";
+  if (run.activeStages.length > 0) {
+    return `stage: ${run.activeStages.map((stage) => stage.name).join(", ")}`;
+  }
+  if (run.error !== undefined && run.error.length > 0) return truncateStatusText(run.error);
+  if (run.exitReason !== undefined && run.exitReason.length > 0) {
+    return truncateStatusText(run.exitReason);
+  }
+  return undefined;
+}
+
+function statusAwaitingInputLine(entry: WorkflowStatusAwaitingInput): string {
+  const target = entry.stageId !== undefined
+    ? `stage ${entry.stageName ?? entry.stageId} (${entry.stageId})`
+    : "run-level prompt";
+  const prompt = entry.promptId !== undefined ? ` promptId: ${entry.promptId}` : "";
+  const message = entry.message !== undefined ? ` — "${truncateStatusText(entry.message)}"` : "";
+  return `    awaiting input: ${target}${prompt}${message}`;
+}
+
+function renderStatusToolContent(
+  result: Extract<WorkflowToolResult, { action: "status" }>,
+): string {
+  const lines = ["action: status", `filter: ${result.filter}`];
+  if (result.runs.length === 0) {
+    lines.push(
+      result.filter === "all" ? "runs: none" : `runs: none (statusFilter: ${result.filter})`,
+    );
+    return lines.join("\n");
+  }
+  const inFlight = result.runs.filter((run) => run.endedAt === undefined).length;
+  lines.push(`runs: ${result.runs.length} (${inFlight} in flight)`);
+  result.runs.forEach((run, index) => {
+    const hint = statusRunHint(run);
+    const summaryLine = [
+      `[${index + 1}]`,
+      run.runIdPrefix,
+      run.name,
+      run.status,
+      fmtDuration(run.elapsedMs),
+      ...(hint !== undefined ? [hint] : []),
+    ].join("  ");
+    lines.push(summaryLine);
+    lines.push(`    runId: ${run.runId}`);
+    for (const entry of run.awaitingInput) lines.push(statusAwaitingInputLine(entry));
+  });
+  lines.push(
+    "hint: status with runId returns full run detail; pause/resume/interrupt/quit/send accept the same runId (send also takes stageId/promptId).",
+  );
+  return lines.join("\n");
+}
+
 function renderTranscriptToolContent(
   result: Extract<WorkflowToolResult, { action: "transcript" }>,
 ): string {
@@ -135,11 +209,12 @@ export function renderWorkflowToolContent(
     case "pause":
     case "reload":
     case "interrupt":
-    case "kill":
+    case "quit":
     case "resume":
       return compactWorkflowToolMessage(result);
-    case "list":
     case "status":
+      return renderStatusToolContent(result);
+    case "list":
     case "statusDetail":
     case "inputs":
     case "get":