@bastani/atomic 0.5.2 → 0.5.3-1

package/dist/sdk/components/color-utils.d.ts

@@ -0,0 +1,3 @@
+export declare function hexToRgb(hex: string): [number, number, number];
+export declare function rgbToHex(r: number, g: number, b: number): string;
+export declare function lerpColor(a: string, b: string, t: number): string;

package/dist/sdk/components/connectors.d.ts

@@ -0,0 +1,14 @@
+import type { GraphTheme } from "./graph-theme.js";
+import { type LayoutNode } from "./layout.js";
+export interface ConnectorResult {
+    text: string;
+    col: number;
+    row: number;
+    width: number;
+    height: number;
+    color: string;
+}
+/** Fan-out connector: one parent branching down to one or more tree children. */
+export declare function buildConnector(parent: LayoutNode, rowH: Record<number, number>, theme: GraphTheme): ConnectorResult | null;
+/** Fan-in connector: multiple parents converging down to a single merge child. */
+export declare function buildMergeConnector(child: LayoutNode, rowH: Record<number, number>, allNodes: Record<string, LayoutNode>, theme: GraphTheme): ConnectorResult | null;

package/dist/sdk/components/connectors.test.d.ts

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

package/dist/sdk/components/edge.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource @opentui/react */
+import type { ConnectorResult } from "./connectors.js";
+export declare function Edge({ text, col, row, width, height, color: edgeColor }: ConnectorResult): import("react").ReactNode;

package/dist/sdk/components/error-boundary.d.ts

@@ -0,0 +1,22 @@
+/** @jsxImportSource @opentui/react */
+/**
+ * React Error Boundary for the orchestrator panel.
+ *
+ * Catches render-time errors in the component tree and displays a
+ * static fallback so the rest of the TUI doesn't crash.
+ */
+import { Component, type ReactNode, type ErrorInfo } from "react";
+interface ErrorBoundaryProps {
+    fallback: (error: Error) => ReactNode;
+    children: ReactNode;
+}
+interface ErrorBoundaryState {
+    error: Error | null;
+}
+export declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    state: ErrorBoundaryState;
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, info: ErrorInfo): void;
+    render(): ReactNode;
+}
+export {};

package/dist/sdk/components/graph-theme.d.ts

@@ -0,0 +1,16 @@
+import type { TerminalTheme } from "../runtime/theme.js";
+export interface GraphTheme {
+    background: string;
+    backgroundElement: string;
+    text: string;
+    textMuted: string;
+    textDim: string;
+    primary: string;
+    success: string;
+    error: string;
+    warning: string;
+    info: string;
+    border: string;
+    borderActive: string;
+}
+export declare function deriveGraphTheme(t: TerminalTheme): GraphTheme;

package/dist/sdk/components/header.d.ts

@@ -0,0 +1,2 @@
+/** @jsxImportSource @opentui/react */
+export declare function Header(): import("react").ReactNode;

package/dist/sdk/components/layout.d.ts

@@ -0,0 +1,26 @@
+import type { SessionData, SessionStatus } from "./orchestrator-panel-types.js";
+export declare const NODE_W = 36;
+export declare const NODE_H = 4;
+export declare const H_GAP = 6;
+export declare const V_GAP = 3;
+export declare const PAD = 3;
+export interface LayoutNode {
+    name: string;
+    status: SessionStatus;
+    parents: string[];
+    error?: string;
+    startedAt: number | null;
+    endedAt: number | null;
+    children: LayoutNode[];
+    depth: number;
+    x: number;
+    y: number;
+}
+export interface LayoutResult {
+    roots: LayoutNode[];
+    map: Record<string, LayoutNode>;
+    rowH: Record<number, number>;
+    width: number;
+    height: number;
+}
+export declare function computeLayout(sessions: SessionData[]): LayoutResult;

package/dist/sdk/components/layout.test.d.ts

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

package/dist/sdk/components/node-card.d.ts

@@ -0,0 +1,8 @@
+/** @jsxImportSource @opentui/react */
+import { type LayoutNode } from "./layout.js";
+export declare function NodeCard({ node, focused, pulsePhase, displayH, }: {
+    node: LayoutNode;
+    focused: boolean;
+    pulsePhase: number;
+    displayH: number;
+}): import("react").ReactNode;

package/dist/sdk/components/orchestrator-panel-contexts.d.ts

@@ -0,0 +1,15 @@
+import type { PanelStore } from "./orchestrator-panel-store.js";
+import type { GraphTheme } from "./graph-theme.js";
+export declare const StoreContext: import("react").Context<PanelStore | null>;
+export declare const ThemeContext: import("react").Context<GraphTheme | null>;
+export declare const TmuxSessionContext: import("react").Context<string>;
+export declare function useStore(): PanelStore;
+export declare function useGraphTheme(): GraphTheme;
+/**
+ * Subscribe to the store and return its current version.
+ *
+ * Uses `useSyncExternalStore` so the subscription is active from the
+ * very first render — no `useEffect` timing gap that could cause a
+ * missed `addSession` update.
+ */
+export declare function useStoreVersion(store: PanelStore): number;

package/dist/sdk/components/orchestrator-panel-store.d.ts

@@ -0,0 +1,35 @@
+import type { SessionData, PanelSession } from "./orchestrator-panel-types.js";
+type Listener = () => void;
+export declare class PanelStore {
+    version: number;
+    workflowName: string;
+    agent: string;
+    prompt: string;
+    sessions: SessionData[];
+    completionInfo: {
+        workflowName: string;
+        transcriptsPath: string;
+    } | null;
+    fatalError: string | null;
+    completionReached: boolean;
+    exitResolve: (() => void) | null;
+    abortResolve: (() => void) | null;
+    private listeners;
+    subscribe: (fn: Listener) => (() => void);
+    private emit;
+    setWorkflowInfo(name: string, agent: string, sessions: PanelSession[], prompt: string): void;
+    startSession(name: string): void;
+    completeSession(name: string): void;
+    failSession(name: string, error: string): void;
+    addSession(session: SessionData): void;
+    setCompletion(workflowName: string, transcriptsPath: string): void;
+    setFatalError(message: string): void;
+    /** Safely invoke exitResolve at most once, guarding against rapid repeated calls. */
+    resolveExit(): void;
+    /** Safely invoke abortResolve at most once to signal mid-execution quit. */
+    resolveAbort(): void;
+    /** Quit the workflow — routes to the correct handler based on current phase. */
+    requestQuit(): void;
+    markCompletionReached(): void;
+}
+export {};

package/dist/sdk/components/orchestrator-panel-store.test.d.ts

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

package/dist/sdk/components/orchestrator-panel-types.d.ts

@@ -0,0 +1,16 @@
+export type SessionStatus = "pending" | "running" | "complete" | "error";
+export interface PanelSession {
+    name: string;
+    parents: string[];
+}
+export interface PanelOptions {
+    tmuxSession: string;
+}
+export interface SessionData {
+    name: string;
+    status: SessionStatus;
+    parents: string[];
+    error?: string;
+    startedAt: number | null;
+    endedAt: number | null;
+}

package/dist/sdk/components/orchestrator-panel.d.ts

@@ -0,0 +1,51 @@
+/** @jsxImportSource @opentui/react */
+/**
+ * OrchestratorPanel — public API class that bridges the imperative
+ * executor interface with the React-based session graph TUI.
+ */
+import { type CliRenderer } from "@opentui/core";
+import type { PanelSession, PanelOptions } from "./orchestrator-panel-types.js";
+export declare class OrchestratorPanel {
+    private store;
+    private renderer;
+    private destroyed;
+    private constructor();
+    /**
+     * Create a new OrchestratorPanel with the default CLI renderer.
+     *
+     * This is the primary entry point — it initialises the terminal renderer
+     * and mounts the React-based session graph TUI.
+     */
+    static create(options: PanelOptions): Promise<OrchestratorPanel>;
+    /** Create with an externally-provided renderer (e.g. a test renderer). */
+    static createWithRenderer(renderer: CliRenderer, options: PanelOptions): OrchestratorPanel;
+    /**
+     * Display the workflow overview in the TUI — name, agent, session graph,
+     * and the user prompt. Call once after construction before sessions start.
+     */
+    showWorkflowInfo(name: string, agent: string, sessions: PanelSession[], prompt: string): void;
+    /** Mark a session as running in the graph UI. */
+    sessionStart(name: string): void;
+    /** Mark a session as successfully completed in the graph UI. */
+    sessionSuccess(name: string): void;
+    /** Mark a session as failed in the graph UI and display the error message. */
+    sessionError(name: string, message: string): void;
+    /** Dynamically add a new session node to the graph UI. */
+    addSession(name: string, parents: string[]): void;
+    /** Show the workflow-complete banner with a link to saved transcripts. */
+    showCompletion(workflowName: string, transcriptsPath: string): void;
+    /** Display a fatal error banner in the TUI. */
+    showFatalError(message: string): void;
+    /**
+     * Block until the user presses `q` or `Ctrl+C` in the TUI.
+     * Call after {@link showCompletion} or {@link showFatalError}.
+     */
+    waitForExit(): Promise<void>;
+    /**
+     * Returns a promise that resolves when the user requests a mid-execution quit
+     * (via `q` or `Ctrl+C`). Race this against the workflow run.
+     */
+    waitForAbort(): Promise<void>;
+    /** Tear down the terminal renderer and release resources. Idempotent. */
+    destroy(): void;
+}

package/dist/sdk/components/session-graph-panel.d.ts

@@ -0,0 +1,6 @@
+/** @jsxImportSource @opentui/react */
+/**
+ * Main graph component — renders the navigable session tree with
+ * keyboard navigation, scroll management, and live animations.
+ */
+export declare function SessionGraphPanel(): import("react").ReactNode;

package/dist/sdk/components/status-helpers.d.ts

@@ -0,0 +1,5 @@
+import type { GraphTheme } from "./graph-theme.js";
+export declare function statusColor(status: string, theme: GraphTheme): string;
+export declare function statusLabel(status: string): string;
+export declare function statusIcon(status: string): string;
+export declare function fmtDuration(ms: number): string;

package/dist/sdk/components/statusline.d.ts

@@ -0,0 +1,6 @@
+/** @jsxImportSource @opentui/react */
+import type { LayoutNode } from "./layout.js";
+export declare function Statusline({ focusedNode, attachMsg, }: {
+    focusedNode: LayoutNode | undefined;
+    attachMsg: string;
+}): import("react").ReactNode;

package/dist/sdk/define-workflow.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Workflow Builder — defines a workflow with a single `.run()` entry point.
+ *
+ * Usage:
+ *   defineWorkflow<"copilot">({ name: "my-workflow", description: "..." })
+ *     .run(async (ctx) => {
+ *       await ctx.stage({ name: "research" }, {}, {}, async (s) => { ... });
+ *       await ctx.stage({ name: "plan" }, {}, {}, async (s) => { ... });
+ *     })
+ *     .compile()
+ */
+import type { AgentType, WorkflowOptions, WorkflowContext, WorkflowDefinition } from "./types.js";
+/**
+ * Chainable workflow builder. Records the run callback,
+ * then .compile() seals it into a WorkflowDefinition.
+ */
+export declare class WorkflowBuilder<A extends AgentType = AgentType> {
+    /** @internal Brand for detection across package boundaries */
+    readonly __brand: "WorkflowBuilder";
+    private readonly options;
+    private runFn;
+    constructor(options: WorkflowOptions);
+    /**
+     * Set the workflow's entry point.
+     *
+     * The callback receives a {@link WorkflowContext} with `stage()` for
+     * spawning agent sessions, and `transcript()` / `getMessages()` for
+     * reading completed session outputs. Use native TypeScript control flow
+     * (loops, conditionals, `Promise.all()`) for orchestration.
+     */
+    run(fn: (ctx: WorkflowContext<A>) => Promise<void>): this;
+    /**
+     * Compile the workflow into a sealed WorkflowDefinition.
+     *
+     * After calling compile(), the returned object is consumed by the
+     * Atomic CLI runtime.
+     */
+    compile(): WorkflowDefinition<A>;
+}
+/**
+ * Entry point for defining a workflow.
+ *
+ * Pass a type parameter to narrow all context types to a specific agent:
+ *
+ * @example
+ * ```typescript
+ * import { defineWorkflow } from "@bastani/atomic/workflows";
+ *
+ * export default defineWorkflow<"copilot">({
+ *   name: "hello",
+ *   description: "Two-session demo",
+ * })
+ *   .run(async (ctx) => {
+ *     const describe = await ctx.stage(
+ *       { name: "describe" },
+ *       {},
+ *       {},
+ *       async (s) => {
+ *         // s.client: CopilotClient, s.session: CopilotSession
+ *         await s.session.sendAndWait({ prompt: s.userPrompt });
+ *         s.save(await s.session.getMessages());
+ *       },
+ *     );
+ *     await ctx.stage(
+ *       { name: "summarize" },
+ *       {},
+ *       {},
+ *       async (s) => {
+ *         const research = await s.transcript(describe);
+ *         // ...
+ *       },
+ *     );
+ *   })
+ *   .compile();
+ * ```
+ */
+export declare function defineWorkflow<A extends AgentType = AgentType>(options: WorkflowOptions): WorkflowBuilder<A>;

package/dist/sdk/define-workflow.test.d.ts

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

package/dist/sdk/errors.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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);
+}

package/dist/sdk/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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.js";
+export type { AgentType, Transcript, SavedMessage, SaveTranscript, SessionContext, SessionRef, SessionHandle, SessionRunOptions, WorkflowContext, WorkflowOptions, WorkflowDefinition, StageClientOptions, StageSessionOptions, ProviderClient, ProviderSession, } from "./types.js";
+export { defineWorkflow } from "./define-workflow.js";
+export { discoverWorkflows, findWorkflow, } from "./runtime/discovery.js";
+export { WorkflowLoader } from "./runtime/loader.js";
+export { executeWorkflow } from "./runtime/executor.js";

package/dist/sdk/index.js

@@ -0,0 +1,52 @@
+// @bun
+import {
+  WorkflowLoader,
+  defineWorkflow,
+  discoverWorkflows,
+  executeWorkflow,
+  findWorkflow
+} from "../chunk-mn870nrv.js";
+
+// src/sdk/errors.ts
+class MissingDependencyError extends Error {
+  dependency;
+  constructor(dependency) {
+    super(`Required dependency not found: ${dependency}`);
+    this.dependency = dependency;
+    this.name = "MissingDependencyError";
+  }
+}
+
+class WorkflowNotCompiledError extends Error {
+  path;
+  constructor(path) {
+    super(`Workflow at ${path} was defined but not compiled.
+` + `  Add .compile() at the end of your defineWorkflow() chain:
+
+` + `    export default defineWorkflow({ ... })
+` + `      .run(async (ctx) => { ... })
+` + `      .compile();`);
+    this.path = path;
+    this.name = "WorkflowNotCompiledError";
+  }
+}
+
+class InvalidWorkflowError extends Error {
+  path;
+  constructor(path) {
+    super(`${path} does not export a valid WorkflowDefinition.
+` + `  Make sure it exports defineWorkflow(...).compile() as the default export.`);
+    this.path = path;
+    this.name = "InvalidWorkflowError";
+  }
+}
+export {
+  findWorkflow,
+  executeWorkflow,
+  discoverWorkflows,
+  defineWorkflow,
+  WorkflowNotCompiledError,
+  WorkflowLoader,
+  MissingDependencyError,
+  InvalidWorkflowError
+};

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

@@ -0,0 +1,159 @@
+/**
+ * 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
+ * - Whitespace-collapsing normalization
+ */
+/**
+ * Remove a pane from the initialized set, 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;
+    /** Timeout in ms waiting for Claude to finish responding (default: 300s) */
+    timeoutMs?: number;
+    /** 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;
+}
+export interface ClaudeQueryResult {
+    /** The full pane content after the response completed */
+    output: string;
+    /** Whether delivery was confirmed (text disappeared from input) */
+    delivered: boolean;
+}
+/**
+ * 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<ClaudeQueryResult>;
+/**
+ * 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 {
+    /** Timeout in ms waiting for Claude to finish responding (default: 300s) */
+    timeoutMs?: number;
+    /** 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>): Promise<ClaudeQueryResult>;
+    /** Noop — for API symmetry with CopilotSession.disconnect(). */
+    disconnect(): Promise<void>;
+}
+export interface ClaudeValidationWarning {
+    rule: string;
+    message: string;
+}
+/**
+ * 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 function validateClaudeWorkflow(source: string): ClaudeValidationWarning[];

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

@@ -0,0 +1,14 @@
+/**
+ * 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.
+ */
+export interface CopilotValidationWarning {
+    rule: string;
+    message: string;
+}
+/**
+ * Validate a Copilot workflow source file for common mistakes.
+ */
+export declare function validateCopilotWorkflow(source: string): CopilotValidationWarning[];

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

@@ -0,0 +1,14 @@
+/**
+ * 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.
+ */
+export interface OpenCodeValidationWarning {
+    rule: string;
+    message: string;
+}
+/**
+ * Validate an OpenCode workflow source file for common mistakes.
+ */
+export declare function validateOpenCodeWorkflow(source: string): OpenCodeValidationWarning[];

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

@@ -0,0 +1,31 @@
+/**
+ * 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 } from "../types.js";
+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. Precedence: local > global > builtin.
+ */
+export declare function discoverWorkflows(projectRoot?: string, agentFilter?: AgentType): Promise<DiscoveredWorkflow[]>;
+/**
+ * Find a specific workflow by name and agent.
+ */
+export declare function findWorkflow(name: string, agent: AgentType, projectRoot?: string): Promise<DiscoveredWorkflow | null>;

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

@@ -0,0 +1,10 @@
+/**
+ * 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 {};