@drisp/cli 0.5.26 → 0.6.0

package/dist/chunk-QVRTU2MM.js

@@ -0,0 +1,4009 @@
+// src/infra/plugins/workflowResolver.ts
+import fs3 from "fs";
+import path2 from "path";
+
+// src/infra/plugins/marketplaceShared.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import fs2 from "fs";
+import os from "os";
+import path from "path";
+
+// src/infra/plugins/marketplaceRefresh.ts
+import { execFileSync } from "child_process";
+import fs from "fs";
+var MarketplaceRefreshError = class extends Error {
+  kind;
+  marketplace;
+  constructor(outcome) {
+    super(outcome.message);
+    this.name = "MarketplaceRefreshError";
+    this.kind = outcome.kind;
+    this.marketplace = outcome.marketplace;
+  }
+};
+var NETWORK_OR_AUTH_SIGNATURES = [
+  "could not resolve host",
+  "could not resolve proxy",
+  "couldn\u2019t resolve host",
+  "name or service not known",
+  "temporary failure in name resolution",
+  "failed to connect",
+  "connection timed out",
+  "connection refused",
+  "connection reset",
+  "network is unreachable",
+  "network unavailable",
+  "unable to access",
+  "ssl certificate problem",
+  "gnutls_handshake",
+  "authentication failed",
+  "could not read username",
+  "could not read password",
+  "permission denied (publickey)",
+  "terminal prompts disabled",
+  "invalid username or password",
+  "403 forbidden",
+  "access denied",
+  "repository not found",
+  "remote: not found"
+];
+function classifyGitFailure(message) {
+  const haystack = message.toLowerCase();
+  for (const signature of NETWORK_OR_AUTH_SIGNATURES) {
+    if (haystack.includes(signature)) {
+      return "network-or-auth";
+    }
+  }
+  return "unrecoverable-cache";
+}
+function repoUrlFor(owner, repo) {
+  return `https://github.com/${owner}/${repo}.git`;
+}
+var GIT_STDIO = ["ignore", "ignore", "pipe"];
+function gitFailureText(error) {
+  const err = error;
+  const stderr = err.stderr == null ? "" : err.stderr.toString().trim();
+  const message = err.message ?? "";
+  return stderr ? `${message} ${stderr}`.trim() : message;
+}
+function cloneInto(repoUrl, repoDir) {
+  fs.mkdirSync(repoDir, { recursive: true });
+  try {
+    execFileSync("git", ["clone", "--depth", "1", repoUrl, repoDir], {
+      stdio: GIT_STDIO
+    });
+  } catch (error) {
+    fs.rmSync(repoDir, { recursive: true, force: true });
+    throw error;
+  }
+}
+function failureOutcome(kind, marketplace, cause, backupDir) {
+  const message = kind === "network-or-auth" ? `Could not refresh the "${marketplace}" marketplace: the remote could not be reached (connectivity or authentication problem). ${cause}` : `Could not refresh the "${marketplace}" marketplace: the cached copy is corrupt and could not be rebuilt.${backupDir ? ` Previous cache preserved at ${backupDir}.` : ""} ${cause}`;
+  return {
+    ok: false,
+    kind,
+    marketplace,
+    message,
+    cause,
+    ...backupDir ? { backupDir } : {}
+  };
+}
+function refreshMarketplaceRepo(owner, repo) {
+  const marketplace = `${owner}/${repo}`;
+  const repoDir = marketplaceRepoCacheDir(owner, repo);
+  const repoUrl = repoUrlFor(owner, repo);
+  if (!fs.existsSync(repoDir)) {
+    try {
+      cloneInto(repoUrl, repoDir);
+      return { ok: true, repoDir };
+    } catch (cloneError) {
+      const cause = gitFailureText(cloneError);
+      return failureOutcome(classifyGitFailure(cause), marketplace, cause);
+    }
+  }
+  try {
+    execFileSync("git", ["pull", "--ff-only"], {
+      cwd: repoDir,
+      stdio: GIT_STDIO
+    });
+    return { ok: true, repoDir };
+  } catch {
+    const backupDir = `${repoDir}.backup-${Date.now()}`;
+    try {
+      fs.renameSync(repoDir, backupDir);
+      cloneInto(repoUrl, repoDir);
+      return { ok: true, repoDir, selfHealed: true, backupDir };
+    } catch (recoveryError) {
+      const cause = gitFailureText(recoveryError);
+      return failureOutcome(
+        classifyGitFailure(cause),
+        marketplace,
+        cause,
+        backupDir
+      );
+    }
+  }
+}
+function ensureFailureOutcome(kind, marketplace, cause) {
+  const message = kind === "network-or-auth" ? `Could not reach the "${marketplace}" marketplace: the remote could not be reached (connectivity or authentication problem). ${cause}` : `Could not clone the "${marketplace}" marketplace: the local cache could not be created. ${cause}`;
+  return { ok: false, kind, marketplace, message, cause };
+}
+function ensureRepo(owner, repo) {
+  const repoDir = marketplaceRepoCacheDir(owner, repo);
+  if (!fs.existsSync(repoDir)) {
+    const marketplace = `${owner}/${repo}`;
+    try {
+      cloneInto(repoUrlFor(owner, repo), repoDir);
+    } catch (error) {
+      const cause = gitFailureText(error);
+      throw new MarketplaceRefreshError(
+        ensureFailureOutcome(classifyGitFailure(cause), marketplace, cause)
+      );
+    }
+  }
+  return repoDir;
+}
+
+// src/infra/plugins/marketplaceShared.ts
+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 fs2.existsSync(preferredManifestPath) ? preferredManifestPath : legacyManifestPath;
+}
+function resolveLegacyPluginManifestPath(repoDir) {
+  return path.join(repoDir, ".claude-plugin", "marketplace.json");
+}
+function readManifest(manifestPath) {
+  if (!fs2.existsSync(manifestPath)) {
+    throw new Error(`Marketplace manifest not found: ${manifestPath}`);
+  }
+  return JSON.parse(
+    fs2.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 (!fs2.existsSync(pluginDir)) {
+    throw new Error(`Plugin source directory not found: ${pluginDir}`);
+  }
+  return pluginDir;
+}
+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 (!fs2.existsSync(manifestPath)) continue;
+    try {
+      const manifest = JSON.parse(fs2.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 (!fs2.existsSync(releasePath)) {
+    return void 0;
+  }
+  try {
+    const release = JSON.parse(
+      fs2.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 (!fs2.existsSync(claudeArtifactDir) || !fs2.existsSync(resolvedCodexMarketplacePath) || !fs2.existsSync(codexPluginDir)) {
+      return void 0;
+    }
+    return {
+      claudeArtifactDir,
+      codexMarketplacePath: resolvedCodexMarketplacePath,
+      codexPluginDir
+    };
+  } catch {
+    return void 0;
+  }
+}
+function requireGitForMarketplace(kind) {
+  try {
+    execFileSync2("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}). If this workflow was recently added, run \`athena-flow marketplace refresh\` and try again.`
+    );
+    this.name = "WorkflowNotFoundError";
+    this.workflowName = workflowName;
+    this.searchedSources = searchedSources;
+  }
+};
+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;
+  }
+};
+
+// src/infra/plugins/workflowResolver.ts
+function resolveWorkflowManifestPath(repoDir) {
+  const preferred = path2.join(repoDir, ".athena-workflow", "marketplace.json");
+  const legacy = path2.join(repoDir, ".claude-plugin", "marketplace.json");
+  return fs3.existsSync(preferred) ? preferred : legacy;
+}
+function preferCanonicalWorkflowPath(repoDir, workflowPath) {
+  const relativePath = path2.relative(repoDir, workflowPath);
+  const segments = relativePath.split(path2.sep);
+  if (segments[0] !== ".workflows") return workflowPath;
+  const canonical = path2.join(repoDir, "workflows", ...segments.slice(1));
+  return fs3.existsSync(canonical) ? canonical : workflowPath;
+}
+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 && !path2.isAbsolute(sourcePath) && !sourcePath.startsWith("./") && !sourcePath.startsWith("../")) {
+    sourcePath = path2.join(workflowRoot, sourcePath);
+  }
+  const workflowPath = path2.resolve(repoDir, sourcePath);
+  if (!workflowPath.startsWith(repoDir + path2.sep) && workflowPath !== repoDir) {
+    throw new Error(
+      `Workflow "${entry.name}" source resolves outside the marketplace repo: ${workflowPath}`
+    );
+  }
+  const resolved = preferCanonicalWorkflowPath(repoDir, workflowPath);
+  if (!fs3.existsSync(resolved)) {
+    throw new Error(`Workflow source not found: ${resolved}`);
+  }
+  return resolved;
+}
+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 findMarketplaceRepoDir(startPath) {
+  let currentDir = path2.resolve(startPath);
+  for (; ; ) {
+    if (fs3.existsSync(resolveWorkflowManifestPath(currentDir)) || fs3.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 (!fs3.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)
+  );
+}
+function gatherMarketplaceWorkflowSources(source) {
+  const trimmed = source.trim();
+  const resolvedPath = path2.resolve(trimmed);
+  if (fs3.existsSync(resolvedPath) && fs3.statSync(resolvedPath).isFile()) {
+    return [{ kind: "filesystem", workflowPath: fs3.realpathSync(resolvedPath) }];
+  }
+  if (!fs3.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 = fs3.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 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 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 (fs3.existsSync(resolvedPath) && fs3.statSync(resolvedPath).isFile()) {
+    return { kind: "filesystem", workflowPath: fs3.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/versionedPluginResolution.ts
+import { execFileSync as execFileSync3 } from "child_process";
+import fs4 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 fs4.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 (fs4.existsSync(destDir)) {
+    return destDir;
+  }
+  const cacheBase = versionedPluginCacheDir();
+  fs4.mkdirSync(cacheBase, { recursive: true });
+  const tmpDir = fs4.mkdtempSync(path3.join(cacheBase, ".tmp-"));
+  try {
+    const tarball = execFileSync3(
+      "npm",
+      ["pack", `${npmPkg}@${version}`, "--pack-destination", tmpDir],
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    const tarballPath = path3.join(tmpDir, tarball);
+    if (!fs4.existsSync(tarballPath)) {
+      throw new Error(`npm pack did not produce expected tarball: ${tarball}`);
+    }
+    const extractDir = path3.join(tmpDir, "extracted");
+    fs4.mkdirSync(extractDir, { recursive: true });
+    execFileSync3("tar", ["xzf", tarballPath, "-C", extractDir], {
+      stdio: "ignore"
+    });
+    const packageDir = path3.join(extractDir, "package");
+    if (!fs4.existsSync(packageDir)) {
+      throw new Error(
+        "Extracted tarball does not contain a package/ directory"
+      );
+    }
+    fs4.mkdirSync(path3.dirname(destDir), { recursive: true });
+    try {
+      fs4.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") && fs4.existsSync(destDir)) {
+        return destDir;
+      }
+      throw error;
+    }
+    return destDir;
+  } finally {
+    fs4.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 (!fs4.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 = fs4.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 outcome = refreshMarketplaceRepo(owner, repo);
+  if (!outcome.ok) {
+    throw new MarketplaceRefreshError(outcome);
+  }
+}
+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: [] };
+var STALE_CONFIG_KEYS = ["channels"];
+var warnedStaleKeys = /* @__PURE__ */ new Set();
+function warnStaleKeys(configPath, raw) {
+  for (const key of STALE_CONFIG_KEYS) {
+    if (!(key in raw)) continue;
+    const dedupeKey = `${configPath}\0${key}`;
+    if (warnedStaleKeys.has(dedupeKey)) continue;
+    warnedStaleKeys.add(dedupeKey);
+    console.error(
+      `Warning: ignoring unsupported config key "${key}" in ${configPath} (channels were removed; delete the key to silence this)`
+    );
+  }
+}
+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"));
+  warnStaleKeys(configPath, raw);
+  if (raw.permissionGraceMs !== void 0 && (typeof raw.permissionGraceMs !== "number" || !Number.isFinite(raw.permissionGraceMs) || raw.permissionGraceMs < 0)) {
+    throw new Error(
+      `Invalid config: "${configPath}" field "permissionGraceMs" must be a non-negative number of milliseconds`
+    );
+  }
+  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`
+    );
+  }
+  const plugins = (raw.plugins ?? []).map((p) => {
+    if (isMarketplaceRef(p)) return p;
+    return path4.isAbsolute(p) ? p : path4.resolve(baseDir, p);
+  });
+  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,
+    permissionGraceMs: raw.permissionGraceMs,
+    // Personal capabilities are stored opaque. In particular skill `path`
+    // is NOT relative-resolved against baseDir (R1) — Issue 3 resolves it
+    // to an absolute path at install time.
+    mcpServers: raw.mcpServers,
+    skills: raw.skills
+  };
+}
+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",
+  ...STALE_CONFIG_KEYS
+];
+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/core/workflows/types.ts
+var DEFAULT_MAX_TURN_TOKEN_COUNT = 13e4;
+var DEFAULT_NUDGE_CAP = 3;
+var DEFAULT_RETRY_CAP = 3;
+var DEFAULT_RETRY_BACKOFF_MS = 1e4;
+var DEFAULT_PERMISSION_GRACE_MS = 6e4;
+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 path8 from "path";
+
+// src/core/workflows/builtins/index.ts
+import fs7 from "fs";
+import os4 from "os";
+import path6 from "path";
+
+// src/core/workflows/journalReader.ts
+import fs6 from "fs";
+import path5 from "path";
+
+// 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.journalPath !== void 0) {
+    result = result.replaceAll("{journalPath}", ctx.journalPath);
+    result = result.replaceAll("{trackerPath}", ctx.journalPath);
+  }
+  return result;
+}
+
+// src/core/workflows/journalReader.ts
+var DEPRECATION_REMOVAL_RELEASE = "0.7.0";
+var DEFAULT_COMPLETION_MARKER = "<!-- WORKFLOW_COMPLETE -->";
+var DEFAULT_NEEDS_HUMAN_MARKER = "<!-- NEEDS_HUMAN";
+var LEGACY_BLOCKED_MARKER = "<!-- WORKFLOW_BLOCKED";
+var DEFAULT_JOURNAL_PATH = ".athena/{sessionId}/journal.md";
+var LEGACY_JOURNAL_FILENAME = "tracker.md";
+var JOURNAL_SKELETON_MARKER = "<!-- JOURNAL_SKELETON -->";
+var LEGACY_TRACKER_SKELETON_MARKER = "<!-- TRACKER_SKELETON -->";
+var DEFAULT_JOURNAL_TOKEN_BOUND = 8e3;
+var DEFAULT_CONTINUE_PROMPT = "Continue the task. Read the journal at {journalPath} for current progress. If the work is complete or you need a human, the terminal marker must be the final non-empty line of the journal; do not write any prose after it.";
+function loopNeedsHumanMarker(markers) {
+  return markers.needsHumanMarker ?? markers.blockedMarker ?? DEFAULT_NEEDS_HUMAN_MARKER;
+}
+function loopJournalPath(loop) {
+  return loop.journalPath ?? loop.trackerPath ?? DEFAULT_JOURNAL_PATH;
+}
+function needsHumanMarkersFor(markers) {
+  return [
+    .../* @__PURE__ */ new Set([
+      loopNeedsHumanMarker(markers),
+      DEFAULT_NEEDS_HUMAN_MARKER,
+      LEGACY_BLOCKED_MARKER
+    ])
+  ];
+}
+function hasSkeletonMarker(content) {
+  return content.includes(JOURNAL_SKELETON_MARKER) || content.includes(LEGACY_TRACKER_SKELETON_MARKER);
+}
+function buildMarkerDeprecation(deprecatedMarker) {
+  const name = deprecatedMarker.replace(/^<!--\s*/, "").replace(/:?$/, "");
+  return `${name} is deprecated and is removed in ${DEPRECATION_REMOVAL_RELEASE}; declare NEEDS_HUMAN: <reason> as the journal's final non-empty line instead.`;
+}
+function readJournal(journalPath) {
+  try {
+    return fs6.readFileSync(journalPath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+function getNonEmptyLines(content) {
+  return content.trimEnd().split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function isNeedsHumanLine(line, marker) {
+  return line === `${marker} -->` || line.startsWith(`${marker}:`);
+}
+function matchNeedsHumanMarker(line, markers) {
+  return markers.find((marker) => isNeedsHumanLine(line, marker));
+}
+function isTerminalMarkerLine(line, completionMarker, needsHumanMarkers) {
+  return line === completionMarker || matchNeedsHumanMarker(line, needsHumanMarkers) !== void 0;
+}
+function getMisplacedTerminalMarker(lines, completionMarker, needsHumanMarkers) {
+  if (lines.length < 2) return void 0;
+  const terminalLine = lines.at(-1);
+  if (terminalLine && isTerminalMarkerLine(terminalLine, completionMarker, needsHumanMarkers)) {
+    return void 0;
+  }
+  return lines.slice(0, -1).find(
+    (line) => isTerminalMarkerLine(line, completionMarker, needsHumanMarkers)
+  );
+}
+function extractNeedsHumanReason(line, marker) {
+  if (!line.startsWith(marker)) return void 0;
+  const afterMarker = line.slice(marker.length);
+  const match = afterMarker.match(/^:\s*(.+?)(?:\s*-->|$)/);
+  return match?.[1]?.trim();
+}
+function parseJournalState(content, markers = {}) {
+  const completionMarker = markers.completionMarker ?? DEFAULT_COMPLETION_MARKER;
+  const needsHumanMarkers = needsHumanMarkersFor(markers);
+  const lines = getNonEmptyLines(content);
+  const terminalLine = lines.at(-1);
+  const completed = terminalLine === completionMarker;
+  const matchedMarker = terminalLine !== void 0 ? matchNeedsHumanMarker(terminalLine, needsHumanMarkers) : void 0;
+  const needsHuman = matchedMarker !== void 0;
+  const needsHumanReason = matchedMarker && terminalLine ? extractNeedsHumanReason(terminalLine, matchedMarker) : void 0;
+  return {
+    completed,
+    needsHuman,
+    needsHumanReason,
+    misplacedTerminalMarker: getMisplacedTerminalMarker(
+      lines,
+      completionMarker,
+      needsHumanMarkers
+    ),
+    skeletonNotReplaced: hasSkeletonMarker(content),
+    ...matchedMarker === LEGACY_BLOCKED_MARKER ? { deprecatedMarker: LEGACY_BLOCKED_MARKER } : {}
+  };
+}
+function demoteTerminalMarkers(content, markers = {}) {
+  const completionMarker = markers.completionMarker ?? DEFAULT_COMPLETION_MARKER;
+  const needsHumanMarkers = needsHumanMarkersFor(markers);
+  return content.split("\n").map((line) => {
+    const trimmed = line.trim();
+    if (trimmed === completionMarker) return "> _Prior Run ended: complete._";
+    const matched = matchNeedsHumanMarker(trimmed, needsHumanMarkers);
+    if (matched) {
+      const reason = extractNeedsHumanReason(trimmed, matched);
+      return reason ? `> _Prior Run ended: needed a human \u2014 ${reason}._` : "> _Prior Run ended: needed a human._";
+    }
+    return line;
+  }).join("\n");
+}
+function insertAboveTerminalMarker(content, entry, markers = {}) {
+  const completionMarker = markers.completionMarker ?? DEFAULT_COMPLETION_MARKER;
+  const needsHumanMarkers = needsHumanMarkersFor(markers);
+  const trimmed = content.trimEnd();
+  const lastBreak = trimmed.lastIndexOf("\n");
+  const lastLine = trimmed.slice(lastBreak + 1).trim();
+  if (!isTerminalMarkerLine(lastLine, completionMarker, needsHumanMarkers)) {
+    return content + entry;
+  }
+  const above = lastBreak === -1 ? "" : trimmed.slice(0, lastBreak);
+  const markerLine = trimmed.slice(lastBreak + 1);
+  return `${above.trimEnd()}${entry.replace(/\n*$/, "\n")}
+${markerLine}
+`;
+}
+function buildContinuePrompt(loop) {
+  const template = loop.continuePrompt ?? DEFAULT_CONTINUE_PROMPT;
+  return substituteVariables(template, { journalPath: loopJournalPath(loop) });
+}
+function buildNudgePrompt(loop, opts) {
+  const completionMarker = loop.completionMarker ?? DEFAULT_COMPLETION_MARKER;
+  const needsHumanMarker = loopNeedsHumanMarker(loop);
+  const journalPath = loopJournalPath(loop);
+  const bootstrapPreamble = opts?.skeletonNotReplaced ? `You stopped without writing the journal at ${journalPath} \u2014 it still contains the runner's skeleton. If you were asking the human a question, do not ask it in chat: write it to the journal and declare ${needsHumanMarker}: <your question> --> as the final non-empty line. Otherwise replace the skeleton with the real plan and continue. ` : `You stopped without declaring how this workflow ended. If work remains, continue it now. `;
+  return bootstrapPreamble + `If everything is done and verified, write ${completionMarker} as the final non-empty line of the journal at ${journalPath}. If you cannot proceed without a human, write ${needsHumanMarker}: <reason> --> there instead. Do not stop again without either finishing the work or declaring one of these markers.`;
+}
+function estimateTokenCount(content) {
+  return Math.ceil(content.length / 4);
+}
+function buildJournalSizeNudgeSuffix(journalPath) {
+  const where = journalPath ?? "the journal";
+  return ` Separately: ${where} has crossed the ~8,000-token shedding backstop (ADR 0015 \xA73). Before continuing, cut the completed phases of the still-open unit out of the journal and paste them verbatim into that unit's record under units/<slug>.md, leaving a pointer row behind \u2014 this is a nudge, not a requirement, so continue the work either way.`;
+}
+var UNITS_HEADING_RE = /^##\s+Units\s*$/;
+function splitTableRow(line) {
+  const trimmed = line.trim();
+  const withoutEdgePipes = trimmed.replace(/^\|/, "").replace(/\|$/, "");
+  return withoutEdgePipes.split("|").map((cell) => cell.trim());
+}
+function isSeparatorRow(cells) {
+  return cells.length > 0 && cells.every((cell) => /^:?-+:?$/.test(cell));
+}
+function parseUnitTable(content) {
+  const lines = content.split("\n");
+  const headingIndex = lines.findIndex(
+    (line) => UNITS_HEADING_RE.test(line.trim())
+  );
+  if (headingIndex === -1) return null;
+  let i = headingIndex + 1;
+  while (i < lines.length && lines[i].trim() === "") i++;
+  const tableLines = [];
+  while (i < lines.length) {
+    const trimmed = lines[i].trim();
+    if (!trimmed.startsWith("|")) break;
+    tableLines.push(trimmed);
+    i++;
+  }
+  if (tableLines.length < 2) return null;
+  const rows = [];
+  for (const line of tableLines.slice(1)) {
+    const cells = splitTableRow(line);
+    if (isSeparatorRow(cells)) continue;
+    if (cells.length !== 2) continue;
+    const [label, recordPath] = cells;
+    if (!label || !recordPath) continue;
+    rows.push({ label, recordPath });
+  }
+  return rows;
+}
+function normaliseRecordPath(recordPath) {
+  return recordPath.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+var LEVEL_TWO_HEADING_RE = /^##\s+(.+?)\s*$/;
+function levelTwoHeadings(content) {
+  const headings = /* @__PURE__ */ new Map();
+  for (const line of content.split("\n")) {
+    const match = LEVEL_TWO_HEADING_RE.exec(line.trim());
+    if (match) {
+      const heading = `## ${match[1]}`;
+      const key = heading.toLowerCase();
+      if (!headings.has(key)) headings.set(key, heading);
+    }
+  }
+  return headings;
+}
+function checkShedIntegrity(journalContent, records) {
+  const rows = parseUnitTable(journalContent);
+  if (!rows) return null;
+  const pointed = new Set(rows.map((row) => normaliseRecordPath(row.recordPath)));
+  const journalHeadings = levelTwoHeadings(journalContent);
+  const orphanRecords = [];
+  const sharedHeadings = [];
+  for (const record of records) {
+    const recordPath = normaliseRecordPath(record.recordPath);
+    if (!pointed.has(recordPath)) orphanRecords.push(recordPath);
+    for (const [key, heading] of levelTwoHeadings(record.content)) {
+      if (journalHeadings.has(key)) {
+        sharedHeadings.push({
+          heading: journalHeadings.get(key) ?? heading,
+          recordPath
+        });
+      }
+    }
+  }
+  if (orphanRecords.length === 0 && sharedHeadings.length === 0) return null;
+  return { orphanRecords, sharedHeadings };
+}
+function buildShedIntegrityNudgeSuffix(gaps) {
+  const findings = [
+    ...gaps.orphanRecords.map(
+      (recordPath) => `unit record ${recordPath} has no row in the journal's ## Units table`
+    ),
+    ...gaps.sharedHeadings.map(
+      (shared) => `heading "${shared.heading}" appears in both the journal and ${shared.recordPath}`
+    )
+  ];
+  return ` Separately: the Dossier shows a half-executed shed \u2014 ${findings.join("; ")}. Finish the shed: cut the section out of the journal, paste it verbatim into the record, and leave a pointer row in the ## Units table \u2014 this is a nudge, not a requirement, so continue the work either way.`;
+}
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|$)/;
+function parseUnitRecordFrontmatter(content) {
+  const match = FRONTMATTER_RE.exec(content);
+  if (!match) return null;
+  const block = match[1];
+  const statusMatch = /^status:\s*(\S+)\s*$/m.exec(block);
+  const raw = statusMatch?.[1]?.trim().toLowerCase();
+  if (raw !== "open" && raw !== "closed") return null;
+  return { status: raw };
+}
+function projectJournalTasks(journalAbsPath) {
+  const content = readJournal(journalAbsPath);
+  if (!content) return null;
+  const rows = parseUnitTable(content);
+  if (!rows) return null;
+  const baseDir = path5.dirname(journalAbsPath);
+  const tasks = [];
+  for (const row of rows) {
+    const recordAbsPath = path5.resolve(baseDir, row.recordPath);
+    const relToBase = path5.relative(baseDir, recordAbsPath);
+    if (relToBase.startsWith("..") || path5.isAbsolute(relToBase)) continue;
+    let recordContent;
+    try {
+      recordContent = fs6.readFileSync(recordAbsPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const frontmatter = parseUnitRecordFrontmatter(recordContent);
+    if (!frontmatter) continue;
+    const taskId = path5.basename(row.recordPath, path5.extname(row.recordPath));
+    if (!taskId) continue;
+    tasks.push({
+      taskId,
+      content: row.label,
+      status: frontmatter.status === "closed" ? "completed" : "pending"
+    });
+  }
+  return tasks;
+}
+
+// src/core/workflows/builtins/index.ts
+var DEFAULT_NEEDS_HUMAN_CLOSED_MARKER = `${DEFAULT_NEEDS_HUMAN_MARKER} -->`;
+var DEFAULT_NEEDS_HUMAN_REASON_MARKER = `${DEFAULT_NEEDS_HUMAN_MARKER}: reason -->`;
+var SYSTEM_PROMPT = `You are working on a long-horizon task managed by Athena. A journal file is used to persist progress across sessions.
+
+## Journal File
+
+At the start of each session, read the journal file if it exists. It contains the task plan, completed steps, and current status from prior sessions.
+
+If no journal 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 journal file
+
+### Journal Format
+
+Use this markdown format for the journal:
+
+\`\`\`
+# 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 Journal
+
+After completing meaningful work, update the journal:
+- Check off completed steps
+- Update the current status section
+- Add any important notes or decisions
+
+### Completion
+
+When all steps are complete:
+1. Update the journal with all steps checked off
+2. Put any final summary or outcome notes above the terminal marker
+3. Add \`${DEFAULT_COMPLETION_MARKER}\` as the final non-empty line of the journal file
+4. Do not write any journal content after the terminal marker
+
+### Needs a human
+
+If you cannot proceed without a person \u2014 a question only they can answer, or an external blocker only they can clear:
+1. Document what you need from them in the Notes section
+2. Explain what needs to happen to unblock the task whenever possible above the terminal marker
+3. Add \`${DEFAULT_NEEDS_HUMAN_CLOSED_MARKER}\` or \`${DEFAULT_NEEDS_HUMAN_REASON_MARKER}\` as the final non-empty line of the journal file
+4. Do not write any journal content after the terminal marker
+`;
+function ensureSystemPromptFile() {
+  const dir = path6.join(
+    os4.homedir(),
+    ".config",
+    "athena",
+    "builtins",
+    "default"
+  );
+  const filePath = path6.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,
+      needsHumanMarker: DEFAULT_NEEDS_HUMAN_MARKER,
+      maxIterations: 20
+    },
+    plugins: [],
+    workflowFile: ensureSystemPromptFile()
+  };
+}
+function listBuiltinWorkflows() {
+  return ["default"];
+}
+
+// src/core/workflows/sourceMetadata.ts
+import fs8 from "fs";
+import path7 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 = path7.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(
+    path7.join(workflowDir, "source.json"),
+    JSON.stringify({ v: 2, ...metadata }),
+    "utf-8"
+  );
+}
+
+// src/core/workflows/registry.ts
+function workflowRegistryDir() {
+  return path8.join(os5.homedir(), ".config", "athena", "workflows");
+}
+function registryDir() {
+  return workflowRegistryDir();
+}
+function ensurePathWithinRoot(rootDir, targetPath, label) {
+  const relative = path8.relative(rootDir, targetPath);
+  if (relative === "" || !relative.startsWith("..") && !path8.isAbsolute(relative)) {
+    return;
+  }
+  throw new Error(`${label} resolves outside the workflow root: ${targetPath}`);
+}
+function resolveWorkflow(name) {
+  const workflowDir = path8.join(registryDir(), name);
+  const workflowPath = path8.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 (raw["askRules"] !== void 0 && (!Array.isArray(raw["askRules"]) || !raw["askRules"].every(
+    (e) => typeof e === "string" && e.trim().length > 0
+  ))) {
+    throw new Error(
+      `Invalid workflow.json: "askRules" must be an array of non-empty tool-name patterns`
+    );
+  }
+  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" && !path8.isAbsolute(workflowFile)) {
+    const workflowFilePath = path8.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 = path8.resolve(sourcePath);
+  const sourceDir = path8.dirname(absoluteSourcePath);
+  const absoluteDestDir = path8.resolve(destDir);
+  fs9.mkdirSync(absoluteDestDir, { recursive: true });
+  fs9.writeFileSync(
+    path8.join(absoluteDestDir, "workflow.json"),
+    content,
+    "utf-8"
+  );
+  const copyRelativeAsset = (assetPath) => {
+    if (!assetPath || path8.isAbsolute(assetPath)) return;
+    const sourceAssetPath = path8.resolve(sourceDir, assetPath);
+    ensurePathWithinRoot(sourceDir, sourceAssetPath, "Workflow asset");
+    if (!fs9.existsSync(sourceAssetPath)) return;
+    const destAssetPath = path8.resolve(absoluteDestDir, assetPath);
+    ensurePathWithinRoot(absoluteDestDir, destAssetPath, "Workflow asset");
+    fs9.mkdirSync(path8.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 = path8.join(registryDir(), workflowName);
+  copyWorkflowFiles(source.workflowPath, destDir);
+  const metadata = toStoredMetadata(source);
+  writeWorkflowSourceMetadata(destDir, metadata);
+  return workflowName;
+}
+function reResolveFromMetadata(metadata, refresh = refreshMarketplaceRepo, onSelfHeal) {
+  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);
+    const refreshed = refresh(owner, repo);
+    if (!refreshed.ok) {
+      throw new MarketplaceRefreshError(refreshed);
+    }
+    if (refreshed.selfHealed) {
+      onSelfHeal?.({
+        marketplace: `${owner}/${repo}`,
+        backupDir: refreshed.backupDir
+      });
+    }
+    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, refresh = refreshMarketplaceRepo, onSelfHeal) {
+  const workflowDir = path8.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, refresh, onSelfHeal);
+  const installedName = installWorkflowFromSource(source, name);
+  refreshPinnedWorkflowPlugins(resolveWorkflow(installedName));
+  return installedName;
+}
+function updateWorkflows(names) {
+  const refreshCache = /* @__PURE__ */ new Map();
+  const refresh = (owner, repo) => {
+    const key = `${owner}/${repo}`;
+    const cached = refreshCache.get(key);
+    if (cached) return cached;
+    const outcome = refreshMarketplaceRepo(owner, repo);
+    refreshCache.set(key, outcome);
+    return outcome;
+  };
+  const upgraded = [];
+  const marketplaceFailures = [];
+  const reportedMarketplaces = /* @__PURE__ */ new Set();
+  const workflowFailures = [];
+  const selfHealed = [];
+  const selfHealedMarketplaces = /* @__PURE__ */ new Set();
+  const onSelfHeal = (info) => {
+    if (!selfHealedMarketplaces.has(info.marketplace)) {
+      selfHealedMarketplaces.add(info.marketplace);
+      selfHealed.push(info);
+    }
+  };
+  for (const name of names) {
+    try {
+      upgraded.push(updateWorkflow(name, refresh, onSelfHeal));
+    } catch (error) {
+      if (error instanceof MarketplaceRefreshError) {
+        if (!reportedMarketplaces.has(error.marketplace)) {
+          reportedMarketplaces.add(error.marketplace);
+          marketplaceFailures.push({ marketplace: error.marketplace, error });
+        }
+      } else {
+        workflowFailures.push({
+          name,
+          error: error instanceof Error ? error : new Error(String(error))
+        });
+      }
+    }
+  }
+  return { upgraded, marketplaceFailures, workflowFailures, selfHealed };
+}
+function listWorkflows() {
+  const dir = registryDir();
+  const installed = fs9.existsSync(dir) ? fs9.readdirSync(dir, { withFileTypes: true }).filter(
+    (entry) => entry.isDirectory() && fs9.existsSync(path8.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 = path8.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 crypto from "crypto";
+import path9 from "path";
+
+// src/core/workflows/stateMachine.md
+var stateMachine_default = "# Turn Protocol\n\nYou run inside a managed workflow loop. **Run until the work is done.** The Dossier \u2014 `.athena/<session_id>/` \u2014 is your durable memory; `journal.md` is your index into it: read it, work, write it as you go. Your conversation context usually survives between stops \u2014 the runner resumes your session rather than restarting it \u2014 but never rely on that: the runner may kill a long Turn, your session may be replaced at a context bound, the process may die mid-task. Anything not in the Dossier can be lost.\n\nTwo kinds of Turn exist, and you should know which you are in:\n\n- **A fresh Turn** \u2014 the first Turn of the run, or the Turn right after a Handover (the runner's context reset). You start with no memory of prior work; the Journal checkpoint is your saved state.\n- **A resumed Turn** \u2014 the runner continued your existing session with a new instruction (a corrective nudge, a retry after a transient failure, a human's reply, or a human steer). Your context is intact; act on the new instruction and keep going.\n\nEither kind of Turn may open with a **human steer**: a block delimited by `=== HUMAN STEER \u2026 ===` and `=== END HUMAN STEER ===`, carrying instructions a human sent into the run while it was in progress (several are numbered in arrival order). Read it before you plan. Where it conflicts with the journal's planned next action, the steer wins; note what it changed in the journal and continue. The runner has already recorded the steer itself in the journal, with its origin and the Turn it reached.\n\n## First action, in a fresh Turn\n\n1. If the seed prompt contains a validated **Restart contract**, execute its next action using the objective, constraints, changes, open questions and references it carries. Read additional Journal and Unit Record sections selectively when needed. Do not read the whole Journal as an opening ritual.\n2. Otherwise read the journal at the configured path (default: `.athena/<session_id>/journal.md`). The runner provides the session ID \u2014 do not invent one.\n3. If it contains `<!-- JOURNAL_SKELETON -->`, run [**Orient**](#orient-turn-1). Otherwise run [**Execute**](#execute-continuation) from its saved next action.\n\nUpdate durable state only when it changes; never append checkpoint-processed notes. The Runner may suspend if the restart contract cannot fit its context allowance.\n\nIn a resumed Turn, your context is already loaded \u2014 skim the journal only if you have any doubt it still matches reality, then continue.\n\n## Journal contract\n\nThe journal must always answer five questions:\n\n1. What are we trying to accomplish?\n2. What has been done?\n3. What's left?\n4. What should the next Turn do first?\n5. What else, beyond this file, must the next Turn read to have full context?\n\nA fresh Turn has no other context. If something isn't here or in a file question 5 names, it doesn't exist. Section headings may vary by workflow, but these five answers must be explicit and easy to find. Question 5 is the journal's pointer into the rest of the Dossier (see [The Dossier](#the-dossier)): on a single-file Run its honest answer is \"nothing else\"; once anything has been shed, it names exactly which files, so a fresh Turn's opening read stays small even when the Dossier has grown.\n\n### Terminal markers\n\nDefault markers (workflows may override \u2014 use the markers configured for the active workflow):\n\n- `<!-- WORKFLOW_COMPLETE -->` \u2014 all work done and verified\n- `<!-- NEEDS_HUMAN -->` or `<!-- NEEDS_HUMAN: reason -->` \u2014 you need a human: a question only they can answer, or an external blocker only they can clear\n\nRules:\n\n- Only the last non-empty line of the journal is authoritative. Marker-like text in notes, examples, or quoted instructions earlier in the file is ignored.\n- When you write a terminal marker, it must be the final non-empty line of the journal. Put every summary, status note, and next-step sentence before the marker. Never append prose after it.\n- The runner trusts markers unconditionally. A premature `WORKFLOW_COMPLETE` ends the run with no automatic recovery \u2014 write it only when its criteria are fully met.\n- Include a concrete reason after `NEEDS_HUMAN:` whenever possible \u2014 it is what the human sees when deciding how to answer you. Put the full question there.\n\n### Step block\n\nWhen the workflow has named steps \u2014 phases, gates, stages, whatever the workflow document calls them \u2014 keep one Turn Protocol block in the journal naming the step you are on, revised in place as you move:\n\n```\n<!-- TURN_PROTOCOL\nstep: Build\nstep_index: 3\nstep_total: 5\n-->\n```\n\n`step` is the step's name as the workflow writes it. `step_index` and `step_total` are optional, 1-based, and `step_index` never exceeds `step_total`. The runner reads the block after every Turn and shows the step in the feed as the run's progress; it never changes what you do. Leave the block out when the workflow has no named steps. A block the runner cannot read is ignored with a warning \u2014 it never fails a Turn.\n\n## The Dossier\n\n`.athena/<session_id>/` is the Dossier: the journal plus everywhere it can shed cold detail once shedding earns its keep.\n\n```\njournal.md       state: index, open loops, next action, terminal marker\nunits/<slug>.md   record: contract, problem, design + rationale, build state, gate evidence\norientation.md    cross-unit knowledge, revised in place\n```\n\n**On most Runs the Dossier never grows past `journal.md` itself** \u2014 one file, no ceremony, no extra directories, nothing below this line to act on. Nothing here changes how a short, single-unit Run works.\n\nA **unit** is a bounded piece of the plan that reaches its own closed state while the Run keeps going \u2014 one issue in a multi-issue epic, one phase of a larger goal. A Run with only one unit never closes a unit while another stays open, so it can never trip the first shed trigger below.\n\n### When to shed\n\nTwo triggers, both structural. A single-unit Run can only ever reach the second, and only once that unit has outgrown the bound:\n\n- **A unit closes while another is still open.** Cut that unit's whole detail out of the journal now, before starting the next one.\n- **The journal crosses ~8,000 tokens** (roughly 32,000 characters \u2014 a token is about 4 characters at this codebase's measured rate). This is a backstop for one long single unit, not a target to design toward \u2014 shed the completed phases of the still-open unit.\n\n### How to shed\n\nShedding is three positive acts on one whole named `##` section \u2014 never a summary, never a partial move:\n\n1. **Cut** the section, verbatim, out of `journal.md`.\n2. **Paste** it, verbatim, into `units/<slug>.md` (create the file on that unit's first shed).\n3. **Pointer** \u2014 leave one index row in the journal's unit table with a relative path to where the detail went.\n\nContent is demoted, never deleted. If you find yourself rewording or condensing while moving text, stop \u2014 that is not shedding, that is exactly where fidelity leaks.\n\n### The unit table\n\nThe journal's unit table is the index the runner reads to keep the CLI's own task list in sync with your plan \u2014 it is parsed by tooling, so its shape is fixed, not free-form prose. Keep it under a `## Units` heading, as a GFM table with exactly two columns:\n\n```\n## Units\n\n| Unit                  | Record                     |\n| ---------------------- | --------------------------- |\n| Add the size nudge     | units/size-nudge.md         |\n| Wire up task projection | units/task-projection.md   |\n```\n\n- **Unit** \u2014 a short human-readable label for the unit (what step 3 of [How to shed](#how-to-shed) points at).\n- **Record** \u2014 the path to that unit's `units/<slug>.md`, relative to the journal's own directory.\n\nOne row per unit that has been shed; units still fully inline in the journal (never shed) don't need a row. A row whose Record file is missing, unreadable, or malformed is simply skipped by the runner \u2014 never guessed at, never a failure (see the next section). Malformed rows in an otherwise-fine table don't invalidate the rest of the table.\n\nEach `units/<slug>.md` record opens with a small YAML frontmatter block the runner reads to know the unit's state:\n\n```\n---\nstatus: open\ngates: []\n---\n\n<the shed section content, verbatim>\n```\n\n- `status` \u2014 `open` or `closed`, exactly (case-insensitive). Any other value, or a missing `status` key, means the runner treats the whole record as unparseable for projection purposes \u2014 it still exists as your durable journal, it just doesn't surface in the task list.\n- `gates` \u2014 reserved for future gate-evidence tracking; not read by anything yet. Leave it present but empty, or omit it \u2014 either is fine today.\n\nThis frontmatter is the only structured part of a unit record; everything after the closing `---` is free-form prose exactly like the rest of the Dossier.\n\n### Parsing is best-effort, never a gate\n\nThe unit table and unit-record frontmatter exist so the runner can mirror your plan into the harness's own task list (see [Task UI projection](#task-ui-projection)) and, separately, so it can nudge you when the journal grows past its size backstop. Both are conveniences layered on top of the Dossier, not requirements on it:\n\n- A missing table, an extra column, a typo'd status, a unit record that fails to parse \u2014 none of it fails your Turn, and none of it is worth stopping to fix for the runner's sake. The runner silently skips whatever it can't parse and, at most, folds a nudge into your next prompt: a size nudge when the journal is over its backstop, or a shed-integrity nudge when a shed was left half done \u2014 a `units/*.md` record with no row in the `## Units` table, or a `##` heading present in both the journal and a record. Finish the shed (cut, paste, pointer) and carry on.\n- Never restructure the journal or a unit record just to make automated parsing happy at the expense of the content itself. If the table and the prose disagree, the prose (what you actually did) is the truth.\n\n### orientation.md\n\nKnowledge that spans more than one unit lives here, revised in place instead of appended to \u2014 the one Dossier surface you edit rather than move things into. Two sections with different rules:\n\n- **Established** \u2014 decisions. Never decay; only explicitly superseded (\"we chose X over Y because Z \u2014 superseded 2026-09-03: \u2026\").\n- **Observed** \u2014 facts carrying a `file.ts:123`-style anchor. Revalidate the anchor before relying on it; code moves.\n\nA correction is an edit to the existing entry, not a new capitalized warning stacked on top of stale text.\n\n## Run until done; declare when you need a human\n\nThe loop's contract with you:\n\n- **Do not stop early.** There is no checkpoint budget and no reason to end a Turn \"to be safe\" \u2014 context refresh is the runner's job, not yours. When your context approaches its bound the runner performs a **Handover**: a fresh session resumes from the bounded `## Restart` section in your Journal; missing or stale state pauses the Run. You will not see this happen; just keep the journal current so nothing is lost.\n- **Stopping without a marker is a mistake**, not a signal. The runner reads it as a premature stop and resumes you with a corrective prompt; repeated markerless stops without journal progress escalate to a human. Never stop as a way of asking \"should I continue?\" \u2014 the answer is always to continue or to declare.\n- **Need a human? Declare it.** Write `NEEDS_HUMAN: <your question or blocker>` as the journal's final non-empty line and end. The run suspends until a human replies; their reply resumes your session with the answer. This is the only correct way to wait for a person \u2014 an interactive question asked into an unattended run cannot be answered.\n- Transient infrastructure failures are not yours to manage: the runner retries them by resuming your session. Just make sure the journal reflects reality before risky operations.\n\n## Phases\n\n### Orient (Turn 1)\n\n1. **Replace the skeleton immediately**, before any domain work. Even a three-line journal (goal + \"orienting\") protects you if the Turn dies during setup.\n2. Identify and load the applicable workflow skills before doing domain work. If a workflow, plugin, or local skill table names a relevant skill, read it fully and follow it. Do not assume you already know the workflow's conventions, tool sequence, quality gates, or implementation details.\n3. Use a dedicated git worktree for repository-changing work. If you are not already inside a task-specific worktree, create or enter one before editing files, record its branch/path in the journal, and continue there. Skip this only when the workflow explicitly forbids it or the task is read-only.\n4. Run the workflow's orientation steps exactly as written. These vary by domain \u2014 a test-writing workflow explores the product in a browser; a migration workflow audits the schema. The workflow defines what orientation means. Do not skip, reorder, reinterpret, or replace workflow steps with a generic approach unless the workflow explicitly allows it or the journal records a concrete blocker that makes the written step impossible.\n5. Refine the journal into a granular plan. Each task a concrete, verifiable unit of work, including verification steps (running checks, reviewing output) \u2014 not just implementation. Vague tasks (\"write tests\") cannot be meaningfully resumed by a future Turn that has no idea what they mean here.\n6. Record concrete observations \u2014 what you actually saw, not what you assumed. Wrong assumptions burn entire future Turns on rework.\n7. **Single-Turn requests still go through this phase.** If the entire request is satisfied quickly, write a minimal journal (what was asked, what was done, the outcome) and append `<!-- WORKFLOW_COMPLETE -->`. Leaving the skeleton in place gets you nudged \u2014 the runner cannot trust work it can't read from the journal \u2014 and repeated stops with an untouched skeleton escalate to a human.\n\n### Execute (continuation)\n\n- Work from where the journal says, in the workflow's prescribed sequence, and keep going until the work is done or a declared blocker stops you.\n- Be strict with workflow steps. Before starting each unit, identify the next required workflow step from the workflow document and journal, follow it as written, and record completion or blockers against that step. Do not substitute your own process, collapse separate gates into one, or advance past an unchecked step.\n- Be strict with skills. Before each new activity, check the workflow, plugin metadata, local skill table, and journal for relevant skills. Load the appropriate skill first, read it completely, and follow its instructions. If no skill applies, record that explicitly in the journal before proceeding. Skills carry the implementation detail (scaffolding steps, locator rules, anti-patterns, code templates) that this protocol intentionally doesn't repeat.\n- Keep repository work inside the recorded git worktree. If a continuation starts outside the recorded worktree, enter it before editing. If no worktree is recorded and edits are still required, create or enter one before proceeding.\n- Delegate heavy exploration or generation to subagents via the Task tool. Pass file paths, conventions, and concrete output expectations; tell them which skill to load. Respect the workflow's **delegation constraints** \u2014 some operations must run in the main agent because their output is proof, or because the main agent needs to interpret results in context.\n- Run quality gates in order. Do not skip \u2014 they exist because skipping cascades into rework. On a failing verdict, address the issues and re-run before proceeding. Respect the workflow's **retry limits**: repeated failure usually signals a deeper issue another retry won't fix.\n\n### End\n\nYou end the run only by declaring:\n\n1. Journal reflects all progress, discoveries, and blockers.\n2. Journal says clearly what a fresh Turn would need to do first (a Handover can happen at any time).\n3. If all work is verified: append the completion marker as the final non-empty line.\n4. If a human is needed to proceed: append the needs-human marker as the final non-empty line, with the question or blocker spelled out as the reason.\n\n## When to write the journal\n\nWrite on **concrete triggers**, not on a vague sense of \"meaningful progress.\" The right cadence sits between every-tool-call (noisy log, wastes tokens) and end-of-run (everything lost if you die mid-task). This matters more, not less, now that Turns run long: the Journal checkpoint is what carries a killed or reset session.\n\n- **Discrete unit done** \u2014 file written, fix applied, test run, gate passed. Reflect the new reality before starting the next unit. If another unit is still open, this is also a shed trigger (see [The Dossier](#the-dossier)): cut this unit's detail into `units/<slug>.md` before you start the next one.\n- **Insight learned** \u2014 API quirk, config field that turned out to matter, dead end ruled out, decision between two approaches. Insights are journal-worthy even when no code changed; rediscovering them costs a future Turn a full re-exploration. The journal is a knowledge ledger, not just a task log. Insight that spans more than one unit belongs in `orientation.md`, not the journal.\n- **About to do something risky or long-running** \u2014 subagent dispatch, long build, flaky external call, large refactor. Write _first_, then act. If the operation kills your Turn, only what's on disk survives.\n- **Plan changed** \u2014 task resequenced, new task surfaced, planned task no longer needed. Stale plans poison continuation Turns.\n- **The journal crosses the ~8,000-token backstop** \u2014 shed the completed phases of the still-open unit into its `units/<slug>.md` record now, mid-unit; don't wait for it to close.\n- **You haven't written in a while** \u2014 if you can't remember the last update, you've gone too long. A short defensive update (\"doing X, last completed Y, next is Z\") beats nothing.\n\nEach update covers: what changed (work or knowledge), what's now next, and any caveat a future Turn needs. Don't transcribe tool calls \u2014 the journal is a contract with your future self, not a replay log.\n\nThe cost of one extra journal update is a few tokens. The cost of dying without one is rework. Bias toward writing.\n\n## Task UI projection\n\nThe journal is the durable source of truth. Your harness's task tools are a session-scoped UI projection of the same plan, shown to the user in their CLI widget. They do not survive process exit.\n\n{{TASK_TOOL_INSTRUCTIONS}}\n\n- **Turn 1, after orientation:** project the journal's task plan into the task tools.\n- **In a fresh continuation (e.g. after a Handover):** recreate the projection from the journal; do not assume task IDs from prior sessions still exist.\n- **During work:** update both \u2014 the task tools for immediate UI feedback, the journal for persistence \u2014 in the same working phase.\n\nSeparately, the runner independently re-derives a task list from the journal's [unit table](#the-unit-table) and each unit record's frontmatter after every Turn, and mirrors it into the CLI's own task display. This is a backstop, not a substitute for the above \u2014 it only ever reaches `open`/`closed`, so keep calling the task tools yourself for anything finer-grained. It never blocks or fails a Turn: an unparseable table or record just means that Turn's mirror is skipped, exactly as described in [Parsing is best-effort, never a gate](#parsing-is-best-effort-never-a-gate).\n\n## Quick reference\n\nOn a Handover, use the validated **Restart contract** in the seed prompt: objective, next action, essential constraints, changes, open questions and evidence references. Read additional Journal and Unit Record sections selectively when the next action needs them. Update durable state only when it changes; never append checkpoint-processed notes. The Runner may suspend if the restart contract cannot fit its context allowance.\n\n- [ ] Replace the skeleton immediately, even for single-Turn requests\n- [ ] Run until the work is done \u2014 do not stop at checkpoints, and never stop as a way of asking permission to continue\n- [ ] Need a human? Declare it: `NEEDS_HUMAN: <question>` as the final non-empty line, then end\n- [ ] Update the journal on concrete triggers \u2014 unit done, insight learned, risky op pending, plan changed\n- [ ] Shed a unit's detail into `units/<slug>.md` the moment it closes while another stays open, or the journal crosses ~8,000 tokens \u2014 cut, paste, pointer, never summarize\n- [ ] Keep the unit table and each shed record's `status: open|closed` frontmatter current \u2014 the runner mirrors them into the task list and skips silently on any parse miss\n      On a Handover, use the validated **Restart contract** in the seed prompt: objective, next action, essential constraints, changes, open questions and evidence references. Read additional Journal and Unit Record sections selectively when the next action needs them. Update durable state only when it changes; never append checkpoint-processed notes. The Runner may suspend if the restart contract cannot fit its context allowance.\n- [ ] Project the journal plan into task tools at session start; keep both in sync as work lands\n- [ ] Follow the workflow steps as written; do not skip, reorder, or substitute your own process\n- [ ] Workflow has named steps? Keep the `TURN_PROTOCOL` step block in the journal naming the one you are on\n- [ ] Load the appropriate skill before each activity; do not rely on assumed knowledge\n- [ ] Use and record a dedicated git worktree for repository-changing work\n- [ ] Run quality gates in order; respect delegation constraints and retry limits\n- [ ] Write the completion marker only when all work is verified, and make it the final non-empty line\n\n## Restart checkpoint\n\nMaintain one `## Restart` section in the Journal during normal work, using the\nRun id and token bound supplied by the Runner. Include `Run: <runId>` and these\nnonempty fields: Objective, Next action, Constraints, Changes, Open questions,\nReferences. Use `none` when appropriate. Preserve essential constraints; point to\nevidence instead of copying cold history. Update after orientation and concrete\nmilestones, before large reads or risky operations. Write atomically. At the\ncontext boundary the Runner restarts directly from this section, or pauses if it\nis missing, invalid or already consumed. Continue normal work; do not request a\nseparate summarization Turn.\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 journal; 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 journal 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 journal
+- Keep task state consistent and non-stale: reconcile the task list against the journal before moving on, and before ending the session
+- Maintain exactly one \`in_progress\` task unless the journal 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 journal; 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 journal 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 journal
+- Keep task state consistent and non-stale: reconcile the task list against the journal before moving on, and before ending the session
+- Maintain exactly one active task unless the journal 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, journalPath, harness = "claude-code") {
+  if (!workflow?.workflowFile) {
+    return { workflowOverride: void 0, warnings: [] };
+  }
+  const resolvedPath = path9.isAbsolute(workflow.workflowFile) ? workflow.workflowFile : path9.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,
+    journalPath: journalPath ?? void 0
+  });
+  const assetDir = path9.join(projectDir, ".athena", "execution-assets");
+  fs10.mkdirSync(assetDir, { recursive: true, mode: 448 });
+  const digest = crypto.createHash("sha256").update(composed).digest("hex");
+  const composedPath = path9.join(assetDir, `${digest}.md`);
+  if (!fs10.existsSync(composedPath)) {
+    const temporary = path9.join(
+      assetDir,
+      `${digest}.${crypto.randomUUID()}.tmp`
+    );
+    try {
+      fs10.writeFileSync(temporary, composed, { encoding: "utf-8", mode: 384 });
+      fs10.renameSync(temporary, composedPath);
+    } finally {
+      if (fs10.existsSync(temporary)) fs10.unlinkSync(temporary);
+    }
+  }
+  return {
+    workflowOverride: {
+      appendSystemPromptFile: composedPath,
+      developerInstructions: composed
+    },
+    warnings: []
+  };
+}
+function mergeOverrides(base, workflowOverride) {
+  if (!base) return workflowOverride;
+  if (!workflowOverride) return base;
+  return {
+    ...base,
+    ...workflowOverride
+  };
+}
+function resolveJournalPath(input) {
+  const loop = input.workflow?.loop;
+  if (!loop?.enabled) {
+    return null;
+  }
+  const rawPath = loopJournalPath(loop);
+  if (!input.sessionId && rawPath.includes("{sessionId}")) {
+    return null;
+  }
+  const promptPath = input.sessionId ? rawPath.replaceAll("{sessionId}", input.sessionId) : rawPath;
+  const absolutePath = path9.isAbsolute(promptPath) ? promptPath : path9.resolve(input.projectDir, promptPath);
+  const usesDefaultPath = loop.journalPath === void 0 && loop.trackerPath === void 0;
+  if (usesDefaultPath && !fs10.existsSync(absolutePath)) {
+    const legacyAbsolutePath = path9.join(
+      path9.dirname(absolutePath),
+      LEGACY_JOURNAL_FILENAME
+    );
+    if (fs10.existsSync(legacyAbsolutePath)) {
+      return {
+        absolutePath: legacyAbsolutePath,
+        promptPath: path9.posix.join(
+          path9.posix.dirname(promptPath),
+          LEGACY_JOURNAL_FILENAME
+        )
+      };
+    }
+  }
+  return {
+    absolutePath,
+    promptPath
+  };
+}
+function createWorkflowRunState(input) {
+  const { projectDir, sessionId, workflow, harness } = input;
+  const journalResolved = resolveJournalPath({ projectDir, sessionId, workflow });
+  const { workflowOverride, warnings } = readWorkflowOverride(
+    projectDir,
+    workflow,
+    sessionId,
+    journalResolved?.promptPath,
+    harness
+  );
+  return {
+    workflow,
+    journalPathForPrompt: journalResolved?.promptPath,
+    workflowOverride,
+    warnings
+  };
+}
+function prepareWorkflowTurn(state, input) {
+  const { workflow } = state;
+  const iteration = input.iteration ?? 1;
+  const isContinuation = workflow?.loop?.enabled === true && iteration > 1;
+  const prompt = isContinuation ? buildContinuePrompt({
+    ...workflow.loop,
+    journalPath: state.journalPathForPrompt ?? workflow.loop?.journalPath
+  }) : workflow ? applyPromptTemplate(workflow.promptTemplate, input.prompt) : input.prompt;
+  return {
+    prompt,
+    configOverride: mergeOverrides(
+      input.configOverride,
+      state.workflowOverride
+    ),
+    warnings: state.warnings
+  };
+}
+
+// src/core/workflows/workflowRunner.ts
+import crypto3 from "crypto";
+import fs12 from "fs";
+import path10 from "path";
+
+// src/core/workflows/terminalOutcome.ts
+import fs11 from "fs";
+var MISSING_JOURNAL_MESSAGE = "the journal file went missing during the run \u2014 the workflow can no longer verify progress";
+var MISPLACED_TERMINAL_MARKER_MESSAGE = "terminal workflow marker is not the final non-empty line of the journal; move all summary text above the marker";
+function resolveTurnOutcome(input) {
+  const { journalPath, loop } = input;
+  if (!fs11.existsSync(journalPath)) {
+    return {
+      kind: "stop",
+      status: "failed",
+      stopReason: MISSING_JOURNAL_MESSAGE
+    };
+  }
+  const journal = parseJournalState(readJournal(journalPath), loop);
+  if (journal.misplacedTerminalMarker) {
+    return {
+      kind: "stop",
+      status: "failed",
+      stopReason: MISPLACED_TERMINAL_MARKER_MESSAGE
+    };
+  }
+  if (journal.completed) {
+    return { kind: "stop", status: "completed" };
+  }
+  if (journal.needsHuman) {
+    return {
+      kind: "suspend",
+      status: "awaiting_attention",
+      stopReason: journal.needsHumanReason ? `agent declared NEEDS_HUMAN: ${journal.needsHumanReason}` : "agent declared NEEDS_HUMAN",
+      ...journal.deprecatedMarker ? { deprecation: buildMarkerDeprecation(journal.deprecatedMarker) } : {}
+    };
+  }
+  return { kind: "continue" };
+}
+
+// src/core/workflows/continuationPolicy.ts
+var DEFAULT_RESTART_TOKENS = 2e3;
+var DEFAULT_WORKING_TOKENS = 8e3;
+function resourceInterruption(stop) {
+  const names = {
+    tokens: "token budget",
+    iterations: "iteration ceiling",
+    context: "restart context allowance",
+    restart: "restart checkpoint"
+  };
+  return {
+    kind: "cap_exhausted",
+    cap: stop.cause === "iterations" ? "iterations" : stop.cause === "tokens" ? "tokens" : "handover",
+    limit: stop.limit,
+    message: `${names[stop.cause]} reached: ${stop.limit}; used ${stop.used}${stop.detail ? ` \u2014 ${stop.detail}` : ""}`,
+    resource: stop
+  };
+}
+function admitContinuation(input) {
+  const { loop } = input;
+  if (!loop?.enabled) return null;
+  const base = { fresh: false, checkpointPath: input.checkpointPath };
+  if (loop.maxRunTokens !== void 0 && (input.tokens ?? 0) >= loop.maxRunTokens)
+    return {
+      ...base,
+      cause: "tokens",
+      limit: loop.maxRunTokens,
+      used: input.tokens ?? 0
+    };
+  if (input.iteration > loop.maxIterations)
+    return {
+      ...base,
+      cause: "iterations",
+      limit: loop.maxIterations,
+      used: input.iteration - 1
+    };
+  if (input.context) {
+    const { opening, required, ceiling, source } = input.context;
+    const used = opening + required + DEFAULT_WORKING_TOKENS;
+    if (used > ceiling)
+      return {
+        ...base,
+        cause: "context",
+        fresh: true,
+        limit: ceiling,
+        used,
+        detail: `opening ${opening} + checkpoint ${required} + ${DEFAULT_WORKING_TOKENS} working tokens; ${source}; reduce startup context or increase its allowance`
+      };
+  }
+  return null;
+}
+
+// src/core/workflows/restartContract.ts
+var fields = [
+  "Objective",
+  "Next action",
+  "Constraints",
+  "Changes",
+  "Open questions",
+  "References"
+];
+function readRestartContract(content, limit = DEFAULT_RESTART_TOKENS, expectedRunId) {
+  if ((content.match(/^## Restart[ \t]*$/gm) ?? []).length !== 1) return null;
+  const match = /^## Restart\s*\n([\s\S]*?)(?=^## |$(?![\s\S]))/m.exec(content);
+  if (!match) return null;
+  const text = match[1].trim();
+  if (!fields.every((field) => new RegExp(`^${field}:[ 	]*\\S`, "m").test(text)))
+    return null;
+  if (expectedRunId && !text.split("\n").some((line) => line.trim() === `Run: ${expectedRunId}`))
+    return null;
+  const tokens = estimateTokenCount(text);
+  return tokens <= limit ? { text, tokens } : null;
+}
+function restartInstructions(journalPath, runId, limit = DEFAULT_RESTART_TOKENS) {
+  return `Maintain one ## Restart section in the Journal at ${journalPath} during this Workflow Run. Include Run: ${runId}, followed by these nonempty fields: ${fields.join(", ")}. Use none where appropriate. Update it after orientation and each meaningful work checkpoint, before large reads or risky operations; keep it within ${limit} estimated tokens. Preserve essential constraints and reference supporting evidence. Write changes atomically so interruption cannot leave a partial checkpoint. The Runner may replace your Agent Session at its context bound using only this section. Do not stop to request a Handover; continue working and declare the normal terminal marker when done.`;
+}
+function seedFromRestart(contract, checkpointPath, journalPath) {
+  return `Continue this Workflow Run from its validated restart contract:
+
+${contract.text}
+
+The checkpoint is in ${checkpointPath}${journalPath ? `; the Journal is at ${journalPath}` : ""}. Read additional sections selectively when the next action requires them. Update durable state only when it changes. Do not append checkpoint-processed notes or repeat completed work. Essential constraints above remain in force.`;
+}
+
+// src/core/workflows/turnProtocolBlock.ts
+var BLOCK_OPEN = /^\s*<!--\s*TURN_PROTOCOL\s*$/;
+var BLOCK_CLOSE = /^\s*-->\s*$/;
+var TRAILING_CLOSE = /\s*-->\s*$/;
+var KEY_VALUE = /^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*(.*)$/;
+function parseTurnProtocolBlock(content) {
+  const lines = content.split("\n");
+  let last = null;
+  let open = null;
+  for (const raw of lines) {
+    const line = raw.replace(/\r$/, "");
+    if (open === null) {
+      if (BLOCK_OPEN.test(line)) open = [];
+      continue;
+    }
+    if (BLOCK_CLOSE.test(line)) {
+      last = open;
+      open = null;
+      continue;
+    }
+    if (TRAILING_CLOSE.test(line)) {
+      open.push(line.replace(TRAILING_CLOSE, ""));
+      last = open;
+      open = null;
+      continue;
+    }
+    open.push(line);
+  }
+  if (open !== null) {
+    return {
+      kind: "malformed",
+      reason: "the TURN_PROTOCOL block is never closed with -->"
+    };
+  }
+  if (last === null) return { kind: "missing" };
+  return parseBlockLines(last);
+}
+function parseBlockLines(lines) {
+  const fields2 = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const match = KEY_VALUE.exec(line.trim());
+    if (!match) continue;
+    fields2.set(match[1], match[2].trim());
+  }
+  const name = fields2.get("step");
+  if (name === void 0) {
+    return { kind: "malformed", reason: "the block has no `step:` line" };
+  }
+  if (name.length === 0) {
+    return { kind: "malformed", reason: "the `step:` line names no step" };
+  }
+  const index = parsePositiveInt(fields2.get("step_index"));
+  if (index.kind === "invalid") {
+    return {
+      kind: "malformed",
+      reason: `\`step_index\` must be a positive integer, got "${index.raw}"`
+    };
+  }
+  const total = parsePositiveInt(fields2.get("step_total"));
+  if (total.kind === "invalid") {
+    return {
+      kind: "malformed",
+      reason: `\`step_total\` must be a positive integer, got "${total.raw}"`
+    };
+  }
+  if (index.kind === "value" && total.kind === "value" && index.value > total.value) {
+    return {
+      kind: "malformed",
+      reason: `\`step_index\` (${index.value}) is past \`step_total\` (${total.value})`
+    };
+  }
+  return {
+    kind: "ok",
+    step: {
+      name,
+      ...index.kind === "value" ? { index: index.value } : {},
+      ...total.kind === "value" ? { total: total.value } : {}
+    }
+  };
+}
+function parsePositiveInt(raw) {
+  if (raw === void 0 || raw.length === 0) return { kind: "absent" };
+  if (!/^\d+$/.test(raw)) return { kind: "invalid", raw };
+  const value = Number(raw);
+  if (!Number.isSafeInteger(value) || value < 1) return { kind: "invalid", raw };
+  return { kind: "value", value };
+}
+function sameStep(a, b) {
+  return a.name === b.name && a.index === b.index;
+}
+function createPhaseTracker() {
+  let lastStep = null;
+  let lastMalformedReason = null;
+  return {
+    observe(journalContent) {
+      const parsed = parseTurnProtocolBlock(journalContent);
+      if (parsed.kind === "missing") {
+        lastMalformedReason = null;
+        return { kind: "no_block" };
+      }
+      if (parsed.kind === "malformed") {
+        const warning = parsed.reason === lastMalformedReason ? null : `ignoring the journal's TURN_PROTOCOL block: ${parsed.reason}`;
+        lastMalformedReason = parsed.reason;
+        return { kind: "malformed", reason: parsed.reason, warning };
+      }
+      lastMalformedReason = null;
+      if (lastStep && sameStep(lastStep, parsed.step)) {
+        lastStep = parsed.step;
+        return { kind: "same_step" };
+      }
+      lastStep = parsed.step;
+      return { kind: "new_step", step: parsed.step };
+    }
+  };
+}
+
+// src/core/workflows/steer.ts
+var STEER_BLOCK_OPEN = "=== HUMAN STEER";
+var STEER_BLOCK_END = "=== END HUMAN STEER ===";
+function steerHeading(steer, index, total) {
+  const position = total > 1 ? `${index + 1} of ${total}, ` : "";
+  return `${STEER_BLOCK_OPEN} (${position}via ${steer.origin}, received ${new Date(
+    steer.receivedAt
+  ).toISOString()}) ===`;
+}
+function buildSteerBlock(steers) {
+  const entries = steers.map(
+    (steer, index) => `${steerHeading(steer, index, steers.length)}
+${steer.text.trim()}`
+  );
+  const noun = steers.length > 1 ? "steers" : "steer";
+  return `${entries.join("\n")}
+${STEER_BLOCK_END}
+
+A human steered this run. Read the ${noun} above before you plan: where it conflicts with the journal's planned next action, the steer wins. Apply it, note it in the journal, and continue the workflow.`;
+}
+function prependSteerBlock(prompt, steers) {
+  if (steers.length === 0) return prompt;
+  return `${buildSteerBlock(steers)}
+
+---
+
+${prompt}`;
+}
+function formatSteerJournalEntry(steer, iteration) {
+  const quoted = steer.text.trim().split("\n").map((line) => `> ${line}`).join("\n");
+  return `
+
+---
+
+## Human steer (via ${steer.origin})
+
+_Received ${new Date(steer.receivedAt).toISOString()}; delivered into Turn ${iteration}._
+
+${quoted}
+`;
+}
+function createSteerQueue() {
+  const buffered = [];
+  let listener = null;
+  return {
+    push(steer) {
+      if (listener) {
+        listener(steer);
+        return;
+      }
+      buffered.push(steer);
+    },
+    subscribe(next) {
+      listener = next;
+      for (const steer of buffered.splice(0)) next(steer);
+      return () => {
+        if (listener === next) listener = null;
+      };
+    }
+  };
+}
+
+// src/core/workflows/runMachine.ts
+import crypto2 from "crypto";
+
+// src/core/runtime/failureTaxonomy.ts
+var RULES = [
+  // ── hard, specific ──
+  {
+    pattern: /\b401\b|authentication_error|unauthorized|invalid.?api.?key|api key.*(invalid|revoked|expired)|oauth token.*(expired|revoked)|not.?logged.?in|please.*log ?in/i,
+    classification: { kind: "hard", code: "auth" }
+  },
+  {
+    pattern: /\b402\b|billing|credit balance|insufficient.?(funds|credits?|quota)|payment required|plan limit/i,
+    classification: { kind: "hard", code: "billing" }
+  },
+  {
+    pattern: /model.{0,20}not.?(found|supported|available)|no such model/i,
+    classification: { kind: "hard", code: "model_not_found" }
+  },
+  // ── transient ──
+  {
+    pattern: /\b429\b|rate.?limit/i,
+    classification: { kind: "transient", code: "rate_limit" }
+  },
+  {
+    pattern: /\b529\b|overloaded/i,
+    classification: { kind: "transient", code: "overloaded" }
+  },
+  {
+    pattern: /\b(500|502|503|504)\b|internal server error|bad gateway|service unavailable|gateway timeout|server_error|api_error/i,
+    classification: { kind: "transient", code: "server_error" }
+  },
+  {
+    pattern: /econnrefused|econnreset|etimedout|enotfound|eai_again|epipe|socket hang up|fetch failed|network error|connection (error|closed|refused|reset)/i,
+    classification: { kind: "transient", code: "network" }
+  },
+  // ── hard, generic (after the specific hard + transient rules) ──
+  {
+    pattern: /\b400\b|invalid_request_error|invalid request|malformed request/i,
+    classification: { kind: "hard", code: "invalid_request" }
+  }
+];
+function classifyTurnFailure(input) {
+  const haystack = [input.errorMessage, input.lastStderr, input.lastMessage].filter((part) => typeof part === "string").join("\n");
+  for (const rule of RULES) {
+    if (rule.pattern.test(haystack)) {
+      return rule.classification;
+    }
+  }
+  return { kind: "hard", code: "unclassified" };
+}
+
+// src/core/workflows/runMachine.ts
+function formatGrace(ms) {
+  return ms >= 1e3 ? `${Math.round(ms / 1e3)}s` : `${ms}ms`;
+}
+function describeDeferral(permission) {
+  return permission.graceMs > 0 ? ` unanswered within the grace window (${formatGrace(permission.graceMs)}); deferred` : " deferred immediately (no hub attached to answer)";
+}
+function protocolInterruptionFor(interruption) {
+  if (interruption.kind === "question" || !interruption.permission) return null;
+  return {
+    kind: "question",
+    message: describeInterruption(interruption),
+    requestId: interruption.permission.requestId,
+    question: `${interruption.toolName}: ${interruption.permission.inputSummary}`
+  };
+}
+function describeInterruption(interruption) {
+  switch (interruption.kind) {
+    case "ask_rule":
+      if (interruption.permission) {
+        return `ask rule "${interruption.rule}" fired on ${interruption.toolName}${describeDeferral(interruption.permission)}: ${interruption.permission.inputSummary} \u2014 wake with --answer=allow|deny`;
+      }
+      return `ask rule "${interruption.rule}" fired on ${interruption.toolName} \u2014 needs a human`;
+    case "question":
+      return interruption.question ? `agent asked a question with no human attached to answer: ${interruption.question}` : "agent asked a question with no human attached to answer";
+    case "unclaimed_permission":
+      if (interruption.permission) {
+        return `permission request (${interruption.toolName})${describeDeferral(interruption.permission)}: ${interruption.permission.inputSummary} \u2014 wake with --answer=allow|deny, or rerun with --isolation autonomous`;
+      }
+      return `agent requested sandbox approval (${interruption.toolName}) with no human attached to answer \u2014 rerun with --isolation autonomous, or wake with guidance`;
+  }
+}
+function hashJournalContent(content) {
+  return crypto2.createHash("sha256").update(content).digest("hex");
+}
+function withCumulativeTokens(memory, cumulativeTokens) {
+  return cumulativeTokens === null ? memory : { ...memory, cumulativeTokens };
+}
+function buildWakePrompt(reply, journalPath, parkedInterruption) {
+  return `This workflow run was suspended awaiting a human; it is now resumed. The human replied:
+
+${reply}
+
+` + buildReplayGuidance(parkedInterruption) + (journalPath ? `Consult the relevant Journal sections at ${journalPath} as needed, apply the reply, and continue the workflow. ` : `Apply the reply and continue the workflow. `) + `Keep the journal current as you work \u2014 if it still contains the runner's skeleton, replace it while orienting \u2014 and end by declaring a terminal marker as usual.`;
+}
+function buildReplayGuidance(parked) {
+  if (!parked || parked.kind !== "question" || !parked.requestId) return "";
+  const call = parked.question ?? "the same call";
+  return `Before your previous Turn ended, your request \`${call}\` (request ${parked.requestId}) was deferred because nobody answered it in time. Re-issue that exact call now, with the same input: if an answer was stored while this run was parked it is applied automatically, otherwise the request is held again for a human. Do not work around the deferred call or substitute a different one.
+
+`;
+}
+function buildFailureDetail(event) {
+  const parts = [];
+  if (event.errorMessage) {
+    parts.push(event.errorMessage);
+  } else if (event.exitCode !== null) {
+    parts.push(`Process exited with code ${event.exitCode}`);
+  }
+  if (event.lastStderr) {
+    parts.push(event.lastStderr);
+  } else if (event.streamMessage) {
+    parts.push(event.streamMessage.slice(0, 300));
+  }
+  return parts.join(": ") || "Turn failed";
+}
+function initialRun(cfg, opts) {
+  const initialSteers = opts.initialSteers ?? [];
+  if (opts.resumedMemory) {
+    const memory = initialSteers.length === 0 ? opts.resumedMemory : {
+      ...opts.resumedMemory,
+      pendingSteers: [
+        ...opts.resumedMemory.pendingSteers,
+        ...initialSteers
+      ]
+    };
+    if (opts.waking) {
+      const phase3 = {
+        kind: "awaiting_attention",
+        stopReason: opts.awaitingAttentionStopReason ?? "",
+        ...opts.parkedInterruption ? { interruption: opts.parkedInterruption } : {}
+      };
+      return { phase: phase3, memory, actions: kickoffActionsFor(phase3) };
+    }
+    const phase2 = {
+      kind: "backing_off",
+      ms: 0,
+      resume: {
+        kind: "turn",
+        prompt: opts.resumedMemory.lastStopPrompt,
+        continuation: opts.resumedMemory.lastStopContinuation
+      }
+    };
+    return { phase: phase2, memory, actions: kickoffActionsFor(phase2) };
+  }
+  const continuation = opts.initialContinuation ?? { mode: "fresh" };
+  const iteration = 1;
+  const prepared = prepareWorkflowTurn(cfg.workflowState, {
+    prompt: cfg.initialPrompt,
+    iteration,
+    configOverride: void 0
+  });
+  const prompt = opts.waking ? buildWakePrompt(
+    cfg.initialPrompt,
+    cfg.journalPromptPath,
+    opts.parkedInterruption
+  ) : prepared.prompt;
+  const phase = {
+    kind: "turn_in_flight",
+    prompt,
+    continuation,
+    configOverride: prepared.configOverride
+  };
+  return {
+    phase,
+    memory: {
+      iteration,
+      nudgeStreak: 0,
+      retryStreak: 0,
+      lastJournalHash: null,
+      lastStopPrompt: prompt,
+      lastStopContinuation: continuation,
+      pendingSteers: initialSteers,
+      parkedAfterHandover: false,
+      lastBoundedTurn: null,
+      cumulativeTokens: null
+    },
+    actions: kickoffActionsFor(phase)
+  };
+}
+function kickoffActionsFor(phase) {
+  switch (phase.kind) {
+    case "turn_in_flight":
+      return [
+        {
+          type: "start_turn",
+          prompt: phase.prompt,
+          continuation: phase.continuation,
+          configOverride: phase.configOverride
+        }
+      ];
+    case "backing_off":
+      return [{ type: "wait", ms: phase.ms }];
+    case "awaiting_attention":
+    case "completed":
+    case "failed":
+    case "cancelled":
+      return [];
+  }
+}
+function deliverPendingSteers(result) {
+  const steers = result.memory.pendingSteers;
+  if (steers.length === 0 || result.phase.kind !== "turn_in_flight") {
+    return result;
+  }
+  const startIndex = result.actions.findIndex((a) => a.type === "start_turn");
+  if (startIndex === -1) return result;
+  const start = result.actions[startIndex];
+  const prompt = prependSteerBlock(start.prompt, steers);
+  const actions = [
+    ...result.actions.slice(0, startIndex),
+    {
+      type: "steers_delivered",
+      steers,
+      iteration: result.memory.iteration
+    },
+    { ...start, prompt },
+    ...result.actions.slice(startIndex + 1)
+  ];
+  return {
+    phase: { ...result.phase, prompt },
+    memory: { ...result.memory, lastStopPrompt: prompt, pendingSteers: [] },
+    actions
+  };
+}
+function handleSteer(phase, memory, steer) {
+  return {
+    phase,
+    memory: { ...memory, pendingSteers: [...memory.pendingSteers, steer] },
+    actions: [{ type: "persist" }]
+  };
+}
+function handleTurnInFlight(phase, incoming, event, cfg) {
+  if (event.cancelled) {
+    return {
+      phase: { kind: "cancelled" },
+      memory: incoming,
+      actions: [{ type: "persist" }]
+    };
+  }
+  const memory = {
+    ...withCumulativeTokens(incoming, event.cumulativeTokens),
+    ...event.checkpoint ? { checkpoint: event.checkpoint } : {}
+  };
+  if (event.handoverRequestHandle !== null) {
+    const checkpoint = event.checkpoint;
+    const hash = checkpoint ? hashJournalContent(checkpoint.contract.text) : null;
+    const boundedMemory = {
+      ...memory,
+      ...checkpoint ? { checkpoint } : {},
+      parkedAfterHandover: true,
+      contextKey: cfg.contextKey,
+      lastBoundedTurn: {
+        openingContextTokens: event.openingContextTokens,
+        openingRestartTokens: incoming.activeRestartTokens ?? 0,
+        lastContextTokens: event.lastContextTokens,
+        toolCalls: event.toolCalls
+      },
+      lastJournalHash: hashJournalContent(event.journalContent)
+    };
+    if (!checkpoint || hash === memory.lastRestartHash) {
+      return parkResource(
+        boundedMemory,
+        {
+          cause: "restart",
+          limit: cfg.loop?.maxRestartTokens ?? 2e3,
+          used: checkpoint?.contract.tokens ?? 0,
+          fresh: true,
+          detail: checkpoint ? "Restart checkpoint has already been consumed; update it before continuing" : "Missing, invalid, oversized or wrong-run Restart checkpoint",
+          checkpointPath: boundedMemory.checkpoint?.path
+        },
+        [{ type: "notify_iteration_complete" }]
+      );
+    }
+    const prompt = seedFromRestart(checkpoint.contract, checkpoint.path);
+    const continuation2 = { mode: "fresh" };
+    const iteration = memory.iteration + 1;
+    const prepared2 = prepareWorkflowTurn(cfg.workflowState, {
+      prompt: cfg.initialPrompt,
+      iteration,
+      configOverride: void 0
+    });
+    return {
+      phase: {
+        kind: "turn_in_flight",
+        prompt,
+        continuation: continuation2,
+        configOverride: prepared2.configOverride
+      },
+      memory: {
+        ...boundedMemory,
+        iteration,
+        lastRestartHash: hash,
+        lastStopPrompt: prompt,
+        lastStopContinuation: continuation2,
+        parkedAfterHandover: false
+      },
+      actions: [
+        { type: "persist" },
+        {
+          type: "notify_handover_completed",
+          completion: {
+            iteration: memory.iteration,
+            checkpointPath: checkpoint.path,
+            checkpointTokens: checkpoint.contract.tokens
+          }
+        },
+        { type: "notify_iteration_complete" },
+        {
+          type: "start_turn",
+          restartTokens: checkpoint.contract.tokens,
+          prompt,
+          continuation: continuation2,
+          configOverride: prepared2.configOverride
+        }
+      ]
+    };
+  }
+  if (event.interruption) {
+    const deferred = protocolInterruptionFor(event.interruption);
+    if (deferred) {
+      return {
+        phase: {
+          kind: "awaiting_attention",
+          stopReason: deferred.message,
+          interruption: deferred
+        },
+        memory,
+        actions: [
+          { type: "record_interruption", interruption: deferred },
+          { type: "persist" }
+        ]
+      };
+    }
+    return {
+      phase: {
+        kind: "awaiting_attention",
+        stopReason: describeInterruption(event.interruption)
+      },
+      memory,
+      actions: [{ type: "persist" }]
+    };
+  }
+  const failed = event.hasError || event.exitCode !== null && event.exitCode !== 0;
+  if (failed) {
+    const failureDetail = buildFailureDetail(event);
+    if (cfg.loop?.enabled) {
+      const classification = classifyTurnFailure({
+        errorMessage: event.errorMessage,
+        lastStderr: event.stderrTail ?? event.lastStderr,
+        lastMessage: event.streamMessage
+      });
+      if (classification.kind === "transient") {
+        const retryStreak = memory.retryStreak + 1;
+        const retryCap = cfg.loop.retryCap ?? DEFAULT_RETRY_CAP;
+        if (retryStreak > retryCap) {
+          return {
+            phase: {
+              kind: "awaiting_attention",
+              stopReason: `retry cap reached: ${retryCap} transient failure${retryCap === 1 ? "" : "s"} (retryCap); last (${classification.code}): ${failureDetail}`
+            },
+            memory: { ...memory, retryStreak },
+            actions: [{ type: "persist" }]
+          };
+        }
+        const backoffBase = cfg.loop.retryBackoffMs ?? DEFAULT_RETRY_BACKOFF_MS;
+        const ms = backoffBase * 2 ** (retryStreak - 1);
+        return {
+          phase: {
+            kind: "backing_off",
+            ms,
+            resume: {
+              kind: "turn",
+              prompt: phase.prompt,
+              continuation: phase.continuation
+            }
+          },
+          memory: { ...memory, retryStreak },
+          actions: [{ type: "wait", ms }]
+        };
+      }
+      if (phase.continuation.mode === "resume") {
+        const continuation2 = { mode: "fresh" };
+        const prepared2 = prepareWorkflowTurn(cfg.workflowState, {
+          prompt: cfg.initialPrompt,
+          iteration: memory.iteration,
+          configOverride: void 0
+        });
+        return {
+          phase: {
+            kind: "turn_in_flight",
+            prompt: prepared2.prompt,
+            continuation: continuation2,
+            configOverride: prepared2.configOverride
+          },
+          memory: {
+            ...memory,
+            lastStopPrompt: prepared2.prompt,
+            lastStopContinuation: continuation2
+          },
+          actions: [
+            { type: "persist" },
+            {
+              type: "start_turn",
+              prompt: prepared2.prompt,
+              continuation: continuation2,
+              configOverride: prepared2.configOverride
+            }
+          ]
+        };
+      }
+      return {
+        phase: {
+          kind: "awaiting_attention",
+          stopReason: `hard failure (${classification.code}): ${failureDetail} \u2014 not retried; needs a human`
+        },
+        memory,
+        actions: [{ type: "persist" }]
+      };
+    }
+    return {
+      phase: { kind: "failed", stopReason: failureDetail },
+      memory,
+      actions: [{ type: "persist" }]
+    };
+  }
+  const memoryAfterSuccess = { ...memory, retryStreak: 0 };
+  if (event.transportBroken) {
+    return {
+      phase: {
+        kind: "failed",
+        stopReason: `Hook transport broken: observed a tool use in the Claude stream but received no PreToolUse events.`
+      },
+      memory: memoryAfterSuccess,
+      actions: [{ type: "persist" }]
+    };
+  }
+  if (!cfg.loop?.enabled) {
+    return {
+      phase: { kind: "completed" },
+      memory: memoryAfterSuccess,
+      actions: [{ type: "persist" }]
+    };
+  }
+  const loop = cfg.loop;
+  if (event.outcome && (event.outcome.kind === "stop" || event.outcome.kind === "suspend")) {
+    const outcome = event.outcome;
+    const nextPhase = outcome.status === "completed" ? { kind: "completed" } : outcome.status === "failed" ? { kind: "failed", stopReason: outcome.stopReason } : {
+      kind: "awaiting_attention",
+      stopReason: outcome.stopReason ?? "stopped"
+    };
+    const deprecation = outcome.kind === "suspend" ? outcome.deprecation : void 0;
+    return {
+      phase: nextPhase,
+      memory: memoryAfterSuccess,
+      actions: [
+        ...deprecation ? [{ type: "warn", message: deprecation }] : [],
+        { type: "persist" }
+      ]
+    };
+  }
+  const journalHash = hashJournalContent(event.journalContent);
+  let nudgeStreak = memoryAfterSuccess.nudgeStreak;
+  if (journalHash !== memoryAfterSuccess.lastJournalHash) {
+    nudgeStreak = 0;
+  }
+  const memoryWithHash = {
+    ...memoryAfterSuccess,
+    lastJournalHash: journalHash,
+    nudgeStreak
+  };
+  const sizeNudgeSuffix = (estimateTokenCount(event.journalContent) > DEFAULT_JOURNAL_TOKEN_BOUND ? buildJournalSizeNudgeSuffix(cfg.journalPromptPath) : "") + // Shed-integrity nudge (ADR 0018 §7): a half-executed shed is named
+  // the Turn after it happens, on the same terms as the size nudge.
+  (event.shedIntegrity ? buildShedIntegrityNudgeSuffix(event.shedIntegrity) : "");
+  if (event.adapterSessionId) {
+    const nextNudgeStreak = nudgeStreak + 1;
+    const nudgeCap = loop.nudgeCap ?? DEFAULT_NUDGE_CAP;
+    if (nextNudgeStreak > nudgeCap) {
+      return {
+        phase: {
+          kind: "awaiting_attention",
+          stopReason: `nudge cap reached: ${nudgeCap} nudge${nudgeCap === 1 ? "" : "s"} (nudgeCap) without journal progress or a terminal marker`
+        },
+        memory: { ...memoryWithHash, nudgeStreak: nextNudgeStreak },
+        actions: [{ type: "persist" }]
+      };
+    }
+    const promptOverride = buildNudgePrompt(
+      { ...loop, journalPath: cfg.journalPromptPath ?? loop.journalPath },
+      {
+        skeletonNotReplaced: hasSkeletonMarker(event.journalContent)
+      }
+    ) + sizeNudgeSuffix;
+    const nextIteration2 = memoryWithHash.iteration + 1;
+    const continuation2 = {
+      mode: "resume",
+      handle: event.adapterSessionId
+    };
+    const prepared2 = prepareWorkflowTurn(cfg.workflowState, {
+      prompt: cfg.initialPrompt,
+      iteration: nextIteration2,
+      configOverride: void 0
+    });
+    return {
+      phase: {
+        kind: "turn_in_flight",
+        prompt: promptOverride,
+        continuation: continuation2,
+        configOverride: prepared2.configOverride
+      },
+      memory: {
+        ...memoryWithHash,
+        nudgeStreak: nextNudgeStreak,
+        iteration: nextIteration2,
+        lastStopPrompt: promptOverride,
+        lastStopContinuation: continuation2
+      },
+      actions: [
+        { type: "persist" },
+        { type: "notify_iteration_complete" },
+        {
+          type: "start_turn",
+          prompt: promptOverride,
+          continuation: continuation2,
+          configOverride: prepared2.configOverride
+        }
+      ]
+    };
+  }
+  const nextIteration = memoryWithHash.iteration + 1;
+  const continuation = { mode: "fresh" };
+  const prepared = prepareWorkflowTurn(cfg.workflowState, {
+    prompt: cfg.initialPrompt,
+    iteration: nextIteration,
+    configOverride: void 0
+  });
+  const promptWithSizeNudge = prepared.prompt + sizeNudgeSuffix;
+  return {
+    phase: {
+      kind: "turn_in_flight",
+      prompt: promptWithSizeNudge,
+      continuation,
+      configOverride: prepared.configOverride
+    },
+    memory: {
+      ...memoryWithHash,
+      iteration: nextIteration,
+      lastStopPrompt: promptWithSizeNudge,
+      lastStopContinuation: continuation
+    },
+    actions: [
+      { type: "persist" },
+      { type: "notify_iteration_complete" },
+      {
+        type: "start_turn",
+        prompt: promptWithSizeNudge,
+        continuation,
+        configOverride: prepared.configOverride
+      }
+    ]
+  };
+}
+function handleBackingOff(phase, memory, event, cfg) {
+  if (event.cancelled) {
+    return { phase: { kind: "cancelled" }, memory, actions: [{ type: "persist" }] };
+  }
+  const continuation = event.adapterSessionId ? { mode: "resume", handle: event.adapterSessionId } : phase.resume.continuation;
+  const prompt = continuation.mode === "fresh" ? phase.resume.prompt : cfg.loop ? buildContinuePrompt(cfg.loop) : "Continue.";
+  const prepared = prepareWorkflowTurn(cfg.workflowState, {
+    prompt: cfg.initialPrompt,
+    iteration: memory.iteration,
+    configOverride: void 0
+  });
+  return {
+    phase: {
+      kind: "turn_in_flight",
+      prompt,
+      continuation,
+      configOverride: prepared.configOverride
+    },
+    memory: {
+      ...memory,
+      lastStopPrompt: prompt,
+      lastStopContinuation: continuation
+    },
+    actions: [
+      { type: "persist" },
+      {
+        type: "start_turn",
+        prompt,
+        continuation,
+        configOverride: prepared.configOverride
+      }
+    ]
+  };
+}
+function handleAwaitingAttention(phase, memory, event, cfg) {
+  if (event.checkpoint) memory = { ...memory, checkpoint: event.checkpoint };
+  const nextIteration = memory.iteration + 1;
+  const wakesFresh = memory.parkedAfterHandover || phase.interruption?.kind === "cap_exhausted" && phase.interruption.resource?.fresh === true;
+  if (wakesFresh && memory.checkpoint && !readRestartContract(
+    `## Restart
+${memory.checkpoint.contract.text}`,
+    cfg.loop?.maxRestartTokens,
+    cfg.runId
+  )) {
+    return parkResource(memory, {
+      cause: "restart",
+      limit: cfg.loop?.maxRestartTokens ?? 2e3,
+      used: estimateTokenCount(memory.checkpoint.contract.text),
+      fresh: true,
+      detail: "Retained Restart checkpoint does not satisfy the current contract limit or Run identity",
+      checkpointPath: memory.checkpoint.path
+    });
+  }
+  const continuation = wakesFresh ? { mode: "fresh" } : event.continuation;
+  const prompt = wakesFresh && memory.checkpoint ? `The human replied: ${cfg.initialPrompt}
+
+${seedFromRestart(memory.checkpoint.contract, memory.checkpoint.path, cfg.journalPromptPath)}` : buildWakePrompt(
+    cfg.initialPrompt,
+    cfg.journalPromptPath,
+    phase.interruption
+  );
+  const prepared = prepareWorkflowTurn(cfg.workflowState, {
+    prompt: cfg.initialPrompt,
+    iteration: nextIteration,
+    configOverride: void 0
+  });
+  return {
+    phase: {
+      kind: "turn_in_flight",
+      prompt,
+      continuation,
+      configOverride: prepared.configOverride
+    },
+    memory: {
+      ...memory,
+      iteration: nextIteration,
+      lastStopPrompt: prompt,
+      lastStopContinuation: continuation,
+      parkedAfterHandover: false,
+      lastRestartHash: wakesFresh && memory.checkpoint ? hashJournalContent(memory.checkpoint.contract.text) : memory.lastRestartHash
+    },
+    actions: [
+      { type: "persist" },
+      {
+        type: "start_turn",
+        restartTokens: wakesFresh ? memory.checkpoint?.contract.tokens : void 0,
+        prompt,
+        continuation,
+        configOverride: prepared.configOverride
+      }
+    ]
+  };
+}
+function transition(phase, memory, event, cfg) {
+  switch (phase.kind) {
+    case "turn_in_flight": {
+      if (event.type === "steer")
+        return handleSteer(phase, memory, event.steer);
+      if (event.type !== "turn_finished") {
+        throw new Error(
+          `runMachine: phase 'turn_in_flight' received unexpected event '${event.type}'`
+        );
+      }
+      return handleTurnInFlight(phase, memory, event, cfg);
+    }
+    case "backing_off": {
+      if (event.type === "steer")
+        return handleSteer(phase, memory, event.steer);
+      if (event.type !== "backoff_elapsed") {
+        throw new Error(
+          `runMachine: phase 'backing_off' received unexpected event '${event.type}'`
+        );
+      }
+      return handleBackingOff(phase, memory, event, cfg);
+    }
+    case "awaiting_attention": {
+      if (event.type !== "woken") {
+        throw new Error(
+          `runMachine: phase 'awaiting_attention' received unexpected event '${event.type}'`
+        );
+      }
+      return handleAwaitingAttention(phase, memory, event, cfg);
+    }
+    case "completed":
+    case "failed":
+    case "cancelled": {
+      throw new Error(
+        `runMachine: step() called on terminal phase '${phase.kind}'`
+      );
+    }
+    default: {
+      const _exhaustive = phase;
+      throw new Error(
+        `runMachine: step() called on unrecognized phase kind '${_exhaustive.kind}'`
+      );
+    }
+  }
+}
+function admitResult(result, previous, cfg) {
+  const action = result.actions.find(
+    (a) => a.type === "start_turn" || a.type === "wait"
+  );
+  if (!action) return result;
+  const memory = result.memory;
+  const bounded = memory.contextKey === cfg.contextKey ? memory.lastBoundedTurn : null;
+  const fresh = action.type === "start_turn" && action.continuation.mode === "fresh";
+  const context = bounded?.openingContextTokens != null && bounded.lastContextTokens != null ? {
+    opening: bounded.openingContextTokens,
+    ceiling: bounded.lastContextTokens,
+    required: Math.max(
+      0,
+      (memory.checkpoint?.contract.tokens ?? 0) - (bounded.openingRestartTokens ?? 0)
+    ),
+    source: "conservative last API occupancy, not a measured compaction threshold"
+  } : void 0;
+  const stop = admitContinuation({
+    loop: cfg.loop,
+    iteration: memory.iteration,
+    tokens: memory.cumulativeTokens,
+    checkpointPath: memory.checkpoint?.path,
+    context: fresh ? context : void 0
+  });
+  if (!stop)
+    return deliverPendingSteers(
+      fresh ? {
+        ...result,
+        memory: { ...memory, activeRestartTokens: action.restartTokens ?? 0 }
+      } : result
+    );
+  return parkResource(
+    {
+      ...memory,
+      iteration: previous?.iteration ?? memory.iteration,
+      lastRestartHash: previous?.lastRestartHash,
+      lastStopPrompt: previous?.lastStopPrompt ?? memory.lastStopPrompt,
+      lastStopContinuation: previous?.lastStopContinuation ?? memory.lastStopContinuation,
+      pendingSteers: previous?.pendingSteers ?? memory.pendingSteers
+    },
+    {
+      ...stop,
+      fresh: stop.fresh || !!memory.checkpoint || memory.parkedAfterHandover
+    },
+    result.actions.filter(
+      (a) => a.type === "notify_handover_completed" || a.type === "notify_iteration_complete"
+    )
+  );
+}
+function parkResource(memory, stop, notifications = []) {
+  const interruption = resourceInterruption(stop);
+  return {
+    phase: {
+      kind: "awaiting_attention",
+      stopReason: interruption.message,
+      interruption
+    },
+    memory: { ...memory, parkedAfterHandover: stop.fresh },
+    actions: [
+      { type: "record_interruption", interruption },
+      { type: "persist" },
+      ...notifications
+    ]
+  };
+}
+function createInitialRun(cfg, opts) {
+  return admitResult(initialRun(cfg, opts), opts.resumedMemory, cfg);
+}
+function step(phase, memory, event, cfg) {
+  if (event.type === "resource_exhausted")
+    return parkResource(
+      {
+        ...memory,
+        cumulativeTokens: event.cumulativeTokens
+      },
+      { ...event.stop, checkpointPath: memory.checkpoint?.path }
+    );
+  return admitResult(transition(phase, memory, event, cfg), memory, cfg);
+}
+function serializeRunMemory(memory) {
+  return JSON.stringify(memory);
+}
+function deserializeRunMemory(json) {
+  if (!json) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const candidate = parsed;
+  if (!("lastJournalHash" in candidate) && "lastTrackerHash" in candidate) {
+    candidate.lastJournalHash = candidate.lastTrackerHash;
+    delete candidate.lastTrackerHash;
+  }
+  const continuation = candidate.lastStopContinuation;
+  if (!("pendingSteers" in candidate)) candidate.pendingSteers = [];
+  if (typeof candidate.parkedAfterHandover !== "boolean") {
+    candidate.parkedAfterHandover = false;
+  }
+  if (!isBoundedTurn(candidate.lastBoundedTurn)) {
+    candidate.lastBoundedTurn = null;
+  }
+  if (candidate.checkpoint !== void 0) {
+    const checkpoint = candidate.checkpoint;
+    if (!checkpoint || typeof checkpoint.path !== "string" || !checkpoint.contract || typeof checkpoint.contract.text !== "string" || typeof checkpoint.contract.tokens !== "number" || !Number.isFinite(checkpoint.contract.tokens) || checkpoint.contract.tokens < 0)
+      delete candidate.checkpoint;
+  }
+  if (typeof candidate.lastRestartHash !== "string")
+    delete candidate.lastRestartHash;
+  if (typeof candidate.cumulativeTokens !== "number" || !Number.isFinite(candidate.cumulativeTokens) || candidate.cumulativeTokens < 0)
+    candidate.cumulativeTokens = null;
+  if (typeof candidate.iteration !== "number" || typeof candidate.nudgeStreak !== "number" || typeof candidate.retryStreak !== "number" || candidate.lastJournalHash !== null && typeof candidate.lastJournalHash !== "string" || typeof candidate.lastStopPrompt !== "string" || !continuation || typeof continuation.mode !== "string" || !Array.isArray(candidate.pendingSteers) || !candidate.pendingSteers.every(isQueuedSteer)) {
+    return null;
+  }
+  return candidate;
+}
+function wakesFreshAfterHandover(runMemoryJson) {
+  return deserializeRunMemory(runMemoryJson)?.parkedAfterHandover === true;
+}
+function isBoundedTurn(value) {
+  if (!value || typeof value !== "object") return false;
+  const turn = value;
+  return ["openingContextTokens", "lastContextTokens", "toolCalls"].every(
+    (key) => turn[key] === null || typeof turn[key] === "number"
+  );
+}
+function isQueuedSteer(value) {
+  if (!value || typeof value !== "object") return false;
+  const steer = value;
+  return typeof steer.text === "string" && (steer.origin === "hub" || steer.origin === "local") && typeof steer.receivedAt === "number";
+}
+
+// src/core/workflows/workflowRunner.ts
+var NULL_TOKENS = {
+  input: null,
+  output: null,
+  cacheRead: null,
+  cacheWrite: null,
+  total: null,
+  contextSize: null,
+  contextWindowSize: null
+};
+var JOURNAL_SKELETON_TEMPLATE = `${JOURNAL_SKELETON_MARKER}
+# Workflow Journal
+
+**Session**: {sessionId}
+**Journal**: {journalPath}
+**Goal**: {input}
+
+---
+
+> This journal was created by the runner. Update it as you work.
+> See the Turn Protocol for journal conventions.
+
+## Status
+
+Orientation in progress.
+
+## Plan
+
+_To be created during orientation._
+
+## Progress
+
+_No progress yet._
+`;
+function openRunSection(journalPath, opts) {
+  let existing;
+  try {
+    existing = fs12.readFileSync(journalPath, "utf-8");
+  } catch {
+    return;
+  }
+  const banner = `
+
+---
+
+## New Workflow Run
+
+**Run**: ${opts.runId}
+**Goal**: ${opts.goal}
+
+_Sections above belong to earlier Workflow Runs in this Athena Session._
+`;
+  try {
+    fs12.writeFileSync(
+      journalPath,
+      demoteTerminalMarkers(existing.trimEnd(), opts.markers) + banner,
+      "utf-8"
+    );
+  } catch {
+  }
+}
+function recordSteersInJournal(journalPath, steers, iteration, markers) {
+  let existing;
+  try {
+    existing = fs12.readFileSync(journalPath, "utf-8");
+  } catch {
+    return;
+  }
+  const entries = steers.map((steer) => formatSteerJournalEntry(steer, iteration)).join("");
+  try {
+    fs12.writeFileSync(
+      journalPath,
+      insertAboveTerminalMarker(existing, entries, markers),
+      "utf-8"
+    );
+  } catch {
+  }
+}
+function appendInterruptionNote(journalPath, interruption) {
+  const lines = [
+    "",
+    "",
+    "---",
+    "",
+    "## Needs human (runner note)",
+    "",
+    interruption.message,
+    ""
+  ];
+  if (interruption.kind === "question") {
+    if (interruption.question) lines.push(`- call: ${interruption.question}`);
+    if (interruption.requestId)
+      lines.push(`- request: ${interruption.requestId}`);
+    lines.push(
+      "",
+      "_Written by the runner: the request above was deferred and this run is parked until a human answers it. On continue the agent re-issues the call; a stored answer is replayed into it without asking again._"
+    );
+  } else {
+    lines.push(
+      "_Written by the runner: this run is parked until a human replies._"
+    );
+  }
+  try {
+    fs12.appendFileSync(journalPath, lines.join("\n") + "\n", "utf-8");
+  } catch {
+  }
+}
+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
+  };
+}
+async function delayWithCancel(ms, isCancelled) {
+  const slice = 250;
+  for (let waited = 0; waited < ms && !isCancelled(); waited += slice) {
+    await new Promise(
+      (resolve) => setTimeout(resolve, Math.min(slice, ms - waited))
+    );
+  }
+}
+function readUnitRecords(journalAbsPath) {
+  const unitsDir = path10.join(path10.dirname(journalAbsPath), "units");
+  let names;
+  try {
+    names = fs12.readdirSync(unitsDir).filter((name) => name.endsWith(".md"));
+  } catch {
+    return [];
+  }
+  const records = [];
+  for (const name of names.sort()) {
+    try {
+      records.push({
+        recordPath: `units/${name}`,
+        content: fs12.readFileSync(path10.join(unitsDir, name), "utf-8")
+      });
+    } catch {
+    }
+  }
+  return records;
+}
+function defaultCreateJournal(journalPath, content) {
+  fs12.mkdirSync(path10.dirname(journalPath), { recursive: true });
+  try {
+    fs12.writeFileSync(journalPath, content, { encoding: "utf-8", flag: "wx" });
+  } catch (e) {
+    if (e.code !== "EEXIST") throw e;
+  }
+}
+function isTerminalPhase(phase) {
+  return phase.kind === "awaiting_attention" || phase.kind === "completed" || phase.kind === "failed" || phase.kind === "cancelled";
+}
+function terminalPhaseToStatus(phase) {
+  switch (phase.kind) {
+    case "awaiting_attention":
+      return { status: "awaiting_attention", stopReason: phase.stopReason };
+    case "completed":
+      return { status: "completed" };
+    case "failed":
+      return { status: "failed", stopReason: phase.stopReason };
+    case "cancelled":
+      return { status: "cancelled" };
+  }
+}
+function createWorkflowRunner(input) {
+  const runId = input.resumeRunId ?? crypto3.randomUUID();
+  let cancelled = false;
+  let status = "running";
+  let cumulativeTokens = {
+    ...input.resumedRunMemory?.usage ?? NULL_TOKENS,
+    total: input.resumedRunMemory?.cumulativeTokens ?? null
+  };
+  let stopReason;
+  let interruption;
+  let memory;
+  const preStartSteers = [];
+  let applySteer = null;
+  const journalResolved = resolveJournalPath({
+    projectDir: input.projectDir,
+    sessionId: input.sessionId,
+    workflow: input.workflow
+  });
+  const journalAbsPath = journalResolved?.absolutePath ?? null;
+  const journalPromptPath = journalResolved?.promptPath;
+  function snapshot() {
+    const adapterSessionId = input.currentAdapterSessionId?.() ?? void 0;
+    return {
+      runId,
+      sessionId: input.sessionId,
+      workflowName: input.workflow?.name,
+      iteration: memory?.iteration ?? 0,
+      maxIterations: input.workflow?.loop?.maxIterations ?? 1,
+      status,
+      stopReason,
+      journalPath: journalPromptPath,
+      ...adapterSessionId ? { adapterSessionId } : {},
+      ...memory ? { runMemoryJson: serializeRunMemory(memory) } : {},
+      ...interruption ? { interruption } : {}
+    };
+  }
+  let persistenceFailure;
+  const hasPersistenceFailure = () => persistenceFailure !== void 0;
+  function persist() {
+    if (persistenceFailure) throw persistenceFailure;
+    try {
+      input.persistRunState(snapshot());
+    } catch (cause) {
+      persistenceFailure = new Error(
+        "Workflow state could not be saved; continuation is unsafe.",
+        { cause }
+      );
+      cancelled = true;
+      input.abortCurrentTurn?.();
+      throw persistenceFailure;
+    }
+  }
+  const phaseTracker = createPhaseTracker();
+  function observePhase(journalContent, turn) {
+    const observation = phaseTracker.observe(journalContent);
+    if (observation.kind === "new_step") {
+      const { name, index, total } = observation.step;
+      input.onPhaseChange?.({
+        runId,
+        turn,
+        step: name,
+        ...index !== void 0 ? { stepIndex: index } : {},
+        ...total !== void 0 ? { stepTotal: total } : {}
+      });
+    } else if (observation.kind === "malformed" && observation.warning) {
+      input.onWarning?.(observation.warning);
+    }
+  }
+  const result = (async () => {
+    await Promise.resolve();
+    if (journalAbsPath && input.workflow?.loop?.enabled) {
+      const content = substituteVariables(JOURNAL_SKELETON_TEMPLATE, {
+        sessionId: input.sessionId,
+        journalPath: journalPromptPath,
+        input: input.prompt
+      });
+      const write = input.createJournal ?? defaultCreateJournal;
+      const journalExisted = fs12.existsSync(journalAbsPath);
+      write(journalAbsPath, content);
+      if (journalExisted && !input.resumeRunId) {
+        openRunSection(journalAbsPath, {
+          runId,
+          goal: input.prompt,
+          markers: {
+            completionMarker: input.workflow.loop.completionMarker,
+            needsHumanMarker: input.workflow.loop.needsHumanMarker,
+            blockedMarker: input.workflow.loop.blockedMarker
+          }
+        });
+      }
+    }
+    const workflowState = createWorkflowRunState({
+      projectDir: input.projectDir,
+      sessionId: input.sessionId,
+      workflow: input.workflow,
+      harness: input.harness
+    });
+    const loop = input.workflow?.loop;
+    const cfg = {
+      runId,
+      contextKey: crypto3.randomUUID(),
+      workflowState,
+      initialPrompt: input.prompt,
+      loop,
+      journalAbsPath,
+      journalPromptPath
+    };
+    const initial = createInitialRun(cfg, {
+      initialContinuation: input.initialContinuation,
+      waking: !!(input.resumeRunId && loop?.enabled),
+      resumedMemory: input.resumedRunMemory,
+      initialSteers: preStartSteers.splice(0),
+      parkedInterruption: input.parkedInterruption,
+      awaitingAttentionStopReason: input.resumedStopReason
+    });
+    let phase = initial.phase;
+    memory = initial.memory;
+    persist();
+    applySteer = (steer) => {
+      if (persistenceFailure) return false;
+      if (isTerminalPhase(phase)) return false;
+      const stepResult = step(phase, memory, { type: "steer", steer }, cfg);
+      phase = stepResult.phase;
+      memory = stepResult.memory;
+      try {
+        runSideEffects(stepResult.actions);
+      } catch (error) {
+        if (!hasPersistenceFailure()) throw error;
+        return false;
+      }
+      return true;
+    };
+    async function executeOperation(turn) {
+      const baseline = { ...cumulativeTokens };
+      const startTokens = memory.cumulativeTokens ?? 0;
+      let operationTokens = 0;
+      let finished = false;
+      let openingChecked = false;
+      let stopped = null;
+      const isStopped = () => stopped !== null;
+      let resolveStop;
+      const stopPromise = new Promise((resolve) => {
+        resolveStop = resolve;
+      });
+      function finalStop(event) {
+        const total = memory.cumulativeTokens ?? startTokens;
+        return {
+          ...event,
+          cumulativeTokens: total,
+          stop: {
+            ...event.stop,
+            ...event.stop.cause === "tokens" ? { used: total } : {}
+          }
+        };
+      }
+      function stop(reason) {
+        if (finished || stopped || cancelled) return;
+        stopped = reason;
+        const checkpoint = journalAbsPath ? checkpointFromJournal(readJournal(journalAbsPath)) : null;
+        if (checkpoint) memory = { ...memory, checkpoint };
+        input.abortCurrentTurn?.();
+        resolveStop({
+          type: "resource_exhausted",
+          stop: reason,
+          cumulativeTokens: memory.cumulativeTokens ?? startTokens
+        });
+      }
+      function observe(usage, enforce = true) {
+        if (finished) return;
+        if (usage.total !== null && Number.isFinite(usage.total) && usage.total >= 0) {
+          operationTokens = Math.max(operationTokens, usage.total);
+          memory = {
+            ...memory,
+            cumulativeTokens: startTokens + operationTokens
+          };
+          cumulativeTokens = {
+            ...mergeTokens(baseline, usage),
+            total: memory.cumulativeTokens
+          };
+          memory = { ...memory, usage: cumulativeTokens };
+          persist();
+        }
+        if (!enforce || stopped) return;
+        const limit = admitContinuation({
+          loop,
+          iteration: memory.iteration,
+          tokens: memory.cumulativeTokens
+        });
+        if (limit) {
+          stop(limit);
+          return;
+        }
+        if (!openingChecked && turn.continuation.mode === "fresh" && usage.openingContextSize != null) {
+          openingChecked = true;
+          const previous = memory.contextKey === cfg.contextKey ? memory.lastBoundedTurn : null;
+          const required = memory.checkpoint ? 0 : estimateTokenCount(
+            journalAbsPath ? readJournal(journalAbsPath) : ""
+          );
+          const decision = admitContinuation({
+            loop,
+            iteration: memory.iteration,
+            tokens: memory.cumulativeTokens,
+            context: {
+              opening: usage.openingContextSize,
+              required,
+              ceiling: previous?.lastContextTokens ?? loop?.maxTurnTokenCount ?? DEFAULT_MAX_TURN_TOKEN_COUNT,
+              source: previous ? "conservative prior API occupancy" : "configured ceiling estimate; actual compaction point unknown"
+            }
+          });
+          if (decision) stop(decision);
+        }
+      }
+      try {
+        const operation = input.startTurn({
+          ...turn,
+          onUsage: (usage) => {
+            if (persistenceFailure) return;
+            try {
+              observe(usage);
+            } catch (error) {
+              if (!hasPersistenceFailure()) throw error;
+            }
+          }
+        });
+        const result2 = await Promise.race([operation, stopPromise]);
+        if (persistenceFailure) throw persistenceFailure;
+        if ("type" in result2) {
+          let timer;
+          try {
+            const final = await Promise.race([
+              operation.catch(() => null),
+              new Promise((resolve) => {
+                timer = setTimeout(() => resolve(null), 6e3);
+              })
+            ]);
+            if (final) observe(final.tokens, false);
+          } finally {
+            if (timer) clearTimeout(timer);
+          }
+          return finalStop(result2);
+        }
+        observe(result2.tokens, false);
+        if (isStopped()) return finalStop(await stopPromise);
+        return result2;
+      } finally {
+        finished = true;
+      }
+    }
+    async function performStartTurn(prompt, continuation, configOverride) {
+      const turnResult = await executeOperation({
+        prompt: loop?.enabled && journalAbsPath && (continuation.mode === "fresh" || memory.iteration === 1) ? prompt + "\n\n" + restartInstructions(journalAbsPath, runId, loop.maxRestartTokens) : prompt,
+        continuation,
+        configOverride,
+        iteration: memory.iteration
+      });
+      if ("type" in turnResult) return turnResult;
+      const measured = {
+        openingContextTokens: turnResult.tokens.openingContextSize ?? null,
+        lastContextTokens: turnResult.tokens.contextSize,
+        toolCalls: input.currentTurnToolCalls?.() ?? null
+      };
+      if (cancelled) {
+        return {
+          type: "turn_finished",
+          cancelled: true,
+          hasError: false,
+          exitCode: null,
+          streamMessage: null,
+          transportBroken: false,
+          handoverRequestHandle: null,
+          interruption: null,
+          adapterSessionId: null,
+          outcome: null,
+          journalContent: "",
+          ...measured,
+          shedIntegrity: null,
+          cumulativeTokens: null
+        };
+      }
+      const runTotal = cumulativeTokens.total;
+      const handoverRequest = input.handover?.takeRequest() ?? null;
+      if (handoverRequest) {
+        const journalContent2 = loop?.enabled && journalAbsPath ? readJournal(journalAbsPath) : "";
+        return {
+          type: "turn_finished",
+          cancelled: false,
+          hasError: false,
+          exitCode: null,
+          streamMessage: null,
+          transportBroken: false,
+          handoverRequestHandle: handoverRequest.handle,
+          interruption: null,
+          adapterSessionId: null,
+          outcome: null,
+          journalContent: journalContent2,
+          checkpoint: journalAbsPath ? checkpointFromJournal(journalContent2) : null,
+          ...measured,
+          shedIntegrity: observeShedIntegrity(journalContent2),
+          cumulativeTokens: runTotal
+        };
+      }
+      const interruption2 = input.checkInterruption?.() ?? null;
+      if (interruption2) {
+        return {
+          type: "turn_finished",
+          cancelled: false,
+          hasError: false,
+          exitCode: null,
+          streamMessage: null,
+          transportBroken: false,
+          handoverRequestHandle: null,
+          interruption: interruption2,
+          adapterSessionId: null,
+          outcome: null,
+          journalContent: "",
+          ...measured,
+          shedIntegrity: null,
+          cumulativeTokens: runTotal
+        };
+      }
+      const adapterSessionId = input.currentAdapterSessionId?.() ?? null;
+      const hasError = !!turnResult.error;
+      const failed = hasError || turnResult.exitCode !== null && turnResult.exitCode !== 0;
+      if (failed) {
+        return {
+          type: "turn_finished",
+          cancelled: false,
+          hasError,
+          errorMessage: turnResult.error?.message,
+          exitCode: turnResult.exitCode,
+          lastStderr: turnResult.lastStderr,
+          stderrTail: turnResult.stderrTail,
+          streamMessage: turnResult.streamMessage,
+          transportBroken: false,
+          handoverRequestHandle: null,
+          interruption: null,
+          adapterSessionId,
+          outcome: null,
+          journalContent: "",
+          ...measured,
+          shedIntegrity: null,
+          cumulativeTokens: runTotal
+        };
+      }
+      const transport = turnResult.diagnostics?.transport;
+      const transportBroken = !!(transport && transport.streamToolUses > 0 && transport.preToolUseEvents === 0);
+      let journalContent = "";
+      let outcome = null;
+      if (!transportBroken && loop?.enabled && journalAbsPath) {
+        journalContent = readJournal(journalAbsPath);
+        outcome = resolveTurnOutcome({
+          journalPath: journalAbsPath,
+          loop,
+          iteration: memory.iteration
+        });
+        observePhase(journalContent, memory.iteration);
+      }
+      return {
+        type: "turn_finished",
+        cancelled: false,
+        hasError: false,
+        exitCode: turnResult.exitCode,
+        streamMessage: turnResult.streamMessage,
+        transportBroken,
+        handoverRequestHandle: null,
+        interruption: null,
+        adapterSessionId,
+        outcome,
+        journalContent,
+        checkpoint: checkpointFromJournal(journalContent),
+        ...measured,
+        shedIntegrity: journalContent === "" ? null : observeShedIntegrity(journalContent),
+        cumulativeTokens: runTotal
+      };
+    }
+    function observeShedIntegrity(journalContent) {
+      if (!journalAbsPath || !loop?.enabled) return null;
+      try {
+        return checkShedIntegrity(
+          journalContent,
+          readUnitRecords(journalAbsPath)
+        );
+      } catch {
+        return null;
+      }
+    }
+    function checkpointFromJournal(content) {
+      const contract = readRestartContract(
+        content,
+        loop?.maxRestartTokens,
+        runId
+      );
+      return contract && journalAbsPath ? { path: journalAbsPath, contract } : null;
+    }
+    async function performWait(ms) {
+      await delayWithCancel(ms, () => cancelled);
+      if (cancelled) {
+        return {
+          type: "backoff_elapsed",
+          cancelled: true,
+          adapterSessionId: null
+        };
+      }
+      const adapterSessionId = input.currentAdapterSessionId?.() ?? null;
+      return { type: "backoff_elapsed", cancelled: false, adapterSessionId };
+    }
+    function isKickoffAction(action) {
+      return action.type === "start_turn" || action.type === "wait";
+    }
+    function runSideEffects(actions) {
+      let kickoff = null;
+      for (const action of actions) {
+        if (isKickoffAction(action)) {
+          kickoff = action;
+          continue;
+        }
+        switch (action.type) {
+          case "persist":
+            persist();
+            if (journalAbsPath && input.projectTasks) {
+              try {
+                const tasks = projectJournalTasks(journalAbsPath);
+                if (tasks) input.projectTasks(tasks);
+              } catch {
+              }
+            }
+            break;
+          case "warn":
+            input.onWarning?.(action.message);
+            break;
+          case "notify_iteration_complete":
+            input.onIterationComplete?.(snapshot(), cumulativeTokens);
+            break;
+          case "notify_handover_completed":
+            input.onHandoverCompleted?.({
+              ...action.completion,
+              tokens: cumulativeTokens
+            });
+            break;
+          case "steers_delivered":
+            if (journalAbsPath && loop?.enabled) {
+              recordSteersInJournal(
+                journalAbsPath,
+                action.steers,
+                action.iteration,
+                {
+                  completionMarker: loop.completionMarker,
+                  needsHumanMarker: loop.needsHumanMarker,
+                  blockedMarker: loop.blockedMarker
+                }
+              );
+            }
+            input.onSteerDelivered?.(
+              action.steers.map((steer) => ({
+                ...steer,
+                iteration: action.iteration
+              }))
+            );
+            break;
+          case "record_interruption":
+            interruption = action.interruption;
+            if (journalAbsPath && !(action.interruption.kind === "cap_exhausted" && action.interruption.resource)) {
+              appendInterruptionNote(journalAbsPath, action.interruption);
+            }
+            break;
+        }
+      }
+      return kickoff;
+    }
+    async function runActions(actions) {
+      const kickoff = runSideEffects(actions);
+      if (!kickoff) return null;
+      switch (kickoff.type) {
+        case "start_turn":
+          return performStartTurn(
+            kickoff.prompt,
+            kickoff.continuation,
+            kickoff.configOverride
+          );
+        case "wait":
+          return performWait(kickoff.ms);
+        default:
+          return null;
+      }
+    }
+    let bootstrapActions = initial.actions;
+    if (phase.kind === "awaiting_attention" && input.resumeRunId && initial.actions.length === 0) {
+      const wokenEvent = {
+        type: "woken",
+        continuation: input.initialContinuation ?? { mode: "fresh" },
+        // Prefer a repaired current-run checkpoint when waking.
+        checkpoint: journalAbsPath ? checkpointFromJournal(readJournal(journalAbsPath)) : null
+      };
+      const stepResult = step(phase, memory, wokenEvent, cfg);
+      phase = stepResult.phase;
+      memory = stepResult.memory;
+      bootstrapActions = stepResult.actions;
+    }
+    if (isTerminalPhase(phase)) {
+      const terminal = terminalPhaseToStatus(phase);
+      status = terminal.status;
+      stopReason = terminal.stopReason;
+    }
+    let pendingEvent = await runActions(bootstrapActions);
+    while (pendingEvent) {
+      const stepResult = step(phase, memory, pendingEvent, cfg);
+      phase = stepResult.phase;
+      memory = stepResult.memory;
+      if (isTerminalPhase(phase)) {
+        const terminal = terminalPhaseToStatus(phase);
+        status = terminal.status;
+        stopReason = terminal.stopReason;
+        await runActions(stepResult.actions);
+        break;
+      }
+      pendingEvent = await runActions(stepResult.actions);
+    }
+    return {
+      runId,
+      status,
+      iterations: memory.iteration,
+      stopReason,
+      ...interruption ? { interruption } : {},
+      tokens: cumulativeTokens
+    };
+  })().catch((error) => {
+    if (!persistenceFailure) throw error;
+    return {
+      runId,
+      status: "failed",
+      iterations: memory?.iteration ?? 0,
+      stopReason: persistenceFailure.message,
+      tokens: cumulativeTokens
+    };
+  });
+  return {
+    runId,
+    result,
+    cancel() {
+      cancelled = true;
+    },
+    kill() {
+      cancelled = true;
+      input.abortCurrentTurn?.();
+    },
+    steer(steer) {
+      if (applySteer) return applySteer(steer);
+      preStartSteers.push(steer);
+      return true;
+    }
+  };
+}
+
+// src/infra/plugins/mcpOptions.ts
+import fs13 from "fs";
+import path11 from "path";
+function collectMcpServersWithOptions(pluginDirs) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const dir of pluginDirs) {
+    const mcpPath = path11.join(dir, ".mcp.json");
+    if (!fs13.existsSync(mcpPath)) {
+      continue;
+    }
+    const config = JSON.parse(fs13.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 {
+  DEFAULT_MAX_TURN_TOKEN_COUNT,
+  DEFAULT_PERMISSION_GRACE_MS,
+  createSteerQueue,
+  deserializeRunMemory,
+  wakesFreshAfterHandover,
+  createWorkflowRunner,
+  isMarketplaceRef,
+  findMarketplaceRepoDir,
+  resolveWorkflowMarketplaceSource,
+  listMarketplaceWorkflows,
+  listMarketplaceWorkflowsFromRepo,
+  resolveMarketplaceWorkflow,
+  gatherMarketplaceWorkflowSources,
+  resolveWorkflowInstall,
+  pullMarketplaceRepo,
+  resolveMarketplacePlugin,
+  projectConfigPath,
+  readConfig,
+  resolveActiveWorkflow,
+  readGlobalConfig,
+  writeGlobalConfig,
+  writeProjectConfig,
+  hasProjectWorkflow,
+  installWorkflowPlugins,
+  resolveWorkflowPlugins,
+  listBuiltinWorkflows,
+  readWorkflowSourceMetadata,
+  workflowRegistryDir,
+  resolveWorkflow,
+  installWorkflowFromSource,
+  updateWorkflow,
+  updateWorkflows,
+  listWorkflows,
+  removeWorkflow,
+  compileWorkflowPlan,
+  collectMcpServersWithOptions
+};
+//# sourceMappingURL=chunk-QVRTU2MM.js.map