@bastani/atomic 0.5.2 → 0.5.3-0

package/dist/sdk/runtime/executor.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Workflow runtime executor.
+ *
+ * Architecture:
+ * 1. `executeWorkflow()` is called by the CLI command
+ * 2. It creates a tmux session with an orchestrator pane that runs
+ *    `bun run executor-entry.ts` (a thin wrapper that calls `runOrchestrator()`)
+ * 3. The CLI then attaches to the tmux session (user sees it live)
+ * 4. The orchestrator pane calls `definition.run(workflowCtx)` — the
+ *    user's callback uses `ctx.stage()` to spawn agent sessions
+ *
+ * The entry point is in executor-entry.ts (not this file) to avoid Bun's
+ * dual-module-identity issue: Bun evaluates a file twice when it is both
+ * the entry point and reached through package.json `exports` self-referencing.
+ */
+import type { WorkflowDefinition, AgentType, SavedMessage } from "../types.js";
+export interface WorkflowRunOptions {
+    /** The compiled workflow definition */
+    definition: WorkflowDefinition;
+    /** Agent type */
+    agent: AgentType;
+    /** The user's prompt */
+    prompt: string;
+    /** Absolute path to the workflow's index.ts file (from discovery) */
+    workflowFile: string;
+    /** Project root (defaults to cwd) */
+    projectRoot?: string;
+}
+/**
+ * Escape a string for safe interpolation inside a bash double-quoted string.
+ *
+ * In bash `"..."` strings only `$`, `` ` ``, `\`, `"`, and `!` are special.
+ * Single quotes are literal inside double quotes and need no escaping.
+ * Null bytes are stripped because bash strings cannot contain them.
+ */
+export declare function escBash(s: string): string;
+/**
+ * Escape a string for safe interpolation inside a PowerShell double-quoted string.
+ *
+ * In PowerShell `"..."` strings, backtick is the escape character and `$` triggers
+ * variable expansion.  Null bytes are stripped for safety.
+ */
+export declare function escPwsh(s: string): string;
+/**
+ * Called by `atomic workflow -n <name> -a <agent> <prompt>`.
+ *
+ * Creates a tmux session with the orchestrator as the initial pane,
+ * then attaches so the user sees everything live.
+ */
+export declare function executeWorkflow(options: WorkflowRunOptions): Promise<void>;
+/** Type guard for objects with a string `content` property (Copilot assistant.message data). */
+export declare function hasContent(value: unknown): value is {
+    content: string;
+};
+/** Type guard for Claude message objects whose `content` is an array of text blocks. */
+export declare function isTextBlockArray(value: unknown): value is Array<{
+    type: "text";
+    text: string;
+}>;
+export declare function renderMessagesToText(messages: SavedMessage[]): string;
+export declare function runOrchestrator(): Promise<void>;

package/dist/sdk/runtime/executor.test.d.ts

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

package/dist/sdk/runtime/graph-inference.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Frontier-based graph inference for workflow stage topology.
+ *
+ * Automatically infers parent-child edges from JavaScript's execution order:
+ * - **Sequential** (`await`): completed stages are in the frontier when the
+ *   next stage spawns → parent-child edge.
+ * - **Parallel** (`Promise.all`): both calls fire in the same synchronous
+ *   frame → frontier is empty for the second call → sibling edges.
+ * - **Fan-in**: after `Promise.all` resolves, all parallel stages are in the
+ *   frontier → the next stage depends on all of them.
+ */
+export declare class GraphFrontierTracker {
+    /**
+     * Stages that completed since the last stage was spawned in this scope.
+     * When non-empty at spawn time, the new stage is sequential (depends on frontier).
+     */
+    private frontier;
+    /**
+     * The parent set for the current parallel batch — a snapshot of the frontier
+     * at the point the first sibling consumed it.
+     */
+    private parallelAncestors;
+    constructor(parentName: string);
+    /**
+     * Called synchronously when a new stage is spawned.
+     * Returns the inferred graph parents for this stage.
+     */
+    onSpawn(): string[];
+    /**
+     * Called when a stage settles (completes or fails).
+     * Adds the stage to the frontier so the next spawn can chain from it.
+     */
+    onSettle(name: string): void;
+}

package/dist/sdk/runtime/loader.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Workflow Loader — multi-stage pipeline for resolving and loading workflows.
+ *
+ * Pipeline: Discover → Resolve → Validate → Load
+ *
+ * Each stage returns a typed discriminated result so callers get structured
+ * error information without try/catch guesswork.
+ *
+ * Discovery (finding workflow files on disk) remains in `discovery.ts`.
+ * This module handles everything after a workflow is discovered.
+ */
+import type { WorkflowDefinition } from "../types.js";
+import type { DiscoveredWorkflow } from "./discovery.js";
+export declare namespace WorkflowLoader {
+    /** Successful pipeline result. */
+    type Ok<T> = {
+        ok: true;
+        value: T;
+    };
+    /** Failed pipeline result with stage and error context. */
+    type StageError<S extends string> = {
+        ok: false;
+        stage: S;
+        error: unknown;
+        message: string;
+    };
+    type StageResult<T, S extends string> = Ok<T> | StageError<S>;
+    /** Input to the pipeline — a discovered workflow from disk. */
+    type Plan = DiscoveredWorkflow;
+    /** Output of the resolve stage. */
+    type Resolved = Plan;
+    /** A source validation warning (agent-specific). */
+    interface ValidationWarning {
+        rule: string;
+        message: string;
+    }
+    /** Output of the validate stage. */
+    type Validated = Resolved & {
+        warnings: ValidationWarning[];
+    };
+    /** Output of the load stage — the final result. */
+    type Loaded = Validated & {
+        definition: WorkflowDefinition;
+    };
+    interface Report {
+        /** Called when a stage begins. */
+        start?: (stage: "resolve" | "validate" | "load") => void;
+        /** Called when source validation produces warnings. */
+        warn?: (warnings: ValidationWarning[]) => void;
+        /** Called when a stage fails. */
+        error?: (stage: "resolve" | "validate" | "load", error: unknown, message: string) => void;
+    }
+    /** Verify the workflow file exists. */
+    function resolve(plan: Plan): Promise<StageResult<Resolved, "resolve">>;
+    /**
+     * Read the workflow source and run agent-specific validation checks.
+     * Validation warnings are non-fatal — the pipeline continues.
+     */
+    function validate(resolved: Resolved): Promise<StageResult<Validated, "validate">>;
+    /**
+     * Import the workflow module and extract the WorkflowDefinition.
+     * Checks for common authoring mistakes (missing `.compile()`, wrong export).
+     */
+    function load(validated: Validated): Promise<StageResult<Loaded, "load">>;
+    /**
+     * Run the full pipeline: resolve → validate → load.
+     *
+     * Returns a structured result with the loaded WorkflowDefinition on success,
+     * or a stage-specific error on failure.
+     */
+    function loadWorkflow(plan: Plan, report?: Report): Promise<StageResult<Loaded, "resolve" | "validate" | "load">>;
+}

package/dist/sdk/runtime/panel.d.ts

@@ -0,0 +1,8 @@
+/**
+ * OpenTUI React-based orchestrator panel with session graph view.
+ *
+ * This module re-exports the public API from the components/ directory.
+ * Internal implementation is modularized under ../components/.
+ */
+export { OrchestratorPanel } from "../components/orchestrator-panel.js";
+export type { PanelSession, PanelOptions } from "../components/orchestrator-panel-types.js";

package/dist/sdk/runtime/theme.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Terminal color theme using Catppuccin palettes.
+ *
+ * Uses OpenTUI's built-in dark/light mode detection (via the renderer's
+ * themeMode property) to select the appropriate palette:
+ * - Mocha for dark terminals (and as fallback)
+ * - Latte for light terminals
+ */
+import type { ThemeMode } from "@opentui/core";
+export interface TerminalTheme {
+    bg: string;
+    surface: string;
+    selection: string;
+    border: string;
+    borderDim: string;
+    accent: string;
+    text: string;
+    dim: string;
+    success: string;
+    error: string;
+    warning: string;
+}
+/**
+ * Resolve the terminal theme from the renderer's detected theme mode.
+ * Returns Catppuccin Latte for light terminals, Mocha for dark or unknown.
+ */
+export declare function resolveTheme(mode: ThemeMode | null): TerminalTheme;

package/dist/sdk/runtime/tmux.d.ts

@@ -0,0 +1,191 @@
+/**
+ * tmux session and pane management utilities.
+ *
+ * Provides low-level tmux operations for the workflow runtime:
+ * creating sessions, splitting panes, spawning commands, capturing output,
+ * sending keystrokes, and pane state detection.
+ */
+/**
+ * Resolve the terminal multiplexer binary for the current platform.
+ *
+ * On Windows, tries psmux → pmux → tmux (psmux ships all three as aliases).
+ * On Unix/macOS, uses tmux directly.
+ *
+ * Returns the binary name (not the full path) or null if none is found.
+ * The result is cached after the first call.
+ */
+export declare function getMuxBinary(): string | null;
+/**
+ * Reset the cached multiplexer binary resolution.
+ * Call after installing tmux/psmux to force re-detection.
+ */
+export declare function resetMuxBinaryCache(): void;
+/**
+ * Check if tmux is installed and available.
+ */
+export declare function isTmuxInstalled(): boolean;
+/**
+ * Check if we're currently inside a tmux session.
+ */
+export declare function isInsideTmux(): boolean;
+/**
+ * Run a tmux command and return a result object.
+ * Prefers this over the throwing `tmux()` for cases where callers
+ * need to handle failure gracefully.
+ */
+export declare function tmuxRun(args: string[]): {
+    ok: true;
+    stdout: string;
+} | {
+    ok: false;
+    stderr: string;
+};
+/**
+ * Create a new tmux session with the given name.
+ * The session starts detached with an initial command in the first pane.
+ *
+ * @param sessionName - Unique session name
+ * @param initialCommand - Shell command to run in the initial pane
+ * @param windowName - Optional name for the initial window
+ * @param cwd - Optional working directory for the initial pane
+ * @param envVars - Optional environment variables for the initial pane
+ * @returns The pane ID of the initial pane (e.g., "%0")
+ */
+export declare function createSession(sessionName: string, initialCommand: string, windowName?: string, cwd?: string, envVars?: Record<string, string>): string;
+/**
+ * Create a new window in an existing session without switching focus.
+ *
+ * @param sessionName - Target session name
+ * @param windowName - Name for the new window
+ * @param command - Shell command to run in the new window
+ * @param cwd - Optional working directory for the new window
+ * @param envVars - Optional environment variables for the new window
+ * @returns The pane ID of the new window's pane
+ */
+export declare function createWindow(sessionName: string, windowName: string, command: string, cwd?: string, envVars?: Record<string, string>): string;
+/**
+ * Create a new pane in an existing session by splitting.
+ *
+ * @returns The pane ID of the new pane
+ */
+export declare function createPane(sessionName: string, command: string): string;
+/**
+ * Send literal text to a tmux pane using `-l` flag (no special key interpretation).
+ * Uses `--` to prevent text starting with `-` from being parsed as flags.
+ */
+export declare function sendLiteralText(paneId: string, text: string): void;
+/**
+ * Send a special key (C-m, C-c, C-u, Tab, etc.) to a tmux pane.
+ */
+export declare function sendSpecialKey(paneId: string, key: string): void;
+/**
+ * Send literal text and submit with C-m (carriage return).
+ * Uses C-m instead of Enter for raw-mode TUI compatibility.
+ *
+ * @param presses - Number of C-m presses (default: 1)
+ * @param delayMs - Delay between presses in ms (default: 100)
+ */
+export declare function sendKeysAndSubmit(paneId: string, text: string, presses?: number, delayMs?: number): void;
+/**
+ * Capture the visible content of a tmux pane.
+ *
+ * @param paneId - The pane ID (e.g., "%0")
+ * @param start - Start line (negative = from bottom, default: capture visible only)
+ */
+export declare function capturePane(paneId: string, start?: number): string;
+/**
+ * Capture only the visible portion of a pane (no scrollback).
+ * Preferred for state detection (ready/busy) to avoid stale prompt lines
+ * or old activity indicators in scrollback triggering false positives.
+ * Returns empty string on failure instead of throwing.
+ */
+export declare function capturePaneVisible(paneId: string): string;
+/**
+ * Capture last N lines of scrollback from a pane.
+ * Preferred for output collection where you need recent history.
+ * Returns empty string on failure instead of throwing.
+ */
+export declare function capturePaneScrollback(paneId: string, lines?: number): string;
+/**
+ * Kill a tmux session.
+ */
+export declare function killSession(sessionName: string): void;
+/** Kill a specific tmux window within a session. Silences errors if already dead. */
+export declare function killWindow(sessionName: string, windowName: string): void;
+/**
+ * Check if a tmux session exists.
+ */
+export declare function sessionExists(sessionName: string): boolean;
+/**
+ * Attach to an existing tmux session (takes over the current terminal).
+ */
+export declare function attachSession(sessionName: string): void;
+/**
+ * Switch the current tmux client to a different session.
+ * Use this instead of `attachSession` when already inside tmux to avoid
+ * creating a nested tmux client.
+ */
+export declare function switchClient(sessionName: string): void;
+/**
+ * Get the name of the current tmux session (when running inside tmux).
+ * Returns null if not inside tmux or if the query fails.
+ */
+export declare function getCurrentSession(): string | null;
+/**
+ * Attach or switch to a tmux session depending on whether we're already
+ * inside tmux. Avoids nested tmux clients.
+ *
+ * - Outside tmux: spawns `attach-session` (blocks until session ends).
+ * - Inside tmux: runs `switch-client` (returns immediately).
+ */
+export declare function attachOrSwitch(sessionName: string): void;
+/**
+ * Select (switch to) a window within the current tmux session.
+ */
+export declare function selectWindow(target: string): void;
+/**
+ * Collapse all whitespace to single spaces for robust capture comparison.
+ * Prevents false negatives from tmux inserting/stripping whitespace.
+ */
+export declare function normalizeTmuxCapture(text: string): string;
+/**
+ * Normalize captured text preserving line structure (for display output).
+ */
+export declare function normalizeTmuxLines(text: string): string;
+/**
+ * Returns true when the pane shows an agent prompt ready for input.
+ * Detects Claude Code (❯), Codex (›), and generic (>) prompts.
+ */
+export declare function paneLooksReady(captured: string): boolean;
+/**
+ * Returns true when the agent has an active task in progress.
+ * Checks last 40 lines for known busy indicators.
+ */
+export declare function paneHasActiveTask(captured: string): boolean;
+/**
+ * Returns true when the pane is idle — showing a prompt and not processing.
+ * Uses visible-only capture to avoid stale scrollback matches.
+ */
+export declare function paneIsIdle(paneId: string): boolean;
+/**
+ * Wait for the pane to be idle (prompt visible, no active task) with
+ * exponential backoff. Returns the time spent waiting (ms).
+ */
+export declare function waitForPaneReady(paneId: string, timeoutMs?: number): Promise<number>;
+/**
+ * Attempt to submit by pressing C-m, verifying after each round.
+ * Returns true as soon as the trigger text disappears from the visible
+ * capture or an active task is detected.
+ */
+export declare function attemptSubmitRounds(paneId: string, normalizedPrompt: string, rounds: number, pressesPerRound?: number): Promise<boolean>;
+/**
+ * Wait for a pattern to appear in a tmux pane's output.
+ * Polls the pane content at the given interval until the pattern matches
+ * or the timeout is reached.
+ *
+ * @returns The full pane content when the pattern was found
+ */
+export declare function waitForOutput(paneId: string, pattern: RegExp, options?: {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+}): Promise<string>;

package/dist/sdk/types.d.ts

@@ -0,0 +1,214 @@
+/**
+ * Workflow SDK Types
+ *
+ * Uses native SDK types directly — no re-definitions.
+ */
+import type { SessionEvent } from "@github/copilot-sdk";
+import type { SessionPromptResponse } from "@opencode-ai/sdk/v2";
+import type { SessionMessage } from "@anthropic-ai/claude-agent-sdk";
+import type { CopilotClient, CopilotClientOptions, CopilotSession, SessionConfig as CopilotSessionConfig } from "@github/copilot-sdk";
+import type { OpencodeClient, Session as OpencodeSession } from "@opencode-ai/sdk/v2";
+import type { ClaudeClientWrapper, ClaudeSessionWrapper, ClaudeQueryDefaults } from "./providers/claude.js";
+/** Supported agent types */
+export type AgentType = "copilot" | "opencode" | "claude";
+/**
+ * Maps each agent to the client init options the user passes to `ctx.stage()`.
+ * Auto-injected fields (`cliUrl`, `baseUrl`, `paneId`) are omitted.
+ */
+type ClientOptionsMap = {
+    opencode: {
+        directory?: string;
+        experimental_workspaceID?: string;
+    };
+    copilot: Omit<CopilotClientOptions, "cliUrl">;
+    claude: {
+        chatFlags?: string[];
+        readyTimeoutMs?: number;
+    };
+};
+/**
+ * Maps each agent to the session create options the user passes to `ctx.stage()`.
+ * - OpenCode: `client.session.create()` body params
+ * - Copilot: `client.createSession()` config (onPermissionRequest defaults to approveAll)
+ * - Claude: `claudeQuery()` defaults for subsequent queries
+ */
+type SessionOptionsMap = {
+    opencode: {
+        parentID?: string;
+        title?: string;
+        workspaceID?: string;
+    };
+    copilot: Partial<CopilotSessionConfig>;
+    claude: ClaudeQueryDefaults;
+};
+/** Maps each agent to the `s.client` type provided in the stage callback. */
+type ClientMap = {
+    opencode: OpencodeClient;
+    copilot: CopilotClient;
+    claude: ClaudeClientWrapper;
+};
+/** Maps each agent to the `s.session` type provided in the stage callback. */
+type SessionMap = {
+    opencode: OpencodeSession;
+    copilot: CopilotSession;
+    claude: ClaudeSessionWrapper;
+};
+/** Client init options for `ctx.stage()`, resolved by agent type. */
+export type StageClientOptions<A extends AgentType> = ClientOptionsMap[A];
+/** Session create options for `ctx.stage()`, resolved by agent type. */
+export type StageSessionOptions<A extends AgentType> = SessionOptionsMap[A];
+/** The `s.client` type in a stage callback, resolved by agent type. */
+export type ProviderClient<A extends AgentType> = ClientMap[A];
+/** The `s.session` type in a stage callback, resolved by agent type. */
+export type ProviderSession<A extends AgentType> = SessionMap[A];
+export type { CopilotClient, CopilotClientOptions, CopilotSession, CopilotSessionConfig, OpencodeClient, OpencodeSession, ClaudeClientWrapper, ClaudeSessionWrapper, ClaudeQueryDefaults, };
+/**
+ * A transcript from a completed session.
+ * Provides both the file path and rendered text content.
+ */
+export interface Transcript {
+    /** Absolute path to the transcript file on disk */
+    path: string;
+    /** The transcript content (assistant text extracted from messages) */
+    content: string;
+}
+/**
+ * A saved message from any provider, stored as JSON.
+ * Uses native SDK types directly.
+ */
+export type SavedMessage = {
+    provider: "copilot";
+    data: SessionEvent;
+} | {
+    provider: "opencode";
+    data: SessionPromptResponse;
+} | {
+    provider: "claude";
+    data: SessionMessage;
+};
+/**
+ * Save native message objects from the provider SDK.
+ *
+ * - **Copilot**: `s.save(await s.session.getMessages())`
+ * - **OpenCode**: `s.save(result.data)` — the full `{ info, parts }` response
+ * - **Claude**: `s.save(sessionId)` — auto-reads via `getSessionMessages()`
+ */
+export interface SaveTranscript {
+    /** Save Copilot SessionEvent[] from session.getMessages() */
+    (messages: SessionEvent[]): Promise<void>;
+    /** Save OpenCode prompt response `{ info, parts }` from session.prompt().data */
+    (response: SessionPromptResponse): Promise<void>;
+    /** Save Claude messages — pass the session ID to auto-read transcript */
+    (claudeSessionId: string): Promise<void>;
+}
+/** A reference to a completed session — either a handle or a session name string. */
+export type SessionRef = string | SessionHandle<unknown>;
+/**
+ * Handle returned by `ctx.stage()`. Used for type-safe transcript references
+ * and carries the callback's return value.
+ */
+export interface SessionHandle<T = void> {
+    /** The session's unique name */
+    readonly name: string;
+    /** The session's generated UUID */
+    readonly id: string;
+    /** The value returned by the session callback */
+    readonly result: T;
+}
+/**
+ * Options for spawning a session via `ctx.stage()`.
+ */
+export interface SessionRunOptions {
+    /** Unique name for this session (used for transcript references and graph display) */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+}
+/**
+ * Context provided to each session's callback.
+ * Created by `ctx.stage(opts, clientOpts, sessionOpts, fn)` — the callback
+ * receives this as its argument with pre-initialized `client` and `session`.
+ */
+export interface SessionContext<A extends AgentType = AgentType> {
+    /** Provider-specific SDK client (auto-created by runtime) */
+    client: ProviderClient<A>;
+    /** Provider-specific session (auto-created by runtime) */
+    session: ProviderSession<A>;
+    /** The original user prompt from the CLI invocation */
+    userPrompt: string;
+    /** Which agent is running */
+    agent: A;
+    /**
+     * Get a completed session's transcript as rendered text.
+     * Accepts a SessionHandle (recommended) or session name string.
+     */
+    transcript(ref: SessionRef): Promise<Transcript>;
+    /**
+     * Get a completed session's raw native messages.
+     * Accepts a SessionHandle (recommended) or session name string.
+     */
+    getMessages(ref: SessionRef): Promise<SavedMessage[]>;
+    /**
+     * Save this session's output for subsequent sessions.
+     * Accepts native SDK message objects only.
+     */
+    save: SaveTranscript;
+    /** Path to this session's storage directory on disk */
+    sessionDir: string;
+    /** tmux pane ID for this session */
+    paneId: string;
+    /** Session UUID */
+    sessionId: string;
+    /**
+     * Spawn a nested sub-session with its own tmux window and graph node.
+     * The sub-session is a child of this session in the graph.
+     * The callback's return value is available as `handle.result`.
+     */
+    stage<T = void>(options: SessionRunOptions, clientOpts: StageClientOptions<A>, sessionOpts: StageSessionOptions<A>, run: (ctx: SessionContext<A>) => Promise<T>): Promise<SessionHandle<T>>;
+}
+/**
+ * Top-level context provided to the workflow's `.run()` callback.
+ * Does not have session-specific fields (paneId, save, etc.).
+ */
+export interface WorkflowContext<A extends AgentType = AgentType> {
+    /** The original user prompt from the CLI invocation */
+    userPrompt: string;
+    /** Which agent is running */
+    agent: A;
+    /**
+     * Spawn a session with its own tmux window and graph node.
+     * The runtime manages the full lifecycle: create client → create session →
+     * run callback → cleanup. The callback's return value is available as
+     * `handle.result`.
+     */
+    stage<T = void>(options: SessionRunOptions, clientOpts: StageClientOptions<A>, sessionOpts: StageSessionOptions<A>, run: (ctx: SessionContext<A>) => Promise<T>): Promise<SessionHandle<T>>;
+    /**
+     * Get a completed session's transcript as rendered text.
+     * Accepts a SessionHandle (recommended) or session name string.
+     */
+    transcript(ref: SessionRef): Promise<Transcript>;
+    /**
+     * Get a completed session's raw native messages.
+     * Accepts a SessionHandle (recommended) or session name string.
+     */
+    getMessages(ref: SessionRef): Promise<SavedMessage[]>;
+}
+/**
+ * Options for defining a workflow.
+ */
+export interface WorkflowOptions {
+    /** Unique workflow name */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+}
+/**
+ * A compiled workflow definition — the sealed output of defineWorkflow().compile().
+ */
+export interface WorkflowDefinition<A extends AgentType = AgentType> {
+    readonly __brand: "WorkflowDefinition";
+    readonly name: string;
+    readonly description: string;
+    /** The workflow's entry point. Called by the executor with a WorkflowContext. */
+    readonly run: (ctx: WorkflowContext<A>) => Promise<void>;
+}

package/dist/sdk/workflows/builtin/ralph/claude/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Ralph workflow for Claude Code — plan → orchestrate → review → debug loop.
+ *
+ * Each sub-agent invocation spawns its own visible session in the graph,
+ * so users can see each iteration's progress in real time. The loop
+ * terminates when:
+ *   - {@link MAX_LOOPS} iterations have completed, OR
+ *   - Two consecutive reviewer passes return zero findings.
+ *
+ * Run: atomic workflow -n ralph -a claude "<your spec>"
+ */
+declare const _default: import("../../../index.ts").WorkflowDefinition<"claude">;
+export default _default;