claude-task-worker 0.115.0 → 0.117.0

package/dist/dispatcher-JKUMXTJ2.js

@@ -0,0 +1,410 @@
+// src/dispatcher.ts
+async function loadHerdr() {
+  return await import("./herdr-NDLUM6JF.js");
+}
+async function loadTable() {
+  return await import("./table-DWVMNDS3.js");
+}
+var { getDisplayWidth, truncateToWidth, padToWidth, buildLogTableLines, logLines, writeScreen } = await loadTable();
+var POLL_INTERVAL_MS = 7 * 1e3;
+var SHUTDOWN_TIMEOUT_MS = 10 * 60 * 1e3;
+var PANE_READY_TIMEOUT_MS = 30 * 1e3;
+var PANE_READY_POLL_INTERVAL_MS = 200;
+var WORKER_STARTUP_TIMEOUT_MS = 30 * 1e3;
+var WORKER_STARTUP_POLL_INTERVAL_MS = 500;
+var SEND_MAX_ATTEMPTS = 3;
+var LABEL_PREFIX = "ctw:";
+function workspaceLabelFor(projectName) {
+  return `${LABEL_PREFIX}${projectName}`;
+}
+async function focusedWorkspaceId(herdr) {
+  try {
+    const workspaces = await herdr.workspaceList();
+    return workspaces.find((workspace) => workspace.focused)?.workspaceId;
+  } catch (error) {
+    console.error(`[dispatcher] failed to read the focused workspace: ${error}`);
+    return void 0;
+  }
+}
+async function restoreWorkspaceFocus(herdr, previousWorkspaceId, closingWorkspaceIds) {
+  if (!previousWorkspaceId || closingWorkspaceIds.has(previousWorkspaceId)) return;
+  const currentWorkspaceId = await focusedWorkspaceId(herdr);
+  if (currentWorkspaceId === previousWorkspaceId) return;
+  try {
+    await herdr.workspaceFocus(previousWorkspaceId);
+  } catch (error) {
+    console.error(`[dispatcher] failed to restore focus to workspace "${previousWorkspaceId}": ${error}`);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isWorkerProcess(process2) {
+  return process2.cmdline?.includes("claude-task-worker") ?? false;
+}
+var SHELL_NAME_PATTERN = /^-?(zsh|bash|sh)$/;
+function isShellProcess(process2) {
+  return SHELL_NAME_PATTERN.test(process2.name ?? "") || SHELL_NAME_PATTERN.test(process2.cmdline ?? "");
+}
+async function waitForPaneReady(paneId, herdr, options) {
+  const timeoutMs = options?.timeoutMs ?? PANE_READY_TIMEOUT_MS;
+  const pollIntervalMs = options?.pollIntervalMs ?? PANE_READY_POLL_INTERVAL_MS;
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    const content = await herdr.paneRead(paneId, { source: "visible" });
+    if (content.trim() !== "") return true;
+    if (Date.now() >= deadline) return false;
+    await sleep(pollIntervalMs);
+  }
+}
+async function waitForWorkerStartup(paneId, herdr, options) {
+  const timeoutMs = options?.timeoutMs ?? WORKER_STARTUP_TIMEOUT_MS;
+  const pollIntervalMs = options?.pollIntervalMs ?? WORKER_STARTUP_POLL_INTERVAL_MS;
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    const { foregroundProcesses } = await herdr.paneProcessInfo(paneId);
+    if (foregroundProcesses.some(isWorkerProcess)) return "started";
+    if (foregroundProcesses.length > 0 && !foregroundProcesses.every(isShellProcess)) return "other";
+    if (Date.now() >= deadline) return "shell";
+    await sleep(pollIntervalMs);
+  }
+}
+async function startWorkerInPane(paneId, forwardedCommand, herdr, options) {
+  const maxAttempts = options?.sendMaxAttempts ?? SEND_MAX_ATTEMPTS;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const ready = await waitForPaneReady(paneId, herdr, {
+      timeoutMs: options?.paneReadyTimeoutMs,
+      pollIntervalMs: options?.paneReadyPollIntervalMs
+    });
+    if (!ready) {
+      console.warn(`[dispatcher] pane ${paneId} produced no prompt before the timeout, sending the command anyway`);
+    }
+    await herdr.paneSendText(paneId, forwardedCommand);
+    await herdr.paneSendKeys(paneId, "enter");
+    const result = await waitForWorkerStartup(paneId, herdr, {
+      timeoutMs: options?.workerStartupTimeoutMs,
+      pollIntervalMs: options?.workerStartupPollIntervalMs
+    });
+    if (result === "started") return true;
+    if (result === "other") {
+      console.warn(
+        `[dispatcher] pane ${paneId} foreground is neither the shell nor the worker, giving up without resending`
+      );
+      return false;
+    }
+    if (attempt < maxAttempts) {
+      console.warn(
+        `[dispatcher] worker did not start in pane ${paneId} (attempt ${attempt}/${maxAttempts}), resending the command`
+      );
+    }
+  }
+  return false;
+}
+async function runDispatcher(projects, forwardedCommand, timing) {
+  const herdr = await loadHerdr();
+  const { checkHerdrAvailable, workspaceCreate, workspaceClose, workspaceList, tabRename } = herdr;
+  try {
+    await checkHerdrAvailable();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[dispatcher] ${message}`);
+    throw error;
+  }
+  const existingWorkspaces = await workspaceList();
+  const existingLabels = new Set(existingWorkspaces.map((workspace) => workspace.label));
+  const sessions = /* @__PURE__ */ new Map();
+  for (const project of projects) {
+    const label = workspaceLabelFor(project.name);
+    if (existingLabels.has(label)) {
+      console.warn(`[dispatcher] project "${project.name}" already has a running workspace, skipping`);
+      continue;
+    }
+    let createdWorkspaceId;
+    try {
+      const { workspaceId, tabId, paneId } = await workspaceCreate({
+        label,
+        cwd: project.path,
+        env: { CTW_PROJECT_NAME: project.name }
+      });
+      createdWorkspaceId = workspaceId;
+      await tabRename(tabId, label).catch(
+        (error) => console.error(`[dispatcher] failed to rename the root tab for project "${project.name}": ${error}`)
+      );
+      sessions.set(project.name, {
+        name: project.name,
+        workspaceId,
+        tabId,
+        paneId,
+        startedAt: /* @__PURE__ */ new Date(),
+        status: "running"
+      });
+      const started = await startWorkerInPane(paneId, forwardedCommand, herdr, timing);
+      if (!started) {
+        throw new Error(
+          `worker did not start in pane ${paneId} after ${timing?.sendMaxAttempts ?? SEND_MAX_ATTEMPTS} attempt(s)`
+        );
+      }
+    } catch (error) {
+      console.error(`[dispatcher] failed to dispatch project "${project.name}": ${error}`);
+      sessions.delete(project.name);
+      if (createdWorkspaceId !== void 0) {
+        const focusedBefore = await focusedWorkspaceId(herdr);
+        try {
+          await workspaceClose(createdWorkspaceId);
+        } catch (closeError) {
+          console.error(`[dispatcher] failed to close dangling workspace for project "${project.name}": ${closeError}`);
+        }
+        await restoreWorkspaceFocus(herdr, focusedBefore, /* @__PURE__ */ new Set([createdWorkspaceId]));
+      }
+    }
+  }
+  return sessions;
+}
+async function removeSession(sessions, name, { closeWorkspace }, herdrModule) {
+  const session = sessions.get(name);
+  if (!session) return;
+  sessions.delete(name);
+  if (closeWorkspace) {
+    const herdr = herdrModule ?? await loadHerdr();
+    const focusedBefore = await focusedWorkspaceId(herdr);
+    await herdr.workspaceClose(session.workspaceId);
+    await restoreWorkspaceFocus(herdr, focusedBefore, /* @__PURE__ */ new Set([session.workspaceId]));
+  }
+}
+async function pollOnce(sessions, herdr) {
+  for (const [name, session] of [...sessions.entries()]) {
+    try {
+      const { foregroundProcesses } = await herdr.paneProcessInfo(session.paneId);
+      if (!foregroundProcesses.some(isWorkerProcess)) {
+        await removeSession(sessions, name, { closeWorkspace: true }, herdr);
+      }
+    } catch (error) {
+      if (error instanceof herdr.HerdrError && error.code === "pane_not_found") {
+        await removeSession(sessions, name, { closeWorkspace: false }, herdr);
+        continue;
+      }
+      console.error(`[dispatcher] failed to poll session "${name}": ${error}`);
+    }
+  }
+}
+function formatUptime(start, now) {
+  const totalSeconds = Math.max(0, Math.floor((now.getTime() - start.getTime()) / 1e3));
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
+}
+function renderSessionTable(sessions) {
+  const entries = [...sessions.values()];
+  const logTableLines = buildLogTableLines(logLines);
+  if (entries.length === 0) {
+    if (logTableLines.length > 0) writeScreen(["Logs", ...logTableLines]);
+    return;
+  }
+  const maxProjectWidth = 20;
+  const rows = entries.map((session) => ({
+    project: getDisplayWidth(session.name) > maxProjectWidth ? truncateToWidth(session.name, maxProjectWidth) : session.name,
+    workspace: session.workspaceId,
+    pane: session.paneId,
+    status: session.status,
+    uptime: formatUptime(session.startedAt, /* @__PURE__ */ new Date())
+  }));
+  const colWidths = {
+    project: Math.max(7, ...rows.map((r) => getDisplayWidth(r.project))),
+    workspace: Math.max(9, ...rows.map((r) => r.workspace.length)),
+    pane: Math.max(4, ...rows.map((r) => r.pane.length)),
+    status: Math.max(6, ...rows.map((r) => r.status.length)),
+    uptime: Math.max(6, ...rows.map((r) => r.uptime.length))
+  };
+  const cols = [colWidths.project, colWidths.workspace, colWidths.pane, colWidths.status, colWidths.uptime];
+  const line = (l, m, r, f) => `${l}${cols.map((w) => f.repeat(w + 2)).join(m)}${r}`;
+  const row = (project, workspace, pane, status, uptime) => `\u2502 ${padToWidth(project, colWidths.project)} \u2502 ${workspace.padEnd(colWidths.workspace)} \u2502 ${pane.padEnd(colWidths.pane)} \u2502 ${status.padEnd(colWidths.status)} \u2502 ${uptime.padEnd(colWidths.uptime)} \u2502`;
+  const lines = [];
+  lines.push(line("\u250C", "\u252C", "\u2510", "\u2500"));
+  lines.push(row("Project", "Workspace", "Pane", "Status", "Uptime"));
+  lines.push(line("\u251C", "\u253C", "\u2524", "\u2500"));
+  for (const r of rows) {
+    lines.push(row(r.project, r.workspace, r.pane, r.status, r.uptime));
+  }
+  lines.push(line("\u2514", "\u2534", "\u2518", "\u2500"));
+  if (logTableLines.length > 0) lines.push("", "Logs", ...logTableLines);
+  writeScreen(lines);
+}
+function monitorSessions(sessions, herdr, options) {
+  const pollIntervalMs = options?.pollIntervalMs ?? POLL_INTERVAL_MS;
+  const renderIntervalMs = options?.renderIntervalMs ?? 1e3;
+  let resolveDone;
+  const done = new Promise((resolve) => {
+    resolveDone = resolve;
+  });
+  let settled = false;
+  const finish = () => {
+    if (settled) return;
+    settled = true;
+    clearInterval(pollInterval);
+    clearInterval(renderInterval);
+    resolveDone();
+  };
+  const pollInterval = setInterval(() => {
+    void pollOnce(sessions, herdr).then(() => {
+      if (sessions.size === 0) {
+        finish();
+      }
+    });
+  }, pollIntervalMs);
+  const renderInterval = setInterval(() => {
+    renderSessionTable(sessions);
+  }, renderIntervalMs);
+  return {
+    stop: finish,
+    done
+  };
+}
+var SHUTDOWN_RETRY_TIMEOUT_MS = 90 * 1e3;
+var CTRL_C_KEY = "ctrl+c";
+async function sendCtrlCToAllSessions(sessions, herdr) {
+  await Promise.all(
+    [...sessions.values()].map(async (session) => {
+      try {
+        await herdr.paneSendKeys(session.paneId, CTRL_C_KEY);
+      } catch (error) {
+        console.error(`[dispatcher] failed to send ctrl-c to session "${session.name}": ${error}`);
+      }
+    })
+  );
+}
+async function waitUntilSessionsEmpty(sessions, herdr, pollIntervalMs, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (sessions.size > 0) {
+    await pollOnce(sessions, herdr);
+    if (sessions.size === 0) return true;
+    if (Date.now() >= deadline) return false;
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+  return true;
+}
+async function closeRemainingWorkspaces(sessions, herdr, timeoutMs) {
+  const closingWorkspaceIds = new Set([...sessions.values()].map((session) => session.workspaceId));
+  const focusedBefore = await focusedWorkspaceId(herdr);
+  const results = await Promise.all(
+    [...sessions.values()].map(async (session) => {
+      try {
+        await Promise.race([
+          herdr.workspaceClose(session.workspaceId),
+          new Promise((_, reject) => {
+            setTimeout(() => reject(new Error("workspaceClose timed out")), timeoutMs).unref();
+          })
+        ]);
+        return true;
+      } catch (error) {
+        console.error(
+          `[dispatcher] failed to close workspace "${session.workspaceId}" for session "${session.name}" during shutdown: ${error}`
+        );
+        return false;
+      }
+    })
+  );
+  await restoreWorkspaceFocus(herdr, focusedBefore, closingWorkspaceIds);
+  return results.every((closed) => closed);
+}
+var shutdownPromise;
+async function forceKillAllSessions(sessions, herdr, workspaceCloseTimeoutMs) {
+  console.log(`[dispatcher] force-kill requested, sending ctrl-c and closing ${sessions.size} session(s) immediately`);
+  await sendCtrlCToAllSessions(sessions, herdr);
+  await closeRemainingWorkspaces(sessions, herdr, workspaceCloseTimeoutMs);
+  process.exit(1);
+}
+async function shutdownDispatcher(sessions, monitorHandle, options) {
+  if (shutdownPromise) {
+    if (options?.forceKill) {
+      const herdr = options.herdr ?? await loadHerdr();
+      const workspaceCloseTimeoutMs = options.workspaceCloseTimeoutMs ?? 5e3;
+      await forceKillAllSessions(sessions, herdr, workspaceCloseTimeoutMs);
+      return;
+    }
+    console.log("[dispatcher] shutdown already in progress, ignoring duplicate request");
+    return shutdownPromise;
+  }
+  shutdownPromise = (async () => {
+    const herdr = options?.herdr ?? await loadHerdr();
+    const pollIntervalMs = options?.pollIntervalMs ?? POLL_INTERVAL_MS;
+    const shutdownTimeoutMs = options?.shutdownTimeoutMs ?? SHUTDOWN_TIMEOUT_MS;
+    const retryTimeoutMs = options?.retryTimeoutMs ?? SHUTDOWN_RETRY_TIMEOUT_MS;
+    const workspaceCloseTimeoutMs = options?.workspaceCloseTimeoutMs ?? 5e3;
+    if (monitorHandle) {
+      monitorHandle.stop();
+      await monitorHandle.done;
+    }
+    console.log(`[dispatcher] shutting down, sending ctrl-c to ${sessions.size} session(s)`);
+    await sendCtrlCToAllSessions(sessions, herdr);
+    let finishedInTime = await waitUntilSessionsEmpty(sessions, herdr, pollIntervalMs, shutdownTimeoutMs);
+    if (!finishedInTime) {
+      console.log(
+        `[dispatcher] ${sessions.size} session(s) still alive after ${shutdownTimeoutMs}ms, resending ctrl-c once`
+      );
+      await sendCtrlCToAllSessions(sessions, herdr);
+      finishedInTime = await waitUntilSessionsEmpty(sessions, herdr, pollIntervalMs, retryTimeoutMs);
+    }
+    const allWorkspacesClosed = await closeRemainingWorkspaces(sessions, herdr, workspaceCloseTimeoutMs);
+    process.exit(finishedInTime && allWorkspacesClosed ? 0 : 1);
+  })();
+  try {
+    await shutdownPromise;
+  } finally {
+    shutdownPromise = void 0;
+  }
+}
+function createDispatcherShutdownHandler(shutdown) {
+  let shuttingDown = false;
+  let forceKilling = false;
+  const handle = async () => {
+    if (shuttingDown) {
+      if (forceKilling) return;
+      forceKilling = true;
+      console.log("\n[dispatcher] Force killing sessions immediately...");
+      try {
+        await shutdown({ forceKill: true });
+      } catch (error) {
+        console.error(`[dispatcher] force-kill shutdown failed: ${error}`);
+        process.exit(1);
+      }
+      return;
+    }
+    shuttingDown = true;
+    console.log("\n[dispatcher] Stopping sessions. Waiting for them to finish... (Press Ctrl-C again to force kill)");
+    try {
+      await shutdown();
+    } catch (error) {
+      console.error(`[dispatcher] shutdown failed: ${error}`);
+      process.exit(1);
+    }
+  };
+  return { handle, isShuttingDown: () => shuttingDown };
+}
+export {
+  LABEL_PREFIX,
+  PANE_READY_POLL_INTERVAL_MS,
+  PANE_READY_TIMEOUT_MS,
+  POLL_INTERVAL_MS,
+  SEND_MAX_ATTEMPTS,
+  SHUTDOWN_RETRY_TIMEOUT_MS,
+  SHUTDOWN_TIMEOUT_MS,
+  WORKER_STARTUP_POLL_INTERVAL_MS,
+  WORKER_STARTUP_TIMEOUT_MS,
+  createDispatcherShutdownHandler,
+  focusedWorkspaceId,
+  formatUptime,
+  isShellProcess,
+  isWorkerProcess,
+  monitorSessions,
+  pollOnce,
+  removeSession,
+  renderSessionTable,
+  restoreWorkspaceFocus,
+  runDispatcher,
+  shutdownDispatcher,
+  startWorkerInPane,
+  waitForPaneReady,
+  waitForWorkerStartup,
+  workspaceLabelFor
+};

package/dist/dispatcher.d.ts

@@ -0,0 +1,77 @@
+import type * as HerdrModule from "./herdr";
+import type { ResolvedProject } from "./user-config";
+export declare const POLL_INTERVAL_MS: number;
+export declare const SHUTDOWN_TIMEOUT_MS: number;
+export declare const PANE_READY_TIMEOUT_MS: number;
+export declare const PANE_READY_POLL_INTERVAL_MS = 200;
+export declare const WORKER_STARTUP_TIMEOUT_MS: number;
+export declare const WORKER_STARTUP_POLL_INTERVAL_MS = 500;
+export declare const SEND_MAX_ATTEMPTS = 3;
+export declare const LABEL_PREFIX = "ctw:";
+export declare function workspaceLabelFor(projectName: string): string;
+export declare function focusedWorkspaceId(herdr: typeof HerdrModule): Promise<string | undefined>;
+export declare function restoreWorkspaceFocus(herdr: typeof HerdrModule, previousWorkspaceId: string | undefined, closingWorkspaceIds: Set<string>): Promise<void>;
+export type WorkerSessionStatus = "running";
+export interface WorkerSession {
+    name: string;
+    workspaceId: string;
+    tabId: string;
+    paneId: string;
+    startedAt: Date;
+    status: WorkerSessionStatus;
+}
+export type SessionRegistry = Map<string, WorkerSession>;
+export interface DispatchTimingOptions {
+    paneReadyTimeoutMs?: number;
+    paneReadyPollIntervalMs?: number;
+    workerStartupTimeoutMs?: number;
+    workerStartupPollIntervalMs?: number;
+    sendMaxAttempts?: number;
+}
+export declare function isWorkerProcess(process: {
+    cmdline?: string;
+}): boolean;
+export declare function isShellProcess(process: {
+    name?: string;
+    cmdline?: string;
+}): boolean;
+export declare function waitForPaneReady(paneId: string, herdr: typeof HerdrModule, options?: {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+}): Promise<boolean>;
+export type WorkerStartupResult = "started" | "shell" | "other";
+export declare function waitForWorkerStartup(paneId: string, herdr: typeof HerdrModule, options?: {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+}): Promise<WorkerStartupResult>;
+export declare function startWorkerInPane(paneId: string, forwardedCommand: string, herdr: typeof HerdrModule, options?: DispatchTimingOptions): Promise<boolean>;
+export declare function runDispatcher(projects: ResolvedProject[], forwardedCommand: string, timing?: DispatchTimingOptions): Promise<SessionRegistry>;
+export interface MonitorHandle {
+    stop(): void;
+    done: Promise<void>;
+}
+export declare function removeSession(sessions: SessionRegistry, name: string, { closeWorkspace }: {
+    closeWorkspace: boolean;
+}, herdrModule?: typeof HerdrModule): Promise<void>;
+export declare function pollOnce(sessions: SessionRegistry, herdr: typeof HerdrModule): Promise<void>;
+export declare function formatUptime(start: Date, now: Date): string;
+export declare function renderSessionTable(sessions: SessionRegistry): void;
+export declare function monitorSessions(sessions: SessionRegistry, herdr: typeof HerdrModule, options?: {
+    pollIntervalMs?: number;
+    renderIntervalMs?: number;
+}): MonitorHandle;
+export declare const SHUTDOWN_RETRY_TIMEOUT_MS: number;
+export interface ShutdownOptions {
+    herdr?: typeof HerdrModule;
+    pollIntervalMs?: number;
+    shutdownTimeoutMs?: number;
+    retryTimeoutMs?: number;
+    workspaceCloseTimeoutMs?: number;
+    forceKill?: boolean;
+}
+export declare function shutdownDispatcher(sessions: SessionRegistry, monitorHandle?: MonitorHandle, options?: ShutdownOptions): Promise<void>;
+export interface DispatcherShutdownController {
+    handle: () => Promise<void>;
+    isShuttingDown: () => boolean;
+}
+export declare function createDispatcherShutdownHandler(shutdown: (options?: ShutdownOptions) => Promise<void>): DispatcherShutdownController;

package/dist/gh.d.ts

@@ -0,0 +1,112 @@
+export interface Issue {
+    number: number;
+    title: string;
+    labels: {
+        name: string;
+    }[];
+    parent: {
+        number: number;
+    } | null;
+}
+export interface SubIssuesSummary {
+    total: number;
+    completed: number;
+    percentCompleted: number;
+}
+interface PullRequest {
+    number: number;
+    headRefName: string;
+    labels: {
+        name: string;
+    }[];
+    title: string;
+}
+interface RepoInfo {
+    owner: string;
+    name: string;
+    defaultBranch: string;
+}
+export declare function getCurrentUser(): Promise<string>;
+export declare function getRepoInfo(): Promise<RepoInfo>;
+export declare function listIssuesByLabel(assignee: string, labels: string[], excludeLabels?: string[], epicFilter?: {
+    owner: string;
+    repo: string;
+    numbers: number[];
+}, limit?: number): Promise<Issue[]>;
+export declare function listIssuesByNumbers(assignee: string, labels: string[], excludeLabels: string[], numbers: number[]): Promise<Issue[]>;
+export declare function findOpenPrNumberByHeadRef(headRefName: string): Promise<number | null>;
+export declare function findPrNumberByHeadRef(headRefName: string, state?: "open" | "all"): Promise<number | null>;
+export interface PullRequestStateInfo {
+    number: number;
+    state: string;
+    mergedAt: string | null;
+}
+export declare function findPrStateByHeadRef(headRefName: string): Promise<PullRequestStateInfo | null>;
+export declare function getPrMergeable(prNumber: number): Promise<string>;
+export declare function getIssueBody(issueNumber: number): Promise<string>;
+export declare function getIssueState(issueNumber: number): Promise<string>;
+export interface ClosingPrRef {
+    number: number;
+    state: string;
+    headRefName: string;
+    baseRefName: string;
+    createdAt: string;
+}
+export declare function listPrsClosingIssue(issueNumber: number): Promise<ClosingPrRef[]>;
+export declare function getPrDetail(prNumber: number): Promise<(ClosingPrRef & {
+    body: string;
+}) | null>;
+export declare function closeIssue(issueNumber: number, reason?: "completed" | "not_planned"): Promise<void>;
+export declare function parseClosingIssueNumbers(body: string): number[];
+export declare function bodyClosesIssue(body: string, issueNumber: number): boolean;
+export declare function listPrsCrossReferencingIssue(issueNumber: number): Promise<ClosingPrRef[]>;
+export declare function linkClosingPr(issueNumber: number, prNumber: number): Promise<void>;
+export declare function findPrNumberClosingIssue(issueNumber: number, expectedHeadRefName: string): Promise<number | null>;
+export declare function getIssueSubIssuesSummary(issueNumber: number): Promise<SubIssuesSummary>;
+export interface PRCheck {
+    state: string;
+}
+export interface PullRequestWithChecks extends PullRequest {
+    checks: PRCheck[];
+}
+export declare function isCICompleted(checks: PRCheck[]): boolean;
+export declare function listPullRequestsWithChecks(assignee?: string, label?: string, excludeLabels?: string[], limit?: number): Promise<PullRequestWithChecks[]>;
+export declare function addLabel(type: "issue" | "pr", number: number, label: string): Promise<void>;
+export declare function addAssignee(type: "issue" | "pr", number: number, login: string): Promise<void>;
+export declare function hasLabel(type: "issue" | "pr", number: number, label: string): Promise<boolean>;
+/**
+ * 指定時刻以降に投稿されたコメントのうち、見出しが一致する最新（配列末尾）の1件の本文を返す。
+ * クラウドタスクの完了検知（cc-cloud-done ラベル）後に、最終報告コメントを1回だけ回収する
+ * ために使う想定で、ポーリングでは呼ばない。
+ * `{owner}/{repo}` は `gh api` が解決するため getRepoInfo() は使わない。PR も issue と
+ * 番号空間・エンドポイント（`issues/<number>/comments`）を共有するため type 分岐は不要。
+ */
+export declare function findCommentSince(number: number, since: Date, heading: string): Promise<string | null>;
+/**
+ * 指定ラベルが付いた issue/PR 番号を列挙する。実行中のクラウドタスク全体を1クエリで
+ * 判定するための列挙であり、個別番号の `gh issue view` ポーリングにはしない。
+ * `--state all` にするのは、exec-issue の「コード変更なし」経路が Issue をクローズして
+ * からラベルを付けるため、既定の open 限定だと検知できないため。
+ */
+export declare function listNumbersWithLabel(type: "issue" | "pr", label: string, limit?: number): Promise<number[]>;
+/**
+ * Issue が Open な blockedBy（GitHub Issue Dependencies）を持つかを実体から判定する。
+ *
+ * listIssuesByLabel の `-is:blocked` は検索インデックス経由のため、
+ * (1) `gh issue create --blocked-by` が「Issue作成 → 依存付与」の2フェーズで動き
+ *     ラベル付与から依存登録まで実測2〜3秒の隙間があること、
+ * (2) その後もインデックス反映に遅延があること、
+ * の2点で「まだブロック扱いになっていない」Issueを拾いうる。起動直前に本関数で
+ * 引き直すことで、検索インデックスを経由しない実体の状態で最終判定する。
+ */
+export declare function hasOpenBlockers(issueNumber: number): Promise<boolean>;
+export declare function removeLabel(type: "issue" | "pr", number: number, label: string): Promise<void>;
+export declare function getLastIssueComment(issueNumber: number): Promise<{
+    author: string;
+    body: string;
+} | null>;
+export declare function commentOnPR(prNumber: number, body: string): Promise<void>;
+export declare function commentOnIssue(issueNumber: number, body: string): Promise<void>;
+export declare function createPullRequest(base: string, head: string, title: string, body: string): Promise<number>;
+export declare function createLabel(name: string, color?: string, force?: boolean): Promise<boolean>;
+export {};

package/dist/git.d.ts

@@ -0,0 +1,7 @@
+export declare function syncDefaultBranch(branch: string): void;
+/**
+ * epic ブランチの remote-tracking ref (refs/remotes/origin/<epicBranch>) を
+ * ローカルに用意する。remote に epic ブランチが無ければ defaultBranch から派生させて push する。
+ * 完了時点で origin/<epicBranch> が必ず解決できることを保証する（できなければ throw）。
+ */
+export declare function ensureEpicBranch(epicBranch: string, defaultBranch: string): Promise<void>;