@eugene218/noxdev 1.0.0 → 1.0.2

package/dist/index.js

@@ -1,38 +1,23 @@
 #!/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";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/db/migrate.ts
-var SCHEMA = `
+function migrate(db) {
+  db.exec(SCHEMA);
+}
+var SCHEMA;
+var init_migrate = __esm({
+  "src/db/migrate.ts"() {
+    "use strict";
+    SCHEMA = `
 CREATE TABLE IF NOT EXISTS projects (
   id TEXT PRIMARY KEY,
   display_name TEXT NOT NULL,
@@ -105,14 +90,14 @@ CREATE TABLE IF NOT EXISTS tasks (
   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;
+import Database from "better-sqlite3";
+import { mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
 function getDb() {
   if (_db) return _db;
   mkdirSync(DB_DIR, { recursive: true });
@@ -122,231 +107,15 @@ function getDb() {
   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;
+var DB_DIR, DB_PATH, _db;
+var init_db = __esm({
+  "src/db/index.ts"() {
+    "use strict";
+    init_migrate();
+    DB_DIR = join(homedir(), ".noxdev");
+    DB_PATH = join(DB_DIR, "ledger.db");
   }
-  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) {
@@ -391,12 +160,14 @@ function insertTaskCache(db, runId, tasks) {
   insertMany(tasks);
 }
 function insertTaskResult(db, result) {
+  const mergeDecision = result.pushMode === "auto" && (result.status === "COMPLETED" || result.status === "COMPLETED_RETRY") ? "approved" : "pending";
+  const mergedAt = mergeDecision === "approved" ? (/* @__PURE__ */ new Date()).toISOString() : null;
   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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      dev_log_file, critic_log_file, diff_file, merge_decision, merged_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
   ).run(
     result.runId,
     result.taskId,
@@ -413,12 +184,14 @@ function insertTaskResult(db, result) {
     result.durationSeconds,
     result.devLogFile,
     result.criticLogFile,
-    result.diffFile
+    result.diffFile,
+    mergeDecision,
+    mergedAt
   );
 }
 function updateMergeDecision(db, taskResultId, decision, mergedAt) {
   db.prepare(
-    `UPDATE task_results SET merge_decision = ?, merged_at = ? WHERE id = ?`
+    `UPDATE task_results SET merge_decision = LOWER(?), merged_at = ? WHERE id = ?`
   ).run(decision, mergedAt ?? null, taskResultId);
 }
 function getLatestRun(db, projectId) {
@@ -428,7 +201,7 @@ 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);
+  return db.prepare(`SELECT * FROM task_results WHERE run_id = ? AND LOWER(merge_decision) = 'pending'`).all(runId);
 }
 function getProject(db, projectId) {
   return db.prepare(`SELECT * FROM projects WHERE id = ?`).get(projectId) ?? null;
@@ -451,50 +224,21 @@ function getAllProjects(db) {
        )`
   ).all();
 }
+var init_queries = __esm({
+  "src/db/queries.ts"() {
+    "use strict";
+  }
+});
 
 // src/config/index.ts
+var config_exports = {};
+__export(config_exports, {
+  loadGlobalConfig: () => loadGlobalConfig,
+  loadProjectConfig: () => loadProjectConfig
+});
 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)) {
@@ -540,8 +284,59 @@ function loadProjectConfig(projectPath) {
   }
   return deepMerge(DEFAULT_PROJECT_CONFIG, overrides);
 }
+var DEFAULT_GLOBAL_CONFIG, DEFAULT_PROJECT_CONFIG;
+var init_config = __esm({
+  "src/config/index.ts"() {
+    "use strict";
+    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: ""
+      }
+    };
+    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"
+    };
+  }
+});
 
 // src/auth/index.ts
+var auth_exports = {};
+__export(auth_exports, {
+  getMaxCredentialPath: () => getMaxCredentialPath,
+  isMaxAvailable: () => isMaxAvailable,
+  resolveAuth: () => resolveAuth
+});
 import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
 import { execSync as execSync2 } from "child_process";
 import { homedir as homedir4 } from "os";
@@ -573,18 +368,14 @@ function resolveAuth(config) {
     "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";
+var init_auth = __esm({
+  "src/auth/index.ts"() {
+    "use strict";
+  }
+});
 
 // 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 = [];
@@ -651,11 +442,17 @@ function parseTasksFromFile(filePath, includeDone = false) {
   const content = readFileSync4(filePath, "utf-8");
   return parseTasks(content, includeDone);
 }
+var TASK_HEADER_RE, FIELD_RE;
+var init_tasks = __esm({
+  "src/parser/tasks.ts"() {
+    "use strict";
+    TASK_HEADER_RE = /^## (T\d+): (.+)$/;
+    FIELD_RE = /^- (STATUS|FILES|VERIFY|CRITIC|PUSH|SPEC): (.+)$/i;
+  }
+});
 
 // 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;
@@ -682,6 +479,14 @@ function updateTaskStatus(filePath, taskId, newStatus) {
   }
   writeFileSync2(filePath, result.content, "utf-8");
 }
+var TASK_HEADER_RE2, STATUS_LINE_RE;
+var init_status_update = __esm({
+  "src/parser/status-update.ts"() {
+    "use strict";
+    TASK_HEADER_RE2 = /^## (T\d+): /;
+    STATUS_LINE_RE = /^(- STATUS: )\w+/;
+  }
+});
 
 // src/prompts/builder.ts
 function buildTaskPrompt(ctx) {
@@ -738,14 +543,17 @@ Respond with APPROVED or REJECTED followed by a brief explanation.
 If REJECTED, explain what needs to change.
 `;
 }
+var init_builder = __esm({
+  "src/prompts/builder.ts"() {
+    "use strict";
+  }
+});
 
 // 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");
 }
@@ -792,8 +600,25 @@ function captureDiff(worktreeDir, outputFile) {
     return false;
   }
 }
+var __filename, __dirname;
+var init_runner = __esm({
+  "src/docker/runner.ts"() {
+    "use strict";
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = dirname(__filename);
+  }
+});
 
 // src/engine/orchestrator.ts
+var orchestrator_exports = {};
+__export(orchestrator_exports, {
+  executeRun: () => executeRun
+});
+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";
 function getCurrentSha(cwd) {
   return execSync3("git rev-parse HEAD", { cwd, encoding: "utf-8" }).trim();
 }
@@ -1106,8 +931,28 @@ async function runCritic(ctx, task, logDir, attempt, claudeJsonSrc, claudeSnapsh
     diffFile: diffOutputFile
   };
 }
+var init_orchestrator = __esm({
+  "src/engine/orchestrator.ts"() {
+    "use strict";
+    init_tasks();
+    init_status_update();
+    init_builder();
+    init_runner();
+    init_queries();
+  }
+});
 
 // src/commands/run.ts
+var run_exports = {};
+__export(run_exports, {
+  registerRun: () => registerRun,
+  runAllProjects: () => runAllProjects
+});
+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";
 function generateRunId() {
   const now = /* @__PURE__ */ new Date();
   const pad3 = (n) => String(n).padStart(2, "0");
@@ -1404,11 +1249,271 @@ function registerRun(program2) {
     }
   );
 }
+var init_run = __esm({
+  "src/commands/run.ts"() {
+    "use strict";
+    init_db();
+    init_queries();
+    init_config();
+    init_config();
+    init_auth();
+    init_orchestrator();
+    init_tasks();
+  }
+});
+
+// src/index.ts
+import { createRequire } from "module";
+import { Command } from "commander";
+import chalk14 from "chalk";
+
+// src/brand.ts
+var BANNER = (version2) => `    ,___,
+    [O.O]         noxdev v${version2}
+   /)   )\\        ship code while you sleep
+   " \\|/ "
+  ---m-m---`;
+
+// src/commands/init.ts
+init_db();
+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";
+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/index.ts
+init_run();
 
 // src/commands/status.ts
+init_db();
+init_queries();
 import chalk5 from "chalk";
 
 // src/engine/summary.ts
+init_queries();
 import chalk4 from "chalk";
 function getAllProjectSummaries(db) {
   const projects = getAllProjects(db);
@@ -1617,6 +1722,7 @@ function registerStatus(program2) {
 }
 
 // src/commands/log.ts
+init_db();
 import chalk6 from "chalk";
 function statusBadge2(status) {
   switch (status) {
@@ -1709,10 +1815,13 @@ function registerLog(program2) {
 }
 
 // src/commands/merge.ts
+init_db();
+init_queries();
 import chalk7 from "chalk";
 import { createInterface } from "readline";
 
 // src/merge/interactive.ts
+init_queries();
 import { execSync as execSync5 } from "child_process";
 function getMergeCandidates(db, projectId) {
   const run = getLatestRun(db, projectId);
@@ -1721,8 +1830,28 @@ function getMergeCandidates(db, projectId) {
     `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 UPPER(status) IN ('COMPLETED', 'COMPLETED_RETRY')
+         AND LOWER(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 getAutoApprovedTasks(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 UPPER(status) IN ('COMPLETED', 'COMPLETED_RETRY')
+         AND LOWER(merge_decision) = 'approved'
          AND commit_sha IS NOT NULL`
   ).all(run.id);
   return rows.map((r) => ({
@@ -1815,8 +1944,8 @@ function getBranchFromWorktree(worktreeDir) {
 
 // src/commands/merge.ts
 function askQuestion(rl, prompt) {
-  return new Promise((resolve2) => {
-    rl.question(prompt, (answer) => resolve2(answer.trim().toLowerCase()));
+  return new Promise((resolve3) => {
+    rl.question(prompt, (answer) => resolve3(answer.trim().toLowerCase()));
   });
 }
 async function reviewCandidate(rl, candidate, worktreeDir) {
@@ -1894,36 +2023,45 @@ function registerMerge(program2) {
         console.log(chalk7.red(`Project not found: ${projectId}`));
         return;
       }
-      const candidates = getMergeCandidates(db, projectId);
-      if (candidates.length === 0) {
-        console.log("No pending merge tasks.");
+      const autoApproved = getAutoApprovedTasks(db, projectId);
+      const pendingCandidates = getMergeCandidates(db, projectId);
+      if (autoApproved.length === 0 && pendingCandidates.length === 0) {
+        console.log("No 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`
-      );
+      if (autoApproved.length > 0) {
+        console.log(
+          chalk7.green(`  \u2713 ${autoApproved.length} auto-approved tasks (PUSH: auto)`)
+        );
+      }
       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
-        });
+      if (pendingCandidates.length > 0) {
+        console.log(
+          `Run ${runId}: ${chalk7.bold(String(pendingCandidates.length))} tasks pending review`
+        );
+        for (const candidate of pendingCandidates) {
+          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 interactiveApproved = 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;
+      const totalApproved = autoApproved.length + interactiveApproved;
       console.log("");
       console.log(
-        `Summary: ${chalk7.green(String(approved))} approved, ${chalk7.red(String(rejected))} rejected, ${chalk7.gray(String(skipped))} skipped`
+        `Summary: ${autoApproved.length} auto-approved, ${chalk7.green(String(interactiveApproved))} approved, ${chalk7.red(String(rejected))} rejected, ${chalk7.gray(String(skipped))} skipped`
       );
-      if (approved > 0) {
+      if (totalApproved > 0) {
         const confirm = await askQuestion(
           rl,
-          `Merge ${approved} approved commits to main? [y/n] `
+          `Merge ${totalApproved} approved commits to main? [y/n] `
         );
         if (confirm === "y") {
           const result = applyMergeDecisions(
@@ -1954,6 +2092,7 @@ function registerMerge(program2) {
 }
 
 // src/commands/projects.ts
+init_db();
 import { existsSync as existsSync4, readFileSync as readFileSync7 } from "fs";
 import { join as join8 } from "path";
 import chalk8 from "chalk";
@@ -2143,8 +2282,8 @@ function registerDashboard(program2) {
       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()))
+        new Promise((resolve3) => apiProcess.on("exit", () => resolve3())),
+        new Promise((resolve3) => uiProcess.on("exit", () => resolve3()))
       ]);
       cleanup();
     }
@@ -2211,10 +2350,10 @@ function registerDoctor(program2) {
         if (output) {
           return { passed: true };
         } else {
-          return { passed: false, message: "noxdev-runner image not found. Build it with: docker build -t noxdev-runner ." };
+          return { passed: false, message: "noxdev-runner image not found. Run: noxdev setup" };
         }
       } catch {
-        return { passed: false, message: "noxdev-runner image not found. Build it with: docker build -t noxdev-runner ." };
+        return { passed: false, message: "noxdev-runner image not found. Run: noxdev setup" };
       }
     }));
     checks.push(runCheck("noxdev config directory", false, () => {
@@ -2222,13 +2361,13 @@ function registerDoctor(program2) {
       if (existsSync6(configDir)) {
         return { passed: true };
       } else {
-        return { passed: false, message: "No config directory. Run: noxdev init <project>" };
+        return { passed: false, message: "No config directory. Run: noxdev setup" };
       }
     }));
     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>" };
+        return { passed: false, message: "No database. Run: noxdev setup" };
       }
       try {
         const db = new Database2(dbPath, { readonly: true });
@@ -2236,7 +2375,7 @@ function registerDoctor(program2) {
         db.close();
         return { passed: true, message: `${result.count} projects registered` };
       } catch {
-        return { passed: false, message: "No database. Run: noxdev init <project>" };
+        return { passed: false, message: "No database. Run: noxdev setup" };
       }
     }));
     checks.push(runCheck("Git installed", true, () => {
@@ -2278,6 +2417,7 @@ ${passed}/${total} checks passed. ${criticalFailed ? "Issues found" : "Ready"}`)
 }
 
 // src/commands/remove.ts
+init_db();
 import { execSync as execSync7 } from "child_process";
 import { rmSync, existsSync as existsSync7 } from "fs";
 import readline from "readline";
@@ -2287,10 +2427,10 @@ function askConfirmation(message) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     rl.question(message, (answer) => {
       rl.close();
-      resolve2(answer.trim().toLowerCase() === "y");
+      resolve3(answer.trim().toLowerCase() === "y");
     });
   });
 }
@@ -2357,6 +2497,489 @@ async function runRemove(projectId, force) {
   console.log(chalk11.green(`\u2713 Project "${projectId}" removed from noxdev.`));
 }
 
+// src/commands/setup.ts
+import chalk12 from "chalk";
+import { execSync as execSync8, spawnSync } from "child_process";
+import fs2 from "fs";
+import os from "os";
+import path3 from "path";
+import { createInterface as createInterface2 } from "readline";
+
+// src/lib/paths.ts
+import fs from "fs";
+import path2 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var cachedRoot = null;
+function findCliRoot() {
+  if (cachedRoot) return cachedRoot;
+  const here = path2.dirname(fileURLToPath2(import.meta.url));
+  let dir = here;
+  while (dir !== "/" && dir !== ".") {
+    const pkgPath = path2.join(dir, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        if (pkg.name === "@eugene218/noxdev" || pkg.name === "noxdev") {
+          cachedRoot = dir;
+          return dir;
+        }
+      } catch {
+      }
+    }
+    dir = path2.dirname(dir);
+  }
+  throw new Error(`Could not find noxdev CLI package root walking up from ${here}`);
+}
+function dockerfilePath() {
+  return path2.join(findCliRoot(), "docker", "Dockerfile");
+}
+function demoTasksPath() {
+  return path2.join(findCliRoot(), "templates", "demo-tasks.md");
+}
+
+// src/commands/setup.ts
+function registerSetup(program2) {
+  program2.command("setup").description("Build Docker image and prepare noxdev for first use").option("--rebuild", "Force rebuild of Docker image even if it exists").option("--yes", "Skip confirmation prompts (for scripting)").action(async (opts) => {
+    try {
+      await runSetup(opts);
+    } catch (err) {
+      console.error(
+        chalk12.red(
+          `Error: ${err instanceof Error ? err.message : String(err)}`
+        )
+      );
+      process.exitCode = 1;
+    }
+  });
+}
+async function runSetup(opts = {}) {
+  console.log(chalk12.bold("\n\u{1F989} noxdev setup\n"));
+  console.log(chalk12.cyan("Checking prerequisites...\n"));
+  const nodeVersion = process.versions.node;
+  const major = parseInt(nodeVersion.split(".")[0]);
+  if (major < 20) {
+    console.error(chalk12.red(`\u2716 Node ${process.versions.node} is too old. noxdev requires Node 20 or newer.`));
+    process.exit(1);
+  }
+  if (major >= 25) {
+    console.error(chalk12.red(`\u2716 Node ${process.versions.node} is not supported.`));
+    console.error(chalk12.gray("  noxdev depends on better-sqlite3 which lacks prebuilt binaries for Node 25+."));
+    console.error(chalk12.gray("  Install Node 22 LTS: brew install node@22 (macOS) or nvm install 22"));
+    process.exit(1);
+  }
+  if (major > 22) {
+    console.warn(chalk12.yellow(`\u26A0 Node ${process.versions.node} is untested (supported: 20.x, 22.x LTS).`));
+    console.warn(chalk12.gray("  Continuing anyway. Report issues at github.com/eugeneorlov/noxdev/issues"));
+  }
+  console.log(chalk12.green(`\u2713 Node ${nodeVersion} (supported)`));
+  try {
+    execSync8("docker --version", { stdio: "pipe" });
+    console.log(chalk12.green("\u2713 Docker installed"));
+  } catch {
+    console.error(chalk12.red("\u2716 Docker not found. Install Docker Desktop: https://www.docker.com/products/docker-desktop/"));
+    process.exit(1);
+  }
+  try {
+    execSync8("docker ps", { stdio: "pipe" });
+    console.log(chalk12.green("\u2713 Docker daemon running"));
+  } catch {
+    console.error(chalk12.red("\u2716 Docker daemon not running. Start Docker Desktop and try again."));
+    process.exit(1);
+  }
+  try {
+    execSync8("git --version", { stdio: "pipe" });
+    console.log(chalk12.green("\u2713 Git installed"));
+  } catch {
+    console.error(chalk12.red("\u2716 Git not found. Install with: brew install git (macOS) or apt install git (Linux)"));
+    process.exit(1);
+  }
+  try {
+    execSync8("claude --version", { stdio: "pipe" });
+    console.log(chalk12.green("\u2713 Claude Code CLI installed"));
+  } catch {
+    console.error(chalk12.red("\u2716 Claude Code CLI not found. Install with: npm install -g @anthropic-ai/claude-code"));
+    process.exit(1);
+  }
+  if (!opts.yes) {
+    console.log("\nThis will:");
+    console.log("  \u2022 Build the noxdev-runner Docker image (~3-5 min)");
+    console.log("  \u2022 Verify SOPS + age are installed");
+    console.log("  \u2022 Create ~/.noxdev/ config directory");
+    console.log("  \u2022 Run noxdev doctor\n");
+    const rl = createInterface2({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const answer = await new Promise((resolve3) => {
+      rl.question("Continue? [Y/n] ", (answer2) => {
+        rl.close();
+        resolve3(answer2);
+      });
+    });
+    if (answer.toLowerCase() === "n") {
+      console.log("\nSetup cancelled.");
+      process.exit(0);
+    }
+  }
+  const dockerfileLocation = dockerfilePath();
+  if (!fs2.existsSync(dockerfileLocation)) {
+    console.error(chalk12.red("\u2716 Dockerfile not found at " + dockerfileLocation));
+    console.error(chalk12.gray("  This is a noxdev install bug. Reinstall with:"));
+    console.error(chalk12.gray("  npm install -g @eugene218/noxdev"));
+    process.exit(1);
+  }
+  let imageExists = false;
+  try {
+    execSync8("docker image inspect noxdev-runner:latest", { stdio: "pipe" });
+    imageExists = true;
+  } catch {
+    imageExists = false;
+  }
+  if (imageExists && !opts.rebuild) {
+    console.log(chalk12.green("\n\u2713 Docker image already exists (use --rebuild to force)"));
+  } else {
+    const dockerfileDir = path3.dirname(dockerfileLocation);
+    console.log(chalk12.cyan("\nBuilding noxdev-runner image (this takes 3-5 minutes)...\n"));
+    const result = spawnSync("docker", ["build", "-t", "noxdev-runner:latest", dockerfileDir], {
+      stdio: "inherit"
+    });
+    if (result.status !== 0) {
+      console.error(chalk12.red("\n\u2716 Docker build failed."));
+      process.exit(1);
+    }
+    console.log(chalk12.green("\n\u2713 Docker image built successfully"));
+  }
+  let sopsInstalled = false;
+  let ageInstalled = false;
+  try {
+    execSync8("sops --version", { stdio: "pipe" });
+    sopsInstalled = true;
+  } catch {
+  }
+  try {
+    execSync8("age --version", { stdio: "pipe" });
+    ageInstalled = true;
+  } catch {
+  }
+  if (sopsInstalled && ageInstalled) {
+    console.log(chalk12.green("\n\u2713 SOPS and age installed"));
+  } else if (!sopsInstalled && !ageInstalled) {
+    console.log(chalk12.yellow("\n\u26A0 SOPS and age not installed (optional, for encrypted secrets)"));
+    if (process.platform === "darwin") {
+      console.log(chalk12.gray("  Install with: brew install sops age"));
+    } else if (process.platform === "linux") {
+      console.log(chalk12.gray("  Install with: apt install sops age (or download from GitHub)"));
+    } else {
+      console.log(chalk12.gray("  Install with: choco install sops age (or download from GitHub)"));
+    }
+  } else if (!sopsInstalled) {
+    console.log(chalk12.yellow("\n\u26A0 SOPS not installed (optional, for encrypted secrets)"));
+    if (process.platform === "darwin") {
+      console.log(chalk12.gray("  Install with: brew install sops"));
+    }
+  } else if (!ageInstalled) {
+    console.log(chalk12.yellow("\n\u26A0 age not installed (optional, for encrypted secrets)"));
+    if (process.platform === "darwin") {
+      console.log(chalk12.gray("  Install with: brew install age"));
+    }
+  }
+  const noxdevDir = path3.join(os.homedir(), ".noxdev");
+  if (!fs2.existsSync(noxdevDir)) {
+    fs2.mkdirSync(noxdevDir, { recursive: true });
+    console.log(chalk12.green("\n\u2713 Created ~/.noxdev/"));
+  } else {
+    console.log(chalk12.green("\n\u2713 ~/.noxdev/ already exists"));
+  }
+  console.log(chalk12.bold.green("\n\u2705 Setup complete.\n"));
+  console.log("Next steps:");
+  console.log("  noxdev demo                     # See noxdev build a project autonomously");
+  console.log("  noxdev init <name> --repo .     # Register an existing project\n");
+}
+
+// src/commands/demo.ts
+init_db();
+import { execSync as execSync9 } from "child_process";
+import {
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync5,
+  writeFileSync as writeFileSync5,
+  copyFileSync as copyFileSync2,
+  rmSync as rmSync2
+} from "fs";
+import { join as join10 } from "path";
+import { homedir as homedir8, tmpdir as tmpdir2 } from "os";
+import chalk13 from "chalk";
+import ora2 from "ora";
+function dumpErr(err) {
+  if (err && typeof err === "object") {
+    const e = err;
+    if (e.stderr?.length) {
+      console.error(chalk13.gray("  \u2500 stderr \u2500"));
+      console.error(chalk13.gray("  " + e.stderr.toString().trim().replace(/\n/g, "\n  ")));
+    }
+    if (e.stdout?.length) {
+      console.error(chalk13.gray("  \u2500 stdout \u2500"));
+      console.error(chalk13.gray("  " + e.stdout.toString().trim().replace(/\n/g, "\n  ")));
+    }
+  }
+}
+function registerDemo(program2) {
+  program2.command("demo").description("Scaffold a fresh Vite + React + TypeScript project and run noxdev demo tasks").option("--fresh", "Clean up any existing noxdev-demo project first").action(async (opts) => {
+    try {
+      await runDemo(opts);
+    } catch (err) {
+      console.error(
+        chalk13.red(
+          `Error: ${err instanceof Error ? err.message : String(err)}`
+        )
+      );
+      process.exitCode = 1;
+    }
+  });
+}
+async function runDemo(opts = {}) {
+  console.log(chalk13.bold("\n\u{1F989} noxdev demo\n"));
+  const projectName = "noxdev-demo";
+  const tempDir = join10(tmpdir2(), projectName);
+  const worktreePath = join10(homedir8(), "worktrees", projectName);
+  const branch = `noxdev/${projectName}`;
+  if (opts.fresh) {
+    console.log(chalk13.yellow("\u{1F9F9} Cleaning up existing demo project..."));
+    const db2 = getDb();
+    const existing2 = db2.prepare("SELECT id FROM projects WHERE id = ?").get(projectName);
+    if (existing2) {
+      db2.prepare("DELETE FROM projects WHERE id = ?").run(projectName);
+      console.log(chalk13.gray("  \u2713 Removed project from database"));
+    }
+    if (existsSync8(worktreePath)) {
+      rmSync2(worktreePath, { recursive: true, force: true });
+      console.log(chalk13.gray("  \u2713 Removed worktree directory"));
+    }
+    if (existsSync8(tempDir)) {
+      rmSync2(tempDir, { recursive: true, force: true });
+      console.log(chalk13.gray("  \u2713 Removed temporary directory"));
+    }
+    console.log(chalk13.green("\u2713 Cleanup complete\n"));
+  }
+  console.log(chalk13.cyan("This demo will:"));
+  console.log(chalk13.gray("  \u2022 Scaffold a fresh Vite + React + TypeScript project"));
+  console.log(chalk13.gray("  \u2022 Register it with noxdev"));
+  console.log(chalk13.gray("  \u2022 Copy demo tasks and run them autonomously"));
+  console.log(chalk13.gray("  \u2022 Show you the completed result\n"));
+  console.log(chalk13.bold("Step 1: Checking prerequisites"));
+  let dockerOk = false;
+  try {
+    const result = execSync9("docker images -q noxdev-runner:latest", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    dockerOk = result.length > 0;
+  } catch {
+  }
+  if (!dockerOk) {
+    console.error(chalk13.red("\u2716 Docker image noxdev-runner:latest not found."));
+    console.error(chalk13.yellow("  Run `noxdev setup` first to build the Docker image."));
+    process.exit(1);
+  }
+  console.log(chalk13.green("\u2713 Docker image noxdev-runner:latest found"));
+  const db = getDb();
+  const existing = db.prepare("SELECT id FROM projects WHERE id = ?").get(projectName);
+  if (existing) {
+    console.log(chalk13.yellow(`\u26A0 Project "${projectName}" already exists.`));
+    console.log(chalk13.gray("  Use --fresh to clean up and start over."));
+    console.log(chalk13.gray(`  Or run: noxdev run ${projectName}`));
+    return;
+  }
+  console.log(chalk13.bold("\nStep 2: Scaffolding Vite + React + TypeScript project"));
+  const spinner = ora2("Creating Vite project...").start();
+  try {
+    execSync9(`npm create vite@latest ${projectName} -- --template react-ts`, {
+      cwd: tmpdir2(),
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    spinner.succeed("Vite project scaffolded");
+  } catch (err) {
+    spinner.fail("Failed to scaffold Vite project");
+    dumpErr(err);
+    throw err;
+  }
+  console.log(chalk13.bold("\nStep 3: Initializing git repository"));
+  const gitSpinner = ora2("Setting up git...").start();
+  try {
+    execSync9("git init", { cwd: tempDir, stdio: ["pipe", "pipe", "pipe"] });
+    execSync9('git config user.name "noxdev"', { cwd: tempDir, stdio: ["pipe", "pipe", "pipe"] });
+    execSync9('git config user.email "noxdev@demo"', { cwd: tempDir, stdio: ["pipe", "pipe", "pipe"] });
+    execSync9("git add .", { cwd: tempDir, stdio: ["pipe", "pipe", "pipe"] });
+    execSync9('git commit -m "Initial Vite scaffold"', { cwd: tempDir, stdio: ["pipe", "pipe", "pipe"] });
+    gitSpinner.succeed("Git repository initialized");
+  } catch (err) {
+    gitSpinner.fail("Failed to initialize git repository");
+    dumpErr(err);
+    throw err;
+  }
+  console.log(chalk13.bold("\nStep 4: Registering project with noxdev"));
+  const registerSpinner = ora2("Creating worktree and registering project...").start();
+  try {
+    const defaultBranch = execSync9("git symbolic-ref --short HEAD", {
+      cwd: tempDir,
+      encoding: "utf-8"
+    }).trim();
+    execSync9(`git worktree add -b ${branch} ${worktreePath} ${defaultBranch}`, {
+      cwd: tempDir,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const projectConfig = {
+      project: projectName,
+      display_name: projectName,
+      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"
+    };
+    const configDir = join10(tempDir, ".noxdev");
+    const configPath = join10(configDir, "config.json");
+    mkdirSync5(configDir, { recursive: true });
+    writeFileSync5(configPath, JSON.stringify(projectConfig, null, 2) + "\n");
+    db.prepare(
+      `INSERT INTO projects (id, display_name, repo_path, worktree_path, branch,
+                             test_command, build_command, lint_command)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      projectName,
+      projectName,
+      tempDir,
+      worktreePath,
+      branch,
+      "pnpm test",
+      "pnpm build",
+      "pnpm lint"
+    );
+    registerSpinner.succeed("Project registered with noxdev");
+  } catch (err) {
+    registerSpinner.fail("Failed to register project");
+    dumpErr(err);
+    throw err;
+  }
+  console.log(chalk13.bold("\nStep 5: Setting up demo tasks"));
+  const tasksSpinner = ora2("Copying demo tasks template...").start();
+  try {
+    const targetTasksPath = join10(worktreePath, "TASKS.md");
+    copyFileSync2(demoTasksPath(), targetTasksPath);
+    tasksSpinner.succeed("Demo tasks copied");
+  } catch (err) {
+    tasksSpinner.fail("Failed to copy demo tasks");
+    dumpErr(err);
+    throw err;
+  }
+  console.log(chalk13.bold("\nStep 6: Installing dependencies"));
+  const depsSpinner = ora2("Installing dependencies with pnpm...").start();
+  try {
+    execSync9("pnpm install", { cwd: worktreePath, stdio: ["pipe", "pipe", "pipe"] });
+    depsSpinner.succeed("Dependencies installed");
+  } catch (err) {
+    depsSpinner.fail("Failed to install dependencies");
+    dumpErr(err);
+    throw err;
+  }
+  console.log(chalk13.bold("\nStep 7: Running noxdev demo tasks autonomously"));
+  console.log(chalk13.cyan("\u{1F989} Launching autonomous agent...\n"));
+  try {
+    const { runAllProjects: runAllProjects2 } = await Promise.resolve().then(() => (init_run(), run_exports));
+    const projectRow = {
+      id: projectName,
+      display_name: projectName,
+      repo_path: tempDir,
+      worktree_path: worktreePath,
+      branch
+    };
+    await runSingleProject(projectRow);
+  } catch (err) {
+    console.error(chalk13.red("Failed to run noxdev tasks:"), err instanceof Error ? err.message : String(err));
+    dumpErr(err);
+    throw err;
+  }
+  console.log(chalk13.bold("\n\u{1F389} Demo complete!"));
+  console.log("");
+  console.log(chalk13.green("\u2713 Vite + React + TypeScript project scaffolded"));
+  console.log(chalk13.green("\u2713 Git repository initialized"));
+  console.log(chalk13.green("\u2713 Project registered with noxdev"));
+  console.log(chalk13.green("\u2713 Demo tasks executed autonomously"));
+  console.log("");
+  console.log(chalk13.bold("What happened:"));
+  console.log(chalk13.gray("  \u2022 noxdev read the task specifications in TASKS.md"));
+  console.log(chalk13.gray("  \u2022 Claude Code built the welcome page according to specs"));
+  console.log(chalk13.gray("  \u2022 All changes were committed automatically"));
+  console.log("");
+  console.log(chalk13.bold("Next steps:"));
+  console.log(chalk13.gray(`  \u2022 View the result: cd ${worktreePath} && pnpm dev`));
+  console.log(chalk13.gray(`  \u2022 See the tasks: cat ${worktreePath}/TASKS.md`));
+  console.log(chalk13.gray(`  \u2022 Run more tasks: noxdev run ${projectName}`));
+  console.log(chalk13.gray("  \u2022 Review changes: noxdev dashboard"));
+  console.log("");
+  console.log(chalk13.cyan("\u{1F989} Welcome to autonomous development with noxdev!"));
+}
+async function runSingleProject(project) {
+  const { loadGlobalConfig: loadGlobalConfig2, loadProjectConfig: loadProjectConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const { resolveAuth: resolveAuth2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+  const { executeRun: executeRun2 } = await Promise.resolve().then(() => (init_orchestrator(), orchestrator_exports));
+  const db = getDb();
+  const globalConfig = loadGlobalConfig2();
+  const projectConfig = loadProjectConfig2(project.repo_path);
+  const auth = resolveAuth2({
+    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 = generateRunId2();
+  const gitDir = join10(project.repo_path, ".git");
+  const ctx = {
+    projectId: project.id,
+    projectConfig,
+    worktreeDir: project.worktree_path,
+    projectGitDir: gitDir,
+    gitTargetPath: gitDir,
+    runId,
+    db,
+    auth
+  };
+  await executeRun2(ctx);
+  try {
+    execSync9("git add TASKS.md", { cwd: project.worktree_path, stdio: ["pipe", "pipe", "pipe"] });
+    execSync9('git commit -m "noxdev: update task statuses"', { cwd: project.worktree_path, stdio: ["pipe", "pipe", "pipe"] });
+    console.log(chalk13.gray("  \u2713 TASKS.md status updates committed"));
+  } catch {
+  }
+}
+function generateRunId2() {
+  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("");
+}
+
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
@@ -2371,10 +2994,12 @@ registerProjects(program);
 registerDashboard(program);
 registerDoctor(program);
 registerRemove(program);
+registerSetup(program);
+registerDemo(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(chalk14.hex("#C9A84C")(BANNER(version)));
   console.log();
 }
 program.parse();