@bastani/atomic 0.5.2 → 0.5.3-0

package/dist/chunk-mn870nrv.js

@@ -0,0 +1,982 @@
+// @bun
+// src/sdk/define-workflow.ts
+class WorkflowBuilder {
+  __brand = "WorkflowBuilder";
+  options;
+  runFn = null;
+  constructor(options) {
+    this.options = options;
+  }
+  run(fn) {
+    if (this.runFn) {
+      throw new Error("run() can only be called once per workflow.");
+    }
+    if (typeof fn !== "function") {
+      throw new Error(`run() requires a function, got ${typeof fn}.`);
+    }
+    this.runFn = fn;
+    return this;
+  }
+  compile() {
+    if (!this.runFn) {
+      throw new Error(`Workflow "${this.options.name}" has no run callback. ` + `Add a .run(async (ctx) => { ... }) call before .compile().`);
+    }
+    const runFn = this.runFn;
+    return {
+      __brand: "WorkflowDefinition",
+      name: this.options.name,
+      description: this.options.description ?? "",
+      run: runFn
+    };
+  }
+}
+function defineWorkflow(options) {
+  if (!options.name || options.name.trim() === "") {
+    throw new Error("Workflow name is required.");
+  }
+  return new WorkflowBuilder(options);
+}
+
+// src/sdk/runtime/discovery.ts
+import { join } from "path";
+import { readdir, writeFile } from "fs/promises";
+import { existsSync, readdirSync } from "fs";
+import { homedir } from "os";
+import ignore from "ignore";
+function getLocalWorkflowsDir(projectRoot) {
+  return join(projectRoot, ".atomic", "workflows");
+}
+function getGlobalWorkflowsDir() {
+  return join(homedir(), ".atomic", "workflows");
+}
+var AGENTS = ["copilot", "opencode", "claude"];
+var AGENT_SET = new Set(AGENTS);
+var WORKFLOWS_GITIGNORE = [
+  "node_modules/",
+  "dist/",
+  "build/",
+  "coverage/",
+  ".cache/",
+  "*.log",
+  "*.tsbuildinfo",
+  ""
+].join(`
+`);
+async function loadWorkflowsGitignore(workflowsDir) {
+  const gitignorePath = join(workflowsDir, ".gitignore");
+  let content;
+  try {
+    content = await Bun.file(gitignorePath).text();
+  } catch {
+    await writeFile(gitignorePath, WORKFLOWS_GITIGNORE);
+    content = WORKFLOWS_GITIGNORE;
+  }
+  return ignore().add(content);
+}
+async function discoverFromBaseDir(baseDir, source, agentFilter) {
+  const workflows = [];
+  const agents = agentFilter ? [agentFilter] : AGENTS;
+  const agentNames = new Set(agents);
+  let workflowEntries;
+  try {
+    workflowEntries = await readdir(baseDir, { withFileTypes: true });
+  } catch {
+    return workflows;
+  }
+  const ig = await loadWorkflowsGitignore(baseDir);
+  for (const wfEntry of workflowEntries) {
+    if (!wfEntry.isDirectory())
+      continue;
+    if (wfEntry.name.startsWith("."))
+      continue;
+    if (AGENT_SET.has(wfEntry.name))
+      continue;
+    if (ig.ignores(wfEntry.name + "/"))
+      continue;
+    const workflowDir = join(baseDir, wfEntry.name);
+    let agentEntries;
+    try {
+      agentEntries = await readdir(workflowDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const agentEntry of agentEntries) {
+      if (!agentEntry.isDirectory())
+        continue;
+      if (!agentNames.has(agentEntry.name))
+        continue;
+      const indexPath = join(workflowDir, agentEntry.name, "index.ts");
+      const file = Bun.file(indexPath);
+      if (await file.exists()) {
+        workflows.push({
+          name: wfEntry.name,
+          agent: agentEntry.name,
+          path: indexPath,
+          source
+        });
+      }
+    }
+  }
+  return workflows;
+}
+var BUILTIN_WORKFLOWS_DIR = join(Bun.fileURLToPath(new URL("../workflows/builtin", import.meta.url)));
+function discoverBuiltinWorkflows(agentFilter) {
+  const results = [];
+  const agents = agentFilter ? [agentFilter] : AGENTS;
+  let workflowNames;
+  try {
+    workflowNames = readdirSync(BUILTIN_WORKFLOWS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    return results;
+  }
+  for (const name of workflowNames) {
+    for (const agent of agents) {
+      const indexPath = join(BUILTIN_WORKFLOWS_DIR, name, agent, "index.ts");
+      if (existsSync(indexPath)) {
+        results.push({ name, agent, path: indexPath, source: "builtin" });
+      }
+    }
+  }
+  return results;
+}
+async function discoverWorkflows(projectRoot = process.cwd(), agentFilter) {
+  const localDir = getLocalWorkflowsDir(projectRoot);
+  const globalDir = getGlobalWorkflowsDir();
+  const builtinResults = discoverBuiltinWorkflows(agentFilter);
+  const [globalResults, localResults] = await Promise.all([
+    discoverFromBaseDir(globalDir, "global", agentFilter),
+    discoverFromBaseDir(localDir, "local", agentFilter)
+  ]);
+  const byKey = new Map;
+  for (const wf of builtinResults) {
+    byKey.set(`${wf.agent}/${wf.name}`, wf);
+  }
+  for (const wf of globalResults) {
+    byKey.set(`${wf.agent}/${wf.name}`, wf);
+  }
+  for (const wf of localResults) {
+    byKey.set(`${wf.agent}/${wf.name}`, wf);
+  }
+  return Array.from(byKey.values());
+}
+async function findWorkflow(name, agent, projectRoot = process.cwd()) {
+  const all = await discoverWorkflows(projectRoot, agent);
+  return all.find((w) => w.name === name) ?? null;
+}
+
+// src/sdk/providers/copilot.ts
+function validateCopilotWorkflow(source) {
+  const warnings = [];
+  if (/\bnew\s+CopilotClient\b/.test(source)) {
+    warnings.push({
+      rule: "copilot/manual-client",
+      message: "Manual CopilotClient creation detected. Use s.client instead \u2014 " + "the runtime auto-creates and cleans up the client."
+    });
+  }
+  if (/\bclient\.createSession\b/.test(source)) {
+    warnings.push({
+      rule: "copilot/manual-session",
+      message: "Manual createSession() call detected. Use s.session instead \u2014 " + "the runtime auto-creates the session. Pass session config as the third arg to ctx.stage()."
+    });
+  }
+  return warnings;
+}
+
+// src/sdk/providers/opencode.ts
+function validateOpenCodeWorkflow(source) {
+  const warnings = [];
+  if (/\bcreateOpencodeClient\b/.test(source)) {
+    warnings.push({
+      rule: "opencode/manual-client",
+      message: "Manual createOpencodeClient() call detected. Use s.client instead \u2014 " + "the runtime auto-creates the client. Pass client config as the second arg to ctx.stage()."
+    });
+  }
+  if (/\bclient\.session\.create\b/.test(source)) {
+    warnings.push({
+      rule: "opencode/manual-session",
+      message: "Manual client.session.create() call detected. Use s.session instead \u2014 " + "the runtime auto-creates the session. Pass session config as the third arg to ctx.stage()."
+    });
+  }
+  return warnings;
+}
+
+// src/sdk/runtime/tmux.ts
+var resolvedMuxBinary;
+function getMuxBinary() {
+  if (resolvedMuxBinary !== undefined)
+    return resolvedMuxBinary;
+  if (process.platform === "win32") {
+    for (const candidate of ["psmux", "pmux", "tmux"]) {
+      if (Bun.which(candidate)) {
+        resolvedMuxBinary = candidate;
+        return resolvedMuxBinary;
+      }
+    }
+    resolvedMuxBinary = null;
+    return null;
+  }
+  resolvedMuxBinary = Bun.which("tmux") ? "tmux" : null;
+  return resolvedMuxBinary;
+}
+function resetMuxBinaryCache() {
+  resolvedMuxBinary = undefined;
+}
+function isTmuxInstalled() {
+  return getMuxBinary() !== null;
+}
+function isInsideTmux() {
+  return process.env.TMUX !== undefined || process.env.PSMUX !== undefined;
+}
+function tmuxRun(args) {
+  const binary = getMuxBinary();
+  if (!binary) {
+    return { ok: false, stderr: "No terminal multiplexer (tmux/psmux) found on PATH" };
+  }
+  const result = Bun.spawnSync({
+    cmd: [binary, ...args],
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  if (!result.success) {
+    const stderr = new TextDecoder().decode(result.stderr).trim();
+    return { ok: false, stderr };
+  }
+  return { ok: true, stdout: new TextDecoder().decode(result.stdout).trim() };
+}
+function tmux(args) {
+  const result = tmuxRun(args);
+  if (!result.ok) {
+    throw new Error(`tmux ${args[0]} failed: ${result.stderr}`);
+  }
+  return result.stdout;
+}
+function tmuxExec(args) {
+  const result = tmuxRun(args);
+  if (!result.ok) {
+    throw new Error(`tmux ${args[0]} failed: ${result.stderr}`);
+  }
+}
+function buildEnvArgs(envVars) {
+  if (!envVars)
+    return [];
+  const args = [];
+  for (const [key, value] of Object.entries(envVars)) {
+    args.push("-e", `${key}=${value}`);
+  }
+  return args;
+}
+function createSession(sessionName, initialCommand, windowName, cwd, envVars) {
+  const args = [
+    "new-session",
+    "-d",
+    "-s",
+    sessionName,
+    "-P",
+    "-F",
+    "#{pane_id}",
+    ...buildEnvArgs(envVars)
+  ];
+  if (windowName) {
+    args.push("-n", windowName);
+  }
+  if (cwd) {
+    args.push("-c", cwd);
+  }
+  args.push(initialCommand);
+  const paneId = tmux(args);
+  return paneId || tmux(["list-panes", "-t", sessionName, "-F", "#{pane_id}"]).split(`
+`)[0];
+}
+function createWindow(sessionName, windowName, command, cwd, envVars) {
+  const args = [
+    "new-window",
+    "-d",
+    "-t",
+    sessionName,
+    "-n",
+    windowName,
+    "-P",
+    "-F",
+    "#{pane_id}",
+    ...buildEnvArgs(envVars)
+  ];
+  if (cwd) {
+    args.push("-c", cwd);
+  }
+  args.push(command);
+  return tmux(args);
+}
+function createPane(sessionName, command) {
+  return tmux([
+    "split-window",
+    "-t",
+    sessionName,
+    "-P",
+    "-F",
+    "#{pane_id}",
+    command
+  ]);
+}
+function sendLiteralText(paneId, text) {
+  const normalized = text.replace(/[\r\n]+/g, " ");
+  tmuxExec(["send-keys", "-t", paneId, "-l", "--", normalized]);
+}
+function sendSpecialKey(paneId, key) {
+  tmuxExec(["send-keys", "-t", paneId, key]);
+}
+function sendKeysAndSubmit(paneId, text, presses = 1, delayMs = 100) {
+  sendLiteralText(paneId, text);
+  for (let i = 0;i < presses; i++) {
+    if (i > 0 && delayMs > 0) {
+      Bun.sleepSync(delayMs);
+    }
+    sendSpecialKey(paneId, "C-m");
+  }
+}
+function capturePane(paneId, start) {
+  const args = ["capture-pane", "-t", paneId, "-p"];
+  if (start !== undefined) {
+    args.push("-S", String(start));
+  }
+  return tmux(args);
+}
+function capturePaneVisible(paneId) {
+  const result = tmuxRun(["capture-pane", "-t", paneId, "-p"]);
+  if (!result.ok)
+    return "";
+  return result.stdout;
+}
+function capturePaneScrollback(paneId, lines = 200) {
+  const result = tmuxRun(["capture-pane", "-t", paneId, "-p", "-S", `-${lines}`]);
+  if (!result.ok)
+    return "";
+  return result.stdout;
+}
+function killSession(sessionName) {
+  try {
+    tmuxExec(["kill-session", "-t", sessionName]);
+  } catch {}
+}
+function killWindow(sessionName, windowName) {
+  try {
+    tmuxExec(["kill-window", "-t", `${sessionName}:${windowName}`]);
+  } catch {}
+}
+function sessionExists(sessionName) {
+  const binary = getMuxBinary();
+  if (!binary)
+    return false;
+  const result = Bun.spawnSync({
+    cmd: [binary, "has-session", "-t", sessionName],
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  return result.success;
+}
+function attachSession(sessionName) {
+  const binary = getMuxBinary();
+  if (!binary) {
+    throw new Error("No terminal multiplexer (tmux/psmux) found on PATH");
+  }
+  const proc = Bun.spawnSync({
+    cmd: [binary, "attach-session", "-t", sessionName],
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "pipe"
+  });
+  if (!proc.success) {
+    const stderr = new TextDecoder().decode(proc.stderr).trim();
+    throw new Error(`Failed to attach to session: ${sessionName}${stderr ? ` (${stderr})` : ""}`);
+  }
+}
+function switchClient(sessionName) {
+  tmuxExec(["switch-client", "-t", sessionName]);
+}
+function getCurrentSession() {
+  if (!isInsideTmux())
+    return null;
+  const result = tmuxRun(["display-message", "-p", "#{session_name}"]);
+  if (!result.ok)
+    return null;
+  return result.stdout || null;
+}
+function attachOrSwitch(sessionName) {
+  if (isInsideTmux()) {
+    switchClient(sessionName);
+  } else {
+    attachSession(sessionName);
+  }
+}
+function selectWindow(target) {
+  tmuxExec(["select-window", "-t", target]);
+}
+function normalizeTmuxCapture(text) {
+  return text.replace(/\r/g, "").replace(/\s+/g, " ").trim();
+}
+function normalizeTmuxLines(text) {
+  return text.split(`
+`).map((l) => l.trimEnd()).join(`
+`).trim();
+}
+function toPaneLines(captured) {
+  return captured.split(`
+`).map((l) => l.replace(/\r/g, "").trimEnd()).filter((l) => l.trim() !== "");
+}
+function paneIsBootstrapping(lines) {
+  return lines.some((line) => /\b(loading|initializing|starting up)\b/i.test(line) || /\bmodel:\s*loading\b/i.test(line) || /\bconnecting\s+to\b/i.test(line));
+}
+function paneLooksReady(captured) {
+  const content = captured.trimEnd();
+  if (content === "")
+    return false;
+  const lines = toPaneLines(content);
+  if (paneIsBootstrapping(lines))
+    return false;
+  if (lines.some((line) => /^\s*[\u203A>\u276F]\s*/u.test(line)))
+    return true;
+  if (lines.some((line) => /\bhow can i help(?: you)?\b/i.test(line)))
+    return true;
+  return false;
+}
+function paneHasActiveTask(captured) {
+  const tail = toPaneLines(captured).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) => /^[\u00B7\u273B]\s+[A-Za-z][A-Za-z0-9''-]*(?:\s+[A-Za-z][A-Za-z0-9''-]*){0,3}(?:\u2026|\.{3})$/u.test(l));
+}
+function paneIsIdle(paneId) {
+  const visible = capturePaneVisible(paneId);
+  return paneLooksReady(visible) && !paneHasActiveTask(visible);
+}
+async function waitForPaneReady(paneId, timeoutMs = 30000) {
+  const startedAt = Date.now();
+  let delayMs = 150;
+  const maxDelayMs = 8000;
+  while (Date.now() - startedAt < timeoutMs) {
+    if (paneIsIdle(paneId))
+      return Date.now() - startedAt;
+    const remaining = timeoutMs - (Date.now() - startedAt);
+    if (remaining <= 0)
+      break;
+    await Bun.sleep(Math.min(delayMs, remaining));
+    delayMs = Math.min(maxDelayMs, delayMs * 2);
+  }
+  return Date.now() - startedAt;
+}
+async function attemptSubmitRounds(paneId, normalizedPrompt, rounds, pressesPerRound = 1) {
+  const presses = Math.max(1, Math.floor(pressesPerRound));
+  for (let round = 0;round < rounds; round++) {
+    await Bun.sleep(100);
+    for (let press = 0;press < presses; press++) {
+      sendSpecialKey(paneId, "C-m");
+      if (press < presses - 1)
+        await Bun.sleep(200);
+    }
+    await Bun.sleep(140);
+    const visible = capturePaneVisible(paneId);
+    if (!normalizeTmuxCapture(visible).includes(normalizedPrompt))
+      return true;
+    if (paneHasActiveTask(visible))
+      return true;
+    await Bun.sleep(140);
+  }
+  return false;
+}
+async function waitForOutput(paneId, pattern, options = {}) {
+  const { timeoutMs = 30000, pollIntervalMs = 500 } = options;
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const content = capturePane(paneId);
+    if (pattern.test(content)) {
+      return content;
+    }
+    await Bun.sleep(pollIntervalMs);
+  }
+  throw new Error(`Timed out waiting for pattern ${pattern} in pane ${paneId}`);
+}
+
+// src/sdk/providers/claude.ts
+var initializedPanes = new Set;
+function clearClaudeSession(paneId) {
+  initializedPanes.delete(paneId);
+}
+var DEFAULT_CHAT_FLAGS = [
+  "--allow-dangerously-skip-permissions",
+  "--dangerously-skip-permissions"
+];
+async function createClaudeSession(options) {
+  const {
+    paneId,
+    chatFlags = DEFAULT_CHAT_FLAGS,
+    readyTimeoutMs = 30000
+  } = options;
+  const cmd = ["claude", ...chatFlags].join(" ");
+  sendKeysAndSubmit(paneId, cmd);
+  await Bun.sleep(1000);
+  await waitForPaneReady(paneId, readyTimeoutMs);
+  const visible = capturePaneVisible(paneId);
+  if (!paneLooksReady(visible) && !paneHasActiveTask(visible)) {
+    throw new Error("createClaudeSession() timed out waiting for the Claude TUI to start. " + "Verify the `claude` command is installed and the flags are valid.");
+  }
+  initializedPanes.add(paneId);
+}
+async function claudeQuery(options) {
+  const {
+    paneId,
+    prompt,
+    timeoutMs = 300000,
+    pollIntervalMs = 2000,
+    submitPresses = 1,
+    maxSubmitRounds = 6,
+    readyTimeoutMs = 30000
+  } = options;
+  if (!initializedPanes.has(paneId)) {
+    throw new Error("claudeQuery() called without a prior createClaudeSession() for this pane. " + "Call createClaudeSession({ paneId }) first to start the Claude CLI.");
+  }
+  const normalizedPrompt = normalizeTmuxCapture(prompt).slice(0, 100);
+  const waitElapsed = await waitForPaneReady(paneId, readyTimeoutMs);
+  const responseTimeoutMs = Math.max(0, timeoutMs - waitElapsed);
+  if (waitElapsed > timeoutMs * 0.5) {
+    console.warn(`claudeQuery: readiness wait consumed ${Math.round(waitElapsed / 1000)}s ` + `of ${Math.round(timeoutMs / 1000)}s total timeout budget`);
+  }
+  const beforeContent = normalizeTmuxLines(capturePaneScrollback(paneId));
+  sendLiteralText(paneId, prompt);
+  await Bun.sleep(150);
+  let delivered = await attemptSubmitRounds(paneId, normalizedPrompt, maxSubmitRounds, submitPresses);
+  if (!delivered) {
+    const visibleCapture = capturePaneVisible(paneId);
+    const visibleNorm = normalizeTmuxCapture(visibleCapture);
+    if (visibleNorm.includes(normalizedPrompt) && !paneHasActiveTask(visibleCapture) && paneLooksReady(visibleCapture)) {
+      sendSpecialKey(paneId, "C-u");
+      await Bun.sleep(80);
+      sendLiteralText(paneId, prompt);
+      await Bun.sleep(120);
+      delivered = await attemptSubmitRounds(paneId, normalizedPrompt, 4, submitPresses);
+    }
+  }
+  if (!delivered) {
+    sendSpecialKey(paneId, "C-m");
+    await Bun.sleep(120);
+    sendSpecialKey(paneId, "C-m");
+    await Bun.sleep(300);
+    const verifyCapture = capturePaneVisible(paneId);
+    if (paneHasActiveTask(verifyCapture)) {
+      delivered = true;
+    } else {
+      delivered = !normalizeTmuxCapture(verifyCapture).includes(normalizedPrompt);
+    }
+    if (!delivered) {
+      sendSpecialKey(paneId, "C-m");
+      await Bun.sleep(150);
+      sendSpecialKey(paneId, "C-m");
+    }
+  }
+  const deadline = Date.now() + responseTimeoutMs;
+  let lastContent = "";
+  let stableCount = 0;
+  await Bun.sleep(3000);
+  while (Date.now() < deadline) {
+    const currentContent = normalizeTmuxLines(capturePaneScrollback(paneId));
+    if (currentContent === beforeContent) {
+      await Bun.sleep(pollIntervalMs);
+      continue;
+    }
+    const visible = capturePaneVisible(paneId);
+    if (paneLooksReady(visible) && !paneHasActiveTask(visible)) {
+      return { output: currentContent, delivered };
+    }
+    if (currentContent === lastContent) {
+      stableCount++;
+      if (stableCount >= 3) {
+        return { output: currentContent, delivered };
+      }
+    } else {
+      stableCount = 0;
+    }
+    lastContent = currentContent;
+    await Bun.sleep(pollIntervalMs);
+  }
+  return { output: lastContent || capturePaneScrollback(paneId), delivered };
+}
+function validateClaudeWorkflow(source) {
+  const warnings = [];
+  if (/\bcreateClaudeSession\b/.test(source)) {
+    warnings.push({
+      rule: "claude/manual-session",
+      message: "Manual createClaudeSession() call detected. The runtime auto-starts the Claude CLI \u2014 " + "use s.session.query() instead of claudeQuery(). Pass chatFlags via the second arg to ctx.stage()."
+    });
+  }
+  if (/\bclaudeQuery\b/.test(source)) {
+    warnings.push({
+      rule: "claude/manual-query",
+      message: "Direct claudeQuery() call detected. Use s.session.query(prompt) instead \u2014 " + "it wraps claudeQuery with the correct paneId."
+    });
+  }
+  return warnings;
+}
+
+// src/sdk/runtime/loader.ts
+var WorkflowLoader;
+((WorkflowLoader) => {
+  async function resolve(plan) {
+    try {
+      const file = Bun.file(plan.path);
+      if (!await file.exists()) {
+        return {
+          ok: false,
+          stage: "resolve",
+          error: new Error(`Workflow file not found: ${plan.path}`),
+          message: `Workflow file not found: ${plan.path}`
+        };
+      }
+      return { ok: true, value: plan };
+    } catch (error) {
+      return {
+        ok: false,
+        stage: "resolve",
+        error,
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  WorkflowLoader.resolve = resolve;
+  function validateSource(source, agent) {
+    switch (agent) {
+      case "copilot":
+        return validateCopilotWorkflow(source);
+      case "opencode":
+        return validateOpenCodeWorkflow(source);
+      case "claude":
+        return validateClaudeWorkflow(source);
+      default:
+        return [];
+    }
+  }
+  async function validate(resolved) {
+    try {
+      const source = await Bun.file(resolved.path).text();
+      const warnings = validateSource(source, resolved.agent);
+      return {
+        ok: true,
+        value: { ...resolved, warnings }
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        stage: "validate",
+        error,
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  WorkflowLoader.validate = validate;
+  async function load(validated) {
+    try {
+      const mod = await import(validated.path);
+      const definition = mod.default ?? mod;
+      if (!definition || definition.__brand !== "WorkflowDefinition") {
+        if (definition && definition.__brand === "WorkflowBuilder") {
+          return {
+            ok: false,
+            stage: "load",
+            error: new Error("Workflow not compiled"),
+            message: `Workflow at ${validated.path} was defined but not compiled.
+  Add .compile() at the end of your defineWorkflow() chain:
+
+    export default defineWorkflow({ ... })
+      .run(async (ctx) => { ... })
+      .compile();`
+          };
+        }
+        return {
+          ok: false,
+          stage: "load",
+          error: new Error("Invalid workflow export"),
+          message: `${validated.path} does not export a valid WorkflowDefinition.
+  Make sure it exports defineWorkflow(...).run(...).compile() as the default export.`
+        };
+      }
+      return {
+        ok: true,
+        value: { ...validated, definition }
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        stage: "load",
+        error,
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  WorkflowLoader.load = load;
+  async function loadWorkflow(plan, report) {
+    report?.start?.("resolve");
+    const resolved = await resolve(plan);
+    if (!resolved.ok) {
+      report?.error?.("resolve", resolved.error, resolved.message);
+      return resolved;
+    }
+    report?.start?.("validate");
+    const validated = await validate(resolved.value);
+    if (!validated.ok) {
+      report?.error?.("validate", validated.error, validated.message);
+      return validated;
+    }
+    if (validated.value.warnings.length > 0) {
+      report?.warn?.(validated.value.warnings);
+    }
+    report?.start?.("load");
+    const loaded = await load(validated.value);
+    if (!loaded.ok) {
+      report?.error?.("load", loaded.error, loaded.message);
+      return loaded;
+    }
+    return loaded;
+  }
+  WorkflowLoader.loadWorkflow = loadWorkflow;
+})(WorkflowLoader ||= {});
+
+// src/sdk/runtime/executor.ts
+import { join as join2, resolve } from "path";
+import { homedir as homedir2 } from "os";
+import { mkdir, writeFile as writeFile2, readFile } from "fs/promises";
+
+// src/sdk/components/orchestrator-panel.tsx
+import { createCliRenderer } from "@opentui/core";
+import { createRoot } from "@opentui/react";
+
+// src/sdk/components/orchestrator-panel-store.ts
+class PanelStore {
+  version = 0;
+  workflowName = "";
+  agent = "";
+  prompt = "";
+  sessions = [];
+  completionInfo = null;
+  fatalError = null;
+  completionReached = false;
+  exitResolve = null;
+  abortResolve = null;
+  listeners = new Set;
+  subscribe = (fn) => {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  };
+  emit() {
+    this.version++;
+    for (const fn of this.listeners)
+      fn();
+  }
+  setWorkflowInfo(name, agent, sessions, prompt) {
+    this.workflowName = name;
+    this.agent = agent;
+    this.prompt = prompt;
+    this.sessions = [
+      {
+        name: "orchestrator",
+        status: "running",
+        parents: [],
+        startedAt: Date.now(),
+        endedAt: null
+      },
+      ...sessions.map((s) => ({
+        name: s.name,
+        status: "pending",
+        parents: s.parents.length > 0 ? s.parents : ["orchestrator"],
+        startedAt: null,
+        endedAt: null
+      }))
+    ];
+    this.emit();
+  }
+  startSession(name) {
+    const session = this.sessions.find((s) => s.name === name);
+    if (!session)
+      return;
+    session.status = "running";
+    session.startedAt = Date.now();
+    this.emit();
+  }
+  completeSession(name) {
+    const session = this.sessions.find((s) => s.name === name);
+    if (!session)
+      return;
+    session.status = "complete";
+    session.endedAt = Date.now();
+    this.emit();
+  }
+  failSession(name, error) {
+    const session = this.sessions.find((s) => s.name === name);
+    if (!session)
+      return;
+    session.status = "error";
+    session.error = error;
+    session.endedAt = Date.now();
+    this.emit();
+  }
+  addSession(session) {
+    this.sessions.push(session);
+    this.emit();
+  }
+  setCompletion(workflowName, transcriptsPath) {
+    this.completionInfo = { workflowName, transcriptsPath };
+    const orch = this.sessions.find((s) => s.name === "orchestrator");
+    if (orch) {
+      orch.status = "complete";
+      orch.endedAt = Date.now();
+    }
+    this.emit();
+  }
+  setFatalError(message) {
+    this.fatalError = message;
+    this.completionReached = true;
+    const orch = this.sessions.find((s) => s.name === "orchestrator");
+    if (orch) {
+      orch.status = "error";
+      orch.endedAt = Date.now();
+    }
+    this.emit();
+  }
+  resolveExit() {
+    if (this.exitResolve) {
+      const resolve = this.exitResolve;
+      this.exitResolve = null;
+      resolve();
+    }
+  }
+  resolveAbort() {
+    if (this.abortResolve) {
+      const resolve = this.abortResolve;
+      this.abortResolve = null;
+      resolve();
+    }
+  }
+  requestQuit() {
+    if (this.completionReached) {
+      this.resolveExit();
+    } else {
+      this.resolveAbort();
+    }
+  }
+  markCompletionReached() {
+    this.completionReached = true;
+    this.emit();
+  }
+}
+
+// src/sdk/components/orchestrator-panel-contexts.ts
+import { createContext, useContext, useSyncExternalStore } from "react";
+var StoreContext = createContext(null);
+var ThemeContext = createContext(null);
+var TmuxSessionContext = createContext("");
+
+// src/sdk/components/session-graph-panel.tsx
+import {
+  useKeyboard,
+  useTerminalDimensions,
+  useRenderer
+} from "@opentui/react";
+import {
+  useState,
+  useEffect,
+  useMemo,
+  useCallback,
+  useRef,
+  useContext as useContext2
+} from "react";
+
+// src/sdk/components/node-card.tsx
+import { jsxDEV } from "@opentui/react/jsx-dev-runtime";
+
+// src/sdk/components/edge.tsx
+import { jsxDEV as jsxDEV2 } from "@opentui/react/jsx-dev-runtime";
+
+// src/sdk/components/header.tsx
+import { jsxDEV as jsxDEV3 } from "@opentui/react/jsx-dev-runtime";
+
+// src/sdk/components/statusline.tsx
+import { jsxDEV as jsxDEV4 } from "@opentui/react/jsx-dev-runtime";
+
+// src/sdk/components/session-graph-panel.tsx
+import { jsxDEV as jsxDEV5 } from "@opentui/react/jsx-dev-runtime";
+
+// src/sdk/components/error-boundary.tsx
+import { Component } from "react";
+
+// src/sdk/components/orchestrator-panel.tsx
+import { jsxDEV as jsxDEV6 } from "@opentui/react/jsx-dev-runtime";
+// src/sdk/runtime/executor.ts
+function generateId() {
+  return crypto.randomUUID().slice(0, 8);
+}
+function getSessionsBaseDir() {
+  return join2(homedir2(), ".atomic", "sessions");
+}
+async function ensureDir(dir) {
+  await mkdir(dir, { recursive: true });
+}
+function escBash(s) {
+  return s.replace(/\x00/g, "").replace(/[\n\r]+/g, " ").replace(/[\\"$`!]/g, "\\$&");
+}
+function escPwsh(s) {
+  return s.replace(/\x00/g, "").replace(/[`"$]/g, "`$&").replace(/\n/g, "`n").replace(/\r/g, "`r");
+}
+async function executeWorkflow(options) {
+  const {
+    definition,
+    agent,
+    prompt,
+    workflowFile,
+    projectRoot = process.cwd()
+  } = options;
+  const workflowRunId = generateId();
+  const tmuxSessionName = `atomic-wf-${definition.name}-${workflowRunId}`;
+  const sessionsBaseDir = join2(getSessionsBaseDir(), workflowRunId);
+  await ensureDir(sessionsBaseDir);
+  const thisFile = resolve(import.meta.dir, "executor-entry.ts");
+  const isWin = process.platform === "win32";
+  const launcherExt = isWin ? "ps1" : "sh";
+  const launcherPath = join2(sessionsBaseDir, `orchestrator.${launcherExt}`);
+  const logPath = join2(sessionsBaseDir, "orchestrator.log");
+  const launcherScript = isWin ? [
+    `Set-Location "${escPwsh(projectRoot)}"`,
+    `$env:ATOMIC_WF_ID = "${escPwsh(workflowRunId)}"`,
+    `$env:ATOMIC_WF_TMUX = "${escPwsh(tmuxSessionName)}"`,
+    `$env:ATOMIC_WF_AGENT = "${escPwsh(agent)}"`,
+    `$env:ATOMIC_WF_PROMPT = "${escPwsh(Buffer.from(prompt).toString("base64"))}"`,
+    `$env:ATOMIC_WF_FILE = "${escPwsh(workflowFile)}"`,
+    `$env:ATOMIC_WF_CWD = "${escPwsh(projectRoot)}"`,
+    `bun run "${escPwsh(thisFile)}" 2>"${escPwsh(logPath)}"`
+  ].join(`
+`) : [
+    "#!/bin/bash",
+    `cd "${escBash(projectRoot)}"`,
+    `export ATOMIC_WF_ID="${escBash(workflowRunId)}"`,
+    `export ATOMIC_WF_TMUX="${escBash(tmuxSessionName)}"`,
+    `export ATOMIC_WF_AGENT="${escBash(agent)}"`,
+    `export ATOMIC_WF_PROMPT="${escBash(Buffer.from(prompt).toString("base64"))}"`,
+    `export ATOMIC_WF_FILE="${escBash(workflowFile)}"`,
+    `export ATOMIC_WF_CWD="${escBash(projectRoot)}"`,
+    `bun run "${escBash(thisFile)}" 2>"${escBash(logPath)}"`
+  ].join(`
+`);
+  await writeFile2(launcherPath, launcherScript, { mode: 493 });
+  const shellCmd = isWin ? `pwsh -NoProfile -File "${escPwsh(launcherPath)}"` : `bash "${escBash(launcherPath)}"`;
+  createSession(tmuxSessionName, shellCmd, "orchestrator");
+  if (isInsideTmux()) {
+    switchClient(tmuxSessionName);
+  } else {
+    const muxBinary = getMuxBinary() ?? "tmux";
+    const attachProc = Bun.spawn([muxBinary, "attach-session", "-t", tmuxSessionName], {
+      stdio: ["inherit", "inherit", "inherit"]
+    });
+    await attachProc.exited;
+  }
+}
+
+export { WorkflowBuilder, defineWorkflow, AGENTS, WORKFLOWS_GITIGNORE, discoverWorkflows, findWorkflow, validateCopilotWorkflow, validateOpenCodeWorkflow, getMuxBinary, resetMuxBinaryCache, isTmuxInstalled, isInsideTmux, tmuxRun, createSession, createWindow, createPane, sendLiteralText, sendSpecialKey, sendKeysAndSubmit, capturePane, capturePaneVisible, capturePaneScrollback, killSession, killWindow, sessionExists, attachSession, switchClient, getCurrentSession, attachOrSwitch, selectWindow, normalizeTmuxCapture, normalizeTmuxLines, paneLooksReady, paneHasActiveTask, paneIsIdle, waitForPaneReady, attemptSubmitRounds, waitForOutput, clearClaudeSession, createClaudeSession, claudeQuery, validateClaudeWorkflow, WorkflowLoader, executeWorkflow };