@bastani/atomic 0.5.4 → 0.5.5-0

package/src/sdk/runtime/loader.ts

@@ -12,6 +12,7 @@
 
 import type { WorkflowDefinition, AgentType } from "../types.ts";
 import type { DiscoveredWorkflow } from "./discovery.ts";
+import { errorMessage, WorkflowNotCompiledError, InvalidWorkflowError } from "../errors.ts";
 import { validateCopilotWorkflow } from "../providers/copilot.ts";
 import { validateOpenCodeWorkflow } from "../providers/opencode.ts";
 import { validateClaudeWorkflow } from "../providers/claude.ts";
@@ -44,11 +45,8 @@ export namespace WorkflowLoader {
   /** Output of the resolve stage. */
   export type Resolved = Plan;
 
-  /** A source validation warning (agent-specific). */
-  export interface ValidationWarning {
-    rule: string;
-    message: string;
-  }
+  /** Source validation warning — alias of the canonical type from types.ts. */
+  export type ValidationWarning = import("../types.ts").ValidationWarning;
 
   /** Output of the validate stage. */
   export type Validated = Resolved & {
@@ -97,7 +95,7 @@ export namespace WorkflowLoader {
         ok: false,
         stage: "resolve",
         error,
-        message: error instanceof Error ? error.message : String(error),
+        message: errorMessage(error),
       };
     }
   }
@@ -115,8 +113,10 @@ export namespace WorkflowLoader {
         return validateOpenCodeWorkflow(source);
       case "claude":
         return validateClaudeWorkflow(source);
-      default:
-        return [];
+      default: {
+        const _exhaustive: never = agent;
+        return _exhaustive;
+      }
     }
   }
 
@@ -140,7 +140,7 @@ export namespace WorkflowLoader {
         ok: false,
         stage: "validate",
         error,
-        message: error instanceof Error ? error.message : String(error),
+        message: errorMessage(error),
       };
     }
   }
@@ -162,26 +162,21 @@ export namespace WorkflowLoader {
 
       if (!definition || definition.__brand !== "WorkflowDefinition") {
         if (definition && definition.__brand === "WorkflowBuilder") {
+          const err = new WorkflowNotCompiledError(validated.path);
           return {
             ok: false,
             stage: "load",
-            error: new Error("Workflow not compiled"),
-            message:
-              `Workflow at ${validated.path} was defined but not compiled.\n` +
-              `  Add .compile() at the end of your defineWorkflow() chain:\n\n` +
-              `    export default defineWorkflow({ ... })\n` +
-              `      .run(async (ctx) => { ... })\n` +
-              `      .compile();`,
+            error: err,
+            message: err.message,
           };
         }
 
+        const err = new InvalidWorkflowError(validated.path);
         return {
           ok: false,
           stage: "load",
-          error: new Error("Invalid workflow export"),
-          message:
-            `${validated.path} does not export a valid WorkflowDefinition.\n` +
-            `  Make sure it exports defineWorkflow(...).run(...).compile() as the default export.`,
+          error: err,
+          message: err.message,
         };
       }
 
@@ -194,7 +189,7 @@ export namespace WorkflowLoader {
         ok: false,
         stage: "load",
         error,
-        message: error instanceof Error ? error.message : String(error),
+        message: errorMessage(error),
       };
     }
   }

package/src/sdk/runtime/tmux.ts

@@ -6,7 +6,9 @@
  * sending keystrokes, and pane state detection.
  */
 
-import { join } from "path";
+import { join } from "node:path";
+import { writeFileSync, unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
 import type { Subprocess } from "bun";
 
 // ---------------------------------------------------------------------------
@@ -19,6 +21,11 @@ export const SOCKET_NAME = "atomic";
 /** Path to the bundled tmux config (shared by tmux and psmux). */
 const CONFIG_PATH = join(import.meta.dir, "tmux.conf");
 
+/** Discriminated result from a tmux command execution. */
+export type TmuxResult =
+  | { ok: true; stdout: string }
+  | { ok: false; stderr: string };
+
 // ---------------------------------------------------------------------------
 // Core tmux primitives
 // ---------------------------------------------------------------------------
@@ -81,7 +88,7 @@ export function isInsideTmux(): boolean {
  * Prefers this over the throwing `tmux()` for cases where callers
  * need to handle failure gracefully.
  */
-export function tmuxRun(args: string[]): { ok: true; stdout: string } | { ok: false; stderr: string } {
+export function tmuxRun(args: string[]): TmuxResult {
   const binary = getMuxBinary();
   if (!binary) {
     return { ok: false, stderr: "No terminal multiplexer (tmux/psmux) found on PATH" };
@@ -93,10 +100,9 @@ export function tmuxRun(args: string[]): { ok: true; stdout: string } | { ok: fa
     stderr: "pipe",
   });
   if (!result.success) {
-    const stderr = new TextDecoder().decode(result.stderr).trim();
-    return { ok: false, stderr };
+    return { ok: false, stderr: result.stderr.toString().trim() };
   }
-  return { ok: true, stdout: new TextDecoder().decode(result.stdout).trim() };
+  return { ok: true, stdout: result.stdout.toString().trim() };
 }
 
 /**
@@ -223,14 +229,64 @@ export function createPane(sessionName: string, command: string): string {
 // Keystroke sending
 // ---------------------------------------------------------------------------
 
+/**
+ * Maximum bytes per `send-keys -l` invocation.
+ *
+ * tmux passes the text as a single command-line argument to the child
+ * process. On Linux the per-argument limit (`MAX_ARG_STRLEN`) is 128 KB;
+ * on macOS the total `ARG_MAX` is ~1 MB but shared across all args.
+ * We stay well under both limits with 50 KB chunks.
+ */
+const SEND_KEYS_CHUNK_SIZE = 50_000;
+
 /**
  * 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.
+ *
+ * Long texts are chunked to avoid OS `ARG_MAX` / `MAX_ARG_STRLEN` limits
+ * that cause `tmux send-keys` to fail with "command too long".
  */
 export function sendLiteralText(paneId: string, text: string): void {
   // Replace newlines with spaces to avoid premature submission
   const normalized = text.replace(/[\r\n]+/g, " ");
-  tmuxExec(["send-keys", "-t", paneId, "-l", "--", normalized]);
+
+  if (normalized.length <= SEND_KEYS_CHUNK_SIZE) {
+    tmuxExec(["send-keys", "-t", paneId, "-l", "--", normalized]);
+    return;
+  }
+
+  for (let offset = 0; offset < normalized.length; offset += SEND_KEYS_CHUNK_SIZE) {
+    const chunk = normalized.slice(offset, offset + SEND_KEYS_CHUNK_SIZE);
+    tmuxExec(["send-keys", "-t", paneId, "-l", "--", chunk]);
+  }
+}
+
+/**
+ * Send text to a tmux pane via the paste buffer.
+ *
+ * More reliable than `send-keys -l` for large text:
+ * - No OS ARG_MAX / MAX_ARG_STRLEN limits (text goes through a temp file)
+ * - Atomic delivery — the entire text is pasted at once
+ * - No chunking needed
+ *
+ * Newlines are normalized to spaces to prevent premature submission,
+ * matching `sendLiteralText`'s behavior.
+ */
+export function sendViaPasteBuffer(paneId: string, text: string): void {
+  const normalized = text.replace(/[\r\n]+/g, " ");
+  const tmp = join(tmpdir(), `atomic-paste-${process.pid}-${Date.now()}.txt`);
+
+  writeFileSync(tmp, normalized, "utf-8");
+  try {
+    tmuxExec(["load-buffer", tmp]);
+    tmuxExec(["paste-buffer", "-t", paneId, "-d"]);
+  } finally {
+    try {
+      unlinkSync(tmp);
+    } catch {
+      // Temp file cleanup is best-effort
+    }
+  }
 }
 
 /**
@@ -247,17 +303,17 @@ export function sendSpecialKey(paneId: string, key: string): void {
  * @param presses - Number of C-m presses (default: 1)
  * @param delayMs - Delay between presses in ms (default: 100)
  */
-export function sendKeysAndSubmit(
+export async function sendKeysAndSubmit(
   paneId: string,
   text: string,
   presses = 1,
   delayMs = 100
-): void {
+): Promise<void> {
   sendLiteralText(paneId, text);
 
   for (let i = 0; i < presses; i++) {
     if (i > 0 && delayMs > 0) {
-      Bun.sleepSync(delayMs);
+      await Bun.sleep(delayMs);
     }
     sendSpecialKey(paneId, "C-m");
   }
@@ -281,6 +337,16 @@ export function capturePane(paneId: string, start?: number): string {
   return tmux(args);
 }
 
+/** Internal capture helper — returns empty string on failure. */
+function capturePaneRaw(paneId: string, scrollbackLines?: number): string {
+  const args = ["capture-pane", "-t", paneId, "-p"];
+  if (scrollbackLines !== undefined) {
+    args.push("-S", `-${scrollbackLines}`);
+  }
+  const result = tmuxRun(args);
+  return result.ok ? result.stdout : "";
+}
+
 /**
  * Capture only the visible portion of a pane (no scrollback).
  * Preferred for state detection (ready/busy) to avoid stale prompt lines
@@ -288,9 +354,7 @@ export function capturePane(paneId: string, start?: number): string {
  * Returns empty string on failure instead of throwing.
  */
 export function capturePaneVisible(paneId: string): string {
-  const result = tmuxRun(["capture-pane", "-t", paneId, "-p"]);
-  if (!result.ok) return "";
-  return result.stdout;
+  return capturePaneRaw(paneId);
 }
 
 /**
@@ -299,9 +363,7 @@ export function capturePaneVisible(paneId: string): string {
  * Returns empty string on failure instead of throwing.
  */
 export function capturePaneScrollback(paneId: string, lines = 200): string {
-  const result = tmuxRun(["capture-pane", "-t", paneId, "-p", "-S", `-${lines}`]);
-  if (!result.ok) return "";
-  return result.stdout;
+  return capturePaneRaw(paneId, lines);
 }
 
 // ---------------------------------------------------------------------------
@@ -336,22 +398,28 @@ export function sessionExists(sessionName: string): boolean {
   return result.ok;
 }
 
-/**
- * Attach to an existing tmux session (takes over the current terminal).
- */
-export function attachSession(sessionName: string): void {
+/** Build the full argument list for an attach-session command. */
+function buildAttachArgs(sessionName: string): string[] {
   const binary = getMuxBinary();
   if (!binary) {
     throw new Error("No terminal multiplexer (tmux/psmux) found on PATH");
   }
+  return [binary, "-f", CONFIG_PATH, "-L", SOCKET_NAME, "attach-session", "-t", sessionName];
+}
+
+/**
+ * Attach to an existing tmux session (takes over the current terminal).
+ */
+export function attachSession(sessionName: string): void {
+  const cmd = buildAttachArgs(sessionName);
   const proc = Bun.spawnSync({
-    cmd: [binary, "-f", CONFIG_PATH, "-L", SOCKET_NAME, "attach-session", "-t", sessionName],
+    cmd,
     stdin: "inherit",
     stdout: "inherit",
     stderr: "pipe",
   });
   if (!proc.success) {
-    const stderr = new TextDecoder().decode(proc.stderr).trim();
+    const stderr = proc.stderr.toString().trim();
     throw new Error(`Failed to attach to session: ${sessionName}${stderr ? ` (${stderr})` : ""}`);
   }
 }
@@ -362,14 +430,9 @@ export function attachSession(sessionName: string): void {
  * Used by all async attach call sites (executor, chat).
  */
 export function spawnMuxAttach(sessionName: string): Subprocess {
-  const binary = getMuxBinary();
-  if (!binary) {
-    throw new Error("No terminal multiplexer (tmux/psmux) found on PATH");
-  }
-  return Bun.spawn(
-    [binary, "-f", CONFIG_PATH, "-L", SOCKET_NAME, "attach-session", "-t", sessionName],
-    { stdio: ["inherit", "inherit", "inherit"] },
-  );
+  return Bun.spawn(buildAttachArgs(sessionName), {
+    stdio: ["inherit", "inherit", "inherit"],
+  });
 }
 
 /**
@@ -485,10 +548,10 @@ export function paneHasActiveTask(captured: string): boolean {
     .map((line) => line.trim())
     .slice(-40);
 
-  if (tail.some((l) => /\b\d+\s+background terminal running\b/i.test(l))) return true;
-  if (tail.some((l) => /esc to interrupt/i.test(l))) return true;
-  if (tail.some((l) => /\bbackground terminal running\b/i.test(l))) return true;
   return tail.some((l) =>
+    /\b\d+\s+background terminal running\b/i.test(l) ||
+    /esc to interrupt/i.test(l) ||
+    /\bbackground terminal running\b/i.test(l) ||
     /^[·✻]\s+[A-Za-z][A-Za-z0-9''-]*(?:\s+[A-Za-z][A-Za-z0-9''-]*){0,3}(?:…|\.{3})$/u.test(l),
   );
 }

package/src/sdk/types.ts

@@ -95,6 +95,51 @@ export type {
   ClaudeQueryDefaults,
 };
 
+// ─── Validation ─────────────────────────────────────────────────────────────
+
+/** A source validation warning emitted by provider-specific workflow validators. */
+export interface ValidationWarning {
+  rule: string;
+  message: string;
+}
+
+/** A declarative validation rule: pattern to match + warning to emit. */
+export interface ValidationRule {
+  pattern: RegExp;
+  rule: string;
+  message: string;
+}
+
+/**
+ * Run a set of regex-based validation rules against workflow source code.
+ * Returns a warning for each matching pattern.
+ */
+export function validateWorkflowSource(
+  source: string,
+  rules: readonly ValidationRule[],
+): ValidationWarning[] {
+  // Strip single-line comments to avoid false positives from patterns
+  // that appear only in comments (e.g., a comment mentioning claudeQuery).
+  const stripped = source.replace(/\/\/.*$/gm, "");
+  const warnings: ValidationWarning[] = [];
+  for (const { pattern, rule, message } of rules) {
+    if (pattern.test(stripped)) {
+      warnings.push({ rule, message });
+    }
+  }
+  return warnings;
+}
+
+/**
+ * Create a provider-specific workflow validator from a set of rules.
+ * Eliminates boilerplate — each provider file only needs to declare its rules.
+ */
+export function createProviderValidator(
+  rules: readonly ValidationRule[],
+): (source: string) => ValidationWarning[] {
+  return (source) => validateWorkflowSource(source, rules);
+}
+
 // ─── Workflow input schemas ─────────────────────────────────────────────────
 
 /**

package/src/sdk/workflows/builtin/deep-research-codebase/claude/index.ts

@@ -79,6 +79,23 @@ import {
   slugifyPrompt,
 } from "../helpers/prompts.ts";
 
+// ── Timeouts ────────────────────────────────────────────────────────────────
+// Every s.session.query() call passes one of these explicitly — never relying
+// on the 300-second default. Explorer and aggregator stages dispatch sub-agents
+// and can easily run 30+ minutes; a premature timeout causes the stage to
+// complete early, which makes Promise.all resolve and the next stage to launch
+// before parallel stages finish.
+const SCOUT_TIMEOUT_MS = 15 * 60 * 1000; // 15 min — short orientation call
+const HISTORY_TIMEOUT_MS = 20 * 60 * 1000; // 20 min — reads research/ docs
+const EXPLORER_TIMEOUT_MS = 45 * 60 * 1000; // 45 min — multi-step sub-agent dispatch
+const AGGREGATOR_TIMEOUT_MS = 45 * 60 * 1000; // 45 min — reads N explorer reports
+
+// Between sub-agent dispatches Claude's TUI briefly shows the prompt indicator
+// without an active-task spinner. Requiring 3 consecutive idle detections
+// prevents the query from returning during these transient gaps.
+const EXPLORER_IDLE_CONFIRM = 3;
+const AGGREGATOR_IDLE_CONFIRM = 3;
+
 export default defineWorkflow<"claude">({
     name: "deep-research-codebase",
     description:
@@ -149,6 +166,7 @@ export default defineWorkflow<"claude">({
               explorerCount: actualCount,
               partitionPreview: partitions,
             }),
+            { timeoutMs: SCOUT_TIMEOUT_MS },
           );
           s.save(s.sessionId);
 
@@ -177,6 +195,7 @@ export default defineWorkflow<"claude">({
           // synthesis as prose (no file write — consumed via transcript).
           await s.session.query(
             buildHistoryPrompt({ question: prompt, root }),
+            { timeoutMs: HISTORY_TIMEOUT_MS },
           );
           s.save(s.sessionId);
         },
@@ -236,6 +255,10 @@ export default defineWorkflow<"claude">({
                 scratchPath,
                 root,
               }),
+              {
+                timeoutMs: EXPLORER_TIMEOUT_MS,
+                idleConfirmCount: EXPLORER_IDLE_CONFIRM,
+              },
             );
             s.save(s.sessionId);
 
@@ -286,6 +309,10 @@ export default defineWorkflow<"claude">({
             scoutOverview,
             historyOverview,
           }),
+          {
+            timeoutMs: AGGREGATOR_TIMEOUT_MS,
+            idleConfirmCount: AGGREGATOR_IDLE_CONFIRM,
+          },
         );
         s.save(s.sessionId);
       },

package/src/sdk/workflows/builtin/deep-research-codebase/helpers/prompts.ts

@@ -137,9 +137,10 @@ export function buildExplorerPrompt(opts: {
     .map((u) => `\`${path.join(opts.root, u.path)}\``)
     .join(", ");
 
-  const orientation = opts.scoutOverview.trim().length > 0
-    ? opts.scoutOverview.trim()
-    : "(scout overview unavailable — proceed without)";
+  const orientation =
+    opts.scoutOverview.trim().length > 0
+      ? opts.scoutOverview.trim()
+      : "(scout overview unavailable — proceed without)";
 
   return [
     `<RESEARCH_QUESTION>`,
@@ -418,13 +419,15 @@ export function buildExplorerPromptGeneric(opts: {
     .map((u) => `\`${path.join(opts.root, u.path)}\``)
     .join(", ");
 
-  const orientation = opts.scoutOverview.trim().length > 0
-    ? opts.scoutOverview.trim()
-    : "(scout overview unavailable — proceed without)";
+  const orientation =
+    opts.scoutOverview.trim().length > 0
+      ? opts.scoutOverview.trim()
+      : "(scout overview unavailable — proceed without)";
 
-  const history = opts.historyOverview.trim().length > 0
-    ? opts.historyOverview.trim()
-    : "(no historical research surfaced)";
+  const history =
+    opts.historyOverview.trim().length > 0
+      ? opts.historyOverview.trim()
+      : "(no historical research surfaced)";
 
   return [
     `<RESEARCH_QUESTION>`,
@@ -670,7 +673,11 @@ export function buildAggregatorPrompt(opts: {
   totalLoc: number;
   totalFiles: number;
   explorerCount: number;
-  explorerFiles: { index: number; scratchPath: string; partition: PartitionUnit[] }[];
+  explorerFiles: {
+    index: number;
+    scratchPath: string;
+    partition: PartitionUnit[];
+  }[];
   finalPath: string;
   scoutOverview: string;
   historyOverview: string;
@@ -682,13 +689,15 @@ export function buildAggregatorPrompt(opts: {
     })
     .join("\n");
 
-  const orientation = opts.scoutOverview.trim().length > 0
-    ? opts.scoutOverview.trim()
-    : "(scout overview unavailable)";
+  const orientation =
+    opts.scoutOverview.trim().length > 0
+      ? opts.scoutOverview.trim()
+      : "(scout overview unavailable)";
 
-  const history = opts.historyOverview.trim().length > 0
-    ? opts.historyOverview.trim()
-    : "(no historical research surfaced)";
+  const history =
+    opts.historyOverview.trim().length > 0
+      ? opts.historyOverview.trim()
+      : "(no historical research surfaced)";
 
   return [
     `<RESEARCH_QUESTION>`,

package/src/sdk/workflows/builtin/deep-research-codebase/helpers/scout.ts

@@ -13,7 +13,7 @@
  * Everything here is pure TypeScript + child_process — no LLM calls.
  */
 
-import { spawnSync } from "node:child_process";
+// Use Bun.spawnSync instead of node:child_process for consistency with the rest of the codebase.
 
 /** Source-file extensions we treat as "code" for LOC accounting. */
 const CODE_EXTENSIONS = new Set<string>([
@@ -72,12 +72,13 @@ export type CodebaseScout = {
 
 /** Resolve the project root. Prefers `git rev-parse --show-toplevel`. */
 export function getCodebaseRoot(): string {
-  const r = spawnSync("git", ["rev-parse", "--show-toplevel"], {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "ignore"],
+  const r = Bun.spawnSync({
+    cmd: ["git", "rev-parse", "--show-toplevel"],
+    stdout: "pipe",
+    stderr: "pipe",
   });
-  if (r.status === 0 && r.stdout) {
-    return r.stdout.trim();
+  if (r.success && r.stdout) {
+    return r.stdout.toString().trim();
   }
   return process.cwd();
 }
@@ -91,29 +92,29 @@ function isCodeFile(p: string): boolean {
 
 /** List all files in the repository. Prefers git ls-files (respects .gitignore). */
 function listAllFiles(root: string): string[] {
-  const git = spawnSync("git", ["ls-files"], {
+  const git = Bun.spawnSync({
+    cmd: ["git", "ls-files"],
     cwd: root,
-    encoding: "utf8",
-    maxBuffer: 64 * 1024 * 1024,
-    stdio: ["ignore", "pipe", "ignore"],
+    stdout: "pipe",
+    stderr: "pipe",
   });
-  if (git.status === 0 && git.stdout) {
-    return git.stdout.split("\n").filter((l) => l.length > 0);
+  if (git.success && git.stdout) {
+    return git.stdout.toString().split("\n").filter((l) => l.length > 0);
   }
 
   // Fallback: shell out to find with the standard ignore patterns.
-  const args: string[] = [".", "-type", "f"];
+  const args: string[] = ["find", ".", "-type", "f"];
   for (const pattern of FIND_IGNORE_PATTERNS) {
     args.push("-not", "-path", `*/${pattern}/*`);
   }
-  const find = spawnSync("find", args, {
+  const find = Bun.spawnSync({
+    cmd: args,
     cwd: root,
-    encoding: "utf8",
-    maxBuffer: 64 * 1024 * 1024,
-    stdio: ["ignore", "pipe", "ignore"],
+    stdout: "pipe",
+    stderr: "pipe",
   });
-  if (find.status === 0 && find.stdout) {
-    return find.stdout
+  if (find.success && find.stdout) {
+    return find.stdout.toString()
       .split("\n")
       .map((p) => p.replace(/^\.\//, ""))
       .filter((p) => p.length > 0);
@@ -135,14 +136,14 @@ function countLines(root: string, files: string[]): Map<string, number> {
   const BATCH = 200;
   for (let i = 0; i < files.length; i += BATCH) {
     const batch = files.slice(i, i + BATCH);
-    const r = spawnSync("wc", ["-l", "--", ...batch], {
+    const r = Bun.spawnSync({
+      cmd: ["wc", "-l", "--", ...batch],
       cwd: root,
-      encoding: "utf8",
-      maxBuffer: 32 * 1024 * 1024,
-      stdio: ["ignore", "pipe", "ignore"],
+      stdout: "pipe",
+      stderr: "pipe",
     });
     if (!r.stdout) continue;
-    for (const line of r.stdout.split("\n")) {
+    for (const line of r.stdout.toString().split("\n")) {
       const m = line.match(/^\s*(\d+)\s+(.+)$/);
       // Regex groups are typed `string | undefined` under strict mode even
       // when the whole match succeeded — guard explicitly.

package/src/sdk/workflows/builtin/ralph/claude/index.ts

@@ -26,6 +26,10 @@ import { safeGitStatusS } from "../helpers/git.ts";
 const MAX_LOOPS = 10;
 const CONSECUTIVE_CLEAN_THRESHOLD = 2;
 
+// The orchestrator stage implements the actual code changes and can run for
+// a very long time on large tasks. 24 hours prevents premature timeout.
+const ORCHESTRATOR_TIMEOUT_MS = 24 * 60 * 60 * 1000; // 24 hours
+
 /** Wrap a prompt with a Claude Code @-mention so the named sub-agent runs it. */
 function asAgentCall(agentName: string, prompt: string): string {
   return `@"${agentName} (agent)" ${prompt}`;
@@ -78,6 +82,7 @@ export default defineWorkflow<"claude">({
               "orchestrator",
               buildOrchestratorPrompt(prompt),
             ),
+            { timeoutMs: ORCHESTRATOR_TIMEOUT_MS },
           );
           s.save(s.sessionId);
         },

package/src/sdk/workflows/index.ts

@@ -10,6 +10,7 @@ export { defineWorkflow, WorkflowBuilder } from "../define-workflow.ts";
 
 export type {
   AgentType,
+  ValidationWarning,
   Transcript,
   SavedMessage,
   SaveTranscript,
@@ -44,15 +45,14 @@ export type { SessionMessage as ClaudeSessionMessage } from "@anthropic-ai/claud
 
 // Providers
 export { createClaudeSession, claudeQuery, clearClaudeSession, validateClaudeWorkflow } from "../providers/claude.ts";
-export type { ClaudeSessionOptions, ClaudeQueryOptions, ClaudeQueryResult, ClaudeValidationWarning } from "../providers/claude.ts";
+export type { ClaudeSessionOptions, ClaudeQueryOptions, ClaudeQueryResult } from "../providers/claude.ts";
 
 export { validateCopilotWorkflow } from "../providers/copilot.ts";
-export type { CopilotValidationWarning } from "../providers/copilot.ts";
 
 export { validateOpenCodeWorkflow } from "../providers/opencode.ts";
-export type { OpenCodeValidationWarning } from "../providers/opencode.ts";
 
 // Runtime — tmux utilities
+export type { TmuxResult } from "../runtime/tmux.ts";
 export {
   SOCKET_NAME,
   isTmuxInstalled,