claude-task-worker 0.1.0

package/dist/index.js

@@ -0,0 +1,1890 @@
+#!/usr/bin/env node
+
+// src/gh.ts
+import { execFile } from "node:child_process";
+function execGh(args) {
+  return new Promise((resolve2, reject) => {
+    execFile("gh", args, (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error(`gh ${args.join(" ")} failed: ${stderr || error.message}`));
+        return;
+      }
+      resolve2(stdout.trim());
+    });
+  });
+}
+function execGhAllowExit(args, allowedCodes) {
+  return new Promise((resolve2, reject) => {
+    execFile("gh", args, (error, stdout, stderr) => {
+      if (error) {
+        const code = error.code;
+        if (typeof code === "number" && allowedCodes.includes(code)) {
+          resolve2(stdout.trim());
+          return;
+        }
+        reject(new Error(`gh ${args.join(" ")} failed: ${stderr || error.message}`));
+        return;
+      }
+      resolve2(stdout.trim());
+    });
+  });
+}
+async function getCurrentUser() {
+  return execGh(["api", "user", "--jq", ".login"]);
+}
+async function getRepoInfo() {
+  const output = await execGh(["repo", "view", "--json", "owner,name,defaultBranchRef"]);
+  const parsed = JSON.parse(output);
+  return { owner: parsed.owner.login, name: parsed.name, defaultBranch: parsed.defaultBranchRef.name };
+}
+async function listIssuesByLabel(assignee, labels, excludeLabels = [], epicFilter) {
+  const labelArgs = labels.flatMap((label) => ["--label", label]);
+  const searchTerms = ["sort:created-asc", "-is:blocked", ...excludeLabels.map((label) => `-label:"${label}"`)];
+  if (epicFilter && epicFilter.numbers.length > 0) {
+    for (const number of epicFilter.numbers) {
+      searchTerms.push(`parent-issue:${epicFilter.owner}/${epicFilter.repo}#${number}`);
+    }
+  }
+  const search = searchTerms.join(" ");
+  const output = await execGh([
+    "issue",
+    "list",
+    "--assignee",
+    assignee,
+    ...labelArgs,
+    "--json",
+    "number,title,labels,parent",
+    "--search",
+    search,
+    "--limit",
+    "10"
+  ]);
+  return JSON.parse(output);
+}
+async function listIssuesByNumbers(assignee, labels, excludeLabels, numbers) {
+  const results = [];
+  for (const number of numbers) {
+    try {
+      const output = await execGh([
+        "issue",
+        "view",
+        String(number),
+        "--json",
+        "number,title,labels,parent,assignees,state"
+      ]);
+      const parsed = JSON.parse(output);
+      if (parsed.state !== "OPEN") continue;
+      if (!parsed.assignees.some((a) => a.login === assignee)) continue;
+      const labelNames = new Set(parsed.labels.map((l) => l.name));
+      if (!labels.every((label) => labelNames.has(label))) continue;
+      if (excludeLabels.some((label) => labelNames.has(label))) continue;
+      results.push({
+        number: parsed.number,
+        title: parsed.title,
+        labels: parsed.labels,
+        parent: parsed.parent
+      });
+    } catch (err) {
+      console.error(`[gh] listIssuesByNumbers failed for #${number}: ${err}`);
+    }
+  }
+  return results;
+}
+async function getIssueSubIssuesSummary(issueNumber) {
+  const output = await execGh(["issue", "view", String(issueNumber), "--json", "subIssuesSummary"]);
+  const parsed = JSON.parse(output);
+  const summary = parsed?.subIssuesSummary;
+  if (!summary || typeof summary.total !== "number" || typeof summary.completed !== "number" || typeof summary.percentCompleted !== "number") {
+    return { total: 0, completed: 0, percentCompleted: 0 };
+  }
+  return {
+    total: summary.total,
+    completed: summary.completed,
+    percentCompleted: summary.percentCompleted
+  };
+}
+var COMPLETED_CHECK_STATES = /* @__PURE__ */ new Set([
+  "SUCCESS",
+  "FAILURE",
+  "ERROR",
+  "NEUTRAL",
+  "CANCELLED",
+  "SKIPPED",
+  "TIMED_OUT",
+  "ACTION_REQUIRED",
+  "STARTUP_FAILURE",
+  "STALE"
+]);
+function isCICompleted(checks) {
+  if (checks.length === 0) return true;
+  if (checks.some((check) => check.state === "FAILURE" || check.state === "ERROR")) return true;
+  return checks.every((check) => COMPLETED_CHECK_STATES.has(check.state));
+}
+async function fetchPRChecks(prNumber) {
+  const output = await execGhAllowExit(["pr", "checks", String(prNumber), "--json", "state"], [0, 1, 8]);
+  if (!output) return [];
+  return JSON.parse(output);
+}
+async function listPullRequestsWithChecks(assignee, label, excludeLabels = []) {
+  const search = ["sort:created-asc", ...excludeLabels.map((l) => `-label:"${l}"`)].join(" ");
+  const args = [
+    "pr",
+    "list",
+    "--state",
+    "open",
+    "--json",
+    "number,title,labels,headRefName",
+    "--search",
+    search,
+    "--limit",
+    "10"
+  ];
+  if (assignee) {
+    args.push("--assignee", assignee);
+  }
+  if (label) {
+    args.push("--label", label);
+  }
+  const output = await execGh(args);
+  const prs = JSON.parse(output);
+  const withChecks = await Promise.all(prs.map(async (pr) => ({ ...pr, checks: await fetchPRChecks(pr.number) })));
+  return withChecks.filter((pr) => isCICompleted(pr.checks));
+}
+async function withRetry(fn, maxRetries = 5, baseDelayMs = 1e3) {
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      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));
+    }
+  }
+  throw new Error("unreachable");
+}
+async function addLabel(type, number, label) {
+  await withRetry(async () => {
+    try {
+      await execGh([type, "edit", String(number), "--add-label", label]);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (message.includes("already exists") || message.includes("already has")) return;
+      throw err;
+    }
+  });
+}
+async function removeLabel(type, number, label) {
+  await withRetry(async () => {
+    try {
+      await execGh([type, "edit", String(number), "--remove-label", label]);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (message.includes("not found") || message.includes("does not exist") || message.includes("could not remove"))
+        return;
+      throw err;
+    }
+  });
+}
+async function commentOnPR(prNumber, body) {
+  await execGh(["pr", "comment", String(prNumber), "--body", body]);
+}
+async function createLabel(name, color, force) {
+  try {
+    const args = ["label", "create", name];
+    if (color) args.push("--color", color);
+    if (force) args.push("--force");
+    await execGh(args);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/config.ts
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+var DEFAULT_WORKER_CONFIG = {
+  skill: "",
+  model: "sonnet",
+  effort: "high",
+  pollingIntervalSeconds: 60,
+  cooldownSeconds: 0,
+  maxConcurrentTasks: 1
+};
+var WORKER_DEFAULTS = {
+  "answer-issue-questions": {
+    skill: "/claude-task-worker:answer-issue-questions",
+    model: "sonnet",
+    effort: "xhigh",
+    pollingIntervalSeconds: 60,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1
+  },
+  "create-issue": {
+    skill: "/claude-task-worker:create-issue-from-issue-number",
+    model: "sonnet",
+    effort: "xhigh",
+    pollingIntervalSeconds: 60,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1
+  },
+  "update-issue": {
+    skill: "/claude-task-worker:update-issue",
+    model: "sonnet",
+    effort: "high",
+    pollingIntervalSeconds: 60,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1
+  },
+  "exec-issue": {
+    skill: "/claude-task-worker:exec-issue",
+    model: "sonnet",
+    effort: "high",
+    pollingIntervalSeconds: 60,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1
+  },
+  "fix-review-point": {
+    skill: "/claude-task-worker:fix-review-point",
+    model: "sonnet",
+    effort: "high",
+    pollingIntervalSeconds: 60,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1
+  },
+  "triage-created-issue": {
+    skill: "/claude-task-worker:triage-created-issue",
+    model: "sonnet",
+    effort: "high",
+    pollingIntervalSeconds: 60,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1
+  },
+  "triage-pr": {
+    skill: "/claude-task-worker:triage-pr",
+    model: "sonnet",
+    effort: "high",
+    pollingIntervalSeconds: 60,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1
+  },
+  "resolve-conflict": {
+    skill: "/claude-task-worker:resolve-pr-conflict",
+    model: "sonnet",
+    effort: "high",
+    pollingIntervalSeconds: 60,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1
+  },
+  "check-dependabot": {
+    skill: "/claude-task-worker:check-dependabot",
+    model: "sonnet",
+    effort: "high",
+    pollingIntervalSeconds: 3600,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1
+  },
+  "epic-issue": {
+    skill: "/claude-task-worker:create-epic-pr",
+    model: "sonnet",
+    effort: "high",
+    pollingIntervalSeconds: 300,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1
+  }
+};
+var DEFAULT_CONFIG = {
+  fixReviewPointCallbackCommentMessage: "",
+  workers: {}
+};
+var CONFIG_PATH = join(process.cwd(), "claude-task-worker.json");
+function defaultsFor(name) {
+  return WORKER_DEFAULTS[name] ?? DEFAULT_WORKER_CONFIG;
+}
+function parseWorkerEntry(name, val) {
+  const base = defaultsFor(name);
+  if (typeof val !== "object" || val === null || Array.isArray(val)) {
+    console.warn(`[config] invalid workers.${name}: expected object, using defaults`);
+    return null;
+  }
+  const entry = val;
+  const result = { ...base };
+  if ("skill" in entry) {
+    if (typeof entry.skill === "string" && entry.skill.length > 0) {
+      result.skill = entry.skill;
+    } else {
+      console.warn(`[config] invalid workers.${name}.skill: ${String(entry.skill)}, using default ${base.skill}`);
+    }
+  }
+  if ("model" in entry) {
+    if (typeof entry.model === "string" && entry.model.length > 0) {
+      result.model = entry.model;
+    } else {
+      console.warn(`[config] invalid workers.${name}.model: ${String(entry.model)}, using default ${base.model}`);
+    }
+  }
+  if ("effort" in entry) {
+    if (typeof entry.effort === "string" && entry.effort.length > 0) {
+      result.effort = entry.effort;
+    } else {
+      console.warn(`[config] invalid workers.${name}.effort: ${String(entry.effort)}, using default ${base.effort}`);
+    }
+  }
+  if ("pollingIntervalSeconds" in entry) {
+    const val2 = entry.pollingIntervalSeconds;
+    if (typeof val2 === "number" && Number.isFinite(val2) && val2 > 0) {
+      result.pollingIntervalSeconds = val2;
+    } else {
+      console.warn(
+        `[config] invalid workers.${name}.pollingIntervalSeconds: ${String(val2)}, using default ${base.pollingIntervalSeconds}`
+      );
+    }
+  }
+  if ("cooldownSeconds" in entry) {
+    const val2 = entry.cooldownSeconds;
+    if (typeof val2 === "number" && Number.isFinite(val2) && val2 >= 0) {
+      result.cooldownSeconds = val2;
+    } else {
+      console.warn(
+        `[config] invalid workers.${name}.cooldownSeconds: ${String(val2)}, using default ${base.cooldownSeconds}`
+      );
+    }
+  }
+  if ("maxConcurrentTasks" in entry) {
+    const val2 = entry.maxConcurrentTasks;
+    if (typeof val2 === "number" && Number.isInteger(val2) && val2 > 0) {
+      result.maxConcurrentTasks = val2;
+    } else {
+      console.warn(
+        `[config] invalid workers.${name}.maxConcurrentTasks: ${String(val2)}, using default ${base.maxConcurrentTasks}`
+      );
+    }
+  }
+  return result;
+}
+function loadConfig() {
+  const configPath = CONFIG_PATH;
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return { ...DEFAULT_CONFIG, workers: {} };
+    }
+    throw err;
+  }
+  const result = { ...DEFAULT_CONFIG, workers: {} };
+  if ("fixReviewPointCallbackCommentMessage" in raw) {
+    const val = raw["fixReviewPointCallbackCommentMessage"];
+    if (typeof val === "string") {
+      result.fixReviewPointCallbackCommentMessage = val;
+    }
+  }
+  if ("workers" in raw) {
+    const workers = raw["workers"];
+    if (typeof workers !== "object" || workers === null || Array.isArray(workers)) {
+      console.warn(`[config] invalid workers: expected object, ignoring`);
+    } else {
+      for (const [name, val] of Object.entries(workers)) {
+        const parsed = parseWorkerEntry(name, val);
+        if (parsed) result.workers[name] = parsed;
+      }
+    }
+  }
+  return result;
+}
+function getWorkerConfig(workerName) {
+  const config = loadConfig();
+  return config.workers[workerName] ?? { ...defaultsFor(workerName) };
+}
+
+// src/git.ts
+import { execSync, execFile as execFile2 } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile2);
+var running = false;
+function syncDefaultBranch(branch) {
+  if (running) return;
+  running = true;
+  try {
+    execSync(
+      `git worktree prune && git checkout ${branch} && git add -A && git reset --hard && git fetch origin ${branch} && git reset --hard origin/${branch}`,
+      { stdio: "pipe" }
+    );
+  } finally {
+    running = false;
+  }
+}
+async function ensureEpicBranch(epicBranch, defaultBranch) {
+  try {
+    await fetchRemoteTracking(epicBranch);
+    await assertRemoteTrackingExists(epicBranch);
+    return;
+  } catch (error) {
+    if (!isMissingRemoteRefError(error)) {
+      throw error;
+    }
+  }
+  await fetchRemoteTracking(defaultBranch);
+  await execFileAsync("git", ["push", "origin", `refs/remotes/origin/${defaultBranch}:refs/heads/${epicBranch}`]);
+  await fetchRemoteTracking(epicBranch);
+  await assertRemoteTrackingExists(epicBranch);
+}
+async function fetchRemoteTracking(branch) {
+  await execFileAsync("git", ["fetch", "--no-prune", "origin", `+refs/heads/${branch}:refs/remotes/origin/${branch}`]);
+}
+function isMissingRemoteRefError(error) {
+  const stderr = String(error?.stderr ?? "");
+  return /couldn't find remote ref/i.test(stderr);
+}
+async function assertRemoteTrackingExists(epicBranch) {
+  await execFileAsync("git", ["rev-parse", "--verify", "--quiet", `refs/remotes/origin/${epicBranch}`]);
+}
+
+// src/process-manager.ts
+import { spawn } from "node:child_process";
+var childProcesses = /* @__PURE__ */ new Map();
+var TASK_TIMEOUT_MS = 90 * 60 * 1e3;
+function getDisplayWidth(str) {
+  let width = 0;
+  for (const char of str) {
+    const code = char.codePointAt(0);
+    if (code >= 4352 && code <= 4447 || code >= 11904 && code <= 12350 || code >= 12352 && code <= 13247 || code >= 13312 && code <= 19903 || code >= 19968 && code <= 42191 || code >= 44032 && code <= 55215 || code >= 63744 && code <= 64255 || code >= 65072 && code <= 65135 || code >= 65281 && code <= 65376 || code >= 65504 && code <= 65510 || code >= 131072 && code <= 196605 || code >= 196608 && code <= 262141) {
+      width += 2;
+    } else {
+      width += 1;
+    }
+  }
+  return width;
+}
+function truncateToWidth(str, maxWidth) {
+  let width = 0;
+  let i = 0;
+  const chars = [...str];
+  while (i < chars.length) {
+    const charWidth = getDisplayWidth(chars[i]);
+    if (width + charWidth > maxWidth - 3) {
+      return chars.slice(0, i).join("") + "...";
+    }
+    width += charWidth;
+    i++;
+  }
+  return str;
+}
+function padToWidth(str, targetWidth) {
+  const currentWidth = getDisplayWidth(str);
+  const padding = targetWidth - currentWidth;
+  return padding > 0 ? str + " ".repeat(padding) : str;
+}
+var tasks = /* @__PURE__ */ new Map();
+var shuttingDown = false;
+function setShuttingDown() {
+  shuttingDown = true;
+}
+function isShuttingDown() {
+  return shuttingDown;
+}
+function isRunning(id) {
+  const task = tasks.get(id);
+  return task?.status === "running";
+}
+function isWorkerAtCapacity(workerName) {
+  let count = 0;
+  for (const task of tasks.values()) {
+    if (task.workerName === workerName && task.status === "running") {
+      count++;
+    }
+  }
+  return count >= getWorkerConfig(workerName).maxConcurrentTasks;
+}
+function formatDuration(start, end = /* @__PURE__ */ new Date()) {
+  const diffMs = end.getTime() - start.getTime();
+  const totalSeconds = Math.floor(diffMs / 1e3);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${minutes}m ${String(seconds).padStart(2, "0")}s`;
+}
+function formatTime(date) {
+  const h = String(date.getHours()).padStart(2, "0");
+  const m = String(date.getMinutes()).padStart(2, "0");
+  const s = String(date.getSeconds()).padStart(2, "0");
+  return `${h}:${m}:${s}`;
+}
+function renderTable() {
+  const entries = [...tasks.values()];
+  if (entries.length === 0) return;
+  const runningTasks = entries.filter((t) => t.status === "running");
+  const finishedTasks = entries.filter((t) => t.status !== "running");
+  const maxTitleWidth = 40;
+  const maxPathWidth = 40;
+  const allRows = [
+    ...runningTasks.map((t) => ({
+      id: `#${t.id}`,
+      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,
+      time: formatTime(t.startedAt),
+      duration: formatDuration(t.startedAt)
+    })),
+    ...finishedTasks.map((t) => ({
+      id: `#${t.id}`,
+      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,
+      time: formatTime(t.finishedAt ?? t.startedAt),
+      duration: formatDuration(t.startedAt, t.finishedAt)
+    }))
+  ];
+  const hasPath = allRows.some((r) => r.path !== "");
+  const colWidths = {
+    id: Math.max(3, ...allRows.map((r) => r.id.length)),
+    title: Math.max(5, ...allRows.map((r) => getDisplayWidth(r.title))),
+    worker: Math.max(6, ...allRows.map((r) => r.worker.length)),
+    ...hasPath ? { path: Math.max(8, ...allRows.map((r) => r.path.length)) } : {},
+    status: Math.max(6, ...allRows.map((r) => r.status.length)),
+    time: Math.max(4, ...allRows.map((r) => r.time.length)),
+    duration: Math.max(8, ...allRows.map((r) => r.duration.length))
+  };
+  const pad = (s, w, useDisplayWidth = false) => useDisplayWidth ? padToWidth(s, w) : s + " ".repeat(w - s.length);
+  const cols = hasPath ? [
+    colWidths.id,
+    colWidths.title,
+    colWidths.worker,
+    colWidths.path,
+    colWidths.status,
+    colWidths.time,
+    colWidths.duration
+  ] : [colWidths.id, colWidths.title, colWidths.worker, colWidths.status, colWidths.time, colWidths.duration];
+  const line = (l, m, r, f) => `${l}${cols.map((w) => f.repeat(w + 2)).join(m)}${r}`;
+  const row = (id, title, worker, path, status, time, duration) => hasPath ? `\u2502 ${pad(id, colWidths.id)} \u2502 ${pad(title, colWidths.title, true)} \u2502 ${pad(worker, colWidths.worker)} \u2502 ${pad(path, colWidths.path)} \u2502 ${pad(status, colWidths.status)} \u2502 ${pad(time, colWidths.time)} \u2502 ${pad(duration, colWidths.duration)} \u2502` : `\u2502 ${pad(id, colWidths.id)} \u2502 ${pad(title, colWidths.title, true)} \u2502 ${pad(worker, colWidths.worker)} \u2502 ${pad(status, colWidths.status)} \u2502 ${pad(time, colWidths.time)} \u2502 ${pad(duration, colWidths.duration)} \u2502`;
+  const lines = [];
+  lines.push(line("\u250C", "\u252C", "\u2510", "\u2500"));
+  lines.push(row("#", "Title", "Worker", "Worktree", "Status", "Time", "Duration"));
+  lines.push(line("\u251C", "\u253C", "\u2524", "\u2500"));
+  for (const r of allRows.filter((r2) => r2.status === "running")) {
+    lines.push(row(r.id, r.title, r.worker, r.path, r.status, r.time, r.duration));
+  }
+  if (runningTasks.length > 0 && finishedTasks.length > 0) {
+    lines.push(line("\u251C", "\u253C", "\u2524", "\u2500"));
+  }
+  for (const r of allRows.filter((r2) => r2.status !== "running")) {
+    lines.push(row(r.id, r.title, r.worker, r.path, r.status, r.time, r.duration));
+  }
+  lines.push(line("\u2514", "\u2534", "\u2518", "\u2500"));
+  console.clear();
+  console.log(lines.join("\n"));
+}
+var renderInterval;
+function ensureRenderInterval() {
+  if (renderInterval) return;
+  renderInterval = setInterval(renderTable, 1e3);
+  renderInterval.unref();
+}
+function run(command, args, id, title, workerName, path, onComplete, cwd) {
+  tasks.set(id, {
+    id,
+    title,
+    status: "running",
+    workerName,
+    path,
+    startedAt: /* @__PURE__ */ new Date()
+  });
+  ensureRenderInterval();
+  renderTable();
+  const child = spawn(command, args, {
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true,
+    ...cwd ? { cwd } : {}
+  });
+  childProcesses.set(id, child);
+  child.stderr?.resume();
+  const outputChunks = [];
+  child.stdout?.on("data", (chunk) => {
+    outputChunks.push(chunk);
+  });
+  let timedOut = false;
+  const timeoutHandle = setTimeout(() => {
+    timedOut = true;
+    console.error(`[worker] task #${id} timed out after ${TASK_TIMEOUT_MS / 1e3}s, terminating`);
+    if (child.pid) {
+      try {
+        process.kill(-child.pid, "SIGTERM");
+      } catch {
+        try {
+          child.kill("SIGTERM");
+        } catch {
+        }
+      }
+    }
+  }, TASK_TIMEOUT_MS);
+  timeoutHandle.unref();
+  child.on("close", async (code) => {
+    clearTimeout(timeoutHandle);
+    const output = Buffer.concat(outputChunks).toString("utf-8") + (timedOut ? `
+[worker] task timed out after ${TASK_TIMEOUT_MS / 1e3}s` : "");
+    const finalStatus = !timedOut && code === 0 ? "completed" : "failed";
+    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();
+    }
+    childProcesses.delete(id);
+    renderTable();
+  });
+  child.on("error", async (err) => {
+    clearTimeout(timeoutHandle);
+    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();
+    }
+    childProcesses.delete(id);
+    renderTable();
+  });
+}
+function waitForAllProcesses() {
+  return new Promise((resolve2) => {
+    const check = () => {
+      if (childProcesses.size === 0) {
+        resolve2();
+      } else {
+        setTimeout(check, 500);
+      }
+    };
+    check();
+  });
+}
+function shutdown(signal = "SIGTERM") {
+  for (const [, child] of childProcesses) {
+    if (!child.pid) continue;
+    try {
+      process.kill(-child.pid, signal);
+    } catch {
+      try {
+        child.kill(signal);
+      } catch {
+      }
+    }
+  }
+}
+
+// src/random-name.ts
+import { randomInt } from "node:crypto";
+var ADJECTIVES = [
+  "brave",
+  "calm",
+  "dark",
+  "eager",
+  "fair",
+  "gentle",
+  "happy",
+  "keen",
+  "lively",
+  "noble",
+  "proud",
+  "quiet",
+  "rapid",
+  "sharp",
+  "swift",
+  "tender",
+  "vivid",
+  "warm",
+  "bold",
+  "bright",
+  "clever",
+  "daring",
+  "fierce",
+  "grand",
+  "humble",
+  "jovial",
+  "kind",
+  "lucky",
+  "mighty",
+  "neat",
+  "agile",
+  "amber",
+  "breezy",
+  "crisp",
+  "deep",
+  "dusty",
+  "elfin",
+  "frosty",
+  "golden",
+  "hardy",
+  "icy",
+  "joyful",
+  "lean",
+  "misty",
+  "nimble",
+  "open",
+  "peppy",
+  "radiant",
+  "serene",
+  "tidy",
+  "upbeat",
+  "valiant",
+  "wiry",
+  "zesty",
+  "ancient",
+  "brisk",
+  "crispy",
+  "deft",
+  "earnest",
+  "fleet",
+  "airy",
+  "ardent",
+  "astute",
+  "azure",
+  "balmy",
+  "blithe",
+  "buoyant",
+  "candid",
+  "cheery",
+  "coastal",
+  "dashing",
+  "dazzling",
+  "devoted",
+  "dynamic",
+  "edgy",
+  "elegant",
+  "enduring",
+  "exotic",
+  "fabled",
+  "faithful",
+  "famous",
+  "fearless",
+  "flawless",
+  "fluent",
+  "focused",
+  "forceful",
+  "forged",
+  "frank",
+  "fresh",
+  "frugal",
+  "gallant",
+  "gifted",
+  "glowing",
+  "graceful",
+  "grounded",
+  "honest",
+  "hopeful",
+  "ideal",
+  "immense",
+  "intact",
+  "intrepid",
+  "ironclad",
+  "ivory",
+  "keen",
+  "knowing",
+  "lavish",
+  "level",
+  "lithe",
+  "lofty",
+  "loyal",
+  "luminous",
+  "majestic",
+  "mellow",
+  "mindful",
+  "modern"
+];
+var NOUNS = [
+  "falcon",
+  "river",
+  "cedar",
+  "flame",
+  "stone",
+  "breeze",
+  "coral",
+  "delta",
+  "frost",
+  "grove",
+  "harbor",
+  "iris",
+  "jade",
+  "lark",
+  "maple",
+  "orbit",
+  "pearl",
+  "ridge",
+  "spark",
+  "tide",
+  "vale",
+  "wolf",
+  "apex",
+  "bloom",
+  "crest",
+  "dawn",
+  "ember",
+  "flint",
+  "hawk",
+  "sage",
+  "arrow",
+  "basin",
+  "cliff",
+  "dune",
+  "echo",
+  "fern",
+  "gale",
+  "helm",
+  "isle",
+  "jungle",
+  "kite",
+  "lance",
+  "marsh",
+  "nova",
+  "oak",
+  "pine",
+  "quill",
+  "reef",
+  "shore",
+  "thorn",
+  "umber",
+  "veil",
+  "wave",
+  "xenon",
+  "yew",
+  "zenith",
+  "acorn",
+  "birch",
+  "comet",
+  "dew",
+  "abyss",
+  "anchor",
+  "anvil",
+  "arc",
+  "ash",
+  "atlas",
+  "aurora",
+  "axe",
+  "bay",
+  "beacon",
+  "blade",
+  "bolt",
+  "brook",
+  "bud",
+  "burl",
+  "cairn",
+  "canopy",
+  "cape",
+  "cavern",
+  "chain",
+  "chalk",
+  "chasm",
+  "chord",
+  "chrome",
+  "citrus",
+  "claw",
+  "cloud",
+  "cobalt",
+  "creek",
+  "crown",
+  "crystal",
+  "current",
+  "cypress",
+  "depot",
+  "depth",
+  "drift",
+  "dusk",
+  "dust",
+  "eddy",
+  "elm",
+  "epoch",
+  "ether",
+  "field",
+  "fin",
+  "fjord",
+  "foam",
+  "forge",
+  "fossil",
+  "geyser",
+  "glacier",
+  "glow",
+  "granite",
+  "heath",
+  "heron",
+  "hollow"
+];
+function pick(list) {
+  return list[randomInt(list.length)];
+}
+function generateWorktreeName() {
+  const suffix = String(randomInt(1e4)).padStart(4, "0");
+  return `${pick(ADJECTIVES)}-${pick(NOUNS)}-${suffix}`;
+}
+
+// src/slack.ts
+import { exec } from "node:child_process";
+import { readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+import { promisify as promisify2 } from "node:util";
+var execAsync = promisify2(exec);
+var WEBHOOK_URL = process.env.CLAUDE_TASK_WORKER_SLACK_WEBHOOK_URL;
+var USAGE_CACHE_PATH = "/tmp/claude-usage-cache.json";
+var USAGE_CACHE_TTL_SECONDS = 360;
+async function send(payload) {
+  if (!WEBHOOK_URL) return;
+  try {
+    await fetch(WEBHOOK_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+  } catch (err) {
+    console.error(`[slack] Failed to send notification: ${err}`);
+  }
+}
+function extractToken(credentials) {
+  if (typeof credentials === "string") return credentials;
+  return credentials.claudeAiOauth?.accessToken ?? credentials.oauth_token ?? credentials.access_token ?? "";
+}
+async function getOAuthToken() {
+  try {
+    const { stdout } = await execAsync('security find-generic-password -s "Claude Code-credentials" -w');
+    return extractToken(JSON.parse(stdout.trim()));
+  } catch {
+    const raw = readFileSync2(join2(homedir(), ".claude", ".credentials.json"), "utf-8");
+    return extractToken(JSON.parse(raw));
+  }
+}
+function readUsageCache() {
+  try {
+    const raw = readFileSync2(USAGE_CACHE_PATH, "utf-8");
+    const cached = JSON.parse(raw);
+    if (Date.now() - cached.timestamp < USAGE_CACHE_TTL_SECONDS * 1e3) {
+      return cached.data;
+    }
+  } catch {
+  }
+  return null;
+}
+function writeUsageCache(data) {
+  try {
+    writeFileSync(USAGE_CACHE_PATH, JSON.stringify({ timestamp: Date.now(), data }));
+  } catch {
+  }
+}
+async function fetchUsageInfo() {
+  const cached = readUsageCache();
+  if (cached) return cached;
+  try {
+    const token = await getOAuthToken();
+    const res = await fetch("https://api.anthropic.com/api/oauth/usage", {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "anthropic-beta": "oauth-2025-04-20"
+      }
+    });
+    if (!res.ok) {
+      console.error(`[slack] Usage API returned ${res.status}`);
+      return null;
+    }
+    const body = await res.json();
+    const data = {
+      fiveHourUtilization: body.five_hour.utilization,
+      fiveHourResetsAt: body.five_hour.resets_at,
+      sevenDayUtilization: body.seven_day.utilization,
+      sevenDayResetsAt: body.seven_day.resets_at
+    };
+    writeUsageCache(data);
+    return data;
+  } catch (err) {
+    console.error(`[slack] Failed to fetch usage info: ${err}`);
+    return null;
+  }
+}
+function utilizationEmoji(value) {
+  if (value < 50) return "\u{1F7E2}";
+  if (value < 80) return "\u{1F7E1}";
+  return "\u{1F534}";
+}
+function formatResetTimeJST(isoString) {
+  const date = new Date(isoString);
+  return date.toLocaleString("ja-JP", {
+    timeZone: "Asia/Tokyo",
+    month: "numeric",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit"
+  });
+}
+async function buildTokenLimitText() {
+  const usage = await fetchUsageInfo();
+  if (!usage) return "";
+  const fiveH = usage.fiveHourUtilization.toFixed(1);
+  const sevenD = usage.sevenDayUtilization.toFixed(1);
+  const emoji = utilizationEmoji(Math.max(usage.fiveHourUtilization, usage.sevenDayUtilization));
+  const fiveHReset = formatResetTimeJST(usage.fiveHourResetsAt);
+  const sevenDReset = formatResetTimeJST(usage.sevenDayResetsAt);
+  return ` | ${emoji} 5h: ${fiveH}% (reset: ${fiveHReset}) / 7d: ${sevenD}% (reset: ${sevenDReset})`;
+}
+async function notifyTaskCompleted(workerName, repoName, id, title, url, output) {
+  const tokenText = await buildTokenLimitText();
+  const truncatedOutput = output && output.length > 1e3 ? `\u2026${output.slice(-1e3)}` : output;
+  const outputBlock = truncatedOutput ? `
+\`\`\`${truncatedOutput}\`\`\`` : "";
+  await send({
+    text: `\u2705 [${workerName}] ${repoName} | Task completed: <${url}|#${id} ${title}>${tokenText}${outputBlock}`
+  });
+}
+async function notifyTaskFailed(workerName, repoName, id, title, url, output) {
+  const tokenText = await buildTokenLimitText();
+  const truncatedOutput = output && output.length > 1e3 ? `\u2026${output.slice(-1e3)}` : output;
+  const outputBlock = truncatedOutput ? `
+\`\`\`${truncatedOutput}\`\`\`` : "";
+  await send({
+    text: `\u274C [${workerName}] ${repoName} | Task failed: <${url}|#${id} ${title}>${tokenText}${outputBlock}`
+  });
+}
+async function notifyError(workerName, repoName, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  await send({
+    text: `\u{1F6A8} [${workerName}] ${repoName} | Error: ${message}`
+  });
+}
+
+// src/worktree.ts
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+import { readdir, rm, stat } from "node:fs/promises";
+import { resolve, sep } from "node:path";
+var execFileAsync2 = promisify3(execFile3);
+var WORKTREES_DIR = ".claude/worktrees";
+function isManagedWorktreePath(path) {
+  return resolve(path).startsWith(resolve(WORKTREES_DIR) + sep);
+}
+async function forceRemoveIfExists(path) {
+  if (!isManagedWorktreePath(path)) {
+    console.error(`[worktree] Refusing to remove path outside ${WORKTREES_DIR}: ${path}`);
+    return;
+  }
+  try {
+    await stat(path);
+  } catch {
+    return;
+  }
+  await rm(path, { recursive: true, force: true });
+  console.log(`[worktree] Force removed remaining directory: ${path}`);
+}
+function getWorktreePath(worktreeId) {
+  return `${WORKTREES_DIR}/${worktreeId}`;
+}
+async function createWorktreeFromBranch(worktreeId, baseBranch) {
+  const worktreePath = `${WORKTREES_DIR}/${worktreeId}`;
+  await execFileAsync2("git", ["worktree", "add", "-B", worktreeId, worktreePath, `origin/${baseBranch}`]);
+}
+async function removeWorktree(worktreeId) {
+  const worktreePath = `${WORKTREES_DIR}/${worktreeId}`;
+  try {
+    await execFileAsync2("git", ["worktree", "remove", "--force", worktreePath]);
+  } catch (error) {
+    console.error(`[worktree] Failed to remove worktree ${worktreeId}:`, error);
+  }
+  await forceRemoveIfExists(worktreePath);
+}
+async function removeWorktreeByBranch(branchName) {
+  try {
+    const { stdout } = await execFileAsync2("git", ["worktree", "list", "--porcelain"]);
+    const entries = stdout.trim().split("\n\n").filter(Boolean);
+    for (const entry of entries) {
+      const branchLine = entry.split("\n").find((l) => l.startsWith("branch "));
+      if (!branchLine) continue;
+      const branch = branchLine.replace("branch refs/heads/", "");
+      if (branch !== branchName) continue;
+      const worktreeLine = entry.split("\n").find((l) => l.startsWith("worktree "));
+      if (!worktreeLine) continue;
+      const worktreePath = worktreeLine.replace("worktree ", "");
+      if (!isManagedWorktreePath(worktreePath)) {
+        console.log(`[worktree] Skipping unmanaged worktree for branch ${branchName}: ${worktreePath}`);
+        continue;
+      }
+      try {
+        await execFileAsync2("git", ["worktree", "remove", "--force", worktreePath]);
+        console.log(`[worktree] Removed worktree for branch ${branchName}: ${worktreePath}`);
+      } catch (error) {
+        console.error(`[worktree] Failed to remove worktree for branch ${branchName}:`, error);
+      }
+      await forceRemoveIfExists(worktreePath);
+    }
+  } catch (error) {
+    console.error(`[worktree] Failed to remove worktree for branch ${branchName}:`, error);
+  }
+}
+
+// src/workers/issue-worker.ts
+var LABEL_TRIAGE_SCOPE = "cc-triage-scope";
+function createIssuePollingWorker(config) {
+  return async () => {
+    const { owner, name, defaultBranch } = await getRepoInfo();
+    const user = await getCurrentUser();
+    const { pollingIntervalSeconds, cooldownSeconds } = getWorkerConfig(config.name);
+    const pollingIntervalMs = pollingIntervalSeconds * 1e3;
+    const cooldownMs = cooldownSeconds * 1e3;
+    console.log(
+      `[${config.name}] Polling issues every ${pollingIntervalSeconds} seconds for ${owner}/${name} (assignee: ${user})`
+    );
+    let lastCompletionAt = 0;
+    const tick = async () => {
+      if (isShuttingDown()) return;
+      if (cooldownMs > 0 && lastCompletionAt > 0 && Date.now() - lastCompletionAt < cooldownMs) return;
+      try {
+        const excludeLabels = ["cc-in-progress", "cc-need-human-check", ...config.excludeLabels ?? []];
+        const epicFilter = config.epicFilters && config.epicFilters.length > 0 ? { owner, repo: name, numbers: config.epicFilters } : void 0;
+        const labels = config.labelFilters && config.labelFilters.length > 0 ? [...config.triggerLabels, ...config.labelFilters] : config.triggerLabels;
+        const candidates = config.ownNumberFilters && config.ownNumberFilters.length > 0 ? await listIssuesByNumbers(user, labels, excludeLabels, config.ownNumberFilters) : await listIssuesByLabel(user, labels, excludeLabels, epicFilter);
+        for (const issue of candidates) {
+          if (isRunning(issue.number)) continue;
+          if (isWorkerAtCapacity(config.name)) break;
+          if (config.preflight) {
+            const action = await config.preflight(issue);
+            if (action === "skip") continue;
+            if (action === "mark-pr-created") {
+              await addLabel("issue", issue.number, "cc-pr-created").catch(
+                (err) => console.error(`[${config.name}] addLabel cc-pr-created failed for #${issue.number}: ${err}`)
+              );
+              continue;
+            }
+          }
+          const hadTriageScope = issue.labels.some((l) => l.name === LABEL_TRIAGE_SCOPE);
+          await addLabel("issue", issue.number, "cc-in-progress");
+          const worktreeId = generateWorktreeName();
+          try {
+            const issueUrl = `https://github.com/${owner}/${name}/issues/${issue.number}`;
+            syncDefaultBranch(defaultBranch);
+            const { model, effort, skill } = getWorkerConfig(config.name);
+            const command = skill || config.command;
+            const parentNumber = issue.parent?.number;
+            let cwd;
+            const claudeArgs = [
+              "-p",
+              `${command} ${issue.number}`,
+              "--dangerously-skip-permissions",
+              "--model",
+              model,
+              "--effort",
+              effort
+            ];
+            if (parentNumber !== void 0) {
+              const epicBranch = `cc-epic-${parentNumber}`;
+              await ensureEpicBranch(epicBranch, defaultBranch);
+              await createWorktreeFromBranch(worktreeId, epicBranch);
+              cwd = getWorktreePath(worktreeId);
+              console.log(
+                `[${config.name}] #${issue.number}: created worktree ${worktreeId} from ${epicBranch} (parent #${parentNumber})`
+              );
+            } else {
+              claudeArgs.push("--worktree", worktreeId);
+            }
+            run(
+              "claude",
+              claudeArgs,
+              issue.number,
+              issue.title,
+              config.name,
+              worktreeId,
+              async (status, output) => {
+                lastCompletionAt = Date.now();
+                for (const label of config.triggerLabels) {
+                  await removeLabel("issue", issue.number, label).catch(
+                    (err) => console.error(`[${config.name}] removeLabel ${label} failed for #${issue.number}: ${err}`)
+                  );
+                }
+                if (hadTriageScope) {
+                  await addLabel("issue", issue.number, LABEL_TRIAGE_SCOPE).catch(
+                    (err) => console.error(
+                      `[${config.name}] addLabel ${LABEL_TRIAGE_SCOPE} failed for #${issue.number}: ${err}`
+                    )
+                  );
+                }
+                try {
+                  if (status === "completed") {
+                    await config.onCompleted?.(issue.number);
+                    await notifyTaskCompleted(config.name, name, issue.number, issue.title, issueUrl, output);
+                  } else {
+                    await notifyTaskFailed(config.name, name, issue.number, issue.title, issueUrl, output);
+                  }
+                } catch (err) {
+                  console.error(`[${config.name}] post-task error for #${issue.number}: ${err}`);
+                } finally {
+                  await removeLabel("issue", issue.number, "cc-in-progress").catch(
+                    (err) => console.error(`[${config.name}] removeLabel cc-in-progress failed for #${issue.number}: ${err}`)
+                  );
+                  await removeWorktree(worktreeId).catch(
+                    (err) => console.error(`[${config.name}] removeWorktree failed for #${issue.number}: ${err}`)
+                  );
+                }
+              },
+              cwd
+            );
+          } catch (err) {
+            console.error(`[${config.name}] setup error for #${issue.number}: ${err}`);
+            await removeLabel("issue", issue.number, "cc-in-progress").catch(() => {
+            });
+            await removeWorktree(worktreeId).catch(() => {
+            });
+            await notifyError(config.name, name, err);
+          }
+        }
+      } catch (err) {
+        console.error(`[${config.name}] tick error: ${err}`);
+        await notifyError(config.name, name, err);
+      }
+    };
+    await tick();
+    setInterval(tick, pollingIntervalMs);
+  };
+}
+
+// src/workers/exec-issue.ts
+var execIssueWorker = (opts = {}) => createIssuePollingWorker({
+  name: "exec-issue",
+  command: "/claude-task-worker:exec-issue",
+  triggerLabels: ["cc-exec-issue"],
+  epicFilters: opts.epicFilters,
+  labelFilters: opts.labelFilters,
+  onCompleted: async (issueNumber) => {
+    await addLabel("issue", issueNumber, "cc-pr-created");
+  }
+})();
+
+// src/workers/pr-worker.ts
+var LABEL_IN_PROGRESS = "cc-in-progress";
+var LABEL_TRIAGE_SCOPE2 = "cc-triage-scope";
+function createPrPollingWorker(config) {
+  return async () => {
+    const { owner, name, defaultBranch } = await getRepoInfo();
+    const user = await getCurrentUser();
+    const { pollingIntervalSeconds, cooldownSeconds } = getWorkerConfig(config.name);
+    const pollingIntervalMs = pollingIntervalSeconds * 1e3;
+    const cooldownMs = cooldownSeconds * 1e3;
+    console.log(
+      `[${config.name}] Polling PRs every ${pollingIntervalSeconds} seconds for ${owner}/${name} (assignee: ${user})`
+    );
+    let lastCompletionAt = 0;
+    const tick = async () => {
+      if (isShuttingDown()) return;
+      if (cooldownMs > 0 && lastCompletionAt > 0 && Date.now() - lastCompletionAt < cooldownMs) return;
+      try {
+        const excludeLabels = [LABEL_IN_PROGRESS, ...config.excludeLabels ?? []];
+        const candidates = await listPullRequestsWithChecks(user, config.triggerLabel, excludeLabels);
+        for (const pr of candidates) {
+          if (isRunning(pr.number)) continue;
+          if (isWorkerAtCapacity(config.name)) break;
+          const prUrl = `https://github.com/${owner}/${name}/pull/${pr.number}`;
+          const hadTriageScope = pr.labels.some((l) => l.name === LABEL_TRIAGE_SCOPE2);
+          await addLabel("pr", pr.number, LABEL_IN_PROGRESS);
+          try {
+            await removeWorktreeByBranch(pr.headRefName);
+            const worktreeId = generateWorktreeName();
+            syncDefaultBranch(defaultBranch);
+            const { model, effort, skill } = getWorkerConfig(config.name);
+            const command = skill || config.command;
+            run(
+              "claude",
+              [
+                "-p",
+                `${command} ${pr.number}`,
+                "--dangerously-skip-permissions",
+                "--model",
+                model,
+                "--effort",
+                effort,
+                "--worktree",
+                worktreeId
+              ],
+              pr.number,
+              `PR #${pr.number} (${pr.headRefName})`,
+              config.name,
+              worktreeId,
+              async (status, output) => {
+                lastCompletionAt = Date.now();
+                try {
+                  if (status === "completed") {
+                    await config.onCompleted?.(pr);
+                    await notifyTaskCompleted(config.name, name, pr.number, pr.title, prUrl, output);
+                  } else {
+                    await notifyTaskFailed(config.name, name, pr.number, pr.title, prUrl, output);
+                  }
+                } catch (err) {
+                  console.error(`[${config.name}] post-task error for PR #${pr.number}: ${err}`);
+                } finally {
+                  await removeLabel("pr", pr.number, config.triggerLabel).catch(
+                    (err) => console.error(
+                      `[${config.name}] removeLabel ${config.triggerLabel} failed for PR #${pr.number}: ${err}`
+                    )
+                  );
+                  if (hadTriageScope) {
+                    await addLabel("pr", pr.number, LABEL_TRIAGE_SCOPE2).catch(
+                      (err) => console.error(
+                        `[${config.name}] addLabel ${LABEL_TRIAGE_SCOPE2} failed for PR #${pr.number}: ${err}`
+                      )
+                    );
+                  }
+                  if (config.onFinally) {
+                    await config.onFinally(pr).catch((err) => console.error(`[${config.name}] onFinally failed for PR #${pr.number}: ${err}`));
+                  }
+                  await removeLabel("pr", pr.number, LABEL_IN_PROGRESS).catch(
+                    (err) => console.error(
+                      `[${config.name}] removeLabel ${LABEL_IN_PROGRESS} failed for PR #${pr.number}: ${err}`
+                    )
+                  );
+                  await removeWorktree(worktreeId).catch(
+                    (err) => console.error(`[${config.name}] removeWorktree failed for PR #${pr.number}: ${err}`)
+                  );
+                }
+              }
+            );
+          } catch (err) {
+            console.error(`[${config.name}] setup error for PR #${pr.number}: ${err}`);
+            await removeLabel("pr", pr.number, LABEL_IN_PROGRESS).catch(() => {
+            });
+            await notifyError(config.name, name, err);
+          }
+        }
+      } catch (err) {
+        console.error(`[${config.name}] tick error: ${err}`);
+        await notifyError(config.name, name, err);
+      }
+    };
+    await tick();
+    setInterval(tick, pollingIntervalMs);
+  };
+}
+
+// src/workers/fix-review-point.ts
+var fixReviewPointWorker = createPrPollingWorker({
+  name: "fix-review-point",
+  command: "/claude-task-worker:fix-review-point",
+  triggerLabel: "cc-fix-onetime",
+  onCompleted: async (pr) => {
+    const config = loadConfig();
+    if (config.fixReviewPointCallbackCommentMessage) {
+      try {
+        await commentOnPR(pr.number, config.fixReviewPointCallbackCommentMessage);
+      } catch (err) {
+        console.error(`[fix-review-point] failed to post comment on PR #${pr.number}: ${err}`);
+      }
+    }
+  }
+});
+
+// src/workers/create-issue.ts
+var createIssueWorker = (opts = {}) => createIssuePollingWorker({
+  name: "create-issue",
+  command: "/claude-task-worker:create-issue-from-issue-number",
+  triggerLabels: ["cc-triage-scope"],
+  excludeLabels: [
+    "cc-issue-created",
+    "cc-pr-created",
+    "cc-update-issue",
+    "cc-answer-issue-questions",
+    "cc-exec-issue"
+  ],
+  epicFilters: opts.epicFilters,
+  labelFilters: opts.labelFilters,
+  onCompleted: async (issueNumber) => {
+    await addLabel("issue", issueNumber, "cc-issue-created");
+  }
+})();
+
+// src/workers/update-issue.ts
+var updateIssueWorker = (opts = {}) => createIssuePollingWorker({
+  name: "update-issue",
+  command: "/claude-task-worker:update-issue",
+  triggerLabels: ["cc-update-issue"],
+  epicFilters: opts.epicFilters,
+  labelFilters: opts.labelFilters
+})();
+
+// src/workers/answer-issue-questions.ts
+var answerIssueQuestionsWorker = (opts = {}) => createIssuePollingWorker({
+  name: "answer-issue-questions",
+  command: "/claude-task-worker:answer-issue-questions",
+  triggerLabels: ["cc-answer-issue-questions"],
+  epicFilters: opts.epicFilters,
+  labelFilters: opts.labelFilters,
+  onCompleted: async (issueNumber) => {
+    await addLabel("issue", issueNumber, "cc-update-issue");
+  }
+})();
+
+// src/workers/triage-created-issue.ts
+var triageCreatedIssueWorker = (opts = {}) => createIssuePollingWorker({
+  name: "triage-created-issue",
+  command: "/claude-task-worker:triage-created-issue",
+  triggerLabels: ["cc-issue-created", "cc-triage-scope"],
+  excludeLabels: ["cc-pr-created", "cc-update-issue", "cc-answer-issue-questions", "cc-exec-issue"],
+  epicFilters: opts.epicFilters,
+  labelFilters: opts.labelFilters,
+  onCompleted: async (issueNumber) => {
+    await addLabel("issue", issueNumber, "cc-issue-created");
+  }
+})();
+
+// src/workers/triage-pr.ts
+var triagePrWorker = createPrPollingWorker({
+  name: "triage-pr",
+  command: "/claude-task-worker:triage-pr",
+  triggerLabel: "cc-triage-scope",
+  excludeLabels: ["cc-fix-onetime", "cc-resolve-conflict"]
+});
+
+// src/workers/resolve-conflict.ts
+var resolveConflictWorker = createPrPollingWorker({
+  name: "resolve-conflict",
+  command: "/claude-task-worker:resolve-pr-conflict",
+  triggerLabel: "cc-resolve-conflict"
+});
+
+// src/workers/check-dependabot.ts
+var checkDependabotWorker = createPrPollingWorker({
+  name: "check-dependabot",
+  command: "/claude-task-worker:check-dependabot",
+  triggerLabel: "dependencies",
+  excludeLabels: ["cc-triage-scope"],
+  onCompleted: async (pr) => {
+    await addLabel("pr", pr.number, "cc-triage-scope");
+  }
+});
+
+// src/workers/epic-issue.ts
+var epicIssueWorker = (opts = {}) => createIssuePollingWorker({
+  name: "epic-issue",
+  command: "/claude-task-worker:create-epic-pr",
+  triggerLabels: ["cc-epic-issue"],
+  excludeLabels: ["cc-pr-created"],
+  ownNumberFilters: opts.epicFilters,
+  labelFilters: opts.labelFilters,
+  preflight: async (epic) => {
+    const summary = await getIssueSubIssuesSummary(epic.number);
+    if (summary.total === 0) return "skip";
+    if (summary.completed !== summary.total) return "skip";
+    return "proceed";
+  },
+  onCompleted: async (issueNumber) => {
+    await addLabel("issue", issueNumber, "cc-pr-created");
+  }
+})();
+
+// src/commands/init.ts
+import { mkdir, writeFile, access } from "node:fs/promises";
+var LABELS = [
+  { name: "cc-update-issue", color: "e4e669" },
+  { name: "cc-answer-issue-questions", color: "5319e7" },
+  { name: "cc-exec-issue", color: "7057ff" },
+  { name: "cc-fix-onetime", color: "d93f0b" },
+  { name: "cc-in-progress", color: "0e8a16" },
+  { name: "cc-need-human-check", color: "b60205" },
+  { name: "cc-issue-created", color: "f9a825" },
+  { name: "cc-pr-created", color: "006b75" },
+  { name: "cc-triage-scope", color: "c5def5" },
+  { name: "cc-resolve-conflict", color: "fbca04" },
+  { name: "cc-epic-issue", color: "8b5cf6" }
+];
+var ISSUE_TEMPLATE = `name: "[claude-task-worker] Issue\u4F5C\u6210\u4F9D\u983C"
+description: claude-task-worker\u3067GitHub Issue\u3092\u4F5C\u6210\u3059\u308B
+title: "[claude-task-worker] Issue\u4F5C\u6210\u4F9D\u983C"
+labels:
+  - cc-triage-scope
+body:
+  - type: textarea
+    id: request
+    attributes:
+      label: \u4F9D\u983C\u5185\u5BB9
+      description: \u4F5C\u6210\u3057\u3066\u307B\u3057\u3044Issue\u306E\u5185\u5BB9\u3092\u8A18\u8FF0\u3057\u3066\u304F\u3060\u3055\u3044
+    validations:
+      required: true
+`;
+var ASSIGN_CREATOR_WORKFLOW = `name: Assign creator on cc-triage-scope
+
+on:
+  issues:
+    types: [opened]
+
+jobs:
+  assign:
+    if: contains(github.event.issue.labels.*.name, 'cc-triage-scope')
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+    steps:
+      - uses: actions/github-script@v9
+        with:
+          script: |
+            await github.rest.issues.addAssignees({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: context.issue.number,
+              assignees: [context.payload.issue.user.login]
+            });
+`;
+async function writeFileWithMode(path, content, force) {
+  try {
+    await access(path);
+    if (!force) return "skipped";
+    await writeFile(path, content, "utf-8");
+    return "overwritten";
+  } catch {
+    await writeFile(path, content, "utf-8");
+    return "created";
+  }
+}
+function logWriteResult(result, path) {
+  if (result === "created") console.log(`[init] Created: ${path}`);
+  else if (result === "overwritten") console.log(`[init] Overwritten: ${path}`);
+  else console.log(`[init] Already exists: ${path}`);
+}
+async function createConfig(force) {
+  const initialConfig = { ...DEFAULT_CONFIG, workers: { ...WORKER_DEFAULTS } };
+  const result = await writeFileWithMode(CONFIG_PATH, JSON.stringify(initialConfig, null, 2), force);
+  logWriteResult(result, CONFIG_PATH);
+}
+async function init(options = {}) {
+  const force = options.force ?? false;
+  console.log(`[init] Creating labels...${force ? " (force mode)" : ""}`);
+  for (const label of LABELS) {
+    const ok = await createLabel(label.name, label.color, true);
+    if (ok) {
+      console.log(`[init] Ensured label: ${label.name}`);
+    } else {
+      console.log(`[init] Failed to create label: ${label.name}`);
+    }
+  }
+  console.log("[init] Creating issue template...");
+  await mkdir(".github/ISSUE_TEMPLATE", { recursive: true });
+  const templatePath = ".github/ISSUE_TEMPLATE/cc-triage-scope.yml";
+  logWriteResult(await writeFileWithMode(templatePath, ISSUE_TEMPLATE, force), templatePath);
+  console.log("[init] Creating GitHub Actions workflow...");
+  await mkdir(".github/workflows", { recursive: true });
+  const workflowPath = ".github/workflows/assign-creator-on-cc-triage-scope.yml";
+  logWriteResult(await writeFileWithMode(workflowPath, ASSIGN_CREATOR_WORKFLOW, force), workflowPath);
+  console.log("[init] Creating config file...");
+  await createConfig(force);
+  console.log("[init] Done.");
+}
+
+// src/commands/run-command.ts
+import { spawn as spawn2 } from "node:child_process";
+function runCommand(command, args) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn2(command, args, {
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    const forwardSignal = (signal) => {
+      child.kill(signal);
+    };
+    const onSigint = () => forwardSignal("SIGINT");
+    const onSigterm = () => forwardSignal("SIGTERM");
+    const cleanup = () => {
+      process.removeListener("SIGINT", onSigint);
+      process.removeListener("SIGTERM", onSigterm);
+    };
+    process.once("SIGINT", onSigint);
+    process.once("SIGTERM", onSigterm);
+    child.on("error", (err) => {
+      cleanup();
+      reject(err);
+    });
+    child.on("close", (code) => {
+      cleanup();
+      if (code === 0) {
+        resolve2();
+      } else {
+        reject(new Error(`${command} ${args.join(" ")} exited with code ${code}`));
+      }
+    });
+  });
+}
+
+// src/commands/install.ts
+var PLUGIN_NAME = "claude-task-worker";
+var MARKETPLACE_NAME = "claude-task-worker";
+var MARKETPLACE_SOURCE = "getty104/claude-task-worker";
+async function addMarketplace() {
+  console.log(`[install] Adding marketplace: ${MARKETPLACE_SOURCE}...`);
+  try {
+    await runCommand("claude", ["plugin", "marketplace", "add", MARKETPLACE_SOURCE]);
+    console.log("[install] Marketplace added.");
+  } catch (err) {
+    console.error(
+      `[install] Failed to add marketplace (already added is expected and safe to ignore): ${err.message}`
+    );
+  }
+}
+async function installPlugin() {
+  console.log(`[install] Installing plugin: ${PLUGIN_NAME}@${MARKETPLACE_NAME}...`);
+  try {
+    await runCommand("claude", ["plugin", "install", `${PLUGIN_NAME}@${MARKETPLACE_NAME}`]);
+    console.log("[install] Plugin installed. Restart your Claude Code session to apply.");
+    return true;
+  } catch (err) {
+    console.error(`[install] Failed to install plugin: ${err.message}`);
+    return false;
+  }
+}
+async function installCli() {
+  console.log("[install] Installing claude-task-worker CLI (npm install -g claude-task-worker@latest)...");
+  try {
+    await runCommand("npm", ["install", "-g", "claude-task-worker@latest"]);
+    console.log("[install] claude-task-worker CLI installed.");
+    return true;
+  } catch (err) {
+    console.error(`[install] Failed to install claude-task-worker CLI: ${err.message}`);
+    return false;
+  }
+}
+async function install() {
+  console.log("[install] Starting install...");
+  await addMarketplace();
+  const pluginOk = await installPlugin();
+  const cliOk = await installCli();
+  if (!pluginOk || !cliOk) {
+    process.exitCode = 1;
+  }
+  console.log("[install] Done.");
+}
+
+// src/commands/update.ts
+var PLUGIN_NAME2 = "claude-task-worker";
+var MARKETPLACE_NAME2 = "claude-task-worker";
+async function updateMarketplace() {
+  console.log(`[update] Updating marketplace: ${MARKETPLACE_NAME2}...`);
+  try {
+    await runCommand("claude", ["plugin", "marketplace", "update", MARKETPLACE_NAME2]);
+    console.log("[update] Marketplace updated.");
+    return true;
+  } catch (err) {
+    console.error(`[update] Failed to update marketplace: ${err.message}`);
+    return false;
+  }
+}
+async function updatePlugin() {
+  console.log(`[update] Updating plugin: ${PLUGIN_NAME2}@${MARKETPLACE_NAME2}...`);
+  try {
+    await runCommand("claude", ["plugin", "update", `${PLUGIN_NAME2}@${MARKETPLACE_NAME2}`]);
+    console.log("[update] Plugin updated. Restart your Claude Code session to apply the update.");
+    return true;
+  } catch (err) {
+    console.error(`[update] Failed to update plugin: ${err.message}`);
+    return false;
+  }
+}
+async function updateCli() {
+  console.log("[update] Updating claude-task-worker CLI (npm install -g claude-task-worker@latest)...");
+  try {
+    await runCommand("npm", ["install", "-g", "claude-task-worker@latest"]);
+    console.log("[update] claude-task-worker CLI updated.");
+    return true;
+  } catch (err) {
+    console.error(`[update] Failed to update claude-task-worker CLI: ${err.message}`);
+    return false;
+  }
+}
+async function update() {
+  console.log("[update] Starting update...");
+  const marketplaceOk = await updateMarketplace();
+  const pluginOk = await updatePlugin();
+  const cliOk = await updateCli();
+  if (!marketplaceOk || !pluginOk || !cliOk) {
+    process.exitCode = 1;
+  }
+  console.log("[update] Done.");
+}
+
+// src/index.ts
+var WORKERS = {
+  "exec-issue": execIssueWorker,
+  "fix-review-point": fixReviewPointWorker,
+  "create-issue": createIssueWorker,
+  "update-issue": updateIssueWorker,
+  "answer-issue-questions": answerIssueQuestionsWorker,
+  "triage-created-issue": triageCreatedIssueWorker,
+  "triage-pr": triagePrWorker,
+  "resolve-conflict": resolveConflictWorker,
+  "check-dependabot": checkDependabotWorker,
+  "epic-issue": epicIssueWorker
+};
+function printUsage() {
+  console.log(`Usage: claude-task-worker <command> [--epic <issue-number>] [--label <label-name>]
+
+Commands:
+  init [--force]    Create required GitHub labels and config file (use --force to overwrite existing files)
+  install           Add the claude-task-worker marketplace, install the plugin, and install/update the CLI
+  update            Update the claude-task-worker plugin/marketplace and the CLI itself
+  usage             Notify current usage to Slack
+
+Workers:
+  exec-issue        Poll issues and run /exec-issue
+  fix-review-point  Poll PRs and run /fix-review-point
+  create-issue      Poll issues and run /create-issue
+  update-issue      Poll issues and run update command
+  answer-issue-questions  Poll issues and run /answer-issue-questions
+  triage-created-issue  Poll cc-issue-created + cc-triage-scope issues and run /triage-created-issue
+  triage-pr         Poll and triage PRs every 5 minutes
+  resolve-conflict  Poll cc-resolve-conflict PRs and run /resolve-conflict
+  check-dependabot  Poll dependabot PRs every 1 hour
+  epic-issue        Poll cc-epic-issue issues and create epic PR when all sub-issues are closed
+  all               Poll all workers except triage-created-issue, triage-pr, check-dependabot
+  yolo              Poll all workers including triage-created-issue, triage-pr, check-dependabot
+
+Options:
+  --epic <number>   Limit issue-based workers to sub-issues of the specified epic issue. Repeatable: any matching parent (OR).
+  --label <name>    Limit issue-based workers to issues that also carry the specified label. Repeatable: all must be present (AND).
+
+Example:
+  claude-task-worker init
+  claude-task-worker exec-issue
+  claude-task-worker all --epic 100
+  claude-task-worker all --epic 100 --epic 200
+  claude-task-worker all --label priority-high
+  claude-task-worker all --label priority-high --label needs-design
+  claude-task-worker yolo --epic 100 --epic 200 --label priority-high`);
+}
+var workerType = process.argv[2];
+if (!workerType) {
+  printUsage();
+  process.exit(1);
+}
+if (workerType !== "all" && workerType !== "yolo" && workerType !== "init" && workerType !== "install" && workerType !== "update" && workerType !== "usage" && !WORKERS[workerType]) {
+  console.error(`Unknown command: ${workerType}`);
+  printUsage();
+  process.exit(1);
+}
+function collectFlagValues(flag) {
+  const values = [];
+  for (let i = 0; i < process.argv.length; i++) {
+    if (process.argv[i] !== flag) continue;
+    const raw = process.argv[i + 1];
+    if (!raw || raw.startsWith("--")) {
+      console.error(`${flag} requires a value`);
+      process.exit(1);
+    }
+    values.push(raw);
+  }
+  return values;
+}
+function parseEpicFilters() {
+  const raws = collectFlagValues("--epic");
+  return raws.map((raw) => {
+    const num = Number(raw);
+    if (!Number.isFinite(num) || !Number.isInteger(num) || num <= 0) {
+      console.error(`--epic requires a positive integer issue number, got: ${raw}`);
+      process.exit(1);
+    }
+    return num;
+  });
+}
+function parseLabelFilters() {
+  return collectFlagValues("--label");
+}
+process.on("unhandledRejection", (err) => {
+  console.error("[worker] unhandled rejection:", err);
+  process.exit(1);
+});
+process.on("SIGTERM", async () => {
+  if (isShuttingDown()) return;
+  setShuttingDown();
+  console.log(
+    "\n[worker] Stopping new tasks. Waiting for in-flight tasks to finish... (Send SIGTERM again to force kill)"
+  );
+  await waitForAllProcesses();
+  process.exit(0);
+});
+var forceKilling = false;
+process.on("SIGINT", async () => {
+  if (isShuttingDown()) {
+    if (forceKilling) return;
+    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());
+    await Promise.race([waitForAllProcesses(), cleanupTimeout]);
+    process.exit(1);
+  }
+  setShuttingDown();
+  console.log(
+    "\n[worker] Stopping new tasks. Waiting for in-flight tasks to finish... (Press Ctrl-C again to force kill)"
+  );
+  await waitForAllProcesses();
+  process.exit(0);
+});
+if (workerType === "init") {
+  const force = process.argv.slice(3).includes("--force");
+  init({ force });
+} else if (workerType === "install") {
+  (async () => {
+    await install();
+  })();
+} else if (workerType === "update") {
+  (async () => {
+    await update();
+  })();
+} else if (workerType === "usage") {
+  (async () => {
+    const text = await buildTokenLimitText();
+    if (!text) {
+      console.error("Failed to fetch usage info");
+      process.exit(1);
+    }
+    console.log(text.trim());
+    await send({ text: `\u{1F4CA} Usage${text}` });
+  })();
+} else if (workerType === "all") {
+  const epicFilters = parseEpicFilters();
+  const labelFilters = parseLabelFilters();
+  Promise.all([
+    execIssueWorker({ epicFilters, labelFilters }),
+    fixReviewPointWorker(),
+    createIssueWorker({ epicFilters, labelFilters }),
+    updateIssueWorker({ epicFilters, labelFilters }),
+    answerIssueQuestionsWorker({ epicFilters, labelFilters }),
+    resolveConflictWorker(),
+    epicIssueWorker({ epicFilters, labelFilters })
+  ]);
+} else if (workerType === "yolo") {
+  const epicFilters = parseEpicFilters();
+  const labelFilters = parseLabelFilters();
+  (async () => {
+    await Promise.all([
+      execIssueWorker({ epicFilters, labelFilters }),
+      fixReviewPointWorker(),
+      createIssueWorker({ epicFilters, labelFilters }),
+      updateIssueWorker({ epicFilters, labelFilters }),
+      answerIssueQuestionsWorker({ epicFilters, labelFilters }),
+      triageCreatedIssueWorker({ epicFilters, labelFilters }),
+      checkDependabotWorker(),
+      triagePrWorker(),
+      resolveConflictWorker(),
+      epicIssueWorker({ epicFilters, labelFilters })
+    ]);
+  })();
+} else {
+  const epicFilters = parseEpicFilters();
+  const labelFilters = parseLabelFilters();
+  WORKERS[workerType]({ epicFilters, labelFilters });
+}