@open330/oac 2026.2.17

package/dist/chunk-UVK4T7KV.js

@@ -0,0 +1,2238 @@
+// src/cli.ts
+import { readFile as readFile4 } from "fs/promises";
+import { Command as Command9 } from "commander";
+
+// src/commands/doctor.ts
+import { spawn } from "child_process";
+import chalk, { Chalk } from "chalk";
+import { Command } from "commander";
+var MINIMUM_NODE_VERSION = "24.0.0";
+function createDoctorCommand() {
+  const command = new Command("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 === "pass");
+    if (globalOptions.json) {
+      console.log(
+        JSON.stringify(
+          {
+            checks,
+            allPassed
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      renderDoctorOutput(ui, checks, allPassed);
+    }
+    if (!allPassed) {
+      process.exitCode = 1;
+    }
+  });
+  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-cli",
+    name: "Codex CLI",
+    requirement: "installed",
+    value: codexVersion,
+    status: codexResult.ok ? "pass" : "fail",
+    message: codexResult.ok ? void 0 : explainCommandFailure("codex", codexResult)
+  });
+  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) {
+    return {
+      id: "github-auth",
+      name: "GitHub auth",
+      requirement: "gh auth status or GITHUB_TOKEN",
+      value: "gh auth status",
+      status: "pass"
+    };
+  }
+  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 getGlobalOptions(command) {
+  const options = command.optsWithGlobals();
+  return {
+    config: options.config ?? "oac.config.ts",
+    verbose: options.verbose === 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 renderDoctorOutput(ui, checks, allPassed) {
+  console.log("Checking environment...");
+  console.log("");
+  for (const check of checks) {
+    const icon = check.status === "pass" ? ui.green("[OK]") : ui.red("[X]");
+    const status = check.status === "pass" ? ui.green("PASS") : ui.red("FAIL");
+    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)}`);
+    }
+  }
+  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;
+}
+function runCommand(command, args) {
+  return new Promise((resolvePromise) => {
+    const child = spawn(command, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: process.env
+    });
+    let stdout = "";
+    let stderr = "";
+    let resolved = false;
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.once("error", (error) => {
+      if (resolved) {
+        return;
+      }
+      resolved = true;
+      const errorWithCode = error;
+      resolvePromise({
+        ok: false,
+        exitCode: null,
+        stdout,
+        stderr,
+        errorCode: errorWithCode.code,
+        errorMessage: error.message
+      });
+    });
+    child.once("close", (exitCode) => {
+      if (resolved) {
+        return;
+      }
+      resolved = true;
+      resolvePromise({
+        ok: exitCode === 0,
+        exitCode,
+        stdout,
+        stderr
+      });
+    });
+  });
+}
+
+// src/commands/init.ts
+import { constants as fsConstants } from "fs";
+import { access, mkdir, writeFile } from "fs/promises";
+import { resolve } from "path";
+import { checkbox, confirm, input } from "@inquirer/prompts";
+import chalk2, { Chalk as Chalk2 } from "chalk";
+import { Command as Command2 } 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 Command2("init");
+  command.description("Initialize OAC in the current directory").action(async (_options, cmd) => {
+    const globalOptions = getGlobalOptions2(cmd);
+    const ui = createUi2(globalOptions);
+    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-cli" },
+        { 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 = resolve(process.cwd(), "oac.config.ts");
+    const trackingDirectory = resolve(process.cwd(), ".oac");
+    if (await pathExists(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 });
+    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 doctor` to verify or `oac scan` to discover tasks.");
+  });
+  return command;
+}
+function getGlobalOptions2(command) {
+  const options = command.optsWithGlobals();
+  return {
+    config: options.config ?? "oac.config.ts",
+    verbose: options.verbose === true,
+    json: options.json === true,
+    color: options.color !== false
+  };
+}
+function createUi2(options) {
+  const noColorEnv = Object.prototype.hasOwnProperty.call(process.env, "NO_COLOR");
+  const colorEnabled = options.color && !noColorEnv;
+  return new Chalk2({ level: colorEnabled ? chalk2.level : 0 });
+}
+function buildConfigFile(input2) {
+  const enabledProviders = input2.providers.map((provider) => `'${provider}'`).join(", ");
+  return `import { defineConfig } from '@open330/oac-core';
+
+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 pathExists(path) {
+  try {
+    await access(path, fsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/leaderboard.ts
+import { readFile, readdir } from "fs/promises";
+import { resolve as resolve2 } from "path";
+import { contributionLogSchema } from "@open330/oac-tracking";
+import Table from "cli-table3";
+import { Command as Command3 } from "commander";
+function createLeaderboardCommand() {
+  const command = new Command3("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 = getGlobalOptions3(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 Table({
+      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());
+  });
+  return command;
+}
+function getGlobalOptions3(command) {
+  const options = command.optsWithGlobals();
+  return {
+    config: options.config ?? "oac.config.ts",
+    verbose: options.verbose === true,
+    json: options.json === true,
+    color: options.color !== false
+  };
+}
+async function loadLeaderboardEntries(repoPath) {
+  const leaderboardPath = resolve2(repoPath, ".oac", "leaderboard.json");
+  try {
+    const leaderboardRaw = await readFile(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 = resolve2(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 = resolve2(contributionsPath, fileName);
+      try {
+        const content = await readFile(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 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);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isFileNotFoundError(error) {
+  if (!isRecord(error)) {
+    return false;
+  }
+  return error.code === "ENOENT";
+}
+
+// src/commands/log.ts
+import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
+import { resolve as resolve3 } from "path";
+import { contributionLogSchema as contributionLogSchema2 } from "@open330/oac-tracking";
+import Table2 from "cli-table3";
+import { Command as Command4 } from "commander";
+function createLogCommand() {
+  const command = new Command4("log");
+  command.description("View contribution history").option("--limit <number>", "Max entries to show", parseInteger2, 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 = getGlobalOptions4(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 Table2({
+      head: ["Date", "Repo", "Tasks", "Tokens", "PRs", "Source"]
+    });
+    for (const log of filteredLogs) {
+      table.push([
+        formatDate(log.timestamp),
+        log.repo.fullName,
+        String(log.tasks.length),
+        formatInteger2(log.budget.totalTokensUsed),
+        String(log.tasks.filter((task) => Boolean(task.pr)).length),
+        summarizeSources(log)
+      ]);
+    }
+    console.log(table.toString());
+  });
+  return command;
+}
+function getGlobalOptions4(command) {
+  const options = command.optsWithGlobals();
+  return {
+    config: options.config ?? "oac.config.ts",
+    verbose: options.verbose === true,
+    json: options.json === true,
+    color: options.color !== false
+  };
+}
+async function readContributionLogs2(repoPath) {
+  const contributionsPath = resolve3(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 = resolve3(contributionsPath, fileName);
+      try {
+        const content = await readFile2(filePath, "utf8");
+        const payload = JSON.parse(content);
+        const parsed = contributionLogSchema2.safeParse(payload);
+        return parsed.success ? parsed.data : null;
+      } catch {
+        return null;
+      }
+    })
+  );
+  return logs.filter((log) => log !== null);
+}
+function parseInteger2(value) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`Expected an integer but received "${value}".`);
+  }
+  return parsed;
+}
+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 formatInteger2(value) {
+  return new Intl.NumberFormat("en-US").format(value);
+}
+function isFileNotFoundError2(error) {
+  if (typeof error !== "object" || error === null) {
+    return false;
+  }
+  const code = error.code;
+  return code === "ENOENT";
+}
+
+// src/commands/plan.ts
+import { constants as fsConstants2 } from "fs";
+import { access as access2 } from "fs/promises";
+import { resolve as resolve4 } from "path";
+import { pathToFileURL } from "url";
+import { buildExecutionPlan, estimateTokens } from "@open330/oac-budget";
+import { loadConfig } from "@open330/oac-core";
+import {
+  CompositeScanner,
+  LintScanner,
+  TodoScanner,
+  rankTasks
+} from "@open330/oac-discovery";
+import { cloneRepo, resolveRepo } from "@open330/oac-repo";
+import chalk3, { Chalk as Chalk3 } from "chalk";
+import Table3 from "cli-table3";
+import { Command as Command5 } from "commander";
+import ora from "ora";
+function createPlanCommand() {
+  const command = new Command5("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", parseInteger3).option("--provider <id>", "Agent provider id").action(async (options, cmd) => {
+    const globalOptions = getGlobalOptions5(cmd);
+    const ui = createUi3(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);
+    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
+    });
+  });
+  return command;
+}
+function getGlobalOptions5(command) {
+  const options = command.optsWithGlobals();
+  return {
+    config: options.config ?? "oac.config.ts",
+    verbose: options.verbose === true,
+    json: options.json === true,
+    color: options.color !== false
+  };
+}
+function createUi3(options) {
+  const noColorEnv = Object.prototype.hasOwnProperty.call(process.env, "NO_COLOR");
+  const colorEnabled = options.color && !noColorEnv;
+  return new Chalk3({ level: colorEnabled ? chalk3.level : 0 });
+}
+function createSpinner(enabled, text) {
+  if (enabled) {
+    return null;
+  }
+  return ora({ text, color: "blue" }).start();
+}
+function parseInteger3(value) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`Expected an integer but received "${value}".`);
+  }
+  return parsed;
+}
+async function loadOptionalConfig(configPath, verbose, ui) {
+  const absolutePath = resolve4(process.cwd(), configPath);
+  if (!await pathExists2(absolutePath)) {
+    return null;
+  }
+  try {
+    const imported = await import(`${pathToFileURL(absolutePath).href}?t=${Date.now()}`);
+    const candidate = imported.default ?? imported.config ?? imported;
+    return loadConfig(candidate);
+  } catch (error) {
+    if (verbose) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(ui.yellow(`[oac] Failed to load config at ${configPath}: ${message}`));
+    }
+    return null;
+  }
+}
+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. Use --repo or configure repos in oac.config.ts.");
+}
+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);
+}
+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)
+  };
+}
+async function estimateTaskMap(tasks, providerId) {
+  const entries = await Promise.all(
+    tasks.map(async (task) => {
+      const estimate = await estimateTokens(task, providerId);
+      return [task.id, estimate];
+    })
+  );
+  return new Map(entries);
+}
+function renderPlan(ui, data) {
+  const table = new Table3({
+    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),
+      formatInteger3(entry.estimate.totalEstimatedTokens),
+      formatInteger3(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: ${formatInteger3(budgetUsed)} / ${formatInteger3(effectiveBudget)} (effective)`
+  );
+  console.log(`Reserve:     ${formatInteger3(data.plan.reserveTokens)} (10%)`);
+  console.log(`Remaining:   ${formatInteger3(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)} (${formatInteger3(
+          deferred.estimate.totalEstimatedTokens
+        )} tokens, ${reason})`
+      );
+    }
+  }
+}
+function formatInteger3(value) {
+  return new Intl.NumberFormat("en-US").format(value);
+}
+function truncate(value, maxLength) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+async function pathExists2(path) {
+  try {
+    await access2(path, fsConstants2.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/run.ts
+import { randomUUID } from "crypto";
+import { constants as fsConstants3 } from "fs";
+import { access as access3 } from "fs/promises";
+import { resolve as resolve5 } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import { buildExecutionPlan as buildExecutionPlan2, estimateTokens as estimateTokens2 } from "@open330/oac-budget";
+import {
+  UNLIMITED_BUDGET,
+  createEventBus,
+  loadConfig as loadConfig2
+} from "@open330/oac-core";
+import {
+  CompositeScanner as CompositeScanner2,
+  GitHubIssuesScanner,
+  LintScanner as LintScanner2,
+  TodoScanner as TodoScanner2,
+  rankTasks as rankTasks2
+} from "@open330/oac-discovery";
+import {
+  CodexAdapter,
+  createSandbox,
+  executeTask as workerExecuteTask
+} from "@open330/oac-execution";
+import { cloneRepo as cloneRepo2, resolveRepo as resolveRepo2 } from "@open330/oac-repo";
+import { writeContributionLog } from "@open330/oac-tracking";
+import chalk4, { Chalk as Chalk4 } from "chalk";
+import Table4 from "cli-table3";
+import { Command as Command6 } from "commander";
+import { execa } from "execa";
+import ora2 from "ora";
+var DEFAULT_TIMEOUT_SECONDS = 300;
+var DEFAULT_CONCURRENCY = 2;
+function createRunCommand() {
+  const command = new Command6("run");
+  command.description("Run the full OAC pipeline").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", parseInteger4).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", parseInteger4).option("--timeout <seconds>", "Per-task timeout in seconds", parseInteger4).option("--source <source>", "Filter tasks by source (lint, todo, github-issue, test-gap)").action(async (options, cmd) => {
+    const globalOptions = getGlobalOptions6(cmd);
+    const ui = createUi4(globalOptions);
+    const outputJson = globalOptions.json;
+    validateRunOptions(options);
+    const config = await loadOptionalConfig2(globalOptions.config, globalOptions.verbose, ui);
+    const repoInput = resolveRepoInput2(options.repo, config);
+    const providerId = resolveProviderId2(options.provider, config);
+    const totalBudget = resolveBudget2(options.tokens, config);
+    const mode = resolveMode(options.mode, config);
+    const concurrency = resolveConcurrency(options.concurrency, config);
+    const timeoutSeconds = resolveTimeout(options.timeout, config);
+    const minPriority = config?.discovery.minPriority ?? 20;
+    const maxTasks = options.maxTasks ?? void 0;
+    const scannerSelection = selectScannersFromConfig2(config);
+    const runStartedAt = Date.now();
+    const runId = randomUUID();
+    if (!outputJson) {
+      console.log(
+        ui.blue(
+          `Starting OAC run (budget: ${formatBudgetDisplay(totalBudget)} tokens, concurrency: ${concurrency})`
+        )
+      );
+    }
+    const resolveSpinner = createSpinner2(outputJson, "Resolving repository...");
+    const resolvedRepo = await resolveRepo2(repoInput);
+    resolveSpinner?.succeed(`Resolved ${resolvedRepo.fullName}`);
+    const cloneSpinner = createSpinner2(outputJson, "Preparing local clone...");
+    await cloneRepo2(resolvedRepo);
+    cloneSpinner?.succeed(`Repository ready at ${resolvedRepo.localPath}`);
+    const scanSpinner = createSpinner2(
+      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)`);
+    let candidateTasks = rankTasks2(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);
+    }
+    if (candidateTasks.length === 0) {
+      const emptySummary = {
+        runId,
+        repo: resolvedRepo.fullName,
+        provider: providerId,
+        dryRun: Boolean(options.dryRun),
+        selectedTasks: 0,
+        deferredTasks: 0,
+        tasksCompleted: 0,
+        tasksFailed: 0,
+        prsCreated: 0,
+        tokensUsed: 0,
+        tokensBudgeted: totalBudget
+      };
+      if (outputJson) {
+        console.log(JSON.stringify({ summary: emptySummary, plan: null }, null, 2));
+      } else {
+        console.log(ui.yellow("No tasks discovered for execution."));
+      }
+      return;
+    }
+    const estimateSpinner = createSpinner2(
+      outputJson,
+      `Estimating tokens for ${candidateTasks.length} task(s)...`
+    );
+    const estimates = await estimateTaskMap2(candidateTasks, providerId);
+    estimateSpinner?.succeed("Token estimation completed");
+    const plan = buildExecutionPlan2(candidateTasks, estimates, totalBudget);
+    if (options.dryRun) {
+      const dryRunSummary = {
+        runId,
+        repo: resolvedRepo.fullName,
+        provider: providerId,
+        dryRun: true,
+        selectedTasks: plan.selectedTasks.length,
+        deferredTasks: plan.deferredTasks.length,
+        tasksCompleted: 0,
+        tasksFailed: 0,
+        prsCreated: 0,
+        tokensUsed: 0,
+        tokensBudgeted: totalBudget
+      };
+      if (outputJson) {
+        console.log(
+          JSON.stringify(
+            {
+              summary: dryRunSummary,
+              plan
+            },
+            null,
+            2
+          )
+        );
+      } else {
+        renderSelectedPlanTable(ui, plan, totalBudget);
+        console.log("");
+        console.log(ui.blue("Dry run complete. No tasks were executed."));
+      }
+      return;
+    }
+    const codexAdapter = new CodexAdapter();
+    const codexAvailability = await codexAdapter.checkAvailability();
+    const useRealExecution = providerId.includes("codex") && codexAvailability.available;
+    if (!outputJson && globalOptions.verbose) {
+      if (useRealExecution) {
+        console.log(
+          ui.green(
+            `[oac] Using Codex CLI v${codexAvailability.version ?? "unknown"} for execution.`
+          )
+        );
+      } else {
+        console.log(ui.yellow("[oac] Codex CLI not available. Using simulated execution."));
+      }
+    }
+    const executionSpinner = createSpinner2(
+      outputJson,
+      `Executing ${plan.selectedTasks.length} planned task(s)...`
+    );
+    let completedCount = 0;
+    const executedTasks = await runWithConcurrency(
+      plan.selectedTasks,
+      concurrency,
+      async (entry) => {
+        let execution;
+        let sandbox;
+        if (useRealExecution) {
+          const result = await executeWithCodex({
+            task: entry.task,
+            estimate: entry.estimate,
+            codexAdapter,
+            repoPath: resolvedRepo.localPath,
+            baseBranch: resolvedRepo.meta.defaultBranch,
+            timeoutSeconds
+          });
+          execution = result.execution;
+          sandbox = result.sandbox;
+        } else {
+          execution = await simulateExecution(entry.task, entry.estimate);
+        }
+        completedCount += 1;
+        if (executionSpinner) {
+          executionSpinner.text = `Executing tasks... (${completedCount}/${plan.selectedTasks.length})`;
+        }
+        return {
+          task: entry.task,
+          estimate: entry.estimate,
+          execution,
+          sandbox
+        };
+      }
+    );
+    executionSpinner?.succeed("Execution stage finished");
+    const completionSpinner = createSpinner2(outputJson, "Completing task outputs...");
+    const completedTasks = await runWithConcurrency(
+      executedTasks,
+      concurrency,
+      async (result) => {
+        if (mode === "direct-commit") {
+          return result;
+        }
+        if (!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
+        });
+        if (!pr) {
+          return result;
+        }
+        return {
+          ...result,
+          pr
+        };
+      }
+    );
+    completionSpinner?.succeed("Completion stage finished");
+    const tasksCompleted = completedTasks.filter((task) => task.execution.success).length;
+    const tasksFailed = completedTasks.length - tasksCompleted;
+    const prsCreated = completedTasks.filter((task) => Boolean(task.pr)).length;
+    const tokensUsed = completedTasks.reduce(
+      (sum, task) => sum + task.execution.totalTokensUsed,
+      0
+    );
+    const runDurationSeconds = (Date.now() - runStartedAt) / 1e3;
+    const contributionLog = buildContributionLog({
+      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 = createSpinner2(outputJson, "Writing contribution log...");
+    let logPath;
+    try {
+      logPath = await writeContributionLog(contributionLog, resolvedRepo.localPath);
+      trackingSpinner?.succeed(`Contribution log written: ${logPath}`);
+    } catch (error) {
+      trackingSpinner?.fail("Failed to write contribution log");
+      if (globalOptions.verbose && !outputJson) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(ui.yellow(`[oac] Tracking failed: ${message}`));
+      }
+    }
+    const summary = {
+      runId,
+      repo: resolvedRepo.fullName,
+      provider: providerId,
+      dryRun: false,
+      selectedTasks: plan.selectedTasks.length,
+      deferredTasks: plan.deferredTasks.length,
+      tasksCompleted,
+      tasksFailed,
+      prsCreated,
+      tokensUsed,
+      tokensBudgeted: totalBudget,
+      logPath
+    };
+    if (outputJson) {
+      console.log(
+        JSON.stringify(
+          {
+            summary,
+            plan,
+            tasks: completedTasks
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    renderTaskResults(ui, completedTasks);
+    console.log("");
+    console.log(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:     ${formatInteger4(tokensUsed)} / ${formatBudgetDisplay(totalBudget)}`
+    );
+    console.log(`  Duration:        ${formatDuration(runDurationSeconds)}`);
+    if (logPath) {
+      console.log(`  Log:             ${logPath}`);
+    }
+  });
+  return command;
+}
+function getGlobalOptions6(command) {
+  const options = command.optsWithGlobals();
+  return {
+    config: options.config ?? "oac.config.ts",
+    verbose: options.verbose === true,
+    json: options.json === true,
+    color: options.color !== false
+  };
+}
+function createUi4(options) {
+  const noColorEnv = Object.prototype.hasOwnProperty.call(process.env, "NO_COLOR");
+  const colorEnabled = options.color && !noColorEnv;
+  return new Chalk4({ level: colorEnabled ? chalk4.level : 0 });
+}
+function createSpinner2(enabled, text) {
+  if (enabled) {
+    return null;
+  }
+  return ora2({ text, color: "blue" }).start();
+}
+function parseInteger4(value) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`Expected an integer but received "${value}".`);
+  }
+  return parsed;
+}
+function parseTokens(value) {
+  if (value.toLowerCase() === "unlimited") {
+    return UNLIMITED_BUDGET;
+  }
+  return parseInteger4(value);
+}
+function formatBudgetDisplay(budget) {
+  if (budget >= UNLIMITED_BUDGET) {
+    return "unlimited";
+  }
+  return formatInteger4(budget);
+}
+function validateRunOptions(options) {
+  if (typeof options.concurrency === "number" && options.concurrency <= 0) {
+    throw new Error("--concurrency must be greater than zero.");
+  }
+  if (typeof options.timeout === "number" && options.timeout <= 0) {
+    throw new Error("--timeout must be greater than zero.");
+  }
+  if (typeof options.maxTasks === "number" && options.maxTasks <= 0) {
+    throw new Error("--max-tasks must be greater than zero when provided.");
+  }
+}
+async function loadOptionalConfig2(configPath, verbose, ui) {
+  const absolutePath = resolve5(process.cwd(), configPath);
+  if (!await pathExists3(absolutePath)) {
+    return null;
+  }
+  try {
+    const imported = await import(`${pathToFileURL2(absolutePath).href}?t=${Date.now()}`);
+    const candidate = imported.default ?? imported.config ?? imported;
+    return loadConfig2(candidate);
+  } catch (error) {
+    if (verbose) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(ui.yellow(`[oac] Failed to load config at ${configPath}: ${message}`));
+    }
+    return null;
+  }
+}
+function resolveRepoInput2(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. Use --repo or configure repos in oac.config.ts.");
+}
+function resolveProviderId2(providerOption, config) {
+  const fromFlag = providerOption?.trim();
+  if (fromFlag) {
+    return fromFlag;
+  }
+  return config?.provider.id ?? "claude-code";
+}
+function resolveBudget2(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);
+}
+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 Error(`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 Error("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 Error("Timeout must be a positive integer.");
+  }
+  return Math.floor(configuredTimeout);
+}
+function selectScannersFromConfig2(config) {
+  const enabled = [];
+  if (config?.discovery.scanners.lint !== false) {
+    enabled.push("lint");
+  }
+  if (config?.discovery.scanners.todo !== false) {
+    enabled.push("todo");
+  }
+  if (process.env.GITHUB_TOKEN) {
+    enabled.push("github-issues");
+  }
+  if (enabled.length === 0) {
+    enabled.push("lint", "todo");
+  }
+  const uniqueEnabled = [...new Set(enabled)];
+  const scannerInstances = uniqueEnabled.map((scannerName) => {
+    if (scannerName === "lint") return new LintScanner2();
+    if (scannerName === "github-issues") return new GitHubIssuesScanner();
+    return new TodoScanner2();
+  });
+  return {
+    enabled: uniqueEnabled,
+    scanner: new CompositeScanner2(scannerInstances)
+  };
+}
+async function estimateTaskMap2(tasks, providerId) {
+  const entries = await Promise.all(
+    tasks.map(async (task) => {
+      const estimate = await estimateTokens2(task, providerId);
+      return [task.id, estimate];
+    })
+  );
+  return new Map(entries);
+}
+async function executeWithCodex(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 workerExecuteTask(input2.codexAdapter, 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 createPullRequest(input2) {
+  if (!input2.sandbox) {
+    return void 0;
+  }
+  const { branchName, sandboxPath } = input2.sandbox;
+  const [owner, repo] = input2.repoFullName.split("/");
+  try {
+    await execa("git", ["push", "--set-upstream", "origin", branchName], { cwd: sandboxPath });
+    const prTitle = `[OAC] ${input2.task.title}`;
+    const prBody = [
+      "## Summary",
+      "",
+      input2.task.description || `Automated contribution for task "${input2.task.title}".`,
+      "",
+      "## Context",
+      "",
+      `- **Task source:** ${input2.task.source}`,
+      `- **Complexity:** ${input2.task.complexity}`,
+      `- **Tokens used:** ${input2.execution.totalTokensUsed}`,
+      `- **Files changed:** ${input2.execution.filesChanged.length}`,
+      "",
+      "---",
+      "*This PR was automatically generated by [OAC](https://github.com/Open330/open-agent-contribution).*"
+    ].join("\n");
+    const ghResult = await execa(
+      "gh",
+      [
+        "pr",
+        "create",
+        "--repo",
+        input2.repoFullName,
+        "--title",
+        prTitle,
+        "--body",
+        prBody,
+        "--head",
+        branchName,
+        "--base",
+        input2.baseBranch
+      ],
+      { cwd: sandboxPath }
+    );
+    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;
+  }
+}
+async function simulateExecution(task, estimate) {
+  const start = Date.now();
+  const delayMs = Math.min(1500, Math.max(150, Math.round(estimate.totalEstimatedTokens / 40)));
+  await sleep(delayMs);
+  return {
+    success: true,
+    exitCode: 0,
+    totalTokensUsed: Math.max(1, Math.round(estimate.totalEstimatedTokens * 0.9)),
+    filesChanged: task.targetFiles.length > 0 ? task.targetFiles.slice(0, Math.min(task.targetFiles.length, 4)) : [],
+    duration: (Date.now() - start) / 1e3
+  };
+}
+async function commitSandboxChanges(sandboxPath, task) {
+  try {
+    const statusResult = await execa("git", ["status", "--porcelain"], { cwd: sandboxPath });
+    if (!statusResult.stdout.trim()) {
+      return { hasChanges: false, filesChanged: [] };
+    }
+    await execa("git", ["add", "-A"], { cwd: sandboxPath });
+    await execa(
+      "git",
+      ["commit", "-m", `[OAC] ${task.title}
+
+Automated contribution by OAC using Codex CLI.`],
+      { cwd: sandboxPath }
+    );
+    const diffResult = await execa("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: [] };
+  }
+}
+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;
+}
+function renderSelectedPlanTable(ui, plan, budget) {
+  const table = new Table4({
+    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),
+      truncate2(entry.task.title, 56),
+      formatInteger4(entry.estimate.totalEstimatedTokens),
+      formatInteger4(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: ${formatInteger4(
+      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(
+        `  - ${truncate2(deferred.task.title, 72)} (${formatInteger4(
+          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 ${formatInteger4(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}`);
+    }
+  }
+}
+async function runWithConcurrency(items, concurrency, worker) {
+  if (items.length === 0) {
+    return [];
+  }
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  const runWorker = async () => {
+    while (true) {
+      const currentIndex = nextIndex;
+      nextIndex += 1;
+      if (currentIndex >= items.length) {
+        return;
+      }
+      results[currentIndex] = await worker(items[currentIndex], currentIndex);
+    }
+  };
+  const workerCount = Math.min(concurrency, items.length);
+  await Promise.all(Array.from({ length: workerCount }, () => runWorker()));
+  return results;
+}
+function sleep(ms) {
+  return new Promise((resolvePromise) => {
+    setTimeout(resolvePromise, ms);
+  });
+}
+function formatInteger4(value) {
+  return new Intl.NumberFormat("en-US").format(value);
+}
+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`;
+}
+function truncate2(value, maxLength) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+async function pathExists3(path) {
+  try {
+    await access3(path, fsConstants3.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/scan.ts
+import { constants as fsConstants4 } from "fs";
+import { access as access4 } from "fs/promises";
+import { resolve as resolve6 } from "path";
+import { pathToFileURL as pathToFileURL3 } from "url";
+import { loadConfig as loadConfig3 } from "@open330/oac-core";
+import {
+  CompositeScanner as CompositeScanner3,
+  LintScanner as LintScanner3,
+  TodoScanner as TodoScanner3,
+  rankTasks as rankTasks3
+} from "@open330/oac-discovery";
+import { cloneRepo as cloneRepo3, resolveRepo as resolveRepo3 } from "@open330/oac-repo";
+import chalk5, { Chalk as Chalk5 } from "chalk";
+import Table5 from "cli-table3";
+import { Command as Command7 } from "commander";
+import ora3 from "ora";
+var SUPPORTED_SCANNERS = ["lint", "todo"];
+function createScanCommand() {
+  const command = new Command7("scan");
+  command.description("Discover tasks in a repository").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)", parseInteger5, 20).option("--format <format>", "Output format: table|json", "table").action(async (options, cmd) => {
+    const globalOptions = getGlobalOptions7(cmd);
+    const ui = createUi5(globalOptions);
+    const outputFormat = normalizeOutputFormat(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 loadOptionalConfig3(globalOptions.config, globalOptions.verbose, ui);
+    const repoInput = resolveRepoInput3(options.repo, config);
+    const scannerSelection = selectScanners(options.scanners, config);
+    if (!outputJson && scannerSelection.unknown.length > 0) {
+      console.log(
+        ui.yellow(
+          `Ignoring unsupported scanner(s): ${scannerSelection.unknown.join(", ")}. Supported scanners: ${SUPPORTED_SCANNERS.join(", ")}.`
+        )
+      );
+    }
+    const resolveSpinner = createSpinner3(outputJson, "Resolving repository...");
+    const resolvedRepo = await resolveRepo3(repoInput);
+    resolveSpinner?.succeed(`Resolved ${resolvedRepo.fullName}`);
+    const cloneSpinner = createSpinner3(outputJson, "Preparing local clone...");
+    await cloneRepo3(resolvedRepo);
+    cloneSpinner?.succeed(`Repository ready at ${resolvedRepo.localPath}`);
+    const scanSpinner = createSpinner3(
+      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 = rankTasks3(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 Table5({
+      head: ["ID", "Title", "Source", "Priority", "Complexity"]
+    });
+    for (const task of rankedTasks) {
+      table.push([
+        task.id,
+        truncate3(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.`
+      )
+    );
+  });
+  return command;
+}
+function getGlobalOptions7(command) {
+  const options = command.optsWithGlobals();
+  return {
+    config: options.config ?? "oac.config.ts",
+    verbose: options.verbose === true,
+    json: options.json === true,
+    color: options.color !== false
+  };
+}
+function createUi5(options) {
+  const noColorEnv = Object.prototype.hasOwnProperty.call(process.env, "NO_COLOR");
+  const colorEnabled = options.color && !noColorEnv;
+  return new Chalk5({ level: colorEnabled ? chalk5.level : 0 });
+}
+function createSpinner3(enabled, text) {
+  if (enabled) {
+    return null;
+  }
+  return ora3({ text, color: "blue" }).start();
+}
+function parseInteger5(value) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`Expected an integer but received "${value}".`);
+  }
+  return parsed;
+}
+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".`);
+}
+async function loadOptionalConfig3(configPath, verbose, ui) {
+  const absolutePath = resolve6(process.cwd(), configPath);
+  if (!await pathExists4(absolutePath)) {
+    return null;
+  }
+  try {
+    const imported = await import(`${pathToFileURL3(absolutePath).href}?t=${Date.now()}`);
+    const candidate = imported.default ?? imported.config ?? imported;
+    return loadConfig3(candidate);
+  } catch (error) {
+    if (verbose) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(ui.yellow(`[oac] Failed to load config at ${configPath}: ${message}`));
+    }
+    return null;
+  }
+}
+function resolveRepoInput3(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. Use --repo or configure repos in oac.config.ts.");
+}
+function selectScanners(scannerOption, config) {
+  const requested = scannerOption ? parseCsv(scannerOption) : scannersFromConfig(config) ?? [...SUPPORTED_SCANNERS];
+  const enabled = [];
+  const unknown = [];
+  for (const scannerName of requested) {
+    const normalized = scannerName.toLowerCase();
+    if (normalized === "lint" || normalized === "todo") {
+      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) => name === "lint" ? new LintScanner3() : new TodoScanner3()
+  );
+  return {
+    enabled: uniqueEnabled,
+    unknown,
+    scanner: new CompositeScanner3(scannerInstances)
+  };
+}
+function scannersFromConfig(config) {
+  if (!config) {
+    return null;
+  }
+  const configured = [];
+  if (config.discovery.scanners.lint) {
+    configured.push("lint");
+  }
+  if (config.discovery.scanners.todo) {
+    configured.push("todo");
+  }
+  if (configured.length === 0) {
+    return null;
+  }
+  return configured;
+}
+function parseCsv(value) {
+  return value.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+}
+function truncate3(value, maxLength) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+async function pathExists4(path) {
+  try {
+    await access4(path, fsConstants4.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/status.ts
+import { readFile as readFile3 } from "fs/promises";
+import { resolve as resolve7 } from "path";
+import { Command as Command8 } from "commander";
+var WATCH_INTERVAL_MS = 2e3;
+function createStatusCommand() {
+  const command = new Command8("status");
+  command.description("Show current job status").option("--watch", "Poll every 2 seconds", false).action(async (options, cmd) => {
+    const globalOptions = getGlobalOptions8(cmd);
+    const render = async () => {
+      const status = await readRunStatus(process.cwd());
+      renderStatusOutput(status, globalOptions.json);
+    };
+    await render();
+    if (!options.watch) {
+      return;
+    }
+    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);
+  });
+  return command;
+}
+function getGlobalOptions8(command) {
+  const options = command.optsWithGlobals();
+  return {
+    config: options.config ?? "oac.config.ts",
+    verbose: options.verbose === true,
+    json: options.json === true,
+    color: options.color !== false
+  };
+}
+async function readRunStatus(repoPath) {
+  const statusPath = resolve7(repoPath, ".oac", "status.json");
+  try {
+    const raw = await readFile3(statusPath, "utf8");
+    const payload = JSON.parse(raw);
+    return parseRunStatus(payload);
+  } catch (error) {
+    if (isFileNotFoundError3(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+function parseRunStatus(payload) {
+  if (!isRecord2(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 (!isRecord2(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 isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function isFileNotFoundError3(error) {
+  if (!isRecord2(error)) {
+    return false;
+  }
+  return error.code === "ENOENT";
+}
+
+// src/cli.ts
+async function readCliVersion() {
+  try {
+    const packageJsonPath = new URL("../package.json", import.meta.url);
+    const packageJsonRaw = await readFile4(packageJsonPath, "utf8");
+    const packageJson = JSON.parse(packageJsonRaw);
+    if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
+      return packageJson.version;
+    }
+  } catch {
+  }
+  return "0.0.0";
+}
+function registerCommands(program) {
+  program.addCommand(createInitCommand());
+  program.addCommand(createDoctorCommand());
+  program.addCommand(createScanCommand());
+  program.addCommand(createPlanCommand());
+  program.addCommand(createRunCommand());
+  program.addCommand(createLogCommand());
+  program.addCommand(createLeaderboardCommand());
+  program.addCommand(createStatusCommand());
+}
+async function createCliProgram() {
+  const version = await readCliVersion();
+  const program = new Command9();
+  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("--json", "Output machine-readable JSON", false).option("--no-color", "Disable ANSI colors");
+  registerCommands(program);
+  return program;
+}
+async function runCli(argv = process.argv) {
+  const program = await createCliProgram();
+  await program.parseAsync([...argv]);
+}
+
+export {
+  createCliProgram,
+  runCli
+};
+//# sourceMappingURL=chunk-UVK4T7KV.js.map