@matthugh1/conductor-cli 0.2.2 → 0.2.4

package/dist/agent.js

@@ -1,8 +1,4 @@
 #!/usr/bin/env node
-import {
-  ensureDatabaseUrl,
-  postToServer
-} from "./chunk-B2WDTKD7.js";
 
 // ../../src/cli/agent.ts
 import { resolve } from "path";
@@ -124,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({
@@ -144,8 +138,8 @@ async function cmdCheck(projectRoot, jsonOutput) {
     }
     return 1;
   }
-  const { getEnvironmentHealthReport } = await import("./health-UFK7YCKQ.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 {
@@ -157,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);
@@ -182,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,
@@ -218,17 +208,16 @@ async function cmdCheck(projectRoot, jsonOutput) {
     }
   }
   try {
-    const { getGitBranchInfo } = await import("./git-wrapper-DVJ46TMA.js");
-    const { getBranchOverview } = await import("./branch-overview-DSSCUE5F.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`);
     }
@@ -244,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-2ZUJEL3L.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({
@@ -266,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 {
@@ -293,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-2ZDXUUQN.js");
+  const { getServerBaseUrl } = await import("./cli-config-LEERSU5N.js");
   let root = resolvePath(projectRoot.trim());
   try {
     root = await realpath(root);
@@ -368,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) {
@@ -410,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-NM5D5PIZ.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({
@@ -431,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." }));
@@ -446,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 {
@@ -468,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 })
@@ -479,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) {
@@ -496,23 +584,21 @@ async function cmdRun(opts) {
   const { spawn } = await import("child_process");
   const { readFileSync, existsSync } = await import("fs");
   const { assembleAutonomousPrompt } = await import("./runner-prompt-MOOPKA5P.js");
-  const { computeWorkQueue } = await import("./work-queue-U3JYHLX2.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 { 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 });
@@ -556,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;
@@ -678,16 +764,6 @@ async function main() {
     writeOut(HELP_TEXT);
     process.exit(parsed.help ? 0 : 1);
   }
-  const needsDb = parsed.command !== "daemon";
-  if (needsDb) {
-    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) {
@@ -727,7 +803,7 @@ async function main() {
         });
         break;
       case "daemon": {
-        const { cmdDaemon, cmdDaemonCancel } = await import("./daemon-GGOJDZDB.js");
+        const { cmdDaemon, cmdDaemonCancel } = await import("./daemon-ZJDZIP3R.js");
         if (parsed.subcommand === "cancel") {
           exitCode = await cmdDaemonCancel(
             parsed.projectRoot,

package/dist/{chunk-7S5HKGS5.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;
@@ -596,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
 };

package/dist/{chunk-FAZ7FCZQ.js → chunk-N2KKNG4C.js}

@@ -1,12 +1,23 @@
 #!/usr/bin/env node
-import {
-  ConductorError
-} from "./chunk-4YEHSYVN.js";
 
 // ../../src/core/git-wrapper.ts
 import { execFile } from "child_process";
 import { randomBytes } from "crypto";
 import { promisify } from "util";
+
+// ../../src/core/errors.ts
+var ConductorError = class extends Error {
+  code;
+  retryable;
+  constructor(code, message, retryable = false) {
+    super(message);
+    this.name = "ConductorError";
+    this.code = code;
+    this.retryable = retryable;
+  }
+};
+
+// ../../src/core/git-wrapper.ts
 var execFileAsync = promisify(execFile);
 var MAX_BUFFER = 10 * 1024 * 1024;
 var READ_TIMEOUT_MS = 3e4;
@@ -520,6 +531,7 @@ async function executeNarrated(projectRoot, gitArgs) {
 }
 
 export {
+  ConductorError,
   runGit,
   getGitBranchInfo,
   formatGitBranchLine,

package/dist/{chunk-B2WDTKD7.js → cli-config-LEERSU5N.js}

@@ -123,14 +123,13 @@ async function ensureDatabaseUrl() {
   }
   return false;
 }
-
 export {
-  readConfig,
-  writeConfig,
-  readApiKey,
-  readProjectId,
-  getServerBaseUrl,
+  ensureDatabaseUrl,
   fetchConfigFromServer,
+  getServerBaseUrl,
   postToServer,
-  ensureDatabaseUrl
+  readApiKey,
+  readConfig,
+  readProjectId,
+  writeConfig
 };

package/dist/{daemon-GGOJDZDB.js → daemon-ZJDZIP3R.js}

@@ -16,7 +16,7 @@ function log(msg) {
 async function cmdDaemonCancel(projectRoot, projectName, jsonOutput, apiUrl, apiKey) {
   const { existsSync, readFileSync, unlinkSync } = await import("fs");
   const { join } = await import("path");
-  const { createDaemonClient } = await import("./daemon-client-BE64H437.js");
+  const { createDaemonClient } = await import("./daemon-client-CTYOJMJP.js");
   const resolvedUrl = apiUrl ?? process.env.CONDUCTOR_API_URL;
   const client = createDaemonClient(resolvedUrl, apiKey);
   let projectId;
@@ -66,13 +66,13 @@ async function cmdDaemonCancel(projectRoot, projectName, jsonOutput, apiUrl, api
 async function cmdDaemon(opts) {
   const { mkdirSync, writeFileSync, unlinkSync, existsSync, readFileSync } = await import("fs");
   const { join } = await import("path");
-  const { createDaemonClient } = await import("./daemon-client-BE64H437.js");
+  const { createDaemonClient } = await import("./daemon-client-CTYOJMJP.js");
   const resolvedUrl = opts.apiUrl ?? process.env.CONDUCTOR_API_URL;
   const client = createDaemonClient(resolvedUrl, opts.apiKey);
   let projectPath;
   let projectId;
   try {
-    const { readProjectId } = await import("./cli-config-2ZDXUUQN.js");
+    const { readProjectId } = await import("./cli-config-LEERSU5N.js");
     const configProjectId = readProjectId();
     if (configProjectId) {
       projectId = configProjectId;
@@ -137,7 +137,7 @@ async function cmdDaemon(opts) {
   process.on("SIGTERM", shutdown);
   let fileConfig = {};
   try {
-    const { readConfig } = await import("./cli-config-2ZDXUUQN.js");
+    const { readConfig } = await import("./cli-config-LEERSU5N.js");
     const config = readConfig(projectPath);
     fileConfig = config.daemon ?? {};
   } catch {
@@ -393,22 +393,31 @@ async function cmdDaemon(opts) {
     }
     if (daemonConfig.useWorktree && task.initiativeId) {
       try {
-        const {
-          createWorktree,
-          getWorktreeForInitiative
-        } = await import("./worktree-manager-2ZUJEL3L.js");
-        const existing = await getWorktreeForInitiative(projectId, task.initiativeId);
+        const existing = await client.getWorktreeForInitiative(projectId, task.initiativeId);
         if (existing) {
           worktreePath = existing.worktreePath;
           log(`Reusing existing worktree at ${worktreePath}`);
         } else {
-          const wt = await createWorktree(
+          const { runGit } = await import("./git-wrapper-QRZYTYCZ.js");
+          const path = await import("path");
+          const slug = (initiativeTitle ?? "unknown").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+          const branchName = slug;
+          const parentDir = path.dirname(projectPath);
+          const projectDir = path.basename(projectPath);
+          const worktreeDir = path.join(parentDir, `${projectDir}--${slug}`);
+          try {
+            await runGit(projectPath, ["rev-parse", "--verify", branchName]);
+          } catch {
+            await runGit(projectPath, ["branch", branchName]);
+          }
+          await runGit(projectPath, ["worktree", "add", worktreeDir, branchName]);
+          await client.registerWorktree({
             projectId,
-            projectPath,
-            task.initiativeId,
-            initiativeTitle ?? "unknown"
-          );
-          worktreePath = wt.worktreePath;
+            initiativeId: task.initiativeId,
+            branchName,
+            worktreePath: worktreeDir
+          });
+          worktreePath = worktreeDir;
           log(`Created worktree for "${initiativeTitle}" at ${worktreePath}`);
         }
       } catch (err) {