@groupchatai/claude-runner 0.4.2 → 0.4.5

package/dist/index.js

@@ -4,8 +4,18 @@
 import { spawn, execFileSync } from "child_process";
 import { readFileSync, readdirSync, statSync, writeFileSync, existsSync, rmSync } from "fs";
 import path from "path";
+import { fileURLToPath } from "url";
 var API_URL = "https://groupchat.ai";
 var CONVEX_URL = "https://fantastic-jay-464.convex.cloud";
+function sanitizeAgentJsonPayload(payload) {
+  const out = {};
+  for (const [key, value] of Object.entries(payload)) {
+    if (value === void 0 || value === null) continue;
+    if (typeof value === "number" && !Number.isFinite(value)) continue;
+    out[key] = value;
+  }
+  return out;
+}
 var GroupChatAgentClient = class {
   baseUrl;
   token;
@@ -15,13 +25,14 @@ var GroupChatAgentClient = class {
   }
   async request(method, endpoint, body) {
     const url = `${this.baseUrl}${endpoint}`;
+    const jsonBody = body ? JSON.stringify(sanitizeAgentJsonPayload(body)) : void 0;
     const res = await fetch(url, {
       method,
       headers: {
         Authorization: `Bearer ${this.token}`,
         "Content-Type": "application/json"
       },
-      body: body ? JSON.stringify(body) : void 0,
+      body: jsonBody,
       redirect: "follow"
     });
     if (res.status === 401 && res.redirected) {
@@ -31,7 +42,7 @@ var GroupChatAgentClient = class {
           Authorization: `Bearer ${this.token}`,
           "Content-Type": "application/json"
         },
-        body: body ? JSON.stringify(body) : void 0
+        body: jsonBody
       });
       if (!retry.ok) {
         const text = await retry.text().catch(() => "");
@@ -104,8 +115,16 @@ ${comment.body}`
     }
   }
   if (detail.task.dueDate) {
+    let dueStr = new Date(detail.task.dueDate).toLocaleDateString();
+    if (detail.task.dueTime != null) {
+      const h = Math.floor(detail.task.dueTime / 60);
+      const m = detail.task.dueTime % 60;
+      const period = h >= 12 ? "PM" : "AM";
+      const h12 = h === 0 ? 12 : h > 12 ? h - 12 : h;
+      dueStr += ` at ${h12}:${String(m).padStart(2, "0")} ${period}`;
+    }
     parts.push(`
-Due: ${new Date(detail.task.dueDate).toLocaleDateString()}`);
+Due: ${dueStr}`);
   }
   parts.push(
     [
@@ -240,6 +259,190 @@ var ALLOWED_TOOLS = [
   "TodoWrite",
   "NotebookEdit"
 ];
+function clampUserFacingDetail(text, maxChars) {
+  const t = text.trim();
+  if (t.length <= maxChars) return t;
+  return `${t.slice(0, maxChars - 1)}\u2026`;
+}
+function stripAnsi(text) {
+  return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function errorMessageFromUnknown(err) {
+  if (typeof err === "string" && err.trim()) return err.trim();
+  if (err && typeof err === "object") {
+    const o = err;
+    if (typeof o.message === "string" && o.message.trim()) return o.message.trim();
+    if (typeof o.error === "string" && o.error.trim()) return o.error.trim();
+  }
+  return null;
+}
+function formatAnthropicRateLimitPayload(o) {
+  const rateLimitTypeRaw = typeof o.rateLimitType === "string" ? o.rateLimitType.replace(/_/g, " ") : "unknown";
+  const rawReset = o.resetsAt;
+  let resetMs = null;
+  if (typeof rawReset === "number" && Number.isFinite(rawReset)) {
+    resetMs = rawReset > 1e10 ? rawReset : rawReset * 1e3;
+  }
+  const status = typeof o.status === "string" ? o.status : null;
+  const overageReason = typeof o.overageDisabledReason === "string" ? o.overageDisabledReason : null;
+  const parts = [`Rate limit (${rateLimitTypeRaw})`];
+  if (status) parts.push(`status ${status}`);
+  if (resetMs !== null) {
+    const when = new Date(resetMs);
+    const local = when.toLocaleString(void 0, {
+      dateStyle: "medium",
+      timeStyle: "short"
+    });
+    parts.push(`resets at ${local} (${when.toISOString()} UTC)`);
+  }
+  if (overageReason) parts.push(`overage: ${overageReason}`);
+  return parts.join(" \u2014 ");
+}
+function safeFormatRateLimitPayload(o) {
+  try {
+    return formatAnthropicRateLimitPayload(o);
+  } catch {
+    const rt = typeof o.rateLimitType === "string" ? o.rateLimitType : "unknown";
+    const rawReset = o.resetsAt;
+    if (typeof rawReset === "number" && Number.isFinite(rawReset)) {
+      const ms = rawReset > 1e10 ? rawReset : rawReset * 1e3;
+      return `Rate limit (${rt}) \u2014 resets at ${new Date(ms).toISOString()} UTC`;
+    }
+    return `Rate limit (${rt})`;
+  }
+}
+function parseClaudeNdjsonEvents(rawOutput) {
+  const events = [];
+  for (const line of stripAnsi(rawOutput).split("\n")) {
+    const t = line.trim();
+    if (!t.startsWith("{")) continue;
+    try {
+      const ev = JSON.parse(t);
+      if (ev && typeof ev === "object" && typeof ev.type === "string") {
+        events.push(ev);
+      }
+    } catch {
+    }
+  }
+  return events;
+}
+function extractAssistantUserVisibleText(event) {
+  const msg = event.message;
+  if (!msg || typeof msg !== "object" || Array.isArray(msg)) return null;
+  const content = msg.content;
+  if (!Array.isArray(content)) return null;
+  const parts = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const b = block;
+    if (b.type === "text" && typeof b.text === "string" && b.text.trim()) {
+      parts.push(b.text.trim());
+    }
+  }
+  if (parts.length === 0) return null;
+  return parts.join("\n");
+}
+var USAGE_LIMIT_RE = /you['\u2019]?ve hit your limit/i;
+function extractRateLimitRetryInfo(events) {
+  for (const ev of events) {
+    if (ev.type !== "rate_limit_event") continue;
+    const info = ev.rate_limit_info;
+    if (!info || typeof info !== "object" || Array.isArray(info)) continue;
+    const raw = info.resetsAt;
+    if (typeof raw !== "number" || !Number.isFinite(raw)) continue;
+    const ms = raw > 1e10 ? raw : raw * 1e3;
+    return { errorType: "rate_limit", retryAfterMs: ms };
+  }
+  return null;
+}
+function isClaudeUsageLimitText(text) {
+  return USAGE_LIMIT_RE.test(text);
+}
+function extractPlainTextCliErrorFromOutput(rawOutput) {
+  const limitMatch = rawOutput.match(new RegExp(USAGE_LIMIT_RE.source + "[^\\n\\r]*", "gi"));
+  if (limitMatch?.[0]) return limitMatch[0].trim();
+  for (const line of rawOutput.split("\n")) {
+    const t = line.trim();
+    if (!t || t.startsWith("{")) continue;
+    if (/^API error:/i.test(t) || /^Error:/i.test(t) || /^Anthropic/i.test(t)) {
+      return t.length <= 2e3 ? t : `${t.slice(0, 1999)}\u2026`;
+    }
+  }
+  return null;
+}
+function deriveClaudeFailureSummary(exitCode, rawOutput, stderr, events) {
+  const stderrText = stripAnsi(stderr).trim();
+  if (stderrText.length > 0) {
+    return clampUserFacingDetail(stderrText, 2e3);
+  }
+  for (let i = events.length - 1; i >= 0; i--) {
+    const ev = events[i];
+    if (ev.type !== "result") continue;
+    if (typeof ev.error === "string" && ev.error.trim()) {
+      return clampUserFacingDetail(ev.error.trim(), 2e3);
+    }
+    const nested = errorMessageFromUnknown(ev.error);
+    if (nested) return clampUserFacingDetail(nested, 2e3);
+    if (ev.is_error === true && typeof ev.result === "string" && ev.result.trim()) {
+      return clampUserFacingDetail(ev.result.trim(), 2e3);
+    }
+  }
+  for (let i = events.length - 1; i >= 0; i--) {
+    const ev = events[i];
+    if (ev.type !== "error") continue;
+    if (typeof ev.message === "string" && ev.message.trim()) {
+      return clampUserFacingDetail(ev.message.trim(), 2e3);
+    }
+    if (typeof ev.error === "string" && ev.error.trim()) {
+      return clampUserFacingDetail(ev.error.trim(), 2e3);
+    }
+    const nested = errorMessageFromUnknown(ev.error);
+    if (nested) return clampUserFacingDetail(nested, 2e3);
+  }
+  for (let i = events.length - 1; i >= 0; i--) {
+    const ev = events[i];
+    if (ev.type !== "assistant") continue;
+    if (ev.error === void 0 || ev.error === null || ev.error === "") continue;
+    const assistantText = extractAssistantUserVisibleText(ev);
+    if (assistantText) return clampUserFacingDetail(assistantText, 2e3);
+  }
+  for (const ev of events) {
+    if (ev.type === "rate_limit_event") {
+      const info = ev.rate_limit_info;
+      if (info && typeof info === "object" && !Array.isArray(info)) {
+        return clampUserFacingDetail(
+          safeFormatRateLimitPayload(info),
+          2e3
+        );
+      }
+    }
+  }
+  const combined = stripAnsi(`${stderr}
+${rawOutput}`);
+  const plain = extractPlainTextCliErrorFromOutput(combined);
+  if (plain) return clampUserFacingDetail(plain, 2e3);
+  return `Claude Code ended with exit code ${exitCode}. No detailed error was returned; if this persists, run the runner with verbose logging or try again later.`;
+}
+function claudeRunShouldReportAsError(options) {
+  if (options.exitCode !== 0) return true;
+  for (const ev of options.events) {
+    if (ev.type === "rate_limit_event") return true;
+    if (ev.type === "assistant" && ev.error !== void 0 && ev.error !== null && ev.error !== "") {
+      return true;
+    }
+    if (ev.type === "result" && ev.is_error === true) return true;
+  }
+  if (isClaudeUsageLimitText(options.resultSummaryText)) return true;
+  if (isClaudeUsageLimitText(options.combinedText)) return true;
+  return false;
+}
+function compactTaskErrorForApi(detail) {
+  const s = detail.trim();
+  if (/^rate limit \(/i.test(s)) {
+    return s.split(/\s*—\s*/)[0]?.trim() ?? s;
+  }
+  return s;
+}
 function spawnClaudeCode(prompt, config, runOptions, resumeSessionId, cwdOverride) {
   const format = config.verbose ? "stream-json" : "json";
   const args = [];
@@ -350,6 +553,7 @@ function spawnClaudeCode(prompt, config, runOptions, resumeSessionId, cwdOverrid
         resolve({
           stdout,
           rawOutput,
+          stderr,
           exitCode: code ?? 0,
           sessionId: capturedSessionId,
           streamPrUrl: capturedPrUrl
@@ -445,6 +649,12 @@ function runShellCommand(cmd, args, cwd) {
 }
 var sessionCache = /* @__PURE__ */ new Map();
 var runCounter = 0;
+var claudeRunnerSignalTeardownDone = false;
+function tryBeginClaudeRunnerSignalTeardown() {
+  if (claudeRunnerSignalTeardownDone) return false;
+  claudeRunnerSignalTeardownDone = true;
+  return true;
+}
 var WORKTREE_DIR = ".agent-worktrees";
 var WORKTREE_PREFIX = "task-";
 function worktreeNameForTask(taskId) {
@@ -461,15 +671,24 @@ function getDefaultBranch(repoDir) {
     return "main";
   }
 }
-function createWorktree(repoDir, taskId) {
+function createWorktree(repoDir, taskId, existingBranch) {
   const name = worktreeNameForTask(taskId);
-  const branchName = `agent/${name}-${Date.now()}`;
   const worktreeBase = path.join(repoDir, WORKTREE_DIR);
   const worktreePath = path.join(worktreeBase, name);
   if (existsSync(worktreePath)) {
     return worktreePath;
   }
+  if (existingBranch) {
+    try {
+      execGit(["fetch", "origin", existingBranch, "--quiet"], repoDir);
+    } catch {
+    }
+    execGit(["worktree", "add", worktreePath, `origin/${existingBranch}`], repoDir);
+    writeFileSync(path.join(worktreePath, ".agent-branch"), existingBranch, "utf-8");
+    return worktreePath;
+  }
   const baseBranch = getDefaultBranch(repoDir);
+  const branchName = `agent/${name}-${Date.now()}`;
   try {
     execGit(["fetch", "origin", baseBranch, "--quiet"], repoDir);
   } catch {
@@ -478,6 +697,39 @@ function createWorktree(repoDir, taskId) {
   writeFileSync(path.join(worktreePath, ".agent-branch"), branchName, "utf-8");
   return worktreePath;
 }
+async function resolveExistingPrBranch(detail, workDir) {
+  try {
+    if (detail.branchName) return detail.branchName;
+    if (detail.pullRequestUrl) {
+      try {
+        const branch2 = await runShellCommand(
+          "gh",
+          ["pr", "view", detail.pullRequestUrl, "--json", "headRefName", "--jq", ".headRefName"],
+          workDir
+        );
+        if (branch2?.trim()) return branch2.trim();
+      } catch {
+      }
+    }
+    const prUrls = [];
+    for (const item of detail.activity) {
+      if (item.body) {
+        const matches = item.body.match(GITHUB_PR_URL_RE);
+        if (matches) prUrls.push(...matches);
+      }
+    }
+    const prUrl = prUrls[prUrls.length - 1];
+    if (!prUrl) return void 0;
+    const branch = await runShellCommand(
+      "gh",
+      ["pr", "view", prUrl, "--json", "headRefName", "--jq", ".headRefName"],
+      workDir
+    );
+    if (branch?.trim()) return branch.trim();
+  } catch {
+  }
+  return void 0;
+}
 async function listOurWorktrees(workDir) {
   const worktreeDir = path.join(workDir, WORKTREE_DIR);
   let entries;
@@ -640,12 +892,52 @@ Removing ${safe.length} safe worktree(s)\u2026`);
   }
   console.log();
 }
-async function processRun(client, run, config, worktreeDir) {
+function logClaudeRunFailureDiagnostics(log, stderr, rawOutput) {
+  const se = stripAnsi(stderr).trimEnd();
+  const so = stripAnsi(rawOutput);
+  log(`${C.dim}\u2500\u2500 Claude failure diagnostics (--verbose) \u2500\u2500${C.reset}`);
+  if (se.length > 0) {
+    log(`${C.dim}stderr:${C.reset}`);
+    for (const ln of se.split("\n")) {
+      log(`${C.dim}  ${ln}${C.reset}`);
+    }
+  } else {
+    log(`${C.dim}(stderr empty)${C.reset}`);
+  }
+  const lines = so.length > 0 ? so.split("\n") : [];
+  const tailLines = lines.length > 200 ? lines.slice(-200) : lines;
+  log(`${C.dim}stdout: ${lines.length} line(s), showing last ${tailLines.length}${C.reset}`);
+  for (const ln of tailLines) {
+    log(`${C.dim}  ${ln}${C.reset}`);
+  }
+  log(`${C.dim}\u2500\u2500 end diagnostics \u2500\u2500${C.reset}`);
+}
+var CLAUDE_DEBUG_JSON_MAX_CHARS = 1e6;
+function logClaudeRawFailureJson(payload) {
+  const stamped = {
+    _tag: "claude-runner-claude-raw-failure",
+    _capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...payload
+  };
+  console.log(JSON.stringify(stamped, null, 2));
+}
+function truncateClaudeDebugString(text) {
+  const fullLength = text.length;
+  if (fullLength <= CLAUDE_DEBUG_JSON_MAX_CHARS) {
+    return { text, fullLength, truncated: false };
+  }
+  return {
+    text: `${text.slice(0, CLAUDE_DEBUG_JSON_MAX_CHARS)}
+\u2026 [truncated; copy from logs or raise CLAUDE_DEBUG_JSON_MAX_CHARS]`,
+    fullLength,
+    truncated: true
+  };
+}
+async function processRun(client, run, config, worktreeDir, detail) {
   const runNum = ++runCounter;
   const runTag = `  ${C.pid}[${runNum}]${C.reset}`;
   const log = (msg) => console.log(`${runTag} ${msg}`);
   const logGreen = (msg) => console.log(`${runTag} ${C.green}${msg}${C.reset}`);
-  const detail = await client.getRunDetail(run.id);
   const ownerName = run.owner?.name ?? detail.owner?.name ?? "unknown";
   log(`\u{1F4CB} "${run.taskTitle}" \u2014 delegated by ${ownerName}`);
   if (detail.status !== "PENDING") {
@@ -675,6 +967,11 @@ async function processRun(client, run, config, worktreeDir) {
   }
   log("\u25B6  Run started");
   const effectiveCwd = worktreeDir ?? config.workDir;
+  let lastClaudeStderr = "";
+  let lastClaudeStdout = "";
+  let lastClaudeRawOutput = "";
+  let lastClaudeExitCode = null;
+  let lastClaudeSessionId;
   try {
     if (!worktreeDir && runOptions.branch) {
       log(`\u{1F33F} Checking out branch: ${runOptions.branch}`);
@@ -703,7 +1000,12 @@ async function processRun(client, run, config, worktreeDir) {
       effectiveCwd
     );
     log(`\u{1F916} Claude Code spawned (pid ${child.pid})${isFollowUp ? " (follow-up)" : ""}`);
-    let { stdout, rawOutput, exitCode, sessionId, streamPrUrl } = await output;
+    let { stdout, rawOutput, stderr, exitCode, sessionId, streamPrUrl } = await output;
+    lastClaudeStderr = stderr;
+    lastClaudeStdout = stdout;
+    lastClaudeRawOutput = rawOutput;
+    lastClaudeExitCode = exitCode;
+    lastClaudeSessionId = sessionId;
     if (exitCode !== 0 && isFollowUp) {
       log(`\u26A0  Session resume failed, retrying with fresh session\u2026`);
       sessionCache.delete(run.taskId);
@@ -712,21 +1014,81 @@ async function processRun(client, run, config, worktreeDir) {
       const retryResult = await retry.output;
       stdout = retryResult.stdout;
       rawOutput = retryResult.rawOutput;
+      stderr = retryResult.stderr;
       exitCode = retryResult.exitCode;
       sessionId = retryResult.sessionId;
       streamPrUrl = retryResult.streamPrUrl;
+      lastClaudeStderr = stderr;
+      lastClaudeStdout = stdout;
+      lastClaudeRawOutput = rawOutput;
+      lastClaudeExitCode = exitCode;
+      lastClaudeSessionId = sessionId;
     }
     if (sessionId) {
       sessionCache.set(run.taskId, sessionId);
     }
     const pullRequestUrl = streamPrUrl ?? await detectPullRequestUrl(effectiveCwd) ?? extractPullRequestUrlFromOutput(stdout) ?? extractPullRequestUrlFromOutput(rawOutput);
-    if (exitCode !== 0) {
-      const errorMsg = `Claude Code exited with code ${exitCode}:
-\`\`\`
-${stdout.slice(0, 2e3)}
-\`\`\``;
-      await client.errorRun(run.id, errorMsg, { pullRequestUrl });
-      log(`${C.red}\u274C Run errored (exit code ${exitCode})${C.reset}`);
+    const streamEvents = parseClaudeNdjsonEvents(rawOutput);
+    const combinedForLimit = stripAnsi(`${stderr}
+${rawOutput}`);
+    const resultSummaryText = extractResultText(stdout);
+    const usageCap = claudeRunShouldReportAsError({
+      exitCode,
+      events: streamEvents,
+      combinedText: combinedForLimit,
+      resultSummaryText
+    });
+    if (exitCode !== 0 || usageCap) {
+      const detail2 = deriveClaudeFailureSummary(exitCode, rawOutput, stderr, streamEvents);
+      const errorMsg = compactTaskErrorForApi(detail2);
+      if (process.env.GCA_DEBUG_CLAUDE_RAW === "1") {
+        const stderrDbg = truncateClaudeDebugString(stripAnsi(stderr));
+        const stdoutDbg = truncateClaudeDebugString(stripAnsi(stdout));
+        const rawDbg = truncateClaudeDebugString(stripAnsi(rawOutput));
+        logClaudeRawFailureJson({
+          runId: run.id,
+          taskId: run.taskId,
+          taskTitle: run.taskTitle,
+          exitCode,
+          usageCap,
+          sessionId: sessionId ?? null,
+          streamPrUrl: streamPrUrl ?? null,
+          pullRequestUrl: pullRequestUrl ?? null,
+          formattedDetail: detail2,
+          taskErrorMessageSentToApi: errorMsg,
+          parsedEventTypes: streamEvents.map((e) => e.type),
+          stderr: stderrDbg.text,
+          stderrMeta: { fullLength: stderrDbg.fullLength, truncated: stderrDbg.truncated },
+          stdout: stdoutDbg.text,
+          stdoutMeta: { fullLength: stdoutDbg.fullLength, truncated: stdoutDbg.truncated },
+          rawOutput: rawDbg.text,
+          rawOutputMeta: { fullLength: rawDbg.fullLength, truncated: rawDbg.truncated },
+          resultTextFromExtract: resultSummaryText || null
+        });
+      }
+      const retryInfo = extractRateLimitRetryInfo(streamEvents);
+      await client.errorRun(run.id, errorMsg, {
+        pullRequestUrl,
+        errorType: retryInfo?.errorType,
+        retryAfter: retryInfo?.retryAfterMs
+      });
+      if (retryInfo) {
+        const retryAt = new Date(retryInfo.retryAfterMs).toLocaleString(void 0, {
+          dateStyle: "medium",
+          timeStyle: "short"
+        });
+        log(`${C.red}\u23F8  Rate limited \u2014 server will retry at ${retryAt}${C.reset}`);
+      } else {
+        log(
+          `${C.red}\u274C Run errored${exitCode !== 0 ? ` (exit code ${exitCode})` : " (usage limit)"}${C.reset}`
+        );
+      }
+      for (const line of detail2.split("\n")) {
+        log(`${C.red}   ${line}${C.reset}`);
+      }
+      if (config.verbose) {
+        logClaudeRunFailureDiagnostics(log, stderr, rawOutput);
+      }
       return;
     }
     const resultText = extractResultText(stdout);
@@ -736,6 +1098,28 @@ ${stdout.slice(0, 2e3)}
     logGreen(`\u2705 Run completed`);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
+    const stack = err instanceof Error ? err.stack : void 0;
+    const stderrDbg = truncateClaudeDebugString(stripAnsi(lastClaudeStderr));
+    const stdoutDbg = truncateClaudeDebugString(stripAnsi(lastClaudeStdout));
+    const rawDbg = truncateClaudeDebugString(stripAnsi(lastClaudeRawOutput));
+    if (process.env.GCA_DEBUG_CLAUDE_RAW === "1") {
+      logClaudeRawFailureJson({
+        runId: run.id,
+        taskId: run.taskId,
+        taskTitle: run.taskTitle,
+        thrownMessage: message,
+        thrownStack: stack ?? null,
+        exitCode: lastClaudeExitCode,
+        sessionId: lastClaudeSessionId ?? null,
+        note: "Thrown before or after Claude finished; fields may be empty.",
+        stderr: stderrDbg.text,
+        stderrMeta: { fullLength: stderrDbg.fullLength, truncated: stderrDbg.truncated },
+        stdout: stdoutDbg.text,
+        stdoutMeta: { fullLength: stdoutDbg.fullLength, truncated: stdoutDbg.truncated },
+        rawOutput: rawDbg.text,
+        rawOutputMeta: { fullLength: rawDbg.fullLength, truncated: rawDbg.truncated }
+      });
+    }
     const errorBody = `Claude Code runner error:
 \`\`\`
 ${message.slice(0, 2e3)}
@@ -772,6 +1156,25 @@ function loadEnvFile() {
     }
   }
 }
+function getRunnerPackageInfo() {
+  try {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const pkgPath = path.join(here, "..", "package.json");
+    const raw = readFileSync(pkgPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    return {
+      name: pkg.name ?? "@groupchatai/claude-runner",
+      version: pkg.version ?? "unknown"
+    };
+  } catch {
+    return { name: "@groupchatai/claude-runner", version: "unknown" };
+  }
+}
+function showVersion() {
+  const { name, version } = getRunnerPackageInfo();
+  console.log(`${name} ${version}`);
+  process.exit(0);
+}
 function showHelp() {
   console.log(`
 Usage: npx @groupchatai/claude-runner [command] [options]
@@ -792,6 +1195,7 @@ Options:
   --token <token>       Agent token (or set GCA_TOKEN env var)
   --no-worktree         Disable git worktree isolation for runs
   -h, --help            Show this help message
+  -v, -version, --version  Print version and exit
 
 Environment variables:
   GCA_TOKEN             Agent token (gca_...)
@@ -850,6 +1254,11 @@ function parseArgs() {
       case "-h":
         showHelp();
         break;
+      case "--version":
+      case "-v":
+      case "-version":
+        showVersion();
+        break;
       case "--no-worktree":
         config.useWorktrees = false;
         break;
@@ -919,6 +1328,12 @@ var TaskScheduler = class {
     return this.slots.size === 0;
   }
 };
+function drainSchedulerSlot(scheduler, run) {
+  let current = run;
+  while (current) {
+    current = scheduler.complete(current);
+  }
+}
 function handlePendingRuns(runs, scheduler, client, config) {
   if (runs.length > 0 && config.verbose) {
     console.log(`\u{1F4EC} ${runs.length} pending run(s)`);
@@ -943,27 +1358,47 @@ function handlePendingRuns(runs, scheduler, client, config) {
   }
 }
 async function processRunWithDrain(client, run, scheduler, config) {
+  let detail;
+  try {
+    detail = await client.getRunDetail(run.id);
+  } catch (err) {
+    console.error(`  \u274C Failed to fetch run detail for ${run.id}:`, err);
+    drainSchedulerSlot(scheduler, run);
+    return;
+  }
   let worktreeDir;
   if (config.useWorktrees) {
     try {
-      worktreeDir = createWorktree(config.workDir, run.taskId);
-      console.log(
-        `  \u{1F333} Worktree created from main \u2192 ${path.relative(config.workDir, worktreeDir)}`
-      );
+      const existingBranch = await resolveExistingPrBranch(detail, config.workDir);
+      worktreeDir = createWorktree(config.workDir, run.taskId, existingBranch);
+      const rel = path.relative(config.workDir, worktreeDir);
+      if (existingBranch) {
+        console.log(`  \u{1F333} Worktree from existing PR branch ${existingBranch} \u2192 ${rel}`);
+      } else {
+        console.log(`  \u{1F333} Worktree created from main \u2192 ${rel}`);
+      }
     } catch (err) {
       console.error(`  \u26A0  Failed to create worktree, running in-place:`, err);
     }
   }
   let current = run;
+  let currentDetail = detail;
   while (current) {
     try {
-      await processRun(client, current, config, worktreeDir);
+      await processRun(client, current, config, worktreeDir, currentDetail);
     } catch (err) {
       console.error(`Unhandled error processing run ${current.id}:`, err);
     }
     current = scheduler.complete(current);
     if (current) {
       console.log(`  \u23ED  Processing queued follow-up\u2026`);
+      try {
+        currentDetail = await client.getRunDetail(current.id);
+      } catch (err) {
+        console.error(`  \u274C Failed to fetch detail for follow-up ${current.id}:`, err);
+        drainSchedulerSlot(scheduler, current);
+        break;
+      }
     }
   }
   if (worktreeDir) {
@@ -1000,13 +1435,22 @@ async function runWithWebSocket(client, config, scheduler) {
     }
   );
   await new Promise((resolve) => {
-    const shutdown = () => {
+    function shutdown() {
+      if (!tryBeginClaudeRunnerSignalTeardown()) return;
+      process.removeListener("SIGINT", shutdown);
+      process.removeListener("SIGTERM", shutdown);
       console.log("\n\u{1F6D1} Shutting down\u2026");
-      void convex.close();
-      resolve();
-    };
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
+      void (async () => {
+        try {
+          await convex.close();
+        } catch {
+        } finally {
+          resolve();
+        }
+      })();
+    }
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
   });
 }
 async function runWithPolling(client, config, scheduler) {
@@ -1019,12 +1463,15 @@ async function runWithPolling(client, config, scheduler) {
 `
   );
   let running = true;
-  const shutdown = () => {
+  function shutdownPoll() {
+    if (!tryBeginClaudeRunnerSignalTeardown()) return;
+    process.removeListener("SIGINT", shutdownPoll);
+    process.removeListener("SIGTERM", shutdownPoll);
     console.log("\n\u{1F6D1} Shutting down\u2026");
     running = false;
-  };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
+  }
+  process.once("SIGINT", shutdownPoll);
+  process.once("SIGTERM", shutdownPoll);
   if (config.once) {
     try {
       const pending = await client.listPendingRuns();
@@ -1048,7 +1495,14 @@ async function runWithPolling(client, config, scheduler) {
     await sleep(config.pollInterval);
   }
 }
+function wantsVersionOnly(argv) {
+  return argv.some((a) => a === "--version" || a === "-v" || a === "-version");
+}
 async function main() {
+  const argv = process.argv.slice(2);
+  if (wantsVersionOnly(argv)) {
+    showVersion();
+  }
   if (process.argv.includes("cleanup")) {
     loadEnvFile();
     const workDir = process.cwd();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groupchatai/claude-runner",
-  "version": "0.4.2",
+  "version": "0.4.5",
   "description": "Run GroupChat AI agent tasks locally with Claude Code",
   "type": "module",
   "bin": {