@drisp/cli 0.3.39

package/dist/chunk-LPG5WBPV.js

@@ -0,0 +1,2621 @@
+// src/ui/theme/themes.ts
+var darkTheme = {
+  name: "dark",
+  // ── Text hierarchy ──────────────────────────────────────
+  text: "#c9d1d9",
+  // Primary text. Warm gray, not pure white.
+  textMuted: "#848d97",
+  // Dim text. Bumped from #6e7681 for AA compliance (~4.8:1).
+  textInverse: "#0d1117",
+  // Text on colored backgrounds.
+  // ── Accent ──────────────────────────────────────────────
+  border: "#2d333b",
+  // Bumped from #1e2a38 for visibility (~2.2:1 vs bg).
+  accent: "#58a6ff",
+  // Blue. Focus bar, branding, selection, links.
+  accentSecondary: "#bc8cff",
+  // Soft purple. Permission events.
+  // ── Status ──────────────────────────────────────────────
+  status: {
+    success: "#3fb950",
+    // Green. Completion, done glyphs.
+    error: "#f85149",
+    // Red. Failures, blocks, Tool Fail.
+    warning: "#d29922",
+    // Amber. Active stage, zero-result tint, caution.
+    info: "#58a6ff",
+    // Blue. Agent messages, Run OK.
+    working: "#d29922",
+    // Amber. Spinner state (same as warning).
+    neutral: "#9da5ae"
+    // Mid gray. Bumped from #8b949e for AA (~4.8:1).
+  },
+  // ── Context bar ─────────────────────────────────────────
+  contextBar: {
+    track: "#1e2a38",
+    // Empty segment track.
+    low: "#3fb950",
+    // Green.  0–50% budget used.
+    medium: "#d29922",
+    // Amber. 50–80% budget used.
+    high: "#f85149"
+    // Red.   80–100% budget used.
+  },
+  // ── Dialog borders ──────────────────────────────────────
+  dialog: {
+    borderPermission: "#d29922",
+    // Amber border for permission prompts.
+    borderQuestion: "#58a6ff"
+    // Blue border for question prompts.
+  },
+  // ── Input ───────────────────────────────────────────────
+  inputPrompt: "#388bfd",
+  // Blue "input" keyword in prompt.
+  inputChevron: "#484f58",
+  // Bumped from #30363d for visibility (~2.8:1).
+  inputBackground: "#141a21",
+  // Slight lift so the input row reads as its own surface.
+  // ── Feed ────────────────────────────────────────────────
+  feed: {
+    headerLabel: "#848d97",
+    // Matches textMuted.
+    stripeBackground: "#161b22",
+    // Bumped from #0d1521 for visible alternation.
+    focusBackground: "#1b2a3f"
+    // Blue tint for focused row.
+  },
+  // ── User messages ───────────────────────────────────────
+  userMessage: {
+    text: "#6e7681",
+    // Dimmed text for user messages in the message panel.
+    background: "#151d2b",
+    // Blue-tinted lift — differentiates user turns from agent.
+    border: "#30363d",
+    // Subtle border.
+    agentBorder: "#2a4a6a",
+    // Steel blue left border for agent messages.
+    focusBorder: "#58a6ff"
+    // Accent blue for focused message indicator.
+  },
+  // ── Badges ──────────────────────────────────────────────
+  badge: {
+    error: { bg: "#4b1014", fg: "#ff7b72" },
+    running: { bg: "#4a3a0c", fg: "#fbbf24" },
+    idle: { bg: "#10321d", fg: "#3fb950" },
+    search: { bg: "#1b2a3f" },
+    command: { bg: "#2a1b3f" }
+  },
+  // ── Detail view ─────────────────────────────────────────
+  detail: {
+    title: "#c9d1d9",
+    subject: "#58a6ff"
+  },
+  // ── Tool pills ──────────────────────────────────────────
+  toolPill: {
+    safe: { bg: "#0e2233", fg: "#5ba3cc" },
+    mutating: { bg: "#2a1d0a", fg: "#d4a44a" },
+    browser: { bg: "#0b2625", fg: "#5cc4ba" },
+    neutral: { bg: "#141a22", fg: "#7d8590" },
+    skill: { bg: "#2a0f24", fg: "#c98ab8" },
+    "subagent.spawn": { bg: "#0a2e22", fg: "#5cc4a0" },
+    "subagent.return": { bg: "#0a2e22", fg: "#56b492" }
+  }
+};
+var lightTheme = {
+  name: "light",
+  // ── Text hierarchy ──────────────────────────────────────
+  text: "#1f2328",
+  // Near-black. Strong contrast.
+  textMuted: "#656d76",
+  // Medium gray. Same role as dark textMuted.
+  textInverse: "#ffffff",
+  // White on colored backgrounds.
+  // ── Accent ──────────────────────────────────────────────
+  border: "#8c959f",
+  // Darker neutral border so frame lines stay visible on white.
+  accent: "#0969da",
+  // Darker blue for light backgrounds.
+  accentSecondary: "#8250df",
+  // Purple, darkened for readability.
+  // ── Status ──────────────────────────────────────────────
+  status: {
+    success: "#1a7f37",
+    // Dark green. Readable on white.
+    error: "#cf222e",
+    // Dark red.
+    warning: "#9a6700",
+    // Dark amber.
+    info: "#0969da",
+    // Dark blue. Matches accent.
+    working: "#9a6700",
+    // Dark amber.
+    neutral: "#656d76"
+    // Mid gray.
+  },
+  // ── Context bar ─────────────────────────────────────────
+  contextBar: {
+    track: "#d0d7de",
+    // Light gray track.
+    low: "#1a7f37",
+    medium: "#9a6700",
+    high: "#cf222e"
+  },
+  // ── Dialog borders ──────────────────────────────────────
+  dialog: {
+    borderPermission: "#9a6700",
+    borderQuestion: "#0969da"
+  },
+  // ── Input ───────────────────────────────────────────────
+  inputPrompt: "#0969da",
+  inputChevron: "#656d76",
+  inputBackground: "#f3f6f9",
+  // ── Feed ────────────────────────────────────────────────
+  feed: {
+    headerLabel: "#656d76",
+    stripeBackground: "#f6f8fa",
+    focusBackground: "#ddf4ff"
+    // Light blue tint for focused row.
+  },
+  // ── User messages ───────────────────────────────────────
+  userMessage: {
+    text: "#8b949e",
+    // Dimmed text for user messages in the message panel.
+    background: "#edf2fb",
+    // Blue-tinted lift — differentiates user turns from agent.
+    border: "#8c959f",
+    agentBorder: "#6cb0e0",
+    // Medium blue on white bg.
+    focusBorder: "#0969da"
+    // Accent blue for focused message indicator.
+  },
+  // ── Badges ──────────────────────────────────────────────
+  badge: {
+    error: { bg: "#ffebe9", fg: "#cf222e" },
+    running: { bg: "#fff8c5", fg: "#9a6700" },
+    idle: { bg: "#dafbe1", fg: "#1a7f37" },
+    search: { bg: "#ddf4ff" },
+    command: { bg: "#fbefff" }
+  },
+  // ── Detail view ─────────────────────────────────────────
+  detail: {
+    title: "#1f2328",
+    subject: "#0969da"
+  },
+  // ── Tool pills ──────────────────────────────────────────
+  toolPill: {
+    safe: { bg: "#ddf4ff", fg: "#0550ae" },
+    mutating: { bg: "#fff8c5", fg: "#7c5200" },
+    browser: { bg: "#dafbe1", fg: "#116329" },
+    neutral: { bg: "#f6f8fa", fg: "#424a53" },
+    skill: { bg: "#fbefff", fg: "#6639ba" },
+    "subagent.spawn": { bg: "#dafbe1", fg: "#116329" },
+    "subagent.return": { bg: "#dafbe1", fg: "#1a7f37" }
+  }
+};
+var highContrastTheme = {
+  name: "high-contrast",
+  // ── Text hierarchy ──────────────────────────────────────
+  text: "#f0f6fc",
+  // Near-white. Maximum brightness.
+  textMuted: "#9ea7b3",
+  // Bumped from #7d8590 for better contrast (~5.2:1).
+  textInverse: "#010409",
+  // Near-black.
+  // ── Accent ──────────────────────────────────────────────
+  border: "#71b7ff",
+  accent: "#71b7ff",
+  // Brighter blue. Punches through.
+  accentSecondary: "#d2a8ff",
+  // Bright purple.
+  // ── Status ──────────────────────────────────────────────
+  status: {
+    success: "#56d364",
+    // Bright green. Higher saturation.
+    error: "#ff7b72",
+    // Bright red. Softened for readability.
+    warning: "#e3b341",
+    // Bright amber.
+    info: "#71b7ff",
+    // Bright blue.
+    working: "#e3b341",
+    // Bright amber.
+    neutral: "#b1bac4"
+    // Bumped from #9ea7b3 for HC (~6.0:1).
+  },
+  // ── Context bar ─────────────────────────────────────────
+  contextBar: {
+    track: "#3d444d",
+    // HC track — brighter than dark.
+    low: "#56d364",
+    medium: "#e3b341",
+    high: "#ff7b72"
+  },
+  // ── Dialog borders ──────────────────────────────────────
+  dialog: {
+    borderPermission: "#e3b341",
+    borderQuestion: "#71b7ff"
+  },
+  // ── Input ───────────────────────────────────────────────
+  inputPrompt: "#71b7ff",
+  inputChevron: "#9ea7b3",
+  // Bumped from #7d8590 for visibility.
+  inputBackground: "#16202b",
+  // ── Feed ────────────────────────────────────────────────
+  feed: {
+    headerLabel: "#9ea7b3",
+    // Matches textMuted.
+    stripeBackground: "#0d1521",
+    // Bumped from #0b141f for visible alternation.
+    focusBackground: "#1a3350"
+    // Brighter blue tint for HC.
+  },
+  // ── User messages ───────────────────────────────────────
+  userMessage: {
+    text: "#7d8590",
+    // Dimmed text for user messages in the message panel.
+    background: "#1a2436",
+    // Blue-tinted lift — differentiates user turns from agent.
+    border: "#444c56",
+    // Bumped from #3d444d for HC visibility.
+    agentBorder: "#5599cc",
+    // Brighter blue for HC.
+    focusBorder: "#71b7ff"
+    // Accent blue for focused message indicator.
+  },
+  // ── Badges ──────────────────────────────────────────────
+  badge: {
+    error: { bg: "#6e1b16", fg: "#ff7b72" },
+    running: { bg: "#5c4813", fg: "#e3b341" },
+    idle: { bg: "#154228", fg: "#56d364" },
+    search: { bg: "#1a3350" },
+    command: { bg: "#301e50" }
+  },
+  // ── Detail view ─────────────────────────────────────────
+  detail: {
+    title: "#f0f6fc",
+    subject: "#71b7ff"
+  },
+  // ── Tool pills ──────────────────────────────────────────
+  toolPill: {
+    safe: { bg: "#122d42", fg: "#a2d2ff" },
+    mutating: { bg: "#3a2e10", fg: "#f0d070" },
+    browser: { bg: "#0f3520", fg: "#7ee28b" },
+    neutral: { bg: "#1c2128", fg: "#b1bac4" },
+    skill: { bg: "#2b1a40", fg: "#e0c0ff" },
+    "subagent.spawn": { bg: "#0f3520", fg: "#7ee28b" },
+    "subagent.return": { bg: "#0f3520", fg: "#6bcc79" }
+  }
+};
+var THEMES = {
+  dark: darkTheme,
+  light: lightTheme,
+  "high-contrast": highContrastTheme
+};
+function resolveTheme(name) {
+  if (name && name in THEMES) {
+    return THEMES[name];
+  }
+  return darkTheme;
+}
+
+// src/ui/theme/ThemeContext.tsx
+import { createContext, useContext } from "react";
+var ThemeContext = createContext(darkTheme);
+var ThemeProvider = ThemeContext.Provider;
+function useTheme() {
+  return useContext(ThemeContext);
+}
+
+// src/infra/plugins/workflowSourceResolution.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/infra/plugins/marketplaceShared.ts
+import { execFileSync } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+var MARKETPLACE_REF_RE = /^[a-zA-Z0-9_-]+@[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/;
+var MARKETPLACE_SLUG_RE = /^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/;
+function marketplacesCacheDir() {
+  return path.join(os.homedir(), ".config", "athena", "marketplaces");
+}
+function marketplaceRepoCacheDir(owner, repo) {
+  return path.join(marketplacesCacheDir(), owner, repo);
+}
+function resolvePluginManifestPath(repoDir) {
+  const preferredManifestPath = path.join(
+    repoDir,
+    ".agents",
+    "plugins",
+    "marketplace.json"
+  );
+  const legacyManifestPath = resolveLegacyPluginManifestPath(repoDir);
+  return fs.existsSync(preferredManifestPath) ? preferredManifestPath : legacyManifestPath;
+}
+function resolveLegacyPluginManifestPath(repoDir) {
+  return path.join(repoDir, ".claude-plugin", "marketplace.json");
+}
+function resolveWorkflowManifestPath(repoDir) {
+  const preferredManifestPath = path.join(
+    repoDir,
+    ".athena-workflow",
+    "marketplace.json"
+  );
+  const legacyManifestPath = resolveLegacyPluginManifestPath(repoDir);
+  return fs.existsSync(preferredManifestPath) ? preferredManifestPath : legacyManifestPath;
+}
+function readManifest(manifestPath) {
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error(`Marketplace manifest not found: ${manifestPath}`);
+  }
+  return JSON.parse(
+    fs.readFileSync(manifestPath, "utf-8")
+  );
+}
+function entryRelativeSourcePath(entry, pluginName) {
+  let sourcePath;
+  if (typeof entry.source === "string") {
+    sourcePath = entry.source;
+  } else {
+    const sourceRecord = entry.source;
+    if (sourceRecord.source !== "local" || typeof sourceRecord.path !== "string") {
+      throw new Error(
+        `Plugin "${pluginName}" uses a remote source type which is not supported by athena-cli. Only local relative path sources are supported.`
+      );
+    }
+    sourcePath = sourceRecord.path;
+  }
+  if (!sourcePath.startsWith("./")) {
+    throw new Error(
+      `Plugin "${pluginName}" source must start with "./": ${sourcePath}`
+    );
+  }
+  const relativeSourcePath = sourcePath.slice(2);
+  if (relativeSourcePath.length === 0) {
+    throw new Error(`Plugin "${pluginName}" source must not be empty`);
+  }
+  if (relativeSourcePath.includes("\\")) {
+    throw new Error(
+      `Plugin "${pluginName}" source must stay within the marketplace root: ${sourcePath}`
+    );
+  }
+  const segments = relativeSourcePath.split("/");
+  if (segments.some(
+    (segment) => segment === "" || segment === "." || segment === ".."
+  )) {
+    throw new Error(
+      `Plugin "${pluginName}" source must stay within the marketplace root: ${sourcePath}`
+    );
+  }
+  return relativeSourcePath;
+}
+function resolvePluginDirFromManifest(pluginName, repoDir, manifestPath) {
+  const manifest = readManifest(manifestPath);
+  if (!Array.isArray(manifest.plugins)) {
+    throw new Error(
+      `Invalid marketplace manifest at ${manifestPath}: "plugins" must be an array`
+    );
+  }
+  const entry = manifest.plugins.find((p) => p.name === pluginName);
+  if (!entry) {
+    const available = manifest.plugins.map((p) => p.name).join(", ");
+    throw new Error(
+      `Plugin "${pluginName}" not found in marketplace manifest ${manifestPath}. Available plugins: ${available}`
+    );
+  }
+  const pluginDir = path.join(
+    repoDir,
+    entryRelativeSourcePath(entry, pluginName)
+  );
+  if (!fs.existsSync(pluginDir)) {
+    throw new Error(`Plugin source directory not found: ${pluginDir}`);
+  }
+  return pluginDir;
+}
+function resolveWorkflowEntryPath(entry, manifest, repoDir) {
+  if (typeof entry.source !== "string") {
+    throw new Error(
+      `Workflow "${entry.name}" uses a remote source type which is not supported.`
+    );
+  }
+  let sourcePath = entry.source;
+  const { workflowRoot } = manifest.metadata ?? {};
+  if (workflowRoot && !path.isAbsolute(sourcePath) && !sourcePath.startsWith("./") && !sourcePath.startsWith("../")) {
+    sourcePath = path.join(workflowRoot, sourcePath);
+  }
+  const workflowPath = path.resolve(repoDir, sourcePath);
+  if (!workflowPath.startsWith(repoDir + path.sep) && workflowPath !== repoDir) {
+    throw new Error(
+      `Workflow "${entry.name}" source resolves outside the marketplace repo: ${workflowPath}`
+    );
+  }
+  const resolvedWorkflowPath = preferCanonicalWorkflowPath(
+    repoDir,
+    workflowPath
+  );
+  if (!fs.existsSync(resolvedWorkflowPath)) {
+    throw new Error(`Workflow source not found: ${resolvedWorkflowPath}`);
+  }
+  return resolvedWorkflowPath;
+}
+function resolveWorkflowPathFromManifest(workflowName, repoDir, manifestPath) {
+  const manifest = readManifest(manifestPath);
+  const workflows = manifest.workflows ?? [];
+  const entry = workflows.find((w) => w.name === workflowName);
+  if (!entry) {
+    const available = workflows.map((w) => w.name).join(", ") || "(none)";
+    throw new Error(
+      `Workflow "${workflowName}" not found in marketplace manifest ${manifestPath}. Available workflows: ${available}`
+    );
+  }
+  return resolveWorkflowEntryPath(entry, manifest, repoDir);
+}
+function listWorkflowEntriesFromManifest(repoDir, manifestPath, source) {
+  const manifest = readManifest(manifestPath);
+  const workflows = manifest.workflows ?? [];
+  return workflows.filter(
+    (entry) => typeof entry.source === "string"
+  ).map((entry) => ({
+    name: entry.name,
+    description: entry.description,
+    version: entry.version,
+    workflowPath: resolveWorkflowEntryPath(entry, manifest, repoDir),
+    ref: source.kind === "remote" ? `${entry.name}@${source.owner}/${source.repo}` : void 0,
+    source
+  }));
+}
+function preferCanonicalWorkflowPath(repoDir, workflowPath) {
+  const relativePath = path.relative(repoDir, workflowPath);
+  const segments = relativePath.split(path.sep);
+  if (segments[0] !== ".workflows") {
+    return workflowPath;
+  }
+  const canonicalPath = path.join(repoDir, "workflows", ...segments.slice(1));
+  return fs.existsSync(canonicalPath) ? canonicalPath : workflowPath;
+}
+function isMarketplaceRef(entry) {
+  return MARKETPLACE_REF_RE.test(entry);
+}
+function isMarketplaceSlug(entry) {
+  return MARKETPLACE_SLUG_RE.test(entry);
+}
+function parseRef(ref) {
+  const atIdx = ref.indexOf("@");
+  const pluginName = ref.slice(0, atIdx);
+  const slug = ref.slice(atIdx + 1);
+  const slashIdx = slug.indexOf("/");
+  return {
+    pluginName,
+    owner: slug.slice(0, slashIdx),
+    repo: slug.slice(slashIdx + 1)
+  };
+}
+function buildMarketplacePluginResolution(ref, repoDir, manifestPath) {
+  const { pluginName } = parseRef(ref);
+  const pluginDir = resolvePluginDirFromManifest(
+    pluginName,
+    repoDir,
+    manifestPath
+  );
+  const version = resolvePluginVersionFromDir(pluginDir);
+  const artifactLayout = version ? resolvePackagedArtifactLayout(pluginDir, version) : void 0;
+  return {
+    ref,
+    pluginName,
+    marketplacePath: artifactLayout?.codexMarketplacePath ?? manifestPath,
+    pluginDir: artifactLayout?.claudeArtifactDir ?? pluginDir,
+    codexPluginDir: artifactLayout?.codexPluginDir ?? pluginDir
+  };
+}
+function isPathWithinRoot(rootDir, targetPath) {
+  const relative = path.relative(rootDir, targetPath);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function resolvePluginVersionFromDir(pluginDir) {
+  const manifestPaths = [
+    path.join(pluginDir, ".codex-plugin", "plugin.json"),
+    path.join(pluginDir, ".claude-plugin", "plugin.json")
+  ];
+  for (const manifestPath of manifestPaths) {
+    if (!fs.existsSync(manifestPath)) continue;
+    try {
+      const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+      if (typeof manifest.version === "string" && manifest.version.length > 0) {
+        return manifest.version;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+function resolvePackagedArtifactLayout(pluginRoot, version) {
+  const releasePath = path.join(pluginRoot, "dist", version, "release.json");
+  if (!fs.existsSync(releasePath)) {
+    return void 0;
+  }
+  try {
+    const release = JSON.parse(
+      fs.readFileSync(releasePath, "utf-8")
+    );
+    if (release.version !== version) {
+      return void 0;
+    }
+    const claudePath = release.artifacts?.claude?.path;
+    const codexMarketplacePath = release.artifacts?.codex?.marketplacePath;
+    const codexPluginPath = release.artifacts?.codex?.pluginPath;
+    if (typeof claudePath !== "string" || typeof codexMarketplacePath !== "string" || typeof codexPluginPath !== "string") {
+      return void 0;
+    }
+    const releaseDir = path.dirname(releasePath);
+    const claudeArtifactDir = path.resolve(releaseDir, claudePath);
+    const resolvedCodexMarketplacePath = path.resolve(
+      releaseDir,
+      codexMarketplacePath
+    );
+    const codexPluginDir = path.resolve(releaseDir, codexPluginPath);
+    if (!isPathWithinRoot(releaseDir, claudeArtifactDir) || !isPathWithinRoot(releaseDir, resolvedCodexMarketplacePath) || !isPathWithinRoot(releaseDir, codexPluginDir)) {
+      return void 0;
+    }
+    if (!fs.existsSync(claudeArtifactDir) || !fs.existsSync(resolvedCodexMarketplacePath) || !fs.existsSync(codexPluginDir)) {
+      return void 0;
+    }
+    return {
+      claudeArtifactDir,
+      codexMarketplacePath: resolvedCodexMarketplacePath,
+      codexPluginDir
+    };
+  } catch {
+    return void 0;
+  }
+}
+function ensureRepo(owner, repo) {
+  const repoDir = marketplaceRepoCacheDir(owner, repo);
+  if (!fs.existsSync(repoDir)) {
+    const repoUrl = `https://github.com/${owner}/${repo}.git`;
+    fs.mkdirSync(repoDir, { recursive: true });
+    try {
+      execFileSync("git", ["clone", "--depth", "1", repoUrl, repoDir], {
+        stdio: "ignore"
+      });
+    } catch (error) {
+      fs.rmSync(repoDir, { recursive: true, force: true });
+      throw new Error(
+        `Failed to clone marketplace repo ${owner}/${repo}: ${error.message}`
+      );
+    }
+  } else {
+    try {
+      execFileSync("git", ["pull", "--ff-only"], {
+        cwd: repoDir,
+        stdio: "ignore"
+      });
+    } catch {
+    }
+  }
+  return repoDir;
+}
+function requireGitForMarketplace(kind) {
+  try {
+    execFileSync("git", ["--version"], { stdio: "ignore" });
+  } catch {
+    throw new Error(
+      `git is not installed. Install git to use marketplace ${kind}.`
+    );
+  }
+}
+
+// src/infra/plugins/workflowSourceErrors.ts
+var WorkflowAmbiguityError = class extends Error {
+  workflowName;
+  candidates;
+  constructor(workflowName, candidates) {
+    const list = candidates.map((c) => `  - ${c.sourceLabel}: use ${c.disambiguator}`).join("\n");
+    super(
+      `Workflow "${workflowName}" is provided by multiple configured marketplaces:
+${list}
+Run \`athena-flow workflow install <disambiguator>\` to pick one.`
+    );
+    this.name = "WorkflowAmbiguityError";
+    this.workflowName = workflowName;
+    this.candidates = candidates;
+  }
+};
+var WorkflowNotFoundError = class extends Error {
+  workflowName;
+  searchedSources;
+  constructor(workflowName, searchedSources) {
+    const sourceList = searchedSources.length ? searchedSources.join(", ") : "(no marketplaces configured)";
+    super(
+      `Workflow "${workflowName}" not found in any configured marketplace (searched: ${sourceList}).`
+    );
+    this.name = "WorkflowNotFoundError";
+    this.workflowName = workflowName;
+    this.searchedSources = searchedSources;
+  }
+};
+
+// src/infra/plugins/workflowSourceResolution.ts
+function findMarketplaceRepoDir(startPath) {
+  let currentDir = path2.resolve(startPath);
+  for (; ; ) {
+    if (fs2.existsSync(resolveWorkflowManifestPath(currentDir)) || fs2.existsSync(resolvePluginManifestPath(currentDir))) {
+      return currentDir;
+    }
+    const parentDir = path2.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return void 0;
+    }
+    currentDir = parentDir;
+  }
+}
+function resolveWorkflowMarketplaceSource(source) {
+  const trimmed = source.trim();
+  const resolvedPath = path2.resolve(trimmed);
+  if (!fs2.existsSync(resolvedPath) && isMarketplaceSlug(trimmed)) {
+    const slashIdx = trimmed.indexOf("/");
+    return {
+      kind: "remote",
+      slug: trimmed,
+      owner: trimmed.slice(0, slashIdx),
+      repo: trimmed.slice(slashIdx + 1)
+    };
+  }
+  const repoDir = findMarketplaceRepoDir(trimmed);
+  if (!repoDir) {
+    throw new Error(
+      `Local marketplace not found from source: ${trimmed}. Expected a marketplace repo root or a path inside one.`
+    );
+  }
+  return {
+    kind: "local",
+    path: resolvedPath,
+    repoDir
+  };
+}
+function listMarketplaceWorkflows(owner, repo) {
+  requireGitForMarketplace("workflows");
+  const repoDir = ensureRepo(owner, repo);
+  return listWorkflowEntriesFromManifest(
+    repoDir,
+    resolveWorkflowManifestPath(repoDir),
+    { kind: "remote", slug: `${owner}/${repo}`, owner, repo }
+  );
+}
+function listMarketplaceWorkflowsFromRepo(repoDir) {
+  return listWorkflowEntriesFromManifest(
+    repoDir,
+    resolveWorkflowManifestPath(repoDir),
+    { kind: "local", repoDir }
+  );
+}
+function resolveMarketplaceWorkflow(ref) {
+  requireGitForMarketplace("workflows");
+  const { pluginName: workflowName, owner, repo } = parseRef(ref);
+  const repoDir = ensureRepo(owner, repo);
+  return resolveWorkflowPathFromManifest(
+    workflowName,
+    repoDir,
+    resolveWorkflowManifestPath(repoDir)
+  );
+}
+var WorkflowVersionNotFoundError = class extends Error {
+  workflowName;
+  requestedVersion;
+  availableVersion;
+  sourceLabel;
+  constructor(workflowName, requestedVersion, availableVersion, sourceLabel) {
+    const availableText = availableVersion ? `found version ${availableVersion}` : "marketplace entry does not declare a version";
+    super(
+      `Workflow "${workflowName}" version ${requestedVersion} not found in ${sourceLabel} (${availableText}).`
+    );
+    this.name = "WorkflowVersionNotFoundError";
+    this.workflowName = workflowName;
+    this.requestedVersion = requestedVersion;
+    this.availableVersion = availableVersion;
+    this.sourceLabel = sourceLabel;
+  }
+};
+function parseBareWorkflowName(source) {
+  const atIdx = source.indexOf("@");
+  if (atIdx <= 0 || atIdx === source.length - 1) {
+    return { bareName: source, pinnedVersion: void 0 };
+  }
+  const suffix = source.slice(atIdx + 1);
+  if (suffix.includes("/")) {
+    return { bareName: source, pinnedVersion: void 0 };
+  }
+  return {
+    bareName: source.slice(0, atIdx),
+    pinnedVersion: suffix
+  };
+}
+function gatherMarketplaceWorkflowSources(source) {
+  const trimmed = source.trim();
+  const resolvedPath = path2.resolve(trimmed);
+  if (fs2.existsSync(resolvedPath) && fs2.statSync(resolvedPath).isFile()) {
+    return [
+      {
+        kind: "filesystem",
+        workflowPath: fs2.realpathSync(resolvedPath)
+      }
+    ];
+  }
+  if (!fs2.existsSync(resolvedPath) && isMarketplaceSlug(trimmed)) {
+    const slashIdx = trimmed.indexOf("/");
+    const owner = trimmed.slice(0, slashIdx);
+    const repo = trimmed.slice(slashIdx + 1);
+    requireGitForMarketplace("workflows");
+    const repoDir2 = ensureRepo(owner, repo);
+    const manifestPath2 = resolveWorkflowManifestPath(repoDir2);
+    return listWorkflowEntriesFromManifest(repoDir2, manifestPath2, {
+      kind: "remote",
+      slug: trimmed,
+      owner,
+      repo
+    }).map((entry) => ({
+      kind: "marketplace-remote",
+      slug: trimmed,
+      owner,
+      repo,
+      workflowName: entry.name,
+      version: entry.version,
+      ref: entry.ref,
+      manifestPath: manifestPath2,
+      workflowPath: entry.workflowPath
+    }));
+  }
+  const repoDir = findMarketplaceRepoDir(trimmed);
+  if (!repoDir) {
+    throw new Error(
+      `Marketplace source not found: ${trimmed}. Expected a marketplace repo root, a path inside one, or an owner/repo slug.`
+    );
+  }
+  const canonicalRepoDir = fs2.realpathSync(repoDir);
+  const manifestPath = resolveWorkflowManifestPath(canonicalRepoDir);
+  return listWorkflowEntriesFromManifest(canonicalRepoDir, manifestPath, {
+    kind: "local",
+    repoDir: canonicalRepoDir
+  }).map((entry) => ({
+    kind: "marketplace-local",
+    repoDir: canonicalRepoDir,
+    workflowName: entry.name,
+    version: entry.version,
+    manifestPath,
+    workflowPath: entry.workflowPath
+  }));
+}
+function resolvedSourceLabel(s) {
+  if (s.kind === "marketplace-remote") return `marketplace ${s.slug}`;
+  if (s.kind === "marketplace-local") return `local marketplace ${s.repoDir}`;
+  return `file ${s.workflowPath}`;
+}
+function resolvedSourceDisambiguator(s) {
+  if (s.kind === "marketplace-remote") return s.ref;
+  return s.workflowPath;
+}
+function resolveWorkflowInstall(sourceOrName, configuredSources) {
+  if (isMarketplaceRef(sourceOrName)) {
+    const { pluginName: workflowName, owner, repo } = parseRef(sourceOrName);
+    requireGitForMarketplace("workflows");
+    const repoDir = ensureRepo(owner, repo);
+    const manifestPath = resolveWorkflowManifestPath(repoDir);
+    const workflowPath = resolveWorkflowPathFromManifest(
+      workflowName,
+      repoDir,
+      manifestPath
+    );
+    const entry = listWorkflowEntriesFromManifest(repoDir, manifestPath, {
+      kind: "remote",
+      slug: `${owner}/${repo}`,
+      owner,
+      repo
+    }).find((e) => e.name === workflowName);
+    return {
+      kind: "marketplace-remote",
+      slug: `${owner}/${repo}`,
+      owner,
+      repo,
+      workflowName,
+      version: entry?.version,
+      ref: sourceOrName,
+      manifestPath,
+      workflowPath
+    };
+  }
+  const resolvedPath = path2.resolve(sourceOrName);
+  if (fs2.existsSync(resolvedPath) && fs2.statSync(resolvedPath).isFile()) {
+    return { kind: "filesystem", workflowPath: fs2.realpathSync(resolvedPath) };
+  }
+  const { bareName, pinnedVersion } = parseBareWorkflowName(sourceOrName);
+  if (bareName.includes("/") || bareName.includes("\\")) {
+    throw new Error(`Workflow source not found: ${sourceOrName}`);
+  }
+  const allListings = [];
+  let versionMismatch;
+  for (const configured of configuredSources) {
+    let sources;
+    try {
+      sources = gatherMarketplaceWorkflowSources(configured);
+    } catch {
+      continue;
+    }
+    for (const src of sources) {
+      if ((src.kind === "marketplace-remote" || src.kind === "marketplace-local") && src.workflowName === bareName) {
+        if (pinnedVersion !== void 0 && src.version !== pinnedVersion) {
+          versionMismatch ??= new WorkflowVersionNotFoundError(
+            bareName,
+            pinnedVersion,
+            src.version,
+            resolvedSourceLabel(src)
+          );
+          continue;
+        }
+        allListings.push(src);
+      }
+    }
+  }
+  if (allListings.length === 0) {
+    if (versionMismatch) throw versionMismatch;
+    throw new WorkflowNotFoundError(bareName, configuredSources);
+  }
+  if (allListings.length > 1) {
+    const candidates = allListings.map((s) => ({
+      sourceLabel: resolvedSourceLabel(s),
+      disambiguator: resolvedSourceDisambiguator(s)
+    }));
+    throw new WorkflowAmbiguityError(bareName, candidates);
+  }
+  return allListings[0];
+}
+
+// src/infra/plugins/marketplace.ts
+import { execFileSync as execFileSync3 } from "child_process";
+import fs4 from "fs";
+
+// src/infra/plugins/versionedPluginResolution.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import fs3 from "fs";
+import os2 from "os";
+import path3 from "path";
+var PLUGIN_NPM_SCOPE = "@athenaflow";
+function pluginNpmPackageName(pluginName) {
+  return `${PLUGIN_NPM_SCOPE}/plugin-${pluginName}`;
+}
+function versionedPluginCacheDir() {
+  return path3.join(os2.homedir(), ".config", "athena", "plugin-packages");
+}
+function resolveVersionedPluginDir(owner, repo, pluginName, version) {
+  const cacheDir = path3.join(
+    versionedPluginCacheDir(),
+    owner,
+    repo,
+    pluginName,
+    version
+  );
+  return fs3.existsSync(cacheDir) ? cacheDir : void 0;
+}
+function fetchPluginPackage(owner, repo, pluginName, version) {
+  const npmPkg = pluginNpmPackageName(pluginName);
+  const destDir = path3.join(
+    versionedPluginCacheDir(),
+    owner,
+    repo,
+    pluginName,
+    version
+  );
+  if (fs3.existsSync(destDir)) {
+    return destDir;
+  }
+  const cacheBase = versionedPluginCacheDir();
+  fs3.mkdirSync(cacheBase, { recursive: true });
+  const tmpDir = fs3.mkdtempSync(path3.join(cacheBase, ".tmp-"));
+  try {
+    const tarball = execFileSync2(
+      "npm",
+      ["pack", `${npmPkg}@${version}`, "--pack-destination", tmpDir],
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    const tarballPath = path3.join(tmpDir, tarball);
+    if (!fs3.existsSync(tarballPath)) {
+      throw new Error(`npm pack did not produce expected tarball: ${tarball}`);
+    }
+    const extractDir = path3.join(tmpDir, "extracted");
+    fs3.mkdirSync(extractDir, { recursive: true });
+    execFileSync2("tar", ["xzf", tarballPath, "-C", extractDir], {
+      stdio: "ignore"
+    });
+    const packageDir = path3.join(extractDir, "package");
+    if (!fs3.existsSync(packageDir)) {
+      throw new Error(
+        "Extracted tarball does not contain a package/ directory"
+      );
+    }
+    fs3.mkdirSync(path3.dirname(destDir), { recursive: true });
+    try {
+      fs3.renameSync(packageDir, destDir);
+    } catch (error) {
+      const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
+      if ((code === "EEXIST" || code === "ENOTEMPTY") && fs3.existsSync(destDir)) {
+        return destDir;
+      }
+      throw error;
+    }
+    return destDir;
+  } finally {
+    fs3.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+function resolvePackagedArtifactsOrThrow(pluginName, version, pluginRoot, stage) {
+  const artifactLayout = resolvePackagedArtifactLayout(pluginRoot, version);
+  if (!artifactLayout) {
+    throw new Error(
+      `${stage} for plugin "${pluginName}" version ${version} is missing packaged runtime artifacts`
+    );
+  }
+  return artifactLayout;
+}
+function readSourceFallbackEntry(repoDir, pluginName) {
+  const manifestPath = resolvePluginManifestPath(repoDir);
+  const manifest = readManifest(manifestPath);
+  const entry = manifest.plugins.find((plugin) => plugin.name === pluginName);
+  if (!entry) {
+    return void 0;
+  }
+  const pluginRoot = path3.join(
+    repoDir,
+    entryRelativeSourcePath(entry, pluginName)
+  );
+  const version = entry.version ?? resolvePluginVersionFromDir(pluginRoot);
+  return { pluginRoot, version };
+}
+function resolveMarketplaceSourceFallback(ref, pluginName, version, repoDir) {
+  const entry = readSourceFallbackEntry(repoDir, pluginName);
+  if (!entry || entry.version !== version) {
+    return void 0;
+  }
+  resolvePackagedArtifactsOrThrow(
+    pluginName,
+    version,
+    entry.pluginRoot,
+    "marketplace source fallback"
+  );
+  return buildMarketplacePluginResolution(
+    ref,
+    repoDir,
+    resolvePluginManifestPath(repoDir)
+  );
+}
+function describeSourceFallbackRejection(owner, repo, pluginName, version, repoDir) {
+  if (!fs3.existsSync(repoDir)) {
+    return `source fallback was unavailable because marketplace repo ${owner}/${repo} is not cached locally`;
+  }
+  let entry;
+  try {
+    entry = readSourceFallbackEntry(repoDir, pluginName);
+  } catch (error) {
+    return `source fallback could not determine the marketplace source version: ${error.message}`;
+  }
+  if (!entry?.version) {
+    return `source fallback was considered, but marketplace repo ${owner}/${repo} does not expose a version for plugin "${pluginName}"`;
+  }
+  return `source fallback was considered, but marketplace repo ${owner}/${repo} exposes version ${entry.version} instead of requested ${version}`;
+}
+function resolveVersionedMarketplacePluginTarget(ref, version, sourceRepoDir, options) {
+  const { pluginName, owner, repo } = parseRef(ref);
+  const forceRefresh = options?.forceRefresh === true;
+  const cachedDir = resolveVersionedPluginDir(owner, repo, pluginName, version);
+  if (cachedDir && !forceRefresh) {
+    const artifactLayout = resolvePackagedArtifactsOrThrow(
+      pluginName,
+      version,
+      cachedDir,
+      "cache"
+    );
+    return {
+      ref,
+      pluginName,
+      marketplacePath: artifactLayout.codexMarketplacePath,
+      pluginDir: artifactLayout.claudeArtifactDir,
+      codexPluginDir: artifactLayout.codexPluginDir
+    };
+  }
+  let npmError;
+  try {
+    const fetchedDir = fetchPluginPackage(owner, repo, pluginName, version);
+    const artifactLayout = resolvePackagedArtifactsOrThrow(
+      pluginName,
+      version,
+      fetchedDir,
+      "npm package"
+    );
+    return {
+      ref,
+      pluginName,
+      marketplacePath: artifactLayout.codexMarketplacePath,
+      pluginDir: artifactLayout.claudeArtifactDir,
+      codexPluginDir: artifactLayout.codexPluginDir
+    };
+  } catch (error) {
+    npmError = error;
+  }
+  const repoDir = sourceRepoDir ?? ensureRepo(owner, repo);
+  const fallbackTarget = fs3.existsSync(repoDir) ? resolveMarketplaceSourceFallback(ref, pluginName, version, repoDir) : void 0;
+  if (fallbackTarget) {
+    return fallbackTarget;
+  }
+  const npmStageMessage = `npm package resolution failed for ${pluginNpmPackageName(pluginName)}@${version}: ${npmError.message}`;
+  const fallbackMessage = describeSourceFallbackRejection(
+    owner,
+    repo,
+    pluginName,
+    version,
+    repoDir
+  );
+  throw new Error(
+    `Plugin "${pluginName}" version ${version} could not be resolved. ${npmStageMessage}. ${fallbackMessage}.`
+  );
+}
+function refreshVersionedMarketplacePluginTarget(ref, version, sourceRepoDir) {
+  return resolveVersionedMarketplacePluginTarget(ref, version, sourceRepoDir, {
+    forceRefresh: true
+  });
+}
+
+// src/infra/plugins/marketplace.ts
+function pullMarketplaceRepo(owner, repo) {
+  const repoDir = marketplaceRepoCacheDir(owner, repo);
+  if (!fs4.existsSync(repoDir)) {
+    throw new Error(
+      `Marketplace repo ${owner}/${repo} is not cached. It will be cloned on first use.`
+    );
+  }
+  execFileSync3("git", ["pull", "--ff-only"], {
+    cwd: repoDir,
+    stdio: "ignore"
+  });
+}
+function resolveMarketplacePlugin(ref) {
+  requireGitForMarketplace("plugins");
+  const { pluginName, owner, repo } = parseRef(ref);
+  const repoDir = ensureRepo(owner, repo);
+  return resolvePluginDirFromManifest(
+    pluginName,
+    repoDir,
+    resolvePluginManifestPath(repoDir)
+  );
+}
+function resolveMarketplacePluginTarget(ref) {
+  requireGitForMarketplace("plugins");
+  const { owner, repo } = parseRef(ref);
+  const repoDir = ensureRepo(owner, repo);
+  const directTarget = buildMarketplacePluginResolution(
+    ref,
+    repoDir,
+    resolvePluginManifestPath(repoDir)
+  );
+  const pluginVersion = resolvePluginVersionFromDir(directTarget.pluginDir);
+  if (!pluginVersion) {
+    return directTarget;
+  }
+  return resolveVersionedMarketplacePluginTarget(ref, pluginVersion, repoDir);
+}
+function resolveMarketplacePluginTargetFromRepo(ref, repoDir) {
+  return buildMarketplacePluginResolution(
+    ref,
+    repoDir,
+    resolvePluginManifestPath(repoDir)
+  );
+}
+
+// src/infra/plugins/config.ts
+import fs5 from "fs";
+import os3 from "os";
+import path4 from "path";
+var EMPTY_CONFIG = { plugins: [], additionalDirectories: [] };
+function projectConfigPath(projectDir) {
+  return path4.join(projectDir, ".athena", "config.json");
+}
+function readConfig(projectDir) {
+  return readConfigFile(projectConfigPath(projectDir), projectDir);
+}
+function resolveActiveWorkflow(input) {
+  const { globalConfig, projectConfig, override } = input;
+  if (override !== void 0) {
+    return {
+      name: override,
+      source: "override",
+      selectionsLayer: projectConfig.activeWorkflow !== void 0 ? projectConfig : globalConfig
+    };
+  }
+  if (projectConfig.activeWorkflow !== void 0) {
+    return {
+      name: projectConfig.activeWorkflow,
+      source: "project",
+      selectionsLayer: projectConfig
+    };
+  }
+  if (globalConfig.activeWorkflow !== void 0) {
+    return {
+      name: globalConfig.activeWorkflow,
+      source: "global",
+      selectionsLayer: globalConfig
+    };
+  }
+  return {
+    name: "default",
+    source: "default",
+    selectionsLayer: globalConfig
+  };
+}
+function readGlobalConfig() {
+  const homeDir = os3.homedir();
+  const configPath = path4.join(homeDir, ".config", "athena", "config.json");
+  return readConfigFile(configPath, homeDir);
+}
+function readConfigFile(configPath, baseDir) {
+  if (!fs5.existsSync(configPath)) {
+    return EMPTY_CONFIG;
+  }
+  const raw = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
+  if ("workflowMarketplaceSource" in raw) {
+    throw new Error(
+      `Invalid config: "${configPath}" uses deprecated "workflowMarketplaceSource"; use "workflowMarketplaceSources"`
+    );
+  }
+  if (raw.workflowMarketplaceSources !== void 0 && (!Array.isArray(raw.workflowMarketplaceSources) || !raw.workflowMarketplaceSources.every(
+    (source) => typeof source === "string"
+  ))) {
+    throw new Error(
+      `Invalid config: "${configPath}" field "workflowMarketplaceSources" must be an array of strings`
+    );
+  }
+  if (raw.harness !== void 0 && raw.harness !== "claude-code" && raw.harness !== "openai-codex" && raw.harness !== "opencode") {
+    throw new Error(
+      `Invalid config: "${configPath}" field "harness" must be one of claude-code, openai-codex, opencode`
+    );
+  }
+  if (raw.channels !== void 0 && (!Array.isArray(raw.channels) || !raw.channels.every((c) => typeof c === "string"))) {
+    throw new Error(
+      `Invalid config: "${configPath}" field "channels" must be an array of strings`
+    );
+  }
+  const plugins = (raw.plugins ?? []).map((p) => {
+    if (isMarketplaceRef(p)) {
+      try {
+        return resolveMarketplacePlugin(p);
+      } catch (error) {
+        console.error(
+          `Warning: skipping plugin "${p}": ${error.message}`
+        );
+        return null;
+      }
+    }
+    return path4.isAbsolute(p) ? p : path4.resolve(baseDir, p);
+  }).filter((p) => p !== null);
+  const additionalDirectories = (raw.additionalDirectories ?? []).map(
+    (dir) => path4.isAbsolute(dir) ? dir : path4.resolve(baseDir, dir)
+  );
+  return {
+    plugins,
+    additionalDirectories,
+    model: raw.model,
+    theme: raw.theme,
+    activeWorkflow: raw.activeWorkflow,
+    workflowMarketplaceSources: raw.workflowMarketplaceSources,
+    workflowSelections: raw.workflowSelections,
+    setupComplete: raw.setupComplete,
+    harness: raw.harness,
+    telemetry: raw.telemetry,
+    telemetryDiagnostics: raw.telemetryDiagnostics,
+    deviceId: raw.deviceId,
+    channels: raw.channels
+  };
+}
+function readExistingConfig(configPath) {
+  try {
+    return JSON.parse(fs5.readFileSync(configPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeConfigFile(configDir, configPath, updates, deleteKeys) {
+  const existing = readExistingConfig(configPath);
+  const merged = { ...existing, ...updates };
+  if (updates.workflowSelections) {
+    const existingSelections = existing["workflowSelections"] ?? {};
+    merged["workflowSelections"] = {
+      ...existingSelections,
+      ...updates.workflowSelections
+    };
+  }
+  if (deleteKeys) {
+    for (const key of deleteKeys) {
+      delete merged[key];
+    }
+  }
+  fs5.mkdirSync(configDir, { recursive: true });
+  fs5.writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+}
+var GLOBAL_CONFIG_LEGACY_KEYS = [
+  "workflow",
+  "mcpServerOptions",
+  "workflowMarketplaceSource"
+];
+function writeGlobalConfig(updates) {
+  const homeDir = os3.homedir();
+  const configDir = path4.join(homeDir, ".config", "athena");
+  const configPath = path4.join(configDir, "config.json");
+  writeConfigFile(configDir, configPath, updates, GLOBAL_CONFIG_LEGACY_KEYS);
+}
+function writeProjectConfig(projectDir, updates) {
+  const configDir = path4.join(projectDir, ".athena");
+  const configPath = path4.join(configDir, "config.json");
+  writeConfigFile(configDir, configPath, updates);
+}
+function hasActiveWorkflow(configPath) {
+  try {
+    const raw = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
+    return typeof raw.activeWorkflow === "string" && raw.activeWorkflow !== "";
+  } catch {
+    return false;
+  }
+}
+function hasProjectWorkflow(projectDir) {
+  return hasActiveWorkflow(projectConfigPath(projectDir));
+}
+
+// src/setup/components/StepStatus.tsx
+import { Text, Box } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function StepStatus({ status, message }) {
+  const theme = useTheme();
+  const icon = status === "success" ? "\u2713" : status === "error" ? "\u2717" : "\u280B";
+  const color = status === "success" ? theme.status.success : status === "error" ? theme.status.error : theme.status.working;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "row", marginTop: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { color, bold: true, children: [
+      icon,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx(Text, { color, children: message })
+  ] });
+}
+
+// src/setup/steps/McpOptionsStep.tsx
+import { useState as useState2, useCallback, useEffect as useEffect2, useRef as useRef2 } from "react";
+import { Box as Box3, Text as Text3 } from "ink";
+
+// src/setup/components/StepSelector.tsx
+import { useEffect, useRef, useState } from "react";
+import { Box as Box2, Text as Text2, useInput } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function getInitialCursor(options, initialValue) {
+  if (initialValue) {
+    const initialIndex = options.findIndex(
+      (option) => option.value === initialValue && !option.disabled
+    );
+    if (initialIndex >= 0) {
+      return initialIndex;
+    }
+  }
+  const firstEnabled = options.findIndex((option) => !option.disabled);
+  return firstEnabled >= 0 ? firstEnabled : 0;
+}
+function StepSelector({
+  options,
+  onSelect,
+  isActive = true,
+  initialValue,
+  onHighlight,
+  gap = 0
+}) {
+  const theme = useTheme();
+  const [cursor, setCursor] = useState(
+    () => getInitialCursor(options, initialValue)
+  );
+  const highlightedRef = useRef(void 0);
+  const moveCursor = (direction) => {
+    setCursor((prev) => {
+      if (options.length <= 1) {
+        return prev;
+      }
+      let next = prev;
+      for (let i = 0; i < options.length; i += 1) {
+        const candidate = Math.max(
+          0,
+          Math.min(next + direction, options.length - 1)
+        );
+        if (candidate === next) {
+          return prev;
+        }
+        next = candidate;
+        if (!options[next]?.disabled) {
+          return next;
+        }
+      }
+      return prev;
+    });
+  };
+  useInput(
+    (_input, key) => {
+      if (key.downArrow) {
+        moveCursor(1);
+      } else if (key.upArrow) {
+        moveCursor(-1);
+      } else if (key.return) {
+        const opt = options[cursor];
+        if (!opt.disabled) {
+          onSelect(opt.value);
+        }
+      }
+    },
+    { isActive }
+  );
+  useEffect(() => {
+    if (!onHighlight) {
+      return;
+    }
+    const option = options[cursor];
+    if (option.disabled) {
+      return;
+    }
+    if (highlightedRef.current === option.value) {
+      return;
+    }
+    highlightedRef.current = option.value;
+    onHighlight(option.value);
+  }, [cursor, options, onHighlight]);
+  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", gap, children: options.map((opt, i) => {
+    const isCursor = i === cursor;
+    return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs2(
+        Text2,
+        {
+          color: opt.disabled ? theme.textMuted : isCursor ? theme.accent : theme.text,
+          bold: isCursor && !opt.disabled,
+          inverse: isCursor && !opt.disabled,
+          dimColor: opt.disabled,
+          children: [
+            isCursor ? " > " : "   ",
+            opt.label,
+            isCursor ? " " : ""
+          ]
+        }
+      ),
+      opt.description && !opt.disabled ? /* @__PURE__ */ jsx2(Box2, { paddingLeft: 5, children: /* @__PURE__ */ jsxs2(Text2, { dimColor: true, italic: true, children: [
+        "\u21B3 ",
+        opt.description
+      ] }) }) : null
+    ] }, opt.value);
+  }) });
+}
+
+// src/setup/steps/McpOptionsStep.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function McpOptionsStep({ servers, onComplete }) {
+  const theme = useTheme();
+  const [serverIndex, setServerIndex] = useState2(0);
+  const choicesRef = useRef2({});
+  const autoSkippedRef = useRef2(false);
+  useEffect2(() => {
+    if (servers.length === 0 && !autoSkippedRef.current) {
+      autoSkippedRef.current = true;
+      onComplete({});
+    }
+  }, [servers.length, onComplete]);
+  const handleSelect = useCallback(
+    (value) => {
+      const server = servers[serverIndex];
+      const selectedOption = server.options[Number(value)];
+      choicesRef.current = {
+        ...choicesRef.current,
+        [server.serverName]: selectedOption.env
+      };
+      if (serverIndex + 1 < servers.length) {
+        setServerIndex((prev) => prev + 1);
+      } else {
+        onComplete(choicesRef.current);
+      }
+    },
+    [serverIndex, servers, onComplete]
+  );
+  if (servers.length === 0) {
+    return null;
+  }
+  const currentServer = servers[serverIndex];
+  const selectorOptions = currentServer.options.map((opt, i) => ({
+    label: i === 0 ? `${opt.label} (default)` : opt.label,
+    value: String(i)
+  }));
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, color: theme.accent, children: "Configure MCP servers" }),
+    /* @__PURE__ */ jsxs3(Text3, { color: theme.textMuted, children: [
+      "Server ",
+      serverIndex + 1,
+      " of ",
+      servers.length,
+      ":",
+      " ",
+      /* @__PURE__ */ jsx3(Text3, { bold: true, children: currentServer.serverName })
+    ] }),
+    /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(
+      StepSelector,
+      {
+        options: selectorOptions,
+        onSelect: handleSelect
+      },
+      currentServer.serverName
+    ) })
+  ] });
+}
+
+// src/core/workflows/types.ts
+function pluginSpecRef(spec) {
+  return typeof spec === "string" ? spec : spec.ref;
+}
+function pluginSpecVersion(spec) {
+  return typeof spec === "string" ? void 0 : spec.version;
+}
+
+// src/core/workflows/installer.ts
+function installWorkflowPlugins(workflow) {
+  return resolveWorkflowPlugins(workflow).resolvedPlugins.map(
+    (plugin) => plugin.claudeArtifactDir
+  );
+}
+function marketplaceNameFromRef(ref) {
+  return ref.slice(ref.indexOf("@") + 1);
+}
+function toResolvedWorkflowPlugin(target, ref, version) {
+  return {
+    ref: target.ref,
+    pluginName: target.pluginName,
+    marketplaceName: marketplaceNameFromRef(ref),
+    ...version !== void 0 && { version },
+    pluginDir: target.pluginDir,
+    claudeArtifactDir: target.pluginDir,
+    codexPluginDir: target.codexPluginDir,
+    codexMarketplacePath: target.marketplacePath
+  };
+}
+function resolveWorkflowPlugins(workflow) {
+  const resolvedPlugins = workflow.plugins.map((spec) => {
+    const ref = pluginSpecRef(spec);
+    const version = pluginSpecVersion(spec);
+    try {
+      const source = "__source" in workflow ? workflow.__source : void 0;
+      const repoDir = source?.kind === "marketplace-local" ? source.repoDir : void 0;
+      if (version) {
+        const target2 = resolveVersionedMarketplacePluginTarget(
+          ref,
+          version,
+          repoDir
+        );
+        return toResolvedWorkflowPlugin(target2, ref, version);
+      }
+      if (repoDir) {
+        const target2 = resolveMarketplacePluginTargetFromRepo(ref, repoDir);
+        return toResolvedWorkflowPlugin(target2, ref);
+      }
+      const target = resolveMarketplacePluginTarget(ref);
+      return toResolvedWorkflowPlugin(target, ref);
+    } catch (error) {
+      throw new Error(
+        `Workflow "${workflow.name}": failed to install plugin "${ref}": ${error.message}`
+      );
+    }
+  });
+  return {
+    resolvedPlugins,
+    localPlugins: resolvedPlugins.map((p) => ({
+      ref: p.ref,
+      pluginDir: p.claudeArtifactDir
+    })),
+    codexPlugins: resolvedPlugins.map((p) => ({
+      ref: p.ref,
+      pluginName: p.pluginName,
+      marketplacePath: p.codexMarketplacePath,
+      ...p.version !== void 0 && { version: p.version }
+    }))
+  };
+}
+function refreshPinnedWorkflowPlugins(workflow) {
+  const source = "__source" in workflow ? workflow.__source : void 0;
+  for (const spec of workflow.plugins) {
+    const ref = pluginSpecRef(spec);
+    const version = pluginSpecVersion(spec);
+    if (!version) {
+      continue;
+    }
+    try {
+      refreshVersionedMarketplacePluginTarget(
+        ref,
+        version,
+        source?.kind === "marketplace-local" ? source.repoDir : void 0
+      );
+    } catch (error) {
+      throw new Error(
+        `Workflow "${workflow.name}": failed to refresh pinned plugin "${ref}" at version ${version}: ${error.message}`
+      );
+    }
+  }
+}
+
+// src/core/workflows/registry.ts
+import fs9 from "fs";
+import os5 from "os";
+import path7 from "path";
+
+// src/core/workflows/builtins/index.ts
+import fs7 from "fs";
+import os4 from "os";
+import path5 from "path";
+
+// src/core/workflows/loopManager.ts
+import fs6 from "fs";
+
+// src/core/workflows/templateVars.ts
+function substituteVariables(text, ctx) {
+  let result = text;
+  if (ctx.input !== void 0) {
+    result = result.replaceAll("{input}", ctx.input);
+  }
+  if (ctx.sessionId !== void 0) {
+    result = result.replaceAll("{sessionId}", ctx.sessionId);
+    result = result.replaceAll("<session_id>", ctx.sessionId);
+  }
+  if (ctx.trackerPath !== void 0) {
+    result = result.replaceAll("{trackerPath}", ctx.trackerPath);
+  }
+  return result;
+}
+
+// src/core/workflows/loopManager.ts
+var DEFAULT_COMPLETION_MARKER = "<!-- WORKFLOW_COMPLETE -->";
+var DEFAULT_BLOCKED_MARKER = "<!-- WORKFLOW_BLOCKED";
+var DEFAULT_TRACKER_PATH = ".athena/{sessionId}/tracker.md";
+var TRACKER_SKELETON_MARKER = "<!-- TRACKER_SKELETON -->";
+var DEFAULT_CONTINUE_PROMPT = "Continue the task. Read the tracker at {trackerPath} for current progress.";
+function createLoopManager(trackerPath, config) {
+  let iteration = 0;
+  let active = true;
+  const completionMarker = config.completionMarker ?? DEFAULT_COMPLETION_MARKER;
+  const blockedMarker = config.blockedMarker ?? DEFAULT_BLOCKED_MARKER;
+  function readTracker() {
+    try {
+      return fs6.readFileSync(trackerPath, "utf-8");
+    } catch {
+      return "";
+    }
+  }
+  function getTerminalLine(content) {
+    const lines = content.trimEnd().split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+    return lines.at(-1);
+  }
+  function extractBlockedReason(line) {
+    if (!line.startsWith(blockedMarker)) return void 0;
+    const afterMarker = line.slice(blockedMarker.length);
+    const match = afterMarker.match(/^:\s*(.+?)(?:\s*-->|$)/);
+    return match?.[1]?.trim();
+  }
+  function getState() {
+    const content = readTracker();
+    const terminalLine = getTerminalLine(content);
+    const completed = terminalLine === completionMarker;
+    const blocked = terminalLine !== void 0 && (terminalLine === `${blockedMarker} -->` || terminalLine.startsWith(`${blockedMarker}:`));
+    const blockedReason = blocked && terminalLine ? extractBlockedReason(terminalLine) : void 0;
+    const reachedLimit = iteration >= config.maxIterations;
+    const skeletonNotReplaced = content.includes(TRACKER_SKELETON_MARKER);
+    return {
+      active,
+      iteration,
+      maxIterations: config.maxIterations,
+      completionMarker,
+      blockedMarker,
+      completed,
+      blocked,
+      blockedReason,
+      reachedLimit,
+      skeletonNotReplaced
+    };
+  }
+  function incrementIteration() {
+    iteration++;
+  }
+  function deactivate() {
+    active = false;
+  }
+  return {
+    getState,
+    incrementIteration,
+    deactivate,
+    trackerPath
+  };
+}
+function buildContinuePrompt(loop) {
+  const template = loop.continuePrompt ?? DEFAULT_CONTINUE_PROMPT;
+  return substituteVariables(template, {
+    trackerPath: loop.trackerPath ?? DEFAULT_TRACKER_PATH
+  });
+}
+
+// src/core/workflows/builtins/index.ts
+var DEFAULT_BLOCKED_CLOSED_MARKER = `${DEFAULT_BLOCKED_MARKER} -->`;
+var DEFAULT_BLOCKED_REASON_MARKER = `${DEFAULT_BLOCKED_MARKER}: reason -->`;
+var SYSTEM_PROMPT = `You are working on a long-horizon task managed by Athena. A tracker file is used to persist progress across sessions.
+
+## Tracker File
+
+At the start of each session, read the tracker file if it exists. It contains the task plan, completed steps, and current status from prior sessions.
+
+If no tracker file exists, create one by:
+1. Analyzing the user's request to understand the full scope
+2. Breaking the task into concrete, actionable steps
+3. Writing the plan to the tracker file
+
+### Tracker Format
+
+Use this markdown format for the tracker:
+
+\`\`\`
+# Task: <one-line summary>
+
+## Plan
+- [x] Step 1 description
+- [x] Step 2 description
+- [ ] Step 3 description (current)
+- [ ] Step 4 description
+
+## Current Status
+<brief description of where things stand and what to do next>
+
+## Notes
+<any important context, decisions, or blockers discovered along the way>
+\`\`\`
+
+### Updating the Tracker
+
+After completing meaningful work, update the tracker:
+- Check off completed steps
+- Update the current status section
+- Add any important notes or decisions
+
+### Completion
+
+When all steps are complete:
+1. Update the tracker with all steps checked off
+2. Add \`${DEFAULT_COMPLETION_MARKER}\` at the end of the tracker file
+3. Provide a summary of what was accomplished
+
+### Blocked
+
+If you are blocked and cannot make further progress:
+1. Document what is blocking you in the Notes section
+2. Add \`${DEFAULT_BLOCKED_CLOSED_MARKER}\` or \`${DEFAULT_BLOCKED_REASON_MARKER}\` at the end of the tracker file
+3. Explain what needs to happen to unblock the task whenever possible
+`;
+function ensureSystemPromptFile() {
+  const dir = path5.join(
+    os4.homedir(),
+    ".config",
+    "athena",
+    "builtins",
+    "default"
+  );
+  const filePath = path5.join(dir, "system_prompt.md");
+  if (!fs7.existsSync(filePath) || fs7.readFileSync(filePath, "utf-8") !== SYSTEM_PROMPT) {
+    fs7.mkdirSync(dir, { recursive: true });
+    fs7.writeFileSync(filePath, SYSTEM_PROMPT, "utf-8");
+  }
+  return filePath;
+}
+function resolveBuiltinWorkflow(name) {
+  if (name !== "default") {
+    return void 0;
+  }
+  return {
+    name: "default",
+    description: "General-purpose workflow for long-horizon tasks \u2014 breaks work into steps, tracks progress across sessions, and loops until complete",
+    promptTemplate: "{input}",
+    loop: {
+      enabled: true,
+      completionMarker: DEFAULT_COMPLETION_MARKER,
+      blockedMarker: DEFAULT_BLOCKED_MARKER,
+      maxIterations: 20
+    },
+    plugins: [],
+    workflowFile: ensureSystemPromptFile()
+  };
+}
+function listBuiltinWorkflows() {
+  return ["default"];
+}
+
+// src/core/workflows/sourceMetadata.ts
+import fs8 from "fs";
+import path6 from "path";
+function legacyLocalToNew(legacyPath, legacyRepoDir) {
+  const repoDir = legacyRepoDir ?? findMarketplaceRepoDir(legacyPath);
+  if (!repoDir) {
+    return { kind: "filesystem", path: legacyPath };
+  }
+  try {
+    const canonicalRepoDir = fs8.realpathSync(repoDir);
+    const listings = listMarketplaceWorkflowsFromRepo(canonicalRepoDir);
+    const absolutePath = fs8.realpathSync(legacyPath);
+    const match = listings.find(
+      (l) => fs8.realpathSync(l.workflowPath) === absolutePath
+    );
+    if (match) {
+      return {
+        kind: "marketplace-local",
+        repoDir: canonicalRepoDir,
+        workflowName: match.name,
+        ...match.version ? { version: match.version } : {}
+      };
+    }
+  } catch {
+  }
+  return { kind: "filesystem", path: legacyPath };
+}
+function readWorkflowSourceMetadata(workflowDir) {
+  const sourceFile = path6.join(workflowDir, "source.json");
+  if (!fs8.existsSync(sourceFile)) return void 0;
+  let raw;
+  try {
+    raw = JSON.parse(fs8.readFileSync(sourceFile, "utf-8"));
+  } catch {
+    throw new Error(`Invalid source.json: ${sourceFile} is not valid JSON`);
+  }
+  if (!raw || typeof raw !== "object") {
+    throw new Error(
+      `Invalid source.json: ${sourceFile} must contain an object`
+    );
+  }
+  const r = raw;
+  if (r["v"] === 2) {
+    if (r["kind"] === "marketplace-remote" && typeof r["ref"] === "string") {
+      return {
+        kind: "marketplace-remote",
+        ref: r["ref"],
+        ...typeof r["version"] === "string" ? { version: r["version"] } : {}
+      };
+    }
+    if (r["kind"] === "marketplace-local" && typeof r["repoDir"] === "string" && typeof r["workflowName"] === "string") {
+      return {
+        kind: "marketplace-local",
+        repoDir: r["repoDir"],
+        workflowName: r["workflowName"],
+        ...typeof r["version"] === "string" ? { version: r["version"] } : {}
+      };
+    }
+    if (r["kind"] === "filesystem" && typeof r["path"] === "string") {
+      return { kind: "filesystem", path: r["path"] };
+    }
+  }
+  if (r["kind"] === "marketplace" && typeof r["ref"] === "string") {
+    return { kind: "marketplace-remote", ref: r["ref"] };
+  }
+  if (r["kind"] === "local" && typeof r["path"] === "string") {
+    return legacyLocalToNew(
+      r["path"],
+      typeof r["repoDir"] === "string" ? r["repoDir"] : void 0
+    );
+  }
+  throw new Error(`Invalid source.json: ${sourceFile} kind is not supported`);
+}
+function writeWorkflowSourceMetadata(workflowDir, metadata) {
+  fs8.mkdirSync(workflowDir, { recursive: true });
+  fs8.writeFileSync(
+    path6.join(workflowDir, "source.json"),
+    JSON.stringify({ v: 2, ...metadata }),
+    "utf-8"
+  );
+}
+
+// src/core/workflows/registry.ts
+function registryDir() {
+  return path7.join(os5.homedir(), ".config", "athena", "workflows");
+}
+function ensurePathWithinRoot(rootDir, targetPath, label) {
+  const relative = path7.relative(rootDir, targetPath);
+  if (relative === "" || !relative.startsWith("..") && !path7.isAbsolute(relative)) {
+    return;
+  }
+  throw new Error(`${label} resolves outside the workflow root: ${targetPath}`);
+}
+function resolveWorkflow(name) {
+  const workflowDir = path7.join(registryDir(), name);
+  const workflowPath = path7.join(workflowDir, "workflow.json");
+  if (!fs9.existsSync(workflowPath)) {
+    const builtin = resolveBuiltinWorkflow(name);
+    if (builtin) {
+      return builtin;
+    }
+    throw new Error(
+      `Workflow "${name}" not found. Install with: athena workflow install <source> --name ${name}`
+    );
+  }
+  const source = readWorkflowSourceMetadata(workflowDir);
+  const raw = JSON.parse(fs9.readFileSync(workflowPath, "utf-8"));
+  if (!Array.isArray(raw["plugins"])) {
+    throw new Error(
+      `Invalid workflow.json: "plugins" must be an array (got ${typeof raw["plugins"]})`
+    );
+  }
+  for (const entry of raw["plugins"]) {
+    if (typeof entry === "string") {
+      if (isMarketplaceRef(entry.trim())) {
+        continue;
+      }
+      throw new Error(
+        `Invalid workflow.json: each plugin must be a valid marketplace ref string or {ref, version} object`
+      );
+    }
+    if (typeof entry === "object" && entry !== null) {
+      const r = entry["ref"];
+      const v = entry["version"];
+      if (typeof r === "string" && isMarketplaceRef(r.trim()) && r.trim().length > 0 && typeof v === "string" && v.trim().length > 0) {
+        continue;
+      }
+    }
+    throw new Error(
+      `Invalid workflow.json: each plugin must be a valid marketplace ref string or {ref, version} object`
+    );
+  }
+  if (typeof raw["promptTemplate"] !== "string") {
+    throw new Error(`Invalid workflow.json: "promptTemplate" must be a string`);
+  }
+  if (raw["examplePrompts"] !== void 0 && (!Array.isArray(raw["examplePrompts"]) || !raw["examplePrompts"].every((e) => typeof e === "string"))) {
+    throw new Error(
+      `Invalid workflow.json: "examplePrompts" must be an array of strings`
+    );
+  }
+  if (typeof raw["workflowFile"] !== "string" || raw["workflowFile"].length === 0) {
+    throw new Error(
+      'Invalid workflow.json: "workflowFile" is required and must point to the workflow instructions file'
+    );
+  }
+  const workflowFile = raw["workflowFile"];
+  if (typeof workflowFile === "string" && !path7.isAbsolute(workflowFile)) {
+    const workflowFilePath = path7.resolve(workflowDir, workflowFile);
+    if (!fs9.existsSync(workflowFilePath)) {
+      throw new Error(
+        `Invalid workflow.json: workflowFile "${workflowFile}" not found at ${workflowFilePath}`
+      );
+    }
+    raw["workflowFile"] = workflowFilePath;
+  } else if (typeof workflowFile === "string" && !fs9.existsSync(workflowFile)) {
+    throw new Error(
+      `Invalid workflow.json: workflowFile "${workflowFile}" not found`
+    );
+  }
+  return {
+    ...raw,
+    ...source ? { __source: source } : {}
+  };
+}
+function readWorkflowSource(sourcePath) {
+  const content = fs9.readFileSync(sourcePath, "utf-8");
+  return { content, workflow: JSON.parse(content) };
+}
+function copyWorkflowFiles(sourcePath, destDir) {
+  const { content, workflow } = readWorkflowSource(sourcePath);
+  const absoluteSourcePath = path7.resolve(sourcePath);
+  const sourceDir = path7.dirname(absoluteSourcePath);
+  const absoluteDestDir = path7.resolve(destDir);
+  fs9.mkdirSync(absoluteDestDir, { recursive: true });
+  fs9.writeFileSync(
+    path7.join(absoluteDestDir, "workflow.json"),
+    content,
+    "utf-8"
+  );
+  const copyRelativeAsset = (assetPath) => {
+    if (!assetPath || path7.isAbsolute(assetPath)) return;
+    const sourceAssetPath = path7.resolve(sourceDir, assetPath);
+    ensurePathWithinRoot(sourceDir, sourceAssetPath, "Workflow asset");
+    if (!fs9.existsSync(sourceAssetPath)) return;
+    const destAssetPath = path7.resolve(absoluteDestDir, assetPath);
+    ensurePathWithinRoot(absoluteDestDir, destAssetPath, "Workflow asset");
+    fs9.mkdirSync(path7.dirname(destAssetPath), { recursive: true });
+    fs9.copyFileSync(sourceAssetPath, destAssetPath);
+  };
+  const rawWorkflow = workflow;
+  const promptAsset = rawWorkflow["workflowFile"];
+  if (typeof promptAsset !== "string" || promptAsset.length === 0) {
+    throw new Error(
+      'Invalid workflow.json: "workflowFile" is required and must point to the workflow instructions file'
+    );
+  }
+  copyRelativeAsset(promptAsset);
+}
+function toStoredMetadata(source) {
+  if (source.kind === "marketplace-remote") {
+    return {
+      kind: "marketplace-remote",
+      ref: source.ref,
+      ...source.version ? { version: source.version } : {}
+    };
+  }
+  if (source.kind === "marketplace-local") {
+    return {
+      kind: "marketplace-local",
+      repoDir: source.repoDir,
+      workflowName: source.workflowName,
+      ...source.version ? { version: source.version } : {}
+    };
+  }
+  return { kind: "filesystem", path: source.workflowPath };
+}
+function installWorkflowFromSource(source, name) {
+  const { workflow } = readWorkflowSource(source.workflowPath);
+  const workflowName = name ?? workflow.name;
+  if (!workflowName) {
+    throw new Error(
+      'Workflow has no "name" field. Provide --name to specify one.'
+    );
+  }
+  const destDir = path7.join(registryDir(), workflowName);
+  copyWorkflowFiles(source.workflowPath, destDir);
+  const metadata = toStoredMetadata(source);
+  writeWorkflowSourceMetadata(destDir, metadata);
+  return workflowName;
+}
+function reResolveFromMetadata(metadata) {
+  if (metadata.kind === "marketplace-remote") {
+    const slug = metadata.ref.slice(metadata.ref.indexOf("@") + 1);
+    const slashIdx = slug.indexOf("/");
+    const owner = slug.slice(0, slashIdx);
+    const repo = slug.slice(slashIdx + 1);
+    try {
+      pullMarketplaceRepo(owner, repo);
+    } catch (error) {
+      if (!(error instanceof Error) || !error.message.includes("is not cached")) {
+        throw error;
+      }
+    }
+    return resolveWorkflowInstall(metadata.ref, []);
+  }
+  if (metadata.kind === "marketplace-local") {
+    const manifestPath = resolveWorkflowManifestPath(metadata.repoDir);
+    const listings = listMarketplaceWorkflowsFromRepo(metadata.repoDir);
+    const entry = listings.find((l) => l.name === metadata.workflowName);
+    if (!entry) {
+      throw new Error(
+        `Workflow "${metadata.workflowName}" is no longer in the local marketplace at ${metadata.repoDir}.`
+      );
+    }
+    return {
+      kind: "marketplace-local",
+      repoDir: metadata.repoDir,
+      workflowName: metadata.workflowName,
+      ...entry.version ? { version: entry.version } : {},
+      manifestPath,
+      workflowPath: entry.workflowPath
+    };
+  }
+  return { kind: "filesystem", workflowPath: metadata.path };
+}
+function updateWorkflow(name) {
+  const workflowDir = path7.join(registryDir(), name);
+  const metadata = readWorkflowSourceMetadata(workflowDir);
+  if (!metadata) {
+    throw new Error(
+      `Workflow "${name}" has no recorded source. Reinstall it with: athena-flow workflow install <source>`
+    );
+  }
+  const source = reResolveFromMetadata(metadata);
+  const installedName = installWorkflowFromSource(source, name);
+  refreshPinnedWorkflowPlugins(resolveWorkflow(installedName));
+  return installedName;
+}
+function listWorkflows() {
+  const dir = registryDir();
+  const installed = fs9.existsSync(dir) ? fs9.readdirSync(dir, { withFileTypes: true }).filter(
+    (entry) => entry.isDirectory() && fs9.existsSync(path7.join(dir, entry.name, "workflow.json"))
+  ).map((entry) => entry.name) : [];
+  const builtins = listBuiltinWorkflows().filter(
+    (name) => !installed.includes(name)
+  );
+  return [...builtins, ...installed];
+}
+function removeWorkflow(name) {
+  const dir = path7.join(registryDir(), name);
+  if (!fs9.existsSync(dir)) {
+    throw new Error(`Workflow "${name}" not found.`);
+  }
+  fs9.rmSync(dir, { recursive: true, force: true });
+}
+
+// src/core/workflows/applyWorkflow.ts
+function applyPromptTemplate(template, input, ctx) {
+  return substituteVariables(template, { input, ...ctx });
+}
+
+// src/core/workflows/plan.ts
+function compileWorkflowPlan(input) {
+  if (!input.workflow) {
+    return void 0;
+  }
+  const resolved = !input.resolvedPlugins && (!input.localPlugins || !input.codexPlugins) ? resolveWorkflowPlugins(input.workflow) : void 0;
+  const resolvedPlugins = input.resolvedPlugins ?? resolved?.resolvedPlugins ?? [];
+  const localPlugins = input.localPlugins ?? resolved?.localPlugins ?? [];
+  const codexPlugins = input.codexPlugins ?? resolved?.codexPlugins ?? [];
+  return {
+    workflow: input.workflow,
+    resolvedPlugins: resolvedPlugins.filter(
+      (plugin, index, array) => array.findIndex((candidate) => candidate.ref === plugin.ref) === index
+    ),
+    localPlugins: localPlugins.filter(
+      (plugin, index, array) => array.findIndex((candidate) => candidate.ref === plugin.ref) === index
+    ),
+    agentRoots: resolvedPlugins.map((plugin) => `${plugin.claudeArtifactDir}/agents`).filter((root, index, array) => array.indexOf(root) === index),
+    codexPlugins: codexPlugins.filter(
+      (target, index, array) => array.findIndex((candidate) => candidate.ref === target.ref) === index
+    ),
+    pluginMcpConfig: input.pluginMcpConfig
+  };
+}
+
+// src/core/workflows/sessionPlan.ts
+import fs10 from "fs";
+import path8 from "path";
+
+// src/core/workflows/stateMachine.md
+var stateMachine_default = "# Stateless Session Protocol\n\nYou operate in stateless sessions managed by a workflow runner. Each session is a fresh process with no memory of prior sessions. The **tracker file** is your only continuity \u2014 it's how you talk to your future self.\n\n## Execution Model\n\nThe runner spawns `claude -p` sessions in a loop:\n\n- **Session 1**: You receive the user's original request.\n- **Sessions 2+**: You receive a continuation prompt directing you to read the tracker.\n- **Between sessions**: The runner inspects the tracker for terminal markers. If found, or if the max iteration cap is reached, the loop ends. The tracker is preserved for resume, audit, and debugging.\n\n### Terminal Markers\n\nBy default, workflows use these tracker markers:\n\n- `<!-- WORKFLOW_COMPLETE -->`\n- `<!-- WORKFLOW_BLOCKED -->`\n- `<!-- WORKFLOW_BLOCKED: reason -->`\n\nWorkflows may override the default marker strings via configuration. Use the markers configured for the current workflow.\n\nRules:\n\n- Only the last non-empty line of the tracker is treated as authoritative\n- Marker-like text earlier in the tracker, including notes, examples, or quoted instructions, is ignored\n- Write `WORKFLOW_COMPLETE` only when the workflow's completion criteria have been fully verified\n- Write `WORKFLOW_BLOCKED` only when progress cannot continue in the current workflow without external intervention or a workflow-defined stop condition has been reached\n- Include a concrete reason after the colon whenever possible, but `<!-- WORKFLOW_BLOCKED -->` without a reason is still valid\n\n### Tracker Path\n\nBy default, the tracker file lives at `.athena/<session_id>/tracker.md` in the project root, where `<session_id>` is the current Athena session ID. This session-scoped path allows multiple workflows to run concurrently and makes resume reliable. The runner provides the session ID \u2014 do not generate one yourself.\n\nWorkflows may override the default tracker path via configuration. Read and write the tracker at the configured path for the current workflow.\n\n**Assume interruption.** Your context window can reset at any moment \u2014 the runner may kill a session that's taking too long, or you may hit token limits mid-task. Any progress not written to the tracker is gone. This isn't a theoretical risk; it's the normal operating mode.\n\n## Session Protocol\n\nEvery session follows four phases: **Read**, **Orient**, **Execute**, **End**.\n\n### Phase 1 \u2014 Read the Tracker\n\nRead the tracker file at the configured tracker path for the current workflow. By default this is `.athena/<session_id>/tracker.md`.\n\n- **Contains `<!-- TRACKER_SKELETON -->`**: This is session 1. The runner created a skeleton tracker with the goal and session metadata. Proceed to Phase 2 (Orient) \u2014 replace the skeleton with a real tracker. **You must do this even if the entire request can be satisfied in a single turn.** Write a minimal tracker (what was asked, what was done, the outcome) and then append `<!-- WORKFLOW_COMPLETE -->`. Leaving the skeleton in place causes the runner to classify the session as a failure.\n- **Otherwise**: This is a continuation session. The tracker contains everything prior sessions learned and decided. Skip to Phase 3 (Execute) using the tracker's context.\n\nWhy read first: without the tracker, you'll duplicate work already done or contradict decisions made in prior sessions. The tracker is the single source of truth across sessions.\n\n### Phase 2 \u2014 Orient (Session 1 Only)\n\n#### 2a. Create the tracker immediately\n\nWrite a skeleton tracker as your first write operation, before doing any domain work. Even a minimal tracker with just the goal and \"orientation in progress\" provides continuity if the session is interrupted during setup.\n\nThe tracker must always answer four questions for any future session:\n\n1. What are we trying to accomplish?\n2. What has been completed so far?\n3. What work is left?\n4. What should the next session do first?\n\nThese answers are the contract between sessions. The exact section headings may vary by workflow, but the tracker must make all four answers explicit and easy to find. A future session reading this tracker has no other context \u2014 if something isn't here, it doesn't exist.\n\n#### 2b. Workflow-specific orientation\n\nExecute the orientation steps defined by the workflow. These vary by domain \u2014 a test-writing workflow explores the product in a browser; a migration workflow audits the database schema. The workflow defines what orientation means.\n\n#### 2c. Create a task plan\n\nRefine the skeleton tracker into granular, verifiable checkpoints based on what orientation revealed. Each task should be a concrete unit of progress, not a vague phase. Include verification steps (running checks, reviewing output), not just implementation. Vague tasks like \"write tests\" can't be meaningfully resumed by a future session that has no idea what \"write tests\" means in this context.\n\n#### 2d. Update the tracker\n\nAfter orientation, ensure the tracker captures: the goal, what was discovered, what's planned, and what the next session should do first. Record concrete observations \u2014 what you actually saw, not what you assumed. Assumptions that turn out wrong waste entire future sessions on rework.\n\n### Phase 3 \u2014 Execute\n\nWork through tasks, advancing the plan step by step.\n\n#### Load skills before acting\n\nIf the workflow defines a skill table, load the relevant skill before each activity. Skills carry implementation details \u2014 scaffolding steps, authentication strategies, locator rules, anti-patterns, code templates \u2014 that would otherwise be lost between sessions. This prompt defines the protocol; skills define how to execute each step.\n\n#### Follow the workflow's sequence\n\nExecute in the order the workflow prescribes. Not every session covers all steps \u2014 pick up where the tracker says rather than restarting the flow.\n\n#### Delegate heavy work\n\nUse subagents via the Task tool to offload heavy exploration or generation, preserving your main context for orchestration. Pass file paths, conventions, and concrete output expectations. Instruct subagents to load the appropriate skill.\n\nRespect the workflow's **delegation constraints** \u2014 some operations must run in the main agent because their output serves as proof or because the main agent needs to interpret results in context.\n\n#### Execute quality gates\n\nIf the workflow defines quality gates, execute them in order. Do not skip gates \u2014 they exist because prior experience showed that skipping them leads to cascading rework. If a gate returns a failing verdict, address the issues and re-run the gate before proceeding.\n\nRespect the workflow's **retry limits** for failing steps. Repeated failures usually signal a deeper issue that another retry won't fix.\n\n#### Update the tracker as you work\n\nTreat tracker updates as defensive checkpoints against three failure modes: the runner killing your session, your context collapsing under tool-output load, and you simply forgetting an hour from now what you just learned. The right cadence sits between \"every tool call\" (noisy, wastes tokens, turns the tracker into a log) and \"at the end of the session\" (everything is lost if you die mid-task).\n\nUpdate the tracker whenever any of the following happens \u2014 these are the checkpoints, not \"felt like a good moment\":\n\n- **You finished a discrete unit of work.** A file written, a fix applied, a test run, a quality gate passed. The tracker should reflect the new reality before you start the next unit, not after several units have piled up.\n- **You learned something a future session can't cheaply rederive.** An API quirk, a config field that turned out to matter, a dead end you've now ruled out, a decision between two approaches. Insights are tracker-worthy even when no code changed \u2014 losing them costs the next session a full re-exploration. The tracker is your knowledge ledger, not just a task log.\n- **You're about to do something risky or long-running.** Dispatching a subagent, kicking off a long build, calling a flaky external service, starting a large refactor. If that operation kills your session, only what's already in the tracker survives. Write first, then act.\n- **Your plan changed.** A task got resequenced, a new task surfaced, a planned task turned out to be unnecessary. Stale plans poison continuation sessions \u2014 the tracker must reflect what you'll actually do next, not what you thought five steps ago.\n- **You've been working a while without writing.** If you can't remember when you last touched the tracker, you've gone too long. A short defensive update (\"currently doing X, last completed Y, next is Z\") beats nothing.\n\nWhat an update contains depends on the trigger, but always cover: what changed (work or knowledge), what's now next, and any caveat the next session needs to know. Avoid transcribing tool calls \u2014 the tracker is a contract with your future self, not a replay log.\n\nThe cost of one extra tracker update is a few tokens. The cost of dying without one is a whole wasted session rediscovering what you already knew. Bias toward writing.\n\n#### Task visibility\n\nThe tracker contains the authoritative task plan \u2014 it persists across sessions. Your harness's task UI is only a live projection of that plan, visible to the user in their CLI widget. It is session-scoped and does not survive process exit.\n\n**The relationship:** tracker is the source of truth, task tools are the display.\n\n{{TASK_TOOL_INSTRUCTIONS}}\n\n- **Session 1 (Orient):** After creating the task plan in the tracker, project each task into the task management tools so the user can see progress in real time.\n- **Session 2+ (Resume):** After reading the tracker, recreate the task projection from the tracker's plan. Set statuses to match what the tracker says is done, remaining, and next. The user sees consistent progress across sessions.\n- **During work:** Update both \u2014 the task tools for immediate UI feedback, the tracker for persistence. When a task completes, mark it done in the task tools and record it in the tracker in the same working phase.\n\nThis gives the user a consistent view of progress in their CLI regardless of which session they're in, while the tracker remains the durable contract between sessions.\n\n### Phase 4 \u2014 End of Session\n\n1. Ensure the tracker reflects all progress, discoveries, and blockers.\n2. Write clear instructions for what the next session should do first.\n3. If all work is complete and verified: write `<!-- WORKFLOW_COMPLETE -->` at the end of the tracker.\n4. If an unrecoverable blocker prevents progress: write `<!-- WORKFLOW_BLOCKED -->` or `<!-- WORKFLOW_BLOCKED: reason -->` at the end of the tracker.\n\nDo not write terminal markers prematurely. The runner trusts markers unconditionally \u2014 a premature marker kills the loop before work is done, and there's no automatic recovery.\n\n## Session Bounding\n\nEach fresh session starts with a clean context window and a compact tracker \u2014 effectively a self-compaction. As you work, your context fills with tool outputs, exploration results, and intermediate state. The longer you run, the more attention is spread across tokens that are no longer relevant, degrading your precision on the work that matters now.\n\nWork on a bounded chunk per session. Ending early and letting the next session pick up from a clean tracker is almost always better than pushing through with a heavy context.\n\nHeuristics for when to checkpoint and end:\n\n- After completing a quality gate \u2014 natural boundary\n- After crossing multiple phases (e.g., explored + planned + wrote specs) \u2014 stop before pushing into the next\n- When you notice your context is heavy with tool outputs from earlier work\n\n## Guardrails\n\nQuick-reference checklist \u2014 each of these is explained in detail above:\n\n- Read the tracker before doing anything else\n- Replace the skeleton immediately \u2014 even for simple requests. Write minimal tracker content (what was asked, what was done, outcome) and then the terminal marker before the session ends.\n- Update the tracker on concrete triggers (unit of work done, insight learned, risky operation pending, plan changed) \u2014 not on a vague sense of \"meaningful progress\"\n- Project the tracker's task plan into task management tools at session start\n- Update both task tools and tracker as milestones complete\n- Load the relevant skill before each activity\n- Do not write the completion marker until all work is verified\n- Respect the workflow's delegation constraints and retry limits\n";
+
+// src/core/workflows/stateMachine.ts
+function buildTaskToolInstructions(harness) {
+  switch (harness) {
+    case "openai-codex":
+      return `Use the \`update_plan\` tool to create and maintain the task list shown to the user for the full harness session.
+
+- As soon as orientation yields a credible plan, create a detailed task list from the tracker; each item should be a concrete, verifiable unit of work, not a vague phase
+- At the start of every fresh harness session, recreate the full task list from the tracker before resuming execution
+- Do not carry forward prior session task IDs or assume prior session plan items still exist in the tool
+- Keep the task list accurate throughout the session: when scope, ordering, status, or completion changes, update \`update_plan\` immediately in the same working phase as the tracker
+- Keep task state consistent and non-stale: reconcile the task list against the tracker before moving on, and before ending the session
+- Maintain exactly one \`in_progress\` task unless the tracker explicitly records parallel active work`;
+    case "claude-code":
+    case "opencode":
+    default:
+      return `Use \`TaskCreate\` and \`TaskUpdate\` to create and maintain the task list shown to the user for the full harness session.
+
+- As soon as orientation yields a credible plan, create a detailed task list from the tracker; each item should be a concrete, verifiable unit of work, not a vague phase
+- At the start of every fresh harness session, recreate the full task list from the tracker instead of trying to resume prior session task IDs
+- Do not refer to task IDs created in earlier sessions; they are session-scoped UI artifacts, not durable workflow state
+- Keep the task list accurate throughout the session: when scope, ordering, status, or completion changes, update the task list in the same working phase as the tracker
+- Keep task state consistent and non-stale: reconcile the task list against the tracker before moving on, and before ending the session
+- Maintain exactly one active task unless the tracker explicitly records parallel active work`;
+  }
+}
+function buildStateMachineContent(harness = "claude-code") {
+  return stateMachine_default.replace(
+    "{{TASK_TOOL_INSTRUCTIONS}}",
+    buildTaskToolInstructions(harness)
+  );
+}
+var STATE_MACHINE_CONTENT = buildStateMachineContent();
+
+// src/core/workflows/sessionPlan.ts
+function readWorkflowOverride(projectDir, workflow, sessionId, trackerPath, harness = "claude-code") {
+  if (!workflow?.workflowFile) {
+    return { workflowOverride: void 0, warnings: [] };
+  }
+  const resolvedPath = path8.isAbsolute(workflow.workflowFile) ? workflow.workflowFile : path8.resolve(projectDir, workflow.workflowFile);
+  let workflowContent;
+  try {
+    workflowContent = fs10.readFileSync(resolvedPath, "utf-8");
+  } catch {
+    return {
+      workflowOverride: void 0,
+      warnings: [
+        `Workflow file not found: ${workflow.workflowFile}. Continuing without workflow system instructions.`
+      ]
+    };
+  }
+  let composed = workflow.loop?.enabled ? buildStateMachineContent(harness) + "\n\n" + workflowContent : workflowContent;
+  composed = substituteVariables(composed, {
+    sessionId,
+    trackerPath: trackerPath ?? void 0
+  });
+  const workflowDir = path8.dirname(resolvedPath);
+  const composedPath = path8.join(workflowDir, ".composed-system-prompt.md");
+  fs10.writeFileSync(composedPath, composed, "utf-8");
+  return {
+    workflowOverride: {
+      appendSystemPromptFile: composedPath,
+      developerInstructions: composed
+    },
+    warnings: []
+  };
+}
+function mergeOverrides(base, workflowOverride) {
+  if (!base) return workflowOverride;
+  if (!workflowOverride) return base;
+  return {
+    ...base,
+    ...workflowOverride
+  };
+}
+function resolveTrackerPath(input) {
+  const loop = input.workflow?.loop;
+  if (!loop?.enabled) {
+    return null;
+  }
+  const rawPath = loop.trackerPath ?? DEFAULT_TRACKER_PATH;
+  if (!input.sessionId && rawPath.includes("{sessionId}")) {
+    return null;
+  }
+  const promptPath = input.sessionId ? rawPath.replaceAll("{sessionId}", input.sessionId) : rawPath;
+  const absolutePath = path8.isAbsolute(promptPath) ? promptPath : path8.resolve(input.projectDir, promptPath);
+  return {
+    absolutePath,
+    promptPath
+  };
+}
+function createWorkflowRunState(input) {
+  const { projectDir, sessionId, workflow, harness } = input;
+  const trackerResolved = resolveTrackerPath({ projectDir, sessionId, workflow });
+  const loopManager = workflow?.loop?.enabled === true && trackerResolved ? createLoopManager(trackerResolved.absolutePath, workflow.loop) : null;
+  const { workflowOverride, warnings } = readWorkflowOverride(
+    projectDir,
+    workflow,
+    sessionId,
+    trackerResolved?.promptPath,
+    harness
+  );
+  return {
+    workflow,
+    loopManager,
+    trackerPathForPrompt: trackerResolved?.promptPath,
+    workflowOverride,
+    warnings
+  };
+}
+function prepareWorkflowTurn(state, input) {
+  const { workflow, loopManager } = state;
+  const prompt = workflow && loopManager && loopManager.getState().iteration > 0 ? buildContinuePrompt({
+    ...workflow.loop,
+    trackerPath: state.trackerPathForPrompt ?? workflow.loop?.trackerPath
+  }) : workflow ? applyPromptTemplate(workflow.promptTemplate, input.prompt) : input.prompt;
+  return {
+    prompt,
+    configOverride: mergeOverrides(
+      input.configOverride,
+      state.workflowOverride
+    ),
+    warnings: state.warnings
+  };
+}
+function shouldContinueWorkflowRun(state) {
+  const { workflow, loopManager } = state;
+  if (!workflow?.loop?.enabled || !loopManager) {
+    return null;
+  }
+  const loopState = loopManager.getState();
+  if (!fs10.existsSync(loopManager.trackerPath)) {
+    cleanupWorkflowRun(state);
+    return {
+      reason: "missing_tracker",
+      maxIterations: loopState.maxIterations
+    };
+  }
+  if (loopState.skeletonNotReplaced) {
+    cleanupWorkflowRun(state);
+    return {
+      reason: "skeleton_not_replaced",
+      maxIterations: loopState.maxIterations
+    };
+  }
+  let reason;
+  if (loopState.completed) {
+    reason = "completed";
+  } else if (loopState.blocked) {
+    reason = "blocked";
+  } else if (loopState.iteration + 1 >= loopState.maxIterations) {
+    reason = "max_iterations";
+  }
+  if (reason) {
+    cleanupWorkflowRun(state);
+    return {
+      reason,
+      blockedReason: loopState.blockedReason,
+      maxIterations: loopState.maxIterations
+    };
+  }
+  loopManager.incrementIteration();
+  return null;
+}
+function cleanupWorkflowRun(state) {
+  if (!state.loopManager) {
+    return;
+  }
+  state.loopManager.deactivate();
+  state.loopManager = null;
+}
+
+// src/core/workflows/useWorkflowSessionController.ts
+import { useCallback as useCallback2, useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
+
+// src/core/workflows/workflowRunner.ts
+import crypto from "crypto";
+import fs11 from "fs";
+import path9 from "path";
+var NULL_TOKENS = {
+  input: null,
+  output: null,
+  cacheRead: null,
+  cacheWrite: null,
+  total: null,
+  contextSize: null,
+  contextWindowSize: null
+};
+var TRACKER_SKELETON_TEMPLATE = `${TRACKER_SKELETON_MARKER}
+# Workflow Tracker
+
+**Session**: {sessionId}
+**Tracker**: {trackerPath}
+**Goal**: {input}
+
+---
+
+> This tracker was created by the runner. Update it as you work.
+> See the Stateless Session Protocol for tracker conventions.
+
+## Status
+
+Orientation in progress.
+
+## Plan
+
+_To be created during orientation._
+
+## Progress
+
+_No progress yet._
+`;
+function mergeTokens(base, next) {
+  const input = (base.input ?? 0) + (next.input ?? 0);
+  const output = (base.output ?? 0) + (next.output ?? 0);
+  const cacheRead = (base.cacheRead ?? 0) + (next.cacheRead ?? 0);
+  const cacheWrite = (base.cacheWrite ?? 0) + (next.cacheWrite ?? 0);
+  const hasAny = base.input !== null || next.input !== null || base.output !== null || next.output !== null || base.cacheRead !== null || next.cacheRead !== null || base.cacheWrite !== null || next.cacheWrite !== null;
+  if (!hasAny)
+    return {
+      ...NULL_TOKENS,
+      contextSize: next.contextSize,
+      contextWindowSize: next.contextWindowSize
+    };
+  return {
+    input,
+    output,
+    cacheRead,
+    cacheWrite,
+    total: input + output + cacheRead + cacheWrite,
+    contextSize: next.contextSize ?? base.contextSize,
+    contextWindowSize: next.contextWindowSize ?? base.contextWindowSize
+  };
+}
+function defaultCreateTracker(trackerPath, content) {
+  fs11.mkdirSync(path9.dirname(trackerPath), { recursive: true });
+  try {
+    fs11.writeFileSync(trackerPath, content, { encoding: "utf-8", flag: "wx" });
+  } catch (e) {
+    if (e.code !== "EEXIST") throw e;
+  }
+}
+function createWorkflowRunner(input) {
+  const runId = crypto.randomUUID();
+  let cancelled = false;
+  let status = "running";
+  let iterations = 0;
+  let cumulativeTokens = { ...NULL_TOKENS };
+  let stopReason;
+  const trackerResolved = resolveTrackerPath({
+    projectDir: input.projectDir,
+    sessionId: input.sessionId,
+    workflow: input.workflow
+  });
+  const trackerAbsPath = trackerResolved?.absolutePath ?? null;
+  const trackerPromptPath = trackerResolved?.promptPath;
+  function snapshot() {
+    return {
+      runId,
+      sessionId: input.sessionId,
+      workflowName: input.workflow?.name,
+      iteration: iterations,
+      maxIterations: input.workflow?.loop?.maxIterations ?? 1,
+      status,
+      stopReason,
+      trackerPath: trackerPromptPath
+    };
+  }
+  function persist() {
+    try {
+      input.persistRunState(snapshot());
+    } catch {
+    }
+  }
+  const result = (async () => {
+    await Promise.resolve();
+    if (trackerAbsPath && input.workflow?.loop?.enabled) {
+      const content = substituteVariables(TRACKER_SKELETON_TEMPLATE, {
+        sessionId: input.sessionId,
+        trackerPath: trackerPromptPath,
+        input: input.prompt
+      });
+      const write = input.createTracker ?? defaultCreateTracker;
+      write(trackerAbsPath, content);
+    }
+    persist();
+    const workflowState = createWorkflowRunState({
+      projectDir: input.projectDir,
+      sessionId: input.sessionId,
+      workflow: input.workflow,
+      harness: input.harness
+    });
+    let nextContinuation = input.initialContinuation ?? {
+      mode: "fresh"
+    };
+    try {
+      while (!cancelled) {
+        iterations++;
+        const prepared = prepareWorkflowTurn(workflowState, {
+          prompt: input.prompt,
+          configOverride: void 0
+        });
+        const turnResult = await input.startTurn({
+          prompt: prepared.prompt,
+          continuation: nextContinuation,
+          configOverride: prepared.configOverride
+        });
+        if (cancelled) {
+          status = "cancelled";
+          persist();
+          break;
+        }
+        cumulativeTokens = mergeTokens(cumulativeTokens, turnResult.tokens);
+        if (turnResult.error || turnResult.exitCode !== null && turnResult.exitCode !== 0) {
+          status = "failed";
+          const parts = [];
+          if (turnResult.error?.message) {
+            parts.push(turnResult.error.message);
+          } else if (turnResult.exitCode !== null) {
+            parts.push(`Process exited with code ${turnResult.exitCode}`);
+          }
+          if (turnResult.lastStderr) {
+            parts.push(turnResult.lastStderr);
+          }
+          stopReason = parts.join(": ") || "Turn failed";
+          persist();
+          break;
+        }
+        const transport = turnResult.diagnostics?.transport;
+        if (transport && transport.streamToolUses > 0 && transport.preToolUseEvents === 0) {
+          status = "failed";
+          stopReason = `Hook transport broken: observed ${transport.streamToolUses} tool use(s) in Claude stream but received no PreToolUse events.`;
+          persist();
+          break;
+        }
+        if (!input.workflow?.loop?.enabled) {
+          status = "completed";
+          persist();
+          break;
+        }
+        const loopStop = shouldContinueWorkflowRun(workflowState);
+        if (loopStop) {
+          if (loopStop.reason === "completed") {
+            status = "completed";
+          } else if (loopStop.reason === "blocked") {
+            status = "blocked";
+            stopReason = loopStop.blockedReason;
+          } else if (loopStop.reason === "max_iterations") {
+            status = "exhausted";
+          } else if (loopStop.reason === "skeleton_not_replaced") {
+            status = "failed";
+            stopReason = "Agent did not replace the tracker skeleton. The session completed without engaging with the workflow tracker.";
+          } else {
+            status = "failed";
+            stopReason = `Loop stopped: ${loopStop.reason}`;
+          }
+          persist();
+          break;
+        }
+        persist();
+        input.onIterationComplete?.(snapshot());
+        nextContinuation = { mode: "fresh" };
+      }
+      if (cancelled && status === "running") {
+        status = "cancelled";
+        persist();
+      }
+    } finally {
+      cleanupWorkflowRun(workflowState);
+    }
+    return {
+      runId,
+      status,
+      iterations,
+      stopReason,
+      tokens: cumulativeTokens
+    };
+  })();
+  return {
+    runId,
+    result,
+    cancel() {
+      cancelled = true;
+    },
+    kill() {
+      cancelled = true;
+      input.abortCurrentTurn?.();
+    }
+  };
+}
+
+// src/core/workflows/useWorkflowSessionController.ts
+function useWorkflowSessionController(base, input) {
+  const [isRunning, setIsRunning] = useState3(false);
+  const runnerRef = useRef3(null);
+  const activeRunIdRef = useRef3(null);
+  const cancelCurrentRun = useCallback2(async () => {
+    const runner = runnerRef.current;
+    if (runner) {
+      runner.kill();
+      await runner.result.catch(() => {
+      });
+      runnerRef.current = null;
+      activeRunIdRef.current = null;
+    }
+  }, []);
+  const interrupt = useCallback2(() => {
+    const runner = runnerRef.current;
+    if (runner) {
+      runner.kill();
+      runnerRef.current = null;
+      activeRunIdRef.current = null;
+    } else {
+      void base.kill().catch(() => {
+      });
+    }
+    setIsRunning(false);
+  }, [base]);
+  const kill = useCallback2(async () => {
+    if (runnerRef.current) {
+      await cancelCurrentRun();
+    } else {
+      await base.kill();
+    }
+    setIsRunning(false);
+  }, [base, cancelCurrentRun]);
+  const spawn = useCallback2(
+    async (prompt, continuation, _configOverride) => {
+      await cancelCurrentRun();
+      setIsRunning(true);
+      const handle = createWorkflowRunner({
+        sessionId: input.sessionId ?? "",
+        projectDir: input.projectDir,
+        harness: input.harness,
+        workflow: input.workflow,
+        prompt,
+        initialContinuation: continuation,
+        startTurn: (turnInput) => base.startTurn(
+          turnInput.prompt,
+          turnInput.continuation,
+          turnInput.configOverride
+        ),
+        persistRunState: input.persistRunState ?? (() => {
+        }),
+        abortCurrentTurn: () => void base.kill().catch(() => {
+        })
+      });
+      runnerRef.current = handle;
+      activeRunIdRef.current = handle.runId;
+      try {
+        const runResult = await handle.result;
+        return {
+          exitCode: runResult.status === "failed" ? 1 : 0,
+          error: runResult.status === "failed" ? new Error(runResult.stopReason ?? "Run failed") : null,
+          tokens: runResult.tokens,
+          streamMessage: null
+        };
+      } finally {
+        if (runnerRef.current === handle) {
+          runnerRef.current = null;
+          activeRunIdRef.current = null;
+          setIsRunning(false);
+        }
+      }
+    },
+    [
+      base,
+      cancelCurrentRun,
+      input.projectDir,
+      input.sessionId,
+      input.harness,
+      input.workflow,
+      input.persistRunState
+    ]
+  );
+  useEffect3(() => {
+    return () => {
+      runnerRef.current?.kill();
+      runnerRef.current = null;
+      activeRunIdRef.current = null;
+    };
+  }, []);
+  return {
+    ...base,
+    startTurn: spawn,
+    isRunning,
+    interrupt,
+    kill,
+    get activeRunId() {
+      return activeRunIdRef.current;
+    }
+  };
+}
+
+// src/infra/plugins/mcpOptions.ts
+import fs12 from "fs";
+import path10 from "path";
+function collectMcpServersWithOptions(pluginDirs) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const dir of pluginDirs) {
+    const mcpPath = path10.join(dir, ".mcp.json");
+    if (!fs12.existsSync(mcpPath)) {
+      continue;
+    }
+    const config = JSON.parse(fs12.readFileSync(mcpPath, "utf-8"));
+    for (const [serverName, serverConfig] of Object.entries(
+      config.mcpServers ?? {}
+    )) {
+      if (seen.has(serverName) || !Array.isArray(serverConfig.options) || serverConfig.options.length === 0) {
+        continue;
+      }
+      seen.add(serverName);
+      result.push({ serverName, options: serverConfig.options });
+    }
+  }
+  return result;
+}
+
+export {
+  darkTheme,
+  resolveTheme,
+  ThemeProvider,
+  useTheme,
+  createWorkflowRunner,
+  useWorkflowSessionController,
+  isMarketplaceRef,
+  findMarketplaceRepoDir,
+  resolveWorkflowMarketplaceSource,
+  listMarketplaceWorkflows,
+  listMarketplaceWorkflowsFromRepo,
+  resolveMarketplaceWorkflow,
+  gatherMarketplaceWorkflowSources,
+  resolveWorkflowInstall,
+  projectConfigPath,
+  readConfig,
+  resolveActiveWorkflow,
+  readGlobalConfig,
+  writeGlobalConfig,
+  writeProjectConfig,
+  hasProjectWorkflow,
+  StepSelector,
+  StepStatus,
+  McpOptionsStep,
+  installWorkflowPlugins,
+  resolveWorkflowPlugins,
+  listBuiltinWorkflows,
+  resolveWorkflow,
+  installWorkflowFromSource,
+  updateWorkflow,
+  listWorkflows,
+  removeWorkflow,
+  compileWorkflowPlan,
+  collectMcpServersWithOptions
+};
+//# sourceMappingURL=chunk-LPG5WBPV.js.map