claude-task-worker 0.37.0 → 0.39.0

package/README.md

@@ -138,7 +138,6 @@ CLI 本体に npm の実行時依存パッケージはない（ビルド時に e
 | [CodeGraph (`codegraph`)](https://www.npmjs.com/package/@colbymchenry/codegraph) | - | コード探索用のインデックス。MCP サーバー（`codegraph serve --mcp`）としてプラグインから起動される。`install` / `update` / `init` が面倒を見る。未インストールでもワーカーは動作する（探索がテキスト検索に落ちるだけ） |
 | [Pencil CLI (`pencil`)](https://docs.pencil.dev/for-developers/pencil-cli) | - | `.pen` デザインファイルの編集・参照・コンフリクト解消（`edit-pencil-design` / `inspect-pencil-node` / `resolve-pencil-conflict` スキルで使用） |
 | [herdr](https://herdr.dev) | - | `--project` 使用時と `mode: "herdr"` 使用時にのみ必要。複数プロジェクトへのディスパッチ・セッション監視・一括停止、タスクのTUI実行に使用 |
-| [Headroom (`headroom`)](https://github.com/headroom-ai/headroom) | - | `headroom: true` 使用時にのみ必要。タスクの claude をコンテキスト圧縮プロキシ経由で起動する |
 | `claude-task-worker` プラグイン | - | 各ワーカーが呼び出すスキル群（本リポジトリの `plugin/`） |
 
 Slack通知（任意）を使う場合は Slack Incoming Webhook URL が必要。Claude API使用状況の取得には、macOSでは `security` コマンド（Keychain）を使用し、それ以外の環境では `~/.claude/.credentials.json` にフォールバックする。
@@ -176,7 +175,6 @@ Slack通知（任意）を使う場合は Slack Incoming Webhook URL が必要
 - [Claude Code (`claude`)](https://docs.anthropic.com/en/docs/claude-code) がインストール済みであること
 - `claude-task-worker` プラグインがインストール済みであること（下記インストール手順を参照）
 - `--project` オプション・`mode: "herdr"` を使う場合のみ、[herdr](https://herdr.dev) がインストール済みであること
-- `headroom: true` を使う場合のみ、[Headroom](https://github.com/headroom-ai/headroom) がインストール済みであること
 - CodeGraph はコード探索の精度向上のために推奨（`install` / `init` が導入・インデックス構築を行う）。未導入でもワーカーは動作する
 
 詳細は上記「[必要なライブラリ](#必要なライブラリ)」を参照。
@@ -348,7 +346,7 @@ claude-task-worker yolo --epic 100 --epic 200 --label priority-high
 }
 ```
 
-`mode` については [`mode`（タスクの実行形態）](#modeタスクの実行形態) を、`headroom` については [`headroom`（Headroom 経由でのタスク実行）](#headroomheadroom-経由でのタスク実行) を参照。
+`mode` については [`mode`（タスクの実行形態）](#modeタスクの実行形態) を参照。
 
 `--project` は繰り返し指定可能で、複数指定した場合は解決後のプロジェクト集合の和集合が対象になる（重複は一意化される）。`--epic` / `--label` と併用でき、ディスパッチ先の各プロジェクトで実行されるコマンドにそのまま引き継がれる。
 
@@ -388,7 +386,7 @@ claude-task-worker exec-issue --project app-a --epic 100 --label priority-high
 
 `mode: "herdr"` のときの1タスクの流れ:
 
-1. worktree を作成し、`ctw:<プロジェクト名>:#<Issue/PR番号>` ラベルのタブで claude を TUI 起動する（タブを先に作ってからその中で起動するため、ユーザーが見ているタブにペインが割り込むことはない）
+1. worktree を作成し、`ctw:<プロジェクト名>:#<Issue/PR番号>` ラベルのタブを作ってから、そのルートペインで `herdr agent start --kind claude` を使って claude を TUI 起動する（タブを先に作ってからその中で起動するため、ユーザーが見ているタブにペインが割り込むことはない）。`agent start` は claude が検出され入力待ちになるまで同期的にブロックするため、起動確認の別ポーリングは不要
 2. herdr が持つ agent ステータスを監視し、`done`（未確認完了）または `working` → `idle` の遷移をタスク完了とみなす。ワーカーのタスクタブは誰も開かないため、完了したタスクは通常 `done` として観測される
 3. 完了したら claude のセッション transcript（`~/.claude/projects/*/<sessionId>.jsonl`）から最終レポートを回収して通知に使い、タブを閉じてラベル・worktree を後片付けする。transcript を引けない場合のみペインの内容にフォールバックする
 
@@ -407,33 +405,6 @@ claude-task-worker exec-issue --project app-a --epic 100 --label priority-high
 
   適用は `herdr server reload-config`。この設定は herdr サーバー全体に効くため、ワーカー以外の対話セッションの完了音も鳴らなくなる（`[ui.sound.agents] claude = "off"` でも実質同じ範囲）。ワーカーだけを無音にしたい場合は、`HERDR_DISABLE_SOUND=1 herdr --session <name>` で別セッションを起動し、その中でディスパッチャーを動かす
 
-### `headroom`（Headroom 経由でのタスク実行）
-
-`config.json` のトップレベルに `"headroom": true` を書くと、ワーカーは各タスクの claude を [Headroom](https://github.com/headroom-ai/headroom) 経由（`headroom wrap claude`）で起動する。Headroom がローカルプロキシを立ててコンテキストを圧縮し、`ANTHROPIC_BASE_URL` を差し替えた状態で claude を起動する。既定は `false`（`claude` を直接起動する）。
-
-`mode` と同じくトップレベル一括の設定で、プロジェクト単位・ワーカー単位の指定はできない。
-
-```json
-{
-  "headroom": true,
-  "projects": { "app-a": "/Users/me/repos/app-a" }
-}
-```
-
-| `headroom` | 実行されるコマンド |
-|-----------|------------------|
-| `false`（既定） | `claude <引数>` |
-| `true` | `headroom wrap claude --1m --memory --no-tokensave --no-serena -- <引数>` |
-
-補足:
-
-- `mode` とは独立して組み合わせられる（`mode: "herdr"` の TUI 起動も `headroom wrap claude` になる）
-- claude へ渡す引数はすべて `--` の後ろに置かれる。`headroom wrap claude` 自身も `--port` / `--memory` などのオプションを持ち、`-p` のように衝突しうるフラグは `--` の後ろでないと claude に届かないため。逆に headroom 自身へのオプションは `--` の前に置く
-- 1M コンテキストウィンドウは `--model` の値へ `[1m]` サフィックスを付けることで解放する（`--model 'sonnet[1m]'` のようになる）。headroom の `--1m` は `ANTHROPIC_MODEL` をセットするだけの実装で、CLI の `--model` が環境変数に勝つため、`--model` を明示するワーカー起動では単体では効かない
-- `--no-tokensave` / `--no-serena` で headroom が既定で登録するコードグラフ系 MCP を止める。コード探索はプラグインの codegraph MCP が担うため機能面の損失はなく、タスク起動のたびに走る再登録・再インデックスと、ユーザーのグローバル設定（`~/.claude.json`）の書き換えを避けられる
-- `headroom: true` で headroom コマンドが PATH に無い場合、ワーカーは起動時にエラー終了する（`mode: "herdr"` と同じく、サイレントに直接起動へフォールバックはしない）
-- `headroom wrap claude` は claude を起動する前に起動バナー（枠線・`ANTHROPIC_BASE_URL=...` など）を stdout へ出力し、これを抑止するオプションは無い。ワーカーは空振りセッション検知（exit 0 かつ無出力を失敗とみなす判定）の前にこのバナーを取り除くため、検知は `headroom: true` でも従来どおり機能する。ただし Slack 通知の本文にはバナーがそのまま含まれる
-
 ### exec-issue
 
 `cc-exec-issue` ラベルが付いた自分にアサインされたIssueを定期取得し、Claude Codeで処理を実行する。（デフォルト1分間隔）

package/dist/index.js

@@ -132,38 +132,6 @@ var init_table = __esm({
   }
 });
 
-// src/task-result.ts
-function stripHeadroomBanner(stdout) {
-  const lines = stdout.split("\n");
-  let i = 0;
-  while (i < lines.length && (lines[i].trim() === "" || lines[i].startsWith("  "))) i++;
-  return lines.slice(i).join("\n");
-}
-function buildTaskResult(code, stdout, stderrTail, options) {
-  const meaningful = options?.headroom ? stripHeadroomBanner(stdout) : stdout;
-  const emptyOutput = meaningful.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 };
-}
-var STDERR_TAIL_LIMIT;
-var init_task_result = __esm({
-  "src/task-result.ts"() {
-    "use strict";
-    STDERR_TAIL_LIMIT = 8 * 1024;
-  }
-});
-
 // src/transcript.ts
 import { existsSync, readFileSync as readFileSync3, readdirSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
@@ -230,20 +198,21 @@ var init_transcript = __esm({
 // src/herdr.ts
 var herdr_exports = {};
 __export(herdr_exports, {
+  AGENT_KIND: () => AGENT_KIND,
+  AGENT_START_READY_TIMEOUT_MS: () => AGENT_START_READY_TIMEOUT_MS,
   HERDR_TIMEOUT_MS: () => HERDR_TIMEOUT_MS,
   HerdrError: () => HerdrError,
   HerdrUnavailableError: () => HerdrUnavailableError,
   agentGet: () => agentGet,
+  agentStart: () => agentStart,
   checkHerdrAvailable: () => checkHerdrAvailable,
   getCurrentWorkspaceId: () => getCurrentWorkspaceId,
-  launchAgentInPane: () => launchAgentInPane,
   paneClose: () => paneClose,
   paneGet: () => paneGet,
   paneProcessInfo: () => paneProcessInfo,
   paneRead: () => paneRead,
   paneSendKeys: () => paneSendKeys,
   paneSendText: () => paneSendText,
-  shellQuoteArgv: () => shellQuoteArgv,
   tabClose: () => tabClose,
   tabCreate: () => tabCreate,
   tabList: () => tabList,
@@ -255,18 +224,13 @@ __export(herdr_exports, {
 });
 import { createRequire as createRequire2 } from "node:module";
 import { resolve as resolvePath } from "node:path";
-function runHerdr(args) {
+function runHerdr(args, timeoutMs = HERDR_TIMEOUT_MS) {
   return new Promise((resolve3) => {
-    childProcess2.execFile(
-      "herdr",
-      args,
-      { timeout: HERDR_TIMEOUT_MS, killSignal: "SIGKILL" },
-      (error, stdout, stderr) => {
-        const parsed = parseHerdrResponse(stdout);
-        const stderrError = parsed?.error ? void 0 : parseHerdrResponse(stderr)?.error;
-        resolve3({ execError: error, parsed, stderrError, stdout, stderr });
-      }
-    );
+    childProcess2.execFile("herdr", args, { timeout: timeoutMs, killSignal: "SIGKILL" }, (error, stdout, stderr) => {
+      const parsed = parseHerdrResponse(stdout);
+      const stderrError = parsed?.error ? void 0 : parseHerdrResponse(stderr)?.error;
+      resolve3({ execError: error, parsed, stderrError, stdout, stderr });
+    });
   });
 }
 function parseHerdrResponse(output) {
@@ -279,7 +243,7 @@ function parseHerdrResponse(output) {
   }
 }
 async function execHerdr(args, options) {
-  const { execError, parsed, stderrError, stdout, stderr } = await runHerdr(args);
+  const { execError, parsed, stderrError, stdout, stderr } = await runHerdr(args, options?.timeoutMs);
   const stderrSuffix = stderr.trim() ? `: ${stderr.trim()}` : "";
   const errorPayload = parsed?.error ?? stderrError;
   if (errorPayload) {
@@ -396,32 +360,44 @@ async function workspaceClose(workspaceId) {
 async function workspaceFocus(workspaceId) {
   await execHerdr(["workspace", "focus", workspaceId]);
 }
-function shellQuoteArgv(argv) {
-  return argv.map((arg) => `'${arg.replace(/'/g, `'\\''`)}'`).join(" ");
-}
-async function launchAgentInPane(paneId, argv) {
-  await paneSendText(paneId, shellQuoteArgv(argv));
-  await paneSendKeys(paneId, "enter");
-}
 function toAgentStatus(value) {
   return value === "working" || value === "idle" || value === "blocked" || value === "done" ? value : "unknown";
 }
-async function agentGet(target) {
-  const result = await execHerdr(["agent", "get", target]);
-  const agent = result?.agent;
-  if (!agent?.pane_id) {
-    throw new Error(`Failed to get agent info for ${target}: invalid response structure from herdr`);
-  }
+function toAgentInfo(agent) {
   const session = agent.agent_session;
   const sessionId = session?.kind === "id" && typeof session.value === "string" ? session.value : void 0;
   return {
-    paneId: agent.pane_id,
+    paneId: agent.pane_id ?? "",
     tabId: agent.tab_id ?? "",
     workspaceId: agent.workspace_id ?? "",
     agentStatus: toAgentStatus(agent.agent_status),
     sessionId
   };
 }
+async function agentStart(paneId, {
+  name,
+  args,
+  kind = AGENT_KIND,
+  readyTimeoutMs = AGENT_START_READY_TIMEOUT_MS
+}) {
+  const result = await execHerdr(
+    ["agent", "start", name, "--kind", kind, "--pane", paneId, "--timeout", String(readyTimeoutMs), "--", ...args],
+    { timeoutMs: readyTimeoutMs + AGENT_START_EXEC_BUFFER_MS }
+  );
+  const agent = result?.agent;
+  if (!agent?.pane_id) {
+    throw new Error(`Failed to start agent in pane ${paneId}: invalid response structure from herdr`);
+  }
+  return toAgentInfo(agent);
+}
+async function agentGet(target) {
+  const result = await execHerdr(["agent", "get", target]);
+  const agent = result?.agent;
+  if (!agent?.pane_id) {
+    throw new Error(`Failed to get agent info for ${target}: invalid response structure from herdr`);
+  }
+  return toAgentInfo(agent);
+}
 function getCurrentWorkspaceId() {
   const id = process.env.HERDR_WORKSPACE_ID;
   return id && id.length > 0 ? id : void 0;
@@ -503,7 +479,7 @@ async function checkHerdrAvailable() {
     );
   }
 }
-var childProcess2, HerdrUnavailableError, HerdrError, HERDR_TIMEOUT_MS, PANE_READ_ERROR_ALLOWED_KEYS;
+var childProcess2, HerdrUnavailableError, HerdrError, HERDR_TIMEOUT_MS, AGENT_KIND, AGENT_START_READY_TIMEOUT_MS, AGENT_START_EXEC_BUFFER_MS, PANE_READ_ERROR_ALLOWED_KEYS;
 var init_herdr = __esm({
   "src/herdr.ts"() {
     "use strict";
@@ -525,6 +501,9 @@ var init_herdr = __esm({
       }
     };
     HERDR_TIMEOUT_MS = 15 * 1e3;
+    AGENT_KIND = "claude";
+    AGENT_START_READY_TIMEOUT_MS = 120 * 1e3;
+    AGENT_START_EXEC_BUFFER_MS = 15 * 1e3;
     PANE_READ_ERROR_ALLOWED_KEYS = /* @__PURE__ */ new Set(["code", "message"]);
   }
 });
@@ -532,8 +511,6 @@ var init_herdr = __esm({
 // src/herdr-runner.ts
 var herdr_runner_exports = {};
 __export(herdr_runner_exports, {
-  AGENT_DETECT_POLL_INTERVAL_MS: () => AGENT_DETECT_POLL_INTERVAL_MS,
-  AGENT_DETECT_TIMEOUT_MS: () => AGENT_DETECT_TIMEOUT_MS,
   AGENT_POLL_INTERVAL_MS: () => AGENT_POLL_INTERVAL_MS,
   CLAUDE_EXIT_POLL_INTERVAL_MS: () => CLAUDE_EXIT_POLL_INTERVAL_MS,
   CLAUDE_EXIT_TIMEOUT_MS: () => CLAUDE_EXIT_TIMEOUT_MS,
@@ -578,8 +555,7 @@ function buildHerdrTaskResult(paneOutput, options) {
   if (report !== "") {
     return { status: "completed", output: report };
   }
-  const meaningful = options?.headroom ? stripHeadroomBanner(paneOutput) : paneOutput;
-  if (meaningful.trim() === "") {
+  if (paneOutput.trim() === "") {
     return {
       status: "failed",
       output: "[worker] the claude session became idle but its pane produced no output (session aborted before the model ran; e.g. a skill preamble command failed)"
@@ -590,7 +566,7 @@ function buildHerdrTaskResult(paneOutput, options) {
 async function startHerdrTask({
   label,
   cwd,
-  argv,
+  args,
   env,
   workspaceId,
   herdr,
@@ -606,16 +582,7 @@ async function startHerdrTask({
     if (!ready) {
       console.warn(`[herdr-runner] pane ${paneId} produced no prompt before the timeout, launching anyway`);
     }
-    await mod.launchAgentInPane(paneId, argv);
-    const detected = await waitForAgentDetected(paneId, mod, {
-      timeoutMs: timing?.agentDetectTimeoutMs,
-      pollIntervalMs: timing?.agentDetectPollIntervalMs
-    });
-    if (!detected) {
-      throw new Error(
-        `claude was not detected in pane ${paneId} after launch (it may have failed to start; e.g. a skill preamble command failed)`
-      );
-    }
+    await mod.agentStart(paneId, { name: label, args, readyTimeoutMs: timing?.agentStartReadyTimeoutMs });
   } catch (err) {
     await mod.tabClose(tabId).catch(() => {
     });
@@ -639,24 +606,6 @@ async function waitForPaneReady(paneId, mod, options) {
     await sleep(pollIntervalMs);
   }
 }
-async function waitForAgentDetected(paneId, mod, options) {
-  const timeoutMs = options?.timeoutMs ?? AGENT_DETECT_TIMEOUT_MS;
-  const pollIntervalMs = options?.pollIntervalMs ?? AGENT_DETECT_POLL_INTERVAL_MS;
-  const deadline = Date.now() + timeoutMs;
-  for (; ; ) {
-    try {
-      await mod.agentGet(paneId);
-      return true;
-    } catch (err) {
-      if (err instanceof mod.HerdrError && err.code === "pane_not_found") return false;
-      if (!(err instanceof mod.HerdrError && err.code === "agent_not_found")) {
-        console.error(`[herdr-runner] unexpected error while waiting for agent detection on pane ${paneId}: ${err}`);
-      }
-    }
-    if (Date.now() >= deadline) return false;
-    await sleep(pollIntervalMs);
-  }
-}
 async function waitForHerdrTask(paneId, options) {
   const mod = options?.herdr ?? await loadHerdr();
   const pollIntervalMs = options?.pollIntervalMs ?? AGENT_POLL_INTERVAL_MS;
@@ -688,7 +637,7 @@ async function waitForHerdrTask(paneId, options) {
     if (observed.decision === "completed") {
       const output = await readPaneOutput(paneId, mod);
       const report = (options?.readReport ?? readFinalReport)(sessionId);
-      return buildHerdrTaskResult(output, { headroom: options?.headroom, report });
+      return buildHerdrTaskResult(output, { report });
     }
     if (observed.decision === "blocked-first-seen") {
       options?.onBlocked?.();
@@ -746,18 +695,15 @@ async function stopHerdrTask(task, herdr, options) {
 function sleep(ms) {
   return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
-var AGENT_POLL_INTERVAL_MS, PANE_OUTPUT_LINES, PANE_READY_TIMEOUT_MS, PANE_READY_POLL_INTERVAL_MS, AGENT_DETECT_TIMEOUT_MS, AGENT_DETECT_POLL_INTERVAL_MS, CLAUDE_EXIT_TIMEOUT_MS, CLAUDE_EXIT_POLL_INTERVAL_MS;
+var AGENT_POLL_INTERVAL_MS, PANE_OUTPUT_LINES, PANE_READY_TIMEOUT_MS, PANE_READY_POLL_INTERVAL_MS, CLAUDE_EXIT_TIMEOUT_MS, CLAUDE_EXIT_POLL_INTERVAL_MS;
 var init_herdr_runner = __esm({
   "src/herdr-runner.ts"() {
     "use strict";
-    init_task_result();
     init_transcript();
     AGENT_POLL_INTERVAL_MS = 3 * 1e3;
     PANE_OUTPUT_LINES = 300;
     PANE_READY_TIMEOUT_MS = 30 * 1e3;
     PANE_READY_POLL_INTERVAL_MS = 200;
-    AGENT_DETECT_TIMEOUT_MS = 120 * 1e3;
-    AGENT_DETECT_POLL_INTERVAL_MS = 500;
     CLAUDE_EXIT_TIMEOUT_MS = 15 * 1e3;
     CLAUDE_EXIT_POLL_INTERVAL_MS = 200;
   }
@@ -1548,13 +1494,7 @@ var SYSTEM_PROMPT = `\u3053\u306E\u30BB\u30C3\u30B7\u30E7\u30F3\u306F \`claude-t
 - \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 CLAUDE_COMMAND = "claude";
-var HEADROOM_COMMAND = "headroom";
-var HEADROOM_WRAP_OPTIONS = ["--1m", "--memory", "--no-tokensave", "--no-serena"];
-var CONTEXT_1M_SUFFIX = "[1m]";
-function withContext1mSuffix(model) {
-  return model.endsWith(CONTEXT_1M_SUFFIX) ? model : `${model}${CONTEXT_1M_SUFFIX}`;
-}
-function buildClaudeArgs({ mode, prompt, model, effort, headroom }) {
+function buildClaudeArgs({ mode, prompt, model, effort }) {
   return [
     ...mode === "herdr" ? [] : ["-p"],
     prompt,
@@ -1565,28 +1505,16 @@ function buildClaudeArgs({ mode, prompt, model, effort, headroom }) {
     "--append-system-prompt",
     SYSTEM_PROMPT,
     "--model",
-    headroom ? withContext1mSuffix(model) : model,
+    model,
     "--effort",
     effort
   ];
 }
 function buildClaudeExecution(invocation) {
-  const args = buildClaudeArgs(invocation);
-  if (!invocation.headroom) {
-    return { command: CLAUDE_COMMAND, args };
-  }
-  return {
-    command: HEADROOM_COMMAND,
-    args: ["wrap", CLAUDE_COMMAND, ...HEADROOM_WRAP_OPTIONS, "--", ...args]
-  };
+  return { command: CLAUDE_COMMAND, args: buildClaudeArgs(invocation) };
 }
 function buildClaudeEnv(mode) {
-  if (mode === "herdr") {
-    return {
-      CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: CLAUDE_SPAWN_ENV.CLAUDE_CODE_DISABLE_BACKGROUND_TASKS
-    };
-  }
-  return { ...CLAUDE_SPAWN_ENV };
+  return mode === "herdr" ? { CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: CLAUDE_SPAWN_ENV.CLAUDE_CODE_DISABLE_BACKGROUND_TASKS } : { ...CLAUDE_SPAWN_ENV };
 }
 
 // src/config.ts
@@ -1895,7 +1823,25 @@ async function assertRemoteTrackingExists(epicBranch) {
 import { spawn } from "node:child_process";
 import { basename } from "node:path";
 init_table();
-init_task_result();
+
+// src/task-result.ts
+var STDERR_TAIL_LIMIT = 8 * 1024;
+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/user-config.ts
 import { readFileSync as readFileSync2, statSync } from "node:fs";
@@ -1903,7 +1849,6 @@ import { homedir } from "node:os";
 import { isAbsolute as isAbsolute2, join as join2, resolve } from "node:path";
 var RESERVED_ALL = "all";
 var DEFAULT_RUN_MODE = "default";
-var DEFAULT_HEADROOM = false;
 var UserConfigError = class extends Error {
   constructor(message) {
     super(message);
@@ -1952,13 +1897,6 @@ function parseMode(raw, path) {
   console.warn(`[config] invalid mode: ${JSON.stringify(value)} in ${path}, using "${DEFAULT_RUN_MODE}"`);
   return DEFAULT_RUN_MODE;
 }
-function parseHeadroom(raw, path) {
-  if (!("headroom" in raw)) return DEFAULT_HEADROOM;
-  const value = raw["headroom"];
-  if (typeof value === "boolean") return value;
-  console.warn(`[config] invalid headroom: ${JSON.stringify(value)} in ${path}, using ${DEFAULT_HEADROOM}`);
-  return DEFAULT_HEADROOM;
-}
 function loadUserConfig() {
   const path = getUserConfigPath();
   const raw = readRawConfig();
@@ -1975,7 +1913,6 @@ function loadUserConfig() {
     throw new UserConfigError(`config.json "projectGroups" must be an object: ${path}`);
   }
   const mode = parseMode(raw, path);
-  const headroom = parseHeadroom(raw, path);
   const rawProjects = raw["projects"];
   const rawProjectGroups = "projectGroups" in raw ? raw["projectGroups"] : {};
   const projectKeys = Object.keys(rawProjects);
@@ -2026,7 +1963,7 @@ function loadUserConfig() {
     }
     projectGroups[groupName] = members;
   }
-  return { mode, headroom, projects, projectGroups };
+  return { mode, projects, projectGroups };
 }
 var cachedRunMode;
 function getRunMode() {
@@ -2036,35 +1973,18 @@ function getRunMode() {
   return cachedRunMode;
 }
 function readRunMode() {
-  const raw = readTopLevelConfig(`using "${DEFAULT_RUN_MODE}" mode`);
-  if (raw === void 0) return DEFAULT_RUN_MODE;
-  return parseMode(raw, getUserConfigPath());
-}
-var cachedHeadroom;
-function getHeadroomEnabled() {
-  if (cachedHeadroom === void 0) {
-    cachedHeadroom = readHeadroom();
-  }
-  return cachedHeadroom;
-}
-function readHeadroom() {
-  const raw = readTopLevelConfig(`using headroom=${DEFAULT_HEADROOM}`);
-  if (raw === void 0) return DEFAULT_HEADROOM;
-  return parseHeadroom(raw, getUserConfigPath());
-}
-function readTopLevelConfig(fallbackDescription) {
   let raw;
   try {
     raw = readRawConfig();
   } catch (err) {
-    console.warn(`[config] failed to read config file, ${fallbackDescription}: ${err}`);
-    return void 0;
+    console.warn(`[config] failed to read config file, using "${DEFAULT_RUN_MODE}" mode: ${err}`);
+    return DEFAULT_RUN_MODE;
   }
-  if (raw === void 0) return void 0;
+  if (raw === void 0) return DEFAULT_RUN_MODE;
   if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    return void 0;
+    return DEFAULT_RUN_MODE;
   }
-  return raw;
+  return parseMode(raw, getUserConfigPath());
 }
 function findProjectNameByPath(path) {
   let config;
@@ -2182,7 +2102,7 @@ function resolveProjectName(cwd = process.cwd()) {
   if (injected && injected.length > 0) return injected;
   return findProjectNameByPath(cwd) ?? basename(cwd);
 }
-async function runViaHerdr(command, args, id, onComplete, cwd, env) {
+async function runViaHerdr(args, id, onComplete, cwd, env) {
   const { startHerdrTask: startHerdrTask2, stopHerdrTask: stopHerdrTask2, taskTabLabel: taskTabLabel2, waitForHerdrTask: waitForHerdrTask2 } = await Promise.resolve().then(() => (init_herdr_runner(), herdr_runner_exports));
   const { getCurrentWorkspaceId: getCurrentWorkspaceId2 } = await Promise.resolve().then(() => (init_herdr(), herdr_exports));
   const label = taskTabLabel2(resolveProjectName(), id);
@@ -2193,14 +2113,13 @@ async function runViaHerdr(command, args, id, onComplete, cwd, env) {
     task = await startHerdrTask2({
       label,
       cwd: cwd ?? process.cwd(),
-      argv: [command, ...args],
+      args,
       env,
       workspaceId: getCurrentWorkspaceId2()
     });
     herdrTasks.set(id, task);
     result = await waitForHerdrTask2(task.paneId, {
       signal: herdrAbortSignal,
-      headroom: getHeadroomEnabled(),
       onBlocked: () => console.warn(`[worker] #${id} is blocked and waiting for input in herdr tab "${label}"`),
       onStatus: (status) => {
         const task2 = tasks.get(id);
@@ -2230,7 +2149,7 @@ function run(command, args, id, title, workerName, path, onComplete, cwd, env) {
   ensureRenderInterval();
   renderTable();
   if (getRunMode() === "herdr") {
-    void runViaHerdr(command, args, id, onComplete, cwd, env);
+    void runViaHerdr(args, id, onComplete, cwd, env);
     return;
   }
   const child = spawn(command, args, {
@@ -2258,8 +2177,7 @@ function run(command, args, id, title, workerName, path, onComplete, cwd, env) {
     const result = buildTaskResult(
       code,
       Buffer.concat(outputChunks).toString("utf-8"),
-      Buffer.concat(stderrChunks).toString("utf-8").slice(-STDERR_TAIL_LIMIT),
-      { headroom: getHeadroomEnabled() }
+      Buffer.concat(stderrChunks).toString("utf-8").slice(-STDERR_TAIL_LIMIT)
     );
     await finishTask(id, result, onComplete);
     childProcesses.delete(id);
@@ -2972,8 +2890,7 @@ function createIssuePollingWorker(config) {
               mode,
               prompt: `${command} ${issue.number}`,
               model,
-              effort,
-              headroom: getHeadroomEnabled()
+              effort
             });
             let baseBranch = defaultBranch;
             if (parentNumber !== void 0) {
@@ -3144,8 +3061,7 @@ function createPrPollingWorker(config) {
               mode,
               prompt: `${command} ${pr.number}`,
               model,
-              effort,
-              headroom: getHeadroomEnabled()
+              effort
             });
             run(
               execution.command,
@@ -4046,22 +3962,8 @@ async function assertRunModeAvailable() {
   }
   console.log("[worker] run mode: herdr (each task runs as a TUI session in its own herdr tab)");
 }
-async function assertHeadroomAvailable() {
-  if (!getHeadroomEnabled()) return;
-  const { execFile: execFile3 } = await import("node:child_process");
-  const { promisify: promisify4 } = await import("node:util");
-  try {
-    await promisify4(execFile3)(HEADROOM_COMMAND, ["--version"]);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`[worker] config.json has headroom: true but the headroom CLI is unavailable: ${message}`);
-    process.exit(1);
-  }
-  console.log("[worker] headroom: enabled (each task runs as `headroom wrap claude`)");
-}
 async function assertRunPrerequisites() {
   await assertRunModeAvailable();
-  await assertHeadroomAvailable();
 }
 if (!hasProjectFilter()) {
   process.on("SIGTERM", async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-task-worker",
-  "version": "0.37.0",
+  "version": "0.39.0",
   "description": "CLI tool that polls GitHub Issues/PRs and delegates work to Claude CLI",
   "type": "module",
   "main": "dist/index.js",