@bastani/atomic 0.5.2-0 → 0.5.3-0

package/dist/sdk/workflows/builtin/ralph/claude/index.js

@@ -0,0 +1,95 @@
+// @bun
+import {
+  buildDebuggerReportPrompt,
+  buildOrchestratorPrompt,
+  buildPlannerPrompt,
+  buildReviewPrompt,
+  extractMarkdownBlock,
+  hasActionableFindings,
+  parseReviewResult,
+  safeGitStatusS
+} from "../../../../../chunk-fdk7tact.js";
+import"../../../../../chunk-1gb5qxz9.js";
+import {
+  defineWorkflow
+} from "../../../../../chunk-mn870nrv.js";
+
+// src/sdk/workflows/builtin/ralph/claude/index.ts
+var MAX_LOOPS = 10;
+var CONSECUTIVE_CLEAN_THRESHOLD = 2;
+function asAgentCall(agentName, prompt) {
+  return `@"${agentName} (agent)" ${prompt}`;
+}
+var claude_default = defineWorkflow({
+  name: "ralph",
+  description: "Plan \u2192 orchestrate \u2192 review \u2192 debug loop with bounded iteration"
+}).run(async (ctx) => {
+  let consecutiveClean = 0;
+  let debuggerReport = "";
+  for (let iteration = 1;iteration <= MAX_LOOPS; iteration++) {
+    const plannerName = `planner-${iteration}`;
+    await ctx.stage({ name: plannerName }, {}, {}, async (s) => {
+      await s.session.query(asAgentCall("planner", buildPlannerPrompt(s.userPrompt, {
+        iteration,
+        debuggerReport: debuggerReport || undefined
+      })));
+      s.save(s.sessionId);
+    });
+    const orchName = `orchestrator-${iteration}`;
+    await ctx.stage({ name: orchName }, {}, {}, async (s) => {
+      await s.session.query(asAgentCall("orchestrator", buildOrchestratorPrompt(s.userPrompt)));
+      s.save(s.sessionId);
+    });
+    let gitStatus = await safeGitStatusS();
+    const reviewerName = `reviewer-${iteration}`;
+    const review = await ctx.stage({ name: reviewerName }, {}, {}, async (s) => {
+      const result = await s.session.query(asAgentCall("reviewer", buildReviewPrompt(s.userPrompt, { gitStatus, iteration })));
+      s.save(s.sessionId);
+      return result.output;
+    });
+    let reviewRaw = review.result;
+    let parsed = parseReviewResult(reviewRaw);
+    if (!hasActionableFindings(parsed, reviewRaw)) {
+      consecutiveClean += 1;
+      if (consecutiveClean >= CONSECUTIVE_CLEAN_THRESHOLD)
+        break;
+      gitStatus = await safeGitStatusS();
+      const confirmName = `reviewer-${iteration}-confirm`;
+      const confirm = await ctx.stage({ name: confirmName }, {}, {}, async (s) => {
+        const result = await s.session.query(asAgentCall("reviewer", buildReviewPrompt(s.userPrompt, {
+          gitStatus,
+          iteration,
+          isConfirmationPass: true
+        })));
+        s.save(s.sessionId);
+        return result.output;
+      });
+      reviewRaw = confirm.result;
+      parsed = parseReviewResult(reviewRaw);
+      if (!hasActionableFindings(parsed, reviewRaw)) {
+        consecutiveClean += 1;
+        if (consecutiveClean >= CONSECUTIVE_CLEAN_THRESHOLD)
+          break;
+      } else {
+        consecutiveClean = 0;
+      }
+    } else {
+      consecutiveClean = 0;
+    }
+    if (hasActionableFindings(parsed, reviewRaw) && iteration < MAX_LOOPS) {
+      const debuggerName = `debugger-${iteration}`;
+      const debugger_ = await ctx.stage({ name: debuggerName }, {}, {}, async (s) => {
+        const result = await s.session.query(asAgentCall("debugger", buildDebuggerReportPrompt(parsed, reviewRaw, {
+          iteration,
+          gitStatus
+        })));
+        s.save(s.sessionId);
+        return result.output;
+      });
+      debuggerReport = extractMarkdownBlock(debugger_.result);
+    }
+  }
+}).compile();
+export {
+  claude_default as default
+};

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

@@ -0,0 +1,13 @@
+/**
+ * Ralph workflow for Copilot — 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 copilot "<your spec>"
+ */
+declare const _default: import("../../../index.ts").WorkflowDefinition<"copilot">;
+export default _default;

package/dist/sdk/workflows/builtin/ralph/copilot/index.js

@@ -0,0 +1,118 @@
+// @bun
+import {
+  buildDebuggerReportPrompt,
+  buildOrchestratorPrompt,
+  buildPlannerPrompt,
+  buildReviewPrompt,
+  extractMarkdownBlock,
+  hasActionableFindings,
+  parseReviewResult,
+  safeGitStatusS
+} from "../../../../../chunk-fdk7tact.js";
+import"../../../../../chunk-1gb5qxz9.js";
+import {
+  defineWorkflow
+} from "../../../../../chunk-mn870nrv.js";
+
+// src/sdk/workflows/builtin/ralph/copilot/index.ts
+var MAX_LOOPS = 10;
+var CONSECUTIVE_CLEAN_THRESHOLD = 2;
+var AGENT_SEND_TIMEOUT_MS = 30 * 60 * 1000;
+function getAssistantText(messages) {
+  return messages.filter((m) => m.type === "assistant.message" && !m.data.parentToolCallId).map((m) => m.data.content).filter((c) => c.length > 0).join(`
+
+`);
+}
+var copilot_default = defineWorkflow({
+  name: "ralph",
+  description: "Plan \u2192 orchestrate \u2192 review \u2192 debug loop with bounded iteration"
+}).run(async (ctx) => {
+  let consecutiveClean = 0;
+  let debuggerReport = "";
+  for (let iteration = 1;iteration <= MAX_LOOPS; iteration++) {
+    const plannerName = `planner-${iteration}`;
+    const planner = await ctx.stage({ name: plannerName }, {}, { agent: "planner" }, async (s) => {
+      await s.session.sendAndWait({
+        prompt: buildPlannerPrompt(s.userPrompt, {
+          iteration,
+          debuggerReport: debuggerReport || undefined
+        })
+      }, AGENT_SEND_TIMEOUT_MS);
+      const messages = await s.session.getMessages();
+      s.save(messages);
+      return getAssistantText(messages);
+    });
+    const orchName = `orchestrator-${iteration}`;
+    await ctx.stage({ name: orchName }, {}, { agent: "orchestrator" }, async (s) => {
+      await s.session.sendAndWait({
+        prompt: buildOrchestratorPrompt(s.userPrompt, {
+          plannerNotes: planner.result
+        })
+      }, AGENT_SEND_TIMEOUT_MS);
+      s.save(await s.session.getMessages());
+    });
+    let gitStatus = await safeGitStatusS();
+    const reviewerName = `reviewer-${iteration}`;
+    const review = await ctx.stage({ name: reviewerName }, {}, { agent: "reviewer" }, async (s) => {
+      await s.session.sendAndWait({
+        prompt: buildReviewPrompt(s.userPrompt, {
+          gitStatus,
+          iteration
+        })
+      }, AGENT_SEND_TIMEOUT_MS);
+      const messages = await s.session.getMessages();
+      s.save(messages);
+      return getAssistantText(messages);
+    });
+    let reviewRaw = review.result;
+    let parsed = parseReviewResult(reviewRaw);
+    if (!hasActionableFindings(parsed, reviewRaw)) {
+      consecutiveClean += 1;
+      if (consecutiveClean >= CONSECUTIVE_CLEAN_THRESHOLD)
+        break;
+      gitStatus = await safeGitStatusS();
+      const confirmName = `reviewer-${iteration}-confirm`;
+      const confirm = await ctx.stage({ name: confirmName }, {}, { agent: "reviewer" }, async (s) => {
+        await s.session.sendAndWait({
+          prompt: buildReviewPrompt(s.userPrompt, {
+            gitStatus,
+            iteration,
+            isConfirmationPass: true
+          })
+        }, AGENT_SEND_TIMEOUT_MS);
+        const messages = await s.session.getMessages();
+        s.save(messages);
+        return getAssistantText(messages);
+      });
+      reviewRaw = confirm.result;
+      parsed = parseReviewResult(reviewRaw);
+      if (!hasActionableFindings(parsed, reviewRaw)) {
+        consecutiveClean += 1;
+        if (consecutiveClean >= CONSECUTIVE_CLEAN_THRESHOLD)
+          break;
+      } else {
+        consecutiveClean = 0;
+      }
+    } else {
+      consecutiveClean = 0;
+    }
+    if (hasActionableFindings(parsed, reviewRaw) && iteration < MAX_LOOPS) {
+      const debuggerName = `debugger-${iteration}`;
+      const debugger_ = await ctx.stage({ name: debuggerName }, {}, { agent: "debugger" }, async (s) => {
+        await s.session.sendAndWait({
+          prompt: buildDebuggerReportPrompt(parsed, reviewRaw, {
+            iteration,
+            gitStatus
+          })
+        }, AGENT_SEND_TIMEOUT_MS);
+        const messages = await s.session.getMessages();
+        s.save(messages);
+        return getAssistantText(messages);
+      });
+      debuggerReport = extractMarkdownBlock(debugger_.result);
+    }
+  }
+}).compile();
+export {
+  copilot_default as default
+};

package/dist/sdk/workflows/builtin/ralph/helpers/git.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Deterministic working-tree probes used by the Ralph loop.
+ *
+ * The reviewer and debugger sub-agents both benefit from knowing exactly which
+ * files were touched in the current iteration. Asking an LLM to figure that
+ * out via tool calls is expensive and lossy, so we capture `git status -s`
+ * directly from the workflow runner and inject it into prompts.
+ *
+ * Failures (no git binary, not a repo, command non-zero) collapse to "" so
+ * the prompts can fall back to the "working tree clean" branch.
+ */
+/**
+ * Run `git status -s` from the given cwd. Returns trimmed stdout, or "" on
+ * any error. Never throws.
+ */
+export declare function safeGitStatusS(cwd?: string): Promise<string>;

package/dist/sdk/workflows/builtin/ralph/helpers/prompts.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Ralph Prompt Utilities
+ *
+ * Prompts used by the Ralph plan → orchestrate → review → debug loop:
+ *   - buildPlannerPrompt:        initial planning OR re-planning from a debugger report
+ *   - buildOrchestratorPrompt:   spawn workers to execute the task list
+ *   - buildReviewPrompt:         structured code review with injected git status
+ *   - buildDebuggerReportPrompt: diagnose review findings, produce a re-plan brief
+ *
+ * Plus parsing helpers for the reviewer JSON output and the debugger markdown
+ * report.
+ *
+ * Zero-dependency: no imports from the Atomic runtime.
+ */
+export interface PlannerContext {
+    /** 1-indexed loop iteration. Iteration 1 = initial plan; >1 = re-plan. */
+    iteration: number;
+    /** Markdown report from the previous iteration's debugger sub-agent. */
+    debuggerReport?: string;
+}
+/**
+ * Build the planner prompt. The first iteration decomposes the original spec;
+ * subsequent iterations decompose the work needed to resolve the debugger
+ * report from the previous loop iteration.
+ */
+export declare function buildPlannerPrompt(spec: string, context?: PlannerContext): string;
+export interface OrchestratorContext {
+    /**
+     * Trailing commentary from the planner's last assistant message, if any.
+     * The Copilot and OpenCode workflows create a fresh session for each
+     * sub-agent, so the planner's in-session output is NOT automatically
+     * visible to the orchestrator — only what the planner persisted via
+     * `TaskCreate`. Forward the planner's final text here so the orchestrator
+     * sees any caveats, risks, or execution hints that didn't fit into task
+     * bodies.
+     */
+    plannerNotes?: string;
+}
+/**
+ * Build the orchestrator prompt. The orchestrator retrieves the planner's
+ * task list, validates the dependency graph, and spawns parallel workers.
+ *
+ * @param spec - The original user specification. Required because the
+ *   orchestrator runs in a fresh session on Copilot/OpenCode and needs the
+ *   end-user goal to resolve ambiguous tasks.
+ * @param context - Optional planner handoff context (trailing commentary).
+ */
+export declare function buildOrchestratorPrompt(spec: string, context?: OrchestratorContext): string;
+/** A single finding from the reviewer sub-agent. */
+export interface ReviewFinding {
+    title: string;
+    body: string;
+    confidence_score?: number;
+    priority?: number;
+    code_location?: {
+        absolute_file_path: string;
+        line_range: {
+            start: number;
+            end: number;
+        };
+    };
+}
+/** Parsed reviewer JSON output. */
+export interface ReviewResult {
+    findings: ReviewFinding[];
+    overall_correctness: string;
+    overall_explanation: string;
+    overall_confidence_score?: number;
+}
+export interface ReviewContext {
+    /** Output of `git status -s` captured immediately before the review. */
+    gitStatus: string;
+    /** 1-indexed loop iteration, used in the prompt header. */
+    iteration?: number;
+    /**
+     * Whether this is the second consecutive review pass within the same loop
+     * iteration (i.e. the previous pass had zero findings and we are
+     * confirming before counting two clean reviews in a row).
+     */
+    isConfirmationPass?: boolean;
+}
+/**
+ * Build the reviewer prompt. Injects deterministic `git status -s` so the
+ * reviewer doesn't have to re-discover what changed.
+ */
+export declare function buildReviewPrompt(spec: string, context: ReviewContext): string;
+export interface DebuggerContext {
+    /** 1-indexed loop iteration the debugger is investigating. */
+    iteration: number;
+    /** Output of `git status -s` from immediately before the review. */
+    gitStatus: string;
+}
+/**
+ * Build a prompt asking the debugger sub-agent to investigate a set of review
+ * findings and produce a structured report. The debugger MUST NOT apply
+ * fixes — its only deliverable is the report, which the next iteration's
+ * planner consumes.
+ */
+export declare function buildDebuggerReportPrompt(review: ReviewResult | null, rawReview: string, context: DebuggerContext): string;
+/**
+ * Parse the reviewer's JSON output. Tries, in order:
+ *   1. Direct JSON.parse on the entire content.
+ *   2. The LAST fenced ```json (or unlabelled) code block.
+ *   3. The LAST balanced object containing a "findings" key in surrounding prose.
+ *
+ * Filters out P3 (minor/style) findings — only P0/P1/P2 count as actionable.
+ * Returns null when no parse strategy succeeds.
+ */
+export declare function parseReviewResult(content: string): ReviewResult | null;
+/**
+ * Extract the LAST fenced ```markdown block from a piece of text. Used for
+ * parsing the debugger's structured report out of a long Claude pane
+ * scrollback or any other output that may include extra prose.
+ *
+ * Falls back to the trimmed full input when no fenced block is present, so
+ * the planner still receives the debugger's content even if formatting drifts.
+ */
+export declare function extractMarkdownBlock(content: string): string;

package/dist/sdk/workflows/builtin/ralph/helpers/review.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Review analysis helpers for the Ralph workflow.
+ *
+ * Simplified versions of the internal conductor-based helpers,
+ * operating on direct values instead of StageOutput maps.
+ */
+import type { ReviewResult } from "./prompts.js";
+/**
+ * Check whether the reviewer produced actionable findings.
+ *
+ * Returns true when:
+ * 1. The parsed ReviewResult has one or more findings, OR
+ * 2. The review could not be parsed (null) but the raw response
+ *    text is non-empty (treat unparseable output as actionable).
+ *
+ * @param review  - Parsed ReviewResult, or null if parsing failed.
+ * @param rawText - The raw reviewer response text.
+ */
+export declare function hasActionableFindings(review: ReviewResult | null, rawText: string): boolean;

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

@@ -0,0 +1,13 @@
+/**
+ * Ralph workflow for OpenCode — 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 opencode "<your spec>"
+ */
+declare const _default: import("../../../index.ts").WorkflowDefinition<"opencode">;
+export default _default;

package/dist/sdk/workflows/builtin/ralph/opencode/index.js

@@ -0,0 +1,147 @@
+// @bun
+import {
+  buildDebuggerReportPrompt,
+  buildOrchestratorPrompt,
+  buildPlannerPrompt,
+  buildReviewPrompt,
+  extractMarkdownBlock,
+  hasActionableFindings,
+  parseReviewResult,
+  safeGitStatusS
+} from "../../../../../chunk-fdk7tact.js";
+import"../../../../../chunk-1gb5qxz9.js";
+import {
+  defineWorkflow
+} from "../../../../../chunk-mn870nrv.js";
+
+// src/sdk/workflows/builtin/ralph/opencode/index.ts
+var MAX_LOOPS = 10;
+var CONSECUTIVE_CLEAN_THRESHOLD = 2;
+function extractResponseText(parts) {
+  return parts.filter((p) => p.type === "text").map((p) => p.text).join(`
+`);
+}
+var opencode_default = defineWorkflow({
+  name: "ralph",
+  description: "Plan \u2192 orchestrate \u2192 review \u2192 debug loop with bounded iteration"
+}).run(async (ctx) => {
+  let consecutiveClean = 0;
+  let debuggerReport = "";
+  for (let iteration = 1;iteration <= MAX_LOOPS; iteration++) {
+    const plannerName = `planner-${iteration}`;
+    const planner = await ctx.stage({ name: plannerName }, {}, { title: `planner-${iteration}` }, async (s) => {
+      const result = await s.client.session.prompt({
+        sessionID: s.session.id,
+        parts: [
+          {
+            type: "text",
+            text: buildPlannerPrompt(s.userPrompt, {
+              iteration,
+              debuggerReport: debuggerReport || undefined
+            })
+          }
+        ],
+        agent: "planner"
+      });
+      s.save(result.data);
+      return extractResponseText(result.data.parts);
+    });
+    const orchName = `orchestrator-${iteration}`;
+    await ctx.stage({ name: orchName }, {}, { title: `orchestrator-${iteration}` }, async (s) => {
+      const result = await s.client.session.prompt({
+        sessionID: s.session.id,
+        parts: [
+          {
+            type: "text",
+            text: buildOrchestratorPrompt(s.userPrompt, {
+              plannerNotes: planner.result
+            })
+          }
+        ],
+        agent: "orchestrator"
+      });
+      s.save(result.data);
+    });
+    let gitStatus = await safeGitStatusS();
+    const reviewerName = `reviewer-${iteration}`;
+    const review = await ctx.stage({ name: reviewerName }, {}, { title: `reviewer-${iteration}` }, async (s) => {
+      const result = await s.client.session.prompt({
+        sessionID: s.session.id,
+        parts: [
+          {
+            type: "text",
+            text: buildReviewPrompt(s.userPrompt, {
+              gitStatus,
+              iteration
+            })
+          }
+        ],
+        agent: "reviewer"
+      });
+      s.save(result.data);
+      return extractResponseText(result.data.parts);
+    });
+    let reviewRaw = review.result;
+    let parsed = parseReviewResult(reviewRaw);
+    if (!hasActionableFindings(parsed, reviewRaw)) {
+      consecutiveClean += 1;
+      if (consecutiveClean >= CONSECUTIVE_CLEAN_THRESHOLD)
+        break;
+      gitStatus = await safeGitStatusS();
+      const confirmName = `reviewer-${iteration}-confirm`;
+      const confirm = await ctx.stage({ name: confirmName }, {}, { title: `reviewer-${iteration}-confirm` }, async (s) => {
+        const result = await s.client.session.prompt({
+          sessionID: s.session.id,
+          parts: [
+            {
+              type: "text",
+              text: buildReviewPrompt(s.userPrompt, {
+                gitStatus,
+                iteration,
+                isConfirmationPass: true
+              })
+            }
+          ],
+          agent: "reviewer"
+        });
+        s.save(result.data);
+        return extractResponseText(result.data.parts);
+      });
+      reviewRaw = confirm.result;
+      parsed = parseReviewResult(reviewRaw);
+      if (!hasActionableFindings(parsed, reviewRaw)) {
+        consecutiveClean += 1;
+        if (consecutiveClean >= CONSECUTIVE_CLEAN_THRESHOLD)
+          break;
+      } else {
+        consecutiveClean = 0;
+      }
+    } else {
+      consecutiveClean = 0;
+    }
+    if (hasActionableFindings(parsed, reviewRaw) && iteration < MAX_LOOPS) {
+      const debuggerName = `debugger-${iteration}`;
+      const debugger_ = await ctx.stage({ name: debuggerName }, {}, { title: `debugger-${iteration}` }, async (s) => {
+        const result = await s.client.session.prompt({
+          sessionID: s.session.id,
+          parts: [
+            {
+              type: "text",
+              text: buildDebuggerReportPrompt(parsed, reviewRaw, {
+                iteration,
+                gitStatus
+              })
+            }
+          ],
+          agent: "debugger"
+        });
+        s.save(result.data);
+        return extractResponseText(result.data.parts);
+      });
+      debuggerReport = extractMarkdownBlock(debugger_.result);
+    }
+  }
+}).compile();
+export {
+  opencode_default as default
+};

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

@@ -0,0 +1,24 @@
+/**
+ * atomic/workflows
+ *
+ * Workflow SDK for defining dynamic agent workflows.
+ * Workflows use defineWorkflow().run().compile() with ctx.stage()
+ * for spawning agent sessions using native TypeScript control flow.
+ */
+export { defineWorkflow, WorkflowBuilder } from "../define-workflow.js";
+export type { AgentType, Transcript, SavedMessage, SaveTranscript, SessionContext, SessionRef, SessionHandle, SessionRunOptions, WorkflowContext, WorkflowOptions, WorkflowDefinition, StageClientOptions, StageSessionOptions, ProviderClient, ProviderSession, CopilotClient, CopilotClientOptions, CopilotSession, CopilotSessionConfig, OpencodeClient, OpencodeSession, ClaudeClientWrapper, ClaudeSessionWrapper, ClaudeQueryDefaults, } from "../types.js";
+export type { SessionEvent as CopilotSessionEvent } from "@github/copilot-sdk";
+export type { SessionPromptResponse as OpenCodePromptResponse } from "@opencode-ai/sdk/v2";
+export type { SessionMessage as ClaudeSessionMessage } from "@anthropic-ai/claude-agent-sdk";
+export { createClaudeSession, claudeQuery, clearClaudeSession, validateClaudeWorkflow } from "../providers/claude.js";
+export type { ClaudeSessionOptions, ClaudeQueryOptions, ClaudeQueryResult, ClaudeValidationWarning } from "../providers/claude.js";
+export { validateCopilotWorkflow } from "../providers/copilot.js";
+export type { CopilotValidationWarning } from "../providers/copilot.js";
+export { validateOpenCodeWorkflow } from "../providers/opencode.js";
+export type { OpenCodeValidationWarning } from "../providers/opencode.js";
+export { isTmuxInstalled, getMuxBinary, resetMuxBinaryCache, isInsideTmux, createSession, createWindow, createPane, sendLiteralText, sendSpecialKey, sendKeysAndSubmit, capturePane, capturePaneVisible, capturePaneScrollback, killSession, killWindow, sessionExists, attachSession, switchClient, getCurrentSession, attachOrSwitch, selectWindow, waitForOutput, tmuxRun, normalizeTmuxCapture, normalizeTmuxLines, paneLooksReady, paneHasActiveTask, paneIsIdle, waitForPaneReady, attemptSubmitRounds, } from "../runtime/tmux.js";
+export { AGENTS, discoverWorkflows, findWorkflow, WORKFLOWS_GITIGNORE, } from "../runtime/discovery.js";
+export type { DiscoveredWorkflow } from "../runtime/discovery.js";
+export { WorkflowLoader } from "../runtime/loader.js";
+export { executeWorkflow } from "../runtime/executor.js";
+export type { WorkflowRunOptions } from "../runtime/executor.js";

package/dist/sdk/workflows/index.js

@@ -0,0 +1,94 @@
+// @bun
+import"../../chunk-1gb5qxz9.js";
+import {
+  AGENTS,
+  WORKFLOWS_GITIGNORE,
+  WorkflowBuilder,
+  WorkflowLoader,
+  attachOrSwitch,
+  attachSession,
+  attemptSubmitRounds,
+  capturePane,
+  capturePaneScrollback,
+  capturePaneVisible,
+  claudeQuery,
+  clearClaudeSession,
+  createClaudeSession,
+  createPane,
+  createSession,
+  createWindow,
+  defineWorkflow,
+  discoverWorkflows,
+  executeWorkflow,
+  findWorkflow,
+  getCurrentSession,
+  getMuxBinary,
+  isInsideTmux,
+  isTmuxInstalled,
+  killSession,
+  killWindow,
+  normalizeTmuxCapture,
+  normalizeTmuxLines,
+  paneHasActiveTask,
+  paneIsIdle,
+  paneLooksReady,
+  resetMuxBinaryCache,
+  selectWindow,
+  sendKeysAndSubmit,
+  sendLiteralText,
+  sendSpecialKey,
+  sessionExists,
+  switchClient,
+  tmuxRun,
+  validateClaudeWorkflow,
+  validateCopilotWorkflow,
+  validateOpenCodeWorkflow,
+  waitForOutput,
+  waitForPaneReady
+} from "../../chunk-mn870nrv.js";
+export {
+  waitForPaneReady,
+  waitForOutput,
+  validateOpenCodeWorkflow,
+  validateCopilotWorkflow,
+  validateClaudeWorkflow,
+  tmuxRun,
+  switchClient,
+  sessionExists,
+  sendSpecialKey,
+  sendLiteralText,
+  sendKeysAndSubmit,
+  selectWindow,
+  resetMuxBinaryCache,
+  paneLooksReady,
+  paneIsIdle,
+  paneHasActiveTask,
+  normalizeTmuxLines,
+  normalizeTmuxCapture,
+  killWindow,
+  killSession,
+  isTmuxInstalled,
+  isInsideTmux,
+  getMuxBinary,
+  getCurrentSession,
+  findWorkflow,
+  executeWorkflow,
+  discoverWorkflows,
+  defineWorkflow,
+  createWindow,
+  createSession,
+  createPane,
+  createClaudeSession,
+  clearClaudeSession,
+  claudeQuery,
+  capturePaneVisible,
+  capturePaneScrollback,
+  capturePane,
+  attemptSubmitRounds,
+  attachSession,
+  attachOrSwitch,
+  WorkflowLoader,
+  WorkflowBuilder,
+  WORKFLOWS_GITIGNORE,
+  AGENTS
+};