@eugene218/noxdev 1.0.0

package/dist/index.js

@@ -0,0 +1,2380 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { createRequire } from "module";
+import { Command } from "commander";
+import chalk12 from "chalk";
+
+// src/brand.ts
+var BANNER = (version2) => `    ,___,
+    [O.O]         noxdev v${version2}
+   /)   )\\        ship code while you sleep
+   " \\|/ "
+  ---m-m---`;
+
+// src/commands/init.ts
+import { execSync } from "child_process";
+import {
+  existsSync,
+  readFileSync,
+  mkdirSync as mkdirSync2,
+  writeFileSync
+} from "fs";
+import { join as join2, resolve } from "path";
+import { homedir as homedir2 } from "os";
+import chalk from "chalk";
+import ora from "ora";
+
+// src/db/index.ts
+import Database from "better-sqlite3";
+import { mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/db/migrate.ts
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS projects (
+  id TEXT PRIMARY KEY,
+  display_name TEXT NOT NULL,
+  repo_path TEXT NOT NULL,
+  worktree_path TEXT NOT NULL,
+  branch TEXT NOT NULL,
+  test_command TEXT,
+  build_command TEXT,
+  lint_command TEXT,
+  docker_memory TEXT DEFAULT '4g',
+  docker_cpus INTEGER DEFAULT 2,
+  docker_timeout_seconds INTEGER DEFAULT 1800,
+  secrets_file TEXT,
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS runs (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id),
+  started_at TEXT NOT NULL,
+  finished_at TEXT,
+  auth_mode TEXT NOT NULL DEFAULT 'max',
+  total_tasks INTEGER DEFAULT 0,
+  completed INTEGER DEFAULT 0,
+  failed INTEGER DEFAULT 0,
+  skipped INTEGER DEFAULT 0,
+  status TEXT DEFAULT 'running',
+  log_file TEXT,
+  commit_before TEXT,
+  commit_after TEXT
+);
+
+CREATE TABLE IF NOT EXISTS task_results (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  run_id TEXT NOT NULL REFERENCES runs(id),
+  task_id TEXT NOT NULL,
+  title TEXT NOT NULL,
+  status TEXT NOT NULL,
+  exit_code INTEGER,
+  auth_mode TEXT,
+  critic_mode TEXT DEFAULT 'review',
+  push_mode TEXT DEFAULT 'auto',
+  attempt INTEGER DEFAULT 1,
+  commit_sha TEXT,
+  started_at TEXT,
+  finished_at TEXT,
+  duration_seconds INTEGER,
+  dev_log_file TEXT,
+  critic_log_file TEXT,
+  diff_file TEXT,
+  merge_decision TEXT DEFAULT 'pending',
+  merged_at TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_task_results_run ON task_results(run_id);
+CREATE INDEX IF NOT EXISTS idx_task_results_status ON task_results(status);
+
+CREATE TABLE IF NOT EXISTS tasks (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  run_id TEXT NOT NULL REFERENCES runs(id),
+  task_id TEXT NOT NULL,
+  title TEXT NOT NULL,
+  files TEXT,
+  verify TEXT,
+  critic TEXT DEFAULT 'review',
+  push TEXT DEFAULT 'auto',
+  spec TEXT,
+  status_before TEXT DEFAULT 'pending',
+  UNIQUE(run_id, task_id)
+);
+`;
+function migrate(db) {
+  db.exec(SCHEMA);
+}
+
+// src/db/index.ts
+var DB_DIR = join(homedir(), ".noxdev");
+var DB_PATH = join(DB_DIR, "ledger.db");
+var _db;
+function getDb() {
+  if (_db) return _db;
+  mkdirSync(DB_DIR, { recursive: true });
+  _db = new Database(DB_PATH);
+  _db.pragma("journal_mode = WAL");
+  _db.pragma("foreign_keys = ON");
+  migrate(_db);
+  return _db;
+}
+
+// src/commands/init.ts
+function detectCommands(repoPath) {
+  const defaults = {
+    test_command: "pnpm test",
+    build_command: "pnpm build",
+    lint_command: "pnpm lint"
+  };
+  const pkgPath = join2(repoPath, "package.json");
+  if (!existsSync(pkgPath)) return defaults;
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const scripts = pkg.scripts ?? {};
+    return {
+      test_command: scripts.test ? `pnpm test` : defaults.test_command,
+      build_command: scripts.build ? `pnpm build` : defaults.build_command,
+      lint_command: scripts.lint ? `pnpm lint` : defaults.lint_command
+    };
+  } catch {
+    return defaults;
+  }
+}
+function registerInit(program2) {
+  program2.command("init").description("Initialize a new project").argument("<project>", "project name").requiredOption("--repo <path>", "path to git repository").action(async (project, opts) => {
+    try {
+      await runInit(project, opts.repo);
+    } catch (err) {
+      console.error(
+        chalk.red(
+          `Error: ${err instanceof Error ? err.message : String(err)}`
+        )
+      );
+      process.exitCode = 1;
+    }
+  });
+}
+async function runInit(project, repoPath) {
+  const resolvedRepo = resolve(repoPath);
+  const branch = `noxdev/${project}`;
+  const worktreePath = join2(homedir2(), "worktrees", project);
+  if (!existsSync(resolvedRepo)) {
+    throw new Error(`Repository path does not exist: ${resolvedRepo}`);
+  }
+  const gitDir = join2(resolvedRepo, ".git");
+  if (!existsSync(gitDir)) {
+    throw new Error(
+      `Not a git repository (missing .git): ${resolvedRepo}`
+    );
+  }
+  console.log(chalk.green("\u2713") + " Repository validated: " + resolvedRepo);
+  try {
+    execSync("git rev-parse HEAD", { cwd: resolvedRepo, stdio: "pipe" });
+  } catch {
+    console.log(chalk.yellow("  \u26A0 Empty repository detected. Creating initial commit..."));
+    const readmePath = join2(resolvedRepo, "README.md");
+    if (!existsSync(readmePath)) {
+      writeFileSync(readmePath, `# ${project}
+`);
+    }
+    execSync("git add .", { cwd: resolvedRepo, stdio: "pipe" });
+    try {
+      execSync("git config user.name", { cwd: resolvedRepo, stdio: "pipe" });
+    } catch {
+      execSync('git config user.name "noxdev"', { cwd: resolvedRepo, stdio: "pipe" });
+    }
+    try {
+      execSync("git config user.email", { cwd: resolvedRepo, stdio: "pipe" });
+    } catch {
+      execSync('git config user.email "noxdev@local"', { cwd: resolvedRepo, stdio: "pipe" });
+    }
+    execSync('git commit -m "init"', { cwd: resolvedRepo, stdio: "pipe" });
+    console.log(chalk.green("  \u2713 Initial commit created"));
+  }
+  const spinnerWt = ora("Creating git worktree\u2026").start();
+  try {
+    const defaultBranch = execSync("git symbolic-ref --short HEAD", {
+      cwd: resolvedRepo,
+      encoding: "utf-8"
+    }).trim();
+    let branchExists = false;
+    try {
+      const result = execSync(`git branch --list ${branch}`, {
+        cwd: resolvedRepo,
+        encoding: "utf-8"
+      }).trim();
+      branchExists = result.length > 0;
+    } catch {
+    }
+    let worktreeExisted = false;
+    if (branchExists) {
+      try {
+        execSync(`git worktree add ${worktreePath} ${branch}`, {
+          cwd: resolvedRepo,
+          stdio: "pipe"
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes("already exists")) {
+          worktreeExisted = true;
+        } else {
+          throw err;
+        }
+      }
+    } else {
+      try {
+        execSync(
+          `git worktree add -b ${branch} ${worktreePath} ${defaultBranch}`,
+          { cwd: resolvedRepo, stdio: "pipe" }
+        );
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes("already exists")) {
+          worktreeExisted = true;
+        } else {
+          throw err;
+        }
+      }
+    }
+    if (worktreeExisted) {
+      spinnerWt.warn(`Worktree already exists at ${worktreePath}`);
+    } else {
+      spinnerWt.succeed(
+        `Worktree created at ${chalk.cyan(worktreePath)}`
+      );
+    }
+  } catch (err) {
+    spinnerWt.fail("Failed to create worktree");
+    throw err;
+  }
+  const detected = detectCommands(resolvedRepo);
+  const configDir = join2(resolvedRepo, ".noxdev");
+  const configPath = join2(configDir, "config.json");
+  const projectConfig = {
+    project,
+    display_name: project,
+    test_command: detected.test_command,
+    build_command: detected.build_command,
+    lint_command: detected.lint_command,
+    docker: {
+      memory: "4g",
+      cpus: 2,
+      timeout_minutes: 30
+    },
+    secrets: "",
+    tasks_file: "TASKS.md",
+    critic_default: "strict",
+    push_default: "never"
+  };
+  mkdirSync2(configDir, { recursive: true });
+  writeFileSync(configPath, JSON.stringify(projectConfig, null, 2) + "\n");
+  console.log(chalk.green("\u2713") + " Config written: " + configPath);
+  const db = getDb();
+  const existing = db.prepare("SELECT id FROM projects WHERE id = ?").get(project);
+  if (existing) {
+    console.log(
+      chalk.yellow("\u26A0") + ` Project "${project}" already registered \u2014 updating`
+    );
+    db.prepare(
+      `UPDATE projects
+       SET repo_path = ?, worktree_path = ?, branch = ?,
+           test_command = ?, build_command = ?, lint_command = ?,
+           updated_at = datetime('now')
+       WHERE id = ?`
+    ).run(
+      resolvedRepo,
+      worktreePath,
+      branch,
+      detected.test_command,
+      detected.build_command,
+      detected.lint_command,
+      project
+    );
+  } else {
+    db.prepare(
+      `INSERT INTO projects (id, display_name, repo_path, worktree_path, branch,
+                             test_command, build_command, lint_command)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      project,
+      project,
+      resolvedRepo,
+      worktreePath,
+      branch,
+      detected.test_command,
+      detected.build_command,
+      detected.lint_command
+    );
+  }
+  console.log(chalk.green("\u2713") + ` Project "${project}" registered in database`);
+  let dockerOk = false;
+  try {
+    const result = execSync("docker images -q noxdev-runner:latest", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    dockerOk = result.length > 0;
+  } catch {
+  }
+  if (!dockerOk) {
+    console.log(
+      chalk.yellow("\u26A0") + " Docker image noxdev-runner:latest not found. Build it before running tasks."
+    );
+  } else {
+    console.log(chalk.green("\u2713") + " Docker image noxdev-runner:latest found");
+  }
+  console.log("");
+  console.log(chalk.bold("Project initialized:"));
+  console.log(`  Worktree:  ${chalk.cyan(worktreePath)}`);
+  console.log(`  Branch:    ${chalk.cyan(branch)}`);
+  console.log(`  Test:      ${detected.test_command}`);
+  console.log(`  Build:     ${detected.build_command}`);
+  console.log(`  Lint:      ${detected.lint_command}`);
+  console.log(`  Config:    ${configPath}`);
+  console.log("");
+  console.log(
+    chalk.blue("\u2192") + ` Write tasks in ${worktreePath}/TASKS.md then run: ${chalk.bold(`noxdev run ${project}`)}`
+  );
+}
+
+// src/commands/run.ts
+import { join as join7 } from "path";
+import { homedir as homedir6 } from "os";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { spawn, execSync as execSync4 } from "child_process";
+import chalk3 from "chalk";
+
+// src/db/queries.ts
+function insertRun(db, run) {
+  db.prepare(
+    `INSERT INTO runs (id, project_id, started_at, auth_mode, total_tasks, commit_before, log_file)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    run.id,
+    run.projectId,
+    run.startedAt,
+    run.authMode,
+    run.totalTasks,
+    run.commitBefore,
+    run.logFile
+  );
+}
+function updateRunFinished(db, runId, updates) {
+  db.prepare(
+    `UPDATE runs
+     SET finished_at = ?, completed = ?, failed = ?, skipped = ?, status = ?, commit_after = ?
+     WHERE id = ?`
+  ).run(
+    updates.finishedAt,
+    updates.completed,
+    updates.failed,
+    updates.skipped,
+    updates.status,
+    updates.commitAfter,
+    runId
+  );
+}
+function insertTaskCache(db, runId, tasks) {
+  const stmt = db.prepare(
+    `INSERT INTO tasks (run_id, task_id, title, files, verify, critic, push, spec, status_before)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+  const insertMany = db.transaction((rows) => {
+    for (const t of rows) {
+      stmt.run(runId, t.taskId, t.title, t.files, t.verify, t.critic, t.push, t.spec, t.statusBefore);
+    }
+  });
+  insertMany(tasks);
+}
+function insertTaskResult(db, result) {
+  db.prepare(
+    `INSERT INTO task_results
+     (run_id, task_id, title, status, exit_code, auth_mode, critic_mode, push_mode,
+      attempt, commit_sha, started_at, finished_at, duration_seconds,
+      dev_log_file, critic_log_file, diff_file)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    result.runId,
+    result.taskId,
+    result.title,
+    result.status,
+    result.exitCode,
+    result.authMode,
+    result.criticMode,
+    result.pushMode,
+    result.attempt,
+    result.commitSha,
+    result.startedAt,
+    result.finishedAt,
+    result.durationSeconds,
+    result.devLogFile,
+    result.criticLogFile,
+    result.diffFile
+  );
+}
+function updateMergeDecision(db, taskResultId, decision, mergedAt) {
+  db.prepare(
+    `UPDATE task_results SET merge_decision = ?, merged_at = ? WHERE id = ?`
+  ).run(decision, mergedAt ?? null, taskResultId);
+}
+function getLatestRun(db, projectId) {
+  return db.prepare(`SELECT * FROM runs WHERE project_id = ? ORDER BY started_at DESC LIMIT 1`).get(projectId) ?? null;
+}
+function getTaskResults(db, runId) {
+  return db.prepare(`SELECT * FROM task_results WHERE run_id = ?`).all(runId);
+}
+function getPendingMerge(db, runId) {
+  return db.prepare(`SELECT * FROM task_results WHERE run_id = ? AND merge_decision = 'pending'`).all(runId);
+}
+function getProject(db, projectId) {
+  return db.prepare(`SELECT * FROM projects WHERE id = ?`).get(projectId) ?? null;
+}
+function getAllProjects(db) {
+  return db.prepare(
+    `SELECT p.*,
+              r.id AS latest_run_id,
+              r.started_at AS latest_run_started_at,
+              r.status AS latest_run_status,
+              r.total_tasks AS latest_run_total_tasks,
+              r.completed AS latest_run_completed,
+              r.failed AS latest_run_failed
+       FROM projects p
+       LEFT JOIN runs r ON r.id = (
+         SELECT r2.id FROM runs r2
+         WHERE r2.project_id = p.id
+         ORDER BY r2.started_at DESC
+         LIMIT 1
+       )`
+  ).all();
+}
+
+// src/config/index.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+var DEFAULT_GLOBAL_CONFIG = {
+  accounts: {
+    max: {
+      preferred: true,
+      rate_limit_ceiling: 80
+    },
+    api: {
+      fallback: true,
+      daily_cap_usd: 5,
+      model: "claude-sonnet-4-6"
+    }
+  },
+  safety: {
+    auto_push: false,
+    max_retries_per_task: 3,
+    circuit_breaker_threshold: 5
+  },
+  secrets: {
+    provider: "age",
+    global: "",
+    age_key: ""
+  }
+};
+var DEFAULT_PROJECT_CONFIG = {
+  project: "",
+  display_name: "",
+  test_command: "pnpm test",
+  build_command: "pnpm build",
+  lint_command: "pnpm lint",
+  docker: {
+    memory: "4g",
+    cpus: 2,
+    timeout_minutes: 30
+  },
+  secrets: "",
+  tasks_file: "TASKS.md",
+  critic_default: "strict",
+  push_default: "never"
+};
+function deepMerge(defaults, overrides) {
+  const result = { ...defaults };
+  for (const key of Object.keys(overrides)) {
+    const val = overrides[key];
+    const def = defaults[key];
+    if (val !== null && typeof val === "object" && !Array.isArray(val) && def !== null && typeof def === "object" && !Array.isArray(def)) {
+      result[key] = deepMerge(
+        def,
+        val
+      );
+    } else {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+function readJsonFile(filePath) {
+  try {
+    const content = readFileSync2(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return null;
+    }
+    throw new Error(
+      `Failed to parse config at ${filePath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function loadGlobalConfig() {
+  const configPath = join3(homedir3(), ".noxdev", "config.json");
+  const overrides = readJsonFile(configPath);
+  if (!overrides) {
+    return { ...DEFAULT_GLOBAL_CONFIG };
+  }
+  return deepMerge(DEFAULT_GLOBAL_CONFIG, overrides);
+}
+function loadProjectConfig(projectPath) {
+  const configPath = join3(projectPath, ".noxdev", "config.json");
+  const overrides = readJsonFile(configPath);
+  if (!overrides) {
+    return { ...DEFAULT_PROJECT_CONFIG };
+  }
+  return deepMerge(DEFAULT_PROJECT_CONFIG, overrides);
+}
+
+// src/auth/index.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
+import { execSync as execSync2 } from "child_process";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
+function getMaxCredentialPath() {
+  return join4(homedir4(), ".claude.json");
+}
+function isMaxAvailable() {
+  const credPath = getMaxCredentialPath();
+  if (!existsSync2(credPath)) return false;
+  const content = readFileSync3(credPath, "utf-8");
+  return content.trim().length > 0;
+}
+function resolveAuth(config) {
+  if (config.max.preferred && isMaxAvailable()) {
+    return { mode: "max", model: "claude-sonnet-4-20250514" };
+  }
+  if (config.api.fallback) {
+    try {
+      const decrypted = execSync2(
+        `sops -d --extract '["ANTHROPIC_API_KEY"]' ${config.secrets.globalSecretsFile}`,
+        { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+      );
+      return { mode: "api", apiKey: decrypted.trim(), model: config.api.model };
+    } catch {
+    }
+  }
+  throw new Error(
+    "No auth available. Max credentials not found at ~/.claude.json and API fallback is disabled or decryption failed."
+  );
+}
+
+// src/engine/orchestrator.ts
+import { execSync as execSync3 } from "child_process";
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, unlinkSync, readFileSync as readFileSync6, copyFileSync, existsSync as existsSync3 } from "fs";
+import { join as join6 } from "path";
+import { tmpdir, homedir as homedir5 } from "os";
+import chalk2 from "chalk";
+
+// src/parser/tasks.ts
+import { readFileSync as readFileSync4 } from "fs";
+var TASK_HEADER_RE = /^## (T\d+): (.+)$/;
+var FIELD_RE = /^- (STATUS|FILES|VERIFY|CRITIC|PUSH|SPEC): (.+)$/i;
+function parseTasks(content, includeDone = false) {
+  const lines = content.split("\n");
+  const tasks = [];
+  let current = null;
+  let inSpec = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const headerMatch = line.match(TASK_HEADER_RE);
+    if (headerMatch) {
+      if (current) tasks.push(current);
+      current = {
+        taskId: headerMatch[1],
+        title: headerMatch[2],
+        status: "pending",
+        files: [],
+        verify: "",
+        critic: "review",
+        push: "auto",
+        spec: ""
+      };
+      inSpec = false;
+      continue;
+    }
+    if (!current) continue;
+    if (inSpec) {
+      if (/^ {2,}/.test(line)) {
+        current.spec += "\n" + line.trim();
+        continue;
+      }
+      inSpec = false;
+    }
+    const fieldMatch = line.match(FIELD_RE);
+    if (fieldMatch) {
+      const name = fieldMatch[1].toUpperCase();
+      const value = fieldMatch[2];
+      switch (name) {
+        case "STATUS":
+          current.status = value.trim().toLowerCase();
+          break;
+        case "FILES":
+          current.files = value.split(",").map((f) => f.trim()).filter((f) => f.length > 0);
+          break;
+        case "VERIFY":
+          current.verify = value.trim();
+          break;
+        case "CRITIC":
+          current.critic = value.trim();
+          break;
+        case "PUSH":
+          current.push = value.trim();
+          break;
+        case "SPEC":
+          current.spec = value.trimEnd();
+          inSpec = true;
+          break;
+      }
+    }
+  }
+  if (current) tasks.push(current);
+  if (includeDone) return tasks;
+  return tasks.filter((t) => t.status === "pending");
+}
+function parseTasksFromFile(filePath, includeDone = false) {
+  const content = readFileSync4(filePath, "utf-8");
+  return parseTasks(content, includeDone);
+}
+
+// src/parser/status-update.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+var TASK_HEADER_RE2 = /^## (T\d+): /;
+var STATUS_LINE_RE = /^(- STATUS: )\w+/;
+function replaceTaskStatus(content, taskId, newStatus) {
+  const lines = content.split("\n");
+  let inTargetTask = false;
+  let found = false;
+  for (let i = 0; i < lines.length; i++) {
+    const headerMatch = lines[i].match(TASK_HEADER_RE2);
+    if (headerMatch) {
+      inTargetTask = headerMatch[1] === taskId;
+      continue;
+    }
+    if (inTargetTask && STATUS_LINE_RE.test(lines[i])) {
+      lines[i] = lines[i].replace(STATUS_LINE_RE, `$1${newStatus}`);
+      found = true;
+      break;
+    }
+  }
+  return { content: lines.join("\n"), found };
+}
+function updateTaskStatus(filePath, taskId, newStatus) {
+  const content = readFileSync5(filePath, "utf-8");
+  const result = replaceTaskStatus(content, taskId, newStatus);
+  if (!result.found) {
+    throw new Error(`Task ${taskId} not found in ${filePath}`);
+  }
+  writeFileSync2(filePath, result.content, "utf-8");
+}
+
+// src/prompts/builder.ts
+function buildTaskPrompt(ctx) {
+  const { task, projectConfig, worktreePath, attempt, previousError } = ctx;
+  const filesSection = task.files.length > 0 ? task.files.join("\n") : "No specific files listed.";
+  let prompt = `You are an autonomous coding agent working on project "${projectConfig.display_name}".
+Working directory: ${worktreePath}
+
+## Task: ${task.taskId} \u2014 ${task.title}
+
+${task.spec}
+
+## Files to focus on (hints, not constraints):
+${filesSection}
+
+## Verification:
+After completing the task, run: ${task.verify}
+If the verification command fails, fix the issue and re-run until it passes.
+`;
+  if (attempt > 1 && previousError) {
+    prompt += `
+## Previous attempt failed:
+${previousError}
+Analyze what went wrong and try a different approach.
+`;
+  }
+  prompt += `
+## Rules:
+- Make only the changes needed for this task. Do not refactor unrelated code.
+- Commit your changes with message: "noxdev(${task.taskId}): ${task.title}"
+- Do not push to any remote.
+- If you cannot complete the task, create a file FAILED.md explaining what went wrong.
+`;
+  return prompt;
+}
+function buildCriticPrompt(task, diffContent) {
+  return `You are a code review critic. Review this diff for task "${task.taskId}: ${task.title}".
+
+## Task specification:
+${task.spec}
+
+## Diff to review:
+\`\`\`
+${diffContent}
+\`\`\`
+
+## Review checklist:
+1. Does the diff implement what the spec asks for? (correctness)
+2. Are changes scoped to the task? No unrelated modifications? (scope)
+3. Are there security issues? (credential exposure, injection, missing validation)
+4. Does the code follow existing patterns in the project?
+
+Respond with APPROVED or REJECTED followed by a brief explanation.
+If REJECTED, explain what needs to change.
+`;
+}
+
+// src/docker/runner.ts
+import { execFileSync } from "child_process";
+import { statSync } from "fs";
+import { dirname, join as join5 } from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function resolveScriptsDir() {
+  return join5(__dirname, "scripts");
+}
+function runTaskInDocker(options, auth) {
+  const scriptName = auth.mode === "max" ? "docker-run-max.sh" : "docker-run-api.sh";
+  const scriptPath = join5(resolveScriptsDir(), scriptName);
+  const args2 = [
+    options.promptFile,
+    options.taskLog,
+    String(options.timeoutSeconds),
+    options.worktreeDir,
+    options.projectGitDir,
+    options.gitTargetPath,
+    options.memoryLimit,
+    String(options.cpuLimit),
+    options.dockerImage
+  ];
+  if (auth.mode === "api") {
+    args2.push(auth.apiKey);
+  }
+  const startTime = Date.now();
+  try {
+    execFileSync(scriptPath, args2, {
+      stdio: "inherit",
+      timeout: (options.timeoutSeconds + 60) * 1e3
+    });
+    const durationSeconds = Math.round((Date.now() - startTime) / 1e3);
+    return { exitCode: 0, logFile: options.taskLog, durationSeconds };
+  } catch (err) {
+    const durationSeconds = Math.round((Date.now() - startTime) / 1e3);
+    const exitCode = err.status ?? 1;
+    return { exitCode, logFile: options.taskLog, durationSeconds };
+  }
+}
+function captureDiff(worktreeDir, outputFile) {
+  const scriptPath = join5(resolveScriptsDir(), "docker-capture-diff.sh");
+  execFileSync(scriptPath, [worktreeDir, outputFile], {
+    stdio: "inherit"
+  });
+  try {
+    const stat = statSync(outputFile);
+    return stat.size > 0;
+  } catch {
+    return false;
+  }
+}
+
+// src/engine/orchestrator.ts
+function getCurrentSha(cwd) {
+  return execSync3("git rev-parse HEAD", { cwd, encoding: "utf-8" }).trim();
+}
+function isoNow() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function executeRun(ctx) {
+  const claudeJsonSrc = join6(homedir5(), ".claude.json");
+  const claudeSnapshot = join6(homedir5(), ".noxdev", ".claude-snapshot.json");
+  if (existsSync3(claudeJsonSrc)) {
+    mkdirSync3(join6(homedir5(), ".noxdev"), { recursive: true });
+    copyFileSync(claudeJsonSrc, claudeSnapshot);
+    console.log(chalk2.dim("  Credential snapshot saved"));
+  }
+  const tasksFile = join6(ctx.worktreeDir, ctx.projectConfig.tasks_file);
+  const pendingTasks = parseTasksFromFile(tasksFile);
+  if (pendingTasks.length === 0) {
+    console.log("No pending tasks");
+    return;
+  }
+  const commitBefore = getCurrentSha(ctx.worktreeDir);
+  const logDir = join6(homedir5(), ".noxdev", "logs", ctx.runId);
+  insertRun(ctx.db, {
+    id: ctx.runId,
+    projectId: ctx.projectId,
+    startedAt: isoNow(),
+    authMode: ctx.auth.mode,
+    totalTasks: pendingTasks.length,
+    commitBefore,
+    logFile: logDir
+  });
+  insertTaskCache(
+    ctx.db,
+    ctx.runId,
+    pendingTasks.map((t) => ({
+      taskId: t.taskId,
+      title: t.title,
+      files: t.files.join(","),
+      verify: t.verify,
+      critic: t.critic,
+      push: t.push,
+      spec: t.spec,
+      statusBefore: t.status
+    }))
+  );
+  console.log(
+    chalk2.bold(
+      `noxdev run ${ctx.projectId} \u2014 ${pendingTasks.length} pending tasks`
+    )
+  );
+  let completed = 0;
+  let failed = 0;
+  let skipped = 0;
+  let consecutiveFailures = 0;
+  const maxRetries = ctx.projectConfig.docker?.timeout_minutes ? 1 : 1;
+  const circuitBreakerThreshold = 3;
+  let lastSha = commitBefore;
+  for (const task of pendingTasks) {
+    if (consecutiveFailures >= circuitBreakerThreshold) {
+      console.log(
+        chalk2.yellow(
+          `\u26A0 Circuit breaker: ${consecutiveFailures} consecutive failures, stopping run`
+        )
+      );
+      skipped += pendingTasks.length - completed - failed;
+      break;
+    }
+    const result = await executeTask(ctx, task, lastSha, logDir, 1, maxRetries, claudeJsonSrc, claudeSnapshot);
+    if (result.commitSha) {
+      lastSha = result.commitSha;
+    }
+    const newStatus = result.status === "COMPLETED" ? "done" : "failed";
+    try {
+      updateTaskStatus(tasksFile, task.taskId, newStatus);
+    } catch {
+      console.log(
+        chalk2.yellow(`\u26A0 Could not update TASKS.md status for ${task.taskId}`)
+      );
+    }
+    if (result.status === "COMPLETED") {
+      completed++;
+      consecutiveFailures = 0;
+    } else {
+      failed++;
+      consecutiveFailures++;
+    }
+  }
+  const commitAfter = getCurrentSha(ctx.worktreeDir);
+  const runStatus = failed === 0 ? "completed" : "partial";
+  updateRunFinished(ctx.db, ctx.runId, {
+    finishedAt: isoNow(),
+    completed,
+    failed,
+    skipped,
+    status: runStatus,
+    commitAfter
+  });
+  const parts = [];
+  if (completed > 0) parts.push(chalk2.green(`${completed} completed`));
+  if (failed > 0) parts.push(chalk2.red(`${failed} failed`));
+  if (skipped > 0) parts.push(chalk2.yellow(`${skipped} skipped`));
+  console.log(`
+Run ${ctx.runId} complete: ${parts.join(", ")}`);
+}
+async function executeTask(ctx, task, lastSha, logDir, attempt, maxRetries, claudeJsonSrc, claudeSnapshot, previousError) {
+  console.log(chalk2.bold(`
+\u2501\u2501\u2501 ${task.taskId}: ${task.title} \u2501\u2501\u2501`));
+  if (attempt > 1) {
+    console.log(chalk2.yellow(`  Retry attempt ${attempt}`));
+  }
+  const startedAt = isoNow();
+  const startTime = Date.now();
+  const prompt = buildTaskPrompt({
+    task,
+    projectConfig: ctx.projectConfig,
+    worktreePath: ctx.worktreeDir,
+    runId: ctx.runId,
+    attempt,
+    previousError
+  });
+  const promptFile = join6(
+    tmpdir(),
+    `noxdev-prompt-${ctx.runId}-${task.taskId}.md`
+  );
+  writeFileSync3(promptFile, prompt, "utf-8");
+  const taskLogDir = join6(logDir, task.taskId);
+  mkdirSync3(taskLogDir, { recursive: true });
+  const taskLog = join6(taskLogDir, `attempt-${attempt}.log`);
+  if (existsSync3(claudeSnapshot)) {
+    copyFileSync(claudeSnapshot, claudeJsonSrc);
+  }
+  const timeoutSeconds = ctx.projectConfig.docker.timeout_minutes * 60;
+  const dockerResult = runTaskInDocker(
+    {
+      promptFile,
+      taskLog,
+      timeoutSeconds,
+      worktreeDir: ctx.worktreeDir,
+      projectGitDir: ctx.projectGitDir,
+      gitTargetPath: ctx.gitTargetPath,
+      memoryLimit: ctx.projectConfig.docker.memory,
+      cpuLimit: ctx.projectConfig.docker.cpus,
+      dockerImage: "noxdev-runner:latest"
+    },
+    ctx.auth
+  );
+  const endTime = Date.now();
+  const durationSeconds = Math.round((endTime - startTime) / 1e3);
+  let commitSha = null;
+  try {
+    const currentSha = getCurrentSha(ctx.worktreeDir);
+    if (currentSha !== lastSha) {
+      commitSha = currentSha;
+    }
+  } catch {
+  }
+  let status = dockerResult.exitCode === 0 ? "COMPLETED" : "FAILED";
+  if (status === "FAILED" && attempt < maxRetries) {
+    let errorContext = `Exit code: ${dockerResult.exitCode}`;
+    try {
+      const logContent = readFileSync6(taskLog, "utf-8");
+      const lines = logContent.split("\n");
+      errorContext = lines.slice(-50).join("\n");
+    } catch {
+    }
+    try {
+      unlinkSync(promptFile);
+    } catch {
+    }
+    return executeTask(
+      ctx,
+      task,
+      commitSha ?? lastSha,
+      logDir,
+      attempt + 1,
+      maxRetries,
+      claudeJsonSrc,
+      claudeSnapshot,
+      errorContext
+    );
+  }
+  let criticLogFile = null;
+  let diffFile = null;
+  if (task.critic === "review" && status === "COMPLETED") {
+    const criticResult = await runCritic(ctx, task, logDir, attempt, claudeJsonSrc, claudeSnapshot);
+    criticLogFile = criticResult.criticLogFile;
+    diffFile = criticResult.diffFile;
+    if (criticResult.rejected) {
+      status = "FAILED";
+      if (attempt < maxRetries) {
+        try {
+          unlinkSync(promptFile);
+        } catch {
+        }
+        return executeTask(
+          ctx,
+          task,
+          commitSha ?? lastSha,
+          logDir,
+          attempt + 1,
+          maxRetries,
+          claudeJsonSrc,
+          claudeSnapshot,
+          `Critic rejected the changes: ${criticResult.reason}`
+        );
+      }
+    }
+  }
+  const finishedAt = isoNow();
+  insertTaskResult(ctx.db, {
+    runId: ctx.runId,
+    taskId: task.taskId,
+    title: task.title,
+    status,
+    exitCode: dockerResult.exitCode,
+    authMode: ctx.auth.mode,
+    criticMode: task.critic,
+    pushMode: task.push,
+    attempt,
+    commitSha,
+    startedAt,
+    finishedAt,
+    durationSeconds,
+    devLogFile: taskLog,
+    criticLogFile,
+    diffFile
+  });
+  if (status === "COMPLETED") {
+    console.log(
+      chalk2.green(`  \u2713 ${task.taskId} completed in ${durationSeconds}s`)
+    );
+  } else {
+    console.log(
+      chalk2.red(
+        `  \u2717 ${task.taskId} failed (exit ${dockerResult.exitCode}) in ${durationSeconds}s`
+      )
+    );
+  }
+  try {
+    unlinkSync(promptFile);
+  } catch {
+  }
+  return {
+    taskId: task.taskId,
+    title: task.title,
+    status,
+    exitCode: dockerResult.exitCode,
+    commitSha,
+    durationSeconds,
+    attempt
+  };
+}
+async function runCritic(ctx, task, logDir, attempt, claudeJsonSrc, claudeSnapshot) {
+  console.log(chalk2.dim(`  Running critic review for ${task.taskId}\u2026`));
+  const taskLogDir = join6(logDir, task.taskId);
+  const diffOutputFile = join6(taskLogDir, `diff-attempt-${attempt}.patch`);
+  const hasDiff = captureDiff(ctx.worktreeDir, diffOutputFile);
+  if (!hasDiff) {
+    console.log(chalk2.yellow("  \u26A0 No diff to review, skipping critic"));
+    return { rejected: false, reason: "", criticLogFile: null, diffFile: null };
+  }
+  const diffContent = readFileSync6(diffOutputFile, "utf-8");
+  const criticPromptContent = buildCriticPrompt(task, diffContent);
+  const criticPromptFile = join6(
+    tmpdir(),
+    `noxdev-critic-${ctx.runId}-${task.taskId}.md`
+  );
+  writeFileSync3(criticPromptFile, criticPromptContent, "utf-8");
+  if (existsSync3(claudeSnapshot)) {
+    copyFileSync(claudeSnapshot, claudeJsonSrc);
+  }
+  const criticLog = join6(taskLogDir, `critic-attempt-${attempt}.log`);
+  const criticResult = runTaskInDocker(
+    {
+      promptFile: criticPromptFile,
+      taskLog: criticLog,
+      timeoutSeconds: 120,
+      worktreeDir: ctx.worktreeDir,
+      projectGitDir: ctx.projectGitDir,
+      gitTargetPath: ctx.gitTargetPath,
+      memoryLimit: ctx.projectConfig.docker.memory,
+      cpuLimit: ctx.projectConfig.docker.cpus,
+      dockerImage: "noxdev-runner:latest"
+    },
+    ctx.auth
+  );
+  try {
+    unlinkSync(criticPromptFile);
+  } catch {
+  }
+  let rejected = false;
+  let reason = "";
+  try {
+    const criticOutput = readFileSync6(criticLog, "utf-8");
+    if (/\bREJECTED\b/i.test(criticOutput)) {
+      rejected = true;
+      const match = criticOutput.match(/REJECTED[:\s]*(.*)/i);
+      reason = match?.[1]?.trim() ?? "Critic rejected without explanation";
+      console.log(chalk2.red(`  \u2717 Critic REJECTED: ${reason}`));
+    } else {
+      console.log(chalk2.green("  \u2713 Critic APPROVED"));
+    }
+  } catch {
+    console.log(chalk2.yellow("  \u26A0 Could not read critic output, assuming approved"));
+  }
+  return {
+    rejected,
+    reason,
+    criticLogFile: criticLog,
+    diffFile: diffOutputFile
+  };
+}
+
+// src/commands/run.ts
+function generateRunId() {
+  const now = /* @__PURE__ */ new Date();
+  const pad3 = (n) => String(n).padStart(2, "0");
+  return [
+    now.getFullYear(),
+    pad3(now.getMonth() + 1),
+    pad3(now.getDate()),
+    "_",
+    pad3(now.getHours()),
+    pad3(now.getMinutes()),
+    pad3(now.getSeconds())
+  ].join("");
+}
+function generateRunIdForProject(projectId) {
+  const now = /* @__PURE__ */ new Date();
+  const pad3 = (n) => String(n).padStart(2, "0");
+  return [
+    now.getFullYear(),
+    pad3(now.getMonth() + 1),
+    pad3(now.getDate()),
+    "_",
+    pad3(now.getHours()),
+    pad3(now.getMinutes()),
+    pad3(now.getSeconds()),
+    "_",
+    projectId
+  ].join("");
+}
+async function runProject(project) {
+  const db = getDb();
+  const globalConfig = loadGlobalConfig();
+  const projectConfig = loadProjectConfig(project.repo_path);
+  const auth = resolveAuth({
+    max: { preferred: globalConfig.accounts.max.preferred },
+    api: {
+      fallback: globalConfig.accounts.api.fallback,
+      dailyCapUsd: globalConfig.accounts.api.daily_cap_usd,
+      model: globalConfig.accounts.api.model
+    },
+    secrets: {
+      provider: globalConfig.secrets.provider,
+      globalSecretsFile: globalConfig.secrets.global,
+      ageKeyFile: globalConfig.secrets.age_key
+    }
+  });
+  const runId = generateRunId();
+  const gitDir = join7(project.repo_path, ".git");
+  try {
+    const baseBranch = execSync4("git symbolic-ref --short HEAD", {
+      cwd: project.repo_path,
+      encoding: "utf-8"
+    }).trim();
+    execSync4(`git merge ${baseBranch} --no-edit`, {
+      cwd: project.worktree_path,
+      stdio: "pipe"
+    });
+    console.log(chalk3.gray(`  \u2713 Worktree synced with ${baseBranch}`));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("CONFLICT")) {
+      console.error(chalk3.red("\u2716 Merge conflict syncing worktree with base branch."));
+      console.error(chalk3.gray("  Resolve manually: cd " + project.worktree_path));
+      console.error(chalk3.gray("  Then re-run: noxdev run " + project.id));
+      process.exit(1);
+    }
+    console.log(chalk3.gray("  \u2713 Worktree up to date"));
+  }
+  const ctx = {
+    projectId: project.id,
+    projectConfig,
+    worktreeDir: project.worktree_path,
+    projectGitDir: gitDir,
+    gitTargetPath: gitDir,
+    runId,
+    db,
+    auth
+  };
+  await executeRun(ctx);
+  try {
+    const worktreePath = project.worktree_path;
+    execSync4("git add TASKS.md", { cwd: worktreePath, stdio: "pipe" });
+    execSync4('git commit -m "noxdev: update task statuses"', { cwd: worktreePath, stdio: "pipe" });
+    console.log(chalk3.gray("  \u2713 TASKS.md status updates committed"));
+  } catch {
+  }
+}
+async function runAllProjects(db) {
+  const projects = getAllProjects(db);
+  if (projects.length === 0) {
+    console.log("No registered projects. Run `noxdev init` first.");
+    return;
+  }
+  console.log(
+    chalk3.bold(
+      `noxdev run --all: ${projects.length} registered projects`
+    )
+  );
+  const globalConfig = loadGlobalConfig();
+  const auth = resolveAuth({
+    max: { preferred: globalConfig.accounts.max.preferred },
+    api: {
+      fallback: globalConfig.accounts.api.fallback,
+      dailyCapUsd: globalConfig.accounts.api.daily_cap_usd,
+      model: globalConfig.accounts.api.model
+    },
+    secrets: {
+      provider: globalConfig.secrets.provider,
+      globalSecretsFile: globalConfig.secrets.global,
+      ageKeyFile: globalConfig.secrets.age_key
+    }
+  });
+  const results = [];
+  for (let i = 0; i < projects.length; i++) {
+    const proj = projects[i];
+    const projectConfig = loadProjectConfig(proj.repo_path);
+    const tasksFile = join7(proj.worktree_path, projectConfig.tasks_file);
+    let pendingCount = 0;
+    try {
+      const pending = parseTasksFromFile(tasksFile);
+      pendingCount = pending.length;
+    } catch {
+      pendingCount = 0;
+    }
+    const time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+    console.log(
+      `[${time}] Project ${i + 1}/${projects.length}: ${proj.display_name} (${pendingCount} pending tasks)`
+    );
+    const runId = generateRunIdForProject(proj.id);
+    const gitDir = join7(proj.repo_path, ".git");
+    const ctx = {
+      projectId: proj.id,
+      projectConfig,
+      worktreeDir: proj.worktree_path,
+      projectGitDir: gitDir,
+      gitTargetPath: gitDir,
+      runId,
+      db,
+      auth
+    };
+    let completed = 0;
+    let total = pendingCount;
+    try {
+      await executeRun(ctx);
+      const run = db.prepare("SELECT * FROM runs WHERE id = ?").get(runId);
+      if (run) {
+        completed = run.completed ?? 0;
+        total = run.total_tasks;
+        if (run.failed === run.total_tasks && run.total_tasks > 0) {
+          console.log(
+            chalk3.yellow(
+              `\u26A0 Project ${proj.display_name}: all tasks failed (circuit-break), continuing to next project`
+            )
+          );
+        }
+      }
+    } catch (err) {
+      console.log(
+        chalk3.yellow(
+          `\u26A0 Project ${proj.display_name} failed: ${err instanceof Error ? err.message : String(err)}`
+        )
+      );
+    }
+    try {
+      const worktreePath = proj.worktree_path;
+      execSync4("git add TASKS.md", { cwd: worktreePath, stdio: "pipe" });
+      execSync4('git commit -m "noxdev: update task statuses"', { cwd: worktreePath, stdio: "pipe" });
+      console.log(chalk3.gray("  \u2713 TASKS.md status updates committed"));
+    } catch {
+    }
+    results.push({
+      displayName: proj.display_name,
+      completed,
+      total
+    });
+  }
+  console.log("\n---");
+  console.log("MULTI-PROJECT RUN COMPLETE");
+  for (const r of results) {
+    console.log(`  ${r.displayName}: ${r.completed}/${r.total} completed`);
+  }
+  console.log("---");
+}
+function whichCommand(cmd) {
+  try {
+    execSync4(`which ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function startOvernightRun(project, all) {
+  const childArgs = ["run"];
+  if (project) childArgs.push(project);
+  if (all) childArgs.push("--all");
+  const entryPoint = join7(import.meta.dirname, "..", "index.js");
+  let spawnCmd;
+  let spawnArgs;
+  if (whichCommand("systemd-inhibit")) {
+    spawnCmd = "systemd-inhibit";
+    spawnArgs = [
+      "--what=sleep",
+      "--who=noxdev",
+      "--why=Overnight coding run",
+      "node",
+      entryPoint,
+      ...childArgs
+    ];
+  } else if (whichCommand("caffeinate")) {
+    spawnCmd = "caffeinate";
+    spawnArgs = ["-s", "node", entryPoint, ...childArgs];
+  } else {
+    console.log(
+      chalk3.yellow(
+        "Could not inhibit sleep. Machine may sleep during overnight run."
+      )
+    );
+    spawnCmd = "node";
+    spawnArgs = [entryPoint, ...childArgs];
+  }
+  const child = spawn(spawnCmd, spawnArgs, {
+    detached: true,
+    stdio: "ignore"
+  });
+  const pid = child.pid;
+  if (!pid) {
+    console.error(chalk3.red("Failed to start overnight process."));
+    process.exitCode = 1;
+    return;
+  }
+  child.unref();
+  const noxdevDir = join7(homedir6(), ".noxdev");
+  mkdirSync4(noxdevDir, { recursive: true });
+  writeFileSync4(join7(noxdevDir, "noxdev.pid"), String(pid), "utf-8");
+  console.log(
+    `noxdev overnight run started (PID: ${pid}). Check status with: noxdev status`
+  );
+}
+function registerRun(program2) {
+  program2.command("run").description("Run coding tasks").argument("[project]", "project name").option("--overnight", "run in overnight mode").option("--all", "run for all projects").action(
+    async (project, opts) => {
+      try {
+        if (opts.overnight) {
+          await startOvernightRun(project, opts.all);
+          return;
+        }
+        const db = getDb();
+        if (opts.all) {
+          await runAllProjects(db);
+          return;
+        }
+        let projectRow;
+        if (project) {
+          projectRow = getProject(db, project);
+          if (!projectRow) {
+            console.error(
+              chalk3.red(
+                `Project "${project}" not found. Run \`noxdev init ${project}\` first.`
+              )
+            );
+            process.exitCode = 1;
+            return;
+          }
+        } else {
+          const projects = getAllProjects(db);
+          if (projects.length === 0) {
+            console.error(
+              chalk3.red(
+                "No projects registered. Run `noxdev init` first."
+              )
+            );
+            process.exitCode = 1;
+            return;
+          }
+          if (projects.length > 1) {
+            console.error(
+              chalk3.red(
+                `Multiple projects registered. Specify one: ${projects.map((p) => p.id).join(", ")}`
+              )
+            );
+            process.exitCode = 1;
+            return;
+          }
+          projectRow = projects[0];
+        }
+        await runProject(projectRow);
+      } catch (err) {
+        console.error(
+          chalk3.red(
+            `Error: ${err instanceof Error ? err.message : String(err)}`
+          )
+        );
+        process.exitCode = 1;
+      }
+    }
+  );
+}
+
+// src/commands/status.ts
+import chalk5 from "chalk";
+
+// src/engine/summary.ts
+import chalk4 from "chalk";
+function getAllProjectSummaries(db) {
+  const projects = getAllProjects(db);
+  const summaries = [];
+  for (const p of projects) {
+    const run = getLatestRun(db, p.id);
+    if (!run) {
+      summaries.push({
+        projectId: p.id,
+        displayName: p.display_name,
+        runId: null,
+        status: null,
+        total: 0,
+        completed: 0,
+        failed: 0,
+        skipped: 0,
+        pendingMerge: 0,
+        startedAt: null,
+        finishedAt: null
+      });
+      continue;
+    }
+    const pending = getPendingMerge(db, run.id);
+    summaries.push({
+      projectId: p.id,
+      displayName: p.display_name,
+      runId: run.id,
+      status: run.status,
+      total: run.total_tasks ?? 0,
+      completed: run.completed ?? 0,
+      failed: run.failed ?? 0,
+      skipped: run.skipped ?? 0,
+      pendingMerge: pending.length,
+      startedAt: run.started_at,
+      finishedAt: run.finished_at
+    });
+  }
+  return summaries;
+}
+function relativeTime(isoDate) {
+  const now = Date.now();
+  const dateStr = isoDate.endsWith("Z") ? isoDate : isoDate + "Z";
+  const then = new Date(dateStr).getTime();
+  const diffMs = now - then;
+  const diffMin = Math.floor(diffMs / 6e4);
+  const diffHr = Math.floor(diffMs / 36e5);
+  const diffDay = Math.floor(diffMs / 864e5);
+  if (diffMin < 60) return `${Math.max(diffMin, 1)}m ago`;
+  if (diffHr < 24) return `${diffHr}h ago`;
+  if (diffDay < 7) return `${diffDay}d ago`;
+  return isoDate.slice(0, 10);
+}
+function pad(str, len) {
+  return str.length >= len ? str : str + " ".repeat(len - str.length);
+}
+function formatSummaryTable(summaries) {
+  const header = `${pad("PROJECT", 21)}${pad("LAST RUN", 13)}${pad("STATUS", 14)}${pad("TASKS", 14)}MERGE`;
+  const lines = [chalk4.bold(header)];
+  for (const s of summaries) {
+    if (!s.runId || !s.startedAt) {
+      const line = `${pad(s.projectId, 21)}${pad("never", 13)}${pad("\u2014", 14)}${pad("\u2014", 14)}\u2014`;
+      lines.push(chalk4.dim(line));
+      continue;
+    }
+    const timeStr = relativeTime(s.startedAt);
+    const statusStr = s.status ?? "\u2014";
+    let tasksStr;
+    if (s.failed > 0) {
+      tasksStr = `${s.completed}/${s.total} (${s.failed} fail)`;
+    } else if (s.completed === s.total && s.total > 0) {
+      tasksStr = `${s.completed}/${s.total} \u2713`;
+    } else {
+      tasksStr = `${s.completed}/${s.total}`;
+    }
+    const mergeStr = s.pendingMerge > 0 ? `${s.pendingMerge} pending` : "\u2014";
+    const raw = `${pad(s.projectId, 21)}${pad(timeStr, 13)}${pad(statusStr, 14)}${pad(tasksStr, 14)}${mergeStr}`;
+    if (s.failed > 0) {
+      lines.push(chalk4.yellow(raw));
+    } else if (s.completed === s.total && s.total > 0) {
+      lines.push(chalk4.green(raw));
+    } else {
+      lines.push(raw);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/commands/status.ts
+function relativeTime2(isoDate) {
+  const now = Date.now();
+  const dateStr = isoDate.endsWith("Z") ? isoDate : isoDate + "Z";
+  const then = new Date(dateStr).getTime();
+  const diffMs = now - then;
+  const diffMin = Math.floor(diffMs / 6e4);
+  const diffHr = Math.floor(diffMs / 36e5);
+  const diffDay = Math.floor(diffMs / 864e5);
+  if (diffMin < 60) return `${Math.max(diffMin, 1)}m ago`;
+  if (diffHr < 24) return `${diffHr}h ago`;
+  if (diffDay < 7) return `${diffDay}d ago`;
+  return isoDate.slice(0, 10);
+}
+function statusBadge(status) {
+  switch (status) {
+    case "completed":
+      return chalk5.green("COMPLETED");
+    case "failed":
+      return chalk5.red("FAILED");
+    case "skipped":
+      return chalk5.yellow("SKIPPED");
+    case "completed_retry":
+      return chalk5.green("COMPLETED") + chalk5.green(" (retry)");
+    default:
+      return status.toUpperCase();
+  }
+}
+function showProjectStatus(db, projectId) {
+  const project = getProject(db, projectId);
+  if (!project) {
+    console.log(chalk5.red(`Project not found: ${projectId}`));
+    return;
+  }
+  const run = getLatestRun(db, projectId);
+  if (!run) {
+    console.log(`${projectId}: No runs yet. Run: noxdev run ${projectId}`);
+    return;
+  }
+  const tasks = getTaskResults(db, run.id);
+  const timeStr = relativeTime2(run.started_at);
+  console.log(`noxdev status: ${chalk5.bold(project.display_name)}`);
+  if (run.status === "running") {
+    console.log(`Run ${run.id} \xB7 ${timeStr} \xB7 ${chalk5.cyan("running")}`);
+    console.log(chalk5.cyan(`Run in progress since ${timeStr}...`));
+  } else {
+    console.log(`Run ${run.id} \xB7 ${timeStr} \xB7 ${run.status}`);
+  }
+  const completed = run.completed ?? 0;
+  const failed = run.failed ?? 0;
+  const skipped = run.skipped ?? 0;
+  const total = run.total_tasks ?? 0;
+  console.log("");
+  console.log(
+    `Tasks: ${chalk5.green(String(completed))} completed, ${chalk5.red(String(failed))} failed, ${chalk5.yellow(String(skipped))} skipped (of ${total})`
+  );
+  if (tasks.length > 0) {
+    console.log("");
+    console.log("Commits:");
+    for (const t of tasks) {
+      const badge = statusBadge(t.status);
+      const sha = t.commit_sha || "no commit";
+      const dur = t.duration_seconds != null ? `${t.duration_seconds}s` : "";
+      console.log(`  ${t.task_id}: ${t.title}  ${badge}  ${sha}  ${dur}`);
+    }
+  }
+  const pending = getPendingMerge(db, run.id);
+  if (pending.length > 0) {
+    console.log("");
+    console.log(`Pending merge: ${pending.length} tasks awaiting review`);
+    console.log(`Next step: noxdev merge ${projectId}`);
+  }
+}
+function isRecentRun(startedAt) {
+  const dateStr = startedAt.endsWith("Z") ? startedAt : startedAt + "Z";
+  const then = new Date(dateStr).getTime();
+  const diffMs = Date.now() - then;
+  return diffMs < 24 * 36e5;
+}
+function registerStatus(program2) {
+  program2.command("status").description("Show project status").argument("[project]", "project name").option("--summary", "Show only the summary table, no per-project detail").action((project, opts) => {
+    try {
+      const db = getDb();
+      if (project) {
+        showProjectStatus(db, project);
+        return;
+      }
+      const projects = getAllProjects(db);
+      if (projects.length === 0) {
+        console.log("No projects registered. Run: noxdev init <project> --repo <path>");
+        return;
+      }
+      if (projects.length === 1 && !opts.summary) {
+        showProjectStatus(db, projects[0].id);
+        return;
+      }
+      const summaries = getAllProjectSummaries(db);
+      console.log(formatSummaryTable(summaries));
+      if (opts.summary) {
+        return;
+      }
+      const recentProjects = summaries.filter(
+        (s) => s.startedAt && isRecentRun(s.startedAt)
+      );
+      if (recentProjects.length > 0) {
+        console.log("");
+        for (const s of recentProjects) {
+          console.log("---");
+          showProjectStatus(db, s.projectId);
+        }
+      }
+    } catch (err) {
+      console.error(
+        chalk5.red(`Error: ${err instanceof Error ? err.message : String(err)}`)
+      );
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/log.ts
+import chalk6 from "chalk";
+function statusBadge2(status) {
+  switch (status) {
+    case "completed":
+      return chalk6.green("COMPLETED");
+    case "failed":
+      return chalk6.red("FAILED");
+    case "skipped":
+      return chalk6.yellow("SKIPPED");
+    case "completed_retry":
+      return chalk6.green("COMPLETED") + chalk6.green(" (retry)");
+    default:
+      return status.toUpperCase();
+  }
+}
+function showTaskLog(db, taskId) {
+  const results = db.prepare(`SELECT * FROM task_results WHERE task_id = ? ORDER BY id DESC`).all(taskId);
+  if (results.length === 0) {
+    console.log(chalk6.red(`No results found for task: ${taskId}`));
+    return;
+  }
+  const latest = results[0];
+  const taskCache = db.prepare(
+    `SELECT spec, files, verify, critic, push FROM tasks WHERE task_id = ? ORDER BY id DESC LIMIT 1`
+  ).get(taskId);
+  console.log(`noxdev log: ${chalk6.bold(taskId)} \u2014 ${latest.title}`);
+  console.log("");
+  console.log(
+    `Latest run: ${latest.run_id} \xB7 ${statusBadge2(latest.status)} \xB7 attempt ${latest.attempt}`
+  );
+  console.log("");
+  if (taskCache?.spec) {
+    console.log("Spec:");
+    for (const line of taskCache.spec.split("\n")) {
+      console.log(`  ${line}`);
+    }
+    console.log("");
+  }
+  console.log(`Files: ${taskCache?.files || "none specified"}`);
+  console.log(`Verify: ${taskCache?.verify || "none"}`);
+  console.log(
+    `Critic: ${taskCache?.critic || latest.critic_mode || "review"}  Push: ${taskCache?.push || latest.push_mode || "auto"}`
+  );
+  console.log("");
+  console.log("Execution:");
+  console.log(`  Started:   ${latest.started_at || "unknown"}`);
+  console.log(`  Finished:  ${latest.finished_at || "unknown"}`);
+  console.log(
+    `  Duration:  ${latest.duration_seconds != null ? `${latest.duration_seconds}s` : "unknown"}`
+  );
+  console.log(`  Exit code: ${latest.exit_code ?? "none"}`);
+  console.log(`  Auth mode: ${latest.auth_mode || "unknown"}`);
+  console.log(`  Commit:    ${latest.commit_sha || "none"}`);
+  console.log("");
+  console.log(`Merge: ${latest.merge_decision}`);
+  console.log("");
+  console.log("Logs:");
+  console.log(`  Dev agent:  ${latest.dev_log_file || "not available"}`);
+  console.log(`  Critic:     ${latest.critic_log_file || "not available"}`);
+  console.log(`  Diff:       ${latest.diff_file || "not available"}`);
+  if (latest.dev_log_file) {
+    console.log("");
+    console.log(`View dev agent log? Run: cat ${latest.dev_log_file}`);
+  }
+  if (results.length > 1) {
+    console.log("");
+    console.log("History:");
+    for (const r of results) {
+      const dur = r.duration_seconds != null ? `${r.duration_seconds}s` : "unknown";
+      console.log(
+        `  Run ${r.run_id}: ${statusBadge2(r.status)} \xB7 ${dur} \xB7 attempt ${r.attempt}`
+      );
+    }
+  }
+}
+function registerLog(program2) {
+  program2.command("log").description("Show task log").argument("<task-id>", "task identifier").action((taskId) => {
+    try {
+      const db = getDb();
+      showTaskLog(db, taskId);
+    } catch (err) {
+      console.error(
+        chalk6.red(
+          `Error: ${err instanceof Error ? err.message : String(err)}`
+        )
+      );
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/merge.ts
+import chalk7 from "chalk";
+import { createInterface } from "readline";
+
+// src/merge/interactive.ts
+import { execSync as execSync5 } from "child_process";
+function getMergeCandidates(db, projectId) {
+  const run = getLatestRun(db, projectId);
+  if (!run) return [];
+  const rows = db.prepare(
+    `SELECT id, task_id, title, status, commit_sha, diff_file
+       FROM task_results
+       WHERE run_id = ?
+         AND status IN ('completed', 'completed_retry')
+         AND merge_decision = 'pending'
+         AND commit_sha IS NOT NULL`
+  ).all(run.id);
+  return rows.map((r) => ({
+    taskResultId: r.id,
+    taskId: r.task_id,
+    title: r.title,
+    status: r.status,
+    commitSha: r.commit_sha,
+    diffFile: r.diff_file
+  }));
+}
+function getDiffStats(worktreeDir, commitSha) {
+  return execSync5(`git show --stat --format="" ${commitSha}`, {
+    cwd: worktreeDir,
+    encoding: "utf-8"
+  }).trim();
+}
+function getFullDiff(worktreeDir, commitSha) {
+  return execSync5(`git show ${commitSha}`, {
+    cwd: worktreeDir,
+    encoding: "utf-8"
+  });
+}
+function applyMergeDecisions(db, worktreeDir, projectGitDir, decisions) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let merged = 0;
+  let rejected = 0;
+  let skipped = 0;
+  const candidates = getMergeCandidatesForDecisions(db, decisions);
+  for (const d of decisions) {
+    if (d.decision === "rejected") {
+      const candidate = candidates.get(d.taskResultId);
+      if (candidate) {
+        execSync5(`git revert --no-commit ${candidate.commitSha}`, {
+          cwd: worktreeDir
+        });
+        execSync5(
+          `git commit -m "noxdev: revert ${d.taskId} (rejected in merge review)"`,
+          { cwd: worktreeDir }
+        );
+      }
+      updateMergeDecision(db, d.taskResultId, "rejected", now);
+      rejected++;
+    } else if (d.decision === "approved") {
+      updateMergeDecision(db, d.taskResultId, "approved", now);
+      merged++;
+    } else {
+      skipped++;
+    }
+  }
+  if (merged > 0) {
+    const run = getRunForDecisions(db, decisions, candidates);
+    const branch = getBranchFromWorktree(worktreeDir);
+    const runId = run?.id ?? "unknown";
+    execSync5(
+      `git merge ${branch} -m "noxdev: merge ${merged} approved tasks from run ${runId}"`,
+      { cwd: projectGitDir }
+    );
+  }
+  return { merged, rejected, skipped };
+}
+function getMergeCandidatesForDecisions(db, decisions) {
+  const result = /* @__PURE__ */ new Map();
+  for (const d of decisions) {
+    const row = db.prepare(`SELECT commit_sha, run_id FROM task_results WHERE id = ?`).get(d.taskResultId);
+    if (row) {
+      result.set(d.taskResultId, {
+        commitSha: row.commit_sha,
+        runId: row.run_id
+      });
+    }
+  }
+  return result;
+}
+function getRunForDecisions(db, decisions, candidates) {
+  for (const d of decisions) {
+    const c = candidates.get(d.taskResultId);
+    if (c) {
+      return db.prepare(`SELECT id FROM runs WHERE id = ?`).get(c.runId);
+    }
+  }
+  return null;
+}
+function getBranchFromWorktree(worktreeDir) {
+  return execSync5("git rev-parse --abbrev-ref HEAD", {
+    cwd: worktreeDir,
+    encoding: "utf-8"
+  }).trim();
+}
+
+// src/commands/merge.ts
+function askQuestion(rl, prompt) {
+  return new Promise((resolve2) => {
+    rl.question(prompt, (answer) => resolve2(answer.trim().toLowerCase()));
+  });
+}
+async function reviewCandidate(rl, candidate, worktreeDir) {
+  const shortSha = candidate.commitSha.slice(0, 7);
+  let diffStats = "";
+  try {
+    diffStats = getDiffStats(worktreeDir, candidate.commitSha);
+  } catch {
+    diffStats = "(diff stats unavailable)";
+  }
+  console.log("");
+  console.log(
+    `${chalk7.bold(candidate.taskId)}: ${candidate.title} [${candidate.status}]`
+  );
+  console.log(`   commit: ${shortSha}  ${diffStats}`);
+  while (true) {
+    const answer = await askQuestion(
+      rl,
+      `   ${chalk7.cyan("[a]pprove")}  ${chalk7.red("[r]eject")}  ${chalk7.yellow("[d]iff")}  ${chalk7.gray("[s]kip")}  > `
+    );
+    if (answer === "a") return "approved";
+    if (answer === "r") return "rejected";
+    if (answer === "s") return "skipped";
+    if (answer === "d") {
+      try {
+        const diff = getFullDiff(worktreeDir, candidate.commitSha);
+        console.log("");
+        console.log(diff);
+      } catch {
+        console.log("   (could not load diff)");
+      }
+      while (true) {
+        const answer2 = await askQuestion(
+          rl,
+          `   ${chalk7.cyan("[a]pprove")}  ${chalk7.red("[r]eject")}  > `
+        );
+        if (answer2 === "a") return "approved";
+        if (answer2 === "r") return "rejected";
+      }
+    }
+  }
+}
+function registerMerge(program2) {
+  program2.command("merge").description("Merge completed branches").argument("[project]", "project name").action(async (project) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    try {
+      const db = getDb();
+      let projectId;
+      if (project) {
+        projectId = project;
+      } else {
+        const projects = getAllProjects(db);
+        if (projects.length === 0) {
+          console.log(
+            "No projects registered. Run: noxdev init <project> --repo <path>"
+          );
+          return;
+        }
+        if (projects.length === 1) {
+          projectId = projects[0].id;
+        } else {
+          console.log(
+            chalk7.red(
+              "Multiple projects found. Specify one: noxdev merge <project>"
+            )
+          );
+          return;
+        }
+      }
+      const proj = getProject(db, projectId);
+      if (!proj) {
+        console.log(chalk7.red(`Project not found: ${projectId}`));
+        return;
+      }
+      const candidates = getMergeCandidates(db, projectId);
+      if (candidates.length === 0) {
+        console.log("No pending merge tasks.");
+        return;
+      }
+      const run = getLatestRun(db, projectId);
+      const runId = run?.id ?? "unknown";
+      console.log(
+        `Run ${runId}: ${chalk7.bold(String(candidates.length))} tasks pending review`
+      );
+      const decisions = [];
+      for (const candidate of candidates) {
+        const decision = await reviewCandidate(rl, candidate, proj.worktree_path);
+        decisions.push({
+          taskResultId: candidate.taskResultId,
+          taskId: candidate.taskId,
+          decision
+        });
+      }
+      const approved = decisions.filter((d) => d.decision === "approved").length;
+      const rejected = decisions.filter((d) => d.decision === "rejected").length;
+      const skipped = decisions.filter((d) => d.decision === "skipped").length;
+      console.log("");
+      console.log(
+        `Summary: ${chalk7.green(String(approved))} approved, ${chalk7.red(String(rejected))} rejected, ${chalk7.gray(String(skipped))} skipped`
+      );
+      if (approved > 0) {
+        const confirm = await askQuestion(
+          rl,
+          `Merge ${approved} approved commits to main? [y/n] `
+        );
+        if (confirm === "y") {
+          const result = applyMergeDecisions(
+            db,
+            proj.worktree_path,
+            proj.repo_path,
+            decisions
+          );
+          console.log(
+            `Merged: ${result.merged}, Rejected: ${result.rejected}, Skipped: ${result.skipped}`
+          );
+        } else {
+          console.log("Merge cancelled.");
+        }
+      }
+      console.log("Run 'git push origin main' when ready.");
+    } catch (err) {
+      console.error(
+        chalk7.red(
+          `Error: ${err instanceof Error ? err.message : String(err)}`
+        )
+      );
+      process.exitCode = 1;
+    } finally {
+      rl.close();
+    }
+  });
+}
+
+// src/commands/projects.ts
+import { existsSync as existsSync4, readFileSync as readFileSync7 } from "fs";
+import { join as join8 } from "path";
+import chalk8 from "chalk";
+function relativeTime3(isoDate) {
+  const now = Date.now();
+  const then = (/* @__PURE__ */ new Date(isoDate + "Z")).getTime();
+  const diffMs = now - then;
+  const diffMin = Math.floor(diffMs / 6e4);
+  const diffHr = Math.floor(diffMs / 36e5);
+  const diffDay = Math.floor(diffMs / 864e5);
+  if (diffMin < 60) return `${Math.max(diffMin, 1)}m ago`;
+  if (diffHr < 24) return `${diffHr}h ago`;
+  if (diffDay < 7) return `${diffDay}d ago`;
+  return isoDate.slice(0, 10);
+}
+function countPendingTasks(repoPath) {
+  const tasksPath = join8(repoPath, "TASKS.md");
+  if (!existsSync4(tasksPath)) return -1;
+  try {
+    const content = readFileSync7(tasksPath, "utf-8");
+    const matches = content.match(/^- STATUS:\s*pending/gim);
+    return matches ? matches.length : 0;
+  } catch {
+    return -1;
+  }
+}
+function pad2(str, len) {
+  return str.length >= len ? str.slice(0, len) : str + " ".repeat(len - str.length);
+}
+function registerProjects(program2) {
+  program2.command("projects").description("List all projects").action(() => {
+    try {
+      const db = getDb();
+      const rows = db.prepare(
+        `SELECT p.id, p.display_name, p.repo_path, p.worktree_path,
+                    r.started_at, r.completed, r.failed, r.status AS run_status
+             FROM projects p
+             LEFT JOIN runs r ON r.id = (
+               SELECT r2.id FROM runs r2
+               WHERE r2.project_id = p.id
+               ORDER BY r2.started_at DESC LIMIT 1
+             )
+             ORDER BY p.display_name`
+      ).all();
+      if (rows.length === 0) {
+        console.log(
+          "No projects registered. Run: noxdev init <project> --repo <path>"
+        );
+        return;
+      }
+      const header = chalk8.bold(pad2("PROJECT", 20)) + chalk8.bold(pad2("LAST RUN", 14)) + chalk8.bold(pad2("STATUS", 20)) + chalk8.bold("TASKS");
+      console.log(header);
+      console.log("-".repeat(60));
+      for (const row of rows) {
+        const project = pad2(row.display_name, 20);
+        const lastRun = row.started_at ? relativeTime3(row.started_at) : "never";
+        const lastRunCol = pad2(lastRun, 14);
+        let statusCol;
+        if (row.started_at) {
+          const c = row.completed ?? 0;
+          const f = row.failed ?? 0;
+          const plain = `${c} done / ${f} fail`;
+          const trailing = " ".repeat(Math.max(0, 20 - plain.length));
+          statusCol = `${chalk8.green(String(c))} done / ${chalk8.red(String(f))} fail${trailing}`;
+        } else {
+          statusCol = pad2("-", 20);
+        }
+        const pending = countPendingTasks(row.worktree_path);
+        const tasksCol = pending >= 0 ? String(pending) : "-";
+        console.log(`${project}${lastRunCol}${statusCol}${tasksCol}`);
+      }
+    } catch (err) {
+      console.error(
+        chalk8.red(
+          `Error: ${err instanceof Error ? err.message : String(err)}`
+        )
+      );
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/dashboard.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync5 } from "fs";
+import path from "path";
+import chalk9 from "chalk";
+import express from "express";
+function registerDashboard(program2) {
+  program2.command("dashboard").description("Launch the noxdev dashboard (API + UI)").option("--port <port>", "frontend port", "4401").option("--api-port <port>", "API port", "4400").action(async (opts) => {
+    const bundledDashboard = path.resolve(import.meta.dirname, "dashboard");
+    const monorepoDevDashboard = path.resolve(import.meta.dirname, "..", "..", "..", "packages", "dashboard");
+    const dashboardDir = existsSync5(path.join(bundledDashboard, "index.html")) ? bundledDashboard : monorepoDevDashboard;
+    if (!existsSync5(dashboardDir)) {
+      console.error(chalk9.red("Dashboard not found. Run 'pnpm build' in the noxdev monorepo first."));
+      process.exitCode = 1;
+      return;
+    }
+    const isBundled = existsSync5(path.join(dashboardDir, "index.html"));
+    if (isBundled) {
+      console.log(chalk9.bold("noxdev dashboard"));
+      console.log(`  Dashboard: http://localhost:${opts.apiPort}`);
+      console.log("  Press Ctrl+C to stop");
+      const serverUrl = new URL(path.join(dashboardDir, "api", "server.js"), "file://").href;
+      const { app } = await import(serverUrl);
+      app.use(express.static(dashboardDir));
+      app.get("*", (req, res) => {
+        res.sendFile(path.join(dashboardDir, "index.html"));
+      });
+      const server = app.listen(parseInt(opts.apiPort), () => {
+        console.log(chalk9.green(`Dashboard running on http://localhost:${opts.apiPort}`));
+      });
+      const cleanup = () => {
+        console.log(chalk9.yellow("\nShutting down dashboard..."));
+        server.close();
+        process.exit(0);
+      };
+      process.on("SIGINT", cleanup);
+      process.on("SIGTERM", cleanup);
+      await new Promise(() => {
+      });
+    } else {
+      const apiServerPath = path.join(dashboardDir, "dist", "api", "server.js");
+      if (!existsSync5(apiServerPath)) {
+        console.error(chalk9.red("Dashboard API not built. Run 'pnpm build' in the noxdev monorepo first."));
+        process.exitCode = 1;
+        return;
+      }
+      console.log(chalk9.bold("noxdev dashboard"));
+      console.log(`  API:    http://localhost:${opts.apiPort}`);
+      console.log(`  UI:     http://localhost:${opts.port}`);
+      console.log("  Press Ctrl+C to stop");
+      const processes = [];
+      const apiProcess = spawn2("node", [apiServerPath], {
+        stdio: "pipe",
+        env: { ...process.env, PORT: opts.apiPort }
+      });
+      processes.push(apiProcess);
+      const uiProcess = spawn2("npx", ["vite", "--port", opts.port, "--open"], {
+        cwd: dashboardDir,
+        stdio: "pipe"
+      });
+      processes.push(uiProcess);
+      apiProcess.stdout?.on("data", (data) => {
+        const lines = data.toString().split("\n").filter((line) => line.trim());
+        lines.forEach((line) => {
+          console.log(chalk9.blue("[API]"), line);
+        });
+      });
+      apiProcess.stderr?.on("data", (data) => {
+        const lines = data.toString().split("\n").filter((line) => line.trim());
+        lines.forEach((line) => {
+          console.log(chalk9.red("[API ERROR]"), line);
+        });
+      });
+      uiProcess.stdout?.on("data", (data) => {
+        const lines = data.toString().split("\n").filter((line) => line.trim());
+        lines.forEach((line) => {
+          console.log(chalk9.green("[UI]"), line);
+        });
+      });
+      uiProcess.stderr?.on("data", (data) => {
+        const lines = data.toString().split("\n").filter((line) => line.trim());
+        lines.forEach((line) => {
+          console.log(chalk9.yellow("[UI WARN]"), line);
+        });
+      });
+      apiProcess.on("exit", (code) => {
+        if (code !== 0) {
+          console.log(chalk9.red(`API server exited with code ${code}`));
+        }
+      });
+      uiProcess.on("exit", (code) => {
+        if (code !== 0) {
+          console.log(chalk9.red(`UI server exited with code ${code}`));
+        }
+      });
+      const cleanup = () => {
+        console.log(chalk9.yellow("\nShutting down dashboard..."));
+        processes.forEach((proc) => {
+          if (!proc.killed) {
+            proc.kill("SIGTERM");
+          }
+        });
+        process.exit(0);
+      };
+      process.on("SIGINT", cleanup);
+      process.on("SIGTERM", cleanup);
+      await Promise.race([
+        new Promise((resolve2) => apiProcess.on("exit", () => resolve2())),
+        new Promise((resolve2) => uiProcess.on("exit", () => resolve2()))
+      ]);
+      cleanup();
+    }
+  });
+}
+
+// src/commands/doctor.ts
+import { execSync as execSync6 } from "child_process";
+import { existsSync as existsSync6 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join9 } from "path";
+import chalk10 from "chalk";
+import Database2 from "better-sqlite3";
+function runCheck(name, critical, checkFn) {
+  try {
+    const result = checkFn();
+    return { name, passed: result.passed, critical, message: result.message };
+  } catch (error) {
+    return {
+      name,
+      passed: false,
+      critical,
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function formatCheckResult(result) {
+  const symbol = result.passed ? chalk10.green("\u2713") : result.critical ? chalk10.red("\u2717") : chalk10.yellow("!");
+  const message = result.message ? ` ${result.message}` : "";
+  return `[${symbol}] ${result.name}${message}`;
+}
+function registerDoctor(program2) {
+  program2.command("doctor").description("Check prerequisites for running noxdev").action(() => {
+    console.log("noxdev doctor - checking prerequisites...\n");
+    const checks = [];
+    checks.push(runCheck("Node.js version >= 18", true, () => {
+      const version2 = process.version;
+      const major = parseInt(version2.slice(1).split(".")[0]);
+      if (major >= 18) {
+        return { passed: true };
+      } else {
+        return { passed: false, message: `Node.js 18+ required, found ${version2}` };
+      }
+    }));
+    checks.push(runCheck("Docker installed", true, () => {
+      try {
+        const output = execSync6("docker --version", { encoding: "utf8" }).trim();
+        return { passed: true, message: output };
+      } catch {
+        return { passed: false, message: "Docker not found. Install: https://docs.docker.com/get-docker/" };
+      }
+    }));
+    checks.push(runCheck("Docker daemon running", true, () => {
+      try {
+        execSync6("docker info", { stdio: "pipe" });
+        return { passed: true };
+      } catch {
+        return { passed: false, message: "Docker daemon not running. Start Docker Desktop or run: sudo systemctl start docker" };
+      }
+    }));
+    checks.push(runCheck("Docker image exists", false, () => {
+      try {
+        const output = execSync6("docker images -q noxdev-runner:latest", { encoding: "utf8" }).trim();
+        if (output) {
+          return { passed: true };
+        } else {
+          return { passed: false, message: "noxdev-runner image not found. Build it with: docker build -t noxdev-runner ." };
+        }
+      } catch {
+        return { passed: false, message: "noxdev-runner image not found. Build it with: docker build -t noxdev-runner ." };
+      }
+    }));
+    checks.push(runCheck("noxdev config directory", false, () => {
+      const configDir = join9(homedir7(), ".noxdev");
+      if (existsSync6(configDir)) {
+        return { passed: true };
+      } else {
+        return { passed: false, message: "No config directory. Run: noxdev init <project>" };
+      }
+    }));
+    checks.push(runCheck("SQLite database", false, () => {
+      const dbPath = join9(homedir7(), ".noxdev", "ledger.db");
+      if (!existsSync6(dbPath)) {
+        return { passed: false, message: "No database. Run: noxdev init <project>" };
+      }
+      try {
+        const db = new Database2(dbPath, { readonly: true });
+        const result = db.prepare("SELECT count(*) as count FROM projects").get();
+        db.close();
+        return { passed: true, message: `${result.count} projects registered` };
+      } catch {
+        return { passed: false, message: "No database. Run: noxdev init <project>" };
+      }
+    }));
+    checks.push(runCheck("Git installed", true, () => {
+      try {
+        execSync6("git --version", { stdio: "pipe" });
+        return { passed: true };
+      } catch {
+        return { passed: false };
+      }
+    }));
+    checks.push(runCheck("SOPS installed", false, () => {
+      try {
+        execSync6("sops --version", { stdio: "pipe" });
+        return { passed: true };
+      } catch {
+        return { passed: false, message: "SOPS not found. Secrets encryption unavailable." };
+      }
+    }));
+    checks.push(runCheck("Claude credentials", true, () => {
+      const claudePath = join9(homedir7(), ".claude.json");
+      if (existsSync6(claudePath)) {
+        return { passed: true };
+      } else {
+        return { passed: false, message: "Claude credentials not found. Run: claude login" };
+      }
+    }));
+    for (const check of checks) {
+      console.log(formatCheckResult(check));
+    }
+    const passed = checks.filter((c) => c.passed).length;
+    const total = checks.length;
+    const criticalFailed = checks.some((c) => c.critical && !c.passed);
+    console.log(`
+${passed}/${total} checks passed. ${criticalFailed ? "Issues found" : "Ready"}`);
+    if (criticalFailed) {
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/remove.ts
+import { execSync as execSync7 } from "child_process";
+import { rmSync, existsSync as existsSync7 } from "fs";
+import readline from "readline";
+import chalk11 from "chalk";
+function askConfirmation(message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    rl.question(message, (answer) => {
+      rl.close();
+      resolve2(answer.trim().toLowerCase() === "y");
+    });
+  });
+}
+function registerRemove(program2) {
+  program2.command("remove").description("Remove a project from noxdev").argument("<project>", "project ID to remove").option("-f, --force", "Skip confirmation prompt").action(async (projectId, opts) => {
+    try {
+      await runRemove(projectId, opts.force ?? false);
+    } catch (err) {
+      console.error(
+        chalk11.red(
+          `Error: ${err instanceof Error ? err.message : String(err)}`
+        )
+      );
+      process.exitCode = 1;
+    }
+  });
+}
+async function runRemove(projectId, force) {
+  const db = getDb();
+  const project = db.prepare("SELECT id, worktree_path, repo_path FROM projects WHERE id = ?").get(projectId);
+  if (!project) {
+    console.error(chalk11.red(`\u2716 Project not found: ${projectId}`));
+    process.exit(1);
+  }
+  if (!force) {
+    console.log(chalk11.yellow(`\u26A0 This will remove project "${projectId}" from noxdev.`));
+    console.log(chalk11.gray("  SQLite records (runs, tasks, results) will be deleted."));
+    console.log(chalk11.gray(`  Worktree at ${project.worktree_path} will be removed.`));
+    console.log(chalk11.gray("  Your repo and main branch are NOT affected."));
+    console.log();
+    const confirmed = await askConfirmation("Confirm? [y/N] ");
+    if (!confirmed) {
+      console.log("Operation cancelled.");
+      return;
+    }
+  }
+  const worktreePath = project.worktree_path;
+  const repoPath = project.repo_path;
+  try {
+    execSync7(`git worktree remove "${worktreePath}" --force`, {
+      cwd: repoPath,
+      stdio: "pipe"
+    });
+  } catch {
+    try {
+      rmSync(worktreePath, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  if (!existsSync7(worktreePath)) {
+    console.log(chalk11.green(`  \u2713 Worktree removed: ${worktreePath}`));
+  }
+  db.exec("BEGIN");
+  try {
+    db.prepare("DELETE FROM task_results WHERE run_id IN (SELECT id FROM runs WHERE project_id = ?)").run(projectId);
+    db.prepare("DELETE FROM tasks WHERE run_id IN (SELECT id FROM runs WHERE project_id = ?)").run(projectId);
+    db.prepare("DELETE FROM runs WHERE project_id = ?").run(projectId);
+    db.prepare("DELETE FROM projects WHERE id = ?").run(projectId);
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+  console.log(chalk11.green(`\u2713 Project "${projectId}" removed from noxdev.`));
+}
+
+// src/index.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+var program = new Command();
+program.name("noxdev").description("Autonomous overnight coding agent orchestrator").version(version);
+registerInit(program);
+registerRun(program);
+registerStatus(program);
+registerLog(program);
+registerMerge(program);
+registerProjects(program);
+registerDashboard(program);
+registerDoctor(program);
+registerRemove(program);
+var args = process.argv.slice(2);
+var hasNoSubcommand = args.length === 0 || args.length === 1 && args[0].startsWith("-");
+if (hasNoSubcommand && !args.includes("--version") && !args.includes("-V")) {
+  console.log(chalk12.hex("#C9A84C")(BANNER(version)));
+  console.log();
+}
+program.parse();