claude-task-worker 0.115.0 → 0.117.0

package/dist/chunk-FAD5CNP4.js

@@ -0,0 +1,3396 @@
+import {
+  CLOUD_WORKTREE_LABEL,
+  TASK_DISPLAY_LIMIT,
+  buildLogTableLines,
+  buildTaskTableLines,
+  logLines,
+  pushLogLine,
+  selectRecentTasks,
+  writeScreen
+} from "./chunk-N42YU3GJ.js";
+
+// src/gh.ts
+import { createRequire } from "node:module";
+var childProcess = createRequire(import.meta.url)("node:child_process");
+function execGh(args) {
+  return new Promise((resolve5, reject) => {
+    childProcess.execFile("gh", args, (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error(`gh ${args.join(" ")} failed: ${stderr || error.message}`));
+        return;
+      }
+      resolve5(stdout.trim());
+    });
+  });
+}
+function execGhAllowExit(args, allowedCodes) {
+  return new Promise((resolve5, reject) => {
+    childProcess.execFile("gh", args, (error, stdout, stderr) => {
+      if (error) {
+        const code = error.code;
+        if (typeof code === "number" && allowedCodes.includes(code)) {
+          resolve5(stdout.trim());
+          return;
+        }
+        reject(new Error(`gh ${args.join(" ")} failed: ${stderr || error.message}`));
+        return;
+      }
+      resolve5(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, limit = 10) {
+  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",
+    String(limit)
+  ]);
+  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 findOpenPrNumberByHeadRef(headRefName) {
+  return findPrNumberByHeadRef(headRefName, "open");
+}
+async function findPrNumberByHeadRef(headRefName, state = "open") {
+  const output = await execGh([
+    "pr",
+    "list",
+    "--state",
+    state,
+    "--head",
+    headRefName,
+    "--json",
+    "number",
+    "--limit",
+    "1"
+  ]);
+  const prs = JSON.parse(output);
+  return prs.length > 0 ? prs[0].number : null;
+}
+async function findPrStateByHeadRef(headRefName) {
+  const output = await execGh([
+    "pr",
+    "list",
+    "--state",
+    "all",
+    "--head",
+    headRefName,
+    "--json",
+    "number,state,mergedAt",
+    "--limit",
+    "1"
+  ]);
+  const prs = JSON.parse(output);
+  if (prs.length === 0) return null;
+  return { number: prs[0].number, state: prs[0].state, mergedAt: prs[0].mergedAt ?? null };
+}
+async function getPrMergeable(prNumber) {
+  const output = await execGh(["pr", "view", String(prNumber), "--json", "mergeable"]);
+  const parsed = JSON.parse(output);
+  return typeof parsed?.mergeable === "string" ? parsed.mergeable : "UNKNOWN";
+}
+async function getIssueBody(issueNumber) {
+  const output = await execGh(["issue", "view", String(issueNumber), "--json", "body"]);
+  const parsed = JSON.parse(output);
+  return typeof parsed?.body === "string" ? parsed.body : "";
+}
+async function getIssueState(issueNumber) {
+  const output = await execGh(["issue", "view", String(issueNumber), "--json", "state"]);
+  const parsed = JSON.parse(output);
+  return parsed.state;
+}
+async function listPrsClosingIssue(issueNumber) {
+  const { owner, name } = await getRepoInfo();
+  const query = `query($owner: String!, $name: String!, $number: Int!) {
+    repository(owner: $owner, name: $name) {
+      issue(number: $number) {
+        closedByPullRequestsReferences(first: 10, includeClosedPrs: true) { nodes { number state headRefName baseRefName createdAt } }
+      }
+    }
+  }`;
+  const output = await execGh([
+    "api",
+    "graphql",
+    "-f",
+    `query=${query}`,
+    "-F",
+    `owner=${owner}`,
+    "-F",
+    `name=${name}`,
+    "-F",
+    `number=${issueNumber}`
+  ]);
+  const parsed = JSON.parse(output);
+  const nodes = parsed?.data?.repository?.issue?.closedByPullRequestsReferences?.nodes ?? [];
+  return nodes.map((node) => ({
+    number: node.number,
+    state: node.state ?? "",
+    headRefName: node.headRefName ?? "",
+    baseRefName: node.baseRefName ?? "",
+    createdAt: node.createdAt ?? ""
+  }));
+}
+async function fetchPrRef(owner, name, prNumber) {
+  try {
+    const parsed = JSON.parse(await execGh(["api", `repos/${owner}/${name}/pulls/${prNumber}`]));
+    return {
+      number: prNumber,
+      state: parsed?.merged_at ? "MERGED" : String(parsed?.state ?? "").toUpperCase(),
+      headRefName: parsed?.head?.ref ?? "",
+      baseRefName: parsed?.base?.ref ?? "",
+      createdAt: parsed?.created_at ?? "",
+      body: typeof parsed?.body === "string" ? parsed.body : ""
+    };
+  } catch (err) {
+    console.error(`[gh] failed to read PR #${prNumber}: ${err}`);
+    return null;
+  }
+}
+async function getPrDetail(prNumber) {
+  const { owner, name } = await getRepoInfo();
+  return fetchPrRef(owner, name, prNumber);
+}
+async function closeIssue(issueNumber, reason = "completed") {
+  const { owner, name } = await getRepoInfo();
+  await execGh([
+    "api",
+    "-X",
+    "PATCH",
+    `repos/${owner}/${name}/issues/${issueNumber}`,
+    "-f",
+    "state=closed",
+    "-f",
+    `state_reason=${reason}`
+  ]);
+}
+function parseClosingIssueNumbers(body) {
+  const pattern = /\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)\s*:?\s*#(\d+)\b(?!\d)/gi;
+  return [...new Set([...body.matchAll(pattern)].map((m) => Number(m[1])))];
+}
+function bodyClosesIssue(body, issueNumber) {
+  const pattern = new RegExp(`\\b(close[sd]?|fix(?:e[sd])?|resolve[sd]?)\\s*:?\\s*#${issueNumber}\\b(?!\\d)`, "i");
+  return pattern.test(body);
+}
+async function listPrsCrossReferencingIssue(issueNumber) {
+  const { owner, name } = await getRepoInfo();
+  const output = await execGh(["api", `repos/${owner}/${name}/issues/${issueNumber}/timeline`, "--paginate"]);
+  const events = JSON.parse(output);
+  const numbers = [
+    ...new Set(
+      events.filter(
+        (e) => e.event === "cross-referenced" && e.source?.issue?.pull_request != null && e.source.issue.repository?.full_name === `${owner}/${name}` && typeof e.source.issue.number === "number"
+      ).map((e) => e.source?.issue?.number)
+    )
+  ];
+  const refs = await Promise.all(numbers.map((number) => fetchPrRef(owner, name, number)));
+  return refs.filter((ref) => ref !== null && bodyClosesIssue(ref.body, issueNumber)).map(({ body: _body, ...ref }) => ref);
+}
+var ADD_CLOSE_ISSUE_REFERENCES = `mutation($issueId: ID!, $prId: ID!) {
+  addCloseIssueReferences(input: { issueId: $issueId, pullRequestIds: [$prId] }) { issue { number } }
+}`;
+async function linkClosingPr(issueNumber, prNumber) {
+  const { owner, name } = await getRepoInfo();
+  const issueId = JSON.parse(await execGh(["api", `repos/${owner}/${name}/issues/${issueNumber}`]))?.node_id;
+  const prId = JSON.parse(await execGh(["api", `repos/${owner}/${name}/pulls/${prNumber}`]))?.node_id;
+  if (typeof issueId !== "string" || typeof prId !== "string") {
+    throw new Error(`node_id not found (issue #${issueNumber} / PR #${prNumber})`);
+  }
+  await execGh([
+    "api",
+    "graphql",
+    "-f",
+    `query=${ADD_CLOSE_ISSUE_REFERENCES}`,
+    "-F",
+    `issueId=${issueId}`,
+    "-F",
+    `prId=${prId}`
+  ]);
+}
+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 = [], limit = 5) {
+  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",
+    String(limit)
+  ];
+  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((resolve5) => setTimeout(resolve5, 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 addAssignee(type, number, login) {
+  await withRetry(async () => {
+    await execGh([type, "edit", String(number), "--add-assignee", login]);
+  });
+}
+async function hasLabel(type, number, label) {
+  return withRetry(async () => {
+    const output = await execGh([type, "view", String(number), "--json", "labels"]);
+    const parsed = JSON.parse(output);
+    const labels = parsed?.labels ?? [];
+    return labels.some((l) => l.name === label);
+  });
+}
+async function findCommentSince(number, since, heading) {
+  const output = await execGh(["api", `repos/{owner}/{repo}/issues/${number}/comments?since=${since.toISOString()}`]);
+  const comments = JSON.parse(output);
+  const matched = comments.filter((comment) => comment.body.split("\n").some((line) => line.trim() === heading));
+  if (matched.length === 0) {
+    return null;
+  }
+  return matched[matched.length - 1].body;
+}
+async function listNumbersWithLabel(type, label, limit = 50) {
+  const output = await execGh([
+    type,
+    "list",
+    "--label",
+    label,
+    "--state",
+    "all",
+    "--json",
+    "number",
+    "--limit",
+    String(limit)
+  ]);
+  const parsed = JSON.parse(output);
+  return parsed.map((entry) => entry.number);
+}
+async function hasOpenBlockers(issueNumber) {
+  return withRetry(async () => {
+    const output = await execGh(["issue", "view", String(issueNumber), "--json", "blockedBy"]);
+    const parsed = JSON.parse(output);
+    const nodes = parsed?.blockedBy?.nodes ?? [];
+    return nodes.some((node) => node.state === "OPEN");
+  });
+}
+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 commentOnIssue(issueNumber, body) {
+  await execGh(["issue", "comment", String(issueNumber), "--body", body]);
+}
+async function createPullRequest(base, head, title, body) {
+  const args = ["pr", "create", "--base", base, "--head", head, "--title", title, "--body", body];
+  const url = await execGh(args);
+  const matched = url.match(/\/pull\/(\d+)/);
+  if (!matched) throw new Error(`gh pr create returned an unexpected output: ${url}`);
+  return Number(matched[1]);
+}
+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/dispatch-args.ts
+import { resolve } from "node:path";
+var FLAG_INCOMPATIBLE_COMMANDS = [
+  "init",
+  "apply-labels",
+  "install",
+  "update",
+  "cloud-setup",
+  "usage",
+  "version",
+  "list-workers"
+];
+function collectFlagValues(argv, flag) {
+  const values = [];
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] !== flag) continue;
+    const raw = argv[i + 1];
+    if (!raw || raw.startsWith("--")) {
+      console.error(`[dispatcher] ${flag} requires a value`);
+      process.exit(1);
+    }
+    values.push(raw);
+  }
+  return values;
+}
+function parseProjectFilters() {
+  return collectFlagValues(process.argv, "--project");
+}
+function hasProjectFilter() {
+  return process.argv.includes("--project");
+}
+function assertProjectCompatibleCommand(command) {
+  if (FLAG_INCOMPATIBLE_COMMANDS.includes(command)) {
+    console.error(`[dispatcher] --project cannot be used with the "${command}" command`);
+    process.exit(1);
+  }
+}
+var cachedCloudFlag;
+function hasCloudFlag() {
+  if (cachedCloudFlag === void 0) {
+    cachedCloudFlag = process.argv.includes("--cloud");
+  }
+  return cachedCloudFlag;
+}
+var cachedDebugFlag;
+function hasDebugFlag() {
+  if (cachedDebugFlag === void 0) {
+    cachedDebugFlag = process.argv.includes("--debug");
+  }
+  return cachedDebugFlag;
+}
+var INHERIT_CONFIG_FLAG = "--inherit-config";
+var cachedInheritConfigPath;
+function getInheritConfigPath() {
+  if (cachedInheritConfigPath === void 0) {
+    const values = collectFlagValues(process.argv, INHERIT_CONFIG_FLAG);
+    cachedInheritConfigPath = values.length > 0 ? resolve(values[values.length - 1]) : null;
+  }
+  return cachedInheritConfigPath;
+}
+function assertCloudCompatibleCommand(command) {
+  if (FLAG_INCOMPATIBLE_COMMANDS.includes(command)) {
+    console.error(`[worker] --cloud cannot be used with the "${command}" command`);
+    process.exit(1);
+  }
+}
+function shellQuote(value) {
+  if (value === "") return "''";
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function buildForwardedCommand(argv) {
+  const tokens = [];
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--project") {
+      i++;
+      continue;
+    }
+    if (argv[i] === INHERIT_CONFIG_FLAG && i + 1 < argv.length) {
+      tokens.push(argv[i], resolve(argv[i + 1]));
+      i++;
+      continue;
+    }
+    tokens.push(argv[i]);
+  }
+  return ["claude-task-worker", ...tokens.map(shellQuote)].join(" ");
+}
+
+// src/config.ts
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, normalize, relative, resolve as resolve2, sep as SEP } from "node:path";
+var DEFAULT_UI_DESIGN_CONFIG = {
+  enabled: false,
+  designDir: "designs",
+  yolo: false
+};
+var DEFAULT_WORKER_CONFIG = {
+  skill: "",
+  model: "opus",
+  advisorModel: "",
+  effort: "medium",
+  pollingIntervalSeconds: 60,
+  cooldownSeconds: 0,
+  maxConcurrentTasks: 1,
+  enabled: true
+};
+var WORKER_DEFAULTS = {
+  "answer-issue-questions": {
+    skill: "/claude-task-worker:answer-issue-questions",
+    model: "opus",
+    advisorModel: "",
+    effort: "medium",
+    pollingIntervalSeconds: 60,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1,
+    enabled: true
+  },
+  "create-issue": {
+    skill: "/claude-task-worker:create-issue-from-issue-number",
+    model: "opus",
+    advisorModel: "",
+    effort: "medium",
+    pollingIntervalSeconds: 60,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1,
+    enabled: true
+  },
+  "update-issue": {
+    skill: "/claude-task-worker:update-issue",
+    model: "sonnet",
+    advisorModel: "",
+    effort: "medium",
+    pollingIntervalSeconds: 60,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1,
+    enabled: true
+  },
+  "exec-issue": {
+    skill: "/claude-task-worker:exec-issue",
+    model: "opus",
+    advisorModel: "",
+    effort: "medium",
+    pollingIntervalSeconds: 60,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1,
+    enabled: true
+  },
+  "fix-review-point": {
+    skill: "/claude-task-worker:fix-review-point",
+    model: "opus",
+    advisorModel: "",
+    effort: "medium",
+    pollingIntervalSeconds: 60,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1,
+    enabled: true
+  },
+  "triage-created-issue": {
+    skill: "/claude-task-worker:triage-created-issue",
+    model: "sonnet",
+    advisorModel: "",
+    effort: "medium",
+    pollingIntervalSeconds: 60,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1,
+    enabled: true
+  },
+  "triage-pr": {
+    skill: "/claude-task-worker:triage-pr",
+    model: "opus",
+    advisorModel: "",
+    effort: "medium",
+    pollingIntervalSeconds: 60,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1,
+    enabled: true
+  },
+  "resolve-conflict": {
+    skill: "/claude-task-worker:resolve-pr-conflict",
+    model: "sonnet",
+    advisorModel: "",
+    effort: "high",
+    pollingIntervalSeconds: 60,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1,
+    enabled: true
+  },
+  "check-dependabot": {
+    skill: "/claude-task-worker:check-dependabot",
+    model: "sonnet",
+    advisorModel: "",
+    effort: "high",
+    pollingIntervalSeconds: 3600,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1,
+    enabled: true
+  },
+  "epic-issue": {
+    skill: "/claude-task-worker:create-epic-pr",
+    model: "sonnet",
+    advisorModel: "",
+    effort: "medium",
+    pollingIntervalSeconds: 300,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1,
+    enabled: true
+  },
+  "create-ui-design": {
+    skill: "/claude-task-worker:create-ui-design",
+    model: "opus",
+    advisorModel: "",
+    effort: "medium",
+    pollingIntervalSeconds: 60,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1,
+    enabled: true
+  },
+  "apply-ui-design": {
+    skill: "/claude-task-worker:apply-ui-design",
+    model: "sonnet",
+    advisorModel: "",
+    effort: "medium",
+    pollingIntervalSeconds: 300,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1,
+    enabled: true
+  },
+  // 以下3つは定期ワーカー（createScheduledWorker）。実行間隔そのものは
+  // SCHEDULE_INTERVAL_HOURS（24時間）と実行ログで決まり、pollingIntervalSeconds は
+  // 「24時間経過したかを確認する頻度」でしかない。
+  // model が opus なのは、成果物（CODING_GUIDELINES.md / .claude/requirements/ / DESIGN.md）が
+  // 後続の全 Issue・全デザインの前提として読まれ、誤った一般化がそのまま下流の手戻りになるため。
+  "update-coding-guidelines": {
+    skill: "/claude-task-worker:update-coding-guidelines",
+    model: "opus",
+    advisorModel: "",
+    effort: "medium",
+    pollingIntervalSeconds: 3600,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1,
+    enabled: true
+  },
+  "update-requirement-rules": {
+    skill: "/claude-task-worker:update-requirement-rules",
+    model: "opus",
+    advisorModel: "",
+    effort: "medium",
+    pollingIntervalSeconds: 3600,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1,
+    enabled: true
+  },
+  "update-design-md": {
+    skill: "/claude-task-worker:update-design-md",
+    model: "opus",
+    advisorModel: "",
+    effort: "medium",
+    pollingIntervalSeconds: 3600,
+    cooldownSeconds: 0,
+    maxConcurrentTasks: 1,
+    enabled: true
+  }
+};
+var SCHEDULED_WORKER_NAMES = [
+  "update-coding-guidelines",
+  "update-requirement-rules",
+  "update-design-md"
+];
+var CLOUD_DONE_LABEL = "cc-cloud-done";
+function isCloudWorker(_name) {
+  return hasCloudFlag();
+}
+function checkCloudAuth(input) {
+  if (input.status.kind === "unknown") return [];
+  const { loggedIn, authMethod, apiProvider, apiKeySource } = input.status;
+  const baseUrlSet = !!input.baseUrl;
+  if (loggedIn && apiProvider === "firstParty" && authMethod === "claude.ai" && !apiKeySource && !baseUrlSet) {
+    return [];
+  }
+  const prefix = `\u30AF\u30E9\u30A6\u30C9\u5B9F\u884C\uFF08--cloud \u30D5\u30E9\u30B0\uFF09\u306B\u306F claude.ai \u30A2\u30AB\u30A6\u30F3\u30C8\u3067\u306E\u30B5\u30A4\u30F3\u30A4\u30F3\u304C\u5FC5\u8981\u3067\u3059\u3002\u73FE\u5728\u306E\u8A8D\u8A3C\u69CB\u6210: ${authMethod} / ${apiProvider}\u3002`;
+  if (apiProvider === "bedrock" || apiProvider === "vertex") {
+    return [
+      `${prefix} \u7B2C\u4E09\u8005\u30D7\u30ED\u30D0\u30A4\u30C0\uFF08Bedrock / Vertex\uFF09\u3092\u4F7F\u3063\u3066\u3044\u308B\u5834\u5408: \u30AF\u30E9\u30A6\u30C9\u30BB\u30C3\u30B7\u30E7\u30F3\u306F Anthropic \u306E\u30A4\u30F3\u30D5\u30E9\u4E0A\u3067\u52D5\u304F\u305F\u3081\u5229\u7528\u3067\u304D\u307E\u305B\u3093\u3002CLAUDE_CODE_USE_BEDROCK / CLAUDE_CODE_USE_VERTEX \u3092\u89E3\u9664\u3059\u308B\u304B\u3001--cloud \u30D5\u30E9\u30B0\u3092\u5916\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+    ];
+  }
+  if (apiKeySource || authMethod === "oauth_token") {
+    return [
+      `${prefix} API \u30AD\u30FC\u8A8D\u8A3C\uFF08ANTHROPIC_API_KEY / ANTHROPIC_AUTH_TOKEN\uFF09\u306E\u5834\u5408: API \u30AD\u30FC\u3067\u306F\u30AF\u30E9\u30A6\u30C9\u30BB\u30C3\u30B7\u30E7\u30F3\u3092\u4F5C\u6210\u3067\u304D\u307E\u305B\u3093\u3002\u74B0\u5883\u5909\u6570\u3092\u89E3\u9664\u3057\u3066 claude auth login \u3067\u30B5\u30A4\u30F3\u30A4\u30F3\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+    ];
+  }
+  if (!loggedIn) {
+    return [`${prefix} \u672A\u30B5\u30A4\u30F3\u30A4\u30F3\u306E\u5834\u5408: claude auth login \u3092\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002`];
+  }
+  if (baseUrlSet) {
+    return [
+      `${prefix} ANTHROPIC_BASE_URL \u3092\u8A2D\u5B9A\u3057\u3066\u3044\u308B\u5834\u5408: \u30AB\u30B9\u30BF\u30E0\u30A8\u30F3\u30C9\u30DD\u30A4\u30F3\u30C8\u69CB\u6210\u3067\u306F\u30AF\u30E9\u30A6\u30C9\u30BB\u30C3\u30B7\u30E7\u30F3\u3092\u5229\u7528\u3067\u304D\u307E\u305B\u3093\u3002\u89E3\u9664\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+    ];
+  }
+  return [`${prefix} claude auth status --json \u306E\u51FA\u529B\u304B\u3089\u30AF\u30E9\u30A6\u30C9\u5B9F\u884C\u306E\u524D\u63D0\u6761\u4EF6\u3092\u5224\u5B9A\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u3002`];
+}
+function checkCloudConfig(input) {
+  if (!input.cloud) return [];
+  const errors = [];
+  if (input.scriptAvailable === false) {
+    errors.push(
+      `--cloud requires a pty, provided via the "script" command (creating a new cloud session requires a TTY, which the worker's spawn does not have on its own). "script" is unavailable \u2014 either the platform is not darwin/linux, or "script" is not on PATH. Drop the --cloud flag, or run on darwin/linux where "script" is available.`
+    );
+  }
+  if (input.auth !== void 0) errors.push(...checkCloudAuth(input.auth));
+  return errors;
+}
+var DEFAULT_CONFIG = {
+  fixReviewPointCallbackCommentMessage: "",
+  remoteEnvId: null,
+  labels: [],
+  workerFiles: [],
+  uiDesign: { ...DEFAULT_UI_DESIGN_CONFIG },
+  lastRun: {},
+  workers: {}
+};
+var CONFIG_PATH = join(process.cwd(), "claude-task-worker.json");
+var LOCAL_CONFIG_PATH = join(process.cwd(), "claude-task-worker.local.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 ("advisorModel" in entry) {
+    if (typeof entry.advisorModel === "string") {
+      result.advisorModel = entry.advisorModel;
+    } else {
+      console.warn(
+        `[config] invalid workers.${name}.advisorModel: ${String(entry.advisorModel)}, using default ${JSON.stringify(base.advisorModel)}`
+      );
+    }
+  }
+  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}`
+      );
+    }
+  }
+  if ("enabled" in entry) {
+    if (typeof entry.enabled === "boolean") {
+      result.enabled = entry.enabled;
+    } else {
+      console.warn(`[config] invalid workers.${name}.enabled: ${String(entry.enabled)}, using default ${base.enabled}`);
+    }
+  }
+  if ("cloud" in entry) {
+    console.warn(
+      `[config] workers.${name}.cloud is removed; cloud execution now opts in via the --cloud flag at runtime. This setting is ignored.`
+    );
+  }
+  return result;
+}
+function parseUiDesignEntry(val) {
+  const result = { ...DEFAULT_UI_DESIGN_CONFIG };
+  if (typeof val !== "object" || val === null || Array.isArray(val)) {
+    console.warn(`[config] invalid uiDesign: expected object, using defaults`);
+    return result;
+  }
+  const entry = val;
+  if ("enabled" in entry) {
+    if (typeof entry.enabled === "boolean") {
+      result.enabled = entry.enabled;
+    } else {
+      console.warn(
+        `[config] invalid uiDesign.enabled: ${String(entry.enabled)}, using default ${DEFAULT_UI_DESIGN_CONFIG.enabled}`
+      );
+    }
+  }
+  if ("yolo" in entry) {
+    if (typeof entry.yolo === "boolean") {
+      result.yolo = entry.yolo;
+    } else {
+      console.warn(
+        `[config] invalid uiDesign.yolo: ${String(entry.yolo)}, using default ${DEFAULT_UI_DESIGN_CONFIG.yolo}`
+      );
+    }
+  }
+  if ("designDir" in entry) {
+    const normalized = typeof entry.designDir === "string" && entry.designDir.length > 0 ? normalize(entry.designDir) : null;
+    const isContained = normalized !== null && !isAbsolute(normalized) && normalized !== ".." && !normalized.startsWith(`..${SEP}`);
+    if (isContained) {
+      result.designDir = normalized;
+    } else {
+      console.warn(
+        `[config] invalid uiDesign.designDir: ${String(entry.designDir)}, using default ${DEFAULT_UI_DESIGN_CONFIG.designDir}`
+      );
+    }
+  }
+  return result;
+}
+function parseLastRunEntry(val) {
+  if (typeof val !== "object" || val === null || Array.isArray(val)) {
+    console.warn(`[config] invalid lastRun: expected object, ignoring`);
+    return {};
+  }
+  const result = {};
+  for (const [name, at] of Object.entries(val)) {
+    if (typeof at === "string" && !Number.isNaN(Date.parse(at))) {
+      result[name] = at;
+    } else {
+      console.warn(`[config] invalid lastRun.${name}: ${String(at)}, ignoring`);
+    }
+  }
+  return result;
+}
+function parseLabelsEntry(val) {
+  if (!Array.isArray(val)) {
+    console.warn(`[config] invalid labels: expected array of strings, ignoring`);
+    return [];
+  }
+  const result = [];
+  for (const item of val) {
+    if (typeof item === "string" && item.trim().length > 0) {
+      result.push(item.trim());
+    } else {
+      console.warn(`[config] invalid labels entry: ${String(item)}, ignoring`);
+    }
+  }
+  return result;
+}
+function parseWorkerFilesEntry(val) {
+  if (!Array.isArray(val)) {
+    console.warn(`[config] invalid workerFiles: expected array of strings, ignoring`);
+    return [];
+  }
+  const result = [];
+  for (const item of val) {
+    if (typeof item === "string" && item.trim().length > 0) {
+      result.push(item.trim());
+    } else {
+      console.warn(`[config] invalid workerFiles entry: ${String(item)}, ignoring`);
+    }
+  }
+  return result;
+}
+function resolveWorkerFilePath(entry, configDir, home) {
+  if (entry === "~") return home;
+  if (entry.startsWith("~/")) return resolve2(home, entry.slice(2));
+  return resolve2(configDir, entry);
+}
+function isPlainObject(val) {
+  return typeof val === "object" && val !== null && !Array.isArray(val);
+}
+function mergeConfigRaw(base, local) {
+  const result = { ...base };
+  for (const [key, val] of Object.entries(local)) {
+    const current = result[key];
+    result[key] = isPlainObject(current) && isPlainObject(val) ? mergeConfigRaw(current, val) : val;
+  }
+  return result;
+}
+function readRawConfig(path2) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path2, "utf-8"));
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw err;
+  }
+  if (!isPlainObject(parsed)) {
+    console.warn(`[config] invalid ${path2}: expected object, ignoring`);
+    return {};
+  }
+  return parsed;
+}
+function resolveInheritedRelativePaths(raw, configDir, repoRoot) {
+  const result = { ...raw };
+  const uiDesign = raw["uiDesign"];
+  if (isPlainObject(uiDesign) && typeof uiDesign.designDir === "string" && uiDesign.designDir.length > 0) {
+    result["uiDesign"] = {
+      ...uiDesign,
+      designDir: relative(repoRoot, resolve2(configDir, uiDesign.designDir)) || "."
+    };
+  }
+  const workerFiles = raw["workerFiles"];
+  if (Array.isArray(workerFiles)) {
+    result["workerFiles"] = workerFiles.map(
+      (entry) => typeof entry === "string" && entry.trim().length > 0 && !entry.trim().startsWith("~") ? resolve2(configDir, entry.trim()) : entry
+    );
+  }
+  return result;
+}
+function readInheritedRawConfig(path2, repoRoot) {
+  if (!existsSync(path2)) {
+    throw new Error(`${INHERIT_CONFIG_FLAG} ${path2} does not exist`);
+  }
+  return resolveInheritedRelativePaths(readRawConfig(path2), dirname(path2), repoRoot);
+}
+function readCwdRawConfig() {
+  return mergeConfigRaw(readRawConfig(CONFIG_PATH), readRawConfig(LOCAL_CONFIG_PATH));
+}
+function loadConfig() {
+  const inheritPath = getInheritConfigPath();
+  const cwdRaw = readCwdRawConfig();
+  const raw = inheritPath ? mergeConfigRaw(readInheritedRawConfig(inheritPath, process.cwd()), cwdRaw) : cwdRaw;
+  const result = {
+    ...DEFAULT_CONFIG,
+    labels: [],
+    workerFiles: [],
+    uiDesign: { ...DEFAULT_UI_DESIGN_CONFIG },
+    lastRun: {},
+    workers: {}
+  };
+  if ("remoteEnvId" in raw) {
+    const val = raw["remoteEnvId"];
+    if (val === null) {
+      result.remoteEnvId = null;
+    } else if (typeof val === "string" && val.trim().length > 0) {
+      result.remoteEnvId = val.trim();
+    } else {
+      console.warn(`[config] invalid remoteEnvId: ${String(val)}, using default null`);
+    }
+  }
+  if ("labels" in raw) {
+    result.labels = parseLabelsEntry(raw["labels"]);
+  }
+  if ("workerFiles" in raw) {
+    result.workerFiles = parseWorkerFilesEntry(raw["workerFiles"]);
+  }
+  if ("lastRun" in raw) {
+    result.lastRun = parseLastRunEntry(raw["lastRun"]);
+  }
+  if ("fixReviewPointCallbackCommentMessage" in raw) {
+    const val = raw["fixReviewPointCallbackCommentMessage"];
+    if (typeof val === "string") {
+      result.fixReviewPointCallbackCommentMessage = val;
+    }
+  }
+  if ("uiDesign" in raw) {
+    result.uiDesign = parseUiDesignEntry(raw["uiDesign"]);
+  }
+  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) };
+}
+function isWorkerEnabled(workerName) {
+  try {
+    return getWorkerConfig(workerName).enabled;
+  } catch (err) {
+    console.warn(`[config] failed to load workers.${workerName}.enabled, treating it as enabled: ${err}`);
+    return true;
+  }
+}
+function partitionEnabledWorkers(names, isEnabled) {
+  const enabled = [];
+  const disabled = [];
+  for (const name of names) (isEnabled(name) ? enabled : disabled).push(name);
+  return { enabled, disabled };
+}
+function disabledWorkerMessage(workerName) {
+  return `${workerName} is disabled by workers.${workerName}.enabled: false in claude-task-worker.json (or claude-task-worker.local.json). To run it, set workers.${workerName}.enabled to true or remove the key.`;
+}
+function getLastRunAt(workerName) {
+  let at;
+  try {
+    const raw = readCwdRawConfig();
+    at = "lastRun" in raw ? parseLastRunEntry(raw["lastRun"])[workerName] : void 0;
+  } catch (err) {
+    console.warn(`[config] failed to load lastRun, treating ${workerName} as never run: ${err}`);
+    return void 0;
+  }
+  if (at === void 0) return void 0;
+  const parsed = Date.parse(at);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+function writeLastRun(repoRoot, workerName, at = /* @__PURE__ */ new Date()) {
+  const path2 = join(repoRoot, "claude-task-worker.json");
+  let raw = {};
+  try {
+    const parsed = JSON.parse(readFileSync(path2, "utf-8"));
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      raw = parsed;
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      console.warn(`[config] failed to read ${path2}, rewriting it with lastRun only: ${err}`);
+    }
+  }
+  const current = typeof raw["lastRun"] === "object" && raw["lastRun"] !== null ? raw["lastRun"] : {};
+  raw["lastRun"] = { ...current, [workerName]: at.toISOString() };
+  writeFileSync(path2, `${JSON.stringify(raw, null, 2)}
+`, "utf-8");
+}
+function getRemoteEnvId() {
+  try {
+    return loadConfig().remoteEnvId;
+  } catch (err) {
+    console.warn(`[config] failed to load remoteEnvId, not passing --environment: ${err}`);
+    return null;
+  }
+}
+function getUiDesignConfig() {
+  try {
+    return loadConfig().uiDesign;
+  } catch (err) {
+    console.warn(`[config] failed to load uiDesign config, using defaults: ${err}`);
+    return { ...DEFAULT_UI_DESIGN_CONFIG };
+  }
+}
+
+// src/user-config.ts
+import { readFileSync as readFileSync2, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute as isAbsolute2, join as join2, resolve as resolve3 } from "node:path";
+var RESERVED_ALL = "all";
+var DEFAULT_RUN_MODE = "default";
+var DEFAULT_ADVISOR_ENABLED = false;
+var PERMISSION_MODES = [
+  "manual",
+  "auto",
+  "acceptEdits",
+  "dontAsk",
+  "plan",
+  "bypassPermissions"
+];
+var DEFAULT_PERMISSION_MODE = "bypassPermissions";
+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(path2) {
+  try {
+    return statSync(path2).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function parseConfigFile(path2) {
+  let content;
+  try {
+    content = readFileSync2(path2, "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: ${path2}: ${err.message}`);
+    }
+    throw err;
+  }
+}
+function readRawConfig2() {
+  return parseConfigFile(getUserConfigPath());
+}
+function parseMode(raw, path2) {
+  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 ${path2}, using "${DEFAULT_RUN_MODE}"`);
+  return DEFAULT_RUN_MODE;
+}
+function parseAdvisor(raw, path2) {
+  if (!("advisor" in raw)) return DEFAULT_ADVISOR_ENABLED;
+  const value = raw["advisor"];
+  if (typeof value === "boolean") return value;
+  console.warn(`[config] invalid advisor: ${JSON.stringify(value)} in ${path2}, using ${DEFAULT_ADVISOR_ENABLED}`);
+  return DEFAULT_ADVISOR_ENABLED;
+}
+function parsePermission(raw, path2) {
+  if (!("permission" in raw)) return DEFAULT_PERMISSION_MODE;
+  const value = raw["permission"];
+  if (typeof value === "string" && PERMISSION_MODES.includes(value)) return value;
+  console.warn(`[config] invalid permission: ${JSON.stringify(value)} in ${path2}, using "${DEFAULT_PERMISSION_MODE}"`);
+  return DEFAULT_PERMISSION_MODE;
+}
+function loadUserConfig() {
+  const path2 = getUserConfigPath();
+  const raw = readRawConfig2();
+  if (raw === void 0) {
+    throw new UserConfigError(`config.json not found: ${path2}`);
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new UserConfigError(`config.json must contain a JSON object: ${path2}`);
+  }
+  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: ${path2}`);
+  }
+  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: ${path2}`);
+  }
+  const mode = parseMode(raw, path2);
+  const advisor = parseAdvisor(raw, path2);
+  const permission = parsePermission(raw, path2);
+  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": ${path2}`);
+    }
+    if (typeof value !== "string" || !isAbsolute2(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": ${path2}`);
+    }
+    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, advisor, permission, projects, projectGroups };
+}
+var cachedRunMode;
+function getRunMode() {
+  if (cachedRunMode === void 0) {
+    cachedRunMode = readRunMode();
+  }
+  return cachedRunMode;
+}
+var cachedAdvisorEnabled;
+function isAdvisorEnabled() {
+  if (cachedAdvisorEnabled === void 0) {
+    cachedAdvisorEnabled = readAdvisorEnabled();
+  }
+  return cachedAdvisorEnabled;
+}
+var cachedPermissionMode;
+function getPermissionMode() {
+  if (cachedPermissionMode === void 0) {
+    cachedPermissionMode = readTopLevel(parsePermission, DEFAULT_PERMISSION_MODE, "permission");
+  }
+  return cachedPermissionMode;
+}
+function readTopLevel(parse, fallback, label) {
+  let raw;
+  try {
+    raw = readRawConfig2();
+  } catch (err) {
+    console.warn(`[config] failed to read config file, using default ${label}: ${err}`);
+    return fallback;
+  }
+  if (raw === void 0) return fallback;
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return fallback;
+  }
+  return parse(raw, getUserConfigPath());
+}
+function readAdvisorEnabled() {
+  return readTopLevel(parseAdvisor, DEFAULT_ADVISOR_ENABLED, "advisor");
+}
+function readRunMode() {
+  return readTopLevel(parseMode, DEFAULT_RUN_MODE, "mode");
+}
+function findProjectNameByPath(path2) {
+  let config;
+  try {
+    config = loadUserConfig();
+  } catch {
+    return void 0;
+  }
+  const target = resolve3(path2);
+  for (const [name, projectPath] of Object.entries(config.projects)) {
+    if (resolve3(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/claude-args.ts
+import { mkdirSync, renameSync, writeFileSync as writeFileSync2 } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+var CLOUD_REPORT_HEADING = "## claude-task-worker \u5B9F\u884C\u7D50\u679C";
+var DISALLOWED_TOOLS = [
+  // 遅延 / yield: 後続ウェイクアップ前提。print モードではウェイクアップが発火せず、
+  // 呼ぶと処理未完のままプロセスが終了する。
+  "Monitor",
+  "ScheduleWakeup",
+  // 対話 / 承認: 自律実行セッションには回答・承認するユーザーが存在しない。
+  "AskUserQuestion",
+  "EnterPlanMode",
+  // スコープ外の副作用を伴う自動化: コード修正タスクに用途がなく、ユーザーの
+  // クラウド routine / リモート環境へ副作用を及ぼしうる。
+  "CronCreate",
+  "CronDelete",
+  "CronList",
+  "RemoteTrigger",
+  // 環境管理の競合: ワーカーは locked worktree の残骸問題のため claude 管理の worktree を
+  // 意図的に避け、自前で worktree を生成して cwd として渡している。モデルが worktree を
+  // 作成/切り替えると、この前提とクリーンアップが壊れる。
+  "EnterWorktree"
+];
+var DISALLOWED_TOOLS_ARG = DISALLOWED_TOOLS.join(",");
+var CLAUDE_SPAWN_ENV = {
+  CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: "1",
+  CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS: "0"
+};
+var SYSTEM_PROMPT_BASE = `\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\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
+- \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
+
+\u30B3\u30FC\u30C9\u306E\u63A2\u7D22\u30FB\u8ABF\u67FB\u3067\u306F\u4EE5\u4E0B\u306B\u5F93\u3046\u3053\u3068\u3002
+
+- **CodeGraph \u304C\u4F7F\u3048\u308B\u5834\u5408\u306F \`Grep\`/\`Glob\` \u306B\u3088\u308B\u30C6\u30AD\u30B9\u30C8\u691C\u7D22\u3088\u308A\u512A\u5148\u3059\u308B**\u3002\u30B7\u30F3\u30DC\u30EB\u306E\u5B9A\u7FA9\u5143\u30FB\u53C2\u7167\u5143\u30FB\u547C\u3073\u51FA\u3057\u95A2\u4FC2\u3092\u69CB\u9020\u3068\u3057\u3066\u8FBF\u308C\u308B\u305F\u3081\u3001\u547D\u540D\u3086\u308C\u306B\u3088\u308B\u53D6\u308A\u3053\u307C\u3057\u304C\u8D77\u304D\u306B\u304F\u304F\u3001\u5FC5\u8981\u306A\u60C5\u5831\u306B\u5C11\u306A\u3044\u8A66\u884C\u3067\u5230\u9054\u3067\u304D\u308B
+- **\u5229\u7528\u53EF\u5426\u306F codegraph \u7CFB\u306E MCP \u30C4\u30FC\u30EB\uFF08\`codegraph_explore\` \u7B49\uFF09\u304C\u81EA\u5206\u306B\u4E0E\u3048\u3089\u308C\u3066\u3044\u308B\u304B\u3060\u3051\u3067\u5224\u65AD\u3059\u308B**\u3002\u7121\u3051\u308C\u3070\u300C\u5229\u7528\u4E0D\u53EF\u300D\u3068\u5373\u65AD\u3057\u3066\u30C6\u30AD\u30B9\u30C8\u691C\u7D22\u3078\u9032\u307F\u3001\u5224\u5B9A\u306B\u624B\u9593\u3092\u304B\u3051\u306A\u3044
+- \u672A\u30A4\u30F3\u30C7\u30C3\u30AF\u30B9\u306E\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u3067\u306F MCP \u30C4\u30FC\u30EB\u304C\u3042\u3063\u3066\u3082\u30A8\u30E9\u30FC\u3084\u7A7A\u306E\u7D50\u679C\u304C\u8FD4\u308B\u3002\u305D\u306E\u5834\u5408\u3082\u30C6\u30AD\u30B9\u30C8\u691C\u7D22\u3078\u5207\u308A\u66FF\u3048\u308B\u3060\u3051\u3067\u3088\u304F\u3001\u30A4\u30F3\u30C7\u30C3\u30AF\u30B9\u3092\u7528\u610F\u3057\u3088\u3046\u3068\u3057\u306A\u3044\uFF08\u30BF\u30B9\u30AF\u306E\u8CAC\u52D9\u5916\uFF09
+- CodeGraph \u304C\u8FD4\u3057\u305F\u30BD\u30FC\u30B9\u306F\u300C\u8AAD\u307F\u7D42\u3048\u305F\u3082\u306E\u300D\u3068\u3057\u3066\u6271\u3044\u3001\u540C\u3058\u7B87\u6240\u3092 \`Grep\`/\`Read\` \u3067\u88CF\u53D6\u308A\u3057\u76F4\u3055\u306A\u3044\u3002\u305F\u3060\u3057\u51FA\u529B\u306B staleness\uFF08\u30A4\u30F3\u30C7\u30C3\u30AF\u30B9\u304C\u53E4\u3044\u65E8\uFF09\u306E\u8B66\u544A\u304C\u51FA\u3066\u3044\u308B\u5834\u5408\u306F\u8A72\u5F53\u30D5\u30A1\u30A4\u30EB\u3092 \`Read\` \u3057\u3066\u73FE\u7269\u3092\u78BA\u8A8D\u3059\u308B
+- \u8A2D\u5B9A\u30D5\u30A1\u30A4\u30EB\u30FB\u30C9\u30AD\u30E5\u30E1\u30F3\u30C8\u30FB\u30B3\u30E1\u30F3\u30C8/\u6587\u5B57\u5217\u30EA\u30C6\u30E9\u30EB\u30FB\u672A\u5BFE\u5FDC\u8A00\u8A9E\u306A\u3069 CodeGraph \u304C\u6271\u308F\u306A\u3044\u5BFE\u8C61\u306F\u3001\u5F93\u6765\u3069\u304A\u308A\u30C6\u30AD\u30B9\u30C8\u691C\u7D22\u3067\u88DC\u3046
+- \u63A2\u7D22\u3092\u30B5\u30D6\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u3078\u59D4\u8B72\u3059\u308B\u5834\u5408\u306F\u3001\u3053\u306E\u65B9\u91DD\u3082\u59D4\u8B72\u30D7\u30ED\u30F3\u30D7\u30C8\u306B\u660E\u8A18\u3057\u3066\u4F1D\u3048\u308B`;
+var OPUS_SYSTEM_PROMPT_ADDENDUM = `\u6210\u679C\u7269\u306E\u5206\u91CF\u3068\u30B9\u30B3\u30FC\u30D7\u306B\u3064\u3044\u3066\u306F\u4EE5\u4E0B\u306B\u5F93\u3046\u3053\u3068\u3002
+
+- \u4F9D\u983C\u3055\u308C\u305F\u30B9\u30B3\u30FC\u30D7\u3060\u3051\u3092\u6210\u679C\u7269\u306B\u3059\u308B\u3002\u5468\u8FBA\u306E\u30EA\u30D5\u30A1\u30AF\u30BF\u30FB\u547D\u540D\u6574\u7406\u30FB\u6C17\u3065\u3044\u305F\u5225\u306E\u6539\u5584\u3092\u52DD\u624B\u306B\u8DB3\u3055\u306A\u3044\u3002\u6C17\u3065\u3044\u305F\u70B9\u306F\u5B9F\u88C5\u305B\u305A\u3001\u6700\u7D42\u5831\u544A\u306B1\u884C\u3067\u6319\u3052\u308B\u3060\u3051\u306B\u3059\u308B
+- \u4F9D\u983C\u306E\u524D\u63D0\u304C\u8AA4\u3063\u3066\u3044\u308B\u3068\u8003\u3048\u308B\u5834\u5408\u3082\u3001\u6307\u6458\u30921-2\u884C\u6DFB\u3048\u305F\u3046\u3048\u3067**\u4F9D\u983C\u3069\u304A\u308A\u306E\u30B9\u30B3\u30FC\u30D7\u3067**\u5B8C\u9042\u3059\u308B\uFF08\u9ED9\u3063\u3066\u7E2E\u5C0F\u30FB\u62E1\u5927\u30FB\u5225\u7269\u3078\u306E\u7F6E\u304D\u63DB\u3048\u3092\u3057\u306A\u3044\uFF09
+- \u5909\u66F4\u306B\u5165\u308B\u524D\u306B\u3001\u4F9D\u983C\u304C\u660E\u793A\u3057\u3066\u3044\u306A\u304F\u3066\u3082\u7D50\u8AD6\u3092\u5DE6\u53F3\u3057\u3046\u308B\u60C5\u5831\u6E90\uFF08Issue/PR \u306E\u30B3\u30E1\u30F3\u30C8\u30FB\u95A2\u9023 Issue/PR\u30FB\`docs/\`\u30FB\`.claude/requirements/\`\u30FB\`CODING_GUIDELINES.md\`\u30FB\u30EA\u30F3\u30AF\u5148\u306E\u4ED5\u69D8\uFF09\u3092\u898B\u3066\u304B\u3089\u7740\u624B\u3059\u308B\u3002\u898B\u3064\u3051\u305F\u5185\u5BB9\u306F\u4F7F\u3046
+- Issue\u30B3\u30E1\u30F3\u30C8\u30FBPR\u306E\u672C\u6587\u30FBdescription\u30FB\u30EC\u30DD\u30FC\u30C8\u7B49\u306E\u66F8\u304D\u7269\u306F\u3001\u5FC5\u8981\u306A\u5B9F\u8CEA\u3060\u3051\u3092\u66F8\u304F\u3002\u540C\u3058\u5185\u5BB9\u306E\u8A00\u3044\u63DB\u3048\u30FB\u57CB\u3081\u8349\u30BB\u30AF\u30B7\u30E7\u30F3\u30FB\u300C\u8A72\u5F53\u306A\u3057\u300D\u3092\u4E26\u3079\u308B\u3060\u3051\u306E\u7BC0\u3092\u8DB3\u3055\u306A\u3044
+- \u6700\u7D42\u5831\u544A\u306F\u7D50\u8AD6\u304B\u3089\u66F8\u304F\u30021\u6587\u76EE\u3067\u300C\u4F55\u3092\u3057\u305F\u304B / \u3069\u3053\u3067\u6B62\u307E\u3063\u305F\u304B\u300D\u3092\u8FF0\u3079\u3001\u8A73\u7D30\u3092\u305D\u306E\u5F8C\u306B\u7F6E\u304F
+
+\u30B5\u30D6\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u3078\u306E\u59D4\u8B72\u306F\u4EE5\u4E0B\u306B\u5F93\u3046\u3053\u3068\u3002
+
+- \u81EA\u5206\u3067\u6570\u56DE\u306E\u30C4\u30FC\u30EB\u547C\u3073\u51FA\u3057\u3067\u7D42\u308F\u308B\u4F5C\u696D\u306F\u59D4\u8B72\u3057\u306A\u3044\uFF08\u30D6\u30EA\u30FC\u30D5\u30A3\u30F3\u30B0\u4F5C\u6210\u3068\u59D4\u8B72\u5148\u306E\u518D\u63A2\u7D22\u3067\u30B3\u30B9\u30C8\u3068\u6642\u9593\u304C\u500D\u306B\u306A\u308B\uFF09
+- \u59D4\u8B72\u3059\u308B\u306E\u306F\u3001\u72EC\u7ACB\u3057\u3066\u4E26\u5217\u5B9F\u884C\u3067\u304D\u308B\u4F5C\u696D\u30FB\u63A2\u7D22\u7BC4\u56F2\u306E\u5E83\u3044\u8ABF\u67FB\u30FB\u5C02\u9580\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u306E\u524D\u63D0\u77E5\u8B58\u304C\u8981\u308B\u4F5C\u696D\u306B\u9650\u308B
+- 1\u30BF\u30B9\u30AF\u306B1\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u30021\u4F53\u3067\u5B8C\u7D50\u3059\u308B\u4F5C\u696D\u306B\u8907\u6570\u4F53\u3092\u91CD\u306D\u3066\u8D77\u52D5\u3057\u306A\u3044
+- **\u81EA\u5206\u306E\u4F5C\u696D\u306E\u78BA\u8A8D\u30FB\u518D\u30C1\u30A7\u30C3\u30AF\u3092\u76EE\u7684\u306B\u30B5\u30D6\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u3092\u8D77\u52D5\u3057\u306A\u3044**\u3002\u6210\u679C\u7269\u306E\u691C\u8A3C\u306F \`git diff\` \u3084\u30C6\u30B9\u30C8\u30FBLint\u306E\u5B9F\u884C\u3067\u81EA\u5206\u3067\u884C\u3046
+
+\u30BF\u30FC\u30F3\u306E\u7D42\u3048\u65B9\u306F\u4EE5\u4E0B\u306B\u5F93\u3046\u3053\u3068\u3002\u30C4\u30FC\u30EB\u547C\u3073\u51FA\u3057\u3092\u542B\u307E\u306A\u3044\u30E1\u30C3\u30BB\u30FC\u30B8\u3067\u30BF\u30FC\u30F3\u304C\u7D42\u308F\u308B\u3068\u3001\u3053\u306E\u30BB\u30C3\u30B7\u30E7\u30F3\u3067\u306F\u51E6\u7406\u304C\u305D\u3053\u3067\u6253\u3061\u5207\u3089\u308C\u3001\u7D9A\u304D\u3092\u6307\u793A\u3059\u308B\u4EBA\u306F\u3044\u306A\u3044\u3002
+
+- \u6B21\u306E4\u7A2E\u985E\u306E\u7D42\u3048\u65B9\u3092\u3057\u306A\u3044: (1) \u5B9F\u65BD\u5185\u5BB9\u306E\u8981\u7D04\u3092\u66F8\u304D\u300C\u6B21\u306F\u301C\u3059\u308B\u300D\u3068\u544A\u3052\u308B\u3060\u3051\u3067\u6B21\u306B\u9032\u307E\u306A\u3044\u3001(2) \u300C\u301C\u3057\u3066\u3088\u3044\u304B\u300D\u300C\u4ED6\u306B\u5E0C\u671B\u304C\u306A\u3051\u308C\u3070\u7D9A\u3051\u308B\u300D\u3068\u78BA\u8A8D\u3057\u3066\u6B62\u307E\u308B\u3001(3) \u81EA\u5206\u3067\u6C7A\u3081\u3089\u308C\u308B\u9078\u629E\u80A2\u3092\u30E6\u30FC\u30B6\u30FC\u5411\u3051\u306B\u5217\u6319\u3057\u3066\u6B62\u307E\u308B\u3001(4) \u533A\u5207\u308A\u304C\u826F\u3044\u30FB\u9577\u304F\u4F5C\u696D\u3057\u305F\u3068\u3044\u3046\u7406\u7531\u3067\u4E2D\u9593\u5831\u544A\u3060\u3051\u3092\u51FA\u3057\u3066\u6B62\u307E\u308B
+- \u72B6\u6CC1\u30E1\u30E2\u3084\u63A8\u5968\u6848\u306F\u3001\u6B21\u306E\u30C4\u30FC\u30EB\u547C\u3073\u51FA\u3057\u3068\u540C\u3058\u30E1\u30C3\u30BB\u30FC\u30B8\u306B\u66F8\u3044\u3066\u4F5C\u696D\u3092\u7D9A\u3051\u308B\u3002\u30E6\u30FC\u30B6\u30FC\u306E\u56DE\u7B54\u306B\u4F9D\u5B58\u3057\u306A\u3044\u4F5C\u696D\u306F\u6B62\u3081\u305A\u306B\u9032\u3081\u308B
+- \u30BF\u30FC\u30F3\u3092\u7D42\u3048\u3066\u3088\u3044\u306E\u306F\u3001\u30B9\u30AD\u30EB\u306E\u5168\u30B9\u30C6\u30C3\u30D7\u3092\u5B8C\u9042\u3057\u305F\u3068\u304D\u3001\u307E\u305F\u306F\u30B9\u30AD\u30EB\u306B\u5B9A\u7FA9\u3055\u308C\u305F\u4E2D\u65AD\u6761\u4EF6\u306B\u8A72\u5F53\u3057\u305F\u3068\u304D\u3060\u3051\u3002\u7834\u58CA\u7684\u30FB\u4E0D\u53EF\u9006\u306A\u64CD\u4F5C\u3067\u5224\u65AD\u306B\u8FF7\u3046\u5834\u5408\u306F\u3001\u78BA\u8A8D\u3092\u6C42\u3081\u3066\u6B62\u307E\u308B\u306E\u3067\u306F\u306A\u304F\u5B9F\u884C\u3057\u306A\u3044\u5074\u3092\u9078\u3073\u3001\u305D\u306E\u65E8\u3092\u6700\u7D42\u5831\u544A\u306B\u66F8\u3044\u3066\u6B8B\u308A\u306E\u4F5C\u696D\u3092\u9032\u3081\u308B`;
+var SONNET_SYSTEM_PROMPT_ADDENDUM = `\u4F5C\u696D\u306E\u9032\u3081\u65B9\u306F\u4EE5\u4E0B\u306B\u5F93\u3046\u3053\u3068\u3002
+
+- \u4F9D\u983C\u3055\u308C\u305F\u4F5C\u696D\u304C\u3059\u3079\u3066\u7D42\u308F\u308B\u307E\u3067\u7D9A\u3051\u308B\u3002\u8A08\u753B\u306E\u78BA\u8A8D\u30FB\u81EA\u5206\u3067\u7B54\u3048\u3089\u308C\u308B\u8CEA\u554F\u30FB\u591A\u6BB5\u30BF\u30B9\u30AF\u306E\u4E00\u90E8\u3092\u7D42\u3048\u305F\u6642\u70B9\u3067\u306E\u300C\u7D9A\u3051\u308B\u304B\u300D\u306E\u78BA\u8A8D\u306E\u305F\u3081\u306B\u6B62\u307E\u3089\u306A\u3044\u3002\u6B62\u307E\u3063\u3066\u3088\u3044\u306E\u306F\u3001\u30B9\u30AD\u30EB\u306B\u5B9A\u7FA9\u3055\u308C\u305F\u4E2D\u65AD\u6761\u4EF6\u306B\u8A72\u5F53\u3057\u305F\u3068\u304D\u3060\u3051
+- \u4F9D\u983C\u3055\u308C\u305F\u4F5C\u696D\u304C\u7D42\u308F\u308A\u691C\u8A3C\u3082\u6E08\u3093\u3060\u3089\u3001\u305D\u3053\u3067\u7D42\u3048\u3066\u5831\u544A\u3059\u308B\u3002\u4F9D\u983C\u3055\u308C\u3066\u3044\u306A\u3044\u30C6\u30B9\u30C8\u30FB\u30C9\u30AD\u30E5\u30E1\u30F3\u30C8\u30FB\u88DC\u52A9\u30D5\u30A1\u30A4\u30EB\u30FB\u30EA\u30D5\u30A1\u30AF\u30BF\u3092\u8DB3\u3055\u306A\u3044\u3002\u3042\u3063\u305F\u65B9\u304C\u3088\u3044\u3068\u8003\u3048\u308B\u3082\u306E\u306F\u6700\u7D42\u5831\u544A\u306B1\u884C\u3067\u6319\u3052\u308B
+- \u5B9F\u884C\u30FB\u30D3\u30EB\u30C9\u30FB\u578B\u30C1\u30A7\u30C3\u30AF\u3067\u304D\u308B\u30B3\u30FC\u30C9\u3092\u5909\u66F4\u3057\u305F\u3089\u3001\u5B8C\u4E86\u3068\u5831\u544A\u3059\u308B\u524D\u306B**\u305D\u306E\u5909\u66F4\u3092\u5B9F\u969B\u306B\u901A\u3059\u691C\u8A3C**\uFF08\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u306E\u30C6\u30B9\u30C8\u30FB\u578B\u30C1\u30A7\u30C3\u30AF\u30FB\u30D3\u30EB\u30C9\u3001\u307E\u305F\u306F\u5909\u66F4\u3057\u305F\u30B3\u30DE\u30F3\u30C9\u81EA\u4F53\uFF09\u3092\u5B9F\u884C\u3059\u308B\u3002\u69CB\u6587\u30C1\u30A7\u30C3\u30AF\u3060\u3051\u3001\u307E\u305F\u306F\u8D77\u52D5\u306B\u5931\u6557\u3057\u305F\u30C1\u30A7\u30C3\u30AF\u30B3\u30DE\u30F3\u30C9\u306F\u691C\u8A3C\u306B\u6570\u3048\u306A\u3044\u3002\u8DB3\u308A\u306A\u3044\u306E\u304C\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u306E\u5BA3\u8A00\u6E08\u307F\u4F9D\u5B58\u3060\u3051\u306A\u3089\u3001\u305D\u306E\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u306E\u30D1\u30C3\u30B1\u30FC\u30B8\u30DE\u30CD\u30FC\u30B8\u30E3\u3068\u30ED\u30C3\u30AF\u30D5\u30A1\u30A4\u30EB\u3067\u5165\u308C\u308B\uFF08\`sudo\` \u3084\u30B7\u30B9\u30C6\u30E0\u306E\u30D1\u30C3\u30B1\u30FC\u30B8\u30DE\u30CD\u30FC\u30B8\u30E3\u306F\u4F7F\u308F\u306A\u3044\uFF09\u3002\u3069\u306E\u691C\u8A3C\u3082\u5B9F\u884C\u3067\u304D\u306A\u3044\u5834\u5408\u306B\u9650\u308A\u3001\u5B8C\u4E86\u3067\u306F\u306A\u304F\u300C\u3069\u306E\u691C\u8A3C\u3092\u5B9F\u884C\u3057\u306A\u304B\u3063\u305F\u304B\u30FB\u306A\u305C\u304B\u300D\u3092\u5831\u544A\u3059\u308B`;
+function systemPromptFor(model) {
+  if (isOpusModel(model)) return `${SYSTEM_PROMPT_BASE}
+
+${OPUS_SYSTEM_PROMPT_ADDENDUM}`;
+  if (isSonnetModel(model)) return `${SYSTEM_PROMPT_BASE}
+
+${SONNET_SYSTEM_PROMPT_ADDENDUM}`;
+  return SYSTEM_PROMPT_BASE;
+}
+function systemPromptVariant(model) {
+  if (isOpusModel(model)) return "opus";
+  if (isSonnetModel(model)) return "sonnet";
+  return "default";
+}
+function isOpusModel(model) {
+  return model.toLowerCase().includes("opus");
+}
+function isSonnetModel(model) {
+  return model.toLowerCase().includes("sonnet");
+}
+var CLAUDE_COMMAND = "claude";
+var cachedSystemPromptFilePaths = /* @__PURE__ */ new Map();
+function systemPromptFilePath(model) {
+  const variant = systemPromptVariant(model);
+  const cached = cachedSystemPromptFilePaths.get(variant);
+  if (cached) return cached;
+  const dir = path.join(os.tmpdir(), "claude-task-worker");
+  mkdirSync(dir, { recursive: true });
+  const target = path.join(dir, `append-system-prompt-${process.pid}-${variant}.txt`);
+  const tmp = `${target}.tmp`;
+  writeFileSync2(tmp, systemPromptFor(model), "utf8");
+  renameSync(tmp, target);
+  cachedSystemPromptFilePaths.set(variant, target);
+  return target;
+}
+function buildClaudeArgs({
+  mode,
+  prompt,
+  model,
+  effort,
+  advisorModel,
+  permissionMode,
+  cloud,
+  remoteEnvId,
+  baseRef,
+  onBranch
+}) {
+  const ref = baseRef?.trim() ?? "";
+  const onBranchValue = onBranch?.trim() ?? "";
+  if (cloud === true && ref !== "" && onBranchValue !== "") {
+    throw new Error("--on-branch and --ref both set the cloud session's base branch; pass one or the other");
+  }
+  const advisor = advisorModel?.trim() ?? "";
+  const remoteEnv = remoteEnvId?.trim() ?? "";
+  const permission = permissionMode ?? DEFAULT_PERMISSION_MODE;
+  return [
+    // default モードはプロンプトを引数で渡す（print モード）。herdr モードでは渡さない:
+    // 引数で渡すと claude が起動と同時に作業を始めてしまい、`herdr agent start` が
+    // 「入力待ちになるまで」ブロックする仕様と噛み合わない（タスクが終わるまで返らず、
+    // 2分を超えると timeout で落ちる）。プロンプトは起動後に `herdr agent prompt` で
+    // 投入し、herdr にターンを追跡させる（herdr-runner.ts の startHerdrTask 参照）。
+    // クラウド実行（`cloud: true`）も print モード非対応のため同様に省く
+    // （実測 T2: `Error: --cloud cannot be combined with --print.`）。
+    ...mode === "herdr" || cloud === true ? [] : ["-p", prompt],
+    // クラウド実行では権限モードを渡さない。クラウドセッションは `--permission-mode` を
+    // 受理するが VM 側へ反映せず（Issue #307。VM の権限モードは cloud-setup が書く
+    // settings.json の `permissions.defaultMode` が決める）、一方でローカル側の作成
+    // コマンドは script(1) の疑似pty越し＝**対話起動**として扱われるため、
+    // `bypassPermissions` を渡すと claude が「WARNING: ... Bypass Permissions mode /
+    // No, exit / Yes, I accept」の承認ダイアログを出す（print モードでは出ない）。
+    // 作成コマンドの stdin は ignore で誰も応答できず、セッションIDが出力されないまま
+    // 必ず `timed out waiting for the cloud session id` で失敗する。
+    ...cloud === true ? [] : ["--permission-mode", permission],
+    "--disallowedTools",
+    DISALLOWED_TOOLS_ARG,
+    "--append-system-prompt-file",
+    systemPromptFilePath(model),
+    "--model",
+    model,
+    "--effort",
+    effort,
+    // advisor 未指定（空文字）ならフラグごと省く。値なしの `--advisor` を渡すと
+    // 後続フラグを値として食われるため、必ずモデル名とセットでのみ付ける。
+    ...advisor === "" ? [] : ["--advisor", advisor],
+    // クラウド環境の指名。値なしの `--environment` は後続フラグを値として食うため、
+    // `--advisor` と同じく ID とセットでのみ付ける。
+    ...cloud === true && remoteEnv !== "" ? ["--environment", remoteEnv] : [],
+    // クラウド実行時は「作成コマンドの共通フラグ」だけをここで返す。`--cloud` 自体は
+    // 付けない（値として渡す description（＝クラウドセッションの初期プロンプト。
+    // appendCloudDoneInstruction() 適用後のタスクプロンプトそのもの）は
+    // `src/process-manager.ts` 側でしか決まらないため。`buildCloudCreateArgs()` が
+    // このフラグ列の先頭へ `--cloud <description>` を足して作成コマンドを完成させる）。
+    // ベースブランチ指定は `--ref` / `--on-branch` のどちらか一方のみ（両方指定は上で例外）。
+    ...cloud === true && ref !== "" ? ["--ref", ref] : [],
+    ...cloud === true && onBranchValue !== "" ? ["--on-branch", onBranchValue] : []
+  ];
+}
+function buildCloudCreateArgs(commonArgs, prompt) {
+  return ["--cloud", prompt, ...commonArgs];
+}
+function appendCloudDoneInstruction(prompt, target, debug = false) {
+  const targetLabel = target.type === "issue" ? `Issue #${target.number}` : `PR #${target.number}`;
+  const checkoutInstruction = buildCloudCheckoutInstruction(target);
+  const worktreeInstruction = buildCloudWorktreeInstruction(prompt);
+  const reportInstruction = debug ? `\`${CLOUD_DONE_LABEL}\` \u30E9\u30D9\u30EB\u3092\u4ED8\u3051\u308B\u76F4\u524D\u306B\u3001${targetLabel} \u3078 \`${CLOUD_REPORT_HEADING}\` \u3092\u898B\u51FA\u3057\u3068\u3059\u308B\u30B3\u30E1\u30F3\u30C8\u30921\u4EF6\u6295\u7A3F\u3057\u3001\u672C\u6587\u306B\u6700\u7D42\u5831\u544A\uFF08\u5B8C\u4E86\u30FB\u4E2D\u65AD\u306B\u304B\u304B\u308F\u3089\u305A\uFF09\u3092\u66F8\u304F\u3053\u3068\u3002GitHub MCP\uFF08\`add_issue_comment\`\uFF09\u3092\u512A\u5148\u3057\u3001\u5931\u6557\u3057\u305F\u5834\u5408\u306E\u307F \`gh ${target.type} comment ${target.number} --body-file -\` \u3078\u30D5\u30A9\u30FC\u30EB\u30D0\u30C3\u30AF\u3059\u308B\u3053\u3068\uFF08\u30D5\u30A9\u30FC\u30EB\u30D0\u30C3\u30AF\u306F1\u56DE\u307E\u3067\uFF09\u3002\u30EF\u30FC\u30AB\u30FC\u306F\u3053\u306E\u30B3\u30E1\u30F3\u30C8\u3092\u6700\u7D42\u30EC\u30DD\u30FC\u30C8\u3068\u3057\u3066\u56DE\u53CE\u3057 Slack \u901A\u77E5\u306B\u8F09\u305B\u308B\u3002` : "";
+  const labelInstruction = `${debug ? "\u4E0A\u8A18\u30B3\u30E1\u30F3\u30C8\u306E\u6295\u7A3F\u5F8C\u3001" : ""}\u3053\u306E\u30BB\u30C3\u30B7\u30E7\u30F3\u306E\u6700\u5F8C\u306E\u64CD\u4F5C\u3068\u3057\u3066 ${targetLabel} \u306B \`${CLOUD_DONE_LABEL}\` \u30E9\u30D9\u30EB\u3092\u4ED8\u4E0E\u3059\u308B\u3053\u3068\u3002\u4ED8\u4E0E\u306F \`bash \${CLAUDE_PLUGIN_ROOT}/scripts/gh-compat.sh add-label ${target.number} ${CLOUD_DONE_LABEL}\` \u3067\u884C\u3044\u3001\u5931\u6557\u3057\u305F\u5834\u5408\u306E\u307F \`gh api -X POST repos/{owner}/{repo}/issues/${target.number}/labels -f "labels[]=${CLOUD_DONE_LABEL}"\` \u3078\u30D5\u30A9\u30FC\u30EB\u30D0\u30C3\u30AF\u3059\u308B\u3053\u3068\uFF08\u30D5\u30A9\u30FC\u30EB\u30D0\u30C3\u30AF\u306F1\u56DE\u307E\u3067\uFF09\u3002**GitHub MCP \u306E \`issue_write\` / \`pull_request_write\`\uFF08method: \`update\`\uFF09\u306F\u4F7F\u308F\u306A\u3044\u3053\u3068** \u2014 \u540C\u30C4\u30FC\u30EB\u306E \`labels\` \u306F\u5168\u7F6E\u63DB\u3067\u3001\`${CLOUD_DONE_LABEL}\` \u3092\u8DB3\u3059\u3064\u3082\u308A\u306E\u547C\u3073\u51FA\u3057\u304C\u65E2\u5B58\u30E9\u30D9\u30EB\uFF08\`cc-triage-scope\` / \`cc-in-progress\` \u7B49\uFF09\u3092\u5DFB\u304D\u6DFB\u3048\u3067\u6D88\u3057\u3001\u305D\u306E Issue/PR \u304C\u30EF\u30FC\u30AB\u30FC\u306E\u30DD\u30FC\u30EA\u30F3\u30B0\u5BFE\u8C61\u304B\u3089\u5916\u308C\u308B\u3002\u30EF\u30FC\u30AB\u30FC\u306F\u3053\u306E\u30E9\u30D9\u30EB\u3067\u30BF\u30B9\u30AF\u306E\u7D42\u4E86\u3092\u691C\u77E5\u3057\u3066\u304A\u308A\u3001\u4ED8\u4E0E\u3055\u308C\u306A\u3044\u3068\u30BF\u30A4\u30E0\u30A2\u30A6\u30C8\u307E\u3067\u5B8C\u4E86\u6271\u3044\u306B\u306A\u3089\u306A\u3044\u3002`;
+  return [prompt, checkoutInstruction, worktreeInstruction, reportInstruction, labelInstruction].filter((part) => part !== "").join("\n\n");
+}
+var CLOUD_WORKTREE_EXEMPT_SKILLS = ["exec-issue", "fix-review-point", "create-ui-design"];
+function buildCloudWorktreeInstruction(prompt) {
+  const skill = prompt.trim().split(/\s+/)[0] ?? "";
+  if (!CLOUD_WORKTREE_EXEMPT_SKILLS.some((name) => skill.endsWith(`:${name}`))) return "";
+  return "\u3053\u306E\u30BB\u30C3\u30B7\u30E7\u30F3\u306F\u30AF\u30E9\u30A6\u30C9\u5B9F\u884C\u306E\u305F\u3081 worktree \u3092\u6301\u305F\u305A\u3001cwd \u306F\u30EA\u30DD\u30B8\u30C8\u30EA\u30EB\u30FC\u30C8\u3067\u3042\u308B\uFF08\u30EF\u30FC\u30AB\u30FC\u306F\u30AF\u30E9\u30A6\u30C9\u5B9F\u884C\u6642\u306B worktree \u3092\u4F5C\u3089\u306A\u3044\uFF09\u3002\u30B9\u30AD\u30EB\u672C\u6587\u306E\u30D5\u30A7\u30FC\u30BA0\u306B\u3042\u308B\u300C`pwd` \u304C `.claude/worktrees/` \u914D\u4E0B\u3067\u306A\u3051\u308C\u3070\u4E2D\u65AD\u3059\u308B\u300D\u78BA\u8A8D\u306F\u3001\u3053\u306E\u6307\u793A\u304C\u3042\u308B\u5834\u5408\u306B\u9650\u308A\u9069\u7528\u3057\u306A\u3044\u3053\u3068\u3002\u305F\u3060\u3057\u30AC\u30FC\u30C9\u306E\u76EE\u7684\u3067\u3042\u308B\u300C\u30C7\u30D5\u30A9\u30EB\u30C8\u30D6\u30E9\u30F3\u30C1\u3067\u4F5C\u696D\u3057\u306A\u3044\u300D\u306F\u7DAD\u6301\u3059\u308B\u3053\u3068 \u2014 \u540C\u3058\u30D5\u30A7\u30FC\u30BA0\u306E\u300C\u30C7\u30D5\u30A9\u30EB\u30C8\u30D6\u30E9\u30F3\u30C1\u540D\u3092\u53D6\u5F97\u3057\u3001\u73FE\u5728\u30D6\u30E9\u30F3\u30C1\u3068\u4E00\u81F4\u3059\u308B\u5834\u5408\u306F\u4E2D\u65AD\u3059\u308B\uFF08\u53D6\u5F97\u5931\u6557\u3082\u4E2D\u65AD\uFF09\u300D\u306F\u5FC5\u305A\u5B9F\u884C\u3057\u3001\u4E00\u81F4\u3057\u305F\u5834\u5408\u306F\u5F93\u6765\u3069\u304A\u308A\u4E2D\u65AD\u3059\u308B\u3053\u3068\u3002";
+}
+function buildCloudCheckoutInstruction(target) {
+  if (target.type !== "pr" || !target.onBranch) return "";
+  return `\u3053\u306E\u30BB\u30C3\u30B7\u30E7\u30F3\u306F PR #${target.number} \u306E head \u30D6\u30E9\u30F3\u30C1\u4E0A\u3067\u958B\u59CB\u3057\u3066\u3044\u308B\uFF08\u30EF\u30FC\u30AB\u30FC\u304C \`--on-branch\` \u3067\u6307\u5B9A\u6E08\u307F\uFF09\u3002\u30B9\u30AD\u30EB\u672C\u6587\u304C\u6307\u793A\u3059\u308B \`gh pr checkout\` \u306F\u5B9F\u884C\u3057\u306A\u3044\u3053\u3068\uFF08\u30AF\u30E9\u30A6\u30C9\u3067\u306F GraphQL \u30B2\u30FC\u30C8\u306B\u3088\u308A 403 \u3067\u5931\u6557\u3057\u3001\u304B\u3064\u65E2\u306B\u30D6\u30E9\u30F3\u30C1\u4E0A\u306B\u3044\u308B\u306E\u3067\u4E0D\u8981\uFF09\u3002\u30D6\u30E9\u30F3\u30C1\u306E\u78BA\u8A8D\u304C\u8981\u308B\u5834\u5408\u306F \`git rev-parse --abbrev-ref HEAD\` \u3092\u4F7F\u3046\u3053\u3068\u3002`;
+}
+function buildCloudGitHubAccessInstruction() {
+  return "\u3053\u306E\u30BB\u30C3\u30B7\u30E7\u30F3\u306F\u30AF\u30E9\u30A6\u30C9\u5B9F\u884C\u306E\u305F\u3081\u3001GitHub \u306E\u53C2\u7167/\u66F4\u65B0\u306F **GitHub MCP \u3092\u7B2C\u4E00\u624B\u6BB5**\u306B\u3059\u308B\u3053\u3068\uFF08\u30B9\u30AD\u30EB\u672C\u6587\u3068 `references/github-access.md` \u306E\u65E2\u5B9A\u3067\u3042\u308B `gh` \u512A\u5148\u3092\u3001\u3053\u306E\u30BB\u30C3\u30B7\u30E7\u30F3\u306B\u9650\u308A\u9006\u8EE2\u3055\u305B\u308B\uFF09\u3002\u30AF\u30E9\u30A6\u30C9\u306E GitHub \u30D7\u30ED\u30AD\u30B7\u306F `gh issue view --json` / `gh pr view --json` \u306A\u3069\u306E GraphQL \u7D4C\u7531\u306E\u64CD\u4F5C\u3092\u30D5\u30A3\u30FC\u30EB\u30C9\u3092\u554F\u308F\u305A 403 \u306B\u3059\u308B\u305F\u3081\u3001`gh` \u3092\u7B2C\u4E00\u624B\u6BB5\u306B\u3059\u308B\u3068 Issue/PR \u672C\u6587\u3092\u53D6\u5F97\u3067\u304D\u306A\u3044\u3002MCP \u306B\u8A72\u5F53\u30C4\u30FC\u30EB\u304C\u7121\u3044\u64CD\u4F5C\u306F `gh api repos/...`\uFF08REST\uFF09\u307E\u305F\u306F `plugin/scripts/gh-compat.sh` \u3092\u4F7F\u3046\u3053\u3068\uFF08REST \u306F\u30AF\u30E9\u30A6\u30C9\u3067\u3082\u6210\u529F\u3059\u308B\uFF09\u3002\u30D5\u30A9\u30FC\u30EB\u30D0\u30C3\u30AF\u306F1\u64CD\u4F5C\u306B\u3064\u304D1\u56DE\u307E\u3067\u3002\u305F\u3060\u3057\u6B21\u306E3\u3064\u306F MCP \u3092\u4F7F\u308F\u306A\u3044\u3053\u3068: (1) Issue / PR \u306E\u4F5C\u6210\u306F `gh-compat.sh create-issue` / `create-pr`\uFF08MCP \u306E `create_pull_request` \u306F labels / assignees \u3092\u53D7\u3051\u4ED8\u3051\u305A\u3001`issue_write` \u306E create \u3082\u6E21\u3057\u5FD8\u308C\u3067\u6B20\u843D\u3057\u3001Assignee \u3068 `cc-triage-scope` \u306E\u7121\u3044 Issue/PR \u304C\u30EF\u30FC\u30AB\u30FC\u306B\u62FE\u308F\u308C\u306A\u304F\u306A\u308B\uFF09\u3001(2) \u30E9\u30D9\u30EB\u30FBAssignee \u306E\u8FFD\u52A0\u306F `gh-compat.sh add-label` / `add-assignee`\uFF08MCP \u306E update \u306F\u5168\u7F6E\u63DB\u3067\u65E2\u5B58\u306E\u3082\u306E\u3092\u6D88\u3059\uFF09\u3001(3) \u30B3\u30DF\u30C3\u30C8\u306F `git commit` \u3068 `git push` \u3060\u3051\u3067\u884C\u3044\u3001`push_files` / `create_or_update_file` / `delete_file` / `create_branch` \u306F\u4F7F\u308F\u306A\u3044\uFF08MCP \u7D4C\u7531\u306E\u30B3\u30DF\u30C3\u30C8\u3067\u306F CI \u304C\u8D77\u52D5\u3057\u306A\u3044\u5834\u9762\u304C\u3042\u308B\u3002`git push` \u304C\u5931\u6557\u3057\u3066\u3082 MCP \u3078\u30D5\u30A9\u30FC\u30EB\u30D0\u30C3\u30AF\u305B\u305A\u3001\u5931\u6557\u3068\u3057\u3066\u5831\u544A\u3059\u308B\uFF09\u3002";
+}
+function buildCloudToolRestriction() {
+  return `\u30AF\u30E9\u30A6\u30C9\u5B9F\u884C\u3067\u306F \`--disallowedTools\` \u30D5\u30E9\u30B0\u306B\u3088\u308B\u30C4\u30FC\u30EB\u5236\u9650\u304C\u53CD\u6620\u3055\u308C\u306A\u3044\u305F\u3081\u3001\u4EE5\u4E0B\u306E\u30C4\u30FC\u30EB\u3092\u4F7F\u308F\u306A\u3044\u3053\u3068: ${DISALLOWED_TOOLS.join(", ")}`;
+}
+function buildCloudPrompt(prompt, model, target, debug = false) {
+  const principles = `\u4EE5\u4E0B\u306F\u3053\u306E\u30BB\u30C3\u30B7\u30E7\u30F3\u306E\u5B9F\u884C\u539F\u5247\u3067\u3042\u308B\u3002\u30AF\u30E9\u30A6\u30C9\u5B9F\u884C\u3067\u306F\u30B7\u30B9\u30C6\u30E0\u30D7\u30ED\u30F3\u30D7\u30C8\u306B\u3088\u308B\u6CE8\u5165\u304C\u53CD\u6620\u3055\u308C\u306A\u3044\u305F\u3081\u3001\u30D7\u30ED\u30F3\u30D7\u30C8\u672C\u6587\u3068\u3057\u3066\u6E21\u3057\u3066\u3044\u308B\u3002
+
+${systemPromptFor(model)}
+
+${buildCloudToolRestriction()}
+
+${buildCloudGitHubAccessInstruction()}`;
+  const withPrinciples = `${prompt}
+
+${principles}`;
+  return target ? appendCloudDoneInstruction(withPrinciples, target, debug) : withPrinciples;
+}
+function shellQuote2(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function buildScriptCommand(command, args, platform = process.platform) {
+  if (platform === "darwin") {
+    return { command: "script", args: ["-q", "/dev/null", command, ...args] };
+  }
+  if (platform === "linux") {
+    return { command: "script", args: ["-qec", [command, ...args].map(shellQuote2).join(" "), "/dev/null"] };
+  }
+  throw new Error(`unsupported platform for script(1): ${platform}`);
+}
+function buildClaudeExecution(invocation) {
+  return {
+    command: CLAUDE_COMMAND,
+    args: buildClaudeArgs(invocation),
+    // クラウド実行では `-p` を付けない代わりに `--cloud` の値（初期プロンプト）として
+    // 渡すため、mode に関わらずプロンプトを返す。
+    ...invocation.mode === "herdr" || invocation.cloud === true ? { prompt: invocation.prompt } : {}
+  };
+}
+function buildClaudeEnv(mode, cloud) {
+  const base = mode === "herdr" || cloud ? { CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: CLAUDE_SPAWN_ENV.CLAUDE_CODE_DISABLE_BACKGROUND_TASKS } : { ...CLAUDE_SPAWN_ENV };
+  if (!cloud) return base;
+  return { ...base, CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1" };
+}
+
+// src/git.ts
+import { execSync, execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+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";
+import { basename } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+
+// src/task-result.ts
+var STDERR_TAIL_LIMIT = 8 * 1024;
+var CLOUD_FAILURE_GUIDANCE = "[worker] \u30AF\u30E9\u30A6\u30C9\u5B9F\u884C\u306E\u524D\u63D0\u6761\u4EF6\uFF08GitHub \u9023\u643A / allow_remote_sessions \u7D44\u7E54\u30DD\u30EA\u30B7\u30FC\uFF09\u304C\u6E80\u305F\u3055\u308C\u3066\u3044\u306A\u3044\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059\u3002\u8A73\u7D30\u306F docs/cloud-prerequisite-checks.md \u3092\u53C2\u7167\u3057\u3066\u304F\u3060\u3055\u3044\u3002";
+function appendCloudFailureGuidance(result, cloud) {
+  if (!cloud || result.status === "completed") return result;
+  return { ...result, output: `${CLOUD_FAILURE_GUIDANCE}
+${result.output}` };
+}
+function buildTaskResult(code, stdout, stderrTail) {
+  const emptyOutput = stdout.trim() === "";
+  const completed = code === 0 && !emptyOutput;
+  let output = stdout;
+  if (code === 0 && emptyOutput) {
+    output += "[worker] claude exited with code 0 but produced no output (session aborted before the model ran; e.g. a skill preamble command failed)";
+  } else if (!completed) {
+    output += `
+[worker] claude exited with code ${code}`;
+  }
+  if (!completed && stderrTail.trim() !== "") {
+    output += `
+[stderr] ${stderrTail.trim()}`;
+  }
+  return { status: completed ? "completed" : "failed", output };
+}
+
+// src/process-manager.ts
+var childProcesses = /* @__PURE__ */ new Map();
+var herdrTasks = /* @__PURE__ */ new Map();
+var herdrAbortSignal = { aborted: false };
+var tasks = /* @__PURE__ */ new Map();
+function pushTaskLogLine(id, stream, text) {
+  pushLogLine({ id, stream, text: text.replace(/\r$/, ""), time: /* @__PURE__ */ new Date() });
+}
+function makeLogFeeder(id, stream) {
+  let partial = "";
+  const decoder = new StringDecoder("utf-8");
+  return {
+    feed(chunk) {
+      partial += decoder.write(chunk);
+      const parts = partial.split("\n");
+      partial = parts.pop() ?? "";
+      for (const part of parts) pushTaskLogLine(id, stream, part);
+    },
+    flush() {
+      partial += decoder.end();
+      if (partial.length > 0) {
+        pushTaskLogLine(id, stream, partial);
+        partial = "";
+      }
+    }
+  };
+}
+function pruneTaskHistory() {
+  const finished = [...tasks.values()].filter((t) => t.status !== "running").sort((a, b) => (b.finishedAt ?? b.startedAt).getTime() - (a.finishedAt ?? a.startedAt).getTime());
+  for (const t of finished.slice(TASK_DISPLAY_LIMIT)) tasks.delete(t.id);
+}
+var shuttingDown = false;
+function setShuttingDown() {
+  shuttingDown = true;
+}
+function isShuttingDown() {
+  return shuttingDown;
+}
+function isRunning(id) {
+  const task = tasks.get(id);
+  return task?.status === "running";
+}
+function isWorktreeInUse(worktreeId) {
+  for (const task of tasks.values()) {
+    if (task.status === "running" && task.path === worktreeId) {
+      return true;
+    }
+  }
+  return false;
+}
+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 renderTable() {
+  const taskLines = buildTaskTableLines(selectRecentTasks([...tasks.values()]));
+  const logTableLines = buildLogTableLines(logLines);
+  if (taskLines.length === 0 && logTableLines.length === 0) return;
+  const lines = [...taskLines];
+  if (logTableLines.length > 0) {
+    if (lines.length > 0) lines.push("");
+    lines.push("Logs", ...logTableLines);
+  }
+  writeScreen(lines);
+}
+var renderInterval;
+function ensureRenderInterval() {
+  if (renderInterval) return;
+  renderInterval = setInterval(renderTable, 1e3);
+  renderInterval.unref();
+}
+async function finishTask(id, result, onComplete) {
+  try {
+    await Promise.race([
+      onComplete?.(result.status, result.output, result.cloudSessionId) ?? 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;
+  }
+  pruneTaskHistory();
+  renderTable();
+}
+function onCompleteWithDebugReport(onComplete, target) {
+  if (!target || !hasDebugFlag()) return onComplete;
+  return async (status, output, cloudSessionId) => {
+    const body = output.trim();
+    if (body !== "") {
+      const comment = target.type === "issue" ? commentOnIssue : commentOnPR;
+      await comment(target.number, `${CLOUD_REPORT_HEADING}
+
+${body}`).catch(
+        (err) => console.error(`[worker] failed to post the debug report to ${target.type} #${target.number}: ${err}`)
+      );
+    }
+    await onComplete?.(status, output, cloudSessionId);
+  };
+}
+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(args, prompt, id, onComplete, cwd, env) {
+  const { startHerdrTask, stopHerdrTask, taskTabLabel, waitForHerdrTask } = await import("./herdr-runner-33D6C2KI.js");
+  const { getCurrentWorkspaceId } = await import("./herdr-NDLUM6JF.js");
+  const label = taskTabLabel(resolveProjectName(), id);
+  let task;
+  let result;
+  herdrTasks.set(id, { paneId: "", tabId: "" });
+  try {
+    task = await startHerdrTask({
+      label,
+      cwd: cwd ?? process.cwd(),
+      args,
+      prompt,
+      env,
+      workspaceId: getCurrentWorkspaceId()
+    });
+    herdrTasks.set(id, task);
+    result = await waitForHerdrTask(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 stopHerdrTask(task);
+    }
+  }
+  await finishTask(id, result, onComplete);
+  herdrTasks.delete(id);
+}
+var CLOUD_SESSION_TIMEOUT_MS = Number(process.env.CTW_CLOUD_SESSION_TIMEOUT_MS) || 120 * 1e3;
+var CLOUD_SESSION_POLL_INTERVAL_MS = 1e3;
+var CLOUD_POLL_INTERVAL_MS = 30 * 1e3;
+var CLOUD_TASK_TIMEOUT_MS = Number(process.env.CTW_CLOUD_TASK_TIMEOUT_MS) || 4 * 60 * 60 * 1e3;
+var cloudWaiters = /* @__PURE__ */ new Map();
+var cloudPollLoopRunning = false;
+function ensureCloudPollLoop() {
+  if (cloudPollLoopRunning) return;
+  cloudPollLoopRunning = true;
+  void (async () => {
+    try {
+      await pollCloudWaiters();
+    } finally {
+      cloudPollLoopRunning = false;
+    }
+  })();
+}
+async function pollCloudWaiters() {
+  while (cloudWaiters.size > 0) {
+    if (herdrAbortSignal.aborted) {
+      for (const waiter of cloudWaiters.values()) waiter.settle("aborted");
+      cloudWaiters.clear();
+      break;
+    }
+    const pendingTypes = /* @__PURE__ */ new Set();
+    for (const waiter of cloudWaiters.values()) pendingTypes.add(waiter.type);
+    const doneKeys = /* @__PURE__ */ new Map();
+    for (const type of pendingTypes) {
+      try {
+        const numbers = await listNumbersWithLabel(type, CLOUD_DONE_LABEL);
+        doneKeys.set(type, new Set(numbers));
+      } catch (err) {
+        console.error(`[worker] failed to poll ${CLOUD_DONE_LABEL} for ${type}: ${err}`);
+      }
+    }
+    const now = Date.now();
+    for (const [key, waiter] of [...cloudWaiters.entries()]) {
+      const done = doneKeys.get(waiter.type);
+      if (done?.has(waiter.number)) {
+        waiter.settle("completed");
+        cloudWaiters.delete(key);
+      } else if (now >= waiter.deadline) {
+        waiter.settle("timeout");
+        cloudWaiters.delete(key);
+      }
+    }
+    if (cloudWaiters.size === 0) break;
+    for (let waited = 0; waited < CLOUD_POLL_INTERVAL_MS; waited += 1e3) {
+      if (herdrAbortSignal.aborted) break;
+      await new Promise((resolve5) => setTimeout(resolve5, 1e3));
+    }
+  }
+}
+function waitForCloudTask(id, target) {
+  return new Promise((resolve5) => {
+    cloudWaiters.set(`${target.type}:${target.number}:${id}`, {
+      type: target.type,
+      number: target.number,
+      deadline: Date.now() + CLOUD_TASK_TIMEOUT_MS,
+      settle: resolve5
+    });
+    ensureCloudPollLoop();
+  });
+}
+async function flagOrphanedCloudSession(target, reason, cloudSessionId) {
+  const { type, number: id } = target;
+  await addLabel(type, id, "cc-need-human-check").catch((err) => {
+    console.error(`[worker] failed to add cc-need-human-check to ${type} #${id}: ${err}`);
+  });
+  const causeLine = reason === "session-id" ? "\u30BB\u30C3\u30B7\u30E7\u30F3ID\u306E\u62BD\u51FA\u306B\u5931\u6557\u3057\u3066\u5F85\u6A5F\u3092\u6253\u3061\u5207\u308A\u307E\u3057\u305F\u3002\u30D7\u30ED\u30F3\u30D7\u30C8\u306F\u6295\u5165\u6E08\u307F\u3067\u3001\u30AF\u30E9\u30A6\u30C9\u30BB\u30C3\u30B7\u30E7\u30F3\u306F\u72EC\u7ACB\u3057\u3066\u7A3C\u50CD\u3057\u3066\u3044\u308B\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059\u3002" : "\u30EF\u30FC\u30AB\u30FC\u306E\u30B7\u30E3\u30C3\u30C8\u30C0\u30A6\u30F3\u3067\u5F85\u6A5F\u3092\u6253\u3061\u5207\u308A\u307E\u3057\u305F\u3002\u30AF\u30E9\u30A6\u30C9\u30BB\u30C3\u30B7\u30E7\u30F3\u306F\u7D99\u7D9A\u3057\u3066\u3044\u308B\u53EF\u80FD\u6027\u304C\u9AD8\u3044\u3067\u3059\u3002";
+  const sessionLine = cloudSessionId ? `https://claude.ai/code/${cloudSessionId}` : "\u30BB\u30C3\u30B7\u30E7\u30F3URL\u4E0D\u660E\uFF08ID\u62BD\u51FA\u306B\u5931\u6557\uFF09";
+  const body = `## \u5B64\u7ACB\u30AF\u30E9\u30A6\u30C9\u30BB\u30C3\u30B7\u30E7\u30F3\u306E\u53EF\u80FD\u6027
+
+**\u539F\u56E0**: ${causeLine}
+
+**\u30BB\u30C3\u30B7\u30E7\u30F3URL**: ${sessionLine}
+
+**\u518D\u958B\u65B9\u6CD5**: \u5B64\u7ACB\u30BB\u30C3\u30B7\u30E7\u30F3\u306E\u6210\u679C\u7269\u304C\u5C4A\u3044\u3066\u3044\u306A\u3044\u304B\u78BA\u8A8D\u3057\u305F\u3046\u3048\u3067\u3001\`cc-need-human-check\` \u30E9\u30D9\u30EB\u3092\u5916\u3059\u3068\u30DD\u30FC\u30EA\u30F3\u30B0\u5BFE\u8C61\u306B\u623B\u308A\u307E\u3059\u3002`;
+  const commentFn = type === "issue" ? commentOnIssue : commentOnPR;
+  await commentFn(id, body).catch((err) => {
+    console.error(`[worker] failed to comment on ${type} #${id} about the orphaned cloud session: ${err}`);
+  });
+}
+async function createCloudSession(args, initialPrompt, cwd, env) {
+  const { extractCloudSessionId, normalizePtyOutput } = await import("./herdr-runner-33D6C2KI.js");
+  const spec = buildScriptCommand("claude", buildCloudCreateArgs(args, initialPrompt));
+  const child = spawn(spec.command, spec.args, {
+    stdio: ["ignore", "pipe", "pipe"],
+    ...cwd ? { cwd } : {},
+    ...env ? { env: { ...process.env, ...env } } : {}
+  });
+  let output = "";
+  return await new Promise((resolve5, reject) => {
+    let settled = false;
+    const finish = (err, sessionId) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      clearInterval(abortCheck);
+      if (err) {
+        child.kill();
+        reject(err);
+      } else {
+        resolve5(sessionId);
+      }
+    };
+    const scan = () => {
+      const sessionId = extractCloudSessionId(normalizePtyOutput(output));
+      if (sessionId) finish(void 0, sessionId);
+    };
+    child.stdout?.on("data", (chunk) => {
+      output += chunk.toString("utf-8");
+      scan();
+    });
+    child.on("error", (err) => finish(new Error(`failed to spawn the cloud session command: ${err.message}`)));
+    child.on("close", () => {
+      scan();
+      finish(new Error(`the cloud session command exited without a session id (output tail: ${output.slice(-1e3)})`));
+    });
+    const timer = setTimeout(
+      () => finish(new Error(`timed out waiting for the cloud session id (output tail: ${output.slice(-1e3)})`)),
+      CLOUD_SESSION_TIMEOUT_MS
+    );
+    const abortCheck = setInterval(() => {
+      if (herdrAbortSignal.aborted) {
+        finish(new Error("the worker is shutting down before the cloud session could be created"));
+      }
+    }, CLOUD_SESSION_POLL_INTERVAL_MS);
+  });
+}
+async function runViaCloud(args, prompt, id, onComplete, cwd, env, cloudTarget, model) {
+  herdrTasks.set(id, { paneId: "", tabId: "" });
+  const debug = hasDebugFlag();
+  const initialPrompt = buildCloudPrompt(prompt, model ?? "", cloudTarget, debug);
+  let result;
+  let cloudSessionId;
+  try {
+    cloudSessionId = await createCloudSession(args, initialPrompt, cwd, env);
+    const createOutput = `[worker] created cloud session ${cloudSessionId} with the task's initial prompt`;
+    if (!cloudTarget) {
+      console.warn(`[worker] #${id} has no completion-detection target, treating session creation as completion`);
+      result = { status: "completed", output: createOutput };
+    } else {
+      const outcome = await waitForCloudTask(id, cloudTarget);
+      const { type: targetType, number: targetNumber } = cloudTarget;
+      if (outcome === "completed") {
+        await removeLabel(targetType, targetNumber, CLOUD_DONE_LABEL).catch((err) => {
+          console.error(`[worker] failed to remove ${CLOUD_DONE_LABEL} from ${targetType} #${targetNumber}: ${err}`);
+        });
+        let reportBody = null;
+        const startedAt = tasks.get(id)?.startedAt;
+        if (debug && startedAt) {
+          try {
+            reportBody = await findCommentSince(targetNumber, startedAt, CLOUD_REPORT_HEADING);
+          } catch (err) {
+            console.error(
+              `[worker] failed to fetch the cloud report comment for ${targetType} #${targetNumber}: ${err}`
+            );
+          }
+        }
+        result = {
+          status: "completed",
+          output: reportBody ?? `${createOutput}
+[worker] detected completion via the ${CLOUD_DONE_LABEL} label`
+        };
+      } else if (outcome === "timeout") {
+        await addLabel(targetType, targetNumber, "cc-need-human-check").catch((err) => {
+          console.error(`[worker] failed to add cc-need-human-check to ${targetType} #${targetNumber}: ${err}`);
+        });
+        result = {
+          status: "failed",
+          output: `${createOutput}
+[worker] timed out waiting for the ${CLOUD_DONE_LABEL} label after ${CLOUD_TASK_TIMEOUT_MS / 1e3 / 60} minutes. Possible causes: the session stopped on AskUserQuestion, the cloud VM crashed, the plugin was not installed, or label assignment itself failed.`
+        };
+      } else {
+        await flagOrphanedCloudSession(cloudTarget, "shutdown", cloudSessionId);
+        result = {
+          status: "failed",
+          output: `${createOutput}
+[worker] shutdown aborted the wait for the ${CLOUD_DONE_LABEL} label. The session may still be running; added cc-need-human-check.`
+        };
+      }
+    }
+    result.cloudSessionId = cloudSessionId;
+  } catch (err) {
+    console.error(`[worker] failed to run #${id} via cloud: ${err}`);
+    let orphanNote = "[worker] note: with the 1-command launch, the cloud session may already have started working independently even though this task is being reported as failed locally (orphaned session).";
+    if (cloudTarget) {
+      const reason = herdrAbortSignal.aborted ? "shutdown" : "session-id";
+      await flagOrphanedCloudSession(cloudTarget, reason, cloudSessionId);
+      orphanNote += " added cc-need-human-check so a human can verify whether it completed on its own.";
+    }
+    result = {
+      status: "failed",
+      output: `[worker] failed to run the task via cloud: ${err}
+${orphanNote}`,
+      ...cloudSessionId ? { cloudSessionId } : {}
+    };
+  }
+  result = appendCloudFailureGuidance(result, true);
+  await finishTask(id, result, onComplete);
+  herdrTasks.delete(id);
+}
+function run(command, args, id, title, workerName, path2, onComplete, cwd, env, prompt, cloud, cloudTarget, model) {
+  tasks.delete(id);
+  tasks.set(id, {
+    id,
+    title,
+    status: "running",
+    workerName,
+    // クラウド実行は worktree を持たない（ワーカーが path に undefined を渡す）ため、
+    // 空欄ではなく実行場所が分かる表示を入れる。
+    path: cloud ? CLOUD_WORKTREE_LABEL : path2,
+    startedAt: /* @__PURE__ */ new Date()
+  });
+  ensureRenderInterval();
+  renderTable();
+  if (cloud) {
+    void runViaCloud(args, prompt ?? "", id, onComplete, cwd, env, cloudTarget, model);
+    return;
+  }
+  const onCompleteWithReport = onCompleteWithDebugReport(onComplete, cloudTarget);
+  if (getRunMode() === "herdr") {
+    void runViaHerdr(args, prompt ?? "", id, onCompleteWithReport, cwd, env);
+    return;
+  }
+  const child = spawn(command, args, {
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true,
+    ...cwd ? { cwd } : {},
+    ...env ? { env: { ...process.env, ...env } } : {}
+  });
+  childProcesses.set(id, child);
+  const stdoutFeeder = makeLogFeeder(id, "stdout");
+  const stderrFeeder = makeLogFeeder(id, "stderr");
+  const outputChunks = [];
+  child.stdout?.on("data", (chunk) => {
+    outputChunks.push(chunk);
+    stdoutFeeder.feed(chunk);
+  });
+  const stderrChunks = [];
+  let stderrLen = 0;
+  child.stderr?.on("data", (chunk) => {
+    stderrChunks.push(chunk);
+    stderrLen += chunk.length;
+    while (stderrChunks.length > 1 && stderrLen - stderrChunks[0].length >= STDERR_TAIL_LIMIT) {
+      stderrLen -= stderrChunks[0].length;
+      stderrChunks.shift();
+    }
+    stderrFeeder.feed(chunk);
+  });
+  child.on("close", async (code) => {
+    stdoutFeeder.flush();
+    stderrFeeder.flush();
+    const result = buildTaskResult(
+      code,
+      Buffer.concat(outputChunks).toString("utf-8"),
+      Buffer.concat(stderrChunks).toString("utf-8").slice(-STDERR_TAIL_LIMIT)
+    );
+    await finishTask(id, result, onCompleteWithReport);
+    childProcesses.delete(id);
+  });
+  child.on("error", async (err) => {
+    console.error(`[worker] failed to spawn process for #${id}: ${err.message}`);
+    await finishTask(id, { status: "failed", output: err.message }, onCompleteWithReport);
+    childProcesses.delete(id);
+  });
+}
+function waitForAllProcesses() {
+  return new Promise((resolve5) => {
+    const check = () => {
+      if (childProcesses.size === 0 && herdrTasks.size === 0) {
+        resolve5();
+      } 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 {
+      }
+    }
+  }
+  if (herdrTasks.size > 0) {
+    herdrAbortSignal.aborted = true;
+  }
+}
+
+// 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}`;
+}
+function isGeneratedWorktreeName(name) {
+  return /^[a-z]+-[a-z]+-\d{4}$/.test(name);
+}
+
+// src/slack.ts
+import { exec } from "node:child_process";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync4 } 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 as mkdirSync2, renameSync as renameSync2, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, 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)));
+}
+function jstFields(date) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: JST,
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hourCycle: "h23"
+  }).formatToParts(date);
+  const pick2 = (type) => parts.find((p) => p.type === type)?.value ?? "";
+  return { month: pick2("month"), day: pick2("day"), hour: pick2("hour"), minute: pick2("minute") };
+}
+var MINUTE_MS = 6e4;
+function ceilToMinute(date) {
+  const remainder = date.getTime() % MINUTE_MS;
+  return remainder === 0 ? date : new Date(date.getTime() + (MINUTE_MS - remainder));
+}
+function parseResetsAt(isoString) {
+  const date = new Date(isoString);
+  return Number.isNaN(date.getTime()) ? null : ceilToMinute(date);
+}
+function resetStamp(isoString, now = /* @__PURE__ */ new Date()) {
+  const date = parseResetsAt(isoString);
+  if (!date) return "";
+  const reset = jstFields(date);
+  const today = jstFields(now);
+  const time = `${reset.hour}:${reset.minute}`;
+  if (reset.month === today.month && reset.day === today.day) return time;
+  return `${reset.month}/${reset.day} ${time}`;
+}
+function resetHour(isoString) {
+  const date = parseResetsAt(isoString);
+  return date ? jstFields(date).hour : "";
+}
+function metric(title, pct, resetsAt, now) {
+  const stamp = resetStamp(resetsAt, now);
+  return {
+    title,
+    formattedValue: `${formatG(pct)}%` + (stamp ? ` \u21BB${stamp}` : ""),
+    normalizedValue: Math.round(pct / 100 * 1e4) / 1e4
+  };
+}
+function buildRuncatSnapshot(usage, now = /* @__PURE__ */ new Date()) {
+  const bar = `${formatG(usage.fiveHourUtilization)}/${formatG(usage.sevenDayUtilization)}`;
+  const stamp = resetHour(usage.fiveHourResetsAt);
+  return {
+    title: "Claude Code",
+    symbol: "staroflife",
+    metrics: [
+      metric("5h", usage.fiveHourUtilization, usage.fiveHourResetsAt, now),
+      metric("7d", usage.sevenDayUtilization, usage.sevenDayResetsAt, now)
+    ],
+    metricsBarValue: stamp ? `${bar} \u21BB${stamp}` : bar,
+    lastUpdatedDate: now.toISOString().replace(/\.\d{3}Z$/, "Z")
+  };
+}
+function writeRuncatUsage(usage, outFile = RUNCAT_OUT_FILE) {
+  const snapshot = buildRuncatSnapshot(usage);
+  const dir = dirname2(outFile);
+  const tmp = join3(dir, `.runcat-${process.pid}-${Date.now()}.json`);
+  try {
+    mkdirSync2(dir, { recursive: true });
+    writeFileSync3(tmp, JSON.stringify(snapshot), "utf-8");
+    renameSync2(tmp, outFile);
+  } catch (err) {
+    rmSync(tmp, { force: true });
+    console.error(`[runcat] Failed to write ${outFile}: ${err}`);
+  }
+}
+
+// src/slack.ts
+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 = readFileSync3(join4(homedir3(), ".claude", ".credentials.json"), "utf-8");
+    return extractToken(JSON.parse(raw));
+  }
+}
+function readUsageCache() {
+  try {
+    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;
+    }
+  } catch {
+  }
+  return null;
+}
+function writeUsageCache(data) {
+  try {
+    writeFileSync4(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"
+  });
+}
+function formatTokenLimitText(usage) {
+  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 buildTokenLimitText() {
+  const usage = await fetchUsageInfo();
+  if (!usage) return "";
+  writeRuncatUsage(usage);
+  return formatTokenLimitText(usage);
+}
+function truncateOutputForNotification(output) {
+  if (output.length <= 1e3) return output;
+  if (output.startsWith(CLOUD_FAILURE_GUIDANCE)) {
+    const rest = output.slice(CLOUD_FAILURE_GUIDANCE.length);
+    return `${CLOUD_FAILURE_GUIDANCE}\u2026${rest.slice(-1e3)}`;
+  }
+  return `\u2026${output.slice(-1e3)}`;
+}
+function buildTaskNotificationText(params) {
+  const { status, workerName, repoName, id, title, url, tokenText, output, cloud } = params;
+  const emoji = status === "completed" ? "\u2705" : "\u274C";
+  const label = status === "completed" ? "completed" : "failed";
+  const truncatedOutput = output ? truncateOutputForNotification(output) : output;
+  const outputBlock = truncatedOutput ? `
+\`\`\`${truncatedOutput}\`\`\`` : "";
+  const body = `${emoji} [${workerName}] ${repoName} | Task ${label}: <${url}|#${id} ${title}>${tokenText}${outputBlock}`;
+  let sessionUrlPrefix = "";
+  if (cloud) {
+    sessionUrlPrefix = cloud.sessionId?.trim() ? `https://claude.ai/code/${cloud.sessionId.trim()}
+` : "\u30BB\u30C3\u30B7\u30E7\u30F3URL\u4E0D\u660E\uFF08ID\u62BD\u51FA\u306B\u5931\u6557\uFF09\n";
+  }
+  return `${sessionUrlPrefix}${body}`;
+}
+async function notifyTaskCompleted(workerName, repoName, id, title, url, output, cloud) {
+  const tokenText = await buildTokenLimitText();
+  await send({
+    text: buildTaskNotificationText({
+      status: "completed",
+      workerName,
+      repoName,
+      id,
+      title,
+      url,
+      tokenText,
+      output,
+      cloud
+    })
+  });
+}
+async function notifyTaskFailed(workerName, repoName, id, title, url, output, cloud) {
+  const tokenText = await buildTokenLimitText();
+  await send({
+    text: buildTaskNotificationText({
+      status: "failed",
+      workerName,
+      repoName,
+      id,
+      title,
+      url,
+      tokenText,
+      output,
+      cloud
+    })
+  });
+}
+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 { createRequire as createRequire2 } from "node:module";
+import { promisify as promisify3 } from "node:util";
+import { readdir, rm, stat } from "node:fs/promises";
+import { basename as basename2, resolve as resolve4, sep } from "node:path";
+var childProcess2 = createRequire2(import.meta.url)("node:child_process");
+var execFileAsync2 = (command, args) => promisify3(childProcess2.execFile)(command, args);
+var WORKTREES_DIR = ".claude/worktrees";
+function isManagedWorktreePath(path2) {
+  return resolve4(path2).startsWith(resolve4(WORKTREES_DIR) + sep);
+}
+async function pathExists(path2) {
+  try {
+    await stat(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function forceRemoveIfExists(path2) {
+  if (!isManagedWorktreePath(path2)) {
+    console.error(`[worktree] Refusing to remove path outside ${WORKTREES_DIR}: ${path2}`);
+    return;
+  }
+  if (!await pathExists(path2)) return;
+  try {
+    await rm(path2, { recursive: true, force: true });
+    console.log(`[worktree] Force removed remaining directory: ${path2}`);
+  } catch (error) {
+    console.error(`[worktree] Failed to remove directory ${path2}:`, error);
+  }
+}
+async function listWorktreeEntries() {
+  const { stdout } = await execFileAsync2("git", ["worktree", "list", "--porcelain"]);
+  return stdout.replace(/\r\n/g, "\n").trim().split("\n\n").filter(Boolean).map((entry) => {
+    const lines = entry.split("\n");
+    const worktreeLine = lines.find((l) => l.startsWith("worktree "));
+    const branchLine = lines.find((l) => l.startsWith("branch refs/heads/"));
+    return {
+      path: worktreeLine ? worktreeLine.slice("worktree ".length) : "",
+      branch: branchLine?.slice("branch refs/heads/".length),
+      locked: lines.some((l) => l === "locked" || l.startsWith("locked "))
+    };
+  }).filter((e) => e.path !== "");
+}
+async function removeRegisteredWorktree(worktreePath) {
+  try {
+    await execFileAsync2("git", ["worktree", "remove", "--force", "--force", worktreePath]);
+  } catch (error) {
+    console.error(`[worktree] Failed to remove worktree ${worktreePath}:`, error);
+  }
+  await forceRemoveIfExists(worktreePath);
+}
+var PROTECTED_BRANCHES = /* @__PURE__ */ new Set(["main", "master", "develop"]);
+async function getDefaultBranchName() {
+  try {
+    const { stdout } = await execFileAsync2("git", ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
+    return stdout.trim().replace(/^origin\//, "");
+  } catch {
+    return void 0;
+  }
+}
+async function deleteLocalBranch(branchName) {
+  const defaultBranch = await getDefaultBranchName();
+  if (PROTECTED_BRANCHES.has(branchName) || branchName === defaultBranch) {
+    console.log(`[worktree] Skipping deletion of protected branch: ${branchName}`);
+    return;
+  }
+  try {
+    await execFileAsync2("git", ["branch", "-D", branchName]);
+    console.log(`[worktree] Deleted local branch: ${branchName}`);
+  } catch (error) {
+    const stderr = String(error?.stderr ?? "");
+    if (/not found/i.test(stderr)) return;
+    console.error(`[worktree] Failed to delete local branch ${branchName}: ${stderr.trim()}`);
+  }
+}
+async function localBranchExists(branchName) {
+  try {
+    await execFileAsync2("git", ["rev-parse", "--verify", "--quiet", `refs/heads/${branchName}`]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getWorktreePath(worktreeId) {
+  return `${WORKTREES_DIR}/${worktreeId}`;
+}
+var worktreeAddQueue = Promise.resolve();
+function createWorktreeFromBranch(worktreeId, baseBranch) {
+  const result = worktreeAddQueue.then(() => addWorktree(worktreeId, baseBranch));
+  worktreeAddQueue = result.catch(() => {
+  });
+  return result;
+}
+async function addWorktree(worktreeId, baseBranch) {
+  const worktreePath = getWorktreePath(worktreeId);
+  await execFileAsync2("git", ["worktree", "add", "--track", "-B", worktreeId, worktreePath, `origin/${baseBranch}`]);
+}
+async function removeWorktree(worktreeId) {
+  const worktreePath = getWorktreePath(worktreeId);
+  let entry;
+  try {
+    entry = (await listWorktreeEntries()).find((e) => resolve4(e.path) === resolve4(worktreePath));
+  } catch (error) {
+    console.error(`[worktree] Failed to list worktrees:`, error);
+  }
+  if (entry) {
+    await removeRegisteredWorktree(worktreePath);
+  } else {
+    await forceRemoveIfExists(worktreePath);
+  }
+  const branches = /* @__PURE__ */ new Set([entry?.branch, worktreeId]);
+  for (const branch of branches) {
+    if (!branch) continue;
+    await deleteLocalBranch(branch);
+  }
+}
+async function removeWorktreeByBranch(branchName) {
+  try {
+    const entries = await listWorktreeEntries();
+    for (const entry of entries) {
+      if (entry.branch !== branchName) continue;
+      if (!isManagedWorktreePath(entry.path)) {
+        console.log(`[worktree] Skipping unmanaged worktree for branch ${branchName}: ${entry.path}`);
+        continue;
+      }
+      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;
+      }
+      if (entry.locked && await pathExists(entry.path)) {
+        console.log(`[worktree] Skipping locked worktree for branch ${branchName}: ${entry.path}`);
+        continue;
+      }
+      await removeRegisteredWorktree(entry.path);
+      console.log(`[worktree] Removed worktree for branch ${branchName}: ${entry.path}`);
+    }
+  } catch (error) {
+    console.error(`[worktree] Failed to remove worktree for branch ${branchName}:`, error);
+  }
+}
+async function removeStaleWorktrees() {
+  const worktreeIds = /* @__PURE__ */ new Set();
+  try {
+    for (const name of await readdir(WORKTREES_DIR)) {
+      if (isGeneratedWorktreeName(name)) worktreeIds.add(name);
+    }
+  } catch {
+  }
+  try {
+    for (const entry of await listWorktreeEntries()) {
+      if (!isManagedWorktreePath(entry.path)) continue;
+      const worktreeId = basename2(entry.path);
+      if (isGeneratedWorktreeName(worktreeId)) worktreeIds.add(worktreeId);
+    }
+  } catch (error) {
+    console.error(`[worktree] Failed to list worktrees:`, error);
+  }
+  for (const worktreeId of worktreeIds) {
+    if (isWorktreeInUse(worktreeId)) continue;
+    console.log(`[worktree] Removing stale worktree: ${worktreeId}`);
+    await removeWorktree(worktreeId);
+  }
+}
+
+// src/workers/worker-definition.ts
+var WORKER_DEFINITION = /* @__PURE__ */ Symbol.for("claude-task-worker.worker-definition");
+function defineWorker(def) {
+  return { [WORKER_DEFINITION]: true, name: def.name, kind: def.kind, start: def.start };
+}
+var KINDS = ["issue", "pr", "scheduled"];
+function isWorkerDefinition(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return v[WORKER_DEFINITION] === true && typeof v.name === "string" && v.name !== "" && typeof v.kind === "string" && KINDS.includes(v.kind) && typeof v.start === "function";
+}
+
+// src/workers/issue-worker.ts
+var STICKY_LABELS = ["cc-triage-scope", "cc-issue-created"];
+var consumableTriggerLabels = (triggerLabels) => triggerLabels.filter((label) => !STICKY_LABELS.includes(label));
+var PREFLIGHT_SEARCH_LIMIT = 5;
+function createIssuePollingWorker(config) {
+  const start = async (opts = {}) => {
+    const epicFilters = opts.epicFilters;
+    const ownNumberFilters = config.epicFilterTarget === "self" ? opts.epicFilters : void 0;
+    const labelFilters = opts.labelFilters;
+    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.epicFilterTarget !== "self" && epicFilters && epicFilters.length > 0 ? { owner, repo: name, numbers: epicFilters } : void 0;
+        const labels = labelFilters && labelFilters.length > 0 ? [...config.triggerLabels, ...labelFilters] : config.triggerLabels;
+        const { maxConcurrentTasks } = getWorkerConfig(config.name);
+        const searchLimit = config.preflight ? PREFLIGHT_SEARCH_LIMIT : maxConcurrentTasks;
+        const candidates = ownNumberFilters && ownNumberFilters.length > 0 ? await listIssuesByNumbers(user, labels, excludeLabels, ownNumberFilters) : await listIssuesByLabel(user, labels, excludeLabels, epicFilter, searchLimit);
+        for (const issue of candidates) {
+          if (isRunning(issue.number)) continue;
+          if (isWorkerAtCapacity(config.name)) break;
+          let blocked = false;
+          try {
+            blocked = await hasOpenBlockers(issue.number);
+          } catch (err) {
+            console.error(`[${config.name}] hasOpenBlockers failed for #${issue.number}: ${err}`);
+          }
+          if (blocked) {
+            console.log(`[${config.name}] #${issue.number}: skipped (blocked by an open issue)`);
+            continue;
+          }
+          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;
+            }
+          }
+          await addLabel("issue", issue.number, "cc-in-progress");
+          const worktreeId = generateWorktreeName();
+          const cloud = isCloudWorker(config.name);
+          try {
+            const issueUrl = `https://github.com/${owner}/${name}/issues/${issue.number}`;
+            syncDefaultBranch(defaultBranch);
+            const { model, effort, skill, advisorModel } = getWorkerConfig(config.name);
+            const command = skill || config.command;
+            const parentNumber = issue.parent?.number;
+            const mode = getRunMode();
+            let baseBranch = defaultBranch;
+            if (parentNumber !== void 0) {
+              baseBranch = `cc-epic-${parentNumber}`;
+              await ensureEpicBranch(baseBranch, defaultBranch);
+            }
+            const execution = buildClaudeExecution({
+              mode,
+              prompt: `${command} ${issue.number}`,
+              model,
+              effort,
+              // config.json の advisor が false なら advisorModel の指定に関わらず渡さない。
+              advisorModel: isAdvisorEnabled() ? advisorModel : "",
+              permissionMode: getPermissionMode(),
+              ...cloud ? { cloud: true, baseRef: baseBranch, remoteEnvId: getRemoteEnvId() ?? "" } : {}
+            });
+            let cwd;
+            if (cloud) {
+              console.log(
+                `[${config.name}] #${issue.number}: cloud execution, running without worktree on ${baseBranch}`
+              );
+            } else {
+              await createWorktreeFromBranch(worktreeId, baseBranch);
+              cwd = getWorktreePath(worktreeId);
+              console.log(`[${config.name}] #${issue.number}: created worktree ${worktreeId} from ${baseBranch}`);
+            }
+            if (cloud) {
+              await removeLabel("issue", issue.number, CLOUD_DONE_LABEL).catch(
+                (err) => console.error(`[${config.name}] removeLabel ${CLOUD_DONE_LABEL} failed for #${issue.number}: ${err}`)
+              );
+            }
+            const startedAt = Date.now();
+            run(
+              execution.command,
+              execution.args,
+              issue.number,
+              issue.title,
+              config.name,
+              cloud ? void 0 : worktreeId,
+              async (status, output, cloudSessionId) => {
+                lastCompletionAt = Date.now();
+                for (const label of consumableTriggerLabels(config.triggerLabels)) {
+                  await removeLabel("issue", issue.number, label).catch(
+                    (err) => console.error(`[${config.name}] removeLabel ${label} failed for #${issue.number}: ${err}`)
+                  );
+                }
+                try {
+                  if (status === "completed") {
+                    const verified = await config.onCompleted?.(issue.number, worktreeId, output, {
+                      cloud,
+                      baseBranch,
+                      startedAt
+                    }) ?? true;
+                    if (verified === false) {
+                      await notifyTaskFailed(
+                        config.name,
+                        name,
+                        issue.number,
+                        issue.title,
+                        issueUrl,
+                        output,
+                        cloud ? { sessionId: cloudSessionId } : void 0
+                      );
+                    } else {
+                      await notifyTaskCompleted(
+                        config.name,
+                        name,
+                        issue.number,
+                        issue.title,
+                        issueUrl,
+                        output,
+                        cloud ? { sessionId: cloudSessionId } : void 0
+                      );
+                    }
+                  } else {
+                    await notifyTaskFailed(
+                      config.name,
+                      name,
+                      issue.number,
+                      issue.title,
+                      issueUrl,
+                      output,
+                      cloud ? { sessionId: cloudSessionId } : void 0
+                    );
+                  }
+                } catch (err) {
+                  console.error(`[${config.name}] post-task error for #${issue.number}: ${err}`);
+                  await notifyTaskFailed(
+                    config.name,
+                    name,
+                    issue.number,
+                    issue.title,
+                    issueUrl,
+                    output,
+                    cloud ? { sessionId: cloudSessionId } : void 0
+                  ).catch(
+                    (notifyErr) => console.error(`[${config.name}] notifyTaskFailed failed for #${issue.number}: ${notifyErr}`)
+                  );
+                } finally {
+                  await removeLabel("issue", issue.number, "cc-in-progress").catch(
+                    (err) => console.error(`[${config.name}] removeLabel cc-in-progress failed for #${issue.number}: ${err}`)
+                  );
+                  if (!cloud) {
+                    await removeWorktree(worktreeId).catch(
+                      (err) => console.error(`[${config.name}] removeWorktree failed for #${issue.number}: ${err}`)
+                    );
+                  }
+                }
+              },
+              cwd,
+              buildClaudeEnv(mode, cloud),
+              execution.prompt,
+              cloud,
+              // クラウドでは cc-cloud-done の探索先、ローカルでは --debug の報告コメントの
+              // 投稿先。どちらも対象は同じ Issue なので実行形態で出し分けない。
+              { type: "issue", number: issue.number },
+              model
+            );
+          } catch (err) {
+            console.error(`[${config.name}] setup error for #${issue.number}: ${err}`);
+            await removeLabel("issue", issue.number, "cc-in-progress").catch(() => {
+            });
+            if (!cloud) {
+              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);
+  };
+  return defineWorker({ name: config.name, kind: "issue", start });
+}
+
+// src/workers/pr-worker.ts
+var LABEL_IN_PROGRESS = "cc-in-progress";
+var LABEL_TRIAGE_SCOPE = "cc-triage-scope";
+function createPrPollingWorker(config) {
+  const start = 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_SCOPE);
+          await addLabel("pr", pr.number, LABEL_IN_PROGRESS);
+          const isCloud = isCloudWorker(config.name);
+          const worktreeId = isCloud ? void 0 : generateWorktreeName();
+          try {
+            if (worktreeId) {
+              await removeWorktreeByBranch(pr.headRefName);
+              await deleteLocalBranch(pr.headRefName);
+              if (await localBranchExists(pr.headRefName)) {
+                console.error(
+                  `[${config.name}] PR #${pr.number}: branch ${pr.headRefName} is still checked out by another worktree; skipping this tick`
+                );
+                await removeLabel("pr", pr.number, LABEL_IN_PROGRESS).catch(() => {
+                });
+                continue;
+              }
+              syncDefaultBranch(defaultBranch);
+              await createWorktreeFromBranch(worktreeId, defaultBranch);
+            }
+            const cwd = worktreeId ? getWorktreePath(worktreeId) : void 0;
+            const { model, effort, skill, advisorModel } = getWorkerConfig(config.name);
+            const command = skill || config.command;
+            const mode = getRunMode();
+            const execution = buildClaudeExecution({
+              mode,
+              prompt: `${command} ${pr.number}`,
+              model,
+              effort,
+              // config.json の advisor が false なら advisorModel の指定に関わらず渡さない。
+              advisorModel: isAdvisorEnabled() ? advisorModel : "",
+              permissionMode: getPermissionMode(),
+              cloud: isCloud,
+              remoteEnvId: isCloud ? getRemoteEnvId() ?? "" : void 0,
+              onBranch: isCloud ? pr.headRefName : void 0
+            });
+            if (isCloud) {
+              await removeLabel("pr", pr.number, CLOUD_DONE_LABEL).catch(
+                (err) => console.error(`[${config.name}] removeLabel ${CLOUD_DONE_LABEL} failed for PR #${pr.number}: ${err}`)
+              );
+            }
+            run(
+              execution.command,
+              execution.args,
+              pr.number,
+              `PR #${pr.number} (${pr.headRefName})`,
+              config.name,
+              worktreeId,
+              async (status, output, cloudSessionId) => {
+                lastCompletionAt = Date.now();
+                try {
+                  if (status === "completed") {
+                    await config.onCompleted?.(pr, output);
+                    await notifyTaskCompleted(
+                      config.name,
+                      name,
+                      pr.number,
+                      pr.title,
+                      prUrl,
+                      output,
+                      isCloud ? { sessionId: cloudSessionId } : void 0
+                    );
+                  } else {
+                    await notifyTaskFailed(
+                      config.name,
+                      name,
+                      pr.number,
+                      pr.title,
+                      prUrl,
+                      output,
+                      isCloud ? { sessionId: cloudSessionId } : void 0
+                    );
+                  }
+                } catch (err) {
+                  console.error(`[${config.name}] post-task error for PR #${pr.number}: ${err}`);
+                } finally {
+                  if (!config.keepTriggerLabel) {
+                    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_SCOPE).catch(
+                      (err) => console.error(
+                        `[${config.name}] addLabel ${LABEL_TRIAGE_SCOPE} 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}`
+                    )
+                  );
+                  if (worktreeId) {
+                    await removeWorktree(worktreeId).catch(
+                      (err) => console.error(`[${config.name}] removeWorktree failed for PR #${pr.number}: ${err}`)
+                    );
+                  }
+                }
+              },
+              cwd,
+              buildClaudeEnv(mode, isCloud),
+              execution.prompt,
+              isCloud,
+              // クラウドでは cc-cloud-done の探索先、ローカルでは --debug の報告コメントの
+              // 投稿先。onBranch は `--on-branch` を渡したか（＝クラウドのみ）を表す。
+              { type: "pr", number: pr.number, onBranch: isCloud },
+              model
+            );
+          } catch (err) {
+            console.error(`[${config.name}] setup error for PR #${pr.number}: ${err}`);
+            await removeLabel("pr", pr.number, LABEL_IN_PROGRESS).catch(() => {
+            });
+            if (worktreeId) {
+              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);
+  };
+  return defineWorker({ name: config.name, kind: "pr", start });
+}
+
+// src/last-run-pr.ts
+import { createRequire as createRequire3 } from "node:module";
+import { promisify as promisify4 } from "node:util";
+var childProcess3 = createRequire3(import.meta.url)("node:child_process");
+var execFileAsync3 = (command, args) => promisify4(childProcess3.execFile)(command, args);
+var CONFIG_FILE = "claude-task-worker.json";
+var LABEL_TRIAGE_SCOPE2 = "cc-triage-scope";
+function lastRunBranchName(workerName) {
+  return `ctw-last-run-${workerName}`;
+}
+function hasLastRunChange(porcelain) {
+  return porcelain.trim().length > 0;
+}
+function lastRunPrTitle(workerName) {
+  return `chore: ${workerName} \u306E\u5B9F\u884C\u8A18\u9332\u3092\u66F4\u65B0`;
+}
+function lastRunPrBody(workerName, at) {
+  return [
+    `\`claude-task-worker\` \u306E \`${workerName}\` \u30EF\u30FC\u30AB\u30FC\u304C\u3001\u5B9A\u671F\u5B9F\u884C\u306E\u8A18\u9332\uFF08\`lastRun.${workerName}\`\uFF09\u3092\u66F4\u65B0\u3057\u307E\u3057\u305F\u3002`,
+    "",
+    `- \u5B9F\u884C\u6642\u523B: ${at.toISOString()}`,
+    "",
+    `\u3053\u306EPR\u306F\u5B9F\u884C\u8A18\u9332\u306E\u307F\u3092\u66F4\u65B0\u3057\u307E\u3059\uFF08\u6210\u679C\u7269\u306E\u5909\u66F4\u306F\u540C\u30EF\u30FC\u30AB\u30FC\u304C\u8D77\u52D5\u3057\u305F\u30B9\u30AD\u30EB\u304C\u5225PR\u3067\u51FA\u3057\u307E\u3059\uFF09\u3002`,
+    `\u30DE\u30FC\u30B8\u306F \`triage-pr\` \u30EF\u30FC\u30AB\u30FC\u304C\u884C\u3044\u307E\u3059\u3002`
+  ].join("\n");
+}
+async function git(cwd, args) {
+  const { stdout } = await execFileAsync3("git", ["-C", cwd, ...args]);
+  return stdout;
+}
+async function publishLastRunPr(workerName, defaultBranch, at) {
+  const branch = lastRunBranchName(workerName);
+  const cwd = getWorktreePath(branch);
+  try {
+    await createWorktreeFromBranch(branch, defaultBranch);
+    writeLastRun(cwd, workerName, at);
+    if (!hasLastRunChange(await git(cwd, ["status", "--porcelain", CONFIG_FILE]))) {
+      console.log(`[${workerName}] lastRun unchanged, skipping PR`);
+      return null;
+    }
+    await git(cwd, ["add", CONFIG_FILE]);
+    await git(cwd, ["commit", "-m", lastRunPrTitle(workerName)]);
+    await git(cwd, ["push", "--force", "origin", `HEAD:refs/heads/${branch}`]);
+    const existing = await findOpenPrNumberByHeadRef(branch);
+    const prNumber = existing ?? await createPullRequest(defaultBranch, branch, lastRunPrTitle(workerName), lastRunPrBody(workerName, at));
+    console.log(`[${workerName}] ${existing !== null ? "updated" : "opened"} lastRun PR #${prNumber}`);
+    await addLabel("pr", prNumber, LABEL_TRIAGE_SCOPE2).catch(
+      (err) => console.error(`[${workerName}] addLabel ${LABEL_TRIAGE_SCOPE2} failed for PR #${prNumber}: ${err}`)
+    );
+    await addAssignee("pr", prNumber, await getCurrentUser()).catch(
+      (err) => console.error(`[${workerName}] addAssignee failed for PR #${prNumber}: ${err}`)
+    );
+    return prNumber;
+  } finally {
+    await removeWorktree(branch).catch((err) => console.error(`[${workerName}] removeWorktree failed: ${err}`));
+  }
+}
+
+// src/workers/scheduled-worker.ts
+var SCHEDULE_INTERVAL_HOURS = 24;
+var SCHEDULE_INTERVAL_MS = SCHEDULE_INTERVAL_HOURS * 60 * 60 * 1e3;
+var SCOPE_DAYS = SCHEDULE_INTERVAL_HOURS / 24;
+var nextTaskId = -1;
+var LABEL_IN_PROGRESS2 = "cc-in-progress";
+function createScheduledWorker(config) {
+  const taskId = nextTaskId--;
+  const start = async () => {
+    const { owner, name: repoName, defaultBranch } = await getRepoInfo();
+    const { pollingIntervalSeconds } = getWorkerConfig(config.name);
+    console.log(
+      `[${config.name}] Checking every ${pollingIntervalSeconds} seconds (runs at most once per ${SCHEDULE_INTERVAL_HOURS}h for ${owner}/${repoName})`
+    );
+    let startedAt = 0;
+    const tick = async () => {
+      if (isShuttingDown()) return;
+      if (config.enabled && !config.enabled()) return;
+      if (isRunning(taskId)) return;
+      const now = Date.now();
+      const lastRunAt = Math.max(getLastRunAt(config.name) ?? 0, startedAt);
+      if (lastRunAt > 0 && now - lastRunAt < SCHEDULE_INTERVAL_MS) return;
+      const worktreeId = generateWorktreeName();
+      startedAt = now;
+      let cloud = false;
+      try {
+        syncDefaultBranch(defaultBranch);
+        const { model, effort, skill, advisorModel } = getWorkerConfig(config.name);
+        cloud = isCloudWorker(config.name);
+        const command = skill || config.command;
+        const mode = getRunMode();
+        const execution = buildClaudeExecution({
+          mode,
+          prompt: `${command} ${SCOPE_DAYS}`,
+          model,
+          effort,
+          advisorModel: isAdvisorEnabled() ? advisorModel : "",
+          permissionMode: getPermissionMode(),
+          ...cloud ? { cloud: true, baseRef: defaultBranch, remoteEnvId: getRemoteEnvId() ?? "" } : {}
+        });
+        const lastRunPr = await publishLastRunPr(config.name, defaultBranch, new Date(now)).catch((err) => {
+          console.error(`[${config.name}] publishLastRunPr failed: ${err}`);
+          return null;
+        });
+        if (cloud && lastRunPr === null) {
+          console.warn(
+            `[${config.name}] no lastRun PR to carry the cc-cloud-done label; the cloud session will be reported as completed as soon as it is created`
+          );
+        }
+        if (cloud && lastRunPr !== null) {
+          await removeLabel("pr", lastRunPr, CLOUD_DONE_LABEL).catch(
+            (err) => console.error(`[${config.name}] removeLabel ${CLOUD_DONE_LABEL} failed for PR #${lastRunPr}: ${err}`)
+          );
+          await addLabel("pr", lastRunPr, LABEL_IN_PROGRESS2).catch(
+            (err) => console.error(`[${config.name}] addLabel ${LABEL_IN_PROGRESS2} failed for PR #${lastRunPr}: ${err}`)
+          );
+        }
+        let cwd;
+        if (cloud) {
+          console.log(`[${config.name}] cloud execution, running without worktree on ${defaultBranch}`);
+        } else {
+          await createWorktreeFromBranch(worktreeId, defaultBranch);
+          cwd = getWorktreePath(worktreeId);
+          console.log(`[${config.name}] created worktree ${worktreeId} from ${defaultBranch}`);
+        }
+        const repoUrl = `https://github.com/${owner}/${repoName}`;
+        run(
+          execution.command,
+          execution.args,
+          taskId,
+          config.name,
+          config.name,
+          cloud ? void 0 : worktreeId,
+          async (status, output) => {
+            try {
+              if (status === "completed") {
+                await notifyTaskCompleted(config.name, repoName, taskId, config.name, repoUrl, output);
+              } else {
+                await notifyTaskFailed(config.name, repoName, taskId, config.name, repoUrl, output);
+              }
+            } catch (err) {
+              console.error(`[${config.name}] post-task error: ${err}`);
+            } finally {
+              if (cloud && lastRunPr !== null) {
+                await removeLabel("pr", lastRunPr, LABEL_IN_PROGRESS2).catch(
+                  (err) => console.error(
+                    `[${config.name}] removeLabel ${LABEL_IN_PROGRESS2} failed for PR #${lastRunPr}: ${err}`
+                  )
+                );
+              }
+              if (!cloud) {
+                await removeWorktree(worktreeId).catch(
+                  (err) => console.error(`[${config.name}] removeWorktree failed: ${err}`)
+                );
+              }
+            }
+          },
+          cwd,
+          buildClaudeEnv(mode, cloud),
+          execution.prompt,
+          cloud,
+          // 定期ワーカーは Issue/PR を起点に走らないため、クラウドの cc-cloud-done も
+          // ローカル --debug の報告コメントも実行記録PRを置き先にする。
+          lastRunPr !== null ? { type: "pr", number: lastRunPr } : void 0,
+          model
+        );
+      } catch (err) {
+        console.error(`[${config.name}] setup error: ${err}`);
+        if (!cloud) {
+          await removeWorktree(worktreeId).catch(() => {
+          });
+        }
+        await notifyError(config.name, repoName, err);
+      }
+    };
+    await tick();
+    setInterval(tick, pollingIntervalSeconds * 1e3);
+  };
+  return defineWorker({ name: config.name, kind: "scheduled", start });
+}
+
+export {
+  getCurrentUser,
+  getRepoInfo,
+  listIssuesByLabel,
+  listIssuesByNumbers,
+  findOpenPrNumberByHeadRef,
+  findPrNumberByHeadRef,
+  findPrStateByHeadRef,
+  getPrMergeable,
+  getIssueBody,
+  getIssueState,
+  listPrsClosingIssue,
+  getPrDetail,
+  closeIssue,
+  parseClosingIssueNumbers,
+  listPrsCrossReferencingIssue,
+  linkClosingPr,
+  getIssueSubIssuesSummary,
+  listPullRequestsWithChecks,
+  addLabel,
+  addAssignee,
+  hasLabel,
+  hasOpenBlockers,
+  removeLabel,
+  commentOnPR,
+  commentOnIssue,
+  createLabel,
+  parseProjectFilters,
+  hasProjectFilter,
+  assertProjectCompatibleCommand,
+  hasCloudFlag,
+  INHERIT_CONFIG_FLAG,
+  getInheritConfigPath,
+  assertCloudCompatibleCommand,
+  buildForwardedCommand,
+  DEFAULT_UI_DESIGN_CONFIG,
+  SCHEDULED_WORKER_NAMES,
+  CLOUD_DONE_LABEL,
+  isCloudWorker,
+  checkCloudConfig,
+  DEFAULT_CONFIG,
+  CONFIG_PATH,
+  LOCAL_CONFIG_PATH,
+  resolveWorkerFilePath,
+  loadConfig,
+  getWorkerConfig,
+  isWorkerEnabled,
+  partitionEnabledWorkers,
+  disabledWorkerMessage,
+  getLastRunAt,
+  writeLastRun,
+  getRemoteEnvId,
+  getUiDesignConfig,
+  UserConfigError,
+  loadUserConfig,
+  getRunMode,
+  isAdvisorEnabled,
+  getPermissionMode,
+  resolveTargetProjects,
+  buildScriptCommand,
+  buildClaudeExecution,
+  buildClaudeEnv,
+  syncDefaultBranch,
+  ensureEpicBranch,
+  setShuttingDown,
+  isShuttingDown,
+  isRunning,
+  isWorkerAtCapacity,
+  renderTable,
+  ensureRenderInterval,
+  run,
+  waitForAllProcesses,
+  shutdown,
+  generateWorktreeName,
+  send,
+  buildTokenLimitText,
+  notifyTaskCompleted,
+  notifyTaskFailed,
+  notifyError,
+  deleteLocalBranch,
+  localBranchExists,
+  getWorktreePath,
+  createWorktreeFromBranch,
+  removeWorktree,
+  removeWorktreeByBranch,
+  removeStaleWorktrees,
+  defineWorker,
+  isWorkerDefinition,
+  createIssuePollingWorker,
+  createPrPollingWorker,
+  publishLastRunPr,
+  createScheduledWorker
+};