@matthugh1/conductor-cli 0.1.0

package/dist/agent.js

@@ -0,0 +1,717 @@
+#!/usr/bin/env node
+import {
+  ensureDatabaseUrl,
+  postToServer
+} from "./chunk-MJKFQIYA.js";
+
+// ../../src/cli/agent.ts
+import { resolve } from "path";
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  let projectRoot = process.cwd();
+  let project;
+  let json = false;
+  let help = false;
+  let once = false;
+  let maxDeliverables;
+  let timeout = 120;
+  let consecutiveFailures = 3;
+  let skipPermissions = false;
+  let dryRun = false;
+  let command;
+  let subcommand;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--project-root" && i + 1 < args.length) {
+      projectRoot = resolve(args[++i]);
+    } else if (arg === "--project" && i + 1 < args.length) {
+      project = args[++i];
+    } else if ((arg === "--max-deliverables" || arg === "--max-tasks") && i + 1 < args.length) {
+      maxDeliverables = Number.parseInt(args[++i], 10);
+    } else if (arg === "--timeout" && i + 1 < args.length) {
+      timeout = Number.parseInt(args[++i], 10);
+    } else if (arg === "--consecutive-failures" && i + 1 < args.length) {
+      consecutiveFailures = Number.parseInt(args[++i], 10);
+    } else if (arg === "--skip-permissions") {
+      skipPermissions = true;
+    } else if (arg === "--dry-run") {
+      dryRun = true;
+    } else if (arg === "--json") {
+      json = true;
+    } else if (arg === "--help" || arg === "-h") {
+      help = true;
+    } else if (arg === "--once") {
+      once = true;
+    } else if (!arg.startsWith("-") && command === void 0) {
+      command = arg;
+    } else if (!arg.startsWith("-") && subcommand === void 0) {
+      subcommand = arg;
+    }
+  }
+  return { command, subcommand, projectRoot, project, json, help, once, maxDeliverables, timeout, consecutiveFailures, skipPermissions, dryRun };
+}
+var HELP_TEXT = `
+Conductor \u2014 local agent CLI
+
+Usage: conductor <command> [options]
+
+Commands:
+  check       Run health checks on the local environment
+  scan        Detect worktrees on disk and sync with database
+  init        Initialize a project for Conductor
+  hooks       Check hook status or install hooks
+  watch       Poll for cleanup tasks and execute them locally
+  run         Autonomous runner \u2014 work through deliverable queue
+
+Options:
+  --project-root <path>         Project directory (default: cwd)
+  --project <name>              Project name (for run command)
+  --json                        Output as JSON instead of plain English
+  --once                        Process one task and exit (watch only)
+  --help                        Show this help text
+
+Run options:
+  --max-deliverables <n>        Max deliverables per run (default: 10)
+  --timeout <minutes>           Max minutes per deliverable (default: 120)
+  --consecutive-failures <n>    Stop after N failures in a row (default: 3)
+  --skip-permissions            Allow Claude to write files without prompting
+  --dry-run                     Show queue without spawning agents
+
+Examples:
+  conductor check
+  conductor init --project-root /path/to/project
+  conductor hooks install
+  conductor scan --json
+  conductor watch
+  conductor run --project Conductor --skip-permissions
+  conductor run --project Conductor --dry-run
+`.trim();
+function writeOut(text) {
+  process.stdout.write(text + "\n");
+}
+function writeErr(text) {
+  process.stderr.write(text + "\n");
+}
+async function cmdCheck(projectRoot, jsonOutput) {
+  const { query: dbQuery } = await import("./db-U6Y3QJDD.js");
+  const projects = await dbQuery(
+    "SELECT id FROM projects WHERE path = $1 LIMIT 1",
+    [projectRoot]
+  );
+  if (projects.length === 0) {
+    if (jsonOutput) {
+      writeOut(
+        JSON.stringify({
+          error: "Project not registered",
+          fix: "Run: conductor init"
+        })
+      );
+    } else {
+      writeErr(
+        "Project is not registered in Conductor. Run: conductor init"
+      );
+    }
+    return 1;
+  }
+  const { getEnvironmentHealthReport } = await import("./health-CTND2ANA.js");
+  const report = await getEnvironmentHealthReport(projects[0].id);
+  if (jsonOutput) {
+    writeOut(JSON.stringify(report, null, 2));
+  } else {
+    writeOut("Environment Health");
+    writeOut("\u2500".repeat(40));
+    for (const check of report.checks) {
+      const icon = check.status === "pass" ? "\u2713" : check.status === "warn" ? "\u26A0" : "\u2717";
+      writeOut(`${icon} ${check.name.padEnd(14)} ${check.message}`);
+    }
+  }
+  try {
+    const { saveHealthSnapshot } = await import("./health-snapshots-6MUVHE3G.js");
+    await saveHealthSnapshot(projects[0].id, report);
+  } catch {
+    const posted = await postToServer("/api/environment/health", { report }, projectRoot);
+    if (!posted && !jsonOutput) {
+      writeErr("\u26A0 Could not sync results to the dashboard.");
+    }
+  }
+  try {
+    const { getGitBranchInfo, formatGitBranchLine, getStatusSummary, getRecentCommits } = await import("./git-wrapper-DVJ46TMA.js");
+    const { getHookStatus } = await import("./git-hooks-UZJ6AER4.js");
+    const { saveGitStatusSnapshot } = await import("./git-snapshots-N3FBS7T3.js");
+    const branchInfo = await getGitBranchInfo(projectRoot);
+    const branchLine = formatGitBranchLine(branchInfo);
+    const status = await getStatusSummary(projectRoot);
+    let recentCommits = [];
+    try {
+      recentCommits = await getRecentCommits(projectRoot);
+    } catch {
+    }
+    let hookStatus = null;
+    try {
+      hookStatus = await getHookStatus(projectRoot);
+    } catch {
+    }
+    const worktreeRows = await dbQuery(
+      "SELECT branch_name, worktree_path FROM worktrees WHERE project_id = $1 AND status = 'active'",
+      [projects[0].id]
+    );
+    const worktreeCommits = {};
+    const { runGit } = await import("./git-wrapper-DVJ46TMA.js");
+    for (const wt of worktreeRows) {
+      try {
+        const out = await runGit(wt.worktree_path, ["log", "-1", "--format=%cI"]);
+        const date = out.trim();
+        if (date) worktreeCommits[wt.branch_name] = date;
+      } catch {
+      }
+    }
+    await saveGitStatusSnapshot(projects[0].id, {
+      branch: branchInfo.branchName,
+      branchLine,
+      status,
+      recentCommits,
+      hookStatus,
+      worktreeCommits
+    });
+    if (!jsonOutput) {
+      writeOut("");
+      writeOut("Git Status");
+      writeOut("\u2500".repeat(40));
+      writeOut(`Branch: ${branchLine}`);
+      writeOut(`Status: ${status}`);
+    }
+  } catch (err) {
+    if (!jsonOutput) {
+      const msg = err instanceof Error ? err.message : "unknown error";
+      writeErr(`\u26A0 Git status snapshot failed: ${msg}`);
+    }
+  }
+  try {
+    const { getGitBranchInfo } = await import("./git-wrapper-DVJ46TMA.js");
+    const { getBranchOverview } = await import("./branch-overview-XVHTGFCJ.js");
+    const { saveBranchOverviewSnapshot } = await import("./git-snapshots-N3FBS7T3.js");
+    const branchInfo = await getGitBranchInfo(projectRoot);
+    let currentBranch = branchInfo.branchName;
+    if (currentBranch?.startsWith("detached (")) currentBranch = null;
+    const overview = await getBranchOverview(projectRoot, {
+      projectId: projects[0].id,
+      currentBranch
+    });
+    await saveBranchOverviewSnapshot(projects[0].id, overview);
+    if (!jsonOutput) {
+      writeOut(`Branches: ${overview.branches.length} found`);
+    }
+  } catch (err) {
+    if (!jsonOutput) {
+      const msg = err instanceof Error ? err.message : "unknown error";
+      writeErr(`\u26A0 Branch overview snapshot failed: ${msg}`);
+    }
+  }
+  const hasFail = report.checks.some((c) => c.status === "fail");
+  const hasWarn = report.checks.some((c) => c.status === "warn");
+  if (hasFail) return 1;
+  if (hasWarn) return 2;
+  return 0;
+}
+async function cmdScan(projectRoot, jsonOutput) {
+  const { scanWorktrees } = await import("./worktree-manager-QKRBTPVC.js");
+  const { query: dbQuery } = await import("./db-U6Y3QJDD.js");
+  const projects = await dbQuery(
+    "SELECT id FROM projects WHERE path = $1 LIMIT 1",
+    [projectRoot]
+  );
+  if (projects.length === 0) {
+    if (jsonOutput) {
+      writeOut(
+        JSON.stringify({
+          error: "Project not registered",
+          fix: "Run: conductor init"
+        })
+      );
+    } else {
+      writeErr(
+        "Project is not registered in Conductor. Run: conductor init"
+      );
+    }
+    return 1;
+  }
+  const projectId = projects[0].id;
+  const result = await scanWorktrees(projectId, projectRoot);
+  if (jsonOutput) {
+    writeOut(JSON.stringify(result, null, 2));
+  } else {
+    writeOut(
+      `Scan complete: ${result.newlyDetected} registered, ${result.registered} existing, ${result.removedFromDisk} removed from disk`
+    );
+    if (result.worktrees.length === 0) {
+      writeOut("No worktrees found.");
+    } else {
+      writeOut("");
+      for (const wt of result.worktrees) {
+        const initiative = wt.initiativeTitle ?? "no initiative";
+        const tag = wt.newlyRegistered ? " [new]" : wt.removedFromDisk ? " [removed from disk]" : "";
+        const commit = wt.lastCommitAt ? `  last commit: ${wt.lastCommitAt.slice(0, 10)}` : "";
+        writeOut(
+          `  ${wt.branchName}  (${initiative})  [${wt.status}]${tag}${commit}`
+        );
+      }
+    }
+  }
+  return 0;
+}
+async function cmdInit(projectRoot, jsonOutput) {
+  const { resolve: resolvePath, basename, join } = await import("path");
+  const { realpath, mkdir, readFile, writeFile, access } = await import("fs/promises");
+  const { getServerBaseUrl } = await import("./cli-config-TDSTAXIA.js");
+  let root = resolvePath(projectRoot.trim());
+  try {
+    root = await realpath(root);
+  } catch {
+  }
+  try {
+    await access(root);
+  } catch {
+    writeErr(`That folder doesn't seem to exist: ${root}`);
+    return 1;
+  }
+  const created = [];
+  const conductorDir = join(root, ".conductor");
+  let alreadyExisted = false;
+  try {
+    await access(conductorDir);
+    alreadyExisted = true;
+  } catch {
+    await mkdir(conductorDir, { recursive: true });
+    created.push("Created .conductor/ folder");
+  }
+  const gitignorePath = join(root, ".gitignore");
+  let gitignoreContent = "";
+  try {
+    gitignoreContent = await readFile(gitignorePath, "utf8");
+  } catch {
+  }
+  const hasConductorEntry = gitignoreContent.split("\n").some((l) => l.trim() === ".conductor/" || l.trim() === ".conductor");
+  if (!hasConductorEntry) {
+    const sep = gitignoreContent.length > 0 && !gitignoreContent.endsWith("\n") ? "\n" : "";
+    const pre = gitignoreContent.length > 0 ? "\n" : "";
+    await writeFile(gitignorePath, `${gitignoreContent}${sep}${pre}# Conductor session data
+.conductor/
+`, "utf8");
+    created.push("Added .conductor/ to .gitignore");
+  }
+  let registeredRemotely = false;
+  let registrationError = null;
+  try {
+    const baseUrl = getServerBaseUrl();
+    const resp = await fetch(`${baseUrl}/projects/register`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: basename(root), localPath: root }),
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (resp.ok) {
+      registeredRemotely = true;
+      created.push("Registered with Conductor server");
+    } else {
+      const errBody = await resp.json().catch(() => ({}));
+      registrationError = errBody.error ?? `Server returned ${resp.status}`;
+    }
+  } catch {
+    registrationError = "Could not reach the Conductor server. Local setup still succeeded.";
+  }
+  if (created.length === 0) created.push("Everything was already set up");
+  const result = { success: true, projectRoot: root, created, alreadyExisted, registeredRemotely, registrationError };
+  if (jsonOutput) {
+    writeOut(JSON.stringify(result, null, 2));
+  } else {
+    if (alreadyExisted && !registeredRemotely && !registrationError) {
+      writeOut("Already initialized \u2014 no changes needed.");
+    } else {
+      writeOut("Project initialized.");
+      writeOut(`  ${created.join(", ")}`);
+    }
+    if (registrationError) {
+      writeOut(`  \u26A0 ${registrationError}`);
+    }
+  }
+  return 0;
+}
+async function cmdHooks(projectRoot, subcommand, jsonOutput) {
+  const { getHookStatus, installHooks } = await import("./git-hooks-UZJ6AER4.js");
+  if (subcommand === "install") {
+    const result = await installHooks(projectRoot);
+    if (jsonOutput) {
+      writeOut(JSON.stringify(result, null, 2));
+    } else {
+      if (result.installed.length > 0) {
+        writeOut(`Hooks installed: ${result.installed.join(", ")}`);
+      }
+      if (result.skipped.length > 0) {
+        writeOut(
+          `Skipped (custom hooks exist): ${result.skipped.join(", ")}`
+        );
+      }
+      if (result.installed.length === 0 && result.skipped.length === 0) {
+        writeOut("No hooks to install.");
+      }
+    }
+    return 0;
+  }
+  const status = await getHookStatus(projectRoot);
+  const presentCount = status.hooks.filter((h) => h.present).length;
+  const totalCount = status.hooks.length;
+  if (jsonOutput) {
+    writeOut(JSON.stringify(status, null, 2));
+  } else {
+    if (status.installed && !status.outdated) {
+      writeOut(`\u2713 Hooks installed (${presentCount}/${totalCount})`);
+    } else if (status.outdated) {
+      writeOut(
+        `\u26A0 Hooks outdated (${presentCount}/${totalCount}) \u2014 run: conductor hooks install`
+      );
+    } else {
+      writeOut(
+        "\u2717 Hooks not installed \u2014 run: conductor hooks install"
+      );
+    }
+  }
+  if (status.installed && !status.outdated) return 0;
+  return 2;
+}
+async function cmdWatch(projectRoot, once, jsonOutput) {
+  const { claimNextTask, executeTask, failStaleTasks } = await import("./cli-tasks-NW3BONXC.js");
+  const { query: dbQuery } = await import("./db-U6Y3QJDD.js");
+  const projects = await dbQuery(
+    "SELECT id FROM projects WHERE path = $1 LIMIT 1",
+    [projectRoot]
+  );
+  if (projects.length === 0) {
+    if (jsonOutput) {
+      writeOut(
+        JSON.stringify({
+          error: "Project not registered",
+          fix: "Run: conductor init"
+        })
+      );
+    } else {
+      writeErr(
+        "Project is not registered in Conductor. Run: conductor init"
+      );
+    }
+    return 1;
+  }
+  const projectId = projects[0].id;
+  const staleCount = await failStaleTasks(projectId);
+  if (staleCount > 0 && !jsonOutput) {
+    writeOut(`Auto-failed ${staleCount} stale task(s).`);
+  }
+  if (once) {
+    const task = await claimNextTask(projectId);
+    if (!task) {
+      if (jsonOutput) {
+        writeOut(JSON.stringify({ message: "No pending tasks." }));
+      } else {
+        writeOut("No pending tasks.");
+      }
+      return 0;
+    }
+    const summary = await executeTask(task);
+    if (jsonOutput) {
+      writeOut(JSON.stringify({ taskId: task.id, taskType: task.taskType, summary }));
+    } else {
+      writeOut(`[${task.taskType}] ${summary}`);
+    }
+    return 0;
+  }
+  if (!jsonOutput) {
+    writeOut("Watching for tasks... (Ctrl+C to stop)");
+  }
+  let running = true;
+  const shutdown = () => {
+    if (!jsonOutput) {
+      writeOut("\nShutting down gracefully...");
+    }
+    running = false;
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  while (running) {
+    try {
+      const task = await claimNextTask(projectId);
+      if (task) {
+        const summary = await executeTask(task);
+        if (jsonOutput) {
+          writeOut(
+            JSON.stringify({ taskId: task.id, taskType: task.taskType, summary })
+          );
+        } else {
+          writeOut(`[${task.taskType}] ${summary}`);
+        }
+      }
+      await failStaleTasks(projectId);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (!jsonOutput) {
+        writeErr(`Poll error: ${msg}`);
+      }
+    }
+    for (let i = 0; i < 5 && running; i++) {
+      await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+    }
+  }
+  return 0;
+}
+async function cmdRun(opts) {
+  const { spawn } = await import("child_process");
+  const { readFileSync, existsSync } = await import("fs");
+  const { assembleAutonomousPrompt } = await import("./runner-prompt-2B6EXGN6.js");
+  const { computeWorkQueue } = await import("./work-queue-YE5P4S7R.js");
+  const { query: dbQuery } = await import("./db-U6Y3QJDD.js");
+  let project = opts.projectName ?? opts.projectRoot;
+  if (opts.projectName) {
+    const rows = await dbQuery(
+      "SELECT path FROM projects WHERE name = $1 LIMIT 1",
+      [opts.projectName]
+    );
+    if (rows.length === 0) {
+      writeErr(`Project "${opts.projectName}" not found in Conductor.`);
+      return 1;
+    }
+    if (rows[0].path === null) {
+      writeErr(`Project "${opts.projectName}" has no local path registered.`);
+      return 1;
+    }
+    project = rows[0].path;
+  }
+  function ts() {
+    return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+  }
+  function log(msg) {
+    writeOut(`[${ts()}] ${msg}`);
+  }
+  function readClaudeMd(root) {
+    for (const p of [resolve(root, "CLAUDE.md"), resolve(root, ".claude", "CLAUDE.md")]) {
+      if (existsSync(p)) return readFileSync(p, "utf8");
+    }
+    return "";
+  }
+  function spawnAgent(prompt, timeoutMs) {
+    return new Promise((res) => {
+      let timedOut = false;
+      const args = [];
+      if (opts.skipPermissions) args.push("--dangerously-skip-permissions");
+      args.push("-p", prompt);
+      const child = spawn("claude", args, {
+        stdio: ["ignore", "inherit", "inherit"],
+        env: { ...process.env }
+      });
+      const timer = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGTERM");
+        setTimeout(() => {
+          if (!child.killed) child.kill("SIGKILL");
+        }, 1e4);
+      }, timeoutMs);
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        res({ exitCode: code, timedOut });
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        writeErr(`[${ts()}] ERROR: Failed to spawn agent: ${err.message}`);
+        res({ exitCode: 1, timedOut: false });
+      });
+    });
+  }
+  async function getNextItem(skipIds) {
+    const queue = await computeWorkQueue(project, 50, { autonomous: true });
+    for (const item of queue.queue) {
+      if (item.type === "deliverable" && (item.tier === "ready" || item.tier === "active") && !skipIds.has(item.entityId)) {
+        return item;
+      }
+    }
+    return null;
+  }
+  log(`Starting runner for project: ${project}`);
+  if (opts.skipPermissions) log("Permissions: --dangerously-skip-permissions will be passed to Claude");
+  const claudeMd = readClaudeMd(project);
+  if (claudeMd.length > 0) log("Loaded CLAUDE.md project rules");
+  const results = [];
+  const attemptedIds = /* @__PURE__ */ new Set();
+  const maxTasks = opts.maxDeliverables ?? 10;
+  let totalIterations = 0;
+  let consecutiveFailures = 0;
+  for (let taskNum = 0; taskNum < maxTasks; taskNum++) {
+    if (consecutiveFailures >= opts.consecutiveFailures) {
+      log(`Stopping: ${consecutiveFailures} consecutive failures reached limit.`);
+      break;
+    }
+    let item;
+    try {
+      item = await getNextItem(attemptedIds);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      writeErr(`[${ts()}] ERROR: Failed to fetch work queue: ${msg}`);
+      consecutiveFailures++;
+      totalIterations++;
+      results.push({ title: "Queue fetch", outcome: "error", durationMs: 0, exitCode: null, errorMessage: msg });
+      continue;
+    }
+    if (item === null) {
+      log("Queue empty \u2014 no autonomous deliverables remaining.");
+      break;
+    }
+    attemptedIds.add(item.entityId);
+    log(`Working on: "${item.title}" (P${item.priority})${item.initiativeTitle ? ` [${item.initiativeTitle}]` : ""}`);
+    if (opts.dryRun) {
+      log(`  [dry-run] Would spawn agent for deliverable ${item.entityId}`);
+      results.push({ title: item.title, outcome: "completed", durationMs: 0, exitCode: 0 });
+      totalIterations++;
+      continue;
+    }
+    let prompt;
+    try {
+      prompt = assembleAutonomousPrompt({ claudeMd, item, projectName: project });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      writeErr(`[${ts()}] ERROR: Prompt assembly failed for "${item.title}": ${msg}`);
+      consecutiveFailures++;
+      totalIterations++;
+      results.push({ title: item.title, outcome: "error", durationMs: 0, exitCode: null, errorMessage: `Prompt: ${msg}` });
+      continue;
+    }
+    const timeoutMs = opts.timeout * 6e4;
+    const startTime = Date.now();
+    let exitCode;
+    let timedOut;
+    try {
+      const r = await spawnAgent(prompt, timeoutMs);
+      exitCode = r.exitCode;
+      timedOut = r.timedOut;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      writeErr(`[${ts()}] ERROR: Agent spawn crashed for "${item.title}": ${msg}`);
+      consecutiveFailures++;
+      totalIterations++;
+      results.push({ title: item.title, outcome: "error", durationMs: Date.now() - startTime, exitCode: null, errorMessage: msg });
+      log("  Branch left intact for inspection.");
+      continue;
+    }
+    const durationMs = Date.now() - startTime;
+    const durationMin = Math.round(durationMs / 6e4);
+    totalIterations++;
+    if (timedOut) {
+      log(`Timed out after ${durationMin}m \u2014 "${item.title}". Branch left intact.`);
+      consecutiveFailures++;
+      results.push({ title: item.title, outcome: "timeout", durationMs, exitCode, errorMessage: `Timed out after ${durationMin}m` });
+    } else if (exitCode === 0) {
+      log(`Completed in ${durationMin}m \u2014 "${item.title}"`);
+      consecutiveFailures = 0;
+      results.push({ title: item.title, outcome: "completed", durationMs, exitCode });
+    } else {
+      log(`Failed (exit ${exitCode}) after ${durationMin}m \u2014 "${item.title}". Branch left intact.`);
+      consecutiveFailures++;
+      results.push({ title: item.title, outcome: "failed", durationMs, exitCode, errorMessage: `Exit code ${exitCode}` });
+    }
+  }
+  log("");
+  log("\u2550\u2550\u2550 Runner Summary \u2550\u2550\u2550");
+  log(`Deliverables attempted: ${results.length}`);
+  const cCount = results.filter((r) => r.outcome === "completed").length;
+  const fCount = results.filter((r) => r.outcome === "failed" || r.outcome === "error").length;
+  const tCount = results.filter((r) => r.outcome === "timeout").length;
+  if (cCount > 0) log(`  Completed: ${cCount}`);
+  if (fCount > 0) log(`  Failed: ${fCount}`);
+  if (tCount > 0) log(`  Timed out: ${tCount}`);
+  if (consecutiveFailures >= opts.consecutiveFailures) {
+    log(`  Stopped early: ${consecutiveFailures} consecutive failures.`);
+  }
+  const totalMin = Math.round(results.reduce((s, r) => s + r.durationMs, 0) / 6e4);
+  log(`Total time: ${totalMin}m`);
+  log(`Total iterations: ${totalIterations}`);
+  for (const r of results) {
+    const min = Math.round(r.durationMs / 6e4);
+    const icon = r.outcome === "completed" ? "OK" : r.outcome === "timeout" ? "TIMEOUT" : r.outcome === "error" ? "ERROR" : "FAIL";
+    const detail = r.errorMessage ? ` \u2014 ${r.errorMessage}` : "";
+    log(`  [${icon}] ${r.title} (${min}m)${detail}`);
+  }
+  if (opts.jsonOutput) {
+    writeOut(JSON.stringify({ attempted: results.length, completed: cCount, failed: fCount, timedOut: tCount, results }, null, 2));
+  }
+  return fCount > 0 ? 1 : 0;
+}
+async function main() {
+  const parsed = parseArgs(process.argv);
+  if (parsed.help || parsed.command === void 0) {
+    writeOut(HELP_TEXT);
+    process.exit(parsed.help ? 0 : 1);
+  }
+  const hasDb = await ensureDatabaseUrl();
+  if (!hasDb) {
+    writeErr(
+      "Could not find a database connection. Make sure the MCP server is running (npm run mcp) and try again."
+    );
+    process.exit(1);
+  }
+  try {
+    let exitCode;
+    switch (parsed.command) {
+      case "check":
+        exitCode = await cmdCheck(parsed.projectRoot, parsed.json);
+        break;
+      case "scan":
+        exitCode = await cmdScan(parsed.projectRoot, parsed.json);
+        break;
+      case "init":
+        exitCode = await cmdInit(parsed.projectRoot, parsed.json);
+        break;
+      case "hooks":
+        exitCode = await cmdHooks(
+          parsed.projectRoot,
+          parsed.subcommand,
+          parsed.json
+        );
+        break;
+      case "watch":
+        exitCode = await cmdWatch(
+          parsed.projectRoot,
+          parsed.once,
+          parsed.json
+        );
+        break;
+      case "run":
+        exitCode = await cmdRun({
+          projectRoot: parsed.projectRoot,
+          projectName: parsed.project,
+          maxDeliverables: parsed.maxDeliverables,
+          timeout: parsed.timeout,
+          consecutiveFailures: parsed.consecutiveFailures,
+          skipPermissions: parsed.skipPermissions,
+          dryRun: parsed.dryRun,
+          jsonOutput: parsed.json
+        });
+        break;
+      default:
+        writeErr(`Unknown command: ${parsed.command}`);
+        writeErr("Run conductor --help for usage.");
+        exitCode = 1;
+    }
+    process.exit(exitCode);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (parsed.json) {
+      writeOut(JSON.stringify({ error: message }, null, 2));
+    } else {
+      writeErr(`Error: ${message}`);
+      if (message.includes("ECONNREFUSED") || message.includes("Could not reach")) {
+        writeErr("Fix: Make sure the MCP server is running (npm run mcp) or set DATABASE_URL");
+      } else if (message.includes("not a git repository")) {
+        writeErr("Fix: Run this from inside a git repository");
+      } else if (message.includes("Git is not installed")) {
+        writeErr("Fix: Install git \u2014 https://git-scm.com/downloads");
+      }
+    }
+    process.exit(1);
+  }
+}
+main();