claude-task-worker 0.26.1 → 0.27.1

package/dist/index.js

@@ -59,41 +59,57 @@ __export(herdr_exports, {
   HERDR_TIMEOUT_MS: () => HERDR_TIMEOUT_MS,
   HerdrError: () => HerdrError,
   HerdrUnavailableError: () => HerdrUnavailableError,
+  agentGet: () => agentGet,
+  agentStart: () => agentStart,
   checkHerdrAvailable: () => checkHerdrAvailable,
+  getCurrentWorkspaceId: () => getCurrentWorkspaceId,
+  paneClose: () => paneClose,
+  paneGet: () => paneGet,
   paneProcessInfo: () => paneProcessInfo,
   paneRead: () => paneRead,
   paneSendKeys: () => paneSendKeys,
   paneSendText: () => paneSendText,
   tabClose: () => tabClose,
   tabCreate: () => tabCreate,
-  tabList: () => tabList
+  tabList: () => tabList,
+  tabRename: () => tabRename,
+  workspaceClose: () => workspaceClose,
+  workspaceCreate: () => workspaceCreate,
+  workspaceList: () => workspaceList
 });
 import { createRequire as createRequire2 } from "node:module";
+import { resolve as resolvePath } from "node:path";
 function runHerdr(args) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     childProcess2.execFile(
       "herdr",
       args,
       { timeout: HERDR_TIMEOUT_MS, killSignal: "SIGKILL" },
       (error, stdout, stderr) => {
-        let parsed;
-        try {
-          parsed = JSON.parse(stdout);
-        } catch {
-          parsed = void 0;
-        }
-        resolve2({ execError: error, parsed, stdout, stderr });
+        const parsed = parseHerdrResponse(stdout);
+        const stderrError = parsed?.error ? void 0 : parseHerdrResponse(stderr)?.error;
+        resolve3({ execError: error, parsed, stderrError, stdout, stderr });
       }
     );
   });
 }
+function parseHerdrResponse(output) {
+  try {
+    const parsed = JSON.parse(output);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
 async function execHerdr(args, options) {
-  const { execError, parsed, stdout, stderr } = await runHerdr(args);
+  const { execError, parsed, stderrError, stdout, stderr } = await runHerdr(args);
   const stderrSuffix = stderr.trim() ? `: ${stderr.trim()}` : "";
-  if (parsed?.error) {
+  const errorPayload = parsed?.error ?? stderrError;
+  if (errorPayload) {
     throw new HerdrError(
-      `herdr ${args.join(" ")} failed: [${parsed.error.code}] ${parsed.error.message}`,
-      parsed.error.code
+      `herdr ${args.join(" ")} failed: [${errorPayload.code}] ${errorPayload.message}`,
+      errorPayload.code
     );
   }
   if (execError) {
@@ -107,8 +123,29 @@ async function execHerdr(args, options) {
   }
   return parsed.result;
 }
-async function tabCreate({ label, cwd }) {
-  const result = await execHerdr(["tab", "create", "--label", label, "--cwd", cwd, "--no-focus"]);
+function envArgs(env) {
+  if (!env) return [];
+  return Object.entries(env).flatMap(([key, value]) => ["--env", `${key}=${value}`]);
+}
+function cwdArgs(cwd) {
+  return ["--cwd", resolvePath(cwd)];
+}
+async function tabCreate({
+  label,
+  cwd,
+  workspaceId,
+  env
+}) {
+  const result = await execHerdr([
+    "tab",
+    "create",
+    ...workspaceId ? ["--workspace", workspaceId] : [],
+    "--label",
+    label,
+    ...cwdArgs(cwd),
+    ...envArgs(env),
+    "--no-focus"
+  ]);
   const paneId = result?.root_pane?.pane_id;
   const tabId = result?.tab?.tab_id;
   if (!paneId || !tabId) {
@@ -116,6 +153,20 @@ async function tabCreate({ label, cwd }) {
   }
   return { paneId, tabId };
 }
+async function tabRename(tabId, label) {
+  await execHerdr(["tab", "rename", tabId, label]);
+}
+async function paneClose(paneId) {
+  await execHerdr(["pane", "close", paneId]);
+}
+async function paneGet(paneId) {
+  const result = await execHerdr(["pane", "get", paneId]);
+  const pane = result?.pane;
+  if (!pane?.pane_id) {
+    throw new Error(`Failed to get pane ${paneId}: invalid response structure from herdr`);
+  }
+  return { paneId: pane.pane_id, tabId: pane.tab_id ?? "" };
+}
 async function tabClose(tabId) {
   await execHerdr(["tab", "close", tabId]);
 }
@@ -130,6 +181,88 @@ async function tabList() {
     workspaceId: tab.workspace_id
   }));
 }
+async function workspaceCreate({
+  label,
+  cwd,
+  env
+}) {
+  const result = await execHerdr([
+    "workspace",
+    "create",
+    "--label",
+    label,
+    ...cwdArgs(cwd),
+    ...envArgs(env),
+    "--no-focus"
+  ]);
+  const workspaceId = result?.workspace?.workspace_id;
+  const paneId = result?.root_pane?.pane_id;
+  const tabId = result?.root_pane?.tab_id;
+  if (!workspaceId || !paneId || !tabId) {
+    throw new Error("Failed to create workspace: invalid response structure from herdr");
+  }
+  return { workspaceId, paneId, tabId };
+}
+async function workspaceList() {
+  const result = await execHerdr(["workspace", "list"]);
+  if (!result || !Array.isArray(result.workspaces)) {
+    return [];
+  }
+  return result.workspaces.map((workspace) => ({
+    workspaceId: workspace.workspace_id,
+    label: workspace.label ?? ""
+  }));
+}
+async function workspaceClose(workspaceId) {
+  await execHerdr(["workspace", "close", workspaceId]);
+}
+async function agentStart({
+  name,
+  cwd,
+  argv,
+  workspaceId,
+  tabId: targetTabId,
+  env
+}) {
+  const result = await execHerdr([
+    "agent",
+    "start",
+    name,
+    ...workspaceId ? ["--workspace", workspaceId] : [],
+    ...targetTabId ? ["--tab", targetTabId] : [],
+    ...cwdArgs(cwd),
+    ...envArgs(env),
+    "--no-focus",
+    "--",
+    ...argv
+  ]);
+  const paneId = result?.agent?.pane_id;
+  const tabId = result?.agent?.tab_id;
+  if (!paneId || !tabId) {
+    throw new Error("Failed to start agent: invalid response structure from herdr");
+  }
+  return { paneId, tabId };
+}
+function toAgentStatus(value) {
+  return value === "working" || value === "idle" || value === "blocked" ? value : "unknown";
+}
+async function agentGet(target) {
+  const result = await execHerdr(["agent", "get", target]);
+  const agent = result?.agent;
+  if (!agent?.pane_id) {
+    throw new Error(`Failed to get agent info for ${target}: invalid response structure from herdr`);
+  }
+  return {
+    paneId: agent.pane_id,
+    tabId: agent.tab_id ?? "",
+    workspaceId: agent.workspace_id ?? "",
+    agentStatus: toAgentStatus(agent.agent_status)
+  };
+}
+function getCurrentWorkspaceId() {
+  const id = process.env.HERDR_WORKSPACE_ID;
+  return id && id.length > 0 ? id : void 0;
+}
 function isPaneReadErrorPayload(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return false;
@@ -233,16 +366,179 @@ var init_herdr = __esm({
   }
 });
 
+// src/herdr-runner.ts
+var herdr_runner_exports = {};
+__export(herdr_runner_exports, {
+  AGENT_POLL_INTERVAL_MS: () => AGENT_POLL_INTERVAL_MS,
+  CLAUDE_EXIT_POLL_INTERVAL_MS: () => CLAUDE_EXIT_POLL_INTERVAL_MS,
+  CLAUDE_EXIT_TIMEOUT_MS: () => CLAUDE_EXIT_TIMEOUT_MS,
+  PANE_OUTPUT_LINES: () => PANE_OUTPUT_LINES,
+  buildHerdrTaskResult: () => buildHerdrTaskResult,
+  createCompletionTracker: () => createCompletionTracker,
+  observeAgentStatus: () => observeAgentStatus,
+  startHerdrTask: () => startHerdrTask,
+  stopHerdrTask: () => stopHerdrTask,
+  taskTabLabel: () => taskTabLabel,
+  waitForHerdrTask: () => waitForHerdrTask
+});
+async function loadHerdr() {
+  return await Promise.resolve().then(() => (init_herdr(), herdr_exports));
+}
+function taskTabLabel(projectName, number) {
+  return `ctw:${projectName}:#${number}`;
+}
+function createCompletionTracker() {
+  return { seenWorking: false, warnedBlocked: false };
+}
+function observeAgentStatus(tracker, status) {
+  if (status === "working") {
+    return { tracker: { ...tracker, seenWorking: true }, decision: "running" };
+  }
+  if (status === "blocked") {
+    if (tracker.warnedBlocked) return { tracker, decision: "running" };
+    return { tracker: { ...tracker, warnedBlocked: true }, decision: "blocked-first-seen" };
+  }
+  if (status === "idle" && tracker.seenWorking) {
+    return { tracker, decision: "completed" };
+  }
+  return { tracker, decision: "running" };
+}
+function buildHerdrTaskResult(paneOutput) {
+  if (paneOutput.trim() === "") {
+    return {
+      status: "failed",
+      output: "[worker] the claude session became idle but its pane produced no output (session aborted before the model ran; e.g. a skill preamble command failed)"
+    };
+  }
+  return { status: "completed", output: paneOutput };
+}
+async function startHerdrTask({
+  label,
+  cwd,
+  argv,
+  env,
+  workspaceId,
+  herdr
+}) {
+  const mod = herdr ?? await loadHerdr();
+  const { tabId, paneId: shellPaneId } = await mod.tabCreate({ label, cwd, workspaceId, env });
+  let paneId;
+  try {
+    ({ paneId } = await mod.agentStart({ name: label, cwd, argv, env, workspaceId, tabId }));
+  } catch (err) {
+    await mod.tabClose(tabId).catch(() => {
+    });
+    throw err;
+  }
+  await mod.paneClose(shellPaneId).catch((err) => {
+    console.error(`[herdr-runner] failed to close the placeholder shell pane ${shellPaneId}: ${err}`);
+  });
+  return { paneId, tabId };
+}
+async function waitForHerdrTask(paneId, options) {
+  const mod = options?.herdr ?? await loadHerdr();
+  const pollIntervalMs = options?.pollIntervalMs ?? AGENT_POLL_INTERVAL_MS;
+  let tracker = createCompletionTracker();
+  for (; ; ) {
+    if (options?.signal?.aborted) {
+      return { status: "failed", output: "[worker] the worker is shutting down; the task was interrupted" };
+    }
+    let status;
+    try {
+      status = (await mod.agentGet(paneId)).agentStatus;
+    } catch (err) {
+      if (err instanceof mod.HerdrError && err.code === "pane_not_found") {
+        return {
+          status: "failed",
+          output: "[worker] the claude pane disappeared before the task completed (claude died or the tab was closed)"
+        };
+      }
+      console.error(`[herdr-runner] failed to read agent status for pane ${paneId}: ${err}`);
+      await sleep(pollIntervalMs);
+      continue;
+    }
+    options?.onStatus?.(status);
+    const observed = observeAgentStatus(tracker, status);
+    tracker = observed.tracker;
+    if (observed.decision === "completed") {
+      const output = await readPaneOutput(paneId, mod);
+      return buildHerdrTaskResult(output);
+    }
+    if (observed.decision === "blocked-first-seen") {
+      options?.onBlocked?.();
+    }
+    await sleep(pollIntervalMs);
+  }
+}
+async function readPaneOutput(paneId, mod) {
+  try {
+    return await mod.paneRead(paneId, { source: "recent", lines: PANE_OUTPUT_LINES });
+  } catch (err) {
+    console.error(`[herdr-runner] failed to read pane ${paneId}: ${err}`);
+    return "";
+  }
+}
+async function waitForPaneGone(paneId, mod, options) {
+  const timeoutMs = options?.timeoutMs ?? CLAUDE_EXIT_TIMEOUT_MS;
+  const pollIntervalMs = options?.pollIntervalMs ?? CLAUDE_EXIT_POLL_INTERVAL_MS;
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    try {
+      await mod.paneGet(paneId);
+    } catch (err) {
+      if (err instanceof mod.HerdrError && err.code === "pane_not_found") return true;
+    }
+    if (Date.now() >= deadline) return false;
+    await sleep(pollIntervalMs);
+  }
+}
+async function stopHerdrTask(task, herdr, options) {
+  const mod = herdr ?? await loadHerdr();
+  try {
+    await mod.paneSendKeys(task.paneId, "ctrl+c", "ctrl+c");
+    const exited = await waitForPaneGone(task.paneId, mod, {
+      timeoutMs: options?.exitTimeoutMs,
+      pollIntervalMs: options?.exitPollIntervalMs
+    });
+    if (!exited) {
+      console.warn(
+        `[herdr-runner] claude did not exit in pane ${task.paneId} after ctrl-c, closing the tab forcefully`
+      );
+    }
+  } catch (err) {
+    console.error(`[herdr-runner] failed to send ctrl-c to pane ${task.paneId}: ${err}`);
+  }
+  try {
+    await mod.tabClose(task.tabId);
+  } catch (err) {
+    if (err instanceof mod.HerdrError && (err.code === "tab_not_found" || err.code === "pane_not_found")) return;
+    console.error(`[herdr-runner] failed to close tab ${task.tabId}: ${err}`);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+var AGENT_POLL_INTERVAL_MS, PANE_OUTPUT_LINES, CLAUDE_EXIT_TIMEOUT_MS, CLAUDE_EXIT_POLL_INTERVAL_MS;
+var init_herdr_runner = __esm({
+  "src/herdr-runner.ts"() {
+    "use strict";
+    AGENT_POLL_INTERVAL_MS = 3 * 1e3;
+    PANE_OUTPUT_LINES = 300;
+    CLAUDE_EXIT_TIMEOUT_MS = 15 * 1e3;
+    CLAUDE_EXIT_POLL_INTERVAL_MS = 200;
+  }
+});
+
 // src/dispatcher.ts
 var dispatcher_exports = {};
 __export(dispatcher_exports, {
+  LABEL_PREFIX: () => LABEL_PREFIX,
   PANE_READY_POLL_INTERVAL_MS: () => PANE_READY_POLL_INTERVAL_MS,
   PANE_READY_TIMEOUT_MS: () => PANE_READY_TIMEOUT_MS,
   POLL_INTERVAL_MS: () => POLL_INTERVAL_MS,
   SEND_MAX_ATTEMPTS: () => SEND_MAX_ATTEMPTS,
   SHUTDOWN_RETRY_TIMEOUT_MS: () => SHUTDOWN_RETRY_TIMEOUT_MS,
   SHUTDOWN_TIMEOUT_MS: () => SHUTDOWN_TIMEOUT_MS,
-  TAB_LABEL_PREFIX: () => TAB_LABEL_PREFIX,
   WORKER_STARTUP_POLL_INTERVAL_MS: () => WORKER_STARTUP_POLL_INTERVAL_MS,
   WORKER_STARTUP_TIMEOUT_MS: () => WORKER_STARTUP_TIMEOUT_MS,
   createDispatcherShutdownHandler: () => createDispatcherShutdownHandler,
@@ -256,21 +552,21 @@ __export(dispatcher_exports, {
   runDispatcher: () => runDispatcher,
   shutdownDispatcher: () => shutdownDispatcher,
   startWorkerInPane: () => startWorkerInPane,
-  tabLabelFor: () => tabLabelFor,
   waitForPaneReady: () => waitForPaneReady,
-  waitForWorkerStartup: () => waitForWorkerStartup
+  waitForWorkerStartup: () => waitForWorkerStartup,
+  workspaceLabelFor: () => workspaceLabelFor
 });
-async function loadHerdr() {
+async function loadHerdr2() {
   return await Promise.resolve().then(() => (init_herdr(), herdr_exports));
 }
 async function loadTable() {
   return await Promise.resolve().then(() => (init_table(), table_exports));
 }
-function tabLabelFor(projectName) {
-  return `${TAB_LABEL_PREFIX}${projectName}`;
+function workspaceLabelFor(projectName) {
+  return `${LABEL_PREFIX}${projectName}`;
 }
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+function sleep2(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 function isWorkerProcess(process2) {
   return process2.cmdline?.includes("claude-task-worker") ?? false;
@@ -286,7 +582,7 @@ async function waitForPaneReady(paneId, herdr, options) {
     const content = await herdr.paneRead(paneId, { source: "visible" });
     if (content.trim() !== "") return true;
     if (Date.now() >= deadline) return false;
-    await sleep(pollIntervalMs);
+    await sleep2(pollIntervalMs);
   }
 }
 async function waitForWorkerStartup(paneId, herdr, options) {
@@ -298,7 +594,7 @@ async function waitForWorkerStartup(paneId, herdr, options) {
     if (foregroundProcesses.some(isWorkerProcess)) return "started";
     if (foregroundProcesses.length > 0 && !foregroundProcesses.every(isShellProcess)) return "other";
     if (Date.now() >= deadline) return "shell";
-    await sleep(pollIntervalMs);
+    await sleep2(pollIntervalMs);
   }
 }
 async function startWorkerInPane(paneId, forwardedCommand, herdr, options) {
@@ -333,8 +629,8 @@ async function startWorkerInPane(paneId, forwardedCommand, herdr, options) {
   return false;
 }
 async function runDispatcher(projects, forwardedCommand, timing) {
-  const herdr = await loadHerdr();
-  const { checkHerdrAvailable: checkHerdrAvailable2, tabCreate: tabCreate2, tabClose: tabClose2, tabList: tabList2 } = herdr;
+  const herdr = await loadHerdr2();
+  const { checkHerdrAvailable: checkHerdrAvailable2, workspaceCreate: workspaceCreate2, workspaceClose: workspaceClose2, workspaceList: workspaceList2, tabRename: tabRename2 } = herdr;
   try {
     await checkHerdrAvailable2();
   } catch (error) {
@@ -342,20 +638,29 @@ async function runDispatcher(projects, forwardedCommand, timing) {
     console.error(`[dispatcher] ${message}`);
     throw error;
   }
-  const existingTabs = await tabList2();
-  const existingLabels = new Set(existingTabs.map((tab) => tab.label));
+  const existingWorkspaces = await workspaceList2();
+  const existingLabels = new Set(existingWorkspaces.map((workspace) => workspace.label));
   const sessions = /* @__PURE__ */ new Map();
   for (const project of projects) {
-    if (existingLabels.has(tabLabelFor(project.name))) {
-      console.warn(`[dispatcher] project "${project.name}" already has a running tab, skipping`);
+    const label = workspaceLabelFor(project.name);
+    if (existingLabels.has(label)) {
+      console.warn(`[dispatcher] project "${project.name}" already has a running workspace, skipping`);
       continue;
     }
-    let createdTabId;
+    let createdWorkspaceId;
     try {
-      const { paneId, tabId } = await tabCreate2({ label: tabLabelFor(project.name), cwd: project.path });
-      createdTabId = tabId;
+      const { workspaceId, tabId, paneId } = await workspaceCreate2({
+        label,
+        cwd: project.path,
+        env: { CTW_PROJECT_NAME: project.name }
+      });
+      createdWorkspaceId = workspaceId;
+      await tabRename2(tabId, label).catch(
+        (error) => console.error(`[dispatcher] failed to rename the root tab for project "${project.name}": ${error}`)
+      );
       sessions.set(project.name, {
         name: project.name,
+        workspaceId,
         tabId,
         paneId,
         startedAt: /* @__PURE__ */ new Date(),
@@ -370,24 +675,24 @@ async function runDispatcher(projects, forwardedCommand, timing) {
     } catch (error) {
       console.error(`[dispatcher] failed to dispatch project "${project.name}": ${error}`);
       sessions.delete(project.name);
-      if (createdTabId !== void 0) {
+      if (createdWorkspaceId !== void 0) {
         try {
-          await tabClose2(createdTabId);
+          await workspaceClose2(createdWorkspaceId);
         } catch (closeError) {
-          console.error(`[dispatcher] failed to close dangling tab for project "${project.name}": ${closeError}`);
+          console.error(`[dispatcher] failed to close dangling workspace for project "${project.name}": ${closeError}`);
         }
       }
     }
   }
   return sessions;
 }
-async function removeSession(sessions, name, { closeTab }) {
+async function removeSession(sessions, name, { closeWorkspace }) {
   const session = sessions.get(name);
   if (!session) return;
   sessions.delete(name);
-  if (closeTab) {
-    const { tabClose: tabClose2 } = await loadHerdr();
-    await tabClose2(session.tabId);
+  if (closeWorkspace) {
+    const { workspaceClose: workspaceClose2 } = await loadHerdr2();
+    await workspaceClose2(session.workspaceId);
   }
 }
 async function pollOnce(sessions, herdr) {
@@ -395,11 +700,11 @@ async function pollOnce(sessions, herdr) {
     try {
       const { foregroundProcesses } = await herdr.paneProcessInfo(session.paneId);
       if (!foregroundProcesses.some(isWorkerProcess)) {
-        await removeSession(sessions, name, { closeTab: true });
+        await removeSession(sessions, name, { closeWorkspace: true });
       }
     } catch (error) {
       if (error instanceof herdr.HerdrError && error.code === "pane_not_found") {
-        await removeSession(sessions, name, { closeTab: false });
+        await removeSession(sessions, name, { closeWorkspace: false });
         continue;
       }
       console.error(`[dispatcher] failed to poll session "${name}": ${error}`);
@@ -419,27 +724,27 @@ function renderSessionTable(sessions) {
   const maxProjectWidth = 20;
   const rows = entries.map((session) => ({
     project: getDisplayWidth2(session.name) > maxProjectWidth ? truncateToWidth2(session.name, maxProjectWidth) : session.name,
-    tab: session.tabId,
+    workspace: session.workspaceId,
     pane: session.paneId,
     status: session.status,
     uptime: formatUptime(session.startedAt, /* @__PURE__ */ new Date())
   }));
   const colWidths = {
     project: Math.max(7, ...rows.map((r) => getDisplayWidth2(r.project))),
-    tab: Math.max(3, ...rows.map((r) => r.tab.length)),
+    workspace: Math.max(9, ...rows.map((r) => r.workspace.length)),
     pane: Math.max(4, ...rows.map((r) => r.pane.length)),
     status: Math.max(6, ...rows.map((r) => r.status.length)),
     uptime: Math.max(6, ...rows.map((r) => r.uptime.length))
   };
-  const cols = [colWidths.project, colWidths.tab, colWidths.pane, colWidths.status, colWidths.uptime];
+  const cols = [colWidths.project, colWidths.workspace, colWidths.pane, colWidths.status, colWidths.uptime];
   const line = (l, m, r, f) => `${l}${cols.map((w) => f.repeat(w + 2)).join(m)}${r}`;
-  const row = (project, tab, pane, status, uptime) => `\u2502 ${padToWidth2(project, colWidths.project)} \u2502 ${tab.padEnd(colWidths.tab)} \u2502 ${pane.padEnd(colWidths.pane)} \u2502 ${status.padEnd(colWidths.status)} \u2502 ${uptime.padEnd(colWidths.uptime)} \u2502`;
+  const row = (project, workspace, pane, status, uptime) => `\u2502 ${padToWidth2(project, colWidths.project)} \u2502 ${workspace.padEnd(colWidths.workspace)} \u2502 ${pane.padEnd(colWidths.pane)} \u2502 ${status.padEnd(colWidths.status)} \u2502 ${uptime.padEnd(colWidths.uptime)} \u2502`;
   const lines = [];
   lines.push(line("\u250C", "\u252C", "\u2510", "\u2500"));
-  lines.push(row("Project", "Tab", "Pane", "Status", "Uptime"));
+  lines.push(row("Project", "Workspace", "Pane", "Status", "Uptime"));
   lines.push(line("\u251C", "\u253C", "\u2524", "\u2500"));
   for (const r of rows) {
-    lines.push(row(r.project, r.tab, r.pane, r.status, r.uptime));
+    lines.push(row(r.project, r.workspace, r.pane, r.status, r.uptime));
   }
   lines.push(line("\u2514", "\u2534", "\u2518", "\u2500"));
   console.clear();
@@ -449,8 +754,8 @@ function monitorSessions(sessions, herdr, options) {
   const pollIntervalMs = options?.pollIntervalMs ?? POLL_INTERVAL_MS;
   const renderIntervalMs = options?.renderIntervalMs ?? 1e3;
   let resolveDone;
-  const done = new Promise((resolve2) => {
-    resolveDone = resolve2;
+  const done = new Promise((resolve3) => {
+    resolveDone = resolve3;
   });
   let settled = false;
   const finish = () => {
@@ -492,24 +797,24 @@ async function waitUntilSessionsEmpty(sessions, herdr, pollIntervalMs, timeoutMs
     await pollOnce(sessions, herdr);
     if (sessions.size === 0) return true;
     if (Date.now() >= deadline) return false;
-    await new Promise((resolve2) => setTimeout(resolve2, pollIntervalMs));
+    await new Promise((resolve3) => setTimeout(resolve3, pollIntervalMs));
   }
   return true;
 }
-async function closeRemainingTabs(sessions, herdr, timeoutMs) {
+async function closeRemainingWorkspaces(sessions, herdr, timeoutMs) {
   const results = await Promise.all(
     [...sessions.values()].map(async (session) => {
       try {
         await Promise.race([
-          herdr.tabClose(session.tabId),
+          herdr.workspaceClose(session.workspaceId),
           new Promise((_, reject) => {
-            setTimeout(() => reject(new Error("tabClose timed out")), timeoutMs).unref();
+            setTimeout(() => reject(new Error("workspaceClose timed out")), timeoutMs).unref();
           })
         ]);
         return true;
       } catch (error) {
         console.error(
-          `[dispatcher] failed to close tab "${session.tabId}" for session "${session.name}" during shutdown: ${error}`
+          `[dispatcher] failed to close workspace "${session.workspaceId}" for session "${session.name}" during shutdown: ${error}`
         );
         return false;
       }
@@ -517,29 +822,29 @@ async function closeRemainingTabs(sessions, herdr, timeoutMs) {
   );
   return results.every((closed) => closed);
 }
-async function forceKillAllSessions(sessions, herdr, tabCloseTimeoutMs) {
+async function forceKillAllSessions(sessions, herdr, workspaceCloseTimeoutMs) {
   console.log(`[dispatcher] force-kill requested, sending ctrl-c and closing ${sessions.size} session(s) immediately`);
   await sendCtrlCToAllSessions(sessions, herdr);
-  await closeRemainingTabs(sessions, herdr, tabCloseTimeoutMs);
+  await closeRemainingWorkspaces(sessions, herdr, workspaceCloseTimeoutMs);
   process.exit(1);
 }
 async function shutdownDispatcher(sessions, monitorHandle, options) {
   if (shutdownPromise) {
     if (options?.forceKill) {
-      const herdr = options.herdr ?? await loadHerdr();
-      const tabCloseTimeoutMs = options.tabCloseTimeoutMs ?? 5e3;
-      await forceKillAllSessions(sessions, herdr, tabCloseTimeoutMs);
+      const herdr = options.herdr ?? await loadHerdr2();
+      const workspaceCloseTimeoutMs = options.workspaceCloseTimeoutMs ?? 5e3;
+      await forceKillAllSessions(sessions, herdr, workspaceCloseTimeoutMs);
       return;
     }
     console.log("[dispatcher] shutdown already in progress, ignoring duplicate request");
     return shutdownPromise;
   }
   shutdownPromise = (async () => {
-    const herdr = options?.herdr ?? await loadHerdr();
+    const herdr = options?.herdr ?? await loadHerdr2();
     const pollIntervalMs = options?.pollIntervalMs ?? POLL_INTERVAL_MS;
     const shutdownTimeoutMs = options?.shutdownTimeoutMs ?? SHUTDOWN_TIMEOUT_MS;
     const retryTimeoutMs = options?.retryTimeoutMs ?? SHUTDOWN_RETRY_TIMEOUT_MS;
-    const tabCloseTimeoutMs = options?.tabCloseTimeoutMs ?? 5e3;
+    const workspaceCloseTimeoutMs = options?.workspaceCloseTimeoutMs ?? 5e3;
     if (monitorHandle) {
       monitorHandle.stop();
       await monitorHandle.done;
@@ -554,8 +859,8 @@ async function shutdownDispatcher(sessions, monitorHandle, options) {
       await sendCtrlCToAllSessions(sessions, herdr);
       finishedInTime = await waitUntilSessionsEmpty(sessions, herdr, pollIntervalMs, retryTimeoutMs);
     }
-    const allTabsClosed = await closeRemainingTabs(sessions, herdr, tabCloseTimeoutMs);
-    process.exit(finishedInTime && allTabsClosed ? 0 : 1);
+    const allWorkspacesClosed = await closeRemainingWorkspaces(sessions, herdr, workspaceCloseTimeoutMs);
+    process.exit(finishedInTime && allWorkspacesClosed ? 0 : 1);
   })();
   try {
     await shutdownPromise;
@@ -590,7 +895,7 @@ function createDispatcherShutdownHandler(shutdown2) {
   };
   return { handle, isShuttingDown: () => shuttingDown2 };
 }
-var getDisplayWidth2, truncateToWidth2, padToWidth2, POLL_INTERVAL_MS, SHUTDOWN_TIMEOUT_MS, PANE_READY_TIMEOUT_MS, PANE_READY_POLL_INTERVAL_MS, WORKER_STARTUP_TIMEOUT_MS, WORKER_STARTUP_POLL_INTERVAL_MS, SEND_MAX_ATTEMPTS, TAB_LABEL_PREFIX, SHELL_NAME_PATTERN, SHUTDOWN_RETRY_TIMEOUT_MS, CTRL_C_KEY, shutdownPromise;
+var getDisplayWidth2, truncateToWidth2, padToWidth2, POLL_INTERVAL_MS, SHUTDOWN_TIMEOUT_MS, PANE_READY_TIMEOUT_MS, PANE_READY_POLL_INTERVAL_MS, WORKER_STARTUP_TIMEOUT_MS, WORKER_STARTUP_POLL_INTERVAL_MS, SEND_MAX_ATTEMPTS, LABEL_PREFIX, SHELL_NAME_PATTERN, SHUTDOWN_RETRY_TIMEOUT_MS, CTRL_C_KEY, shutdownPromise;
 var init_dispatcher = __esm({
   async "src/dispatcher.ts"() {
     "use strict";
@@ -602,7 +907,7 @@ var init_dispatcher = __esm({
     WORKER_STARTUP_TIMEOUT_MS = 30 * 1e3;
     WORKER_STARTUP_POLL_INTERVAL_MS = 500;
     SEND_MAX_ATTEMPTS = 3;
-    TAB_LABEL_PREFIX = "ctw:";
+    LABEL_PREFIX = "ctw:";
     SHELL_NAME_PATTERN = /^-?(zsh|bash|sh)$/;
     SHUTDOWN_RETRY_TIMEOUT_MS = 90 * 1e3;
     CTRL_C_KEY = "ctrl+c";
@@ -613,29 +918,29 @@ var init_dispatcher = __esm({
 import { createRequire } from "node:module";
 var childProcess = createRequire(import.meta.url)("node:child_process");
 function execGh(args) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     childProcess.execFile("gh", args, (error, stdout, stderr) => {
       if (error) {
         reject(new Error(`gh ${args.join(" ")} failed: ${stderr || error.message}`));
         return;
       }
-      resolve2(stdout.trim());
+      resolve3(stdout.trim());
     });
   });
 }
 function execGhAllowExit(args, allowedCodes) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     childProcess.execFile("gh", args, (error, stdout, stderr) => {
       if (error) {
         const code = error.code;
         if (typeof code === "number" && allowedCodes.includes(code)) {
-          resolve2(stdout.trim());
+          resolve3(stdout.trim());
           return;
         }
         reject(new Error(`gh ${args.join(" ")} failed: ${stderr || error.message}`));
         return;
       }
-      resolve2(stdout.trim());
+      resolve3(stdout.trim());
     });
   });
 }
@@ -820,7 +1125,7 @@ async function withRetry(fn, maxRetries = 5, baseDelayMs = 1e3) {
       if (attempt === maxRetries) throw err;
       const delayMs = baseDelayMs * Math.pow(2, attempt - 1);
       console.error(`[gh] Attempt ${attempt}/${maxRetries} failed, retrying in ${delayMs}ms...`);
-      await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+      await new Promise((resolve3) => setTimeout(resolve3, delayMs));
     }
   }
   throw new Error("unreachable");
@@ -899,13 +1204,38 @@ var CLAUDE_SPAWN_ENV = {
   CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: "1",
   CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS: "0"
 };
-var SYSTEM_PROMPT = `\u3053\u306E\u30BB\u30C3\u30B7\u30E7\u30F3\u306F \`claude-task-worker\` \u306E\u30EF\u30FC\u30AB\u30FC\u304B\u3089 \`claude -p\`\uFF08\u975E\u5BFE\u8A71 print \u30E2\u30FC\u30C9\uFF09\u3067\u81EA\u52D5\u8D77\u52D5\u3055\u308C\u3066\u3044\u308B\u3002\u30E6\u30FC\u30B6\u30FC\u3078\u306E\u78BA\u8A8D\u30FB\u8CEA\u554F\u306F\u884C\u308F\u305A\uFF08\u56DE\u7B54\u3059\u308B\u30E6\u30FC\u30B6\u30FC\u306F\u5B58\u5728\u3057\u306A\u3044\uFF09\u3001\u8D77\u52D5\u3055\u308C\u305F\u30B9\u30AD\u30EB\u306E\u30EB\u30FC\u30EB\u306B\u5F93\u3063\u3066\u81EA\u5F8B\u7684\u306B\u5224\u65AD\u3057\u3001\u5168\u30B9\u30C6\u30C3\u30D7\u3092\u5B8C\u9042\u3057\u3066\u304B\u3089\uFF08\u307E\u305F\u306F\u4E2D\u65AD\u6761\u4EF6\u306B\u8A72\u5F53\u3057\u305F\u5834\u5408\u306F\u7406\u7531\u3092\u51FA\u529B\u3057\u3066\uFF09\u7D42\u4E86\u3059\u308B\u3053\u3068\u3002\u66D6\u6627\u306A\u5834\u5408\u306F\u300C\u3088\u308A\u5B89\u5168\u306A\u5074\uFF08\u7834\u58CA\u7684\u3067\u306A\u3044\u5074\uFF09\u300D\u3092\u9078\u629E\u3057\u3001\u305D\u306E\u5224\u65AD\u3068\u6839\u62E0\u3092\u6700\u7D42\u5831\u544A\u306B\u660E\u8A18\u3059\u308B\u3002`;
-var SUBAGENT_SYSTEM_PROMPT = `\u3042\u306A\u305F\u306F claude-task-worker \u306E\u30EF\u30FC\u30AB\u30FC\u304C \`claude -p\`\uFF08\u975E\u5BFE\u8A71 print \u30E2\u30FC\u30C9\uFF09\u3067\u81EA\u52D5\u8D77\u52D5\u3057\u305F\u30BB\u30C3\u30B7\u30E7\u30F3\u5185\u306E\u30B5\u30D6\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u3067\u3059\u3002\u4EE5\u4E0B\u306E\u81EA\u5F8B\u5B9F\u884C\u539F\u5247\u3092\u5FC5\u305A\u9075\u5B88\u3057\u3066\u304F\u3060\u3055\u3044\u3002
+var SYSTEM_PROMPT = `\u3053\u306E\u30BB\u30C3\u30B7\u30E7\u30F3\u306F \`claude-task-worker\` \u306E\u30EF\u30FC\u30AB\u30FC\u304B\u3089\u81EA\u52D5\u8D77\u52D5\u3055\u308C\u3066\u3044\u308B\uFF08\u5FDC\u7B54\u3067\u304D\u308B\u30E6\u30FC\u30B6\u30FC\u306F\u5E38\u99D0\u3057\u3066\u3044\u306A\u3044\uFF09\u3002\u4EE5\u4E0B\u306E\u81EA\u5F8B\u5B9F\u884C\u539F\u5247\u3092\u5FC5\u305A\u9075\u5B88\u3059\u308B\u3053\u3068\u3002
 
-- \u30E6\u30FC\u30B6\u30FC\u3078\u306E\u78BA\u8A8D\u30FB\u8CEA\u554F\u306F\u884C\u308F\u306A\u3044\uFF08\u56DE\u7B54\u3059\u308B\u30E6\u30FC\u30B6\u30FC\u306F\u5B58\u5728\u3057\u306A\u3044\uFF09\u3002\u5224\u65AD\u306F\u3059\u3079\u3066\u59D4\u8B72\u3055\u308C\u305F\u6307\u793A\uFF08\u30D7\u30ED\u30F3\u30D7\u30C8\u3067\u660E\u793A\u7684\u306B\u6E21\u3055\u308C\u305F\u5185\u5BB9\uFF09\u306B\u5F93\u3063\u3066\u81EA\u52D5\u3067\u6C7A\u5B9A\u3059\u308B
+- \u30E6\u30FC\u30B6\u30FC\u3078\u306E\u78BA\u8A8D\u30FB\u8CEA\u554F\u306F\u884C\u308F\u305A\u3001\u8D77\u52D5\u3055\u308C\u305F\u30B9\u30AD\u30EB\u306E\u30EB\u30FC\u30EB\u306B\u5F93\u3063\u3066\u81EA\u5F8B\u7684\u306B\u5224\u65AD\u3059\u308B
 - \u66D6\u6627\u306A\u5834\u5408\u306F\u300C\u3088\u308A\u5B89\u5168\u306A\u5074\uFF08\u7834\u58CA\u7684\u3067\u306A\u3044\u5074\uFF09\u300D\u3092\u9078\u629E\u3057\u3001\u305D\u306E\u5224\u65AD\u3068\u6839\u62E0\u3092\u6700\u7D42\u5831\u544A\u306B\u660E\u8A18\u3059\u308B
-- \u59D4\u8B72\u3055\u308C\u305F\u30BF\u30B9\u30AF\u306F\u6700\u5F8C\u307E\u3067\u5B8C\u9042\u3057\u3066\u304B\u3089\u6700\u7D42\u5831\u544A\u3059\u308B\u3002\u6307\u793A\u306B\u5B9A\u7FA9\u3055\u308C\u305F\u4E2D\u65AD\u6761\u4EF6\u306B\u8A72\u5F53\u3057\u305F\u5834\u5408\u306E\u307F\u3001\u7406\u7531\u3092\u51FA\u529B\u3057\u3066\u7D42\u4E86\u3059\u308B
-- \u5B50\u30B5\u30D6\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306B\u4F5C\u696D\u3092\u59D4\u8B72\u3057\u305F\u5834\u5408\u3001\u305D\u306E\u5B8C\u4E86\u5831\u544A\u3092\u9D5C\u5451\u307F\u306B\u3057\u306A\u3044\u3002\`git diff\` \u7B49\u3067\u5B9F\u969B\u306E\u6210\u679C\u7269\u3092\u691C\u8A3C\u3057\u3066\u304B\u3089\u5B8C\u4E86\u6271\u3044\u306B\u3059\u308B`;
+- \u5168\u30B9\u30C6\u30C3\u30D7\u3092\u5B8C\u9042\u3057\u3066\u304B\u3089\u7D42\u4E86\u3059\u308B\uFF08\u30B9\u30AD\u30EB\u306B\u5B9A\u7FA9\u3055\u308C\u305F\u4E2D\u65AD\u6761\u4EF6\u306B\u8A72\u5F53\u3057\u305F\u5834\u5408\u306E\u307F\u3001\u7406\u7531\u3092\u51FA\u529B\u3057\u3066\u7D42\u4E86\u3059\u308B\uFF09
+- \u30B5\u30D6\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u3078\u4F5C\u696D\u3092\u59D4\u8B72\u3059\u308B\u5834\u5408\u306F\u3001\u4E0A\u8A18\u306E\u539F\u5247\u3092\u59D4\u8B72\u30D7\u30ED\u30F3\u30D7\u30C8\u306B\u3082\u660E\u8A18\u3057\u3066\u4F1D\u3048\u308B
+- \u30B5\u30D6\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306E\u5B8C\u4E86\u5831\u544A\u306F\u9D5C\u5451\u307F\u306B\u3057\u306A\u3044\u3002\`git diff\` \u7B49\u3067\u5B9F\u969B\u306E\u6210\u679C\u7269\u3092\u691C\u8A3C\u3057\u3066\u304B\u3089\u5B8C\u4E86\u6271\u3044\u306B\u3059\u308B`;
+function buildClaudeArgs({ mode, prompt, model, effort }) {
+  return [
+    ...mode === "herdr" ? [] : ["-p"],
+    prompt,
+    "--dangerously-skip-permissions",
+    "--chrome",
+    "--disallowedTools",
+    DISALLOWED_TOOLS_ARG,
+    "--append-system-prompt",
+    SYSTEM_PROMPT,
+    "--model",
+    model,
+    "--effort",
+    effort
+  ];
+}
+function buildClaudeEnv(mode) {
+  if (mode === "herdr") {
+    return {
+      CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: CLAUDE_SPAWN_ENV.CLAUDE_CODE_DISABLE_BACKGROUND_TASKS,
+      HERDR_DISABLE_SOUND: "1"
+    };
+  }
+  return { ...CLAUDE_SPAWN_ENV };
+}
 
 // src/config.ts
 import { readFileSync } from "node:fs";
@@ -1150,6 +1480,7 @@ async function assertRemoteTrackingExists(epicBranch) {
 
 // src/process-manager.ts
 import { spawn } from "node:child_process";
+import { basename } from "node:path";
 init_table();
 
 // src/task-result.ts
@@ -1171,8 +1502,200 @@ function buildTaskResult(code, stdout, stderrTail) {
   return { status: completed ? "completed" : "failed", output };
 }
 
+// src/user-config.ts
+import { readFileSync as readFileSync2, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join as join2, resolve } from "node:path";
+var RESERVED_ALL = "all";
+var DEFAULT_RUN_MODE = "default";
+var UserConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UserConfigError";
+  }
+};
+function getConfigDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  const configHome = xdg && xdg.length > 0 ? xdg : join2(homedir(), ".config");
+  return join2(configHome, "claude-task-worker");
+}
+function getUserConfigPath() {
+  return join2(getConfigDir(), "config.json");
+}
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function parseConfigFile(path) {
+  let content;
+  try {
+    content = readFileSync2(path, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") return void 0;
+    throw err;
+  }
+  try {
+    return JSON.parse(content);
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      throw new UserConfigError(`config file contains invalid JSON: ${path}: ${err.message}`);
+    }
+    throw err;
+  }
+}
+function readRawConfig() {
+  return parseConfigFile(getUserConfigPath());
+}
+function parseMode(raw, path) {
+  if (!("mode" in raw)) return DEFAULT_RUN_MODE;
+  const value = raw["mode"];
+  if (value === "default" || value === "herdr") return value;
+  console.warn(`[config] invalid mode: ${JSON.stringify(value)} in ${path}, using "${DEFAULT_RUN_MODE}"`);
+  return DEFAULT_RUN_MODE;
+}
+function loadUserConfig() {
+  const path = getUserConfigPath();
+  const raw = readRawConfig();
+  if (raw === void 0) {
+    throw new UserConfigError(`config.json not found: ${path}`);
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new UserConfigError(`config.json must contain a JSON object: ${path}`);
+  }
+  if (!("projects" in raw) || typeof raw["projects"] !== "object" || raw["projects"] === null || Array.isArray(raw["projects"])) {
+    throw new UserConfigError(`config.json must contain a "projects" section as an object: ${path}`);
+  }
+  if ("projectGroups" in raw && (typeof raw["projectGroups"] !== "object" || raw["projectGroups"] === null || Array.isArray(raw["projectGroups"]))) {
+    throw new UserConfigError(`config.json "projectGroups" must be an object: ${path}`);
+  }
+  const mode = parseMode(raw, path);
+  const rawProjects = raw["projects"];
+  const rawProjectGroups = "projectGroups" in raw ? raw["projectGroups"] : {};
+  const projectKeys = Object.keys(rawProjects);
+  const groupKeys = Object.keys(rawProjectGroups);
+  if (projectKeys.includes(RESERVED_ALL) || groupKeys.includes(RESERVED_ALL)) {
+    throw new UserConfigError(
+      `"${RESERVED_ALL}" is a reserved word and cannot be used as a key in "projects" or "projectGroups"`
+    );
+  }
+  const groupKeySet = new Set(groupKeys);
+  const duplicateKeys = projectKeys.filter((key) => groupKeySet.has(key));
+  if (duplicateKeys.length > 0) {
+    throw new UserConfigError(
+      `"projects" and "projectGroups" share the same key namespace; duplicate keys are not allowed: ${duplicateKeys.join(", ")}`
+    );
+  }
+  const projects = {};
+  for (const [name, value] of Object.entries(rawProjects)) {
+    if (name === "__proto__") {
+      throw new UserConfigError(`"__proto__" cannot be used as a key in "projects": ${path}`);
+    }
+    if (typeof value !== "string" || !isAbsolute(value)) {
+      console.warn(`[config] invalid projects.${name}: expected an absolute path, skipping`);
+      continue;
+    }
+    if (!isDirectory(value)) {
+      console.warn(`[config] projects.${name} does not exist as a directory: ${value}, skipping`);
+      continue;
+    }
+    projects[name] = value;
+  }
+  const projectGroups = {};
+  for (const [groupName, value] of Object.entries(rawProjectGroups)) {
+    if (groupName === "__proto__") {
+      throw new UserConfigError(`"__proto__" cannot be used as a key in "projectGroups": ${path}`);
+    }
+    if (!Array.isArray(value)) {
+      console.warn(`[config] invalid projectGroups.${groupName}: expected an array, skipping`);
+      continue;
+    }
+    const members = [];
+    for (const member of value) {
+      if (typeof member !== "string" || !Object.prototype.hasOwnProperty.call(projects, member)) {
+        console.warn(`[config] projectGroups.${groupName} references unknown project "${String(member)}", skipping`);
+        continue;
+      }
+      members.push(member);
+    }
+    projectGroups[groupName] = members;
+  }
+  return { mode, projects, projectGroups };
+}
+var cachedRunMode;
+function getRunMode() {
+  if (cachedRunMode === void 0) {
+    cachedRunMode = readRunMode();
+  }
+  return cachedRunMode;
+}
+function readRunMode() {
+  let raw;
+  try {
+    raw = readRawConfig();
+  } catch (err) {
+    console.warn(`[config] failed to read config file, using "${DEFAULT_RUN_MODE}" mode: ${err}`);
+    return DEFAULT_RUN_MODE;
+  }
+  if (raw === void 0) return DEFAULT_RUN_MODE;
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return DEFAULT_RUN_MODE;
+  }
+  return parseMode(raw, getUserConfigPath());
+}
+function findProjectNameByPath(path) {
+  let config;
+  try {
+    config = loadUserConfig();
+  } catch {
+    return void 0;
+  }
+  const target = resolve(path);
+  for (const [name, projectPath] of Object.entries(config.projects)) {
+    if (resolve(projectPath) === target) return name;
+  }
+  return void 0;
+}
+function resolveTargetProjects(requested, config) {
+  const resolved = /* @__PURE__ */ new Map();
+  for (const name of requested) {
+    if (name === RESERVED_ALL) {
+      for (const [projectName, projectPath] of Object.entries(config.projects)) {
+        resolved.set(projectName, { name: projectName, path: projectPath });
+      }
+      continue;
+    }
+    if (Object.prototype.hasOwnProperty.call(config.projects, name)) {
+      resolved.set(name, { name, path: config.projects[name] });
+      continue;
+    }
+    if (Object.prototype.hasOwnProperty.call(config.projectGroups, name)) {
+      for (const projectName of config.projectGroups[name]) {
+        const projectPath = config.projects[projectName];
+        if (projectPath === void 0) continue;
+        resolved.set(projectName, { name: projectName, path: projectPath });
+      }
+      continue;
+    }
+    const availableProjects = Object.keys(config.projects).join(", ") || "(none)";
+    const availableGroups = Object.keys(config.projectGroups).join(", ") || "(none)";
+    throw new UserConfigError(
+      `Unknown project or group: "${name}". Available projects: ${availableProjects}. Available groups: ${availableGroups}.`
+    );
+  }
+  const resolvedProjects = Array.from(resolved.values());
+  if (resolvedProjects.length === 0) {
+    throw new UserConfigError(`No projects resolved from requested targets: ${requested.join(", ")}`);
+  }
+  return resolvedProjects;
+}
+
 // src/process-manager.ts
 var childProcesses = /* @__PURE__ */ new Map();
+var herdrTasks = /* @__PURE__ */ new Map();
+var herdrAbortSignal = { aborted: false };
 var tasks = /* @__PURE__ */ new Map();
 var shuttingDown = false;
 function setShuttingDown() {
@@ -1228,7 +1751,9 @@ function renderTable() {
       title: getDisplayWidth(t.title) > maxTitleWidth ? truncateToWidth(t.title, maxTitleWidth) : t.title,
       worker: t.workerName,
       path: t.path ? t.path.length > maxPathWidth ? truncateToWidth(t.path, maxPathWidth) : t.path : "",
-      status: t.status,
+      // herdr モードでは agent ステータス（working / blocked 等）を併記し、
+      // 人の介入が必要な blocked にも気づけるようにする。
+      status: t.agentStatus ? `${t.status}:${t.agentStatus}` : t.status,
       time: formatTime(t.startedAt),
       duration: formatDuration(t.startedAt)
     })),
@@ -1287,6 +1812,65 @@ function ensureRenderInterval() {
   renderInterval = setInterval(renderTable, 1e3);
   renderInterval.unref();
 }
+async function finishTask(id, result, onComplete) {
+  try {
+    await Promise.race([
+      onComplete?.(result.status, result.output) ?? Promise.resolve(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("onComplete timed out after 120s")), 12e4).unref()
+      )
+    ]);
+  } catch (err) {
+    console.error(`[worker] onComplete error for #${id}: ${err}`);
+  }
+  const task = tasks.get(id);
+  if (task) {
+    task.status = result.status;
+    task.finishedAt = /* @__PURE__ */ new Date();
+    task.agentStatus = void 0;
+  }
+  renderTable();
+}
+function resolveProjectName(cwd = process.cwd()) {
+  const injected = process.env.CTW_PROJECT_NAME;
+  if (injected && injected.length > 0) return injected;
+  return findProjectNameByPath(cwd) ?? basename(cwd);
+}
+async function runViaHerdr(command, args, id, onComplete, cwd, env) {
+  const { startHerdrTask: startHerdrTask2, stopHerdrTask: stopHerdrTask2, taskTabLabel: taskTabLabel2, waitForHerdrTask: waitForHerdrTask2 } = await Promise.resolve().then(() => (init_herdr_runner(), herdr_runner_exports));
+  const { getCurrentWorkspaceId: getCurrentWorkspaceId2 } = await Promise.resolve().then(() => (init_herdr(), herdr_exports));
+  const label = taskTabLabel2(resolveProjectName(), id);
+  let task;
+  let result;
+  herdrTasks.set(id, { paneId: "", tabId: "" });
+  try {
+    task = await startHerdrTask2({
+      label,
+      cwd: cwd ?? process.cwd(),
+      argv: [command, ...args],
+      env,
+      workspaceId: getCurrentWorkspaceId2()
+    });
+    herdrTasks.set(id, task);
+    result = await waitForHerdrTask2(task.paneId, {
+      signal: herdrAbortSignal,
+      onBlocked: () => console.warn(`[worker] #${id} is blocked and waiting for input in herdr tab "${label}"`),
+      onStatus: (status) => {
+        const task2 = tasks.get(id);
+        if (task2 && task2.status === "running") task2.agentStatus = status;
+      }
+    });
+  } catch (err) {
+    console.error(`[worker] failed to run #${id} via herdr: ${err}`);
+    result = { status: "failed", output: `[worker] failed to run the task via herdr: ${err}` };
+  } finally {
+    if (task) {
+      await stopHerdrTask2(task);
+    }
+  }
+  await finishTask(id, result, onComplete);
+  herdrTasks.delete(id);
+}
 function run(command, args, id, title, workerName, path, onComplete, cwd, env) {
   tasks.set(id, {
     id,
@@ -1298,6 +1882,10 @@ function run(command, args, id, title, workerName, path, onComplete, cwd, env) {
   });
   ensureRenderInterval();
   renderTable();
+  if (getRunMode() === "herdr") {
+    void runViaHerdr(command, args, id, onComplete, cwd, env);
+    return;
+  }
   const child = spawn(command, args, {
     stdio: ["ignore", "pipe", "pipe"],
     detached: true,
@@ -1320,55 +1908,25 @@ function run(command, args, id, title, workerName, path, onComplete, cwd, env) {
     }
   });
   child.on("close", async (code) => {
-    const { status: finalStatus, output } = buildTaskResult(
+    const result = buildTaskResult(
       code,
       Buffer.concat(outputChunks).toString("utf-8"),
       Buffer.concat(stderrChunks).toString("utf-8").slice(-STDERR_TAIL_LIMIT)
     );
-    try {
-      await Promise.race([
-        onComplete?.(finalStatus, output) ?? Promise.resolve(),
-        new Promise(
-          (_, reject) => setTimeout(() => reject(new Error("onComplete timed out after 120s")), 12e4).unref()
-        )
-      ]);
-    } catch (err) {
-      console.error(`[worker] onComplete error for #${id}: ${err}`);
-    }
-    const task = tasks.get(id);
-    if (task) {
-      task.status = finalStatus;
-      task.finishedAt = /* @__PURE__ */ new Date();
-    }
+    await finishTask(id, result, onComplete);
     childProcesses.delete(id);
-    renderTable();
   });
   child.on("error", async (err) => {
     console.error(`[worker] failed to spawn process for #${id}: ${err.message}`);
-    try {
-      await Promise.race([
-        onComplete?.("failed", err.message) ?? Promise.resolve(),
-        new Promise(
-          (_, reject) => setTimeout(() => reject(new Error("onComplete timed out after 120s")), 12e4).unref()
-        )
-      ]);
-    } catch (callbackErr) {
-      console.error(`[worker] onComplete error for #${id}: ${callbackErr}`);
-    }
-    const task = tasks.get(id);
-    if (task) {
-      task.status = "failed";
-      task.finishedAt = /* @__PURE__ */ new Date();
-    }
+    await finishTask(id, { status: "failed", output: err.message }, onComplete);
     childProcesses.delete(id);
-    renderTable();
   });
 }
 function waitForAllProcesses() {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const check = () => {
-      if (childProcesses.size === 0) {
-        resolve2();
+      if (childProcesses.size === 0 && herdrTasks.size === 0) {
+        resolve3();
       } else {
         setTimeout(check, 500);
       }
@@ -1388,6 +1946,9 @@ function shutdown(signal = "SIGTERM") {
       }
     }
   }
+  if (herdrTasks.size > 0) {
+    herdrAbortSignal.aborted = true;
+  }
 }
 
 // src/random-name.ts
@@ -1639,16 +2200,16 @@ function isGeneratedWorktreeName(name) {
 
 // src/slack.ts
 import { exec } from "node:child_process";
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { join as join3 } from "node:path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 
 // src/runcat.ts
 import { mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join as join2 } from "node:path";
-var RUNCAT_OUT_FILE = process.env.RUNCAT_OUT_FILE ?? join2(process.env.HOME ?? homedir(), ".claude", "runcat-usage.json");
+import { homedir as homedir2 } from "node:os";
+import { dirname, join as join3 } from "node:path";
+var RUNCAT_OUT_FILE = process.env.RUNCAT_OUT_FILE ?? join3(process.env.HOME ?? homedir2(), ".claude", "runcat-usage.json");
 var JST = "Asia/Tokyo";
 function formatG(value) {
   return String(Number(value.toPrecision(6)));
@@ -1712,7 +2273,7 @@ function buildRuncatSnapshot(usage, now = /* @__PURE__ */ new Date()) {
 function writeRuncatUsage(usage, outFile = RUNCAT_OUT_FILE) {
   const snapshot = buildRuncatSnapshot(usage);
   const dir = dirname(outFile);
-  const tmp = join2(dir, `.runcat-${process.pid}-${Date.now()}.json`);
+  const tmp = join3(dir, `.runcat-${process.pid}-${Date.now()}.json`);
   try {
     mkdirSync(dir, { recursive: true });
     writeFileSync(tmp, JSON.stringify(snapshot), "utf-8");
@@ -1749,13 +2310,13 @@ async function getOAuthToken() {
     const { stdout } = await execAsync('security find-generic-password -s "Claude Code-credentials" -w');
     return extractToken(JSON.parse(stdout.trim()));
   } catch {
-    const raw = readFileSync2(join3(homedir2(), ".claude", ".credentials.json"), "utf-8");
+    const raw = readFileSync3(join4(homedir3(), ".claude", ".credentials.json"), "utf-8");
     return extractToken(JSON.parse(raw));
   }
 }
 function readUsageCache() {
   try {
-    const raw = readFileSync2(USAGE_CACHE_PATH, "utf-8");
+    const raw = readFileSync3(USAGE_CACHE_PATH, "utf-8");
     const cached = JSON.parse(raw);
     if (Date.now() - cached.timestamp < USAGE_CACHE_TTL_SECONDS * 1e3) {
       return cached.data;
@@ -1857,11 +2418,11 @@ async function notifyError(workerName, repoName, error) {
 import { execFile as execFile2 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
 import { readdir, rm, stat } from "node:fs/promises";
-import { basename, resolve, sep } from "node:path";
+import { basename as basename2, resolve as resolve2, sep } from "node:path";
 var execFileAsync2 = promisify3(execFile2);
 var WORKTREES_DIR = ".claude/worktrees";
 function isManagedWorktreePath(path) {
-  return resolve(path).startsWith(resolve(WORKTREES_DIR) + sep);
+  return resolve2(path).startsWith(resolve2(WORKTREES_DIR) + sep);
 }
 async function pathExists(path) {
   try {
@@ -1948,7 +2509,7 @@ async function removeWorktree(worktreeId) {
   const worktreePath = getWorktreePath(worktreeId);
   let entry;
   try {
-    entry = (await listWorktreeEntries()).find((e) => resolve(e.path) === resolve(worktreePath));
+    entry = (await listWorktreeEntries()).find((e) => resolve2(e.path) === resolve2(worktreePath));
   } catch (error) {
     console.error(`[worktree] Failed to list worktrees:`, error);
   }
@@ -1972,7 +2533,7 @@ async function removeWorktreeByBranch(branchName) {
         console.log(`[worktree] Skipping unmanaged worktree for branch ${branchName}: ${entry.path}`);
         continue;
       }
-      const worktreeId = basename(entry.path);
+      const worktreeId = basename2(entry.path);
       if (isWorktreeInUse(worktreeId)) {
         console.log(`[worktree] Skipping worktree in use by a running task for branch ${branchName}: ${entry.path}`);
         continue;
@@ -1999,7 +2560,7 @@ async function removeStaleWorktrees() {
   try {
     for (const entry of await listWorktreeEntries()) {
       if (!isManagedWorktreePath(entry.path)) continue;
-      const worktreeId = basename(entry.path);
+      const worktreeId = basename2(entry.path);
       if (isGeneratedWorktreeName(worktreeId)) worktreeIds.add(worktreeId);
     }
   } catch (error) {
@@ -2058,22 +2619,8 @@ function createIssuePollingWorker(config) {
             const { model, effort, skill } = getWorkerConfig(config.name);
             const command = skill || config.command;
             const parentNumber = issue.parent?.number;
-            const claudeArgs = [
-              "-p",
-              `${command} ${issue.number}`,
-              "--dangerously-skip-permissions",
-              "--chrome",
-              "--disallowedTools",
-              DISALLOWED_TOOLS_ARG,
-              "--append-system-prompt",
-              SYSTEM_PROMPT,
-              "--append-subagent-system-prompt",
-              SUBAGENT_SYSTEM_PROMPT,
-              "--model",
-              model,
-              "--effort",
-              effort
-            ];
+            const mode = getRunMode();
+            const claudeArgs = buildClaudeArgs({ mode, prompt: `${command} ${issue.number}`, model, effort });
             let baseBranch = defaultBranch;
             if (parentNumber !== void 0) {
               baseBranch = `cc-epic-${parentNumber}`;
@@ -2129,7 +2676,7 @@ function createIssuePollingWorker(config) {
                 }
               },
               cwd,
-              { ...CLAUDE_SPAWN_ENV }
+              buildClaudeEnv(mode)
             );
           } catch (err) {
             console.error(`[${config.name}] setup error for #${issue.number}: ${err}`);
@@ -2238,24 +2785,10 @@ function createPrPollingWorker(config) {
             const cwd = getWorktreePath(worktreeId);
             const { model, effort, skill } = getWorkerConfig(config.name);
             const command = skill || config.command;
+            const mode = getRunMode();
             run(
               "claude",
-              [
-                "-p",
-                `${command} ${pr.number}`,
-                "--dangerously-skip-permissions",
-                "--chrome",
-                "--disallowedTools",
-                DISALLOWED_TOOLS_ARG,
-                "--append-system-prompt",
-                SYSTEM_PROMPT,
-                "--append-subagent-system-prompt",
-                SUBAGENT_SYSTEM_PROMPT,
-                "--model",
-                model,
-                "--effort",
-                effort
-              ],
+              buildClaudeArgs({ mode, prompt: `${command} ${pr.number}`, model, effort }),
               pr.number,
               `PR #${pr.number} (${pr.headRefName})`,
               config.name,
@@ -2298,7 +2831,7 @@ function createPrPollingWorker(config) {
                 }
               },
               cwd,
-              { ...CLAUDE_SPAWN_ENV }
+              buildClaudeEnv(mode)
             );
           } catch (err) {
             console.error(`[${config.name}] setup error for PR #${pr.number}: ${err}`);
@@ -2559,7 +3092,7 @@ async function init(options = {}) {
 // src/commands/run-command.ts
 import { spawn as spawn2 } from "node:child_process";
 function runCommand(command, args) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const child = spawn2(command, args, {
       stdio: "inherit",
       shell: process.platform === "win32"
@@ -2582,7 +3115,7 @@ function runCommand(command, args) {
     child.on("close", (code) => {
       cleanup();
       if (code === 0) {
-        resolve2();
+        resolve3();
       } else {
         reject(new Error(`${command} ${args.join(" ")} exited with code ${code}`));
       }
@@ -2686,14 +3219,14 @@ async function update() {
 }
 
 // src/commands/version.ts
-import { readFileSync as readFileSync3 } from "node:fs";
-import { dirname as dirname2, join as join4 } from "node:path";
+import { readFileSync as readFileSync4 } from "node:fs";
+import { dirname as dirname2, join as join5 } from "node:path";
 import { fileURLToPath } from "node:url";
 function version() {
   const here = dirname2(fileURLToPath(import.meta.url));
-  const pkgPath = join4(here, "..", "package.json");
+  const pkgPath = join5(here, "..", "package.json");
   try {
-    const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
     console.log(pkg.version ?? "unknown");
   } catch (err) {
     console.error(`[version] Failed to read version: ${err.message}`);
@@ -2744,141 +3277,6 @@ function buildForwardedCommand(argv) {
   return ["claude-task-worker", ...tokens.map(shellQuote)].join(" ");
 }
 
-// src/projects-config.ts
-import { readFileSync as readFileSync4, statSync } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { isAbsolute, join as join5 } from "node:path";
-var RESERVED_ALL = "all";
-var ProjectsConfigError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ProjectsConfigError";
-  }
-};
-function getProjectsConfigPath() {
-  const xdg = process.env.XDG_CONFIG_HOME;
-  const configHome = xdg && xdg.length > 0 ? xdg : join5(homedir3(), ".config");
-  return join5(configHome, "claude-task-worker", "projects.json");
-}
-var PROJECTS_CONFIG_PATH = getProjectsConfigPath();
-function isDirectory(path) {
-  try {
-    return statSync(path).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function loadProjectsConfig() {
-  const configPath = PROJECTS_CONFIG_PATH;
-  let raw;
-  try {
-    raw = JSON.parse(readFileSync4(configPath, "utf-8"));
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      throw new ProjectsConfigError(`projects.json not found: ${configPath}`);
-    }
-    if (err instanceof SyntaxError) {
-      throw new ProjectsConfigError(`projects.json contains invalid JSON: ${configPath}: ${err.message}`);
-    }
-    throw err;
-  }
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    throw new ProjectsConfigError(`projects.json must contain a JSON object: ${configPath}`);
-  }
-  if (!("projects" in raw) || typeof raw["projects"] !== "object" || raw["projects"] === null || Array.isArray(raw["projects"])) {
-    throw new ProjectsConfigError(`projects.json must contain a "projects" section as an object: ${configPath}`);
-  }
-  if ("projectGroups" in raw && (typeof raw["projectGroups"] !== "object" || raw["projectGroups"] === null || Array.isArray(raw["projectGroups"]))) {
-    throw new ProjectsConfigError(`projects.json "projectGroups" must be an object: ${configPath}`);
-  }
-  const rawProjects = raw["projects"];
-  const rawProjectGroups = "projectGroups" in raw ? raw["projectGroups"] : {};
-  const projectKeys = Object.keys(rawProjects);
-  const groupKeys = Object.keys(rawProjectGroups);
-  if (projectKeys.includes(RESERVED_ALL) || groupKeys.includes(RESERVED_ALL)) {
-    throw new ProjectsConfigError(
-      `"${RESERVED_ALL}" is a reserved word and cannot be used as a key in "projects" or "projectGroups"`
-    );
-  }
-  const groupKeySet = new Set(groupKeys);
-  const duplicateKeys = projectKeys.filter((key) => groupKeySet.has(key));
-  if (duplicateKeys.length > 0) {
-    throw new ProjectsConfigError(
-      `"projects" and "projectGroups" share the same key namespace; duplicate keys are not allowed: ${duplicateKeys.join(", ")}`
-    );
-  }
-  const projects = {};
-  for (const [name, value] of Object.entries(rawProjects)) {
-    if (name === "__proto__") {
-      throw new ProjectsConfigError(`"__proto__" cannot be used as a key in "projects": ${configPath}`);
-    }
-    if (typeof value !== "string" || !isAbsolute(value)) {
-      console.warn(`[projects-config] invalid projects.${name}: expected an absolute path, skipping`);
-      continue;
-    }
-    if (!isDirectory(value)) {
-      console.warn(`[projects-config] projects.${name} does not exist as a directory: ${value}, skipping`);
-      continue;
-    }
-    projects[name] = value;
-  }
-  const projectGroups = {};
-  for (const [groupName, value] of Object.entries(rawProjectGroups)) {
-    if (groupName === "__proto__") {
-      throw new ProjectsConfigError(`"__proto__" cannot be used as a key in "projectGroups": ${configPath}`);
-    }
-    if (!Array.isArray(value)) {
-      console.warn(`[projects-config] invalid projectGroups.${groupName}: expected an array, skipping`);
-      continue;
-    }
-    const members = [];
-    for (const member of value) {
-      if (typeof member !== "string" || !Object.prototype.hasOwnProperty.call(projects, member)) {
-        console.warn(
-          `[projects-config] projectGroups.${groupName} references unknown project "${String(member)}", skipping`
-        );
-        continue;
-      }
-      members.push(member);
-    }
-    projectGroups[groupName] = members;
-  }
-  return { projects, projectGroups };
-}
-function resolveTargetProjects(requested, config) {
-  const resolved = /* @__PURE__ */ new Map();
-  for (const name of requested) {
-    if (name === RESERVED_ALL) {
-      for (const [projectName, projectPath] of Object.entries(config.projects)) {
-        resolved.set(projectName, { name: projectName, path: projectPath });
-      }
-      continue;
-    }
-    if (Object.prototype.hasOwnProperty.call(config.projects, name)) {
-      resolved.set(name, { name, path: config.projects[name] });
-      continue;
-    }
-    if (Object.prototype.hasOwnProperty.call(config.projectGroups, name)) {
-      for (const projectName of config.projectGroups[name]) {
-        const projectPath = config.projects[projectName];
-        if (projectPath === void 0) continue;
-        resolved.set(projectName, { name: projectName, path: projectPath });
-      }
-      continue;
-    }
-    const availableProjects = Object.keys(config.projects).join(", ") || "(none)";
-    const availableGroups = Object.keys(config.projectGroups).join(", ") || "(none)";
-    throw new ProjectsConfigError(
-      `Unknown project or group: "${name}". Available projects: ${availableProjects}. Available groups: ${availableGroups}.`
-    );
-  }
-  const resolvedProjects = Array.from(resolved.values());
-  if (resolvedProjects.length === 0) {
-    throw new ProjectsConfigError(`No projects resolved from requested targets: ${requested.join(", ")}`);
-  }
-  return resolvedProjects;
-}
-
 // src/index.ts
 var WORKERS = {
   "exec-issue": execIssueWorker,
@@ -2981,6 +3379,18 @@ process.on("unhandledRejection", (err) => {
   console.error("[worker] unhandled rejection:", err);
   process.exit(1);
 });
+async function assertRunModeAvailable() {
+  if (getRunMode() !== "herdr") return;
+  const herdr = await Promise.resolve().then(() => (init_herdr(), herdr_exports));
+  try {
+    await herdr.checkHerdrAvailable();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[worker] config.json has mode "herdr" but herdr is unavailable: ${message}`);
+    process.exit(1);
+  }
+  console.log("[worker] run mode: herdr (each task runs as a TUI session in its own herdr tab)");
+}
 if (!hasProjectFilter()) {
   process.on("SIGTERM", async () => {
     if (isShuttingDown()) return;
@@ -2998,7 +3408,7 @@ if (!hasProjectFilter()) {
       forceKilling = true;
       console.log("\n[worker] Force killing running tasks... (cleaning up labels and worktrees)");
       shutdown("SIGKILL");
-      const cleanupTimeout = new Promise((resolve2) => setTimeout(resolve2, 6e4).unref());
+      const cleanupTimeout = new Promise((resolve3) => setTimeout(resolve3, 6e4).unref());
       await Promise.race([waitForAllProcesses(), cleanupTimeout]);
       process.exit(1);
     }
@@ -3022,7 +3432,7 @@ if (hasProjectFilter()) {
     process.on("SIGTERM", shutdownController.handle);
     process.on("SIGINT", shutdownController.handle);
     try {
-      const config = loadProjectsConfig();
+      const config = loadUserConfig();
       const projects = resolveTargetProjects(parseProjectFilters(), config);
       const forwardedCommand = buildForwardedCommand(process.argv.slice(2));
       sessions = await dispatcher.runDispatcher(projects, forwardedCommand);
@@ -3037,7 +3447,7 @@ if (hasProjectFilter()) {
         process.exit(0);
       }
     } catch (err) {
-      if (err instanceof ProjectsConfigError || err instanceof herdr.HerdrUnavailableError) {
+      if (err instanceof UserConfigError || err instanceof herdr.HerdrUnavailableError) {
         console.error(`[dispatcher] ${err.message}`);
         process.exit(1);
       }
@@ -3069,6 +3479,7 @@ if (hasProjectFilter()) {
   const epicFilters = parseEpicFilters();
   const labelFilters = parseLabelFilters();
   (async () => {
+    await assertRunModeAvailable();
     await removeStaleWorktrees();
     await Promise.all([
       execIssueWorker({ epicFilters, labelFilters }),
@@ -3084,6 +3495,7 @@ if (hasProjectFilter()) {
   const epicFilters = parseEpicFilters();
   const labelFilters = parseLabelFilters();
   (async () => {
+    await assertRunModeAvailable();
     await removeStaleWorktrees();
     await Promise.all([
       execIssueWorker({ epicFilters, labelFilters }),
@@ -3102,6 +3514,7 @@ if (hasProjectFilter()) {
   const epicFilters = parseEpicFilters();
   const labelFilters = parseLabelFilters();
   (async () => {
+    await assertRunModeAvailable();
     await removeStaleWorktrees();
     await WORKERS[workerType]({ epicFilters, labelFilters });
   })();