@bastani/atomic 0.5.4 → 0.5.5-0

package/dist/chunk-xkxndz5g.js

@@ -1,1041 +0,0 @@
-// @bun
-// src/sdk/define-workflow.ts
-function validateWorkflowInput(input, workflowName) {
-  if (!input.name || input.name.trim() === "") {
-    throw new Error(`Workflow "${workflowName}" has an input with an empty name.`);
-  }
-  if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(input.name)) {
-    throw new Error(`Workflow "${workflowName}" input "${input.name}" has an invalid ` + `name \u2014 must start with a letter and contain only letters, ` + `digits, underscores, and dashes (so it can be used as a ` + `\`--${input.name}\` CLI flag).`);
-  }
-  if (input.type === "enum") {
-    if (!Array.isArray(input.values) || input.values.length === 0) {
-      throw new Error(`Workflow "${workflowName}" input "${input.name}" is an enum but ` + `declares no \`values\`.`);
-    }
-    if (input.default !== undefined && !input.values.includes(input.default)) {
-      throw new Error(`Workflow "${workflowName}" input "${input.name}" has a default ` + `"${input.default}" that is not one of its declared values: ` + `${input.values.join(", ")}.`);
-    }
-  }
-}
-
-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;
-    const declaredInputs = this.options.inputs ?? [];
-    const seen = new Set;
-    for (const input of declaredInputs) {
-      validateWorkflowInput(input, this.options.name);
-      if (seen.has(input.name)) {
-        throw new Error(`Workflow "${this.options.name}" has duplicate input name "${input.name}".`);
-      }
-      seen.add(input.name);
-    }
-    const inputs = Object.freeze(declaredInputs.map((i) => Object.freeze({ ...i })));
-    return {
-      __brand: "WorkflowDefinition",
-      name: this.options.name,
-      description: this.options.description ?? "",
-      inputs,
-      run: runFn
-    };
-  }
-}
-function defineWorkflow(options) {
-  if (!options.name || options.name.trim() === "") {
-    throw new Error("Workflow name is required.");
-  }
-  return new WorkflowBuilder(options);
-}
-
-// 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
-import { join } from "path";
-var SOCKET_NAME = "atomic";
-var CONFIG_PATH = join(import.meta.dir, "tmux.conf");
-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 fullArgs = ["-f", CONFIG_PATH, "-L", SOCKET_NAME, ...args];
-  const result = Bun.spawnSync({
-    cmd: [binary, ...fullArgs],
-    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 result = tmuxRun(["has-session", "-t", sessionName]);
-  return result.ok;
-}
-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, "-f", CONFIG_PATH, "-L", SOCKET_NAME, "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 spawnMuxAttach(sessionName) {
-  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"] });
-}
-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/discovery.ts
-import { join as join2 } 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 join2(projectRoot, ".atomic", "workflows");
-}
-function getGlobalWorkflowsDir() {
-  return join2(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 = join2(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 = join2(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 = join2(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 = join2(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 = join2(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, options = {}) {
-  const { merge = true } = options;
-  const localDir = getLocalWorkflowsDir(projectRoot);
-  const globalDir = getGlobalWorkflowsDir();
-  const allBuiltins = discoverBuiltinWorkflows();
-  const reservedNames = new Set(allBuiltins.map((w) => w.name));
-  const builtinResults = agentFilter ? allBuiltins.filter((w) => w.agent === agentFilter) : allBuiltins;
-  const [globalResults, localResults] = await Promise.all([
-    discoverFromBaseDir(globalDir, "global", agentFilter),
-    discoverFromBaseDir(localDir, "local", agentFilter)
-  ]);
-  const filteredGlobal = globalResults.filter((w) => !reservedNames.has(w.name));
-  const filteredLocal = localResults.filter((w) => !reservedNames.has(w.name));
-  if (!merge) {
-    return [...filteredGlobal, ...filteredLocal, ...builtinResults];
-  }
-  const byKey = new Map;
-  for (const wf of filteredGlobal) {
-    byKey.set(`${wf.agent}/${wf.name}`, wf);
-  }
-  for (const wf of filteredLocal) {
-    byKey.set(`${wf.agent}/${wf.name}`, wf);
-  }
-  for (const wf of builtinResults) {
-    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;
-}
-async function loadWorkflowsMetadata(discovered) {
-  const results = await Promise.all(discovered.map(async (wf) => {
-    const loaded = await WorkflowLoader.loadWorkflow(wf);
-    if (!loaded.ok)
-      return null;
-    return {
-      ...wf,
-      description: loaded.value.definition.description,
-      inputs: loaded.value.definition.inputs
-    };
-  }));
-  return results.filter((r) => r !== null);
-}
-
-// src/sdk/runtime/executor.ts
-import { join as join3, 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 join3(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,
-    inputs = {},
-    workflowFile,
-    projectRoot = process.cwd()
-  } = options;
-  const workflowRunId = generateId();
-  const tmuxSessionName = `atomic-wf-${definition.name}-${workflowRunId}`;
-  const sessionsBaseDir = join3(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 = join3(sessionsBaseDir, `orchestrator.${launcherExt}`);
-  const logPath = join3(sessionsBaseDir, "orchestrator.log");
-  const inputsB64 = Buffer.from(JSON.stringify(inputs)).toString("base64");
-  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_INPUTS = "${escPwsh(inputsB64)}"`,
-    `$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_INPUTS="${escBash(inputsB64)}"`,
-    `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 });
-  console.log(`[atomic] Session: ${tmuxSessionName} (FYI all atomic sessions run on tmux -L ${SOCKET_NAME})`);
-  if (isInsideTmux()) {
-    const defaultShell = process.env.SHELL || (isWin ? "pwsh" : "sh");
-    createSession(tmuxSessionName, defaultShell, "orchestrator");
-    const launcherCmd = isWin ? ["pwsh", "-NoProfile", "-File", launcherPath] : ["bash", launcherPath];
-    const proc = Bun.spawn(launcherCmd, {
-      stdio: ["inherit", "inherit", "inherit"],
-      cwd: projectRoot
-    });
-    await proc.exited;
-  } else {
-    const shellCmd = isWin ? `pwsh -NoProfile -File "${escPwsh(launcherPath)}"` : `bash "${escBash(launcherPath)}"`;
-    createSession(tmuxSessionName, shellCmd, "orchestrator");
-    const attachProc = spawnMuxAttach(tmuxSessionName);
-    await attachProc.exited;
-  }
-}
-
-export { WorkflowBuilder, defineWorkflow, validateCopilotWorkflow, validateOpenCodeWorkflow, SOCKET_NAME, getMuxBinary, resetMuxBinaryCache, isTmuxInstalled, isInsideTmux, tmuxRun, createSession, createWindow, createPane, sendLiteralText, sendSpecialKey, sendKeysAndSubmit, capturePane, capturePaneVisible, capturePaneScrollback, killSession, killWindow, sessionExists, attachSession, spawnMuxAttach, switchClient, getCurrentSession, attachOrSwitch, selectWindow, normalizeTmuxCapture, normalizeTmuxLines, paneLooksReady, paneHasActiveTask, paneIsIdle, waitForPaneReady, attemptSubmitRounds, waitForOutput, clearClaudeSession, createClaudeSession, claudeQuery, validateClaudeWorkflow, WorkflowLoader, AGENTS, WORKFLOWS_GITIGNORE, discoverWorkflows, findWorkflow, loadWorkflowsMetadata, executeWorkflow };