@open330/oac 2026.2.5

package/dist/chunk-4IUL7ECC.js

@@ -0,0 +1,3152 @@
+import {
+  cloneRepo,
+  resolveRepo
+} from "./chunk-CJAJ4MBO.js";
+import {
+  CompositeScanner,
+  GitHubIssuesScanner,
+  LintScanner,
+  TestGapScanner,
+  TodoScanner,
+  analyzeCodebase,
+  buildScanners,
+  createBacklog,
+  getPendingEpics,
+  groupFindingsIntoEpics,
+  isContextStale,
+  loadBacklog,
+  loadContext,
+  persistBacklog,
+  persistContext,
+  rankTasks,
+  updateBacklog
+} from "./chunk-OTPXGXO7.js";
+import {
+  buildEpicExecutionPlan,
+  buildExecutionPlan,
+  estimateEpicTokens,
+  estimateTokens
+} from "./chunk-5GAUWC3L.js";
+import {
+  adapterRegistry,
+  createSandbox,
+  epicAsTask,
+  executeTask
+} from "./chunk-QPVNC7S4.js";
+import {
+  UNLIMITED_BUDGET,
+  createEventBus,
+  loadConfig
+} from "./chunk-7C7SC4TZ.js";
+import {
+  isRecord,
+  truncate
+} from "./chunk-6A37SKAJ.js";
+import {
+  contributionLogSchema,
+  writeContributionLog
+} from "./chunk-LQC5DLT7.js";
+
+// src/cli/cli.ts
+import { Command as Command13 } from "commander";
+
+// src/cli/commands/analyze.ts
+import Table from "cli-table3";
+import { Command as Command2 } from "commander";
+
+// src/cli/github-auth.ts
+import { execFileSync, spawnSync } from "child_process";
+function ensureGitHubAuth() {
+  const githubToken = process.env.GITHUB_TOKEN?.trim();
+  if (githubToken) {
+    process.env.GITHUB_TOKEN = githubToken;
+    return githubToken;
+  }
+  const ghToken = process.env.GH_TOKEN?.trim();
+  if (ghToken) {
+    process.env.GITHUB_TOKEN = ghToken;
+    return ghToken;
+  }
+  try {
+    const token = execFileSync("gh", ["auth", "token"], {
+      timeout: 5e3,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (token.length > 0) {
+      process.env.GITHUB_TOKEN = token;
+      return token;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function checkGitHubScopes(required = ["repo"]) {
+  try {
+    const result = spawnSync("gh", ["auth", "status"], {
+      timeout: 5e3,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const combined = `${result.stdout ?? ""}${result.stderr ?? ""}`;
+    const scopeLine = combined.match(/Token scopes:\s*(.+)/);
+    if (!scopeLine) return [];
+    const scopes = scopeLine[1].split(",").map((s) => s.trim().replace(/^'|'$/g, ""));
+    return required.filter((r) => !scopes.includes(r));
+  } catch {
+    return [];
+  }
+}
+
+// src/cli/helpers.ts
+import chalk, { Chalk } from "chalk";
+import "commander";
+import ora from "ora";
+import PQueue from "p-queue";
+
+// src/cli/config-loader.ts
+import { constants as fsConstants } from "fs";
+import { access, readFile } from "fs/promises";
+import { resolve } from "path";
+import { pathToFileURL } from "url";
+var DEFINE_CONFIG_IMPORT = /@(?:open330\/oac(?:-core)?|oac\/core)/;
+var DEFINE_CONFIG_IMPORT_LINE = /^\s*import\s*\{\s*defineConfig\s*\}\s*from\s*["']@(?:open330\/oac(?:-core)?|oac\/core)["'];\s*$/m;
+var LEGACY_DEFINE_CONFIG_EXPORT = /export\s+default\s+defineConfig\s*\(/;
+async function loadOptionalConfigFile(configPath, options = {}) {
+  const absolutePath = resolve(options.cwd ?? process.cwd(), configPath);
+  if (!await pathExists(absolutePath)) {
+    return null;
+  }
+  try {
+    const candidate = await importConfigCandidate(absolutePath);
+    return loadConfig(candidate);
+  } catch (error) {
+    options.onWarning?.(
+      `Failed to load config at ${configPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  }
+}
+async function importConfigCandidate(absolutePath) {
+  try {
+    return await importCandidate(`${pathToFileURL(absolutePath).href}?t=${Date.now()}`);
+  } catch (error) {
+    const fallbackCandidate = await importLegacyDefineConfigCandidate(absolutePath, error);
+    if (fallbackCandidate !== null) {
+      return fallbackCandidate;
+    }
+    throw error;
+  }
+}
+async function importLegacyDefineConfigCandidate(absolutePath, error) {
+  if (!shouldTryLegacyDefineConfigFallback(error)) {
+    return null;
+  }
+  const source = await readFile(absolutePath, "utf8");
+  const transformed = transformLegacyDefineConfigSource(source);
+  if (transformed === null) {
+    return null;
+  }
+  const encodedSource = Buffer.from(transformed, "utf8").toString("base64");
+  return await importCandidate(`data:text/javascript;base64,${encodedSource}`);
+}
+function shouldTryLegacyDefineConfigFallback(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return DEFINE_CONFIG_IMPORT.test(error.message);
+}
+function transformLegacyDefineConfigSource(source) {
+  if (!DEFINE_CONFIG_IMPORT_LINE.test(source)) {
+    return null;
+  }
+  if (!LEGACY_DEFINE_CONFIG_EXPORT.test(source)) {
+    return null;
+  }
+  return source.replace(DEFINE_CONFIG_IMPORT_LINE, "").replace(LEGACY_DEFINE_CONFIG_EXPORT, "export default (");
+}
+async function importCandidate(moduleSpecifier) {
+  const imported = await import(moduleSpecifier);
+  return imported.default ?? imported.config ?? imported;
+}
+async function pathExists(path) {
+  try {
+    await access(path, fsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/helpers.ts
+function getGlobalOptions(command) {
+  const options = command.optsWithGlobals();
+  return {
+    config: options.config ?? "oac.config.ts",
+    verbose: options.verbose === true,
+    quiet: options.quiet === true,
+    json: options.json === true,
+    color: options.color !== false
+  };
+}
+function createUi(options) {
+  const noColorEnv = Object.prototype.hasOwnProperty.call(process.env, "NO_COLOR");
+  const colorEnabled = options.color && !noColorEnv;
+  return new Chalk({ level: colorEnabled ? chalk.level : 0 });
+}
+function createSpinner(suppress, text) {
+  if (suppress) {
+    return null;
+  }
+  return ora({ text, color: "blue" }).start();
+}
+function parseInteger(value) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`Expected an integer but received "${value}".`);
+  }
+  return parsed;
+}
+function formatInteger(value) {
+  return new Intl.NumberFormat("en-US").format(value);
+}
+async function loadOptionalConfig(configPath, verbose, ui) {
+  return loadOptionalConfigFile(configPath, {
+    onWarning: verbose ? (message) => {
+      console.warn(ui.yellow(`[oac] ${message}`));
+    } : void 0
+  });
+}
+function resolveRepoInput(repoOption, config) {
+  const fromFlag = repoOption?.trim();
+  if (fromFlag) {
+    return fromFlag;
+  }
+  const firstConfiguredRepo = config?.repos[0];
+  if (typeof firstConfiguredRepo === "string") {
+    return firstConfiguredRepo;
+  }
+  if (firstConfiguredRepo && typeof firstConfiguredRepo === "object" && "name" in firstConfiguredRepo && typeof firstConfiguredRepo.name === "string") {
+    return firstConfiguredRepo.name;
+  }
+  throw new Error(
+    "No repository specified.\n\n  Quick start:  oac run --repo owner/repo\n  With config:  oac init   (creates oac.config.ts, then just run `oac run`)\n"
+  );
+}
+function resolveProviderId(providerOption, config) {
+  const fromFlag = providerOption?.trim();
+  if (fromFlag) {
+    return fromFlag;
+  }
+  return config?.provider.id ?? "claude-code";
+}
+function resolveBudget(tokensOption, config) {
+  const budget = tokensOption ?? config?.budget.totalTokens ?? 1e5;
+  if (!Number.isFinite(budget) || budget <= 0) {
+    throw new Error("Token budget must be a positive number.");
+  }
+  return Math.floor(budget);
+}
+async function estimateTaskMap(tasks, providerId, onProgress) {
+  let completed = 0;
+  const total = tasks.length;
+  const queue = new PQueue({ concurrency: 10 });
+  const entries = await Promise.all(
+    tasks.map(
+      (task) => queue.add(async () => {
+        const estimate = await estimateTokens(task, providerId);
+        completed += 1;
+        onProgress?.(completed, total);
+        return [task.id, estimate];
+      })
+    )
+  );
+  return new Map(entries);
+}
+
+// src/cli/commands/analyze.ts
+function createAnalyzeCommand() {
+  const command = new Command2("analyze");
+  command.description(
+    "Deep codebase analysis \u2014 build module graph and group findings into epics"
+  ).option("--repo <owner/repo>", "Target repository (owner/repo or GitHub URL)").option("--force", "Force re-analysis even if context is fresh", false).option("--format <format>", "Output format: table|json", "table").action(async (options, cmd) => {
+    const globalOptions = getGlobalOptions(cmd);
+    const ui = createUi(globalOptions);
+    const outputJson = globalOptions.json || normalizeOutputFormat(options.format) === "json";
+    const config = await loadOptionalConfig(globalOptions.config, globalOptions.verbose, ui);
+    const repoInput = resolveRepoInput(options.repo, config);
+    const ghToken = ensureGitHubAuth();
+    const resolveSpinner = createSpinner(outputJson, "Resolving repository...");
+    const resolvedRepo = await resolveRepo(repoInput);
+    resolveSpinner?.succeed(`Resolved ${resolvedRepo.fullName}`);
+    const cloneSpinner = createSpinner(outputJson, "Preparing local clone...");
+    await cloneRepo(resolvedRepo);
+    cloneSpinner?.succeed(`Repository ready at ${resolvedRepo.localPath}`);
+    const scanners = buildScannerList(config, Boolean(ghToken));
+    const analyzeSpinner = createSpinner(outputJson, "Analyzing codebase...");
+    const { codebaseMap, qualityReport } = await analyzeCodebase(resolvedRepo.localPath, {
+      scanners,
+      repoFullName: resolvedRepo.fullName,
+      headSha: resolvedRepo.git.headSha,
+      exclude: config?.discovery.exclude
+    });
+    analyzeSpinner?.succeed(
+      `Analyzed ${codebaseMap.modules.length} modules, ${codebaseMap.totalFiles} files, ${qualityReport.findings.length} findings`
+    );
+    const groupSpinner = createSpinner(outputJson, "Grouping findings into epics...");
+    const epics = groupFindingsIntoEpics(qualityReport.findings, { codebaseMap });
+    groupSpinner?.succeed(`Created ${epics.length} epic(s)`);
+    const contextDir = config?.analyze?.contextDir ?? ".oac/context";
+    const persistSpinner = createSpinner(outputJson, "Persisting context...");
+    await persistContext(resolvedRepo.localPath, codebaseMap, qualityReport, contextDir);
+    const backlog = createBacklog(resolvedRepo.fullName, resolvedRepo.git.headSha, epics);
+    await persistBacklog(resolvedRepo.localPath, backlog, contextDir);
+    persistSpinner?.succeed(`Context persisted to ${contextDir}/`);
+    if (outputJson) {
+      console.log(
+        JSON.stringify(
+          {
+            repo: resolvedRepo.fullName,
+            modules: codebaseMap.modules.length,
+            totalFiles: codebaseMap.totalFiles,
+            totalLoc: codebaseMap.totalLoc,
+            findings: qualityReport.summary,
+            epics: epics.map((e) => ({
+              id: e.id,
+              title: e.title,
+              scope: e.scope,
+              subtasks: e.subtasks.length,
+              priority: e.priority,
+              status: e.status
+            }))
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    if (epics.length === 0) {
+      console.log(ui.yellow("No epics created \u2014 the codebase looks clean."));
+      return;
+    }
+    const table = new Table({
+      head: ["Epic", "Scope", "Subtasks", "Priority", "Status"]
+    });
+    for (const epic of epics) {
+      table.push([
+        truncate(epic.title, 55),
+        epic.scope,
+        String(epic.subtasks.length),
+        String(epic.priority),
+        epic.status
+      ]);
+    }
+    console.log(table.toString());
+    console.log("");
+    console.log(
+      ui.blue(
+        `${epics.length} epic(s) added to backlog. Use \`oac run --repo ${resolvedRepo.fullName}\` to execute.`
+      )
+    );
+  });
+  command.addHelpText(
+    "after",
+    `
+Analyze walks the source tree, builds a module dependency graph, runs all
+scanners, and groups findings into epics persisted to .oac/context/.
+For a quick flat task list without persistence, use \`oac scan\`.
+\`oac run\` auto-analyzes by default \u2014 you only need this command to
+inspect or force-refresh the analysis independently.
+
+Examples:
+  $ oac analyze --repo owner/repo
+  $ oac analyze --repo owner/repo --force
+  $ oac analyze --repo owner/repo --format json`
+  );
+  return command;
+}
+function normalizeOutputFormat(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "table" || normalized === "json") return normalized;
+  throw new Error(`Unsupported --format value "${value}". Use "table" or "json".`);
+}
+function buildScannerList(config, hasGitHubAuth) {
+  return buildScanners(config, hasGitHubAuth).instances;
+}
+
+// src/cli/commands/completion.ts
+import { Command as Command3 } from "commander";
+var SUBCOMMANDS = [
+  "init",
+  "analyze",
+  "doctor",
+  "scan",
+  "plan",
+  "run",
+  "log",
+  "leaderboard",
+  "status",
+  "completion"
+];
+var GLOBAL_OPTIONS = ["--config", "--verbose", "--quiet", "--json", "--no-color", "--help", "--version"];
+var COMMAND_OPTIONS = {
+  run: [
+    "--repo",
+    "--tokens",
+    "--provider",
+    "--concurrency",
+    "--dry-run",
+    "--mode",
+    "--max-tasks",
+    "--timeout",
+    "--source",
+    "--retry-failed"
+  ],
+  scan: ["--repo", "--scanners", "--max-findings"],
+  analyze: ["--repo"],
+  plan: ["--repo", "--tokens", "--provider", "--max-tasks"],
+  log: ["--limit", "--repo", "--source", "--since"],
+  leaderboard: ["--limit", "--repo", "--format"],
+  status: ["--watch"],
+  init: [],
+  doctor: []
+};
+function generateBash() {
+  const cmds = SUBCOMMANDS.join(" ");
+  const global = GLOBAL_OPTIONS.join(" ");
+  const cases = Object.entries(COMMAND_OPTIONS).map(([cmd, opts]) => {
+    const all = [...opts, ...GLOBAL_OPTIONS].join(" ");
+    return `      ${cmd}) COMPREPLY=( $(compgen -W "${all}" -- "$cur") ) ;;`;
+  }).join("\n");
+  return `# bash completion for oac
+_oac_completions() {
+  local cur prev cmds
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  cmds="${cmds}"
+
+  if [[ \${COMP_CWORD} -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "$cmds ${global}" -- "$cur") )
+    return
+  fi
+
+  case "\${COMP_WORDS[1]}" in
+${cases}
+      *) COMPREPLY=( $(compgen -W "${global}" -- "$cur") ) ;;
+  esac
+}
+complete -F _oac_completions oac`;
+}
+function generateZsh() {
+  const cmds = SUBCOMMANDS.map((c) => `'${c}:${c} command'`).join(" ");
+  const cases = Object.entries(COMMAND_OPTIONS).map(([cmd, opts]) => {
+    const flags = [...opts, ...GLOBAL_OPTIONS].map((o) => `'${o}'`).join(" ");
+    return `    ${cmd}) _arguments ${flags} ;;`;
+  }).join("\n");
+  return `#compdef oac
+_oac() {
+  local -a commands
+  commands=(${cmds})
+
+  _arguments '1:command:->cmds' '*::arg:->args'
+
+  case "$state" in
+  cmds) _describe 'command' commands ;;
+  args)
+    case "\${words[1]}" in
+${cases}
+    esac
+    ;;
+  esac
+}
+_oac "$@"`;
+}
+function generateFish() {
+  const lines = ["# fish completion for oac"];
+  for (const cmd of SUBCOMMANDS) {
+    lines.push(`complete -c oac -n '__fish_use_subcommand' -a '${cmd}' -d '${cmd} command'`);
+  }
+  for (const opt of GLOBAL_OPTIONS) {
+    const long = opt.replace(/^--/, "");
+    lines.push(`complete -c oac -l '${long}'`);
+  }
+  for (const [cmd, opts] of Object.entries(COMMAND_OPTIONS)) {
+    for (const opt of opts) {
+      const long = opt.replace(/^--/, "");
+      lines.push(
+        `complete -c oac -n '__fish_seen_subcommand_from ${cmd}' -l '${long}'`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+function createCompletionCommand() {
+  const command = new Command3("completion");
+  command.description("Generate shell completion scripts").argument("<shell>", "Shell type: bash, zsh, or fish").action((shell) => {
+    const generators = { bash: generateBash, zsh: generateZsh, fish: generateFish };
+    const gen = generators[shell];
+    if (!gen) {
+      throw new Error(`Unsupported shell "${shell}". Supported: bash, zsh, fish`);
+    }
+    console.log(gen());
+  });
+  command.addHelpText(
+    "after",
+    `
+Examples:
+  $ oac completion bash >> ~/.bashrc
+  $ oac completion zsh >> ~/.zshrc
+  $ oac completion fish > ~/.config/fish/completions/oac.fish`
+  );
+  return command;
+}
+
+// src/cli/commands/doctor.ts
+import { Command as Command4 } from "commander";
+var MINIMUM_NODE_VERSION = "24.0.0";
+function createDoctorCommand() {
+  const command = new Command4("doctor");
+  command.description("Check local environment readiness").action(async (_options, cmd) => {
+    const globalOptions = getGlobalOptions(cmd);
+    const ui = createUi(globalOptions);
+    const checks = await runDoctorChecks();
+    const allPassed = checks.every((check) => check.status !== "fail");
+    if (globalOptions.json) {
+      console.log(
+        JSON.stringify(
+          {
+            checks,
+            allPassed
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      renderDoctorOutput(ui, checks, allPassed);
+    }
+    if (!allPassed) {
+      process.exitCode = 1;
+    }
+  });
+  command.addHelpText(
+    "after",
+    `
+Examples:
+  $ oac doctor`
+  );
+  return command;
+}
+async function runDoctorChecks() {
+  const checks = [];
+  const nodeVersion = process.versions.node;
+  checks.push({
+    id: "node",
+    name: "Node.js",
+    requirement: `>= ${MINIMUM_NODE_VERSION}`,
+    value: `v${nodeVersion}`,
+    status: isVersionAtLeast(nodeVersion, MINIMUM_NODE_VERSION) ? "pass" : "fail",
+    message: `Node.js ${MINIMUM_NODE_VERSION}+ is required.`
+  });
+  const gitResult = await runCommand("git", ["--version"]);
+  const gitVersion = extractVersion(gitResult.stdout) ?? "--";
+  checks.push({
+    id: "git",
+    name: "git",
+    requirement: "installed",
+    value: gitVersion,
+    status: gitResult.ok ? "pass" : "fail",
+    message: gitResult.ok ? void 0 : explainCommandFailure("git", gitResult)
+  });
+  const githubAuthCheck = await checkGithubAuth();
+  checks.push(githubAuthCheck);
+  const claudeResult = await runCommand("claude", ["--version"]);
+  const claudeVersion = extractVersion(claudeResult.stdout) ?? "--";
+  checks.push({
+    id: "claude-cli",
+    name: "Claude CLI",
+    requirement: "installed",
+    value: claudeVersion,
+    status: claudeResult.ok ? "pass" : "fail",
+    message: claudeResult.ok ? void 0 : explainCommandFailure("claude", claudeResult)
+  });
+  const codexResult = await runCommand("codex", ["--version"]);
+  const codexVersion = extractVersion(codexResult.stdout) ?? "--";
+  checks.push({
+    id: "codex",
+    name: "Codex CLI",
+    requirement: "installed",
+    value: codexVersion,
+    status: codexResult.ok ? "pass" : "fail",
+    message: codexResult.ok ? void 0 : explainCommandFailure("codex", codexResult)
+  });
+  const opencodeResult = await runCommand("opencode", ["--version"]);
+  const opencodeVersion = extractVersion(opencodeResult.stdout) ?? "--";
+  checks.push({
+    id: "opencode",
+    name: "OpenCode CLI",
+    requirement: "installed",
+    value: opencodeVersion,
+    status: opencodeResult.ok ? "pass" : "fail",
+    message: opencodeResult.ok ? void 0 : explainCommandFailure("opencode", opencodeResult)
+  });
+  return checks;
+}
+async function checkGithubAuth() {
+  const envToken = process.env.GITHUB_TOKEN?.trim();
+  if (envToken) {
+    return {
+      id: "github-auth",
+      name: "GitHub auth",
+      requirement: "gh auth status or GITHUB_TOKEN",
+      value: `env:${maskToken(envToken)}`,
+      status: "pass"
+    };
+  }
+  const authResult = await runCommand("gh", ["auth", "status"]);
+  if (authResult.ok) {
+    const hasRepoScope = authResult.stdout.includes("repo");
+    return {
+      id: "github-auth",
+      name: "GitHub auth",
+      requirement: "gh auth status or GITHUB_TOKEN",
+      value: "gh auth status",
+      status: hasRepoScope ? "pass" : "warn",
+      message: hasRepoScope ? void 0 : "Missing 'repo' scope \u2014 private repos won't work. Run: gh auth refresh -s repo"
+    };
+  }
+  return {
+    id: "github-auth",
+    name: "GitHub auth",
+    requirement: "gh auth status or GITHUB_TOKEN",
+    value: "--",
+    status: "fail",
+    message: "No GitHub authentication detected. Set GITHUB_TOKEN or run `gh auth login`."
+  };
+}
+function renderDoctorOutput(ui, checks, allPassed) {
+  console.log("Checking environment...");
+  console.log("");
+  for (const check of checks) {
+    const iconMap = { pass: ui.green("[OK]"), warn: ui.yellow("[!]"), fail: ui.red("[X]") };
+    const statusMap = { pass: ui.green("PASS"), warn: ui.yellow("WARN"), fail: ui.red("FAIL") };
+    const icon = iconMap[check.status];
+    const status = statusMap[check.status];
+    const name = check.name.padEnd(12, " ");
+    const requirement = check.requirement.padEnd(30, " ");
+    const value = check.value.padEnd(14, " ");
+    console.log(`  ${icon} ${name} ${requirement} ${value} ${status}`);
+    if (check.status === "fail" && check.message) {
+      console.log(`    ${ui.red(check.message)}`);
+    }
+    if (check.status === "warn" && check.message) {
+      console.log(`    ${ui.yellow(check.message)}`);
+    }
+  }
+  console.log("");
+  if (allPassed) {
+    console.log(ui.green("All checks passed."));
+  } else {
+    console.log(ui.red("Some checks failed."));
+  }
+}
+function extractVersion(output) {
+  const match = output.match(/v?(\d+\.\d+\.\d+)/i);
+  if (!match) {
+    return void 0;
+  }
+  return `v${match[1]}`;
+}
+function explainCommandFailure(commandName, result) {
+  if (result.errorCode === "ENOENT") {
+    return `${commandName} is not installed or not in PATH.`;
+  }
+  if (result.errorMessage) {
+    return result.errorMessage;
+  }
+  if (result.stderr.trim().length > 0) {
+    return result.stderr.trim();
+  }
+  return `${commandName} exited with code ${String(result.exitCode)}.`;
+}
+function maskToken(token) {
+  if (token.length <= 8) {
+    return `${token.slice(0, 2)}****`;
+  }
+  return `${token.slice(0, 4)}****${token.slice(-2)}`;
+}
+function isVersionAtLeast(version, minimum) {
+  const current = version.split(".").map((part) => Number.parseInt(part, 10));
+  const required = minimum.split(".").map((part) => Number.parseInt(part, 10));
+  const length = Math.max(current.length, required.length);
+  for (let index = 0; index < length; index += 1) {
+    const currentPart = current[index] ?? 0;
+    const requiredPart = required[index] ?? 0;
+    if (currentPart > requiredPart) {
+      return true;
+    }
+    if (currentPart < requiredPart) {
+      return false;
+    }
+  }
+  return true;
+}
+async function runCommand(command, args) {
+  try {
+    const { execa: execa3 } = await import("execa");
+    const result = await execa3(command, args, {
+      reject: false,
+      timeout: 3e4,
+      stdin: "ignore"
+    });
+    return {
+      ok: result.exitCode === 0,
+      exitCode: result.exitCode ?? null,
+      stdout: result.stdout,
+      stderr: result.stderr
+    };
+  } catch (error) {
+    const nodeError = error;
+    return {
+      ok: false,
+      exitCode: null,
+      stdout: "",
+      stderr: "",
+      errorCode: nodeError.code,
+      errorMessage: nodeError.message
+    };
+  }
+}
+
+// src/cli/commands/explain.ts
+import { resolve as resolve2 } from "path";
+import { Command as Command5 } from "commander";
+function createExplainCommand() {
+  const command = new Command5("explain");
+  command.description("Explain why a task or epic was selected and what the agent would do").argument("<id>", "Task or epic ID (from scan / analyze / run --dry-run output)").action(async (id, _options, cmd) => {
+    const globalOptions = getGlobalOptions(cmd);
+    const ui = createUi(globalOptions);
+    const config = await loadOptionalConfig(globalOptions.config, globalOptions.verbose, ui);
+    const contextDir = config?.analyze?.contextDir;
+    const repoPath = resolve2(process.cwd());
+    const [context, backlog] = await Promise.all([
+      loadContext(repoPath, contextDir),
+      loadBacklog(repoPath, contextDir)
+    ]);
+    if (!context && !backlog) {
+      const message = "No analysis context found. Run `oac analyze` first.";
+      if (globalOptions.json) {
+        console.log(JSON.stringify({ error: message }, null, 2));
+      } else {
+        console.error(ui.red(message));
+      }
+      process.exitCode = 1;
+      return;
+    }
+    const finding = context?.qualityReport.findings.find(
+      (f) => f.title === id || f.filePath === id
+    );
+    const epic = backlog?.epics.find(
+      (e) => e.id === id || e.title.toLowerCase().includes(id.toLowerCase())
+    );
+    if (!finding && !epic) {
+      const message = `No task or epic matching "${id}" found in the analysis context.`;
+      if (globalOptions.json) {
+        console.log(JSON.stringify({ error: message, id }, null, 2));
+      } else {
+        console.error(ui.red(message));
+        console.log("");
+        printAvailableIds(ui, context, backlog);
+      }
+      process.exitCode = 1;
+      return;
+    }
+    if (globalOptions.json) {
+      console.log(JSON.stringify({ finding: finding ?? null, epic: epic ?? null }, null, 2));
+      return;
+    }
+    if (epic) {
+      console.log(ui.bold("Epic"));
+      console.log(`  ${ui.blue("ID:")}        ${epic.id}`);
+      console.log(`  ${ui.blue("Title:")}     ${epic.title}`);
+      console.log(`  ${ui.blue("Scope:")}     ${epic.scope}`);
+      console.log(`  ${ui.blue("Priority:")}  ${epic.priority}`);
+      console.log(`  ${ui.blue("Status:")}    ${epic.status}`);
+      console.log(`  ${ui.blue("Tasks:")}     ${epic.subtasks.length}`);
+      console.log("");
+      console.log(ui.dim("Description:"));
+      console.log(`  ${epic.description}`);
+      if (epic.subtasks.length > 0) {
+        console.log("");
+        console.log(ui.dim("Task IDs:"));
+        for (const subtask of epic.subtasks) {
+          console.log(`  - ${subtask.id}`);
+        }
+      }
+    }
+    if (finding) {
+      if (epic) console.log("");
+      console.log(ui.bold("Finding"));
+      console.log(`  ${ui.blue("Title:")}      ${finding.title}`);
+      console.log(`  ${ui.blue("Source:")}     ${finding.source.replace(/-/g, " ")}`);
+      console.log(`  ${ui.blue("Scanner:")}   ${finding.scannerId}`);
+      console.log(`  ${ui.blue("Severity:")}  ${colorSeverity(ui, finding.severity)}`);
+      console.log(`  ${ui.blue("Complexity:")} ${finding.complexity}`);
+      console.log(`  ${ui.blue("File:")}      ${finding.filePath}`);
+      if (finding.module) {
+        console.log(`  ${ui.blue("Module:")}    ${finding.module}`);
+      }
+      if (finding.line) {
+        console.log(`  ${ui.blue("Line:")}      ${finding.line}`);
+      }
+      console.log("");
+      console.log(ui.dim("Description:"));
+      console.log(`  ${finding.description}`);
+      console.log("");
+      console.log(ui.dim("What the agent would do:"));
+      console.log(`  1. Check out a clean branch for this task`);
+      console.log(`  2. Open ${finding.filePath}${finding.line ? ` at line ${finding.line}` : ""}`);
+      console.log(`  3. Apply the fix described above`);
+      console.log(`  4. Run tests and linters to verify`);
+      console.log(`  5. Create a PR with the changes`);
+    }
+  });
+  command.addHelpText(
+    "after",
+    `
+Examples:
+  $ oac explain "Add tests for client.ts"
+  $ oac explain src/lib/client.ts`
+  );
+  return command;
+}
+function colorSeverity(ui, severity) {
+  if (severity === "error") return ui.red(severity);
+  if (severity === "warning") return ui.yellow(severity);
+  return ui.green(severity);
+}
+function printAvailableIds(ui, context, backlog) {
+  const findings = context?.qualityReport.findings ?? [];
+  const epics = backlog?.epics ?? [];
+  if (findings.length > 0) {
+    console.log(ui.dim(`Available findings (${findings.length}):`));
+    for (const f of findings.slice(0, 8)) {
+      console.log(`  - ${f.title}`);
+    }
+    if (findings.length > 8) console.log(ui.dim(`  ... and ${findings.length - 8} more`));
+  }
+  if (epics.length > 0) {
+    console.log(ui.dim(`Available epics (${epics.length}):`));
+    for (const e of epics.slice(0, 8)) {
+      console.log(`  - ${e.id}: ${e.title}`);
+    }
+    if (epics.length > 8) console.log(ui.dim(`  ... and ${epics.length - 8} more`));
+  }
+}
+
+// src/cli/commands/init.ts
+import { constants as fsConstants2 } from "fs";
+import { access as access2, mkdir, readFile as readFile2, writeFile } from "fs/promises";
+import { resolve as resolve3 } from "path";
+import { checkbox, confirm, input } from "@inquirer/prompts";
+import { Command as Command6 } from "commander";
+var OAC_LOGO = [
+  "  ___   _   ___",
+  " / _ \\ /_\\ / __|",
+  "| (_) / _ \\ (__",
+  " \\___/_/ \\_\\___|"
+].join("\n");
+var OWNER_REPO_PATTERN = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+(?:\.git)?$/;
+function createInitCommand() {
+  const command = new Command6("init");
+  command.description("Initialize OAC in the current directory").option("--minimal", "Generate a bare-bones config without the interactive wizard").option("--repo <owner/repo>", "Repository in owner/repo format (required with --minimal)").action(async (options, cmd) => {
+    const globalOptions = getGlobalOptions(cmd);
+    const ui = createUi(globalOptions);
+    if (options.minimal) {
+      await runMinimalInit(options, globalOptions, ui);
+      return;
+    }
+    await runInteractiveInit(globalOptions, ui);
+  });
+  command.addHelpText(
+    "after",
+    `
+Examples:
+  $ oac init                              Interactive wizard
+  $ oac init --minimal --repo owner/repo  Quick start with defaults`
+  );
+  return command;
+}
+async function runMinimalInit(options, globalOptions, ui) {
+  const repoInput = options.repo?.trim();
+  if (!repoInput || !isValidRepoInput(repoInput)) {
+    const message = "--repo is required with --minimal (e.g. --repo owner/repo)";
+    if (globalOptions.json) {
+      console.log(JSON.stringify({ error: message }, null, 2));
+    } else {
+      console.error(ui.red(message));
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const repo = normalizeRepoInput(repoInput);
+  const provider = "claude-code";
+  const budgetTokens = 1e5;
+  const configPath = resolve3(process.cwd(), "oac.config.ts");
+  const trackingDirectory = resolve3(process.cwd(), ".oac");
+  if (await pathExists2(configPath)) {
+    const message = "oac.config.ts already exists. Remove it first or run `oac init` without --minimal.";
+    if (globalOptions.json) {
+      console.log(JSON.stringify({ cancelled: true, reason: message }, null, 2));
+    } else {
+      console.log(ui.yellow(message));
+    }
+    return;
+  }
+  const configContent = buildConfigFile({
+    provider,
+    providers: [provider],
+    budgetTokens,
+    repo
+  });
+  await writeFile(configPath, configContent, "utf8");
+  await mkdir(trackingDirectory, { recursive: true });
+  await ensureGitignoreEntry(process.cwd(), ".oac/");
+  const summary = {
+    configPath,
+    trackingDirectory,
+    provider,
+    providers: [provider],
+    budgetTokens,
+    repo
+  };
+  if (globalOptions.json) {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+  console.log(ui.green("Created: oac.config.ts"));
+  console.log(ui.green("Created: .oac/"));
+  console.log("");
+  console.log("Run `oac run` to start the full pipeline, or `oac doctor` to verify setup.");
+}
+async function runInteractiveInit(globalOptions, ui) {
+  if (!globalOptions.json) {
+    console.log(ui.blue(OAC_LOGO));
+    console.log(ui.bold("Welcome to Open Agent Contribution."));
+    console.log("");
+  }
+  const selectedProviders = await checkbox({
+    message: "Select AI provider(s):",
+    choices: [
+      { name: "Claude Code", value: "claude-code", checked: true },
+      { name: "Codex CLI", value: "codex" },
+      { name: "OpenCode", value: "opencode" }
+    ],
+    validate: (value) => value.length > 0 ? true : "Select at least one provider to continue."
+  });
+  const budgetInput = await input({
+    message: "Monthly token budget:",
+    default: "100000",
+    validate: (value) => {
+      const parsed = Number.parseInt(value, 10);
+      if (!Number.isFinite(parsed) || parsed <= 0) {
+        return "Enter a positive integer.";
+      }
+      return true;
+    }
+  });
+  const firstRepoInput = await input({
+    message: "Add your first repo (owner/repo or GitHub URL):",
+    validate: (value) => {
+      if (isValidRepoInput(value)) {
+        return true;
+      }
+      return "Enter a valid GitHub repo like owner/repo.";
+    }
+  });
+  const repo = normalizeRepoInput(firstRepoInput);
+  const budgetTokens = Number.parseInt(budgetInput, 10);
+  const provider = selectedProviders[0] ?? "claude-code";
+  const configPath = resolve3(process.cwd(), "oac.config.ts");
+  const trackingDirectory = resolve3(process.cwd(), ".oac");
+  if (await pathExists2(configPath)) {
+    const shouldOverwrite = await confirm({
+      message: "oac.config.ts already exists. Overwrite it?",
+      default: false
+    });
+    if (!shouldOverwrite) {
+      if (globalOptions.json) {
+        console.log(
+          JSON.stringify(
+            {
+              cancelled: true,
+              reason: "oac.config.ts exists and overwrite was declined"
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+      console.log(ui.yellow("Initialization cancelled."));
+      return;
+    }
+  }
+  const configContent = buildConfigFile({
+    provider,
+    providers: selectedProviders,
+    budgetTokens,
+    repo
+  });
+  await writeFile(configPath, configContent, "utf8");
+  await mkdir(trackingDirectory, { recursive: true });
+  await ensureGitignoreEntry(process.cwd(), ".oac/");
+  const summary = {
+    configPath,
+    trackingDirectory,
+    provider,
+    providers: selectedProviders,
+    budgetTokens,
+    repo
+  };
+  if (globalOptions.json) {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+  console.log(ui.green("Created: oac.config.ts"));
+  console.log(ui.green("Created: .oac/"));
+  console.log("");
+  console.log("Run `oac run` to start the full pipeline, or `oac doctor` to verify setup.");
+}
+function buildConfigFile(input2) {
+  const enabledProviders = input2.providers.map((provider) => `"${provider}"`).join(", ");
+  return `import { defineConfig } from "@open330/oac";
+
+export default defineConfig({
+  repos: ["${input2.repo}"],
+  provider: {
+    id: "${input2.provider}",
+    options: {
+      enabledProviders: [${enabledProviders}],
+    },
+  },
+  budget: {
+    totalTokens: ${input2.budgetTokens},
+  },
+});
+`;
+}
+function normalizeRepoInput(input2) {
+  const trimmed = input2.trim();
+  if (OWNER_REPO_PATTERN.test(trimmed)) {
+    return stripGitSuffix(trimmed);
+  }
+  const normalizedUrlInput = trimmed.startsWith("github.com/") ? `https://${trimmed}` : trimmed;
+  try {
+    const url = new URL(normalizedUrlInput);
+    if (url.hostname !== "github.com") {
+      return trimmed;
+    }
+    const segments = url.pathname.split("/").filter(Boolean);
+    if (segments.length < 2) {
+      return trimmed;
+    }
+    const owner = segments[0];
+    const repo = stripGitSuffix(segments[1] ?? "");
+    if (!owner || !repo) {
+      return trimmed;
+    }
+    return `${owner}/${repo}`;
+  } catch {
+    return trimmed;
+  }
+}
+function stripGitSuffix(value) {
+  return value.endsWith(".git") ? value.slice(0, -4) : value;
+}
+function isValidRepoInput(input2) {
+  const normalized = normalizeRepoInput(input2);
+  return OWNER_REPO_PATTERN.test(normalized);
+}
+async function pathExists2(path) {
+  try {
+    await access2(path, fsConstants2.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureGitignoreEntry(dir, entry) {
+  const gitignorePath = resolve3(dir, ".gitignore");
+  let content = "";
+  try {
+    content = await readFile2(gitignorePath, "utf8");
+  } catch {
+  }
+  if (content.split("\n").some((line) => line.trim() === entry)) {
+    return;
+  }
+  const separator = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
+  await writeFile(gitignorePath, `${content}${separator}${entry}
+`, "utf8");
+}
+
+// src/cli/commands/leaderboard.ts
+import { readFile as readFile3, readdir } from "fs/promises";
+import { resolve as resolve4 } from "path";
+import Table2 from "cli-table3";
+import { Command as Command7 } from "commander";
+function createLeaderboardCommand() {
+  const command = new Command7("leaderboard");
+  command.description("Show contribution rankings").option("--limit <number>", "Max entries to show", parseInteger, 10).option("--sort <field>", "Sort by: runs, tasks, tokens, prs", "tasks").action(async (options, cmd) => {
+    if (options.limit <= 0) {
+      throw new Error("--limit must be a positive integer.");
+    }
+    const globalOptions = getGlobalOptions(cmd);
+    const sortField = normalizeSortField(options.sort);
+    const entries = await loadLeaderboardEntries(process.cwd());
+    const sortedEntries = sortEntries(entries, sortField).slice(0, options.limit);
+    if (globalOptions.json) {
+      console.log(
+        JSON.stringify(
+          {
+            total: sortedEntries.length,
+            sort: sortField,
+            entries: sortedEntries
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    if (sortedEntries.length === 0) {
+      console.log("No leaderboard data found.");
+      return;
+    }
+    const table = new Table2({
+      head: ["Rank", "User", "Tasks", "Tokens Used", "PRs Created", "PRs Merged"]
+    });
+    for (let index = 0; index < sortedEntries.length; index += 1) {
+      const entry = sortedEntries[index];
+      table.push([
+        String(index + 1),
+        entry.githubUsername,
+        String(entry.totalTasksCompleted),
+        formatInteger(entry.totalTokensDonated),
+        String(entry.totalPRsCreated),
+        String(entry.totalPRsMerged)
+      ]);
+    }
+    console.log(table.toString());
+  });
+  command.addHelpText(
+    "after",
+    `
+Examples:
+  $ oac leaderboard
+  $ oac leaderboard --limit 20 --sort tokens`
+  );
+  return command;
+}
+async function loadLeaderboardEntries(repoPath) {
+  const leaderboardPath = resolve4(repoPath, ".oac", "leaderboard.json");
+  try {
+    const leaderboardRaw = await readFile3(leaderboardPath, "utf8");
+    const leaderboardPayload = JSON.parse(leaderboardRaw);
+    return parseStoredLeaderboardEntries(leaderboardPayload);
+  } catch (error) {
+    if (!isFileNotFoundError(error)) {
+      throw error;
+    }
+  }
+  const logs = await readContributionLogs(repoPath);
+  return buildEntriesFromLogs(logs);
+}
+function parseStoredLeaderboardEntries(payload) {
+  if (!isRecord(payload)) {
+    return [];
+  }
+  const entries = payload.entries;
+  if (!Array.isArray(entries)) {
+    return [];
+  }
+  const parsedEntries = [];
+  for (const entry of entries) {
+    if (!isRecord(entry)) {
+      continue;
+    }
+    const githubUsername = entry.githubUsername;
+    const totalRuns = entry.totalRuns;
+    const totalTasksCompleted = entry.totalTasksCompleted;
+    const totalTokensDonated = entry.totalTokensDonated;
+    const totalPRsCreated = entry.totalPRsCreated;
+    const totalPRsMerged = entry.totalPRsMerged;
+    if (typeof githubUsername !== "string" || typeof totalRuns !== "number" || typeof totalTasksCompleted !== "number" || typeof totalTokensDonated !== "number" || typeof totalPRsCreated !== "number" || typeof totalPRsMerged !== "number") {
+      continue;
+    }
+    parsedEntries.push({
+      githubUsername,
+      totalRuns,
+      totalTasksCompleted,
+      totalTokensDonated,
+      totalPRsCreated,
+      totalPRsMerged
+    });
+  }
+  return parsedEntries;
+}
+async function readContributionLogs(repoPath) {
+  const contributionsPath = resolve4(repoPath, ".oac", "contributions");
+  let entries;
+  try {
+    entries = await readdir(contributionsPath, { withFileTypes: true, encoding: "utf8" });
+  } catch (error) {
+    if (isFileNotFoundError(error)) {
+      return [];
+    }
+    throw error;
+  }
+  const fileNames = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
+  const logs = await Promise.all(
+    fileNames.map(async (fileName) => {
+      const filePath = resolve4(contributionsPath, fileName);
+      try {
+        const content = await readFile3(filePath, "utf8");
+        const payload = JSON.parse(content);
+        const parsed = contributionLogSchema.safeParse(payload);
+        return parsed.success ? parsed.data : null;
+      } catch {
+        return null;
+      }
+    })
+  );
+  return logs.filter((log) => log !== null);
+}
+function buildEntriesFromLogs(logs) {
+  const byUser = /* @__PURE__ */ new Map();
+  for (const log of logs) {
+    const username = log.contributor.githubUsername;
+    const existing = byUser.get(username) ?? {
+      githubUsername: username,
+      totalRuns: 0,
+      totalTasksCompleted: 0,
+      totalTokensDonated: 0,
+      totalPRsCreated: 0,
+      totalPRsMerged: 0
+    };
+    existing.totalRuns += 1;
+    existing.totalTasksCompleted += log.tasks.filter((task) => task.status !== "failed").length;
+    existing.totalTokensDonated += log.budget.totalTokensUsed;
+    existing.totalPRsCreated += log.tasks.filter((task) => Boolean(task.pr)).length;
+    existing.totalPRsMerged += log.tasks.filter((task) => task.pr?.status === "merged").length;
+    byUser.set(username, existing);
+  }
+  return Array.from(byUser.values());
+}
+function sortEntries(entries, field) {
+  return [...entries].sort((a, b) => {
+    const first = sortValue(b, field) - sortValue(a, field);
+    if (first !== 0) {
+      return first;
+    }
+    if (b.totalTasksCompleted !== a.totalTasksCompleted) {
+      return b.totalTasksCompleted - a.totalTasksCompleted;
+    }
+    if (b.totalRuns !== a.totalRuns) {
+      return b.totalRuns - a.totalRuns;
+    }
+    return a.githubUsername.localeCompare(b.githubUsername);
+  });
+}
+function normalizeSortField(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "runs" || normalized === "tasks" || normalized === "tokens" || normalized === "prs") {
+    return normalized;
+  }
+  throw new Error(`Unsupported --sort value "${value}". Use runs, tasks, tokens, or prs.`);
+}
+function sortValue(entry, field) {
+  if (field === "runs") {
+    return entry.totalRuns;
+  }
+  if (field === "tasks") {
+    return entry.totalTasksCompleted;
+  }
+  if (field === "tokens") {
+    return entry.totalTokensDonated;
+  }
+  return entry.totalPRsCreated;
+}
+function isFileNotFoundError(error) {
+  if (!isRecord(error)) {
+    return false;
+  }
+  return error.code === "ENOENT";
+}
+
+// src/cli/commands/log.ts
+import { readFile as readFile4, readdir as readdir2 } from "fs/promises";
+import { resolve as resolve5 } from "path";
+import Table3 from "cli-table3";
+import { Command as Command8 } from "commander";
+function createLogCommand() {
+  const command = new Command8("log");
+  command.description("View contribution history").option("--limit <number>", "Max entries to show", parseInteger, 20).option("--repo <name>", "Filter by repo name").option("--source <type>", "Filter by task source").option("--since <date>", "Filter contributions after date (ISO string)").action(async (options, cmd) => {
+    if (options.limit <= 0) {
+      throw new Error("--limit must be a positive integer.");
+    }
+    const globalOptions = getGlobalOptions(cmd);
+    const sinceDate = parseSinceDate(options.since);
+    const repoFilter = options.repo?.trim();
+    const sourceFilter = options.source?.trim().toLowerCase();
+    const logs = await readContributionLogs2(process.cwd());
+    const filteredLogs = logs.filter((log) => repoFilter ? log.repo.fullName === repoFilter : true).filter(
+      (log) => sourceFilter ? log.tasks.some((task) => task.source === sourceFilter) : true
+    ).filter((log) => sinceDate ? Date.parse(log.timestamp) >= sinceDate.getTime() : true).sort((a, b) => Date.parse(b.timestamp) - Date.parse(a.timestamp)).slice(0, options.limit);
+    if (globalOptions.json) {
+      console.log(
+        JSON.stringify(
+          {
+            total: filteredLogs.length,
+            entries: filteredLogs
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    if (filteredLogs.length === 0) {
+      console.log("No contribution logs found.");
+      return;
+    }
+    const table = new Table3({
+      head: ["Date", "Repo", "Tasks", "Tokens", "PRs", "Source"]
+    });
+    for (const log of filteredLogs) {
+      table.push([
+        formatDate(log.timestamp),
+        log.repo.fullName,
+        String(log.tasks.length),
+        formatInteger(log.budget.totalTokensUsed),
+        String(log.tasks.filter((task) => Boolean(task.pr)).length),
+        summarizeSources(log)
+      ]);
+    }
+    console.log(table.toString());
+  });
+  command.addHelpText(
+    "after",
+    `
+Examples:
+  $ oac log
+  $ oac log --limit 10 --repo owner/repo
+  $ oac log --source lint --since 2025-01-01`
+  );
+  return command;
+}
+async function readContributionLogs2(repoPath) {
+  const contributionsPath = resolve5(repoPath, ".oac", "contributions");
+  let entries;
+  try {
+    entries = await readdir2(contributionsPath, { withFileTypes: true, encoding: "utf8" });
+  } catch (error) {
+    if (isFileNotFoundError2(error)) {
+      return [];
+    }
+    throw error;
+  }
+  const files = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
+  const logs = await Promise.all(
+    files.map(async (fileName) => {
+      const filePath = resolve5(contributionsPath, fileName);
+      try {
+        const content = await readFile4(filePath, "utf8");
+        const payload = JSON.parse(content);
+        const parsed = contributionLogSchema.safeParse(payload);
+        return parsed.success ? parsed.data : null;
+      } catch {
+        return null;
+      }
+    })
+  );
+  return logs.filter((log) => log !== null);
+}
+function parseSinceDate(value) {
+  if (!value) {
+    return null;
+  }
+  const parsed = Date.parse(value);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`Invalid --since value "${value}". Expected an ISO date string.`);
+  }
+  return new Date(parsed);
+}
+function summarizeSources(log) {
+  const uniqueSources = [...new Set(log.tasks.map((task) => task.source))].sort(
+    (a, b) => a.localeCompare(b)
+  );
+  if (uniqueSources.length === 0) {
+    return "-";
+  }
+  return uniqueSources.join(", ");
+}
+function formatDate(timestamp) {
+  const date = new Date(timestamp);
+  if (Number.isNaN(date.getTime())) {
+    return timestamp;
+  }
+  return date.toISOString();
+}
+function isFileNotFoundError2(error) {
+  if (typeof error !== "object" || error === null) {
+    return false;
+  }
+  const code = error.code;
+  return code === "ENOENT";
+}
+
+// src/cli/commands/plan.ts
+import Table4 from "cli-table3";
+import { Command as Command9 } from "commander";
+function createPlanCommand() {
+  const command = new Command9("plan");
+  command.description("Build an execution plan from discovered tasks").option("--repo <owner/repo>", "Target repository (owner/repo or GitHub URL)").option("--tokens <number>", "Token budget for planning", parseInteger).option("--provider <id>", "Agent provider id").action(async (options, cmd) => {
+    const globalOptions = getGlobalOptions(cmd);
+    const ui = createUi(globalOptions);
+    const outputJson = globalOptions.json;
+    const config = await loadOptionalConfig(globalOptions.config, globalOptions.verbose, ui);
+    const repoInput = resolveRepoInput(options.repo, config);
+    const providerId = resolveProviderId(options.provider, config);
+    const totalBudget = resolveBudget(options.tokens, config);
+    const minPriority = config?.discovery.minPriority ?? 20;
+    const scannerSelection = selectScannersFromConfig(config);
+    ensureGitHubAuth();
+    const resolveSpinner = createSpinner(outputJson, "Resolving repository...");
+    const resolvedRepo = await resolveRepo(repoInput);
+    resolveSpinner?.succeed(`Resolved ${resolvedRepo.fullName}`);
+    const cloneSpinner = createSpinner(outputJson, "Preparing local clone...");
+    await cloneRepo(resolvedRepo);
+    cloneSpinner?.succeed(`Repository ready at ${resolvedRepo.localPath}`);
+    const scanSpinner = createSpinner(
+      outputJson,
+      `Running scanners: ${scannerSelection.enabled.join(", ")}`
+    );
+    const scannedTasks = await scannerSelection.scanner.scan(resolvedRepo.localPath, {
+      exclude: config?.discovery.exclude,
+      maxTasks: config?.discovery.maxTasks,
+      repo: resolvedRepo
+    });
+    scanSpinner?.succeed(`Discovered ${scannedTasks.length} raw task(s)`);
+    const rankedTasks = rankTasks(scannedTasks).filter((task) => task.priority >= minPriority);
+    const estimateSpinner = createSpinner(
+      outputJson,
+      `Estimating tokens for ${rankedTasks.length} task(s)...`
+    );
+    const estimates = await estimateTaskMap(rankedTasks, providerId);
+    estimateSpinner?.succeed("Token estimation completed");
+    const plan = buildExecutionPlan(rankedTasks, estimates, totalBudget);
+    if (outputJson) {
+      console.log(
+        JSON.stringify(
+          {
+            repo: resolvedRepo.fullName,
+            provider: providerId,
+            budget: totalBudget,
+            tasksDiscovered: rankedTasks.length,
+            plan
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    renderPlan(ui, {
+      repo: resolvedRepo.fullName,
+      provider: providerId,
+      budget: totalBudget,
+      plan
+    });
+  });
+  command.addHelpText(
+    "after",
+    `
+Examples:
+  $ oac plan --repo owner/repo --tokens 100000
+  $ oac plan --repo owner/repo --provider codex`
+  );
+  return command;
+}
+function selectScannersFromConfig(config) {
+  const enabled = [];
+  if (config?.discovery.scanners.lint !== false) {
+    enabled.push("lint");
+  }
+  if (config?.discovery.scanners.todo !== false) {
+    enabled.push("todo");
+  }
+  if (enabled.length === 0) {
+    enabled.push("lint", "todo");
+  }
+  const uniqueEnabled = [...new Set(enabled)];
+  const scannerInstances = uniqueEnabled.map(
+    (scannerName) => scannerName === "lint" ? new LintScanner() : new TodoScanner()
+  );
+  return {
+    enabled: uniqueEnabled,
+    scanner: new CompositeScanner(scannerInstances)
+  };
+}
+function renderPlan(ui, data) {
+  const table = new Table4({
+    head: ["#", "Task", "Est. Tokens", "Cumulative", "Confidence"]
+  });
+  for (let index = 0; index < data.plan.selectedTasks.length; index += 1) {
+    const entry = data.plan.selectedTasks[index];
+    table.push([
+      String(index + 1),
+      truncate(entry.task.title, 56),
+      formatInteger(entry.estimate.totalEstimatedTokens),
+      formatInteger(entry.cumulativeBudgetUsed),
+      entry.estimate.confidence.toFixed(2)
+    ]);
+  }
+  console.log(ui.bold(`Execution Plan for ${data.repo}`));
+  console.log(`Provider: ${data.provider}`);
+  console.log("");
+  if (data.plan.selectedTasks.length > 0) {
+    console.log(table.toString());
+    console.log("");
+  } else {
+    console.log(ui.yellow("No tasks selected for execution."));
+    console.log("");
+  }
+  const effectiveBudget = data.plan.totalBudget - data.plan.reserveTokens;
+  const budgetUsed = data.plan.selectedTasks[data.plan.selectedTasks.length - 1]?.cumulativeBudgetUsed ?? 0;
+  console.log(
+    `Budget used: ${formatInteger(budgetUsed)} / ${formatInteger(effectiveBudget)} (effective)`
+  );
+  console.log(`Reserve:     ${formatInteger(data.plan.reserveTokens)} (10%)`);
+  console.log(`Remaining:   ${formatInteger(data.plan.remainingTokens)}`);
+  if (data.plan.deferredTasks.length > 0) {
+    console.log("");
+    console.log(ui.yellow(`Deferred (${data.plan.deferredTasks.length}):`));
+    for (const deferred of data.plan.deferredTasks) {
+      const reason = deferred.reason.replaceAll("_", " ");
+      console.log(
+        `  - ${truncate(deferred.task.title, 72)} (${formatInteger(
+          deferred.estimate.totalEstimatedTokens
+        )} tokens, ${reason})`
+      );
+    }
+  }
+}
+
+// src/cli/commands/run/index.ts
+import { Command as Command10 } from "commander";
+
+// src/cli/commands/run/pipeline.ts
+import { randomUUID } from "crypto";
+
+// src/cli/commands/run/epic.ts
+import Table6 from "cli-table3";
+import PQueue3 from "p-queue";
+
+// src/cli/commands/run/pr.ts
+import { execa } from "execa";
+
+// src/cli/commands/run/types.ts
+var DEFAULT_TIMEOUT_SECONDS = 300;
+var DEFAULT_CONCURRENCY = 2;
+var PR_CREATION_TIMEOUT_MS = 12e4;
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+var EXIT_SUCCESS = 0;
+var EXIT_GENERAL_ERROR = 1;
+var EXIT_CONFIG_ERROR = 2;
+var EXIT_ALL_FAILED = 3;
+var EXIT_PARTIAL_SUCCESS = 4;
+function resolveExitCode(results) {
+  if (results.length === 0) return EXIT_SUCCESS;
+  const succeeded = results.filter((r) => r.execution.success).length;
+  if (succeeded === results.length) return EXIT_SUCCESS;
+  if (succeeded === 0) return EXIT_ALL_FAILED;
+  return EXIT_PARTIAL_SUCCESS;
+}
+function formatBudgetDisplay(budget) {
+  if (budget >= UNLIMITED_BUDGET) {
+    return "unlimited";
+  }
+  return formatInteger(budget);
+}
+function formatDuration(seconds) {
+  if (!Number.isFinite(seconds) || seconds < 0) {
+    return "0s";
+  }
+  if (seconds < 60) {
+    return `${seconds.toFixed(1)}s`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = Math.round(seconds % 60);
+  return `${minutes}m ${remainingSeconds}s`;
+}
+
+// src/cli/commands/run/pr.ts
+async function createPullRequest(input2) {
+  if (!input2.sandbox) {
+    return void 0;
+  }
+  const { branchName, sandboxPath } = input2.sandbox;
+  try {
+    const ghEnv = { ...process.env };
+    if (input2.ghToken) {
+      ghEnv.GH_TOKEN = input2.ghToken;
+      ghEnv.GITHUB_TOKEN = input2.ghToken;
+    }
+    await execa("git", ["push", "--set-upstream", "origin", branchName], {
+      cwd: sandboxPath,
+      env: ghEnv,
+      timeout: PR_CREATION_TIMEOUT_MS
+    });
+    const prTitle = `[OAC] ${input2.task.title}`;
+    const prBodyLines = [
+      "## Summary",
+      "",
+      input2.task.description || `Automated contribution for task "${input2.task.title}".`,
+      ""
+    ];
+    if (input2.task.linkedIssue) {
+      prBodyLines.push(`Closes #${input2.task.linkedIssue.number}`, "");
+    }
+    prBodyLines.push(
+      "## Context",
+      "",
+      `- **Task source:** ${input2.task.source}`,
+      `- **Complexity:** ${input2.task.complexity}`,
+      `- **Tokens used:** ${input2.execution.totalTokensUsed}`,
+      `- **Files changed:** ${input2.execution.filesChanged.length}`
+    );
+    if (input2.task.linkedIssue) {
+      prBodyLines.push(`- **Resolves:** #${input2.task.linkedIssue.number}`);
+    }
+    prBodyLines.push(
+      "",
+      "---",
+      "*This PR was automatically generated by [OAC](https://github.com/Open330/open-agent-contribution).*"
+    );
+    const prBody = prBodyLines.join("\n");
+    const ghResult = await execa(
+      "gh",
+      [
+        "pr",
+        "create",
+        "--repo",
+        input2.repoFullName,
+        "--title",
+        prTitle,
+        "--body",
+        prBody,
+        "--head",
+        branchName,
+        "--base",
+        input2.baseBranch
+      ],
+      { cwd: sandboxPath, env: ghEnv, timeout: PR_CREATION_TIMEOUT_MS }
+    );
+    const prUrl = ghResult.stdout.trim();
+    const prNumberMatch = prUrl.match(/\/pull\/(\d+)/);
+    const prNumber = prNumberMatch ? Number.parseInt(prNumberMatch[1], 10) : 0;
+    return {
+      number: prNumber,
+      url: prUrl,
+      status: "open"
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[oac] PR creation failed: ${message}`);
+    return void 0;
+  }
+}
+
+// src/cli/commands/run/task.ts
+import Table5 from "cli-table3";
+import { execa as execa2 } from "execa";
+import PQueue2 from "p-queue";
+async function discoverTasks(ctx, options, config, ghToken, resolvedRepo) {
+  const scannerSelection = selectScannersFromConfig2(config, Boolean(ghToken));
+  const minPriority = config?.discovery.minPriority ?? 20;
+  const maxTasks = options.maxTasks ?? void 0;
+  const scanSpinner = createSpinner(
+    ctx.suppressOutput,
+    `Running scanners: ${scannerSelection.enabled.join(", ")}`
+  );
+  const scannedTasks = await scannerSelection.scanner.scan(resolvedRepo.localPath, {
+    exclude: config?.discovery.exclude,
+    maxTasks: config?.discovery.maxTasks,
+    repo: resolvedRepo
+  });
+  scanSpinner?.succeed(`Discovered ${scannedTasks.length} raw task(s)`);
+  let candidateTasks = rankTasks(scannedTasks).filter((task) => task.priority >= minPriority);
+  if (options.source) {
+    candidateTasks = candidateTasks.filter((task) => task.source === options.source);
+  }
+  if (typeof maxTasks === "number") {
+    candidateTasks = candidateTasks.slice(0, maxTasks);
+  }
+  const estimateSpinner = createSpinner(
+    ctx.suppressOutput,
+    `Estimating tokens for ${candidateTasks.length} task(s)...`
+  );
+  const estimates = candidateTasks.length > 0 ? await estimateTaskMap(
+    candidateTasks,
+    resolveProviderId(options.provider, config),
+    (done, total) => {
+      if (estimateSpinner) {
+        const pct = Math.round(done / total * 100);
+        estimateSpinner.text = `Estimating tokens... (${done}/${total} \u2014 ${pct}%)`;
+      }
+    }
+  ) : /* @__PURE__ */ new Map();
+  if (candidateTasks.length > 0) estimateSpinner?.succeed("Token estimation completed");
+  else estimateSpinner?.stop();
+  const plan = buildExecutionPlan(candidateTasks, estimates, resolveBudget(options.tokens, config));
+  return { ...resolvedRepo, candidateTasks, plan, fullName: resolvedRepo.fullName };
+}
+function printEmptySummary(ctx, repoName, providerId, totalBudget) {
+  const emptySummary = {
+    runId: ctx.runId,
+    repo: repoName,
+    provider: providerId,
+    dryRun: Boolean(ctx.options.dryRun),
+    selectedTasks: 0,
+    deferredTasks: 0,
+    tasksCompleted: 0,
+    tasksFailed: 0,
+    prsCreated: 0,
+    tokensUsed: 0,
+    tokensBudgeted: totalBudget
+  };
+  if (ctx.outputJson) {
+    console.log(JSON.stringify({ summary: emptySummary, plan: null }, null, 2));
+  } else {
+    console.log(ctx.ui.yellow("No tasks discovered for execution."));
+  }
+}
+function printDryRunSummary(ctx, repoName, providerId, totalBudget, plan) {
+  const dryRunSummary = {
+    runId: ctx.runId,
+    repo: repoName,
+    provider: providerId,
+    dryRun: true,
+    selectedTasks: plan.selectedTasks.length,
+    deferredTasks: plan.deferredTasks.length,
+    tasksCompleted: 0,
+    tasksFailed: 0,
+    prsCreated: 0,
+    tokensUsed: 0,
+    tokensBudgeted: totalBudget
+  };
+  if (ctx.outputJson) {
+    console.log(JSON.stringify({ summary: dryRunSummary, plan }, null, 2));
+  } else {
+    renderSelectedPlanTable(ctx.ui, plan, totalBudget);
+    console.log("");
+    renderDryRunDiff(ctx.ui, plan);
+    console.log(ctx.ui.blue("Dry run complete. No tasks were executed."));
+  }
+}
+function renderDryRunDiff(ui, plan) {
+  if (plan.selectedTasks.length === 0) return;
+  console.log(ui.bold("Planned changes:"));
+  console.log("");
+  for (const entry of plan.selectedTasks) {
+    const { task } = entry;
+    const sourceLabel = task.source.replace(/-/g, " ");
+    const complexityColor = task.complexity === "trivial" || task.complexity === "simple" ? ui.green : task.complexity === "moderate" ? ui.yellow : ui.red;
+    console.log(`${ui.green("+")} ${ui.bold(task.title)}`);
+    console.log(`  ${ui.dim(`source: ${sourceLabel}  complexity: `)}${complexityColor(task.complexity)}`);
+    if (task.targetFiles.length > 0) {
+      for (const file of task.targetFiles.slice(0, 5)) {
+        console.log(`  ${ui.yellow("~")} ${file}`);
+      }
+      if (task.targetFiles.length > 5) {
+        console.log(`  ${ui.dim(`  ... and ${task.targetFiles.length - 5} more files`)}`);
+      }
+    }
+    if (task.description) {
+      const preview = task.description.length > 120 ? `${task.description.slice(0, 117)}...` : task.description;
+      console.log(`  ${ui.dim(preview)}`);
+    }
+    console.log("");
+  }
+}
+async function executePlan(ctx, params) {
+  const { plan, providerId, resolvedRepo, concurrency, timeoutSeconds, mode, ghToken } = params;
+  const { adapter } = await resolveAdapter(providerId);
+  if (!ctx.suppressOutput && ctx.globalOptions.verbose) {
+    const avail = await adapter.checkAvailability();
+    console.log(
+      ctx.ui.green(`[oac] Using ${adapter.name} v${avail.version ?? "unknown"} for execution.`)
+    );
+  }
+  const executionSpinner = createSpinner(
+    ctx.suppressOutput,
+    `Executing ${plan.selectedTasks.length} planned task(s)...`
+  );
+  let completedCount = 0;
+  const taskQueue = new PQueue2({ concurrency });
+  const executedTasks = await Promise.all(
+    plan.selectedTasks.map(
+      (entry) => taskQueue.add(async () => {
+        const result = await executeWithAgent({
+          task: entry.task,
+          estimate: entry.estimate,
+          adapter,
+          repoPath: resolvedRepo.localPath,
+          baseBranch: resolvedRepo.meta.defaultBranch,
+          timeoutSeconds
+        });
+        const { execution, sandbox } = result;
+        completedCount += 1;
+        if (executionSpinner) {
+          const total = plan.selectedTasks.length;
+          const pct = Math.round(completedCount / total * 100);
+          executionSpinner.text = `Executing tasks... (${completedCount}/${total} \u2014 ${pct}%)`;
+        }
+        return { task: entry.task, estimate: entry.estimate, execution, sandbox };
+      })
+    )
+  );
+  executionSpinner?.succeed("Execution stage finished");
+  const completionSpinner = createSpinner(ctx.suppressOutput, "Completing task outputs...");
+  const completionQueue = new PQueue2({ concurrency });
+  const completedTasks = await Promise.all(
+    executedTasks.map(
+      (result) => completionQueue.add(async () => {
+        if (mode === "direct-commit" || !result.execution.success) return result;
+        const pr = await createPullRequest({
+          task: result.task,
+          execution: result.execution,
+          sandbox: result.sandbox,
+          repoFullName: resolvedRepo.fullName,
+          baseBranch: resolvedRepo.meta.defaultBranch,
+          ghToken
+        });
+        return pr ? { ...result, pr } : result;
+      })
+    )
+  );
+  completionSpinner?.succeed("Completion stage finished");
+  return completedTasks;
+}
+function printFinalSummary(ctx, params) {
+  const { plan, resolvedRepo, providerId, totalBudget, completedTasks } = params;
+  const tasksCompleted = completedTasks.filter((t) => t.execution.success).length;
+  const tasksFailed = completedTasks.length - tasksCompleted;
+  const prsCreated = completedTasks.filter((t) => Boolean(t.pr)).length;
+  const tokensUsed = completedTasks.reduce((sum, t) => sum + t.execution.totalTokensUsed, 0);
+  const runDurationSeconds = (Date.now() - ctx.runStartedAt) / 1e3;
+  const summary = {
+    runId: ctx.runId,
+    repo: resolvedRepo.fullName,
+    provider: providerId,
+    dryRun: false,
+    selectedTasks: plan.selectedTasks.length,
+    deferredTasks: plan.deferredTasks.length,
+    tasksCompleted,
+    tasksFailed,
+    prsCreated,
+    tokensUsed,
+    tokensBudgeted: totalBudget,
+    logPath: params.logPath
+  };
+  if (ctx.outputJson) {
+    console.log(JSON.stringify({ summary, plan, tasks: completedTasks }, null, 2));
+    return;
+  }
+  if (!ctx.globalOptions.quiet) {
+    renderTaskResults(ctx.ui, completedTasks);
+  }
+  console.log("");
+  console.log(ctx.ui.bold("Run Summary"));
+  console.log(`  Tasks completed: ${tasksCompleted}/${completedTasks.length}`);
+  console.log(`  Tasks failed:    ${tasksFailed}`);
+  console.log(`  PRs created:     ${prsCreated}`);
+  console.log(
+    `  Tokens used:     ${formatInteger(tokensUsed)} / ${formatBudgetDisplay(totalBudget)}`
+  );
+  console.log(`  Duration:        ${formatDuration(runDurationSeconds)}`);
+  if (params.logPath) {
+    console.log(`  Log:             ${params.logPath}`);
+  }
+  const failedTasks = completedTasks.filter((t) => !t.execution.success);
+  if (failedTasks.length > 0) {
+    console.log("");
+    console.log(ctx.ui.red(`Failed Tasks (${failedTasks.length}):`));
+    for (const t of failedTasks) {
+      const reason = t.execution.error ? `: ${truncate(t.execution.error, 120)}` : "";
+      console.log(`  ${ctx.ui.red("\u2717")} ${truncate(t.task.title, 60)}${reason}`);
+    }
+  }
+}
+function selectScannersFromConfig2(config, hasGitHubAuth) {
+  const { names, composite } = buildScanners(config, hasGitHubAuth);
+  return { enabled: names, scanner: composite };
+}
+async function executeWithAgent(input2) {
+  const startedAt = Date.now();
+  const taskSlug = input2.task.id.replace(/[^a-zA-Z0-9-]/g, "-").replace(/-+/g, "-").slice(0, 30);
+  const branchName = `oac/${Date.now()}-${taskSlug}`;
+  const sandbox = await createSandbox(input2.repoPath, branchName, input2.baseBranch);
+  const eventBus = createEventBus();
+  const sandboxInfo = {
+    branchName,
+    sandboxPath: sandbox.path,
+    cleanup: sandbox.cleanup
+  };
+  try {
+    const result = await executeTask(input2.adapter, input2.task, sandbox, eventBus, {
+      tokenBudget: input2.estimate.totalEstimatedTokens,
+      timeoutMs: input2.timeoutSeconds * 1e3
+    });
+    const commitResult = await commitSandboxChanges(sandbox.path, input2.task);
+    const filesChanged = commitResult.filesChanged.length > 0 ? commitResult.filesChanged : result.filesChanged.length > 0 ? result.filesChanged : [];
+    return {
+      execution: {
+        success: result.success || commitResult.hasChanges,
+        exitCode: result.exitCode,
+        totalTokensUsed: result.totalTokensUsed,
+        filesChanged,
+        duration: result.duration > 0 ? result.duration / 1e3 : (Date.now() - startedAt) / 1e3,
+        error: result.error
+      },
+      sandbox: sandboxInfo
+    };
+  } catch (error) {
+    const commitResult = await commitSandboxChanges(sandbox.path, input2.task);
+    if (commitResult.hasChanges) {
+      return {
+        execution: {
+          success: true,
+          exitCode: 0,
+          totalTokensUsed: 0,
+          filesChanged: commitResult.filesChanged,
+          duration: (Date.now() - startedAt) / 1e3
+        },
+        sandbox: sandboxInfo
+      };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      execution: {
+        success: false,
+        exitCode: 1,
+        totalTokensUsed: 0,
+        filesChanged: [],
+        duration: (Date.now() - startedAt) / 1e3,
+        error: message
+      },
+      sandbox: sandboxInfo
+    };
+  }
+}
+async function commitSandboxChanges(sandboxPath, task) {
+  try {
+    const statusResult = await execa2("git", ["status", "--porcelain"], { cwd: sandboxPath });
+    if (!statusResult.stdout.trim()) {
+      return { hasChanges: false, filesChanged: [] };
+    }
+    await execa2("git", ["add", "-A"], { cwd: sandboxPath });
+    await execa2(
+      "git",
+      ["commit", "-m", `[OAC] ${task.title}
+
+Automated contribution by OAC using Codex CLI.`],
+      { cwd: sandboxPath }
+    );
+    const diffResult = await execa2("git", ["diff", "--name-only", "HEAD~1", "HEAD"], {
+      cwd: sandboxPath
+    });
+    const changedFiles = diffResult.stdout.trim().split("\n").filter(Boolean);
+    return { hasChanges: true, filesChanged: changedFiles };
+  } catch {
+    return { hasChanges: false, filesChanged: [] };
+  }
+}
+async function resolveAdapter(providerId) {
+  const normalizedId = adapterRegistry.resolveId(providerId);
+  const factory = adapterRegistry.get(providerId);
+  if (!factory) {
+    const supported = adapterRegistry.registeredIds().join(", ");
+    throw new Error(
+      `Unknown provider "${providerId}". Supported providers: ${supported}.
+Run \`oac doctor\` to check your environment setup.`
+    );
+  }
+  const adapter = factory();
+  const availability = await adapter.checkAvailability();
+  if (!availability.available) {
+    throw new Error(
+      `Agent CLI "${normalizedId}" is not available: ${availability.error ?? "unknown reason"}.
+Install the ${normalizedId} CLI or switch providers.
+Run \`oac doctor\` for setup instructions.`
+    );
+  }
+  return { adapter };
+}
+function renderSelectedPlanTable(ui, plan, budget) {
+  const table = new Table5({
+    head: ["#", "Task", "Est. Tokens", "Cumulative", "Confidence"]
+  });
+  for (let index = 0; index < plan.selectedTasks.length; index += 1) {
+    const entry = plan.selectedTasks[index];
+    table.push([
+      String(index + 1),
+      truncate(entry.task.title, 56),
+      formatInteger(entry.estimate.totalEstimatedTokens),
+      formatInteger(entry.cumulativeBudgetUsed),
+      entry.estimate.confidence.toFixed(2)
+    ]);
+  }
+  if (plan.selectedTasks.length > 0) {
+    console.log(table.toString());
+  } else {
+    console.log(ui.yellow("No tasks selected for execution."));
+  }
+  console.log("");
+  console.log(
+    `Budget used: ${formatInteger(
+      plan.selectedTasks[plan.selectedTasks.length - 1]?.cumulativeBudgetUsed ?? 0
+    )} / ${formatBudgetDisplay(budget - plan.reserveTokens)} (effective)`
+  );
+  console.log(`Reserve:     ${formatBudgetDisplay(plan.reserveTokens)} (10%)`);
+  console.log(`Remaining:   ${formatBudgetDisplay(plan.remainingTokens)}`);
+  if (plan.deferredTasks.length > 0) {
+    console.log("");
+    console.log(ui.yellow(`Deferred (${plan.deferredTasks.length}):`));
+    for (const deferred of plan.deferredTasks) {
+      console.log(
+        `  - ${truncate(deferred.task.title, 72)} (${formatInteger(
+          deferred.estimate.totalEstimatedTokens
+        )} tokens, ${deferred.reason.replaceAll("_", " ")})`
+      );
+    }
+  }
+}
+function renderTaskResults(ui, taskResults) {
+  for (let index = 0; index < taskResults.length; index += 1) {
+    const result = taskResults[index];
+    const icon = result.execution.success ? ui.green("[OK]") : ui.red("[X]");
+    const status = result.execution.success ? ui.green("SUCCESS") : ui.red("FAILED");
+    console.log(`${icon} [${index + 1}/${taskResults.length}] ${result.task.title}`);
+    console.log(
+      `    ${status} | tokens ${formatInteger(result.execution.totalTokensUsed)} | duration ${formatDuration(
+        result.execution.duration
+      )}`
+    );
+    if (result.pr) {
+      console.log(`    PR #${result.pr.number}: ${result.pr.url}`);
+    }
+    if (result.execution.error) {
+      console.log(`    Error: ${result.execution.error}`);
+    }
+  }
+}
+
+// src/cli/commands/run/tracking.ts
+async function writeTracking(ctx, params) {
+  const { resolvedRepo, providerId, totalBudget, candidateTasks, completedTasks } = params;
+  const runDurationSeconds = (Date.now() - ctx.runStartedAt) / 1e3;
+  const contributionLog = buildContributionLog({
+    runId: ctx.runId,
+    repoFullName: resolvedRepo.fullName,
+    repoHeadSha: resolvedRepo.git.headSha,
+    defaultBranch: resolvedRepo.meta.defaultBranch,
+    repoOwner: resolvedRepo.owner,
+    providerId,
+    totalBudget,
+    runDurationSeconds,
+    discoveredTasks: candidateTasks.length,
+    taskResults: completedTasks
+  });
+  const trackingSpinner = createSpinner(ctx.suppressOutput, "Writing contribution log...");
+  try {
+    const logPath = await writeContributionLog(contributionLog, resolvedRepo.localPath);
+    trackingSpinner?.succeed(`Contribution log written: ${logPath}`);
+    return logPath;
+  } catch (error) {
+    trackingSpinner?.fail("Failed to write contribution log");
+    if (ctx.globalOptions.verbose && !ctx.suppressOutput) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(ctx.ui.yellow(`[oac] Tracking failed: ${message}`));
+    }
+    return void 0;
+  }
+}
+function buildContributionLog(input2) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const contributor = resolveGithubUsername(input2.repoOwner);
+  const contributionTasks = input2.taskResults.map((result) => ({
+    taskId: result.task.id,
+    title: result.task.title,
+    source: result.task.source,
+    complexity: result.task.complexity,
+    status: deriveTaskStatus(result.execution),
+    tokensUsed: Math.max(0, Math.floor(result.execution.totalTokensUsed)),
+    duration: Math.max(0, result.execution.duration),
+    filesChanged: result.execution.filesChanged,
+    pr: result.pr,
+    linkedIssue: result.task.linkedIssue ? {
+      number: result.task.linkedIssue.number,
+      url: result.task.linkedIssue.url
+    } : void 0,
+    error: result.execution.error
+  }));
+  const tasksSucceeded = contributionTasks.filter((task) => task.status !== "failed").length;
+  const tasksFailed = contributionTasks.length - tasksSucceeded;
+  const totalTokensUsed = contributionTasks.reduce((sum, task) => sum + task.tokensUsed, 0);
+  const totalFilesChanged = contributionTasks.reduce(
+    (sum, task) => sum + task.filesChanged.length,
+    0
+  );
+  return {
+    version: "1.0",
+    runId: input2.runId,
+    timestamp,
+    contributor: {
+      githubUsername: contributor,
+      email: process.env.GIT_AUTHOR_EMAIL ?? void 0
+    },
+    repo: {
+      fullName: input2.repoFullName,
+      headSha: input2.repoHeadSha,
+      defaultBranch: input2.defaultBranch
+    },
+    budget: {
+      provider: input2.providerId,
+      totalTokensBudgeted: input2.totalBudget,
+      totalTokensUsed
+    },
+    tasks: contributionTasks,
+    metrics: {
+      tasksDiscovered: input2.discoveredTasks,
+      tasksAttempted: contributionTasks.length,
+      tasksSucceeded,
+      tasksFailed,
+      totalDuration: Math.max(0, input2.runDurationSeconds),
+      totalFilesChanged,
+      totalLinesAdded: 0,
+      totalLinesRemoved: 0
+    }
+  };
+}
+function deriveTaskStatus(execution) {
+  if (execution.success) {
+    return "success";
+  }
+  if (execution.filesChanged.length > 0) {
+    return "partial";
+  }
+  return "failed";
+}
+function resolveGithubUsername(fallback) {
+  const candidates = [
+    process.env.GITHUB_USER,
+    process.env.GITHUB_USERNAME,
+    process.env.USER,
+    process.env.LOGNAME,
+    fallback,
+    "oac-user"
+  ];
+  for (const candidate of candidates) {
+    const normalized = sanitizeGithubUsername(candidate ?? "");
+    if (normalized) {
+      return normalized;
+    }
+  }
+  return "oac-user";
+}
+function sanitizeGithubUsername(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const cleaned = trimmed.replace(/[^A-Za-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  if (cleaned.length === 0 || cleaned.length > 39) {
+    return null;
+  }
+  if (!/^(?!-)[A-Za-z0-9-]+(?<!-)$/.test(cleaned)) {
+    return null;
+  }
+  return cleaned;
+}
+
+// src/cli/commands/run/epic.ts
+async function tryLoadOrAnalyzeEpics(ctx, params) {
+  const { resolvedRepo, config, ghToken, contextDir, staleAfterMs } = params;
+  const existingBacklog = await loadBacklog(resolvedRepo.localPath, contextDir);
+  if (existingBacklog) {
+    const pending = getPendingEpics(existingBacklog);
+    if (pending.length > 0) {
+      const context = await loadContext(resolvedRepo.localPath, contextDir);
+      if (context && !isContextStale(context.codebaseMap, staleAfterMs)) {
+        if (!ctx.suppressOutput) {
+          console.log(ctx.ui.blue(`[oac] Loaded ${pending.length} pending epic(s) from backlog.`));
+        }
+        return pending;
+      }
+    }
+  }
+  if (!params.autoAnalyze) {
+    return null;
+  }
+  const analyzeSpinner = createSpinner(ctx.suppressOutput, "Auto-analyzing codebase...");
+  const scanners = buildScannerList2(config, Boolean(ghToken));
+  const { codebaseMap, qualityReport } = await analyzeCodebase(resolvedRepo.localPath, {
+    scanners,
+    repoFullName: resolvedRepo.fullName,
+    headSha: resolvedRepo.git.headSha,
+    exclude: config?.discovery.exclude
+  });
+  analyzeSpinner?.succeed(
+    `Analyzed ${codebaseMap.modules.length} modules, ${codebaseMap.totalFiles} files, ${qualityReport.findings.length} findings`
+  );
+  if (qualityReport.findings.length === 0) {
+    return null;
+  }
+  const groupSpinner = createSpinner(ctx.suppressOutput, "Grouping findings into epics...");
+  const epics = groupFindingsIntoEpics(qualityReport.findings, { codebaseMap });
+  groupSpinner?.succeed(`Created ${epics.length} epic(s)`);
+  const persistSpinner = createSpinner(ctx.suppressOutput, "Persisting context...");
+  await persistContext(resolvedRepo.localPath, codebaseMap, qualityReport, contextDir);
+  const backlog = createBacklog(resolvedRepo.fullName, resolvedRepo.git.headSha, epics);
+  await persistBacklog(resolvedRepo.localPath, backlog, contextDir);
+  persistSpinner?.succeed(`Context persisted to ${contextDir}/`);
+  return getPendingEpics(backlog);
+}
+function buildScannerList2(config, hasGitHubAuth) {
+  return buildScanners(config, hasGitHubAuth).instances;
+}
+function makeStubEstimate(taskId, providerId, tokens) {
+  return {
+    taskId,
+    providerId,
+    contextTokens: 0,
+    promptTokens: 0,
+    expectedOutputTokens: 0,
+    totalEstimatedTokens: tokens,
+    confidence: 0.7,
+    feasible: true
+  };
+}
+async function executeEpicEntry(entry, params) {
+  const { adapter, resolvedRepo, providerId, timeoutSeconds, mode, ghToken } = params;
+  const task = epicAsTask(entry.epic);
+  const estimate = makeStubEstimate(task.id, providerId, entry.estimatedTokens);
+  const result = await executeWithAgent({
+    task,
+    estimate,
+    adapter,
+    repoPath: resolvedRepo.localPath,
+    baseBranch: resolvedRepo.meta.defaultBranch,
+    timeoutSeconds
+  });
+  const { execution, sandbox } = result;
+  let pr;
+  if (mode !== "direct-commit" && execution.success && sandbox) {
+    pr = await createPullRequest({
+      task,
+      execution,
+      sandbox,
+      repoFullName: resolvedRepo.fullName,
+      baseBranch: resolvedRepo.meta.defaultBranch,
+      ghToken
+    }) ?? void 0;
+  }
+  return { task, estimate, execution, sandbox, pr };
+}
+async function runEpicPipeline(ctx, params) {
+  const {
+    epics,
+    resolvedRepo,
+    providerId,
+    totalBudget,
+    concurrency,
+    timeoutSeconds,
+    mode,
+    ghToken,
+    contextDir
+  } = params;
+  const estimateSpinner = createSpinner(
+    ctx.suppressOutput,
+    `Estimating tokens for ${epics.length} epic(s)...`
+  );
+  let estimatedCount = 0;
+  for (const epic of epics) {
+    if (epic.estimatedTokens === 0) {
+      epic.estimatedTokens = await estimateEpicTokens(epic, providerId);
+    }
+    estimatedCount += 1;
+    if (estimateSpinner) {
+      const pct = Math.round(estimatedCount / epics.length * 100);
+      estimateSpinner.text = `Estimating epic tokens... (${estimatedCount}/${epics.length} \u2014 ${pct}%)`;
+    }
+  }
+  estimateSpinner?.succeed("Epic token estimation completed");
+  const epicPlan = buildEpicExecutionPlan(epics, totalBudget);
+  if (!ctx.suppressOutput) {
+    console.log(
+      ctx.ui.blue(
+        `[oac] Selected ${epicPlan.selectedEpics.length} epic(s) for execution, ${epicPlan.deferredEpics.length} deferred.`
+      )
+    );
+  }
+  if (ctx.options.dryRun) {
+    printEpicDryRun(ctx, epicPlan, totalBudget);
+    return [];
+  }
+  const { adapter } = await resolveAdapter(providerId);
+  let epicCompletedCount = 0;
+  const epicTotal = epicPlan.selectedEpics.length;
+  const executionSpinner = createSpinner(
+    ctx.suppressOutput,
+    `Executing ${epicTotal} epic(s)...`
+  );
+  const epicQueue = new PQueue3({ concurrency });
+  const allTaskResults = await Promise.all(
+    epicPlan.selectedEpics.map(
+      (entry) => epicQueue.add(async () => {
+        if (!ctx.suppressOutput) {
+          console.log(
+            ctx.ui.blue(
+              `
+[oac] Executing epic: ${entry.epic.title} (${entry.epic.subtasks.length} subtasks)`
+            )
+          );
+        }
+        const result = await executeEpicEntry(entry, {
+          adapter,
+          resolvedRepo,
+          providerId,
+          timeoutSeconds,
+          mode,
+          ghToken
+        });
+        epicCompletedCount += 1;
+        if (executionSpinner) {
+          const pct = Math.round(epicCompletedCount / epicTotal * 100);
+          executionSpinner.text = `Executing epics... (${epicCompletedCount}/${epicTotal} \u2014 ${pct}%)`;
+        }
+        if (!ctx.suppressOutput) {
+          const icon = result.execution.success ? ctx.ui.green("[OK]") : ctx.ui.red("[X]");
+          console.log(`${icon} ${entry.epic.title}`);
+          if (result.pr) console.log(`    PR #${result.pr.number}: ${result.pr.url}`);
+        }
+        return result;
+      })
+    )
+  );
+  executionSpinner?.succeed("Epic execution finished");
+  const completedIds = allTaskResults.filter((r) => r.execution.success).map((r) => r.task.id);
+  const existingBacklog = await loadBacklog(resolvedRepo.localPath, contextDir);
+  if (existingBacklog && completedIds.length > 0) {
+    const updated = updateBacklog(existingBacklog, [], completedIds);
+    await persistBacklog(resolvedRepo.localPath, updated, contextDir);
+  }
+  await writeTracking(ctx, {
+    resolvedRepo,
+    providerId,
+    totalBudget,
+    candidateTasks: allTaskResults.map((r) => r.task),
+    completedTasks: allTaskResults
+  });
+  printEpicSummary(ctx, epicPlan, allTaskResults, resolvedRepo.fullName, providerId, totalBudget);
+  return allTaskResults;
+}
+function printEpicDryRun(ctx, epicPlan, totalBudget) {
+  if (ctx.outputJson) {
+    console.log(
+      JSON.stringify(
+        { summary: { runId: ctx.runId, dryRun: true, epics: epicPlan }, plan: epicPlan },
+        null,
+        2
+      )
+    );
+  } else {
+    renderEpicPlanTable(ctx.ui, epicPlan, totalBudget);
+    console.log("");
+    console.log(ctx.ui.blue("Dry run complete. No epics were executed."));
+  }
+}
+function printEpicSummary(ctx, epicPlan, results, repoName, providerId, totalBudget) {
+  const completed = results.filter((t) => t.execution.success).length;
+  const failed = results.length - completed;
+  const prsCreated = results.filter((t) => Boolean(t.pr)).length;
+  const tokensUsed = results.reduce((sum, t) => sum + t.execution.totalTokensUsed, 0);
+  const duration = (Date.now() - ctx.runStartedAt) / 1e3;
+  if (ctx.outputJson) {
+    console.log(
+      JSON.stringify(
+        {
+          summary: {
+            runId: ctx.runId,
+            repo: repoName,
+            provider: providerId,
+            dryRun: false,
+            selectedEpics: epicPlan.selectedEpics.length,
+            deferredEpics: epicPlan.deferredEpics.length,
+            epicsCompleted: completed,
+            epicsFailed: failed,
+            prsCreated,
+            tokensUsed,
+            tokensBudgeted: totalBudget
+          },
+          epics: results
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  console.log("");
+  console.log(ctx.ui.bold("Run Summary (Epic Mode)"));
+  console.log(`  Epics completed: ${completed}/${results.length}`);
+  console.log(`  Epics failed:    ${failed}`);
+  console.log(`  PRs created:     ${prsCreated}`);
+  console.log(
+    `  Tokens used:     ${formatInteger(tokensUsed)} / ${formatBudgetDisplay(totalBudget)}`
+  );
+  console.log(`  Duration:        ${formatDuration(duration)}`);
+  const failedEpics = results.filter((t) => !t.execution.success);
+  if (failedEpics.length > 0) {
+    console.log("");
+    console.log(ctx.ui.red(`Failed Epics (${failedEpics.length}):`));
+    for (const t of failedEpics) {
+      const reason = t.execution.error ? `: ${truncate(t.execution.error, 120)}` : "";
+      console.log(`  ${ctx.ui.red("\u2717")} ${truncate(t.task.title, 60)}${reason}`);
+    }
+  }
+}
+function renderEpicPlanTable(ui, plan, budget) {
+  const table = new Table6({
+    head: ["#", "Epic", "Scope", "Subtasks", "Est. Tokens", "Priority"]
+  });
+  for (let i = 0; i < plan.selectedEpics.length; i++) {
+    const entry = plan.selectedEpics[i];
+    table.push([
+      String(i + 1),
+      truncate(entry.epic.title, 45),
+      entry.epic.scope,
+      String(entry.epic.subtasks.length),
+      formatInteger(entry.estimatedTokens),
+      String(entry.epic.priority)
+    ]);
+  }
+  if (plan.selectedEpics.length > 0) {
+    console.log(table.toString());
+  } else {
+    console.log(ui.yellow("No epics selected for execution."));
+  }
+  if (plan.deferredEpics.length > 0) {
+    console.log("");
+    console.log(ui.yellow(`Deferred (${plan.deferredEpics.length}):`));
+    for (const deferred of plan.deferredEpics) {
+      console.log(
+        `  - ${truncate(deferred.epic.title, 60)} (${formatInteger(deferred.estimatedTokens)} tokens)`
+      );
+    }
+  }
+}
+
+// src/cli/commands/run/retry.ts
+import { readFile as readFile5, readdir as readdir3 } from "fs/promises";
+import { resolve as resolve6 } from "path";
+async function readMostRecentContributionLog(repoPath) {
+  const contributionsPath = resolve6(repoPath, ".oac", "contributions");
+  let entries;
+  try {
+    const dirEntries = await readdir3(contributionsPath, { withFileTypes: true, encoding: "utf8" });
+    entries = dirEntries.filter((e) => e.isFile() && e.name.endsWith(".json")).map((e) => e.name).sort((a, b) => b.localeCompare(a));
+  } catch {
+    return void 0;
+  }
+  for (const fileName of entries) {
+    try {
+      const content = await readFile5(resolve6(contributionsPath, fileName), "utf8");
+      const parsed = contributionLogSchema.safeParse(JSON.parse(content));
+      if (parsed.success) return parsed.data;
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+}
+function taskFromContributionEntry(entry) {
+  return {
+    id: entry.taskId,
+    source: entry.source,
+    title: entry.title,
+    description: `Retry of failed task: ${entry.title}`,
+    targetFiles: entry.filesChanged,
+    priority: 100,
+    // high priority — user explicitly chose to retry
+    complexity: entry.complexity,
+    executionMode: "new-pr",
+    metadata: { retryOf: entry.taskId },
+    discoveredAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function runRetryPipeline(ctx, params) {
+  const { resolvedRepo, providerId, totalBudget, concurrency, timeoutSeconds, mode, ghToken } = params;
+  const retrySpinner = createSpinner(ctx.suppressOutput, "Loading most recent contribution log...");
+  const log = await readMostRecentContributionLog(resolvedRepo.localPath);
+  if (!log) {
+    retrySpinner?.fail("No contribution logs found in .oac/contributions/");
+    if (!ctx.suppressOutput) {
+      console.log(ctx.ui.yellow("[oac] Run the pipeline at least once before using --retry-failed."));
+    }
+    return [];
+  }
+  const failedEntries = log.tasks.filter((t) => t.status === "failed");
+  if (failedEntries.length === 0) {
+    retrySpinner?.succeed("No failed tasks in the most recent run \u2014 nothing to retry.");
+    return [];
+  }
+  retrySpinner?.succeed(
+    `Found ${failedEntries.length} failed task(s) from run ${log.runId.slice(0, 8)}`
+  );
+  const retryTasks = failedEntries.map(taskFromContributionEntry);
+  const estimates = await estimateTaskMap(retryTasks, providerId);
+  const plan = buildExecutionPlan(retryTasks, estimates, totalBudget);
+  if (plan.selectedTasks.length === 0) {
+    if (!ctx.suppressOutput) {
+      console.log(ctx.ui.yellow("[oac] No retry tasks could be selected within the budget."));
+    }
+    return [];
+  }
+  if (!ctx.suppressOutput) {
+    console.log(
+      ctx.ui.blue(
+        `
+[oac] Retrying ${plan.selectedTasks.length} failed task(s) (budget: ${formatInteger(totalBudget)} tokens)`
+      )
+    );
+  }
+  const completedTasks = await executePlan(ctx, {
+    plan,
+    providerId,
+    resolvedRepo,
+    concurrency,
+    timeoutSeconds,
+    mode,
+    ghToken
+  });
+  await writeTracking(ctx, {
+    resolvedRepo,
+    providerId,
+    totalBudget,
+    candidateTasks: retryTasks,
+    completedTasks
+  });
+  printFinalSummary(ctx, {
+    plan,
+    resolvedRepo,
+    providerId,
+    totalBudget,
+    completedTasks
+  });
+  return completedTasks;
+}
+
+// src/cli/commands/run/pipeline.ts
+async function runPipeline(options, globalOptions, ui) {
+  const ctx = {
+    options,
+    globalOptions,
+    ui,
+    outputJson: globalOptions.json,
+    suppressOutput: globalOptions.json || globalOptions.quiet,
+    runId: randomUUID(),
+    runStartedAt: Date.now()
+  };
+  const config = await loadOptionalConfig(globalOptions.config, globalOptions.verbose, ui);
+  const providerId = resolveProviderId(options.provider, config);
+  const totalBudget = resolveBudget(options.tokens, config);
+  const mode = resolveMode(options.mode, config);
+  const concurrency = resolveConcurrency(options.concurrency, config);
+  const timeoutSeconds = resolveTimeout(options.timeout, config);
+  const ghToken = ensureGitHubAuth();
+  printGitHubAuthWarnings(ctx, ghToken);
+  printRunHeader(ctx, totalBudget, concurrency);
+  const repoInput = resolveRepoInput(options.repo, config);
+  const resolveSpinner = createSpinner(ctx.suppressOutput, "Resolving repository...");
+  const resolvedRepo = await resolveRepo(repoInput);
+  resolveSpinner?.succeed(`Resolved ${resolvedRepo.fullName}`);
+  const cloneSpinner = createSpinner(ctx.suppressOutput, "Preparing local clone...");
+  await cloneRepo(resolvedRepo);
+  cloneSpinner?.succeed(`Repository ready at ${resolvedRepo.localPath}`);
+  if (options.retryFailed) {
+    const retryResults = await runRetryPipeline(ctx, {
+      resolvedRepo,
+      providerId,
+      totalBudget,
+      concurrency,
+      timeoutSeconds,
+      mode,
+      ghToken
+    });
+    process.exitCode = resolveExitCode(retryResults);
+    return;
+  }
+  const autoAnalyze = config?.analyze?.autoAnalyze ?? true;
+  const contextDir = config?.analyze?.contextDir ?? ".oac/context";
+  const staleAfterMs = config?.analyze?.staleAfterMs ?? 864e5;
+  const epics = await tryLoadOrAnalyzeEpics(ctx, {
+    resolvedRepo,
+    config,
+    ghToken,
+    autoAnalyze,
+    contextDir,
+    staleAfterMs
+  });
+  if (epics && epics.length > 0) {
+    const epicResults = await runEpicPipeline(ctx, {
+      epics,
+      resolvedRepo,
+      config,
+      providerId,
+      totalBudget,
+      concurrency,
+      timeoutSeconds,
+      mode,
+      ghToken,
+      contextDir
+    });
+    process.exitCode = resolveExitCode(epicResults);
+    return;
+  }
+  const { candidateTasks, plan } = await discoverTasks(ctx, options, config, ghToken, resolvedRepo);
+  if (candidateTasks.length === 0) {
+    printEmptySummary(ctx, resolvedRepo.fullName, providerId, totalBudget);
+    return;
+  }
+  if (options.dryRun) {
+    printDryRunSummary(ctx, resolvedRepo.fullName, providerId, totalBudget, plan);
+    return;
+  }
+  const completedTasks = await executePlan(ctx, {
+    plan,
+    providerId,
+    resolvedRepo,
+    concurrency,
+    timeoutSeconds,
+    mode,
+    ghToken
+  });
+  await writeTracking(ctx, {
+    resolvedRepo,
+    providerId,
+    totalBudget,
+    candidateTasks,
+    completedTasks
+  });
+  printFinalSummary(ctx, {
+    plan,
+    resolvedRepo,
+    providerId,
+    totalBudget,
+    completedTasks
+  });
+  process.exitCode = resolveExitCode(completedTasks);
+}
+function printGitHubAuthWarnings(ctx, ghToken) {
+  if (ctx.suppressOutput) return;
+  if (!ghToken) {
+    console.log(
+      ctx.ui.yellow("[oac] Warning: GitHub auth not detected. Run `gh auth login` first.")
+    );
+    console.log(
+      ctx.ui.yellow("[oac] For private repos, ensure the 'repo' scope: gh auth refresh -s repo")
+    );
+  } else {
+    const missingScopes = checkGitHubScopes(["repo"]);
+    if (missingScopes.length > 0) {
+      console.log(
+        ctx.ui.yellow(
+          `[oac] Warning: GitHub token missing scope(s): ${missingScopes.join(", ")}. Private repos may fail.`
+        )
+      );
+      console.log(ctx.ui.yellow("[oac] Fix with: gh auth refresh -s repo"));
+    }
+  }
+}
+function printRunHeader(ctx, totalBudget, concurrency) {
+  if (ctx.suppressOutput) return;
+  console.log(
+    ctx.ui.blue(
+      `Starting OAC run (budget: ${formatBudgetDisplay(totalBudget)} tokens, concurrency: ${concurrency})`
+    )
+  );
+}
+function validateRunOptions(options) {
+  if (typeof options.concurrency === "number" && options.concurrency <= 0) {
+    throw new ConfigError("--concurrency must be greater than zero.");
+  }
+  if (typeof options.timeout === "number" && options.timeout <= 0) {
+    throw new ConfigError("--timeout must be greater than zero.");
+  }
+  if (typeof options.maxTasks === "number" && options.maxTasks <= 0) {
+    throw new ConfigError("--max-tasks must be greater than zero when provided.");
+  }
+}
+function resolveMode(modeOption, config) {
+  const candidate = (modeOption ?? config?.execution.mode ?? "new-pr").trim();
+  if (candidate === "new-pr" || candidate === "update-pr" || candidate === "direct-commit") {
+    return candidate;
+  }
+  throw new ConfigError(`Invalid --mode value "${candidate}".`);
+}
+function resolveConcurrency(concurrencyOption, config) {
+  const configuredConcurrency = typeof concurrencyOption === "number" ? concurrencyOption : config?.execution.concurrency ?? DEFAULT_CONCURRENCY;
+  if (!Number.isFinite(configuredConcurrency) || configuredConcurrency <= 0) {
+    throw new ConfigError("Concurrency must be a positive integer.");
+  }
+  return Math.floor(configuredConcurrency);
+}
+function resolveTimeout(timeoutOption, config) {
+  const configuredTimeout = typeof timeoutOption === "number" ? timeoutOption : config?.execution.taskTimeout ?? DEFAULT_TIMEOUT_SECONDS;
+  if (!Number.isFinite(configuredTimeout) || configuredTimeout <= 0) {
+    throw new ConfigError("Timeout must be a positive integer.");
+  }
+  return Math.floor(configuredTimeout);
+}
+
+// src/cli/commands/run/index.ts
+function parseTokens(value) {
+  if (value.toLowerCase() === "unlimited") {
+    return UNLIMITED_BUDGET;
+  }
+  return parseInteger(value);
+}
+function createRunCommand() {
+  const command = new Command10("run");
+  command.alias("r").description(
+    "Run the full OAC pipeline \u2014 analyze, plan, and execute in one command"
+  ).option("--repo <owner/repo>", "Target repository (owner/repo or GitHub URL)").option("--tokens <value>", 'Token budget (number or "unlimited")', parseTokens).option("--provider <id>", "Agent provider id").option("--concurrency <number>", "Maximum parallel task executions", parseInteger).option("--dry-run", "Show plan without executing tasks", false).option("--mode <mode>", "Execution mode: new-pr|update-pr|direct-commit").option("--max-tasks <number>", "Maximum number of discovered tasks to consider", parseInteger).option("--timeout <seconds>", "Per-task timeout in seconds", parseInteger).option("--source <source>", "Filter tasks by source: lint, todo, github-issue, test-gap").option("--retry-failed", "Re-run only failed tasks from the most recent run", false).action(async (options, cmd) => {
+    const globalOptions = getGlobalOptions(cmd);
+    const ui = createUi(globalOptions);
+    validateRunOptions(options);
+    await runPipeline(options, globalOptions, ui);
+  });
+  command.addHelpText(
+    "after",
+    `
+This is the primary command. It auto-analyzes the codebase, groups findings
+into epics, and executes them \u2014 no separate scan/analyze step required.
+
+If no oac.config.ts exists, pass --repo to get started immediately:
+  $ oac run --repo owner/repo
+
+Examples:
+  $ oac run --repo owner/repo --tokens 50000
+  $ oac run --repo owner/repo --provider codex --concurrency 4
+  $ oac run --repo owner/repo --dry-run
+  $ oac run --repo owner/repo --source lint --max-tasks 10
+  $ oac run --repo owner/repo --retry-failed
+
+Exit Codes:
+  0   All tasks/epics completed successfully (or dry-run)
+  1   Unexpected / unhandled error
+  2   Configuration or validation error (bad flags, missing repo)
+  3   All selected tasks/epics failed
+  4   Partial success \u2014 some tasks succeeded, others failed`
+  );
+  return command;
+}
+
+// src/cli/commands/scan.ts
+import Table7 from "cli-table3";
+import { Command as Command11 } from "commander";
+var SUPPORTED_SCANNERS = ["lint", "todo", "github-issues", "test-gap"];
+function createScanCommand() {
+  const command = new Command11("scan");
+  command.description("Quick task discovery \u2014 list individual issues ranked by priority").option("--repo <owner/repo>", "Target repository (owner/repo or GitHub URL)").option("--scanners <names>", "Comma-separated scanner filter (lint,todo)").option("--min-priority <number>", "Minimum priority threshold (0-100)", parseInteger, 20).option("--format <format>", "Output format: table|json", "table").action(async (options, cmd) => {
+    const globalOptions = getGlobalOptions(cmd);
+    const ui = createUi(globalOptions);
+    const outputFormat = normalizeOutputFormat2(options.format);
+    const outputJson = globalOptions.json || outputFormat === "json";
+    if (options.minPriority < 0 || options.minPriority > 100) {
+      throw new Error("--min-priority must be between 0 and 100.");
+    }
+    const config = await loadOptionalConfig(globalOptions.config, globalOptions.verbose, ui);
+    const repoInput = resolveRepoInput(options.repo, config);
+    const ghToken = ensureGitHubAuth();
+    const scannerSelection = selectScanners(options.scanners, config, Boolean(ghToken));
+    if (!outputJson && scannerSelection.unknown.length > 0) {
+      console.log(
+        ui.yellow(
+          `Ignoring unsupported scanner(s): ${scannerSelection.unknown.join(", ")}. Supported scanners: ${SUPPORTED_SCANNERS.join(", ")}.`
+        )
+      );
+    }
+    const resolveSpinner = createSpinner(outputJson, "Resolving repository...");
+    const resolvedRepo = await resolveRepo(repoInput);
+    resolveSpinner?.succeed(`Resolved ${resolvedRepo.fullName}`);
+    const cloneSpinner = createSpinner(outputJson, "Preparing local clone...");
+    await cloneRepo(resolvedRepo);
+    cloneSpinner?.succeed(`Repository ready at ${resolvedRepo.localPath}`);
+    const scanSpinner = createSpinner(
+      outputJson,
+      `Running scanners: ${scannerSelection.enabled.join(", ")}`
+    );
+    const scannedTasks = await scannerSelection.scanner.scan(resolvedRepo.localPath, {
+      exclude: config?.discovery.exclude,
+      maxTasks: config?.discovery.maxTasks,
+      repo: resolvedRepo
+    });
+    scanSpinner?.succeed(`Scanned ${resolvedRepo.fullName}`);
+    const rankedTasks = rankTasks(scannedTasks).filter(
+      (task) => task.priority >= options.minPriority
+    );
+    if (outputJson) {
+      console.log(
+        JSON.stringify(
+          {
+            repo: resolvedRepo.fullName,
+            scanners: scannerSelection.enabled,
+            minPriority: options.minPriority,
+            totalTasks: rankedTasks.length,
+            tasks: rankedTasks
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    if (rankedTasks.length === 0) {
+      console.log(ui.yellow("No tasks discovered for the selected criteria."));
+      return;
+    }
+    const table = new Table7({
+      head: ["ID", "Title", "Source", "Priority", "Complexity"]
+    });
+    for (const task of rankedTasks) {
+      table.push([
+        task.id,
+        truncate(task.title, 60),
+        task.source,
+        String(task.priority),
+        task.complexity
+      ]);
+    }
+    console.log(table.toString());
+    console.log("");
+    console.log(
+      ui.blue(
+        `Found ${rankedTasks.length} task(s). Use \`oac plan --repo ${resolvedRepo.fullName} --tokens <n>\` to build an execution plan.`
+      )
+    );
+  });
+  command.addHelpText(
+    "after",
+    `
+Scan runs lightweight scanners and outputs a flat list of ranked tasks.
+For deeper analysis that groups findings into epics, use \`oac analyze\`.
+To run the full pipeline (analyze + execute), use \`oac run\`.
+
+Examples:
+  $ oac scan --repo owner/repo
+  $ oac scan --repo owner/repo --scanners lint,todo
+  $ oac scan --repo owner/repo --min-priority 50 --format json`
+  );
+  return command;
+}
+function normalizeOutputFormat2(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "table" || normalized === "json") {
+    return normalized;
+  }
+  throw new Error(`Unsupported --format value "${value}". Use "table" or "json".`);
+}
+function selectScanners(scannerOption, config, hasGitHubAuth = false) {
+  const defaultScanners = ["lint", "todo", "test-gap"];
+  if (hasGitHubAuth) {
+    defaultScanners.push("github-issues");
+  }
+  const requested = scannerOption ? parseCsv(scannerOption) : scannersFromConfig(config, hasGitHubAuth) ?? defaultScanners;
+  const enabled = [];
+  const unknown = [];
+  for (const scannerName of requested) {
+    const normalized = scannerName.toLowerCase();
+    if (normalized === "lint" || normalized === "todo" || normalized === "github-issues" || normalized === "test-gap") {
+      enabled.push(normalized);
+    } else {
+      unknown.push(scannerName);
+    }
+  }
+  const uniqueEnabled = [...new Set(enabled)];
+  if (uniqueEnabled.length === 0) {
+    throw new Error(
+      `No supported scanners selected. Supported scanners: ${SUPPORTED_SCANNERS.join(", ")}.`
+    );
+  }
+  const scannerInstances = uniqueEnabled.map((name) => {
+    if (name === "lint") return new LintScanner();
+    if (name === "github-issues") return new GitHubIssuesScanner();
+    if (name === "test-gap") return new TestGapScanner();
+    return new TodoScanner();
+  });
+  return {
+    enabled: uniqueEnabled,
+    unknown,
+    scanner: new CompositeScanner(scannerInstances)
+  };
+}
+function scannersFromConfig(config, hasGitHubAuth = false) {
+  if (!config) {
+    return null;
+  }
+  const configured = [];
+  if (config.discovery.scanners.lint) {
+    configured.push("lint");
+  }
+  if (config.discovery.scanners.todo) {
+    configured.push("todo");
+  }
+  if (config.discovery.scanners.testGap) {
+    configured.push("test-gap");
+  }
+  if (hasGitHubAuth) {
+    configured.push("github-issues");
+  }
+  if (configured.length === 0) {
+    return null;
+  }
+  return configured;
+}
+function parseCsv(value) {
+  return value.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+}
+
+// src/cli/commands/status.ts
+import { readFile as readFile6 } from "fs/promises";
+import { resolve as resolve7 } from "path";
+import { Command as Command12 } from "commander";
+var WATCH_INTERVAL_MS = 2e3;
+function createStatusCommand() {
+  const command = new Command12("status");
+  command.description("Show current job status").option("--watch", "Poll every 2 seconds", false).action(async (options, cmd) => {
+    const globalOptions = getGlobalOptions(cmd);
+    const render = async () => {
+      const status = await readRunStatus(process.cwd());
+      renderStatusOutput(status, globalOptions.json);
+    };
+    await render();
+    if (!options.watch) {
+      return;
+    }
+    const intervalId = setInterval(() => {
+      console.clear();
+      void render().catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        process.exitCode = 1;
+      });
+    }, WATCH_INTERVAL_MS);
+    process.on("SIGINT", () => {
+      clearInterval(intervalId);
+      console.log("\nWatch mode stopped.");
+      process.exit(0);
+    });
+  });
+  command.addHelpText(
+    "after",
+    `
+Examples:
+  $ oac status
+  $ oac status --watch`
+  );
+  return command;
+}
+async function readRunStatus(repoPath) {
+  const statusPath = resolve7(repoPath, ".oac", "status.json");
+  try {
+    const raw = await readFile6(statusPath, "utf8");
+    const payload = JSON.parse(raw);
+    return parseRunStatus(payload);
+  } catch (error) {
+    if (isFileNotFoundError3(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+function parseRunStatus(payload) {
+  if (!isRecord(payload)) {
+    throw new Error("Invalid .oac/status.json format.");
+  }
+  const runId = payload.runId;
+  const startedAt = payload.startedAt;
+  const agent = payload.agent;
+  const tasks = payload.tasks;
+  if (typeof runId !== "string" || typeof startedAt !== "string" || typeof agent !== "string" || !Array.isArray(tasks)) {
+    throw new Error("Invalid .oac/status.json format.");
+  }
+  return {
+    runId,
+    startedAt,
+    agent,
+    tasks: tasks.map((task, index) => parseRunStatusTask(task, index))
+  };
+}
+function parseRunStatusTask(task, index) {
+  if (!isRecord(task)) {
+    throw new Error(`Invalid task at index ${String(index)} in .oac/status.json.`);
+  }
+  const taskId = task.taskId;
+  const title = task.title;
+  const status = task.status;
+  const startedAt = task.startedAt;
+  const completedAt = task.completedAt;
+  const error = task.error;
+  if (typeof taskId !== "string" || typeof title !== "string" || status !== "pending" && status !== "running" && status !== "completed" && status !== "failed") {
+    throw new Error(`Invalid task at index ${String(index)} in .oac/status.json.`);
+  }
+  if (startedAt !== void 0 && typeof startedAt !== "string") {
+    throw new Error(`Invalid task at index ${String(index)} in .oac/status.json.`);
+  }
+  if (completedAt !== void 0 && typeof completedAt !== "string") {
+    throw new Error(`Invalid task at index ${String(index)} in .oac/status.json.`);
+  }
+  if (error !== void 0 && typeof error !== "string") {
+    throw new Error(`Invalid task at index ${String(index)} in .oac/status.json.`);
+  }
+  return {
+    taskId,
+    title,
+    status,
+    startedAt,
+    completedAt,
+    error
+  };
+}
+function renderStatusOutput(status, outputJson) {
+  if (outputJson) {
+    if (!status) {
+      console.log(
+        JSON.stringify(
+          {
+            active: false,
+            message: "No active runs"
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    console.log(
+      JSON.stringify(
+        {
+          active: true,
+          status
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (!status) {
+    console.log("No active runs");
+    return;
+  }
+  const runningTasks = status.tasks.filter((task) => task.status === "running");
+  const completedTasks = status.tasks.filter((task) => task.status === "completed");
+  const failedTasks = status.tasks.filter((task) => task.status === "failed");
+  console.log(`Run ID: ${status.runId}`);
+  console.log(`Start Time: ${status.startedAt}`);
+  console.log(`Agent: ${status.agent}`);
+  console.log(
+    `Tasks In Progress (${String(runningTasks.length)}): ${formatTaskList(runningTasks)}`
+  );
+  console.log(
+    `Completed Tasks (${String(completedTasks.length)}): ${formatTaskList(completedTasks)}`
+  );
+  if (failedTasks.length === 0) {
+    console.log("Errors: none");
+    return;
+  }
+  console.log(`Errors (${String(failedTasks.length)}):`);
+  for (const task of failedTasks) {
+    console.log(`- ${task.taskId}: ${task.error ?? "Unknown error"}`);
+  }
+}
+function formatTaskList(tasks) {
+  if (tasks.length === 0) {
+    return "-";
+  }
+  return tasks.map((task) => `${task.taskId} (${task.title})`).join(", ");
+}
+function isFileNotFoundError3(error) {
+  if (!isRecord(error)) {
+    return false;
+  }
+  return error.code === "ENOENT";
+}
+
+// src/cli/cli.ts
+function registerCommands(program) {
+  program.addCommand(createInitCommand());
+  program.addCommand(createAnalyzeCommand());
+  program.addCommand(createDoctorCommand());
+  program.addCommand(createScanCommand());
+  program.addCommand(createPlanCommand());
+  program.addCommand(createRunCommand());
+  program.addCommand(createLogCommand());
+  program.addCommand(createLeaderboardCommand());
+  program.addCommand(createStatusCommand());
+  program.addCommand(createCompletionCommand());
+  program.addCommand(createExplainCommand());
+}
+async function createCliProgram() {
+  const version = true ? "2026.2.5" : "0.0.0";
+  const program = new Command13();
+  program.name("oac").description("Open Agent Contribution CLI").version(version).option("--config <path>", "Config file path", "oac.config.ts").option("--verbose", "Enable verbose logging", false).option("--quiet", "Suppress non-error output", false).option("--json", "Output machine-readable JSON", false).option("--no-color", "Disable ANSI colors");
+  registerCommands(program);
+  program.addHelpText(
+    "after",
+    `
+Getting Started:
+  $ oac init          Set up your project configuration
+  $ oac doctor        Verify your environment is ready
+  $ oac analyze       Analyze codebase for contribution opportunities
+  $ oac run           Run the full contribution pipeline
+
+Documentation: https://github.com/Open330/open-agent-contribution
+`
+  );
+  return program;
+}
+async function runCli(argv = process.argv) {
+  const program = await createCliProgram();
+  await program.parseAsync([...argv]);
+}
+
+export {
+  ConfigError,
+  EXIT_GENERAL_ERROR,
+  EXIT_CONFIG_ERROR,
+  createCliProgram,
+  runCli
+};
+//# sourceMappingURL=chunk-4IUL7ECC.js.map