@matthugh1/conductor-cli 0.2.0 → 0.2.3

package/dist/agent.js

@@ -1,8 +1,4 @@
 #!/usr/bin/env node
-import {
-  ensureDatabaseUrl,
-  postToServer
-} from "./chunk-MJKFQIYA.js";
 
 // ../../src/cli/agent.ts
 import { resolve } from "path";
@@ -18,6 +14,12 @@ function parseArgs(argv) {
   let consecutiveFailures = 3;
   let skipPermissions = false;
   let dryRun = false;
+  let checkInterval = 3e4;
+  let maxPerDay = 50;
+  let maxConcurrent = 1;
+  let noWorktree = false;
+  let apiUrl;
+  let apiKey;
   let command;
   let subcommand;
   for (let i = 0; i < args.length; i++) {
@@ -36,6 +38,18 @@ function parseArgs(argv) {
       skipPermissions = true;
     } else if (arg === "--dry-run") {
       dryRun = true;
+    } else if (arg === "--check-interval" && i + 1 < args.length) {
+      checkInterval = Number.parseInt(args[++i], 10);
+    } else if (arg === "--max-per-day" && i + 1 < args.length) {
+      maxPerDay = Number.parseInt(args[++i], 10);
+    } else if (arg === "--max-concurrent" && i + 1 < args.length) {
+      maxConcurrent = Number.parseInt(args[++i], 10);
+    } else if (arg === "--no-worktree") {
+      noWorktree = true;
+    } else if (arg === "--api-url" && i + 1 < args.length) {
+      apiUrl = args[++i];
+    } else if (arg === "--api-key" && i + 1 < args.length) {
+      apiKey = args[++i];
     } else if (arg === "--json") {
       json = true;
     } else if (arg === "--help" || arg === "-h") {
@@ -48,7 +62,7 @@ function parseArgs(argv) {
       subcommand = arg;
     }
   }
-  return { command, subcommand, projectRoot, project, json, help, once, maxDeliverables, timeout, consecutiveFailures, skipPermissions, dryRun };
+  return { command, subcommand, projectRoot, project, json, help, once, maxDeliverables, timeout, consecutiveFailures, skipPermissions, dryRun, checkInterval, maxPerDay, maxConcurrent, noWorktree, apiUrl, apiKey };
 }
 var HELP_TEXT = `
 Conductor \u2014 local agent CLI
@@ -62,10 +76,12 @@ Commands:
   hooks       Check hook status or install hooks
   watch       Poll for cleanup tasks and execute them locally
   run         Autonomous runner \u2014 work through deliverable queue
+  daemon      Long-running daemon \u2014 polls for autonomous work
+  daemon cancel  Stop a running daemon
 
 Options:
   --project-root <path>         Project directory (default: cwd)
-  --project <name>              Project name (for run command)
+  --project <name>              Project name (for run/daemon commands)
   --json                        Output as JSON instead of plain English
   --once                        Process one task and exit (watch only)
   --help                        Show this help text
@@ -77,6 +93,15 @@ Run options:
   --skip-permissions            Allow Claude to write files without prompting
   --dry-run                     Show queue without spawning agents
 
+Daemon options:
+  --check-interval <ms>         Poll interval in milliseconds (default: 30000)
+  --max-per-day <n>             Max tasks per day (default: 50)
+  --max-concurrent <n>          Max concurrent agent tasks (default: 1)
+  --timeout <minutes>           Max minutes per deliverable (default: 120)
+  --consecutive-failures <n>    Stop after N failures in a row (default: 3)
+  --no-worktree                 Skip git worktree isolation
+  --skip-permissions            Allow Claude to write files without prompting
+
 Examples:
   conductor check
   conductor init --project-root /path/to/project
@@ -85,6 +110,8 @@ Examples:
   conductor watch
   conductor run --project Conductor --skip-permissions
   conductor run --project Conductor --dry-run
+  conductor daemon --project Conductor
+  conductor daemon cancel --project Conductor
 `.trim();
 function writeOut(text) {
   process.stdout.write(text + "\n");
@@ -93,12 +120,10 @@ function writeErr(text) {
   process.stderr.write(text + "\n");
 }
 async function cmdCheck(projectRoot, jsonOutput) {
-  const { query: dbQuery } = await import("./db-U6Y3QJDD.js");
-  const projects = await dbQuery(
-    "SELECT id FROM projects WHERE path = $1 LIMIT 1",
-    [projectRoot]
-  );
-  if (projects.length === 0) {
+  const { createDaemonClient } = await import("./daemon-client-CTYOJMJP.js");
+  const client = createDaemonClient();
+  const project = await client.resolveProjectByPath(projectRoot);
+  if (!project) {
     if (jsonOutput) {
       writeOut(
         JSON.stringify({
@@ -113,8 +138,8 @@ async function cmdCheck(projectRoot, jsonOutput) {
     }
     return 1;
   }
-  const { getEnvironmentHealthReport } = await import("./health-CTND2ANA.js");
-  const report = await getEnvironmentHealthReport(projects[0].id);
+  const projectId = project.id;
+  const report = await runLocalHealthChecks(projectRoot);
   if (jsonOutput) {
     writeOut(JSON.stringify(report, null, 2));
   } else {
@@ -126,18 +151,15 @@ async function cmdCheck(projectRoot, jsonOutput) {
     }
   }
   try {
-    const { saveHealthSnapshot } = await import("./health-snapshots-6MUVHE3G.js");
-    await saveHealthSnapshot(projects[0].id, report);
+    await client.saveHealthSnapshot(projectId, report);
   } catch {
-    const posted = await postToServer("/api/environment/health", { report }, projectRoot);
-    if (!posted && !jsonOutput) {
+    if (!jsonOutput) {
       writeErr("\u26A0 Could not sync results to the dashboard.");
     }
   }
   try {
-    const { getGitBranchInfo, formatGitBranchLine, getStatusSummary, getRecentCommits } = await import("./git-wrapper-DVJ46TMA.js");
-    const { getHookStatus } = await import("./git-hooks-UZJ6AER4.js");
-    const { saveGitStatusSnapshot } = await import("./git-snapshots-N3FBS7T3.js");
+    const { getGitBranchInfo, formatGitBranchLine, getStatusSummary, getRecentCommits, runGit } = await import("./git-wrapper-QRZYTYCZ.js");
+    const { getHookStatus } = await import("./git-hooks-RQ6WJQS4.js");
     const branchInfo = await getGitBranchInfo(projectRoot);
     const branchLine = formatGitBranchLine(branchInfo);
     const status = await getStatusSummary(projectRoot);
@@ -151,21 +173,20 @@ async function cmdCheck(projectRoot, jsonOutput) {
       hookStatus = await getHookStatus(projectRoot);
     } catch {
     }
-    const worktreeRows = await dbQuery(
-      "SELECT branch_name, worktree_path FROM worktrees WHERE project_id = $1 AND status = 'active'",
-      [projects[0].id]
-    );
     const worktreeCommits = {};
-    const { runGit } = await import("./git-wrapper-DVJ46TMA.js");
-    for (const wt of worktreeRows) {
-      try {
-        const out = await runGit(wt.worktree_path, ["log", "-1", "--format=%cI"]);
-        const date = out.trim();
-        if (date) worktreeCommits[wt.branch_name] = date;
-      } catch {
+    try {
+      const worktrees = await client.listActiveWorktrees(projectId);
+      for (const wt of worktrees) {
+        try {
+          const out = await runGit(wt.worktreePath, ["log", "-1", "--format=%cI"]);
+          const date = out.trim();
+          if (date) worktreeCommits[wt.branchName] = date;
+        } catch {
+        }
       }
+    } catch {
     }
-    await saveGitStatusSnapshot(projects[0].id, {
+    await client.saveGitStatusSnapshot(projectId, {
       branch: branchInfo.branchName,
       branchLine,
       status,
@@ -187,17 +208,16 @@ async function cmdCheck(projectRoot, jsonOutput) {
     }
   }
   try {
-    const { getGitBranchInfo } = await import("./git-wrapper-DVJ46TMA.js");
-    const { getBranchOverview } = await import("./branch-overview-XVHTGFCJ.js");
-    const { saveBranchOverviewSnapshot } = await import("./git-snapshots-N3FBS7T3.js");
+    const { getGitBranchInfo } = await import("./git-wrapper-QRZYTYCZ.js");
+    const { getBranchOverview } = await import("./branch-overview-RRHX3XGY.js");
     const branchInfo = await getGitBranchInfo(projectRoot);
     let currentBranch = branchInfo.branchName;
     if (currentBranch?.startsWith("detached (")) currentBranch = null;
     const overview = await getBranchOverview(projectRoot, {
-      projectId: projects[0].id,
+      projectId: null,
       currentBranch
     });
-    await saveBranchOverviewSnapshot(projects[0].id, overview);
+    await client.saveBranchOverviewSnapshot(projectId, overview);
     if (!jsonOutput) {
       writeOut(`Branches: ${overview.branches.length} found`);
     }
@@ -213,14 +233,73 @@ async function cmdCheck(projectRoot, jsonOutput) {
   if (hasWarn) return 2;
   return 0;
 }
+async function runLocalHealthChecks(projectRoot) {
+  const { existsSync } = await import("fs");
+  const { readFile } = await import("fs/promises");
+  const { join } = await import("path");
+  const { runGit } = await import("./git-wrapper-QRZYTYCZ.js");
+  const start = performance.now();
+  const checks = [];
+  const gitStart = performance.now();
+  try {
+    const output = await runGit(projectRoot, ["--version"]);
+    const version = output.trim().replace("git version ", "");
+    checks.push({ name: "Git", status: "pass", message: `Git ${version} found`, durationMs: Math.round(performance.now() - gitStart) });
+  } catch {
+    checks.push({ name: "Git", status: "fail", message: "Git not found or not working", durationMs: Math.round(performance.now() - gitStart) });
+  }
+  const hookStart = performance.now();
+  const hookPath = join(projectRoot, ".git", "hooks", "post-commit");
+  const CONDUCTOR_HOOK_MARKER = "# Conductor narration hook";
+  if (!existsSync(hookPath)) {
+    checks.push({
+      name: "Hooks",
+      status: "warn",
+      message: "Hooks not installed",
+      fixAction: { label: "Install hooks", href: "/git" },
+      durationMs: Math.round(performance.now() - hookStart)
+    });
+  } else {
+    try {
+      const content = await readFile(hookPath, "utf-8");
+      if (content.includes(CONDUCTOR_HOOK_MARKER)) {
+        checks.push({ name: "Hooks", status: "pass", message: "Hooks installed", durationMs: Math.round(performance.now() - hookStart) });
+      } else {
+        checks.push({
+          name: "Hooks",
+          status: "warn",
+          message: "Hook file exists but is not a Conductor hook",
+          fixAction: { label: "Install hooks", href: "/git" },
+          durationMs: Math.round(performance.now() - hookStart)
+        });
+      }
+    } catch {
+      checks.push({ name: "Hooks", status: "warn", message: "Could not read hook file", durationMs: Math.round(performance.now() - hookStart) });
+    }
+  }
+  const apiStart = performance.now();
+  try {
+    const { createDaemonClient } = await import("./daemon-client-CTYOJMJP.js");
+    await createDaemonClient().resolveProjectByPath(projectRoot);
+    checks.push({ name: "API", status: "pass", message: "Conductor server reachable", durationMs: Math.round(performance.now() - apiStart) });
+  } catch {
+    checks.push({ name: "API", status: "warn", message: "Conductor server not reachable", durationMs: Math.round(performance.now() - apiStart) });
+  }
+  const hasFail = checks.some((c) => c.status === "fail");
+  const hasWarn = checks.some((c) => c.status === "warn");
+  const overall = hasFail ? "unhealthy" : hasWarn ? "degraded" : "healthy";
+  return {
+    checks,
+    overall,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    totalDurationMs: Math.round(performance.now() - start)
+  };
+}
 async function cmdScan(projectRoot, jsonOutput) {
-  const { scanWorktrees } = await import("./worktree-manager-QKRBTPVC.js");
-  const { query: dbQuery } = await import("./db-U6Y3QJDD.js");
-  const projects = await dbQuery(
-    "SELECT id FROM projects WHERE path = $1 LIMIT 1",
-    [projectRoot]
-  );
-  if (projects.length === 0) {
+  const { createDaemonClient } = await import("./daemon-client-CTYOJMJP.js");
+  const client = createDaemonClient();
+  const project = await client.resolveProjectByPath(projectRoot);
+  if (!project) {
     if (jsonOutput) {
       writeOut(
         JSON.stringify({
@@ -235,8 +314,7 @@ async function cmdScan(projectRoot, jsonOutput) {
     }
     return 1;
   }
-  const projectId = projects[0].id;
-  const result = await scanWorktrees(projectId, projectRoot);
+  const { scan: result } = await client.scanWorktreesViaApi(project.id);
   if (jsonOutput) {
     writeOut(JSON.stringify(result, null, 2));
   } else {
@@ -262,7 +340,7 @@ async function cmdScan(projectRoot, jsonOutput) {
 async function cmdInit(projectRoot, jsonOutput) {
   const { resolve: resolvePath, basename, join } = await import("path");
   const { realpath, mkdir, readFile, writeFile, access } = await import("fs/promises");
-  const { getServerBaseUrl } = await import("./cli-config-TDSTAXIA.js");
+  const { getServerBaseUrl } = await import("./cli-config-LEERSU5N.js");
   let root = resolvePath(projectRoot.trim());
   try {
     root = await realpath(root);
@@ -337,7 +415,7 @@ async function cmdInit(projectRoot, jsonOutput) {
   return 0;
 }
 async function cmdHooks(projectRoot, subcommand, jsonOutput) {
-  const { getHookStatus, installHooks } = await import("./git-hooks-UZJ6AER4.js");
+  const { getHookStatus, installHooks } = await import("./git-hooks-RQ6WJQS4.js");
   if (subcommand === "install") {
     const result = await installHooks(projectRoot);
     if (jsonOutput) {
@@ -379,13 +457,11 @@ async function cmdHooks(projectRoot, subcommand, jsonOutput) {
   return 2;
 }
 async function cmdWatch(projectRoot, once, jsonOutput) {
-  const { claimNextTask, executeTask, failStaleTasks } = await import("./cli-tasks-NW3BONXC.js");
-  const { query: dbQuery } = await import("./db-U6Y3QJDD.js");
-  const projects = await dbQuery(
-    "SELECT id FROM projects WHERE path = $1 LIMIT 1",
-    [projectRoot]
-  );
-  if (projects.length === 0) {
+  const { createDaemonClient } = await import("./daemon-client-CTYOJMJP.js");
+  const { runGit } = await import("./git-wrapper-QRZYTYCZ.js");
+  const client = createDaemonClient();
+  const project = await client.resolveProjectByPath(projectRoot);
+  if (!project) {
     if (jsonOutput) {
       writeOut(
         JSON.stringify({
@@ -400,13 +476,56 @@ async function cmdWatch(projectRoot, once, jsonOutput) {
     }
     return 1;
   }
-  const projectId = projects[0].id;
-  const staleCount = await failStaleTasks(projectId);
+  const projectId = project.id;
+  async function executeTaskViaApi(task) {
+    try {
+      switch (task.taskType) {
+        case "remove_worktree": {
+          const worktreeId = task.payload.worktreeId;
+          if (!worktreeId) {
+            const msg = "Missing worktreeId in task payload.";
+            await client.failCliTask(task.id, msg);
+            return msg;
+          }
+          await client.removeWorktreeViaApi(projectId, worktreeId);
+          await client.completeCliTask(task.id, { worktreeId });
+          return `Removed worktree ${worktreeId}`;
+        }
+        case "delete_branch": {
+          const branchName = task.payload.branchName;
+          if (!branchName) {
+            const msg = "Missing branchName in task payload.";
+            await client.failCliTask(task.id, msg);
+            return msg;
+          }
+          await runGit(projectRoot, ["branch", "-D", branchName]);
+          await client.logGitActivityViaApi({
+            projectRoot,
+            eventType: "branch_delete",
+            branch: branchName,
+            summary: `Deleted branch "${branchName}"`
+          });
+          await client.completeCliTask(task.id, { branchName });
+          return `Deleted branch "${branchName}"`;
+        }
+        default: {
+          const msg = `Unknown task type: ${task.taskType}`;
+          await client.failCliTask(task.id, msg);
+          return msg;
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      await client.failCliTask(task.id, msg);
+      return `Failed: ${msg}`;
+    }
+  }
+  const staleCount = await client.failStaleCliTasks(projectId);
   if (staleCount > 0 && !jsonOutput) {
     writeOut(`Auto-failed ${staleCount} stale task(s).`);
   }
   if (once) {
-    const task = await claimNextTask(projectId);
+    const task = await client.claimNextCliTask(projectId);
     if (!task) {
       if (jsonOutput) {
         writeOut(JSON.stringify({ message: "No pending tasks." }));
@@ -415,7 +534,7 @@ async function cmdWatch(projectRoot, once, jsonOutput) {
       }
       return 0;
     }
-    const summary = await executeTask(task);
+    const summary = await executeTaskViaApi(task);
     if (jsonOutput) {
       writeOut(JSON.stringify({ taskId: task.id, taskType: task.taskType, summary }));
     } else {
@@ -437,9 +556,9 @@ async function cmdWatch(projectRoot, once, jsonOutput) {
   process.on("SIGTERM", shutdown);
   while (running) {
     try {
-      const task = await claimNextTask(projectId);
+      const task = await client.claimNextCliTask(projectId);
       if (task) {
-        const summary = await executeTask(task);
+        const summary = await executeTaskViaApi(task);
         if (jsonOutput) {
           writeOut(
             JSON.stringify({ taskId: task.id, taskType: task.taskType, summary })
@@ -448,7 +567,7 @@ async function cmdWatch(projectRoot, once, jsonOutput) {
           writeOut(`[${task.taskType}] ${summary}`);
         }
       }
-      await failStaleTasks(projectId);
+      await client.failStaleCliTasks(projectId);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       if (!jsonOutput) {
@@ -464,24 +583,22 @@ async function cmdWatch(projectRoot, once, jsonOutput) {
 async function cmdRun(opts) {
   const { spawn } = await import("child_process");
   const { readFileSync, existsSync } = await import("fs");
-  const { assembleAutonomousPrompt } = await import("./runner-prompt-2B6EXGN6.js");
-  const { computeWorkQueue } = await import("./work-queue-YE5P4S7R.js");
-  const { query: dbQuery } = await import("./db-U6Y3QJDD.js");
-  let project = opts.projectName ?? opts.projectRoot;
-  if (opts.projectName) {
-    const rows = await dbQuery(
-      "SELECT path FROM projects WHERE name = $1 LIMIT 1",
-      [opts.projectName]
-    );
-    if (rows.length === 0) {
-      writeErr(`Project "${opts.projectName}" not found in Conductor.`);
-      return 1;
-    }
-    if (rows[0].path === null) {
-      writeErr(`Project "${opts.projectName}" has no local path registered.`);
-      return 1;
-    }
-    project = rows[0].path;
+  const { assembleAutonomousPrompt } = await import("./runner-prompt-MOOPKA5P.js");
+  const { createDaemonClient } = await import("./daemon-client-CTYOJMJP.js");
+  const client = createDaemonClient();
+  let project;
+  let projectId;
+  try {
+    const resolved = await client.resolveProject({
+      name: opts.projectName,
+      path: opts.projectName ? void 0 : opts.projectRoot
+    });
+    project = resolved.path;
+    projectId = resolved.id;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    writeErr(`Project not found: ${msg}`);
+    return 1;
   }
   function ts() {
     return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
@@ -525,7 +642,7 @@ async function cmdRun(opts) {
     });
   }
   async function getNextItem(skipIds) {
-    const queue = await computeWorkQueue(project, 50, { autonomous: true });
+    const queue = await client.pollWorkQueue(projectId, 50, { autonomous: true });
     for (const item of queue.queue) {
       if (item.type === "deliverable" && (item.tier === "ready" || item.tier === "active") && !skipIds.has(item.entityId)) {
         return item;
@@ -647,13 +764,6 @@ async function main() {
     writeOut(HELP_TEXT);
     process.exit(parsed.help ? 0 : 1);
   }
-  const hasDb = await ensureDatabaseUrl();
-  if (!hasDb) {
-    writeErr(
-      "Could not find a database connection. Make sure the MCP server is running (npm run mcp) and try again."
-    );
-    process.exit(1);
-  }
   try {
     let exitCode;
     switch (parsed.command) {
@@ -692,6 +802,34 @@ async function main() {
           jsonOutput: parsed.json
         });
         break;
+      case "daemon": {
+        const { cmdDaemon, cmdDaemonCancel } = await import("./daemon-ZJDZIP3R.js");
+        if (parsed.subcommand === "cancel") {
+          exitCode = await cmdDaemonCancel(
+            parsed.projectRoot,
+            parsed.project,
+            parsed.json,
+            parsed.apiUrl,
+            parsed.apiKey
+          );
+        } else {
+          exitCode = await cmdDaemon({
+            projectRoot: parsed.projectRoot,
+            projectName: parsed.project,
+            apiUrl: parsed.apiUrl,
+            apiKey: parsed.apiKey,
+            checkInterval: parsed.checkInterval,
+            maxPerDay: parsed.maxPerDay,
+            maxConsecutiveFailures: parsed.consecutiveFailures,
+            timeout: parsed.timeout,
+            maxConcurrent: parsed.maxConcurrent,
+            noWorktree: parsed.noWorktree,
+            skipPermissions: parsed.skipPermissions,
+            jsonOutput: parsed.json
+          });
+        }
+        break;
+      }
       default:
         writeErr(`Unknown command: ${parsed.command}`);
         writeErr("Run conductor --help for usage.");

package/dist/{chunk-IHARLSA6.js → branch-overview-RRHX3XGY.js}

@@ -1,10 +1,8 @@
 #!/usr/bin/env node
 import {
+  ConductorError,
   runGit
-} from "./chunk-FAZ7FCZQ.js";
-import {
-  query
-} from "./chunk-PANC6BTV.js";
+} from "./chunk-N2KKNG4C.js";
 
 // ../../src/core/branch-overview-match.ts
 function slugifyTitle(title) {
@@ -71,6 +69,114 @@ function resolveDeliverableLink(branchName, hints, sessionByBranch) {
   return null;
 }
 
+// ../../src/core/db.ts
+import { Pool } from "pg";
+var pool = null;
+function getDatabaseUrl() {
+  const url = process.env.DATABASE_URL;
+  if (!url) {
+    throw new ConductorError(
+      "DB_UNREACHABLE" /* DB_UNREACHABLE */,
+      "DATABASE_URL is not set. Set it to your Supabase (or other Postgres) connection string."
+    );
+  }
+  return url;
+}
+function getPool() {
+  if (pool) {
+    return pool;
+  }
+  const connectionString = getDatabaseUrl();
+  const isRemote = connectionString.includes("supabase.co");
+  pool = new Pool({
+    connectionString,
+    max: 10,
+    connectionTimeoutMillis: 5e3,
+    idleTimeoutMillis: 3e4,
+    ...isRemote ? { ssl: { rejectUnauthorized: false } } : {}
+  });
+  pool.on("error", () => {
+    console.error(
+      "Unexpected database error on an idle connection. Check that Postgres is running."
+    );
+  });
+  return pool;
+}
+var TRANSIENT_CODES = /* @__PURE__ */ new Set(["ECONNRESET", "ECONNREFUSED", "ETIMEDOUT"]);
+function isTransientConnectionError(err) {
+  const code = getErrorCode(err);
+  if (code && TRANSIENT_CODES.has(code)) return true;
+  const msg = err instanceof Error ? err.message : String(err);
+  return msg.includes("ECONNRESET") || msg.includes("ECONNREFUSED") || msg.includes("ETIMEDOUT") || msg.includes("connection terminated unexpectedly");
+}
+async function query(sql, params) {
+  const p = getPool();
+  try {
+    const result = await p.query(sql, params);
+    return result.rows;
+  } catch (err) {
+    if (isTransientConnectionError(err)) {
+      await new Promise((r) => setTimeout(r, 1e3));
+      try {
+        const result = await p.query(sql, params);
+        return result.rows;
+      } catch (retryErr) {
+        throw mapDbError(retryErr);
+      }
+    }
+    throw mapDbError(err);
+  }
+}
+function getErrorCode(err) {
+  if (err !== null && typeof err === "object" && "code" in err) {
+    const code = err.code;
+    return typeof code === "string" ? code : void 0;
+  }
+  return void 0;
+}
+function getBestErrorMessage(err) {
+  if (err instanceof AggregateError && err.errors.length > 0) {
+    const first = err.errors[0];
+    if (first instanceof Error && first.message.trim().length > 0) {
+      return first.message;
+    }
+  }
+  if (err instanceof Error && err.message.trim().length > 0) {
+    return err.message;
+  }
+  return String(err);
+}
+function mapDbError(err) {
+  const code = getErrorCode(err);
+  const message = getBestErrorMessage(err);
+  if (code === "ECONNREFUSED" || code === "ECONNRESET" || code === "ETIMEDOUT" || message.includes("ECONNREFUSED") || message.includes("ECONNRESET") || message.includes("ETIMEDOUT") || message.includes("connect ECONNREFUSED") || message.includes("connection terminated unexpectedly")) {
+    return new ConductorError(
+      "DB_UNREACHABLE" /* DB_UNREACHABLE */,
+      "Could not reach the database. Postgres may not be running on this machine.",
+      true
+    );
+  }
+  if (message.includes("password") || message.includes("authentication") || message.includes("28P01")) {
+    return new ConductorError(
+      "DB_QUERY_FAILED" /* DB_QUERY_FAILED */,
+      "Could not sign in to the database. Check your username and password."
+    );
+  }
+  if (message.includes("does not exist") && message.includes("database")) {
+    return new ConductorError(
+      "DB_QUERY_FAILED" /* DB_QUERY_FAILED */,
+      "That database does not exist yet. Create it first, then try again."
+    );
+  }
+  if (message.trim().length > 0) {
+    return new ConductorError("DB_QUERY_FAILED" /* DB_QUERY_FAILED */, message);
+  }
+  return new ConductorError(
+    "DB_QUERY_FAILED" /* DB_QUERY_FAILED */,
+    "Something went wrong while talking to the database."
+  );
+}
+
 // ../../src/core/branch-overview.ts
 var STALE_MS = 7 * 24 * 60 * 60 * 1e3;
 var MAX_COMMITS = 20;
@@ -339,8 +445,9 @@ async function getConflictBranchesForWorkQueue(projectRoot, options) {
     }
   }
   const conflicts = [];
+  const SKIP_BRANCHES = /* @__PURE__ */ new Set(["dev", "develop", "staging"]);
   for (const name of namesToScan) {
-    if (name === defaultBranch) {
+    if (name === defaultBranch || SKIP_BRANCHES.has(name)) {
       continue;
     }
     let lastIso = "";
@@ -595,11 +702,10 @@ async function getMergeStats(projectRoot, defaultBranch, featureBranch) {
   const files = await loadChangedFiles(projectRoot, defaultBranch, featureBranch);
   return { commitCount, fileCount: files.length };
 }
-
 export {
-  isBranchFullyOnMain,
-  getConflictBranchesForWorkQueue,
-  getBranchOverview,
   assertCanQueueMerge,
-  getMergeStats
+  getBranchOverview,
+  getConflictBranchesForWorkQueue,
+  getMergeStats,
+  isBranchFullyOnMain
 };