@bastani/atomic 0.5.12 → 0.5.13-0

package/dist/sdk/errors.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Typed error classes for the SDK.
+ *
+ * The SDK throws these instead of calling process.exit() or console.error().
+ * The CLI layer catches them and maps to user-visible output.
+ */
+/** Thrown when a required system dependency is not found on PATH. */
+export declare class MissingDependencyError extends Error {
+    readonly dependency: "tmux" | "psmux" | "bun";
+    constructor(dependency: "tmux" | "psmux" | "bun");
+}
+/** Thrown when a workflow file is defined but missing .compile(). */
+export declare class WorkflowNotCompiledError extends Error {
+    readonly path: string;
+    constructor(path: string);
+}
+/** Thrown when a workflow file does not export a valid WorkflowDefinition. */
+export declare class InvalidWorkflowError extends Error {
+    readonly path: string;
+    constructor(path: string);
+}
+/** Extract a human-readable message from an unknown thrown value. */
+export declare function errorMessage(error: unknown): string;
+//# sourceMappingURL=errors.d.ts.map

package/dist/sdk/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/sdk/errors.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,qEAAqE;AACrE,qBAAa,sBAAuB,SAAQ,KAAK;aACnB,UAAU,EAAE,MAAM,GAAG,OAAO,GAAG,KAAK;gBAApC,UAAU,EAAE,MAAM,GAAG,OAAO,GAAG,KAAK;CAIjE;AAED,qEAAqE;AACrE,qBAAa,wBAAyB,SAAQ,KAAK;aACrB,IAAI,EAAE,MAAM;gBAAZ,IAAI,EAAE,MAAM;CAUzC;AAED,8EAA8E;AAC9E,qBAAa,oBAAqB,SAAQ,KAAK;aACjB,IAAI,EAAE,MAAM;gBAAZ,IAAI,EAAE,MAAM;CAOzC;AAED,qEAAqE;AACrE,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEnD"}

package/dist/sdk/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * atomic SDK
+ *
+ * Public API barrel — re-exports the SDK surface.
+ * CLI-only concerns (colors, prompts, process management) are not exported here.
+ */
+export { MissingDependencyError, WorkflowNotCompiledError, InvalidWorkflowError, } from "./errors.ts";
+export type { AgentType, Transcript, SavedMessage, SaveTranscript, SessionContext, SessionRef, SessionHandle, SessionRunOptions, WorkflowContext, WorkflowOptions, WorkflowDefinition, StageClientOptions, StageSessionOptions, ProviderClient, ProviderSession, } from "./types.ts";
+export { defineWorkflow } from "./define-workflow.ts";
+export { discoverWorkflows, findWorkflow, } from "./runtime/discovery.ts";
+export { WorkflowLoader } from "./runtime/loader.ts";
+export { executeWorkflow } from "./runtime/executor.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/sdk/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sdk/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EACL,sBAAsB,EACtB,wBAAwB,EACxB,oBAAoB,GACrB,MAAM,aAAa,CAAC;AAGrB,YAAY,EACV,SAAS,EACT,UAAU,EACV,YAAY,EACZ,cAAc,EACd,cAAc,EACd,UAAU,EACV,aAAa,EACb,iBAAiB,EACjB,eAAe,EACf,eAAe,EACf,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,cAAc,EACd,eAAe,GAChB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAGtD,OAAO,EACL,iBAAiB,EACjB,YAAY,GACb,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/sdk/providers/claude.d.ts

@@ -0,0 +1,187 @@
+/**
+ * Claude Code query abstraction.
+ *
+ * Sends a prompt to an interactive Claude Code session running in a tmux pane
+ * using `tmux send-keys -l --` (literal text) + `C-m` (raw carriage return).
+ * Verifies delivery by polling `capture-pane` and retries if needed.
+ *
+ * This is NOT headless — Claude runs as a full interactive TUI in the pane.
+ * We're automating keyboard input and reading pane output.
+ *
+ * Reliability hardened from oh-my-codex's sendToWorker implementation:
+ * - Pre-send readiness wait with exponential backoff
+ * - CLI-specific submit plan (Claude: 1 C-m per round)
+ * - Per-round capture verification (6 rounds)
+ * - Adaptive retry with C-u clear + retype
+ * - Post-submit active-task detection
+ * - File-based idle detection via session JSONL watching
+ */
+import { type SessionMessage, type SDKUserMessage, type Options as SDKOptions } from "@anthropic-ai/claude-agent-sdk";
+/**
+ * Remove a pane from the initialized map, freeing memory.
+ * Call when a Claude session is killed or no longer needed.
+ */
+export declare function clearClaudeSession(paneId: string): void;
+export interface ClaudeSessionOptions {
+    /** tmux pane ID where Claude should be started */
+    paneId: string;
+    /** CLI flags to pass to the `claude` command (default: ["--allow-dangerously-skip-permissions", "--dangerously-skip-permissions"]) */
+    chatFlags?: string[];
+    /** Timeout in ms waiting for Claude TUI to be ready (default: 30s) */
+    readyTimeoutMs?: number;
+}
+/**
+ * Start Claude Code in a tmux pane with configurable CLI flags.
+ *
+ * Must be called before any `claudeQuery()` calls targeting the same pane.
+ * The pane should be a bare shell — `createClaudeSession` sends the `claude`
+ * command with the given flags and waits for the TUI to become ready.
+ *
+ * @example
+ * ```typescript
+ * import { createClaudeSession, claudeQuery } from "@bastani/atomic/workflows";
+ *
+ * await createClaudeSession({ paneId: ctx.paneId });
+ * await claudeQuery({ paneId: ctx.paneId, prompt: "Describe this project" });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With custom flags
+ * await createClaudeSession({
+ *   paneId: ctx.paneId,
+ *   chatFlags: ["--model", "opus", "--dangerously-skip-permissions"],
+ * });
+ * ```
+ */
+export declare function createClaudeSession(options: ClaudeSessionOptions): Promise<void>;
+export interface ClaudeQueryOptions {
+    /** tmux pane ID where Claude is running */
+    paneId: string;
+    /** The prompt to send */
+    prompt: string;
+    /** Polling interval in ms (default: 2000) */
+    pollIntervalMs?: number;
+    /** Number of C-m presses per submit round (default: 1 for Claude) */
+    submitPresses?: number;
+    /** Max submit rounds if text isn't consumed (default: 6) */
+    maxSubmitRounds?: number;
+    /** Timeout in ms waiting for pane to be ready before sending (default: 30s) */
+    readyTimeoutMs?: number;
+}
+/**
+ * Extract text content from assistant messages in a transcript slice.
+ *
+ * Walks messages from `afterIndex` forward, pulls `TextBlock.text` from each
+ * assistant message's content array, and joins them. The `message` payload is
+ * `unknown` in the SDK type so we do runtime narrowing.
+ *
+ * Exported so workflow authors can extract text from `SessionMessage[]`
+ * returned by `s.session.query()`.
+ */
+export declare function extractAssistantText(msgs: ReadonlyArray<{
+    type: string;
+    message: unknown;
+}>, afterIndex: number): string;
+/**
+ * Send a prompt to a Claude Code interactive session running in a tmux pane.
+ *
+ * Flow (hardened from OMX's sendToWorker):
+ * 1. Wait for pane readiness with exponential backoff
+ * 2. Capture pane content before sending
+ * 3. Send literal text via `send-keys -l --`
+ * 4. Submit with C-m rounds and per-round capture verification
+ * 5. Adaptive retry: clear line (C-u), re-type, re-submit
+ * 6. Post-submit verification via active-task detection
+ * 7. Wait for response by polling for output stabilization + prompt return
+ *
+ * @example
+ * ```typescript
+ * import { claudeQuery } from "@bastani/atomic/workflows";
+ *
+ * const result = await claudeQuery({
+ *   paneId: ctx.paneId,
+ *   prompt: "Describe this project",
+ * });
+ * ctx.log(result.output);
+ * ```
+ */
+export declare function claudeQuery(options: ClaudeQueryOptions): Promise<SessionMessage[]>;
+/**
+ * Default query options the user can set per-stage via the `sessionOpts` arg.
+ * These become defaults for every `s.session.query()` call within that stage.
+ */
+export interface ClaudeQueryDefaults {
+    /** Polling interval in ms (default: 2000) */
+    pollIntervalMs?: number;
+    /** Number of C-m presses per submit round (default: 1) */
+    submitPresses?: number;
+    /** Max submit rounds if text isn't consumed (default: 6) */
+    maxSubmitRounds?: number;
+    /** Timeout in ms waiting for pane to be ready before sending (default: 30s) */
+    readyTimeoutMs?: number;
+}
+/**
+ * Synthetic client wrapper for Claude stages.
+ * Auto-starts the Claude CLI in the tmux pane during `start()`.
+ */
+export declare class ClaudeClientWrapper {
+    readonly paneId: string;
+    private readonly opts;
+    constructor(paneId: string, opts?: {
+        chatFlags?: string[];
+        readyTimeoutMs?: number;
+    });
+    /** Start the Claude CLI in the tmux pane. Called by the runtime during init. */
+    start(): Promise<void>;
+    /** Noop — cleanup is handled by the runtime via `clearClaudeSession`. */
+    stop(): Promise<void>;
+}
+/**
+ * Synthetic session wrapper for Claude stages.
+ * Wraps `claudeQuery()` so users call `s.session.query(prompt)`.
+ */
+export declare class ClaudeSessionWrapper {
+    readonly paneId: string;
+    readonly sessionId: string;
+    private readonly defaults;
+    constructor(paneId: string, sessionId: string, defaults?: ClaudeQueryDefaults);
+    /** Send a prompt to Claude and wait for the response. */
+    query(prompt: string, opts?: Partial<ClaudeQueryDefaults & SDKOptions>): Promise<SessionMessage[]>;
+    /** Noop — for API symmetry with CopilotSession.disconnect(). */
+    disconnect(): Promise<void>;
+}
+/**
+ * Headless client wrapper for Claude stages. No tmux pane — noop start/stop.
+ * Used when `options.headless` is true in `ctx.stage()`.
+ */
+export declare class HeadlessClaudeClientWrapper {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+/**
+ * Headless session wrapper for Claude stages. Uses the Agent SDK's `query()`
+ * directly instead of tmux pane operations. Implements the same `query()`
+ * interface as {@link ClaudeSessionWrapper} so workflow callbacks work
+ * identically for headless and interactive stages.
+ *
+ * The `query()` method accepts the full Agent SDK parameter types —
+ * `prompt` can be a plain string or an `AsyncIterable<SDKUserMessage>`
+ * for multi-turn streaming, and `options` passes through SDK-level
+ * configuration (abort controllers, allowed tools, agents, etc.).
+ */
+export declare class HeadlessClaudeSessionWrapper {
+    readonly paneId = "";
+    readonly sessionId: string;
+    constructor(sessionId: string);
+    query(prompt: string | AsyncIterable<SDKUserMessage>, options?: Partial<ClaudeQueryDefaults & SDKOptions>): Promise<SessionMessage[]>;
+    disconnect(): Promise<void>;
+}
+/**
+ * Validate a Claude workflow source file for common mistakes.
+ *
+ * Warns on direct usage of createClaudeSession/claudeQuery — the runtime
+ * now handles init/cleanup automatically via s.client and s.session.
+ */
+export declare const validateClaudeWorkflow: (source: string) => import("../types.ts").ValidationWarning[];
+//# sourceMappingURL=claude.d.ts.map

package/dist/sdk/providers/claude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude.d.ts","sourceRoot":"","sources":["../../../src/sdk/providers/claude.ts"],"names":[],"mappings":"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"}

package/dist/sdk/providers/copilot.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copilot workflow source validation.
+ *
+ * Checks that Copilot workflow source files use the runtime-managed
+ * `s.client` and `s.session` instead of manual SDK client creation.
+ */
+/**
+ * Validate a Copilot workflow source file for common mistakes.
+ */
+export declare const validateCopilotWorkflow: (source: string) => import("../types.ts").ValidationWarning[];
+//# sourceMappingURL=copilot.d.ts.map

package/dist/sdk/providers/copilot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copilot.d.ts","sourceRoot":"","sources":["../../../src/sdk/providers/copilot.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;GAEG;AACH,eAAO,MAAM,uBAAuB,+DAelC,CAAC"}

package/dist/sdk/providers/opencode.d.ts

@@ -0,0 +1,11 @@
+/**
+ * OpenCode workflow source validation.
+ *
+ * Checks that OpenCode workflow source files use the runtime-managed
+ * `s.client` and `s.session` instead of manual SDK client creation.
+ */
+/**
+ * Validate an OpenCode workflow source file for common mistakes.
+ */
+export declare const validateOpenCodeWorkflow: (source: string) => import("../types.ts").ValidationWarning[];
+//# sourceMappingURL=opencode.d.ts.map

package/dist/sdk/providers/opencode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opencode.d.ts","sourceRoot":"","sources":["../../../src/sdk/providers/opencode.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;GAEG;AACH,eAAO,MAAM,wBAAwB,+DAenC,CAAC"}

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

@@ -0,0 +1,86 @@
+/**
+ * Workflow discovery — finds workflow definitions from disk.
+ *
+ * Workflows are discovered from:
+ *   1. .atomic/workflows/<name>/<agent>/index.ts (project-local)
+ *   2. ~/.atomic/workflows/<name>/<agent>/index.ts (global)
+ *
+ * Project-local workflows take precedence over global ones with the same name.
+ */
+import type { AgentType, WorkflowInput } from "../types.ts";
+export interface DiscoveredWorkflow {
+    name: string;
+    agent: AgentType;
+    path: string;
+    source: "local" | "global" | "builtin";
+}
+export declare const AGENTS: AgentType[];
+/**
+ * Default `.gitignore` content for a workflows directory.
+ * Auto-generated during install; regenerated by discovery if missing.
+ */
+export declare const WORKFLOWS_GITIGNORE: string;
+/**
+ * Discover all available workflows from built-in, global, and local sources.
+ * Optionally filter by agent.
+ *
+ * **Merge precedence:** `builtin > local > global`.
+ *
+ * Builtin names are **strictly reserved** — a user-defined local or
+ * global workflow whose name matches any built-in workflow is dropped
+ * entirely from discovery. It will not be registered, returned from
+ * `findWorkflow`, appear in the interactive picker, or show up in
+ * `atomic workflow -l`. This protects SDK-shipped workflows (e.g.
+ * `ralph`) from being silently overridden or even visibly "competing
+ * with" a user's own definition, which would otherwise be confusing
+ * when someone tries to run the canonical version.
+ *
+ * Reservation is by **name only**, across all agents: if a builtin
+ * defines `ralph` for any agent, a local `ralph` for any other agent is
+ * also dropped. Local still overrides global for every non-builtin
+ * name, so project-scoped customisation of user-scoped workflows
+ * continues to work.
+ *
+ * By default, the result is **merged by precedence** — if a workflow is
+ * defined in both local and global sources, only the higher-precedence
+ * entry is returned. This is the right shape for `findWorkflow`, which
+ * needs the single resolved entry per (name, agent) pair.
+ *
+ * Pass `{ merge: false }` to get the **unmerged** result — local and
+ * global contribute their entries independently, so `--list` can show
+ * both a local and a global copy of the same workflow when they coexist
+ * on disk. (Builtin reservation still applies in both modes.)
+ */
+export declare function discoverWorkflows(projectRoot?: string, agentFilter?: AgentType, options?: {
+    merge?: boolean;
+}): Promise<DiscoveredWorkflow[]>;
+/**
+ * Find a specific workflow by name and agent.
+ */
+export declare function findWorkflow(name: string, agent: AgentType, projectRoot?: string): Promise<DiscoveredWorkflow | null>;
+/**
+ * A discovered workflow enriched with the metadata the picker needs to
+ * render it: the human description and the declared input schema.
+ *
+ * Populated by {@link loadWorkflowsMetadata}, which runs each discovered
+ * workflow through {@link WorkflowLoader.loadWorkflow} and extracts just
+ * the display-relevant fields — the full compiled definition is
+ * discarded after extraction so re-imports during execution are cheap.
+ */
+export interface WorkflowWithMetadata extends DiscoveredWorkflow {
+    /** Workflow description, empty string when none was declared. */
+    description: string;
+    /** Picker-ready input schema; free-form workflows materialize a prompt field. */
+    inputs: readonly WorkflowInput[];
+}
+/**
+ * Load metadata (description + picker-ready inputs) for a batch of discovered workflows.
+ *
+ * Workflows that fail to import are **skipped silently** so one broken
+ * entry can never prevent the picker from rendering. Callers that need
+ * to surface load errors (e.g. `atomic workflow -n broken`) should use
+ * {@link WorkflowLoader.loadWorkflow} directly — that path produces
+ * structured error reports.
+ */
+export declare function loadWorkflowsMetadata(discovered: DiscoveredWorkflow[]): Promise<WorkflowWithMetadata[]>;
+//# sourceMappingURL=discovery.d.ts.map

package/dist/sdk/runtime/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../src/sdk/runtime/discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG5D,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,SAAS,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;CACxC;AAUD,eAAO,MAAM,MAAM,EAAE,SAAS,EAAsC,CAAC;AAGrE;;;GAGG;AACH,eAAO,MAAM,mBAAmB,QASpB,CAAC;AAiIb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,iBAAiB,CACrC,WAAW,GAAE,MAAsB,EACnC,WAAW,CAAC,EAAE,SAAS,EACvB,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAO,GAChC,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAoD/B;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,EAChB,WAAW,GAAE,MAAsB,GAClC,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAGpC;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,oBAAqB,SAAQ,kBAAkB;IAC9D,iEAAiE;IACjE,WAAW,EAAE,MAAM,CAAC;IACpB,iFAAiF;IACjF,MAAM,EAAE,SAAS,aAAa,EAAE,CAAC;CAClC;AAED;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CACzC,UAAU,EAAE,kBAAkB,EAAE,GAC/B,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAejC"}

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

@@ -0,0 +1,11 @@
+/**
+ * Orchestrator entry point — invoked inside a tmux pane by the launcher script.
+ *
+ * Separated from executor.ts to avoid the dual-module-identity problem:
+ * Bun evaluates a file twice when it is both the entry point (`bun run`)
+ * and reached through package.json `exports` self-referencing. Keeping
+ * the side-effectful `--run` guard here ensures executor.ts stays a pure
+ * library module that can be safely re-exported from the SDK barrel.
+ */
+export {};
+//# sourceMappingURL=executor-entry.d.ts.map

package/dist/sdk/runtime/executor-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor-entry.d.ts","sourceRoot":"","sources":["../../../src/sdk/runtime/executor-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

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

@@ -0,0 +1,72 @@
+/**
+ * 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.ts";
+export { errorMessage } from "../errors.ts";
+export interface WorkflowRunOptions {
+    /** The compiled workflow definition */
+    definition: WorkflowDefinition;
+    /** Agent type */
+    agent: AgentType;
+    /**
+     * Structured inputs for this run. Free-form workflows model their
+     * single positional prompt as `{ prompt: "..." }` so workflow
+     * authors can read `ctx.inputs.prompt` uniformly regardless of
+     * whether the workflow declares a schema. Empty record is valid.
+     */
+    inputs?: Record<string, 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;
+/**
+ * Decode the ATOMIC_WF_INPUTS env var (base64-encoded JSON) into a
+ * `Record<string, string>`. Returns an empty record when the variable
+ * is missing, malformed, or does not decode to a string-map object —
+ * structured inputs are optional, so a corrupt payload must never
+ * prevent free-form workflows from running.
+ */
+export declare function parseInputsEnv(raw: string | undefined): Record<string, string>;
+/**
+ * Called by `atomic workflow -n <name> -a <agent> <prompt>`.
+ *
+ * Always creates a tmux session in the atomic socket with the
+ * orchestrator as the initial pane, then attaches so the user sees
+ * everything live — even when invoked from inside another tmux session.
+ */
+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;
+};
+export declare function renderMessagesToText(messages: SavedMessage[]): string;
+export declare function runOrchestrator(): Promise<void>;
+//# sourceMappingURL=executor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../../src/sdk/runtime/executor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH,OAAO,KAAK,EACV,kBAAkB,EAMlB,SAAS,EAET,YAAY,EAMb,MAAM,aAAa,CAAC;AAuErB,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAS5C,MAAM,WAAW,kBAAkB;IACjC,uCAAuC;IACvC,UAAU,EAAE,kBAAkB,CAAC;IAC/B,iBAAiB;IACjB,KAAK,EAAE,SAAS,CAAC;IACjB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,qEAAqE;IACrE,YAAY,EAAE,MAAM,CAAC;IACrB,qCAAqC;IACrC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AA0HD;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAKzC;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAMzC;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAgB9E;AAMD;;;;;;GAMG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,IAAI,CAAC,CAyEf;AAcD,gGAAgG;AAChG,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAOvE;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,MAAM,CAkDrE;AAykBD,wBAAsB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CA0JrD"}

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

@@ -0,0 +1,35 @@
+/**
+ * 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;
+}
+//# sourceMappingURL=graph-inference.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graph-inference.d.ts","sourceRoot":"","sources":["../../../src/sdk/runtime/graph-inference.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,qBAAa,oBAAoB;IAC/B;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAgB;IAEhC;;;OAGG;IACH,OAAO,CAAC,iBAAiB,CAAW;gBAExB,UAAU,EAAE,MAAM;IAI9B;;;OAGG;IACH,OAAO,IAAI,MAAM,EAAE;IAUnB;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;CAG7B"}

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

@@ -0,0 +1,70 @@
+/**
+ * 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.ts";
+import type { DiscoveredWorkflow } from "./discovery.ts";
+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;
+    /** Source validation warning — alias of the canonical type from types.ts. */
+    type ValidationWarning = import("../types.ts").ValidationWarning;
+    /** 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">>;
+}
+//# sourceMappingURL=loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../src/sdk/runtime/loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAa,MAAM,aAAa,CAAC;AACjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAMzD,yBAAiB,cAAc,CAAC;IAK9B,kCAAkC;IAClC,KAAY,EAAE,CAAC,CAAC,IAAI;QAAE,EAAE,EAAE,IAAI,CAAC;QAAC,KAAK,EAAE,CAAC,CAAA;KAAE,CAAC;IAE3C,2DAA2D;IAC3D,KAAY,UAAU,CAAC,CAAC,SAAS,MAAM,IAAI;QACzC,EAAE,EAAE,KAAK,CAAC;QACV,KAAK,EAAE,CAAC,CAAC;QACT,KAAK,EAAE,OAAO,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IAEF,KAAY,WAAW,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;IAMrE,+DAA+D;IAC/D,KAAY,IAAI,GAAG,kBAAkB,CAAC;IAEtC,mCAAmC;IACnC,KAAY,QAAQ,GAAG,IAAI,CAAC;IAE5B,6EAA6E;IAC7E,KAAY,iBAAiB,GAAG,OAAO,aAAa,EAAE,iBAAiB,CAAC;IAExE,oCAAoC;IACpC,KAAY,SAAS,GAAG,QAAQ,GAAG;QACjC,QAAQ,EAAE,iBAAiB,EAAE,CAAC;KAC/B,CAAC;IAEF,mDAAmD;IACnD,KAAY,MAAM,GAAG,SAAS,GAAG;QAC/B,UAAU,EAAE,kBAAkB,CAAC;KAChC,CAAC;IAMF,UAAiB,MAAM;QACrB,kCAAkC;QAClC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,KAAK,IAAI,CAAC;QACzD,uDAAuD;QACvD,IAAI,CAAC,EAAE,CAAC,QAAQ,EAAE,iBAAiB,EAAE,KAAK,IAAI,CAAC;QAC/C,iCAAiC;QACjC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;KAC3F;IAMD,uCAAuC;IACvC,SAAsB,OAAO,CAC3B,IAAI,EAAE,IAAI,GACT,OAAO,CAAC,WAAW,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,CAoB3C;IAsBD;;;OAGG;IACH,SAAsB,QAAQ,CAC5B,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,WAAW,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC,CAiB7C;IAMD;;;OAGG;IACH,SAAsB,IAAI,CACxB,SAAS,EAAE,SAAS,GACnB,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAqCtC;IAMD;;;;;OAKG;IACH,SAAsB,YAAY,CAChC,IAAI,EAAE,IAAI,EACV,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,CAAC,CAAC,CA6B/D;CACF"}

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

@@ -0,0 +1,9 @@
+/**
+ * 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.tsx";
+export type { PanelSession, PanelOptions } from "../components/orchestrator-panel-types.ts";
+//# sourceMappingURL=panel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../../src/sdk/runtime/panel.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AACzE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,2CAA2C,CAAC"}

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

@@ -0,0 +1,28 @@
+/**
+ * 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;
+//# sourceMappingURL=theme.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../../../src/sdk/runtime/theme.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAM/C,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AA0CD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,GAAG,aAAa,CAElE"}