@taskless-app/swarm 0.6.38 → 0.6.40

package/dist/overmind.js

@@ -1593,7 +1593,7 @@ function buildZoneModel(entries, opts = {}) {
     if (!m) labelVotes.set(z2, m = /* @__PURE__ */ new Map());
     bump(m, manual);
   }
-  const rename2 = /* @__PURE__ */ new Map();
+  const rename3 = /* @__PURE__ */ new Map();
   const takenNames = /* @__PURE__ */ new Set([SPINE_ZONE]);
   const clustersByEvidence = [...labelVotes.entries()].sort((a, b) => {
     const sum = (m) => [...m.values()].reduce((x, y) => x + y, 0);
@@ -1602,11 +1602,11 @@ function buildZoneModel(entries, opts = {}) {
   for (const [zone, votes] of clustersByEvidence) {
     const top = topKey(votes);
     if (!top || top.share < 0.6 || takenNames.has(top.key) || top.key === zone) continue;
-    rename2.set(zone, top.key);
+    rename3.set(zone, top.key);
     takenNames.add(top.key);
   }
-  const renamed = (z2) => rename2.get(z2) ?? z2;
-  if (rename2.size) {
+  const renamed = (z2) => rename3.get(z2) ?? z2;
+  if (rename3.size) {
     for (const [f, z2] of fileZone) fileZone.set(f, renamed(z2));
     for (const [s, z2] of taskZone) taskZone.set(s, renamed(z2));
   }
@@ -2211,10 +2211,94 @@ var init_claudeResult = __esm({
   }
 });
 
-// src/executors/claudeCode.ts
-import { readdirSync as readdirSync2, statSync, writeFileSync as writeFileSync3 } from "fs";
+// src/transcriptSpend.ts
+import { readFileSync as readFileSync3, readdirSync as readdirSync2, statSync } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join3 } from "path";
+function transcriptDir(worktree, projectsDir) {
+  return join3(projectsDir, worktree.replace(/[/.]/g, "-"));
+}
+function transcriptSpendInWindow(worktree, fromMs, toMs, opts = {}) {
+  const projectsDir = opts.projectsDir ?? join3(homedir2(), ".claude", "projects");
+  const empty = { costUsd: 0, tokensIn: 0, tokensOut: 0, durationMs: 0, replies: 0, unpriced: 0, unpricedModel: null };
+  const dir = transcriptDir(worktree, projectsDir);
+  let files;
+  try {
+    files = readdirSync2(dir).filter((f) => f.endsWith(".jsonl"));
+  } catch {
+    return empty;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  let costUsd = 0;
+  let tokensIn = 0;
+  let tokensOut = 0;
+  let firstAt = null;
+  let lastAt = null;
+  let replies = 0;
+  let unpriced = 0;
+  let unpricedModel = null;
+  for (const f of files) {
+    const path = join3(dir, f);
+    let raw;
+    try {
+      if (statSync(path).mtimeMs < fromMs) continue;
+      raw = readFileSync3(path, "utf8");
+    } catch {
+      continue;
+    }
+    for (const line of raw.split("\n")) {
+      if (!line.startsWith("{") || !line.includes('"usage"')) continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (entry.type !== "assistant") continue;
+      const usage = entry.message?.usage;
+      if (!usage) continue;
+      const at = entry.timestamp ? Date.parse(entry.timestamp) : NaN;
+      if (!Number.isFinite(at) || at < fromMs || at >= toMs) continue;
+      const key = entry.requestId ?? entry.message?.id ?? entry.uuid;
+      if (!key || seen.has(key)) continue;
+      seen.add(key);
+      const model = entry.message?.model ?? null;
+      const est = costFromUsage(usage, model, opts.table);
+      costUsd += est.costUsd;
+      if (est.warning) {
+        unpriced += 1;
+        unpricedModel ??= model;
+      }
+      const num = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
+      tokensIn += num(usage.input_tokens) + num(usage.cache_creation_input_tokens) + num(usage.cache_read_input_tokens);
+      tokensOut += num(usage.output_tokens);
+      if (firstAt === null || at < firstAt) firstAt = at;
+      if (lastAt === null || at > lastAt) lastAt = at;
+      replies += 1;
+    }
+  }
+  if (replies === 0) return empty;
+  return {
+    costUsd,
+    tokensIn,
+    tokensOut,
+    durationMs: firstAt !== null && lastAt !== null ? lastAt - firstAt : 0,
+    replies,
+    unpriced,
+    unpricedModel
+  };
+}
+var init_transcriptSpend = __esm({
+  "src/transcriptSpend.ts"() {
+    "use strict";
+    init_pricing();
+  }
+});
+
+// src/executors/claudeCode.ts
+import { readdirSync as readdirSync3, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
 function claudeArgs(cfgPath, prompt, continueSession = false, model, pluginDirs = [], settings, maxBudgetUsd, effort) {
   const pluginFlags = pluginDirs.flatMap((dir) => ["--plugin-dir", dir]);
   const budgetFlags = typeof maxBudgetUsd === "number" && maxBudgetUsd > 0 ? ["--max-budget-usd", String(maxBudgetUsd)] : [];
@@ -2246,21 +2330,21 @@ function droneSettingsJson(paths, mergeGateHook = null) {
   if (mergeGateHook) settings.hooks = { PreToolUse: [{ matcher: "Bash", hooks: [{ type: "command", command: mergeGateHook }] }] };
   return JSON.stringify(settings);
 }
-function transcriptDir(worktree, projectsDir) {
-  return join3(projectsDir, worktree.replace(/[/.]/g, "-"));
+function transcriptDir2(worktree, projectsDir) {
+  return join4(projectsDir, worktree.replace(/[/.]/g, "-"));
 }
-function sessionTranscriptExists(worktree, projectsDir = join3(homedir2(), ".claude", "projects")) {
+function sessionTranscriptExists(worktree, projectsDir = join4(homedir3(), ".claude", "projects")) {
   try {
-    return readdirSync2(transcriptDir(worktree, projectsDir)).some((f) => f.endsWith(".jsonl"));
+    return readdirSync3(transcriptDir2(worktree, projectsDir)).some((f) => f.endsWith(".jsonl"));
   } catch {
     return false;
   }
 }
-function transcriptMtimeMs(worktree, projectsDir = join3(homedir2(), ".claude", "projects")) {
-  const dir = transcriptDir(worktree, projectsDir);
+function transcriptMtimeMs(worktree, projectsDir = join4(homedir3(), ".claude", "projects")) {
+  const dir = transcriptDir2(worktree, projectsDir);
   let files;
   try {
-    files = readdirSync2(dir);
+    files = readdirSync3(dir);
   } catch {
     return null;
   }
@@ -2268,7 +2352,7 @@ function transcriptMtimeMs(worktree, projectsDir = join3(homedir2(), ".claude",
   for (const f of files) {
     if (!f.endsWith(".jsonl")) continue;
     try {
-      const mtime2 = statSync(join3(dir, f)).mtimeMs;
+      const mtime2 = statSync2(join4(dir, f)).mtimeMs;
       if (latest === null || mtime2 > latest) latest = mtime2;
     } catch {
     }
@@ -2281,7 +2365,7 @@ function writeMcpConfig(spec) {
       [spec.mcp.name]: { command: spec.mcp.command, args: spec.mcp.args, env: spec.mcp.env }
     }
   };
-  const path = join3(spec.worktree, MCP_CONFIG_FILE);
+  const path = join4(spec.worktree, MCP_CONFIG_FILE);
   writeFileSync3(path, JSON.stringify(cfg, null, 2));
   return path;
 }
@@ -2296,6 +2380,7 @@ var init_claudeCode = __esm({
     init_swarmFiles();
     init_mergeGateHook();
     init_claudeResult();
+    init_transcriptSpend();
     ISOLATION_FLAGS = ["--setting-sources", "project", "--strict-mcp-config"];
     MCP_CONFIG_FILE = SWARM_MCP_CONFIG_FILE;
     claudeCodeExecutor = {
@@ -2334,6 +2419,26 @@ var init_claudeCode = __esm({
           ...abortField(sessionAbort(result))
         };
       },
+      // TASWM-548: итога нет — берём трату из транскрипта сессии. Тот пишется по ходу работы и
+      // переживает SIGTERM разгрузки, из-за которого итог и не был напечатан; формат usage там
+      // тот же, что в итоге, поэтому цена считается тем же прайсингом (см. transcriptSpend.ts).
+      rescueSpend(worktree, fromMs, toMs) {
+        const spend = transcriptSpendInWindow(worktree, fromMs, toMs);
+        if (spend.replies === 0) return null;
+        return {
+          costUsd: spend.costUsd,
+          tokensIn: spend.tokensIn,
+          tokensOut: spend.tokensOut,
+          durationMs: spend.durationMs,
+          // Часть ответов не по чему было тарифицировать (модели нет в MODEL_PRICING) — их
+          // токены в трату вошли, а деньги НЕТ. Тот же канал, что и у warning штатного итога
+          // (cost.accountRunCost его печатает): иначе спасённые $0 при сожжённых токенах
+          // выглядели бы как честный ноль.
+          ...spend.unpriced > 0 ? {
+            warning: `\u0437\u0430\u043F\u0438\u0441\u044C \u0441\u0435\u0441\u0441\u0438\u0438: ${spend.unpriced} \u0438\u0437 ${spend.replies} \u043E\u0442\u0432\u0435\u0442\u043E\u0432 \u0431\u0435\u0437 \u0441\u0442\u0440\u043E\u043A\u0438 \u0432 \u043F\u0440\u0430\u0439\u0441\u0438\u043D\u0433\u0435 (\u043C\u043E\u0434\u0435\u043B\u044C "${spend.unpricedModel ?? ""}") \u2014 \u0438\u0445 \u0446\u0435\u043D\u0430 \u0432 \u0441\u043F\u0430\u0441\u0451\u043D\u043D\u0443\u044E \u0442\u0440\u0430\u0442\u0443 \u041D\u0415 \u0432\u043E\u0448\u043B\u0430`
+          } : {}
+        };
+      },
       session: {
         exists: (worktree) => sessionTranscriptExists(worktree),
         mtimeMs: (worktree) => transcriptMtimeMs(worktree)
@@ -2351,34 +2456,34 @@ var init_claudeCode = __esm({
 });
 
 // src/swarmHome.ts
-import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+import { join as join5 } from "path";
 import { mkdirSync as mkdirSync2 } from "fs";
 var SWARM_HOME;
 var init_swarmHome = __esm({
   "src/swarmHome.ts"() {
     "use strict";
-    SWARM_HOME = process.env.SWARM_HOME || join4(homedir3(), ".taskless-swarm");
+    SWARM_HOME = process.env.SWARM_HOME || join5(homedir4(), ".taskless-swarm");
     mkdirSync2(SWARM_HOME, { recursive: true });
   }
 });
 
 // src/executors/codex.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync3, statSync as statSync2, symlinkSync } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync4, statSync as statSync3, symlinkSync } from "fs";
+import { join as join6 } from "path";
 function resolveCodexBin(env = process.env) {
   return (env.SWARM_CODEX_BIN ?? "").trim() || "codex";
 }
 function codexHomePath(worktree, swarmHome = SWARM_HOME) {
-  return join5(swarmHome, "executor-state", "codex", worktree.replace(/[/.]/g, "-"));
+  return join6(swarmHome, "executor-state", "codex", worktree.replace(/[/.]/g, "-"));
 }
 function ensureCodexHome(worktree, realHome, env = process.env, swarmHome = SWARM_HOME) {
   const home = codexHomePath(worktree, swarmHome);
   mkdirSync3(home, { recursive: true });
-  const real = (env.CODEX_HOME ?? "").trim() || join5(realHome, ".codex");
+  const real = (env.CODEX_HOME ?? "").trim() || join6(realHome, ".codex");
   for (const file of ["auth.json", "config.toml"]) {
-    const target = join5(real, file);
-    const link2 = join5(home, file);
+    const target = join6(real, file);
+    const link2 = join6(home, file);
     if (!existsSync4(target) || existsSync4(link2)) continue;
     try {
       symlinkSync(target, link2);
@@ -2437,16 +2542,16 @@ function parseCodexStream(raw) {
 function newestRolloutMtime(dir, depth = 4) {
   let entries;
   try {
-    entries = readdirSync3(dir);
+    entries = readdirSync4(dir);
   } catch {
     return null;
   }
   let latest = null;
   for (const name of entries) {
-    const full = join5(dir, name);
+    const full = join6(dir, name);
     let st;
     try {
-      st = statSync2(full);
+      st = statSync3(full);
     } catch {
       continue;
     }
@@ -2517,8 +2622,8 @@ ${notice}` : spec.prompt;
         return est.warning ? { costUsd: est.costUsd, warning: est.warning } : { costUsd: est.costUsd };
       },
       session: {
-        exists: (worktree) => newestRolloutMtime(join5(codexHomePath(worktree), "sessions")) !== null,
-        mtimeMs: (worktree) => newestRolloutMtime(join5(codexHomePath(worktree), "sessions"))
+        exists: (worktree) => newestRolloutMtime(join6(codexHomePath(worktree), "sessions")) !== null,
+        mtimeMs: (worktree) => newestRolloutMtime(join6(codexHomePath(worktree), "sessions"))
       },
       probe: {
         // Тот же принцип, что у claude: дешёвый реальный прогон — он проверяет и auth, и живость
@@ -2666,8 +2771,8 @@ __export(config_exports, {
   restEndpoint: () => restEndpoint,
   reviewCutoffAt: () => reviewCutoffAt
 });
-import { basename, join as join6, resolve } from "path";
-import { readFileSync as readFileSync3, realpathSync, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "fs";
+import { basename, join as join7, resolve } from "path";
+import { readFileSync as readFileSync4, realpathSync, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "fs";
 function normalizeRepo(repo) {
   const r = (repo ?? "").trim();
   if (!r) return "";
@@ -2681,10 +2786,10 @@ function effectiveRepoOf(repo, fallback) {
   return normalizeRepo(repo || fallback || "");
 }
 function droneWorktreePath(worktreesDir, repo, slug) {
-  return join6(droneWorktreeRoot(worktreesDir, repo), slug);
+  return join7(droneWorktreeRoot(worktreesDir, repo), slug);
 }
 function droneWorktreeRoot(worktreesDir, repo) {
-  return join6(worktreesDir, basename(normalizeRepo(repo)));
+  return join7(worktreesDir, basename(normalizeRepo(repo)));
 }
 function resolveEffectiveWorktreesDir(deps) {
   if (deps.envOverride) return deps.envOverride;
@@ -2732,14 +2837,14 @@ function mcpEndpoint(api, path = TASKLESS_MCP_PATH) {
 }
 function tokenFromFile() {
   try {
-    return readFileSync3(join6(SWARM_HOME, "token"), "utf8").trim();
+    return readFileSync4(join7(SWARM_HOME, "token"), "utf8").trim();
   } catch {
     return "";
   }
 }
 function reviewCutoffAt() {
   try {
-    const raw = JSON.parse(readFileSync3(REVIEW_CUTOFF_PATH, "utf8"));
+    const raw = JSON.parse(readFileSync4(REVIEW_CUTOFF_PATH, "utf8"));
     if (raw.at) return raw.at;
   } catch {
   }
@@ -2760,25 +2865,25 @@ var init_config = __esm({
     init_executors();
     init_swarmHome();
     init_swarmHome();
-    DB_PATH = process.env.SWARM_DB || join6(SWARM_HOME, "swarm.db");
+    DB_PATH = process.env.SWARM_DB || join7(SWARM_HOME, "swarm.db");
     EXECUTOR = resolveExecutor(process.env.SWARM_EXECUTOR);
-    DRONE_HOME = process.env.SWARM_DRONE_HOME || join6(SWARM_HOME, "drone-home");
+    DRONE_HOME = process.env.SWARM_DRONE_HOME || join7(SWARM_HOME, "drone-home");
     DRONE_HOME_ISOLATION = process.env.SWARM_DRONE_ISOLATE_HOME !== "0" && process.platform !== "win32";
     DRONE_ISOLATION = DRONE_HOME_ISOLATION ? { home: DRONE_HOME, swarmHome: SWARM_HOME } : void 0;
-    WORKTREES_NOINDEX_DIR = join6(SWARM_HOME, "worktrees.noindex");
-    WORKTREES_LEGACY_DIR = join6(SWARM_HOME, "worktrees");
+    WORKTREES_NOINDEX_DIR = join7(SWARM_HOME, "worktrees.noindex");
+    WORKTREES_LEGACY_DIR = join7(SWARM_HOME, "worktrees");
     WORKTREES_DIR = process.env.SWARM_WORKTREES || WORKTREES_NOINDEX_DIR;
-    RUN_LOGS_DIR = process.env.SWARM_RUN_LOGS || join6(SWARM_HOME, "run-logs");
-    DAEMON_LOG_PATH = process.env.SWARM_DAEMON_LOG || join6(SWARM_HOME, "overmind.log");
+    RUN_LOGS_DIR = process.env.SWARM_RUN_LOGS || join7(SWARM_HOME, "run-logs");
+    DAEMON_LOG_PATH = process.env.SWARM_DAEMON_LOG || join7(SWARM_HOME, "overmind.log");
     DAEMON_LOG_MAX_BYTES = envNum("SWARM_DAEMON_LOG_MAX_BYTES", 16 * 1024 * 1024);
     DAEMON_LOG_KEEP = envNum("SWARM_DAEMON_LOG_KEEP", 2);
     DAEMON_LOG_CHECK_MS = envNum("SWARM_DAEMON_LOG_CHECK_MS", 6e4);
     DIST_BUILD = true;
     SWARM_BACKEND = process.env.SWARM_BACKEND === "client" ? "client" : process.env.SWARM_BACKEND === "sqlite" ? "sqlite" : DIST_BUILD ? "client" : "sqlite";
-    SWARM_OUTBOX = process.env.SWARM_OUTBOX || join6(SWARM_HOME, "outbox.jsonl");
+    SWARM_OUTBOX = process.env.SWARM_OUTBOX || join7(SWARM_HOME, "outbox.jsonl");
     SWARM_MAX_IN_FLIGHT = Math.trunc(envNum("SWARM_MAX_IN_FLIGHT", 3));
     SWARM_CLAIM_INTERVAL_MS = envNum("SWARM_CLAIM_INTERVAL_MS", 6e4);
-    ENV_CACHE_DIR = process.env.SWARM_ENV_CACHE_DIR || join6(SWARM_HOME, "env-cache");
+    ENV_CACHE_DIR = process.env.SWARM_ENV_CACHE_DIR || join7(SWARM_HOME, "env-cache");
     ENV_CACHE_ENABLED = process.env.SWARM_ENV_CACHE !== "0";
     ENV_CACHE_KEEP = Math.trunc(envNum("SWARM_ENV_CACHE_KEEP", 4));
     SWARM_MAX_LOAD_FACTOR = envNum("SWARM_MAX_LOAD_FACTOR", 0.9);
@@ -2808,15 +2913,15 @@ var init_config = __esm({
     DRONE_CHANNEL_ENABLED = process.env.SWARM_DRONE_CHANNEL !== "0";
     DRONE_CHANNEL_PORT = Number(process.env.SWARM_DRONE_CHANNEL_PORT) || 7421;
     DRONE_CHANNEL_URL = process.env.SWARM_DRONE_CHANNEL_URL || `http://127.0.0.1:${DRONE_CHANNEL_PORT}`;
-    DRONE_CHANNEL_SECRET_PATH = process.env.SWARM_DRONE_CHANNEL_SECRET || join6(SWARM_HOME, "drone-channel.key");
+    DRONE_CHANNEL_SECRET_PATH = process.env.SWARM_DRONE_CHANNEL_SECRET || join7(SWARM_HOME, "drone-channel.key");
     DRONE_CHANNEL_GRACE_MS = envNum("SWARM_DRONE_CHANNEL_GRACE_MS", 12e4);
-    HEARTBEAT_PATH = process.env.SWARM_HEARTBEAT || join6(SWARM_HOME, "overmind.heartbeat");
+    HEARTBEAT_PATH = process.env.SWARM_HEARTBEAT || join7(SWARM_HOME, "overmind.heartbeat");
     HEARTBEAT_STALE_MS = Number(process.env.SWARM_HEARTBEAT_STALE_MS) || 3e4;
     SWARM_REPO = process.env.SWARM_REPO || "";
     SWARM_SCAN_DEPTH = Number(process.env.SWARM_SCAN_DEPTH) || 3;
     SWARM_REPO_PATHS = (process.env.SWARM_REPOS || SWARM_REPO).split(",").map((s) => s.trim()).filter(Boolean);
     SWARM_SCAN_ROOTS_RAW = process.env.SWARM_SCAN_ROOTS || "";
-    REPO_MAP_PATH = process.env.SWARM_REPO_MAP || join6(SWARM_HOME, "repo-map.json");
+    REPO_MAP_PATH = process.env.SWARM_REPO_MAP || join7(SWARM_HOME, "repo-map.json");
     SWARM_REPO_MAP_MS = envNum("SWARM_REPO_MAP_MS", 15 * 6e4);
     SWARM_REPO_SCAN_TTL_MS = envNum("SWARM_REPO_SCAN_TTL_MS", 24 * 60 * 6e4);
     TASKLESS_API = process.env.TASKLESS_API || "https://taskless.ru";
@@ -2831,7 +2936,7 @@ var init_config = __esm({
     SWARM_AUTO_REVIEW = process.env.SWARM_AUTO_REVIEW !== "0";
     SWARM_AUTO_VERIFY = process.env.SWARM_AUTO_VERIFY !== "0";
     SWARM_MERGE_QUEUE = process.env.SWARM_MERGE_QUEUE !== "0";
-    REVIEW_CUTOFF_PATH = process.env.SWARM_REVIEW_CUTOFF || join6(SWARM_HOME, "review-cutoff.json");
+    REVIEW_CUTOFF_PATH = process.env.SWARM_REVIEW_CUTOFF || join7(SWARM_HOME, "review-cutoff.json");
     SWARM_REVIEW_CAP = Math.trunc(envNum("SWARM_REVIEW_CAP", 1));
     SWARM_STORM_URL = process.env.SWARM_STORM_URL || "";
     WEB_PORT = Number(process.env.SWARM_WEB_PORT) || 7420;
@@ -2871,7 +2976,7 @@ var init_quietExec = __esm({
 
 // src/resources.ts
 import os from "os";
-import { readFileSync as readFileSync4, statfsSync } from "fs";
+import { readFileSync as readFileSync5, statfsSync } from "fs";
 function isTransientResourceError(e) {
   const code = e?.code;
   return code === "ENFILE" || code === "EMFILE" || code === "EAGAIN";
@@ -2929,7 +3034,7 @@ function fileDescriptorLoadRatio() {
   }
   if (process.platform === "linux") {
     try {
-      const [allocated, , max] = readFileSync4("/proc/sys/fs/file-nr", "utf8").trim().split(/\s+/).map(Number);
+      const [allocated, , max] = readFileSync5("/proc/sys/fs/file-nr", "utf8").trim().split(/\s+/).map(Number);
       if (Number.isFinite(allocated ?? NaN) && Number.isFinite(max ?? NaN) && max) return allocated / max;
     } catch {
     }
@@ -3031,6 +3136,14 @@ function hostResourcesOk() {
 function reliefDecision(r, minFreeGb = SWARM_RELIEF_MIN_FREE_GB, maxCpuBusy = SWARM_RELIEF_CPU_BUSY, maxFdLoadFactor = SWARM_RELIEF_MAX_FD_LOAD_FACTOR) {
   const cores = r.cpus > 0 ? r.cpus : 1;
   const pct = (v) => `${Math.round(v * 100)}%`;
+  const pctPair = (v, threshold) => {
+    for (const digits of [0, 1, 2, 3, 4]) {
+      const a = (v * 100).toFixed(digits);
+      const b = (threshold * 100).toFixed(digits);
+      if (a !== b) return `${a}% \u043F\u0440\u0438 \u043F\u043E\u0440\u043E\u0433\u0435 ${b}%`;
+    }
+    return `${pct(v)} \u043F\u0440\u0438 \u043F\u043E\u0440\u043E\u0433\u0435 ${pct(threshold)}`;
+  };
   const signals = [];
   signals.push(
     r.cpuBusy == null ? {
@@ -3039,7 +3152,7 @@ function reliefDecision(r, minFreeGb = SWARM_RELIEF_MIN_FREE_GB, maxCpuBusy = SW
       tripped: false
     } : {
       key: "cpu",
-      text: `CPU \u0437\u0430\u043D\u044F\u0442 ${pct(r.cpuBusy)} \u043F\u0440\u0438 \u043F\u043E\u0440\u043E\u0433\u0435 ${pct(maxCpuBusy)}`,
+      text: `CPU \u0437\u0430\u043D\u044F\u0442 ${pctPair(r.cpuBusy, maxCpuBusy)}`,
       tripped: r.cpuBusy > maxCpuBusy
     }
   );
@@ -3051,7 +3164,7 @@ function reliefDecision(r, minFreeGb = SWARM_RELIEF_MIN_FREE_GB, maxCpuBusy = SW
   signals.push(
     r.fdLoadRatio == null ? { key: "fd", text: "\u0434\u0435\u0441\u043A\u0440\u0438\u043F\u0442\u043E\u0440\u044B: \u0438\u0437\u043C\u0435\u0440\u0438\u0442\u044C \u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C", tripped: false } : {
       key: "fd",
-      text: `\u0434\u0435\u0441\u043A\u0440\u0438\u043F\u0442\u043E\u0440\u044B \u0437\u0430\u043D\u044F\u0442\u044B ${pct(r.fdLoadRatio)} \u043F\u0440\u0438 \u043F\u043E\u0440\u043E\u0433\u0435 ${pct(maxFdLoadFactor)}`,
+      text: `\u0434\u0435\u0441\u043A\u0440\u0438\u043F\u0442\u043E\u0440\u044B \u0437\u0430\u043D\u044F\u0442\u044B ${pctPair(r.fdLoadRatio, maxFdLoadFactor)}`,
       tripped: r.fdLoadRatio > maxFdLoadFactor
     }
   );
@@ -3335,11 +3448,11 @@ var init_zoneNotes = __esm({
 });
 
 // src/agentToken.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, unlinkSync as unlinkSync2 } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, unlinkSync as unlinkSync2 } from "fs";
+import { join as join8 } from "path";
 function loadAgentToken() {
   try {
-    const s = JSON.parse(readFileSync5(STORE_PATH, "utf8"));
+    const s = JSON.parse(readFileSync6(STORE_PATH, "utf8"));
     return s.token ? s : null;
   } catch {
     return null;
@@ -3392,7 +3505,7 @@ var init_agentToken = __esm({
   "src/agentToken.ts"() {
     "use strict";
     init_config();
-    STORE_PATH = join7(SWARM_HOME, "agent.json");
+    STORE_PATH = join8(SWARM_HOME, "agent.json");
     base = (api) => api.replace(/\/$/, "");
     TOKEN_PROBE_TIMEOUT_MS = 8e3;
   }
@@ -3506,7 +3619,7 @@ var init_toolFailure = __esm({
 });
 
 // src/heartbeat.ts
-import { readFileSync as readFileSync7, renameSync as renameSync4, writeFileSync as writeFileSync7 } from "fs";
+import { readFileSync as readFileSync8, renameSync as renameSync4, writeFileSync as writeFileSync7 } from "fs";
 function writeHeartbeat(path, now) {
   const tmp = `${path}.tmp`;
   writeFileSync7(tmp, String(now));
@@ -3514,7 +3627,7 @@ function writeHeartbeat(path, now) {
 }
 function readHeartbeat(path) {
   try {
-    const ms = Number(readFileSync7(path, "utf8").trim());
+    const ms = Number(readFileSync8(path, "utf8").trim());
     return Number.isFinite(ms) ? ms : null;
   } catch {
     return null;
@@ -3782,7 +3895,7 @@ var init_procList = __esm({
 
 // src/procCleanup.ts
 function sleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 function parseLsofCwd(output) {
   const rows = [];
@@ -4000,9 +4113,9 @@ var init_procCleanup = __esm({
 });
 
 // src/git.ts
-import { existsSync as existsSync12, readdirSync as readdirSync11, statSync as statSync8 } from "fs";
-import { appendFile, chmod, mkdir, readFile, rm, writeFile } from "fs/promises";
-import { isAbsolute as isAbsolute2, join as join19, sep as sep2 } from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync12, realpathSync as realpathSync2, statSync as statSync10 } from "fs";
+import { appendFile, chmod, mkdir, readFile, rename, rm, writeFile } from "fs/promises";
+import { isAbsolute as isAbsolute2, join as join20, resolve as resolve3, sep as sep2 } from "path";
 import { $ as $2 } from "execa";
 function gitNet(repo, args, timeoutMs) {
   return withHardTimeout(
@@ -4023,9 +4136,75 @@ function isUnrecoverableRefError(e) {
 async function reclaimStaleWorktree(repo, worktree) {
   await detachWorktree(repo, worktree);
 }
+async function inspectWorktreePath(path) {
+  if (!existsSync12(path)) return "free";
+  try {
+    if (readdirSync12(path).length === 0) return "free";
+  } catch {
+    return "orphan";
+  }
+  try {
+    if (statSync10(join20(path, ".git")).isDirectory()) return "main-checkout";
+  } catch {
+  }
+  const top = await $2({ reject: false })`git -C ${path} rev-parse --show-toplevel`;
+  return top.exitCode === 0 && samePath(top.stdout.trim(), path) ? "worktree" : "orphan";
+}
+function samePath(a, b) {
+  const norm = (p) => {
+    try {
+      return realpathSync2(p);
+    } catch {
+      return resolve3(p);
+    }
+  };
+  const [x, y] = [norm(a), norm(b)];
+  return process.platform === "win32" ? posix(x).toLowerCase() === posix(y).toLowerCase() : x === y;
+}
+async function clearWorktreePath(repo, path, branch, opts = {}) {
+  const holder = await inspectWorktreePath(path);
+  if (holder === "free") return;
+  if (holder === "main-checkout") {
+    throw new WorktreeBusyError(
+      branch,
+      path,
+      `\u043F\u043E \u043F\u0443\u0442\u0438 worktree ${path} \u043B\u0435\u0436\u0438\u0442 \u041E\u0421\u041D\u041E\u0412\u041D\u041E\u0419 \u0447\u0435\u043A\u0430\u0443\u0442 \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u044F (\`.git\` \u2014 \u043A\u0430\u0442\u0430\u043B\u043E\u0433, \u0430 \u043D\u0435 \u0444\u0430\u0439\u043B) \u2014 \u044F \u0435\u0433\u043E \u043D\u0435 \u0442\u0440\u043E\u0433\u0430\u044E. \u041F\u043E\u0445\u043E\u0436\u0435, \u043A\u0430\u0442\u0430\u043B\u043E\u0433 worktree'\u0435\u0432 \u0440\u043E\u044F \u043D\u0430\u0441\u0442\u0440\u043E\u0435\u043D \u043D\u0430 \u0440\u0430\u0431\u043E\u0447\u0443\u044E \u043A\u043E\u043F\u0438\u044E \u0447\u0435\u043B\u043E\u0432\u0435\u043A\u0430; \u043F\u043E\u043F\u0440\u0430\u0432\u044C\u0442\u0435 \u043F\u0443\u0442\u044C, \u0441\u043F\u0430\u0432\u043D \u0442\u0443\u0434\u0430 \u0437\u0430\u0441\u0435\u043B\u044F\u0442\u044C\u0441\u044F \u043D\u0435 \u0431\u0443\u0434\u0435\u0442.`
+    );
+  }
+  if (holder === "worktree") {
+    if (opts.isWorktreeHeldLive ? await opts.isWorktreeHeldLive(path) : true) throw new WorktreeBusyError(branch, path);
+    if (await worktreeDirty(path)) {
+      throw new WorktreeBusyError(
+        branch,
+        path,
+        `worktree ${path} \u043E\u0441\u0438\u0440\u043E\u0442\u0435\u043B, \u043D\u043E \u0432\u043D\u0443\u0442\u0440\u0438 \u0435\u0441\u0442\u044C \u043D\u0435\u0441\u0434\u0430\u043D\u043D\u0430\u044F \u0440\u0430\u0431\u043E\u0442\u0430 (\u043D\u0435\u0437\u0430\u043A\u043E\u043C\u043C\u0438\u0447\u0435\u043D\u043D\u043E\u0435 \u0438\u043B\u0438 \u043D\u0435\u0437\u0430\u043F\u0443\u0448\u0435\u043D\u043D\u043E\u0435) \u2014 \u043D\u0435 \u0441\u043D\u043E\u0448\u0443. \u041F\u043E\u0441\u043C\u043E\u0442\u0440\u0438\u0442\u0435 \u0441\u0430\u043C\u0438 (\`git -C ${path} status --untracked-files=all\`) \u0438 \u0443\u0431\u0435\u0440\u0438\u0442\u0435 \u043A\u0430\u0442\u0430\u043B\u043E\u0433, \u043A\u043E\u0433\u0434\u0430 \u0431\u0443\u0434\u0435\u0442 \u043D\u0435 \u0436\u0430\u043B\u043A\u043E.`
+      );
+    }
+    await detachWorktree(repo, path);
+    opts.onStaleReclaim?.(path);
+  }
+  if (!existsSync12(path)) return;
+  await parkOrphanDir(repo, path, branch);
+}
+async function parkOrphanDir(repo, path, branch) {
+  const parked = `${path}.orphan-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+  try {
+    await rename(path, parked);
+  } catch (e) {
+    throw new WorktreeBusyError(
+      branch,
+      path,
+      `\u043F\u0443\u0442\u044C ${path} \u0437\u0430\u043D\u044F\u0442 \u043F\u043E\u0441\u0442\u043E\u0440\u043E\u043D\u043D\u0438\u043C \u043A\u0430\u0442\u0430\u043B\u043E\u0433\u043E\u043C, \u0438 \u043E\u0442\u043E\u0434\u0432\u0438\u043D\u0443\u0442\u044C \u0435\u0433\u043E \u043D\u0435 \u0432\u044B\u0448\u043B\u043E (${String(e)}) \u2014 \u0441\u043F\u0430\u0432\u043D ${branch} \u0442\u0443\u0434\u0430 \u043D\u0435 \u0432\u0441\u0442\u0430\u043D\u0435\u0442. \u0423\u0431\u0435\u0440\u0438\u0442\u0435 \u043A\u0430\u0442\u0430\u043B\u043E\u0433 \u0440\u0443\u043A\u0430\u043C\u0438 \u0438 \u0441\u0434\u0435\u043B\u0430\u0439\u0442\u0435 \`git -C ${repo} worktree prune\`.`
+    );
+  }
+  console.error(
+    `[git] \u043F\u043E \u043F\u0443\u0442\u0438 worktree ${path} \u043B\u0435\u0436\u0430\u043B \u043A\u0430\u0442\u0430\u043B\u043E\u0433, \u043A\u043E\u0442\u043E\u0440\u044B\u0439 git \u0441\u0432\u043E\u0438\u043C \u0440\u0430\u0431\u043E\u0447\u0438\u043C \u0434\u0435\u0440\u0435\u0432\u043E\u043C \u043D\u0435 \u0441\u0447\u0438\u0442\u0430\u0435\u0442 \u2014 \u043E\u0442\u043E\u0434\u0432\u0438\u043D\u0443\u043B \u0432 ${parked}, \u0447\u0442\u043E\u0431\u044B \u0441\u043F\u0430\u0432\u043D ${branch} \u043F\u043E\u0434\u043D\u044F\u043B\u0441\u044F. \u041F\u043E\u0441\u043C\u043E\u0442\u0440\u0438\u0442\u0435, \u0447\u0442\u043E \u0432\u043D\u0443\u0442\u0440\u0438, \u0438 \u0443\u0434\u0430\u043B\u0438\u0442\u0435, \u0435\u0441\u043B\u0438 \u043D\u0435 \u043D\u0443\u0436\u043D\u043E.`
+  );
+  await $2({ reject: false })`git -C ${repo} worktree prune`;
+}
 function isLinkedWorktree(dir) {
   try {
-    return statSync8(join19(dir, ".git")).isFile();
+    return statSync10(join20(dir, ".git")).isFile();
   } catch {
     return false;
   }
@@ -4095,6 +4274,7 @@ async function checkoutWorktree(repo, path, branch, opts) {
   const originSha = await revParse(repo, `refs/remotes/origin/${branch}`);
   if (!localSha && !originSha) {
     const freshBase = opts.base ?? await freshWorktreeBase(repo);
+    await clearWorktreePath(repo, path, branch, opts);
     await $2`git -C ${repo} worktree add -b ${branch} ${path} ${freshBase}`;
     return { reused: false };
   }
@@ -4107,6 +4287,7 @@ async function checkoutWorktree(repo, path, branch, opts) {
     await reclaimStaleWorktree(repo, busyAt);
     opts.onStaleReclaim?.(busyAt);
   }
+  await clearWorktreePath(repo, path, branch, opts);
   if (originSha) {
     await $2`git -C ${repo} worktree add -B ${branch} ${path} ${`origin/${branch}`}`;
     return { reused: true, from: "origin", sha: originSha };
@@ -4135,8 +4316,8 @@ async function ensureGitExcluded(worktree, pattern) {
   try {
     const commonDir = await gitPath(worktree, "--git-common-dir");
     if (!commonDir) return false;
-    const infoDir = join19(commonDir, "info");
-    const excludeFile = join19(infoDir, "exclude");
+    const infoDir = join20(commonDir, "info");
+    const excludeFile = join20(infoDir, "exclude");
     let current = "";
     try {
       current = await readFile(excludeFile, "utf8");
@@ -4156,7 +4337,7 @@ async function gitPath(worktree, flag) {
   const out = await $2({ reject: false })`git -C ${worktree} rev-parse ${flag}`;
   const raw = out.stdout.trim();
   if (out.exitCode !== 0 || !raw) return null;
-  return isAbsolute2(raw) ? raw : join19(worktree, raw);
+  return isAbsolute2(raw) ? raw : join20(worktree, raw);
 }
 async function ensureWorktreeHygiene(worktree) {
   for (const pattern of SWARM_EXCLUDE_PATTERNS) await ensureGitExcluded(worktree, pattern);
@@ -4166,12 +4347,12 @@ async function installGuardHooks(worktree) {
   try {
     const gitDir = await gitPath(worktree, "--git-dir");
     if (!gitDir) return false;
-    const hooksDir = join19(gitDir, "swarm-hooks");
+    const hooksDir = join20(gitDir, "swarm-hooks");
     const prev = await previousHooksPath(worktree);
     await mkdir(hooksDir, { recursive: true });
     for (const hook of GUARD_HOOKS) {
-      await writeFile(join19(hooksDir, hook), guardHookScript(hook, prev ? `${posix(prev)}/${hook}` : null));
-      await chmod(join19(hooksDir, hook), 493);
+      await writeFile(join20(hooksDir, hook), guardHookScript(hook, prev ? `${posix(prev)}/${hook}` : null));
+      await chmod(join20(hooksDir, hook), 493);
     }
     await $2`git -C ${worktree} config extensions.worktreeConfig true`;
     await $2`git -C ${worktree} config --worktree core.hooksPath ${posix(hooksDir)}`;
@@ -4190,7 +4371,7 @@ async function previousHooksPath(worktree) {
     if (out.exitCode === 0 && value) return value;
   }
   const commonDir = await gitPath(worktree, "--git-common-dir");
-  return commonDir ? join19(commonDir, "hooks") : null;
+  return commonDir ? join20(commonDir, "hooks") : null;
 }
 async function removeWorktree(repo, path) {
   const branch = (await $2({ reject: false })`git -C ${path} symbolic-ref --quiet --short HEAD`).stdout.trim();
@@ -4215,7 +4396,7 @@ async function worktreeDirty(path) {
 async function repairMovedWorktrees(targetDir) {
   const subdirs = (dir) => {
     try {
-      return readdirSync11(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join19(dir, d.name));
+      return readdirSync12(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join20(dir, d.name));
     } catch {
       return [];
     }
@@ -4258,10 +4439,11 @@ async function journalForBranch(repo, branch, slug) {
   const out = await $2({ reject: false })`git -C ${repo} show ${`origin/${branch}:journal/${slug}.md`}`;
   return out.exitCode === 0 && out.stdout ? out.stdout : null;
 }
-async function prepareDetachedWorktree(repo, branch, worktree) {
+async function prepareDetachedWorktree(repo, branch, worktree, opts = {}) {
   await gitNetStrict(repo, ["fetch", "--quiet", "origin"], GIT_HEAVY_NET_TIMEOUT_MS);
   const ref = `origin/${branch}`;
   if (!await revParse(repo, `${ref}^{commit}`)) throw new MissingRefError(ref, repo);
+  await clearWorktreePath(repo, worktree, branch, opts);
   await $2`git -C ${repo} worktree add --detach --force ${worktree} ${ref}`;
   await ensureWorktreeHygiene(worktree);
 }
@@ -4304,8 +4486,14 @@ var init_git = __esm({
     init_netTimeout();
     init_swarmFiles();
     WorktreeBusyError = class extends Error {
-      constructor(branch, worktreePath) {
-        super(`worktree \u0437\u0430\u043D\u044F\u0442: ${worktreePath} (\u0432\u0435\u0442\u043A\u0430 ${branch}) \u2014 \u043F\u0440\u0438\u0431\u0435\u0440\u0438 worktree \u0438\u043B\u0438 \u043E\u0442\u043C\u0435\u043D\u0438 \u043F\u0440\u043E\u0433\u043E\u043D (swarm cancel ${branch})`);
+      /**
+       * `why` (TASWM-553) — ПОЧЕМУ путь не отдали, если причина не «его держит живой прогон»:
+       * основной чекаут по пути worktree, каталог с несданной работой, каталог, который не
+       * получилось убрать. Дефолтная формулировка («прибери worktree или отмени прогон»)
+       * человеку в таких случаях не помогает — она отправляет его не туда.
+       */
+      constructor(branch, worktreePath, why) {
+        super(why ?? `worktree \u0437\u0430\u043D\u044F\u0442: ${worktreePath} (\u0432\u0435\u0442\u043A\u0430 ${branch}) \u2014 \u043F\u0440\u0438\u0431\u0435\u0440\u0438 worktree \u0438\u043B\u0438 \u043E\u0442\u043C\u0435\u043D\u0438 \u043F\u0440\u043E\u0433\u043E\u043D (swarm cancel ${branch})`);
         this.branch = branch;
         this.worktreePath = worktreePath;
         this.name = "WorktreeBusyError";
@@ -4345,12 +4533,12 @@ __export(droneChannel_exports, {
   verifyLocalCliToken: () => verifyLocalCliToken
 });
 import { createHmac, randomBytes, timingSafeEqual } from "crypto";
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync9, readFileSync as readFileSync18, writeFileSync as writeFileSync12 } from "fs";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync9, readFileSync as readFileSync19, writeFileSync as writeFileSync12 } from "fs";
 import { dirname as dirname4 } from "path";
 import { serve } from "@hono/node-server";
 function loadChannelSecret(path) {
   try {
-    const s = readFileSync18(path, "utf8").trim();
+    const s = readFileSync19(path, "utf8").trim();
     if (s.length >= 32) return s;
   } catch {
   }
@@ -4592,8 +4780,8 @@ function startDroneChannel(deps, port) {
   return { port, server };
 }
 function closeDroneChannel(server) {
-  return new Promise((resolve4) => {
-    server.close(() => resolve4());
+  return new Promise((resolve5) => {
+    server.close(() => resolve5());
     server.closeAllConnections?.();
   });
 }
@@ -4746,7 +4934,7 @@ var init_droneChannel = __esm({
 
 // src/attachments.ts
 import { mkdir as mkdir3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 function attachmentsFromDoc(doc, origin) {
   const out = [];
   const walk2 = (node) => {
@@ -4837,7 +5025,7 @@ async function materializeAttachments(opts) {
   };
   const result = { files: [], skipped: [] };
   if (opts.refs.length === 0) return result;
-  const dir = join23(opts.worktree, ATTACHMENTS_DIR);
+  const dir = join24(opts.worktree, ATTACHMENTS_DIR);
   await io.removeDir(dir);
   let dirReady = false;
   let total = 0;
@@ -4883,7 +5071,7 @@ async function materializeAttachments(opts) {
         await io.mkdir(dir);
         dirReady = true;
       }
-      await io.writeFile(join23(dir, name), file.bytes);
+      await io.writeFile(join24(dir, name), file.bytes);
     } catch (e) {
       result.skipped.push(`${label2} \u2014 \u043D\u0435 \u0437\u0430\u043F\u0438\u0441\u0430\u043B\u043E\u0441\u044C \u043D\u0430 \u0434\u0438\u0441\u043A (${errText2(e)})`);
       continue;
@@ -5036,7 +5224,7 @@ var init_attachments = __esm({
 
 // src/shotUpload.ts
 import { readFile as fsReadFile } from "fs/promises";
-import { basename as basename4, isAbsolute as isAbsolute3, join as join24 } from "path";
+import { basename as basename4, isAbsolute as isAbsolute3, join as join25 } from "path";
 function shotMimetype(path) {
   const dot = path.lastIndexOf(".");
   if (dot < 0) return null;
@@ -5062,7 +5250,7 @@ async function readShots(paths, opts) {
     }
     let bytes;
     try {
-      bytes = await read(isAbsolute3(path) ? path : join24(opts.worktree, path));
+      bytes = await read(isAbsolute3(path) ? path : join25(opts.worktree, path));
     } catch (e) {
       skipped.push({ path, reason: `\u043D\u0435 \u043F\u0440\u043E\u0447\u0438\u0442\u0430\u043D: ${e instanceof Error ? e.message : String(e)}` });
       continue;
@@ -5143,8 +5331,8 @@ var init_shotUpload = __esm({
 
 // src/oauth.ts
 import { createHash as createHash3, randomBytes as randomBytes2 } from "crypto";
-import { readFileSync as readFileSync19, writeFileSync as writeFileSync13, unlinkSync as unlinkSync4 } from "fs";
-import { join as join25 } from "path";
+import { readFileSync as readFileSync20, writeFileSync as writeFileSync13, unlinkSync as unlinkSync4 } from "fs";
+import { join as join26 } from "path";
 function makePkce() {
   const verifier = randomBytes2(48).toString("base64url");
   const challenge = createHash3("sha256").update(verifier).digest("base64url");
@@ -5228,7 +5416,7 @@ function toStore(clientId, t, now) {
 }
 function loadStore() {
   try {
-    return JSON.parse(readFileSync19(STORE_PATH2, "utf8"));
+    return JSON.parse(readFileSync20(STORE_PATH2, "utf8"));
   } catch {
     return null;
   }
@@ -5244,7 +5432,7 @@ function clearStore() {
 }
 function loadClientId() {
   try {
-    return JSON.parse(readFileSync19(CLIENT_PATH, "utf8")).clientId;
+    return JSON.parse(readFileSync20(CLIENT_PATH, "utf8")).clientId;
   } catch {
     return null;
   }
@@ -5279,8 +5467,8 @@ var init_oauth = __esm({
     AUTHORIZE = "/api/oauth/authorize";
     TOKEN = "/api/oauth/token";
     SCOPE = "openid profile email taskless:full";
-    STORE_PATH2 = join25(SWARM_HOME, "oauth.json");
-    CLIENT_PATH = join25(SWARM_HOME, "oauth-client.json");
+    STORE_PATH2 = join26(SWARM_HOME, "oauth.json");
+    CLIENT_PATH = join26(SWARM_HOME, "oauth-client.json");
     base2 = (api) => api.replace(/\/$/, "");
   }
 });
@@ -5326,11 +5514,11 @@ var init_authState = __esm({
 });
 
 // src/workspace.ts
-import { readFileSync as readFileSync20, writeFileSync as writeFileSync14, unlinkSync as unlinkSync5 } from "fs";
-import { join as join26 } from "path";
+import { readFileSync as readFileSync21, writeFileSync as writeFileSync14, unlinkSync as unlinkSync5 } from "fs";
+import { join as join27 } from "path";
 function loadWorkspace() {
   try {
-    const w = JSON.parse(readFileSync20(WORKSPACE_PATH, "utf8"));
+    const w = JSON.parse(readFileSync21(WORKSPACE_PATH, "utf8"));
     return w && typeof w.id === "string" && w.id ? w : null;
   } catch {
     return null;
@@ -5344,7 +5532,7 @@ var init_workspace = __esm({
   "src/workspace.ts"() {
     "use strict";
     init_config();
-    WORKSPACE_PATH = join26(SWARM_HOME, "workspace.json");
+    WORKSPACE_PATH = join27(SWARM_HOME, "workspace.json");
   }
 });
 
@@ -5948,7 +6136,7 @@ __export(db_exports, {
 import { createRequire as createRequire2 } from "module";
 import { randomUUID as randomUUID3 } from "crypto";
 import { existsSync as existsSync15 } from "fs";
-import { resolve as resolve3 } from "path";
+import { resolve as resolve4 } from "path";
 function rowToQuestion(row) {
   return {
     id: row.id,
@@ -5990,6 +6178,7 @@ function rowToRun(row) {
     tokens_in: row.tokens_in ?? 0,
     tokens_out: row.tokens_out ?? 0,
     duration_ms: row.duration_ms ?? 0,
+    cost_unmeasured: row.cost_unmeasured ?? 0,
     pr_url: row.pr_url ?? null,
     // TASWM-506: файлы, занятые прогоном с открытым PR — JSON-массив, как depends_on.
     changed_paths: row.changed_paths ? JSON.parse(row.changed_paths) : [],
@@ -6070,6 +6259,7 @@ CREATE TABLE IF NOT EXISTS runs (
   tokens_in INTEGER NOT NULL DEFAULT 0,
   tokens_out INTEGER NOT NULL DEFAULT 0,
   duration_ms INTEGER NOT NULL DEFAULT 0,
+  cost_unmeasured INTEGER NOT NULL DEFAULT 0,
   pr_url TEXT,
   superseded_by INTEGER,
   decision TEXT,
@@ -6185,6 +6375,10 @@ CREATE TABLE IF NOT EXISTS imports (
           "ALTER TABLE runs ADD COLUMN tokens_in INTEGER NOT NULL DEFAULT 0",
           "ALTER TABLE runs ADD COLUMN tokens_out INTEGER NOT NULL DEFAULT 0",
           "ALTER TABLE runs ADD COLUMN duration_ms INTEGER NOT NULL DEFAULT 0",
+          // TASWM-548: сколько запусков прогона остались без снятой цены — отличает «бесплатно»
+          // от «не измерено». Прогоны до фичи получают 0: их нули мы перепроверить уже не можем,
+          // а задним числом объявлять их неизмеренными значило бы утверждать непроверенное.
+          "ALTER TABLE runs ADD COLUMN cost_unmeasured INTEGER NOT NULL DEFAULT 0",
           // TASWM-395: усилие рассуждения прогона (`claude --effort`). Nullable без DEFAULT —
           // NULL это и все прогоны до фичи, и прогоны на дефолте харнесса.
           "ALTER TABLE runs ADD COLUMN effort TEXT",
@@ -6571,7 +6765,7 @@ CREATE TABLE IF NOT EXISTS imports (
        * транзакции: прервётся — маркер не встанет, повтор безопасен.
        */
       importDb(sourcePath, repo) {
-        const abs = resolve3(sourcePath);
+        const abs = resolve4(sourcePath);
         const repoN = normalizeRepo(repo);
         const already = this.db.prepare("SELECT run_count FROM imports WHERE source = ?").get(abs);
         if (already) return { imported: false, runs: already.run_count };
@@ -6943,9 +7137,9 @@ var init_droneStore = __esm({
 });
 
 // src/overmind.ts
-import { homedir as homedir6 } from "os";
-import { existsSync as existsSync20, readFileSync as readFileSync24, readdirSync as readdirSync13, renameSync as renameSync12 } from "fs";
-import { basename as basename6, dirname as dirname5, join as join33 } from "path";
+import { homedir as homedir7 } from "os";
+import { existsSync as existsSync20, readFileSync as readFileSync25, readdirSync as readdirSync14, renameSync as renameSync12 } from "fs";
+import { basename as basename6, dirname as dirname5, join as join34 } from "path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "url";
 import { spawn as spawn4 } from "child_process";
 
@@ -7025,7 +7219,7 @@ init_config();
 init_resources();
 init_names2();
 init_storm();
-import { appendFileSync, existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "fs";
+import { appendFileSync, existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
 import { dirname as dirname2 } from "path";
 import { randomUUID } from "crypto";
 
@@ -7082,12 +7276,12 @@ init_zoneNotes();
 init_toolFailure();
 
 // src/logTail.ts
-import { closeSync, existsSync as existsSync6, openSync, readSync, readdirSync as readdirSync5, statSync as statSync4 } from "fs";
-import { join as join9 } from "path";
+import { closeSync, existsSync as existsSync6, openSync, readSync, readdirSync as readdirSync6, statSync as statSync5 } from "fs";
+import { join as join10 } from "path";
 
 // src/runLogDir.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync5, readdirSync as readdirSync4, renameSync as renameSync3, statSync as statSync3 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readdirSync as readdirSync5, renameSync as renameSync3, statSync as statSync4 } from "fs";
+import { join as join9 } from "path";
 var LEGACY_RUN_LOGS_SUBDIR = "legacy";
 function runLogDirName(runLogKey) {
   const safe2 = runLogKey.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^[-_]+|[-_]+$/g, "");
@@ -7095,7 +7289,7 @@ function runLogDirName(runLogKey) {
   return /^\d+$/.test(safe2) ? `k-${safe2}` : safe2;
 }
 function runLogDirPath(runLogsDir, runLogKey) {
-  return join8(runLogsDir, runLogDirName(runLogKey));
+  return join9(runLogsDir, runLogDirName(runLogKey));
 }
 function findRunLogDir(runLogsDir, keys) {
   for (const key of keys) {
@@ -7110,10 +7304,10 @@ function runLogDirForWrite(runLogsDir, keys) {
   return findRunLogDir(runLogsDir, keys) ?? runLogDirPath(runLogsDir, canonical);
 }
 function sweepLegacyRunLogs(runLogsDir) {
-  const legacyDir = join8(runLogsDir, LEGACY_RUN_LOGS_SUBDIR);
+  const legacyDir = join9(runLogsDir, LEGACY_RUN_LOGS_SUBDIR);
   let entries;
   try {
-    entries = readdirSync4(runLogsDir);
+    entries = readdirSync5(runLogsDir);
   } catch {
     return { moved: 0, failed: 0, legacyDir };
   }
@@ -7121,12 +7315,12 @@ function sweepLegacyRunLogs(runLogsDir) {
   let failed = 0;
   for (const name of entries) {
     if (!/^\d+$/.test(name)) continue;
-    const from = join8(runLogsDir, name);
+    const from = join9(runLogsDir, name);
     try {
-      if (!statSync3(from).isDirectory()) continue;
+      if (!statSync4(from).isDirectory()) continue;
       mkdirSync5(legacyDir, { recursive: true });
-      let to = join8(legacyDir, name);
-      for (let n = 2; existsSync5(to) && n < 100; n++) to = join8(legacyDir, `${name}-${n}`);
+      let to = join9(legacyDir, name);
+      for (let n = 2; existsSync5(to) && n < 100; n++) to = join9(legacyDir, `${name}-${n}`);
       renameSync3(from, to);
       moved++;
     } catch {
@@ -7146,7 +7340,7 @@ function fileHeader(name, size, shown) {
 function readTail(path, opts) {
   let size;
   try {
-    size = statSync4(path).size;
+    size = statSync5(path).size;
   } catch {
     return null;
   }
@@ -7181,7 +7375,7 @@ function latestRunLaunch(runLogsDir, runLogKeys) {
   if (!dir) return null;
   let files;
   try {
-    files = readdirSync5(dir);
+    files = readdirSync6(dir);
   } catch {
     return null;
   }
@@ -7192,8 +7386,8 @@ function latestRunLaunch(runLogsDir, runLogKeys) {
   }
   if (indexes.size === 0) return null;
   const index = Math.max(...indexes);
-  const out = [join9(dir, `${index}.json`), join9(dir, `${index}.json.done`)].find((p) => existsSync6(p)) ?? null;
-  const err = existsSync6(join9(dir, `${index}.err.log`)) ? join9(dir, `${index}.err.log`) : null;
+  const out = [join10(dir, `${index}.json`), join10(dir, `${index}.json.done`)].find((p) => existsSync6(p)) ?? null;
+  const err = existsSync6(join10(dir, `${index}.err.log`)) ? join10(dir, `${index}.err.log`) : null;
   return { index, total: indexes.size, out, err };
 }
 function runLogTail(runLogsDir, runLogKeys, opts) {
@@ -7464,13 +7658,13 @@ var SwarmClient = class _SwarmClient {
   recover() {
     if (existsSync7(this.mapPath)) {
       try {
-        const obj = JSON.parse(readFileSync6(this.mapPath, "utf8"));
+        const obj = JSON.parse(readFileSync7(this.mapPath, "utf8"));
         for (const [k, v] of Object.entries(obj)) this.prodIdByKey.set(k, v);
       } catch {
       }
     }
     if (existsSync7(this.outboxPath)) {
-      const txt = readFileSync6(this.outboxPath, "utf8");
+      const txt = readFileSync7(this.outboxPath, "utf8");
       for (const line of txt.split("\n")) {
         const s = line.trim();
         if (!s) continue;
@@ -7493,7 +7687,7 @@ var SwarmClient = class _SwarmClient {
     if (!existsSync7(this.stormPath)) return;
     let txt;
     try {
-      txt = readFileSync6(this.stormPath, "utf8");
+      txt = readFileSync7(this.stormPath, "utf8");
     } catch {
       return;
     }
@@ -7577,6 +7771,7 @@ var SwarmClient = class _SwarmClient {
     if ("tokens_in" in patch && patch.tokens_in !== void 0) out.tokensIn = patch.tokens_in;
     if ("tokens_out" in patch && patch.tokens_out !== void 0) out.tokensOut = patch.tokens_out;
     if ("duration_ms" in patch && patch.duration_ms !== void 0) out.durationMs = patch.duration_ms;
+    if ("cost_unmeasured" in patch && patch.cost_unmeasured !== void 0) out.costUnmeasured = patch.cost_unmeasured;
     if ("respawns" in patch && patch.respawns !== void 0) out.respawns = patch.respawns;
     if ("pr_url" in patch) out.prUrl = patch.pr_url ?? null;
     if ("changed_paths" in patch && patch.changed_paths) out.changedPaths = patch.changed_paths;
@@ -7659,6 +7854,8 @@ var SwarmClient = class _SwarmClient {
       // копятся учётом запусков claude (cost.ts), как cost_usd — TASWM-353
       tokens_out: 0,
       duration_ms: 0,
+      cost_unmeasured: 0,
+      // запусков без снятой цены (TASWM-548) — копится тем же учётом
       pr_url: null,
       changed_paths: [],
       // файлы прогона снимаются при открытии PR (TASWM-506)
@@ -9279,6 +9476,8 @@ var SwarmClient = class _SwarmClient {
         // токены и время работы (TASWM-353) — прод-поля, заполняются ниже
         tokens_out: 0,
         duration_ms: 0,
+        cost_unmeasured: 0,
+        // запусков без снятой цены (TASWM-548) — прод-поле, заполняется ниже
         pr_url: null,
         changed_paths: [],
         // занятые файлы (TASWM-506) — прод-поле, заполняется ниже
@@ -9360,6 +9559,7 @@ var SwarmClient = class _SwarmClient {
     local.tokens_in = typeof pr.tokensIn === "number" ? pr.tokensIn : 0;
     local.tokens_out = typeof pr.tokensOut === "number" ? pr.tokensOut : 0;
     local.duration_ms = typeof pr.durationMs === "number" ? pr.durationMs : 0;
+    local.cost_unmeasured = typeof pr.costUnmeasured === "number" ? pr.costUnmeasured : 0;
     local.pr_url = pr.prUrl ?? null;
     local.changed_paths = Array.isArray(pr.changedPaths) ? pr.changedPaths : local.changed_paths ?? [];
     local.stop_reason = pr.stopReason ?? null;
@@ -9694,11 +9894,11 @@ function tickPulse(health, now, intervalMs) {
 }
 
 // src/logRotate.ts
-import { copyFileSync as copyFileSync2, renameSync as renameSync5, statSync as statSync5, fstatSync, truncateSync, unlinkSync as unlinkSync3, existsSync as existsSync8 } from "fs";
+import { copyFileSync as copyFileSync2, renameSync as renameSync5, statSync as statSync6, fstatSync, truncateSync, unlinkSync as unlinkSync3, existsSync as existsSync8 } from "fs";
 var realIo = {
   size: (path) => {
     try {
-      return statSync5(path).size;
+      return statSync6(path).size;
     } catch {
       return null;
     }
@@ -9720,7 +9920,7 @@ var realOwnerIo = {
   },
   statPath: (path) => {
     try {
-      const s = statSync5(path);
+      const s = statSync6(path);
       return { dev: s.dev, ino: s.ino };
     } catch {
       return null;
@@ -9754,7 +9954,7 @@ function rotateDaemonLog(path, opts, io = realIo) {
 }
 
 // src/daemonLaunch.ts
-import { openSync as openSync2, closeSync as closeSync2, readFileSync as readFileSync8 } from "fs";
+import { openSync as openSync2, closeSync as closeSync2, readFileSync as readFileSync9 } from "fs";
 import { spawn } from "child_process";
 var realRespawnIo = {
   isTty: () => process.stdout.isTTY === true,
@@ -9854,13 +10054,13 @@ async function buildRepoRegistry(paths) {
 }
 
 // src/repoMemory.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "fs";
-import { join as join10 } from "path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "fs";
+import { join as join11 } from "path";
 var FILE = "repos.json";
 function loadRememberedRepos(home) {
   let raw;
   try {
-    raw = readFileSync9(join10(home, FILE), "utf8");
+    raw = readFileSync10(join11(home, FILE), "utf8");
   } catch {
     return [];
   }
@@ -9875,7 +10075,7 @@ function loadRememberedRepos(home) {
 function rememberRepos(home, paths, now = () => /* @__PURE__ */ new Date()) {
   const clean = paths.filter((p) => p.trim().length > 0);
   if (clean.length === 0) return;
-  writeFileSync8(join10(home, FILE), `${JSON.stringify({ paths: clean, at: now().toISOString() }, null, 2)}
+  writeFileSync8(join11(home, FILE), `${JSON.stringify({ paths: clean, at: now().toISOString() }, null, 2)}
 `);
 }
 function pickRepoPaths(args) {
@@ -9889,13 +10089,13 @@ function pickRepoPaths(args) {
 init_src();
 init_config();
 init_linkFailure();
-import { homedir as homedir4 } from "os";
-import { readFileSync as readFileSync11, renameSync as renameSync6, writeFileSync as writeFileSync9 } from "fs";
-import { isAbsolute, join as join12, resolve as resolve2 } from "path";
+import { homedir as homedir5 } from "os";
+import { readFileSync as readFileSync12, renameSync as renameSync6, writeFileSync as writeFileSync9 } from "fs";
+import { isAbsolute, join as join13, resolve as resolve2 } from "path";
 
 // src/repoScan.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync10, statSync as statSync6 } from "fs";
-import { join as join11 } from "path";
+import { readdirSync as readdirSync7, readFileSync as readFileSync11, statSync as statSync7 } from "fs";
+import { join as join12 } from "path";
 var SKIP = /* @__PURE__ */ new Set([
   "node_modules",
   "vendor",
@@ -9925,7 +10125,7 @@ function parseOriginFromGitConfig(text) {
 }
 function originOf(dir) {
   try {
-    return parseOriginFromGitConfig(readFileSync10(join11(dir, ".git", "config"), "utf8"));
+    return parseOriginFromGitConfig(readFileSync11(join12(dir, ".git", "config"), "utf8"));
   } catch {
     return null;
   }
@@ -9954,15 +10154,15 @@ function walk(dir, depth, maxDepth, found) {
   }
   let entries;
   try {
-    entries = readdirSync6(dir);
+    entries = readdirSync7(dir);
   } catch {
     return;
   }
   for (const name of entries) {
     if (name.startsWith(".") || SKIP.has(name)) continue;
-    const child = join11(dir, name);
+    const child = join12(dir, name);
     try {
-      if (!statSync6(child).isDirectory()) continue;
+      if (!statSync7(child).isDirectory()) continue;
     } catch {
       continue;
     }
@@ -9982,13 +10182,13 @@ function defaultScanRoots(home, knownPaths = []) {
     if (parent && parent !== p) add(parent);
   }
   for (const name of ["projects", "code", "src", "dev", "work", "repos", "git", "Projects", "Code", "Developer", "Documents/GitHub", "go/src"]) {
-    add(join11(home, name));
+    add(join12(home, name));
   }
   return out;
 }
 
 // src/repoDiscovery.ts
-function resolveScanRoots(raw, home = homedir4(), knownPaths = []) {
+function resolveScanRoots(raw, home = homedir5(), knownPaths = []) {
   const v = (raw ?? "").trim();
   if (!v) return defaultScanRoots(home, knownPaths);
   if (["off", "none", "0"].includes(v.toLowerCase())) return [];
@@ -9996,7 +10196,7 @@ function resolveScanRoots(raw, home = homedir4(), knownPaths = []) {
   for (const part of v.split(",")) {
     const p = part.trim();
     if (!p) continue;
-    const abs = p === "~" ? home : p.startsWith("~/") ? join12(home, p.slice(2)) : isAbsolute(p) ? p : resolve2(home, p);
+    const abs = p === "~" ? home : p.startsWith("~/") ? join13(home, p.slice(2)) : isAbsolute(p) ? p : resolve2(home, p);
     if (!out.includes(abs)) out.push(abs);
   }
   return out;
@@ -10210,7 +10410,7 @@ function repoMapRows(state) {
 }
 function loadRepoMapCache(path) {
   try {
-    const raw = JSON.parse(readFileSync11(path, "utf8"));
+    const raw = JSON.parse(readFileSync12(path, "utf8"));
     if (!Array.isArray(raw?.entries)) return { scannedAt: null, entries: [] };
     return {
       scannedAt: typeof raw.scannedAt === "string" && raw.scannedAt ? raw.scannedAt : null,
@@ -10233,15 +10433,15 @@ function writeRepoMapCache(path, entries, scannedAt = stamp()) {
 
 // src/hostIdentity.ts
 import { hostname } from "os";
-import { existsSync as existsSync9, readFileSync as readFileSync12, renameSync as renameSync7, writeFileSync as writeFileSync10 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync13, renameSync as renameSync7, writeFileSync as writeFileSync10 } from "fs";
+import { join as join14 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function hostIdentityPath(home) {
-  return join13(home, "host.json");
+  return join14(home, "host.json");
 }
 function loadHostIdentity(deps) {
   const exists = deps.exists ?? existsSync9;
-  const readFile2 = deps.readFile ?? ((p) => readFileSync12(p, "utf8"));
+  const readFile2 = deps.readFile ?? ((p) => readFileSync13(p, "utf8"));
   const writeFile4 = deps.writeFile ?? ((p, data) => {
     writeFileSync10(`${p}.tmp`, data);
     renameSync7(`${p}.tmp`, p);
@@ -10305,7 +10505,18 @@ function pauseDue(reliefSince, lastPauseAt, now, cfg) {
   if (reliefSince == null || now - reliefSince < cfg.sustainMs) return false;
   return lastPauseAt == null || now - lastPauseAt >= cfg.pauseWindowMs;
 }
+function loadBearingRuns(runs) {
+  return runs.filter((r) => r.status === "running" && r.pid != null);
+}
+function reliefWouldStrangleSoleWorker(runs) {
+  return loadBearingRuns(runs).length <= 1;
+}
+function reliefSoleWorkerReason(decision) {
+  const head = `${RELIEF_PAUSE_MARK}: \u041D\u0415 \u0441\u043D\u0438\u043C\u0430\u044E \u2014 \u043D\u0430 \u043C\u0430\u0448\u0438\u043D\u0435 \u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442 \u043E\u0434\u0438\u043D \u0434\u0440\u043E\u043D, \u0438 \u0432\u0441\u044F \u043D\u0430\u0433\u0440\u0443\u0437\u043A\u0430 \u0435\u0433\u043E \u0436\u0435 (\u0441\u043D\u044F\u0442\u044C \u0435\u0433\u043E \u0437\u043D\u0430\u0447\u0438\u0442 \u043E\u0441\u0432\u043E\u0431\u043E\u0434\u0438\u0442\u044C \u043C\u0430\u0448\u0438\u043D\u0443 \u043E\u0442 \u0442\u043E\u0439 \u0440\u0430\u0431\u043E\u0442\u044B, \u0440\u0430\u0434\u0438 \u043A\u043E\u0442\u043E\u0440\u043E\u0439 \u043E\u043D\u0430 \u043D\u0443\u0436\u043D\u0430; TASWM-550)`;
+  return decision ? `${head} \xB7 ${decision}` : head;
+}
 function pickPauseCandidate(runs, protectedRunIds) {
+  if (reliefWouldStrangleSoleWorker(runs)) return null;
   const candidates = runs.filter(
     (r) => r.kind === "drone" && r.status === "running" && r.pid != null && r.resolves_run_id == null && r.reviews_run_id == null && // TASWM-535: прогон, признанный ТЯЖЁЛЫМ, разгрузка не снимает. Правильная реакция на
     // «тяжело» — уменьшить число соседей, а не убить того, кто работает: 27.08 перегруженная
@@ -10325,8 +10536,8 @@ function pickResumeCandidate(pausedForRelief) {
 }
 
 // src/reliefLoop.ts
-import { existsSync as existsSync10, readFileSync as readFileSync13, renameSync as renameSync8, writeFileSync as writeFileSync11 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync14, renameSync as renameSync8, writeFileSync as writeFileSync11 } from "fs";
+import { join as join15 } from "path";
 var numEnv3 = (name, def) => {
   const v = Number(process.env[name]);
   return Number.isFinite(v) && v > 0 ? v : def;
@@ -10361,11 +10572,11 @@ function reliefLoopTripped(entry, cfg = DEFAULT_RELIEF_LOOP_CONFIG) {
   return !!entry && entry.pauses >= cfg.limit;
 }
 function reliefLoopStatePath(home) {
-  return join14(home, "relief-loop.json");
+  return join15(home, "relief-loop.json");
 }
 function loadReliefLoopState(home, now = Date.now(), io = {}, cfg = DEFAULT_RELIEF_LOOP_CONFIG) {
   const exists = io.exists ?? existsSync10;
-  const readFile2 = io.readFile ?? ((p) => readFileSync13(p, "utf8"));
+  const readFile2 = io.readFile ?? ((p) => readFileSync14(p, "utf8"));
   const path = reliefLoopStatePath(home);
   if (!exists(path)) return {};
   try {
@@ -10549,15 +10760,15 @@ function buildReliefCostCandidates(cost, t, sustainMs, build) {
 
 // src/launcher.ts
 import { spawn as spawn2 } from "child_process";
-import { closeSync as closeSync3, existsSync as existsSync11, mkdirSync as mkdirSync8, openSync as openSync3, readdirSync as readdirSync8 } from "fs";
+import { closeSync as closeSync3, existsSync as existsSync11, mkdirSync as mkdirSync8, openSync as openSync3, readdirSync as readdirSync9 } from "fs";
 import { createRequire } from "module";
-import { homedir as homedir5 } from "os";
-import { dirname as dirname3, join as join16 } from "path";
+import { homedir as homedir6 } from "os";
+import { dirname as dirname3, join as join17 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/droneHome.ts
-import { lstatSync, mkdirSync as mkdirSync7, readdirSync as readdirSync7, rmSync, statSync as statSync7, symlinkSync as symlinkSync2 } from "fs";
-import { join as join15, relative, sep } from "path";
+import { lstatSync, mkdirSync as mkdirSync7, readdirSync as readdirSync8, rmSync, statSync as statSync8, symlinkSync as symlinkSync2 } from "fs";
+import { join as join16, relative, sep } from "path";
 var DRONE_HOME_DENY_DEFAULT = [".taskless-swarm", ".bash_history", ".zsh_history"];
 function droneHomeDeny(env = process.env) {
   const extra = (env.SWARM_DRONE_HOME_DENY || "").split(",").map((s) => s.trim()).filter(Boolean);
@@ -10576,28 +10787,28 @@ function buildDroneHome(opts) {
   const deny = opts.deny ?? droneHomeDeny();
   const platform = opts.platform ?? process.platform;
   mkdirSync7(droneHome, { recursive: true, mode: 448 });
-  const wanted = new Set(mirroredEntries(readdirSync7(realHome), deny, platform));
+  const wanted = new Set(mirroredEntries(readdirSync8(realHome), deny, platform));
   const rel = relative(realHome, droneHome);
   if (rel && !rel.startsWith("..") && !rel.includes(sep)) wanted.delete(rel);
-  for (const existing of readdirSync7(droneHome)) {
+  for (const existing of readdirSync8(droneHome)) {
     if (wanted.has(existing)) continue;
-    const p = join15(droneHome, existing);
+    const p = join16(droneHome, existing);
     try {
       if (lstatSync(p).isSymbolicLink()) rmSync(p);
     } catch {
     }
   }
   for (const name of wanted) {
-    const link2 = join15(droneHome, name);
+    const link2 = join16(droneHome, name);
     try {
       lstatSync(link2);
       continue;
     } catch {
     }
-    const target = join15(realHome, name);
+    const target = join16(realHome, name);
     let isDir;
     try {
-      isDir = statSync7(target).isDirectory();
+      isDir = statSync8(target).isDirectory();
     } catch {
       continue;
     }
@@ -10615,7 +10826,7 @@ var REAL_PATH_ENV_PINS = [
   { env: "YARN_GLOBAL_FOLDER", segments: [".yarn", "berry"] }
 ];
 function realPathEnvPins(realHome) {
-  return Object.fromEntries(REAL_PATH_ENV_PINS.map(({ env, segments }) => [env, join15(realHome, ...segments)]));
+  return Object.fromEntries(REAL_PATH_ENV_PINS.map(({ env, segments }) => [env, join16(realHome, ...segments)]));
 }
 function dronePrivatePaths(realHome, swarmHome) {
   return [
@@ -10727,7 +10938,7 @@ function droneEnv(worktree, base3 = process.env, isolation, droneCap = null) {
   const env = { ...base3 };
   const isolate = base3.SWARM_TURBO_ISOLATE !== "0";
   if (isolate && !base3.TURBO_CACHE_DIR) {
-    env.TURBO_CACHE_DIR = join16(worktree, ".turbo", "cache");
+    env.TURBO_CACHE_DIR = join17(worktree, ".turbo", "cache");
   }
   Object.assign(env, droneTestEnv(droneCap, base3));
   for (const key of DAEMON_STATE_ENV) delete env[key];
@@ -10755,10 +10966,10 @@ var DAEMON_STATE_ENV = [
   "TASKLESS_TOKEN"
 ];
 function bundledRoleDir(kind) {
-  return join16(dirname3(fileURLToPath2(import.meta.url)), "..", "roles", kind);
+  return join17(dirname3(fileURLToPath2(import.meta.url)), "..", "roles", kind);
 }
 function roleDir(worktree, kind) {
-  return join16(worktree, ".claude", "roles", kind);
+  return join17(worktree, ".claude", "roles", kind);
 }
 function roleDirs(worktree, kind) {
   return [bundledRoleDir(kind), roleDir(worktree, kind)].filter((dir) => existsSync11(dir));
@@ -10769,7 +10980,7 @@ function nextRunLogPath(runLogsDir, runLogKeys) {
   mkdirSync8(dir, { recursive: true });
   let files = [];
   try {
-    files = readdirSync8(dir);
+    files = readdirSync9(dir);
   } catch {
   }
   let next = 0;
@@ -10777,7 +10988,7 @@ function nextRunLogPath(runLogsDir, runLogKeys) {
     const m = /^(\d+)\.json/.exec(f);
     if (m) next = Math.max(next, Number(m[1]) + 1);
   }
-  return join16(dir, `${next}.json`);
+  return join17(dir, `${next}.json`);
 }
 function openNextRunLog(runLogsDir, runLogKeys) {
   for (let attempt = 0; attempt < 50; attempt++) {
@@ -10858,11 +11069,11 @@ function makeLauncher(cfg) {
     } catch (e) {
       console.error(`[launcher] \u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0437\u0430\u043F\u0438\u0441\u0430\u0442\u044C \u0443\u0441\u0438\u043B\u0438\u0435 \u043F\u0440\u043E\u0433\u043E\u043D\u0430 #${run.id}: ${String(e)}`);
     }
-    const realHome = cfg.droneIsolation?.realHome ?? homedir5();
+    const realHome = cfg.droneIsolation?.realHome ?? homedir6();
     const home = cfg.droneIsolation ? buildDroneHome({ realHome, droneHome: cfg.droneIsolation.home }) : void 0;
-    if (cfg.droneIsolation && process.env.TASKLESS_TOKEN && !existsSync11(join16(cfg.droneIsolation.swarmHome, "token"))) {
+    if (cfg.droneIsolation && process.env.TASKLESS_TOKEN && !existsSync11(join17(cfg.droneIsolation.swarmHome, "token"))) {
       console.error(
-        `[launcher] TASKLESS_TOKEN \u0437\u0430\u0434\u0430\u043D \u0442\u043E\u043B\u044C\u043A\u043E \u0432 env \u0434\u0435\u043C\u043E\u043D\u0430 \u2014 \u0434\u0440\u043E\u043D\u0443 \u043E\u043D \u043D\u0435 \u043D\u0430\u0441\u043B\u0435\u0434\u0443\u0435\u0442\u0441\u044F (TASWM-289), \u0430 \u0444\u0430\u0439\u043B\u0430 ${join16(cfg.droneIsolation.swarmHome, "token")} \u043D\u0435\u0442. read_task \u0434\u0440\u043E\u043D\u0430 \u0431\u0443\u0434\u0435\u0442 slug-only. \u041F\u043E\u0447\u0438\u043D\u0438: \`swarm login\` (oauth.json) \u0438\u043B\u0438 \u043F\u043E\u043B\u043E\u0436\u0438 \u0442\u043E\u043A\u0435\u043D \u0432 \u044D\u0442\u043E\u0442 \u0444\u0430\u0439\u043B.`
+        `[launcher] TASKLESS_TOKEN \u0437\u0430\u0434\u0430\u043D \u0442\u043E\u043B\u044C\u043A\u043E \u0432 env \u0434\u0435\u043C\u043E\u043D\u0430 \u2014 \u0434\u0440\u043E\u043D\u0443 \u043E\u043D \u043D\u0435 \u043D\u0430\u0441\u043B\u0435\u0434\u0443\u0435\u0442\u0441\u044F (TASWM-289), \u0430 \u0444\u0430\u0439\u043B\u0430 ${join17(cfg.droneIsolation.swarmHome, "token")} \u043D\u0435\u0442. read_task \u0434\u0440\u043E\u043D\u0430 \u0431\u0443\u0434\u0435\u0442 slug-only. \u041F\u043E\u0447\u0438\u043D\u0438: \`swarm login\` (oauth.json) \u0438\u043B\u0438 \u043F\u043E\u043B\u043E\u0436\u0438 \u0442\u043E\u043A\u0435\u043D \u0432 \u044D\u0442\u043E\u0442 \u0444\u0430\u0439\u043B.`
       );
     }
     const executor = cfg.executor ?? resolveExecutor();
@@ -10923,39 +11134,94 @@ function makeLauncher(cfg) {
 init_procCleanup();
 
 // src/cost.ts
-import { readFileSync as readFileSync14, readdirSync as readdirSync9, renameSync as renameSync9 } from "fs";
-import { join as join17 } from "path";
+import { readFileSync as readFileSync15, readdirSync as readdirSync10, renameSync as renameSync9, statSync as statSync9 } from "fs";
+import { join as join18 } from "path";
 init_executors();
 var UNPROCESSED_LOG_RE = /^\d+\.json$/;
+var SEGMENT_LOG_RE = /^(\d+)\.json(\.done)?$/;
+var RESCUE_OPEN_WINDOW_MAX_MS = 12 * 60 * 60 * 1e3;
 function unprocessedLogFiles(dir) {
   try {
-    return readdirSync9(dir).filter((f) => UNPROCESSED_LOG_RE.test(f));
+    return readdirSync10(dir).filter((f) => UNPROCESSED_LOG_RE.test(f));
   } catch {
     return [];
   }
 }
+function segmentStarts(dir) {
+  const starts = /* @__PURE__ */ new Map();
+  let entries;
+  try {
+    entries = readdirSync10(dir);
+  } catch {
+    return starts;
+  }
+  for (const f of entries) {
+    const m = SEGMENT_LOG_RE.exec(f);
+    if (!m) continue;
+    try {
+      const st = statSync9(join18(dir, f));
+      starts.set(Number(m[1]), st.birthtimeMs > 0 ? st.birthtimeMs : st.ctimeMs);
+    } catch {
+    }
+  }
+  return starts;
+}
+function segmentWindow(starts, index, nowMs) {
+  const from = starts.get(index);
+  if (from === void 0) return null;
+  let to = null;
+  for (const [i, at] of starts) {
+    if (i > index && (to === null || at < to)) to = at;
+  }
+  if (to !== null) return { from, to: Math.max(to, from) };
+  if (nowMs - from > RESCUE_OPEN_WINDOW_MAX_MS) return null;
+  return { from, to: nowMs };
+}
+function rescueSegmentSpend(deps, run, executor, starts, file, nowMs) {
+  if (!executor.rescueSpend || !run.worktree_path) return null;
+  const index = Number(/^(\d+)\.json$/.exec(file)?.[1]);
+  if (!Number.isFinite(index)) return null;
+  const window = segmentWindow(starts, index, nowMs);
+  if (!window) return null;
+  let spend = null;
+  try {
+    spend = executor.rescueSpend(run.worktree_path, window.from, window.to);
+  } catch (e) {
+    console.warn(`[overmind] cost \u043F\u0440\u043E\u0433\u043E\u043D\u0430 #${run.id}: \u0437\u0430\u043F\u0438\u0441\u044C \u0441\u0435\u0441\u0441\u0438\u0438 \u043D\u0435 \u043F\u0440\u043E\u0447\u0438\u0442\u0430\u043B\u0430\u0441\u044C (${file}) \u2014 ${String(e)}`);
+    return null;
+  }
+  if (!spend) return null;
+  console.warn(
+    `[overmind] cost \u043F\u0440\u043E\u0433\u043E\u043D\u0430 #${run.id}: \u0438\u0442\u043E\u0433 ${file} \u043D\u0435 \u0437\u0430\u043F\u0438\u0441\u0430\u043D (\u0443\u0431\u0438\u0442 \u043D\u0430 \u043F\u043E\u043B\u043F\u0443\u0442\u0438) \u2014 \u0442\u0440\u0430\u0442\u0430 \u0441\u043D\u044F\u0442\u0430 \u0438\u0437 \u0437\u0430\u043F\u0438\u0441\u0438 \u0441\u0435\u0441\u0441\u0438\u0438: $${spend.costUsd.toFixed(4)}, \u0442\u043E\u043A\u0435\u043D\u043E\u0432 ${spend.tokensIn ?? 0}/${spend.tokensOut ?? 0} (TASWM-548)`
+  );
+  return spend;
+}
 function accountRunCost(deps, run) {
   const dir = findRunLogDir(deps.runLogsDir, deps.db.runLogKeys(run.id));
   const files = dir ? unprocessedLogFiles(dir) : [];
   if (!dir || files.length === 0) return;
   const model = resolveRunModel(run, deps.swarmModels?.() ?? null);
   const executor = deps.executor ?? resolveExecutor();
+  const now = deps.now?.() ?? Date.now();
+  const starts = segmentStarts(dir);
   let added = 0;
   let tokensIn = 0;
   let tokensOut = 0;
   let durationMs = 0;
+  let unmeasured = 0;
   const processed = [];
   for (const f of files) {
-    const full = join17(dir, f);
+    const full = join18(dir, f);
     let raw = null;
     try {
-      raw = readFileSync14(full, "utf8");
+      raw = readFileSync15(full, "utf8");
     } catch {
       continue;
     }
-    const result = executor.parseResult(raw, model);
+    const result = executor.parseResult(raw, model) ?? rescueSegmentSpend(deps, run, executor, starts, f, now);
     if (!result) {
-      console.warn(`[overmind] cost \u043F\u0440\u043E\u0433\u043E\u043D\u0430 #${run.id}: \u043D\u0435 \u0440\u0430\u0441\u043F\u0430\u0440\u0441\u0438\u043B\u0441\u044F ${full} (\u043F\u0440\u043E\u0433\u043E\u043D \u0443\u043C\u0435\u0440 \u0434\u043E \u0437\u0430\u043F\u0438\u0441\u0438 \u0440\u0435\u0437\u0443\u043B\u044C\u0442\u0430\u0442\u0430?)`);
+      unmeasured += 1;
+      console.warn(`[overmind] cost \u043F\u0440\u043E\u0433\u043E\u043D\u0430 #${run.id}: \u043D\u0435 \u0440\u0430\u0441\u043F\u0430\u0440\u0441\u0438\u043B\u0441\u044F ${full} \u0438 \u043D\u0435 \u0441\u043F\u0430\u0441\u0451\u043D \u0438\u0437 \u0437\u0430\u043F\u0438\u0441\u0438 \u0441\u0435\u0441\u0441\u0438\u0438 \u2014 \u043F\u043E\u043C\u0435\u0447\u0435\u043D \xAB\u043D\u0435 \u0438\u0437\u043C\u0435\u0440\u0435\u043D\u043E\xBB (TASWM-548)`);
     } else {
       if (result.warning) console.warn(`[overmind] cost \u043F\u0440\u043E\u0433\u043E\u043D\u0430 #${run.id}: ${result.warning}`);
       added += result.costUsd;
@@ -10965,12 +11231,16 @@ function accountRunCost(deps, run) {
     }
     processed.push(full);
   }
-  if (added > 0 || tokensIn > 0 || tokensOut > 0 || durationMs > 0) {
+  if (added > 0 || tokensIn > 0 || tokensOut > 0 || durationMs > 0 || unmeasured > 0) {
     deps.db.updateRun(run.id, {
       cost_usd: run.cost_usd + added,
       tokens_in: run.tokens_in + tokensIn,
       tokens_out: run.tokens_out + tokensOut,
-      duration_ms: run.duration_ms + durationMs
+      duration_ms: run.duration_ms + durationMs,
+      // Отметка «не измерено» копится тем же единственным updateRun, что и деньги: разъехаться
+      // «цену дописали, а признак неполноты потеряли» эти величины не должны — отчёт читает их
+      // ПАРОЙ, и ноль при cost_unmeasured=0 значит «бесплатно», а при >0 — «не знаю».
+      cost_unmeasured: run.cost_unmeasured + unmeasured
     });
   }
   for (const full of processed) {
@@ -10998,8 +11268,8 @@ function makeCostSweeper(deps) {
 }
 
 // src/runOutcome.ts
-import { readdirSync as readdirSync10, readFileSync as readFileSync15 } from "fs";
-import { join as join18 } from "path";
+import { readdirSync as readdirSync11, readFileSync as readFileSync16 } from "fs";
+import { join as join19 } from "path";
 init_executors();
 function endedItself(outcome) {
   return outcome === "graceful" || outcome === "budget" || outcome === "aborted";
@@ -11013,7 +11283,7 @@ function readLatestResultRaw(runLogsDir, runLogKeys) {
   if (!dir) return null;
   let files;
   try {
-    files = readdirSync10(dir);
+    files = readdirSync11(dir);
   } catch {
     return null;
   }
@@ -11026,7 +11296,7 @@ function readLatestResultRaw(runLogsDir, runLogKeys) {
   }
   if (!latest) return null;
   try {
-    return readFileSync15(join18(dir, latest.name), "utf8");
+    return readFileSync16(join19(dir, latest.name), "utf8");
   } catch {
     return null;
   }
@@ -11059,20 +11329,20 @@ init_src();
 init_git();
 
 // src/deps.ts
-import { existsSync as existsSync14, readdirSync as readdirSync12, readFileSync as readFileSync17 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync13, readFileSync as readFileSync18 } from "fs";
+import { join as join23 } from "path";
 import { execa } from "execa";
 
 // src/prepareLock.ts
 import { createHash } from "crypto";
-import { closeSync as closeSync4, openSync as openSync4, rmSync as rmSync2, statSync as statSync9, writeSync } from "fs";
-import { join as join20 } from "path";
+import { closeSync as closeSync4, openSync as openSync4, rmSync as rmSync2, statSync as statSync11, writeSync } from "fs";
+import { join as join21 } from "path";
 import { tmpdir } from "os";
 var WAIT_TIMEOUT_MS = 5 * 6e4;
 var POLL_MS = 300;
 var STALE_MS = 20 * 6e4;
 function machineLockPath(key, dir = tmpdir()) {
-  return join20(dir, `swarm-prepare-${createHash("sha1").update(key).digest("hex").slice(0, 16)}.lock`);
+  return join21(dir, `swarm-prepare-${createHash("sha1").update(key).digest("hex").slice(0, 16)}.lock`);
 }
 function defaultTryCreate(path, content) {
   try {
@@ -11089,7 +11359,7 @@ function defaultTryCreate(path, content) {
 }
 function defaultAgeMs(path) {
   try {
-    return Date.now() - statSync9(path).mtimeMs;
+    return Date.now() - statSync11(path).mtimeMs;
   } catch {
     return null;
   }
@@ -11132,9 +11402,9 @@ init_config();
 // src/envCache.ts
 init_config();
 import { createHash as createHash2 } from "crypto";
-import { cp, link, lstat, mkdir as mkdir2, readdir, readlink, rename, rm as rm2, stat, symlink, utimes, writeFile as writeFile2 } from "fs/promises";
-import { existsSync as existsSync13, readFileSync as readFileSync16 } from "fs";
-import { join as join21 } from "path";
+import { cp, link, lstat, mkdir as mkdir2, readdir, readlink, rename as rename2, rm as rm2, stat, symlink, utimes, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync13, readFileSync as readFileSync17 } from "fs";
+import { join as join22 } from "path";
 function fingerprint(parts) {
   const h = createHash2("sha256");
   for (const p of parts) {
@@ -11148,8 +11418,8 @@ async function cloneTree(src, dst) {
   const entries = await readdir(src, { withFileTypes: true });
   await Promise.all(
     entries.map(async (e) => {
-      const from = join21(src, e.name);
-      const to = join21(dst, e.name);
+      const from = join22(src, e.name);
+      const to = join22(dst, e.name);
       if (e.isDirectory()) return cloneTree(from, to);
       if (e.isSymbolicLink()) {
         return symlink(await readlink(from), to).catch(() => cp(from, to, { recursive: true, verbatimSymlinks: true }));
@@ -11162,11 +11432,11 @@ function cacheRoot(io) {
   return io.root ?? ENV_CACHE_DIR;
 }
 function snapshotDir(io, key) {
-  return join21(cacheRoot(io), key);
+  return join22(cacheRoot(io), key);
 }
 function readManifest(dir) {
   try {
-    const parsed = JSON.parse(readFileSync16(join21(dir, "manifest.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync17(join22(dir, "manifest.json"), "utf8"));
     if (!parsed || typeof parsed !== "object") return null;
     const m = parsed;
     if (typeof m.key !== "string" || !Array.isArray(m.dirs)) return null;
@@ -11179,7 +11449,7 @@ function readManifest(dir) {
 }
 function hasEnvSnapshot(key, io = {}) {
   const exists = io.exists ?? existsSync13;
-  return exists(join21(snapshotDir(io, key), "manifest.json"));
+  return exists(join22(snapshotDir(io, key), "manifest.json"));
 }
 async function restoreEnvSnapshot(worktree, key, io = {}) {
   const exists = io.exists ?? existsSync13;
@@ -11191,13 +11461,13 @@ async function restoreEnvSnapshot(worktree, key, io = {}) {
   try {
     for (let i = 0; i < manifest.dirs.length; i++) {
       const rel = manifest.dirs[i] ?? "";
-      const target = join21(worktree, rel);
+      const target = join22(worktree, rel);
       if (exists(target)) continue;
-      await clone(join21(dir, "trees", String(i)), target);
+      await clone(join22(dir, "trees", String(i)), target);
       made.push(rel);
     }
   } catch {
-    for (const rel of made) await rm2(join21(worktree, rel), { recursive: true, force: true }).catch(() => {
+    for (const rel of made) await rm2(join22(worktree, rel), { recursive: true, force: true }).catch(() => {
     });
     return null;
   }
@@ -11213,17 +11483,17 @@ async function saveEnvSnapshot(worktree, key, dirs, io = {}) {
   const exists = io.exists ?? existsSync13;
   const clone = io.clone ?? cloneTree;
   if (hasEnvSnapshot(key, io)) return true;
-  const present = dirs.filter((rel) => exists(join21(worktree, rel)));
+  const present = dirs.filter((rel) => exists(join22(worktree, rel)));
   if (!present.length) return false;
   const root = cacheRoot(io);
-  const tmp = join21(root, `.tmp-${key}-${process.pid}`);
+  const tmp = join22(root, `.tmp-${key}-${process.pid}`);
   try {
     await rm2(tmp, { recursive: true, force: true });
-    await mkdir2(join21(tmp, "trees"), { recursive: true });
-    for (let i = 0; i < present.length; i++) await clone(join21(worktree, present[i] ?? ""), join21(tmp, "trees", String(i)));
+    await mkdir2(join22(tmp, "trees"), { recursive: true });
+    for (let i = 0; i < present.length; i++) await clone(join22(worktree, present[i] ?? ""), join22(tmp, "trees", String(i)));
     const manifest = { key, dirs: present, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
-    await writeFile2(join21(tmp, "manifest.json"), JSON.stringify(manifest, null, 2));
-    await rename(tmp, snapshotDir(io, key));
+    await writeFile2(join22(tmp, "manifest.json"), JSON.stringify(manifest, null, 2));
+    await rename2(tmp, snapshotDir(io, key));
     return true;
   } catch {
     await rm2(tmp, { recursive: true, force: true }).catch(() => {
@@ -11242,13 +11512,13 @@ async function pruneEnvSnapshots(io = {}) {
   }
   const withTime = [];
   for (const name of names) {
-    const s = await stat(join21(root, name)).catch(() => null);
+    const s = await stat(join22(root, name)).catch(() => null);
     if (s) withTime.push({ name, mtime: s.mtimeMs });
   }
   withTime.sort((a, b) => b.mtime - a.mtime);
   let removed = 0;
   for (const { name } of withTime.slice(Math.max(0, keep))) {
-    await rm2(join21(root, name), { recursive: true, force: true }).catch(() => {
+    await rm2(join22(root, name), { recursive: true, force: true }).catch(() => {
     });
     removed++;
   }
@@ -11264,9 +11534,9 @@ async function sweepEnvCacheTemp(io = {}) {
   }
   let removed = 0;
   for (const name of names) {
-    const s = await lstat(join21(root, name)).catch(() => null);
+    const s = await lstat(join22(root, name)).catch(() => null);
     if (!s || Date.now() - s.mtimeMs < 60 * 6e4) continue;
-    await rm2(join21(root, name), { recursive: true, force: true }).catch(() => {
+    await rm2(join22(root, name), { recursive: true, force: true }).catch(() => {
     });
     removed++;
   }
@@ -11293,21 +11563,21 @@ async function runCommand(cmd, worktree) {
 }
 function safeReadText(p) {
   try {
-    return readFileSync17(p, "utf8");
+    return readFileSync18(p, "utf8");
   } catch {
     return null;
   }
 }
 function safeListDirs(p) {
   try {
-    return readdirSync12(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    return readdirSync13(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
   } catch {
     return [];
   }
 }
 function safeListFiles(p) {
   try {
-    return readdirSync12(p, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name);
+    return readdirSync13(p, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name);
   } catch {
     return [];
   }
@@ -11335,19 +11605,19 @@ function overridePlan(override) {
 function detectPackageManager(worktree, io = {}) {
   const exists = io.exists ?? existsSync14;
   const readText = io.readText ?? safeReadText;
-  const hasPkgJson = exists(join22(worktree, "package.json"));
+  const hasPkgJson = exists(join23(worktree, "package.json"));
   if (!hasPkgJson) {
-    if (exists(join22(worktree, "deno.json")) || exists(join22(worktree, "deno.jsonc")) || exists(join22(worktree, "deno.lock"))) return "deno";
+    if (exists(join23(worktree, "deno.json")) || exists(join23(worktree, "deno.jsonc")) || exists(join23(worktree, "deno.lock"))) return "deno";
     return null;
   }
-  const pkg = readJson(readText, join22(worktree, "package.json"));
+  const pkg = readJson(readText, join23(worktree, "package.json"));
   const declared = typeof pkg?.packageManager === "string" ? pkg.packageManager.split("@")[0] : void 0;
   if (declared === "pnpm" || declared === "bun" || declared === "npm" || declared === "yarn") return declared;
-  if (exists(join22(worktree, "bun.lock")) || exists(join22(worktree, "bun.lockb"))) return "bun";
-  if (exists(join22(worktree, "pnpm-lock.yaml"))) return "pnpm";
-  if (exists(join22(worktree, "yarn.lock"))) return "yarn";
-  if (exists(join22(worktree, "package-lock.json"))) return "npm";
-  if (exists(join22(worktree, "deno.lock"))) return "deno";
+  if (exists(join23(worktree, "bun.lock")) || exists(join23(worktree, "bun.lockb"))) return "bun";
+  if (exists(join23(worktree, "pnpm-lock.yaml"))) return "pnpm";
+  if (exists(join23(worktree, "yarn.lock"))) return "yarn";
+  if (exists(join23(worktree, "package-lock.json"))) return "npm";
+  if (exists(join23(worktree, "deno.lock"))) return "deno";
   return "npm";
 }
 function jsInstallCommand(pm) {
@@ -11411,7 +11681,7 @@ function detectPlan(worktree, io) {
       // node_modules на месте — установку пропускаем (быстрый путь переиспользованного worktree).
       // У deno каталога может не быть вовсе (кэш в DENO_DIR) — тогда `deno install` отработает
       // заново, но он дешёвый: тянет из того же общего кэша.
-      { label: `${pm} install`, run: jsInstallCommand(pm), skipIfExists: join22(worktree, "node_modules"), source: "detect" }
+      { label: `${pm} install`, run: jsInstallCommand(pm), skipIfExists: join23(worktree, "node_modules"), source: "detect" }
     ];
     for (const target of workspaceBuildTargets(worktree, io)) {
       commands.push({ label: `\u0441\u0431\u043E\u0440\u043A\u0430 ${target.name}`, run: jsRunScript(pm, "build"), cwd: target.dir, source: "detect" });
@@ -11420,12 +11690,12 @@ function detectPlan(worktree, io) {
     return { source: "detect", ecosystem: `node/${pm}`, commands };
   }
   for (const marker of ECOSYSTEM_MARKERS) {
-    const hit = marker.files.some((f) => exists(join22(worktree, f))) || marker.ext !== void 0 && listFiles(worktree).some((n) => n.endsWith(marker.ext));
+    const hit = marker.files.some((f) => exists(join23(worktree, f))) || marker.ext !== void 0 && listFiles(worktree).some((n) => n.endsWith(marker.ext));
     if (!hit) continue;
     let ecosystem = marker.ecosystem;
     let command = marker.command;
     for (const refine of marker.refine ?? []) {
-      if (!exists(join22(worktree, refine.file))) continue;
+      if (!exists(join23(worktree, refine.file))) continue;
       ecosystem = refine.ecosystem;
       command = refine.command;
       break;
@@ -11482,12 +11752,12 @@ var CI_INSTALL_PATTERNS = [
 function ciWorkflowPlan(worktree, io) {
   const readText = io.readText ?? safeReadText;
   const listFiles = io.listFiles ?? safeListFiles;
-  const dir = join22(worktree, ".github", "workflows");
+  const dir = join23(worktree, ".github", "workflows");
   const files = listFiles(dir).filter((n) => n.endsWith(".yml") || n.endsWith(".yaml"));
   const seen = /* @__PURE__ */ new Set();
   const commands = [];
   for (const name of files.sort()) {
-    const yaml = readText(join22(dir, name));
+    const yaml = readText(join23(dir, name));
     if (yaml === null) continue;
     for (const raw of workflowRunLines(yaml)) {
       const line = raw.replace(/\s+/g, " ").trim();
@@ -11502,7 +11772,7 @@ function ciWorkflowPlan(worktree, io) {
   return commands.length ? { source: "ci-workflow", ecosystem: "ci-\u043A\u043E\u043D\u0444\u0438\u0433", commands } : null;
 }
 function workspaceGlobs(worktree, readText) {
-  const yaml = readText(join22(worktree, "pnpm-workspace.yaml"));
+  const yaml = readText(join23(worktree, "pnpm-workspace.yaml"));
   if (yaml !== null) {
     const globs = [];
     let inPackages = false;
@@ -11522,7 +11792,7 @@ function workspaceGlobs(worktree, readText) {
     }
     if (globs.length) return globs;
   }
-  const pkg = readJson(readText, join22(worktree, "package.json"));
+  const pkg = readJson(readText, join23(worktree, "package.json"));
   const ws = pkg?.workspaces;
   const list = Array.isArray(ws) ? ws : Array.isArray(ws?.packages) ? ws.packages : [];
   return list.filter((g) => typeof g === "string");
@@ -11533,14 +11803,14 @@ function workspaceDirs(worktree, globs, io) {
     if (glob.startsWith("!")) continue;
     const star = glob.indexOf("*");
     if (star === -1) {
-      const dir = join22(worktree, glob);
-      if (io.exists(join22(dir, "package.json"))) dirs.add(dir);
+      const dir = join23(worktree, glob);
+      if (io.exists(join23(dir, "package.json"))) dirs.add(dir);
       continue;
     }
-    const base3 = join22(worktree, glob.slice(0, star).replace(/\/$/, ""));
+    const base3 = join23(worktree, glob.slice(0, star).replace(/\/$/, ""));
     for (const name of io.listDirs(base3)) {
-      const dir = join22(base3, name);
-      if (io.exists(join22(dir, "package.json"))) dirs.add(dir);
+      const dir = join23(base3, name);
+      if (io.exists(join23(dir, "package.json"))) dirs.add(dir);
     }
   }
   return [...dirs];
@@ -11568,11 +11838,11 @@ function workspaceBuildTargets(worktree, io = {}) {
   if (!globs.length) return [];
   const pkgs = [];
   for (const dir of workspaceDirs(worktree, globs, { exists, listDirs })) {
-    const pkg = readJson(readText, join22(dir, "package.json"));
+    const pkg = readJson(readText, join23(dir, "package.json"));
     if (!pkg || typeof pkg.name !== "string") continue;
     const scripts = pkg.scripts ?? {};
     const entries = entryPaths(pkg);
-    const needsBuild = typeof scripts.build === "string" && entries.length > 0 && entries.some((e) => !exists(join22(dir, e)));
+    const needsBuild = typeof scripts.build === "string" && entries.length > 0 && entries.some((e) => !exists(join23(dir, e)));
     const deps = Object.keys({ ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} });
     pkgs.push({ name: pkg.name, dir, deps, needsBuild });
   }
@@ -11600,7 +11870,7 @@ function devDatabaseUrl(worktree, io = {}) {
   const fromEnv = (io.env ?? process.env).DATABASE_URL;
   if (fromEnv && fromEnv.trim()) return fromEnv.trim();
   for (const file of [".env", ".env.example"]) {
-    const raw = readText(join22(worktree, file));
+    const raw = readText(join23(worktree, file));
     if (raw === null) continue;
     const m = /^\s*(?:export\s+)?DATABASE_URL\s*=\s*(.*)$/m.exec(raw);
     const value = (m?.[1] ?? "").trim().replace(/^['"]|['"]$/g, "");
@@ -11620,7 +11890,7 @@ function prismaPackages(worktree, io) {
   const readText = io.readText ?? safeReadText;
   const listDirs = io.listDirs ?? safeListDirs;
   const dirs = [worktree, ...workspaceDirs(worktree, workspaceGlobs(worktree, readText), { exists, listDirs })];
-  return dirs.filter((dir) => exists(join22(dir, "prisma", "schema.prisma")) && listDirs(join22(dir, "prisma", "migrations")).length > 0);
+  return dirs.filter((dir) => exists(join23(dir, "prisma", "schema.prisma")) && listDirs(join23(dir, "prisma", "migrations")).length > 0);
 }
 function jsExecBin(pm, command) {
   switch (pm) {
@@ -11657,18 +11927,18 @@ function envCachePlan(worktree, io = {}) {
   if (!pm) return null;
   const parts = [`pm:${pm}`];
   for (const name of ENV_DEFINING_FILES) {
-    const raw = readText(join22(worktree, name));
+    const raw = readText(join23(worktree, name));
     if (raw !== null) parts.push(`${name}
 ${raw}`);
   }
   const pkgDirs = workspaceDirs(worktree, workspaceGlobs(worktree, readText), { exists, listDirs });
   const rels = pkgDirs.map((dir) => dir.slice(worktree.length + 1)).sort();
   for (const rel of ["", ...rels]) {
-    const raw = readText(join22(worktree, rel, "package.json"));
+    const raw = readText(join23(worktree, rel, "package.json"));
     if (raw !== null) parts.push(`${rel}/package.json
 ${raw}`);
   }
-  return { key: fingerprint(parts), dirs: ["node_modules", ...rels.map((rel) => join22(rel, "node_modules"))] };
+  return { key: fingerprint(parts), dirs: ["node_modules", ...rels.map((rel) => join23(rel, "node_modules"))] };
 }
 function planPrepare(worktree, io = {}) {
   const plan = overridePlan(io.override) ?? detectPlan(worktree, io) ?? ciWorkflowPlan(worktree, io);
@@ -11693,7 +11963,7 @@ async function ensureWorktreeDeps(worktree, io = {}) {
     restored: [],
     cached: false
   };
-  if (cachePlan && !exists(join22(worktree, "node_modules"))) {
+  if (cachePlan && !exists(join23(worktree, "node_modules"))) {
     report.restored = await restoreEnvSnapshot(worktree, cachePlan.key, cacheIO) ?? [];
   }
   const plan = planPrepare(worktree, io);
@@ -11880,6 +12150,48 @@ function pruneDefers(episodes, live) {
   for (const key of episodes.keys()) if (!live.has(key)) episodes.delete(key);
 }
 
+// src/spawnRetry.ts
+var numEnv4 = (name, def) => {
+  const v = Number(process.env[name]);
+  return Number.isFinite(v) && v > 0 ? v : def;
+};
+var DEFAULT_SPAWN_RETRY_CONFIG = {
+  baseMs: numEnv4("SWARM_SPAWN_RETRY_BASE_MS", 3e4),
+  maxMs: numEnv4("SWARM_SPAWN_RETRY_MAX_MS", 12e4)
+};
+function spawnRetryBackoffMs(attempts, cfg = DEFAULT_SPAWN_RETRY_CONFIG) {
+  const n = Math.max(0, Math.trunc(attempts));
+  const grown = n >= 30 ? cfg.maxMs : cfg.baseMs * 2 ** n;
+  return Math.min(cfg.maxMs, grown);
+}
+function noteSpawnWaiting(state, runId, now) {
+  const prev = state.get(runId);
+  if (prev) return prev;
+  const entry = { since: now, attempts: 0, lastAt: now };
+  state.set(runId, entry);
+  return entry;
+}
+function spawnRetryDue(state, runId, now, cfg = DEFAULT_SPAWN_RETRY_CONFIG) {
+  const entry = state.get(runId);
+  if (!entry) return false;
+  return now - entry.lastAt >= spawnRetryBackoffMs(entry.attempts, cfg);
+}
+function markSpawnRetry(state, runId, now) {
+  const entry = noteSpawnWaiting(state, runId, now);
+  entry.attempts += 1;
+  entry.lastAt = now;
+  return entry.attempts;
+}
+function clearSpawnRetry(state, runId) {
+  state.delete(runId);
+}
+function holdSpawnRetries(state, now) {
+  for (const entry of state.values()) entry.lastAt = now;
+}
+function pruneSpawnRetries(state, live) {
+  for (const id of [...state.keys()]) if (!live.has(id)) state.delete(id);
+}
+
 // src/spawnAttempts.ts
 init_src();
 var PRE_START_ATTEMPT_LIMIT = 3;
@@ -11982,7 +12294,7 @@ function parkReasonUnretriable(reason) {
 // package.json
 var package_default = {
   name: "@taskless-app/swarm",
-  version: "0.6.38",
+  version: "0.6.40",
   type: "module",
   description: "Local control plane for a fleet of AI coding agents (drones), coordinating through Taskless. The overmind runs the swarm.",
   keywords: [
@@ -12033,7 +12345,7 @@ var package_default = {
     execa: "^10.0.0",
     zod: "3.25.76"
   },
-  gitHead: "b605569670600b022ae6eec5d042c385cc4c77dd"
+  gitHead: "b58ef18678e8c0e03e0602a40bf76d6f0a6975c8"
 };
 
 // src/version.ts
@@ -12637,6 +12949,58 @@ ${out.slice(-CI_SUMMARY_LOG_CHARS)}` : out);
 
 ${logs.join("\n---\n")}` : header;
 }
+var CI_INFRA_MARKERS = [
+  /ENOTEMPTY/,
+  /ENOENT: process.cwd/,
+  /working directory was likely removed/,
+  // Любой ENOENT, назвавший путь установки pnpm. Четвёртая грань той же гонки (02.09, 19:14,
+  // PR #1074): «ENOENT: no such file or directory, chmod '…/setup-pnpm/…/pnpm/bin/pnpx.cjs'» —
+  // установщик распаковал pnpm и пошёл выставлять права, а файла уже нет. Окно гонки тут не
+  // «две джобы стартуют вместе», а миллисекунды посреди работы одного установщика.
+  /ENOENT[^\n]*setup-pnpm/,
+  /Cannot find module '[^']*setup-pnpm/,
+  /Cannot find module '[^']*node_modules\/pnpm\/bin\/pnpm\.cjs'/,
+  /self-installer exits with code/,
+  // Сетевые отказы раннера. Тот же класс: чинить нечего, помогает перезапуск. Держатся
+  // здесь потому, что ИМЕННО ЭТИ строки уже перечислены в `INFRA_MARKERS`
+  // (.github/scripts/typecheck-verdict.sh) — там они не гасят прогон. Пока список был
+  // только там, `ci.yml` вёл себя верно, а демон всё равно будил дрона и жёг попытку
+  // CI_WAKE_LIMIT: разошедшиеся списки давали ровно ту потерю, ради которой заведена
+  // CI-112. Расхождение теперь ловится тестом «списки маркеров сходятся с bash», а не
+  // обещанием держать их одинаковыми.
+  /EACCES/,
+  /ETIMEDOUT/,
+  /ECONNRESET/
+  // Вердикта самой джобы (`::error title=Джоба typecheck не смогла запуститься…`,
+  // .github/scripts/typecheck-verdict.sh) тут намеренно НЕТ, хотя соблазн есть: шаг вердикта
+  // завершается успешно, а `gh run view --log-failed` отдаёт логи только УПАВШИХ шагов — до
+  // роя эта строка не доезжает. Сырые следы из лога упавшего шага доезжают, по ним и судим.
+  // Списки маркеров у скрипта и здесь держим одинаковыми руками: они судят один лог, но
+  // общего кода у bash в `.github/` и пакета, уезжающего в npm, быть не может.
+];
+var CI_CODE_FAILURE_MARKERS = [
+  /error TS\d/,
+  /AssertionError/,
+  /Test Files\s+\d+ failed/,
+  /Tests\s+\d+ failed/,
+  /ERR_PNPM_OUTDATED_LOCKFILE/,
+  // Vitest-символы. `×` (U+00D7) сюда НЕ берём: он встречается в обычном тексте логов
+  // (размеры вида 1920×1080) и делал бы «есть дефект кода» из любого скриншот-прогона.
+  /✕|✗/,
+  // Playwright: у него свои символы и своя сводка — ни `Test Files`, ни `✕` он не печатает.
+  // Без этих двух строк упавший e2e рядом с инфра-падением соседней джобы уезжал в
+  // «это окружение», и дрона не будили вовсе (логи ВСЕХ упавших джоб прогона приезжают
+  // одним куском: `gh run view <run-id> --log-failed`, см. ciFailureSummary).
+  /✘/,
+  // НЕ якорим на начало строки: `gh run view --log-failed` печатает каждую строку с
+  // префиксом «джоба<TAB>шаг<TAB>время», и якорь `^\s*` не совпал бы никогда.
+  /\b\d+ failed\b/
+];
+function isInfraCiFailure(summary) {
+  if (!summary) return false;
+  if (CI_CODE_FAILURE_MARKERS.some((re) => re.test(summary))) return false;
+  return CI_INFRA_MARKERS.some((re) => re.test(summary));
+}
 
 // src/droneServer.ts
 init_droneChannel();
@@ -12649,8 +13013,8 @@ import { z } from "zod";
 init_git();
 
 // src/diff.ts
-import { statSync as statSync10 } from "fs";
-import { join as join27 } from "path";
+import { statSync as statSync12 } from "fs";
+import { join as join28 } from "path";
 import { $ as $4 } from "execa";
 var MAX_FILES = 200;
 var MAX_LINES_PER_FILE = 1500;
@@ -12793,7 +13157,7 @@ async function resolveBase(wt, baseBranch) {
 }
 function mtime(path) {
   try {
-    return statSync10(path).mtimeMs;
+    return statSync12(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -12818,7 +13182,7 @@ async function collectRunDiff(worktree, opts = {}) {
       files.push(pf);
     }
   }
-  files.sort((a, b) => mtime(join27(worktree, b.path)) - mtime(join27(worktree, a.path)));
+  files.sort((a, b) => mtime(join28(worktree, b.path)) - mtime(join28(worktree, a.path)));
   const truncatedFiles = files.length > MAX_FILES;
   if (truncatedFiles) files = files.slice(0, MAX_FILES);
   const added = files.reduce((s, f) => s + f.added, 0);
@@ -14898,20 +15262,20 @@ function makeMergeGateParts(deps) {
 
 // src/envGate.ts
 import { existsSync as existsSync17 } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 import { createConnection } from "net";
 import { execa as execa2 } from "execa";
 
 // src/platform.ts
-import { existsSync as existsSync16, readFileSync as readFileSync21 } from "fs";
-import { delimiter, join as join28 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync22 } from "fs";
+import { delimiter, join as join29 } from "path";
 function resolveCommandPath(name, env = process.env, platform = process.platform) {
   if (name.includes("/") || name.includes("\\")) return existsSync16(name) ? name : null;
   const dirs = (env.PATH ?? env.Path ?? "").split(delimiter).filter(Boolean);
   const exts = platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").filter(Boolean) : [""];
   for (const dir of dirs) {
     for (const ext of exts) {
-      const candidate = join28(dir, name + ext);
+      const candidate = join29(dir, name + ext);
       if (existsSync16(candidate)) return candidate;
     }
   }
@@ -14996,7 +15360,7 @@ var COMPOSE_MARKERS = [
 ];
 function detectRequirements(repo, io = {}) {
   const exists = io.exists ?? existsSync17;
-  const marker = COMPOSE_MARKERS.find((f) => exists(join29(repo, f)));
+  const marker = COMPOSE_MARKERS.find((f) => exists(join30(repo, f)));
   return marker ? [{ kind: "docker", raw: `docker (\u0434\u0435\u0442\u0435\u043A\u0442: ${marker})` }] : [];
 }
 function resolveRequirements(repo, declared, io = {}) {
@@ -15018,11 +15382,11 @@ async function hasCommand(name, env) {
   return hasCommandInPath(name, env);
 }
 async function portOpen(host, port) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const socket = createConnection({ host, port });
     const finish = (ok) => {
       socket.destroy();
-      resolve4(ok);
+      resolve5(ok);
     };
     socket.setTimeout(PORT_TIMEOUT_MS);
     socket.once("connect", () => finish(true));
@@ -16571,14 +16935,14 @@ function makeHandler(deps) {
       const ref = url.searchParams.get("pr") ?? "";
       if (!ref.trim()) return Response.json({ error: "\u043D\u0443\u0436\u0435\u043D \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440 pr=<url|\u043D\u043E\u043C\u0435\u0440>" }, { status: 400 });
       const ctxRepo = url.searchParams.get("repo");
-      const resolve4 = deps.mergeGate ?? makeMergeGateResolver({
+      const resolve5 = deps.mergeGate ?? makeMergeGateResolver({
         listRuns: () => deps.db.listRuns(),
         fallbackAutoReview: SWARM_AUTO_REVIEW,
         autoVerify: SWARM_AUTO_VERIFY,
         // TASWM-344
         ...defaultRepo ? { repoFallback: defaultRepo } : {}
       });
-      return Response.json(await resolve4(ref, ctxRepo));
+      return Response.json(await resolve5(ref, ctxRepo));
     }
     if (p === "/resources") return Response.json(hostResourceSnapshot());
     if (p === "/timeline") return Response.json(timelineState(deps.db, Date.now(), readNarratorLog(deps.narratorLog)));
@@ -16731,22 +17095,22 @@ function startWeb(deps, port = WEB_PORT) {
   return { port, server };
 }
 function closeWebServer(server) {
-  return new Promise((resolve4) => {
-    server.close(() => resolve4());
+  return new Promise((resolve5) => {
+    server.close(() => resolve5());
     server.closeAllConnections?.();
   });
 }
 
 // src/hostCommands.ts
 init_src();
-import { readFileSync as readFileSync22, renameSync as renameSync10, writeFileSync as writeFileSync15 } from "fs";
-import { join as join30 } from "path";
+import { readFileSync as readFileSync23, renameSync as renameSync10, writeFileSync as writeFileSync15 } from "fs";
+import { join as join31 } from "path";
 function hostCommandStatePath(home) {
-  return join30(home, "host-command.json");
+  return join31(home, "host-command.json");
 }
 function readState(path) {
   try {
-    return JSON.parse(readFileSync22(path, "utf8"));
+    return JSON.parse(readFileSync23(path, "utf8"));
   } catch {
     return {};
   }
@@ -16917,7 +17281,7 @@ async function doRestart(cmd, opts, note) {
 // src/selfUpdate.ts
 init_git();
 import { existsSync as existsSync18 } from "fs";
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 import { $ as $5 } from "execa";
 var DAEMON_PACKAGE = "@taskless-app/swarm";
 var defaultRun = async (cmd, args, cwd) => {
@@ -16959,7 +17323,7 @@ async function runSelfUpdate(io) {
     };
   }
   await io.onStep("install", "\u0441\u0442\u0430\u0432\u043B\u044E \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0438");
-  if (!exists(join31(repo, "pnpm-lock.yaml"))) {
+  if (!exists(join32(repo, "pnpm-lock.yaml"))) {
     return { ok: false, step: "install", message: "\u0432 \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0438 \u0434\u0435\u043C\u043E\u043D\u0430 \u043D\u0435\u0442 pnpm-lock.yaml \u2014 \u043E\u0431\u043D\u043E\u0432\u043B\u044F\u0442\u044C \u0435\u0433\u043E \u044D\u0442\u0438\u043C \u043F\u0443\u0442\u0451\u043C \u043D\u0435 \u0431\u0435\u0440\u0443\u0441\u044C" };
   }
   const installed2 = await run("pnpm", ["install", "--frozen-lockfile"], repo);
@@ -17066,7 +17430,7 @@ function executorHealthy(opts = {}) {
   const executor = opts.executor ?? resolveExecutor();
   const bin = opts.bin ?? executor.resolveBin();
   const timeoutMs = opts.timeoutMs ?? 2e4;
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let done = false;
     let out = "";
     const finish = (r) => {
@@ -17077,7 +17441,7 @@ function executorHealthy(opts = {}) {
         child.kill("SIGKILL");
       } catch {
       }
-      resolve4(r);
+      resolve5(r);
     };
     const child = spawn3(bin, [...executor.probe.args], { stdio: ["ignore", "pipe", "pipe"] });
     child.stdout?.on("data", (d) => {
@@ -17118,19 +17482,19 @@ async function fetchExternalStorm(url, opts = {}) {
 }
 
 // src/anomalyState.ts
-import { existsSync as existsSync19, readFileSync as readFileSync23, renameSync as renameSync11, writeFileSync as writeFileSync16 } from "fs";
-import { join as join32 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync24, renameSync as renameSync11, writeFileSync as writeFileSync16 } from "fs";
+import { join as join33 } from "path";
 var KEY_TTL_MS = 7 * 24 * 60 * 6e4;
 var MAX_RESOLVED = 200;
 function emptyState() {
   return { since: {}, lastFiredAt: {}, fires: {}, resolved: [], stopQuiet: null };
 }
 function anomalyStatePath(home) {
-  return join32(home, "anomaly-state.json");
+  return join33(home, "anomaly-state.json");
 }
 function loadAnomalyState(home, now = Date.now(), io = {}) {
   const exists = io.exists ?? existsSync19;
-  const readFile2 = io.readFile ?? ((p) => readFileSync23(p, "utf8"));
+  const readFile2 = io.readFile ?? ((p) => readFileSync24(p, "utf8"));
   const path = anomalyStatePath(home);
   if (!exists(path)) return emptyState();
   try {
@@ -17642,6 +18006,7 @@ var CI_POLL_LIMIT_MARK = "\u043E\u043F\u0440\u043E\u0441 CI \u043E\u0441\u0442\u
 var CI_DENIED_LIMIT = Number(process.env.SWARM_CI_DENIED_LIMIT) || 3;
 var CI_DENIED_MARK = "\u043D\u0435\u0442 \u0434\u043E\u0441\u0442\u0443\u043F\u0430 \u043A \u0447\u0435\u043A\u0430\u043C (403)";
 var CI_DENIED_STOP_MARK = "\u043E\u043F\u0440\u043E\u0441 CI \u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D: \u043D\u0435\u0442 \u0434\u043E\u0441\u0442\u0443\u043F\u0430 (403)";
+var CI_INFRA_MARK = "\u0443\u043F\u0430\u043B \u043D\u0435 \u043A\u043E\u0434, \u0430 \u043E\u043A\u0440\u0443\u0436\u0435\u043D\u0438\u0435 \u0434\u0436\u043E\u0431\u044B";
 var CI_WAIT_LIMIT_MS = Number(process.env.SWARM_CI_WAIT_LIMIT_MS) || 45 * 60 * 1e3;
 var CI_POLL_LIMIT = Math.max(
   Number(process.env.SWARM_CI_POLL_LIMIT) || 90,
@@ -18326,10 +18691,10 @@ ${task.description}` : `\u0417\u0430\u0434\u0430\u0447\u0430 ${run.task_slug} (\
   }
   return parts.join("\n");
 }
-var HERO_CHARTER_PATH = join33(dirname5(THIS_FILE), "..", "docs", "HERO.md");
+var HERO_CHARTER_PATH = join34(dirname5(THIS_FILE), "..", "docs", "HERO.md");
 function buildHeroPrompt(task, run, taskContext, attachmentsBlock) {
   const name = run.name || `#${run.id}`;
-  const charter = readFileSync24(HERO_CHARTER_PATH, "utf8");
+  const charter = readFileSync25(HERO_CHARTER_PATH, "utf8");
   const head = task ? `\u042D\u041F\u0418\u041A ${run.task_slug}: ${task.title}
 
 ${task.description}` : `\u042D\u041F\u0418\u041A ${run.task_slug} (\u0442\u0435\u043B\u043E \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u043D\u043E \u2014 \u0440\u0430\u0431\u043E\u0442\u0430\u0439 \u043F\u043E slug \u0438 \u0437\u0434\u0440\u0430\u0432\u043E\u043C\u0443 \u0441\u043C\u044B\u0441\u043B\u0443).`;
@@ -18757,9 +19122,9 @@ function repoHasCi(deps, run) {
 function repoHasCiWorkflows(worktreePath, repo) {
   for (const base3 of [worktreePath, repo]) {
     if (!base3) continue;
-    const dir = join33(base3, ".github", "workflows");
+    const dir = join34(base3, ".github", "workflows");
     try {
-      if (readdirSync13(dir).some((f) => f.endsWith(".yml") || f.endsWith(".yaml"))) return true;
+      if (readdirSync14(dir).some((f) => f.endsWith(".yml") || f.endsWith(".yaml"))) return true;
     } catch {
     }
   }
@@ -18850,6 +19215,21 @@ async function wakeAuthorOnRedCi(deps, run, now, ci, worktreeExists, hasTranscri
   const wt = run.worktree_path;
   if (!wt || !worktreeExists(wt) || !hasTranscript(wt)) return false;
   const summary = await deps.ci.failureSummary(ci.failing, ci.failingRunIds).catch(() => null) ?? `\u274C CI \u0443\u043F\u0430\u043B: ${ci.failing.join(", ") || "(\u0441\u043C. gh pr checks)"}`;
+  if (isInfraCiFailure(summary)) {
+    const seen = ciStreak(deps.db, run.id, CI_INFRA_MARK).count;
+    deps.db.addEvent(
+      run.id,
+      "ci_checked",
+      `CI fail (${ci.failing.join(", ") || "?"}) \u2014 ${CI_INFRA_MARK}; \u0434\u0440\u043E\u043D\u0430 \u043D\u0435 \u0431\u0443\u0436\u0443, \u0447\u0438\u043D\u0438\u0442\u0441\u044F \u043F\u0435\u0440\u0435\u0437\u0430\u043F\u0443\u0441\u043A\u043E\u043C \u0434\u0436\u043E\u0431 [${CI_WAIT_POLL_MARK}]`
+    );
+    if (seen === 0) {
+      narrate(
+        deps,
+        `CI \u0443 ${droneLabel(run)} \u043A\u0440\u0430\u0441\u043D\u044B\u0439 \u043D\u0435 \u043F\u043E \u043A\u043E\u0434\u0443 \u2014 \u0434\u0436\u043E\u0431\u0430 \u043D\u0435 \u0441\u043C\u043E\u0433\u043B\u0430 \u0437\u0430\u043F\u0443\u0441\u0442\u0438\u0442\u044C\u0441\u044F (\u0440\u0430\u043D\u043D\u0435\u0440\u044B). \u0414\u0440\u043E\u043D\u0430 \u043D\u0435 \u0431\u0443\u0436\u0443: \u0447\u0438\u043D\u0438\u0442\u044C \u0435\u043C\u0443 \u0442\u0430\u043C \u043D\u0435\u0447\u0435\u0433\u043E, \u043D\u0443\u0436\u0435\u043D \u043F\u0435\u0440\u0435\u0437\u0430\u043F\u0443\u0441\u043A \u0443\u043F\u0430\u0432\u0448\u0438\u0445 \u0434\u0436\u043E\u0431 (gh run rerun --failed).`
+      );
+    }
+    return true;
+  }
   try {
     await deps.respawn(run, "continue", buildCiWakeNudge(summary));
     deps.db.addEvent(run.id, "ci_wake", `CI \u0443\u043F\u0430\u043B (${ci.failing.join(", ") || "?"}) \u2014 \u0431\u0443\u0436\u0443 \u0434\u0440\u043E\u043D\u0430 \u0441\u043E \u0441\u0436\u0430\u0442\u044B\u043C summary`);
@@ -19638,9 +20018,22 @@ async function manageRelief(deps, now, droneCap, stormActive) {
   const needsRelief = deps.reliefNeeded ? deps.reliefNeeded() : false;
   const resourcesOk2 = deps.resourcesOk();
   state.reliefSince = needsRelief ? state.reliefSince ?? now : null;
+  if (state.reliefSince == null) state.soleWorkerNoted = false;
   if (!resourcesOk2 || needsRelief) state.overloadedAt = now;
   if (needsRelief && deps.kill && pauseDue(state.reliefSince, state.lastPauseAt ?? null, now, cfg)) {
-    const candidate = pickPauseCandidate(deps.db.listRuns("running"), new Set(heavyRunsInFlight(deps).map((r) => r.id)));
+    const running = deps.db.listRuns("running");
+    if (reliefWouldStrangleSoleWorker(running)) {
+      const alone = loadBearingRuns(running)[0];
+      if (alone && !state.soleWorkerNoted) {
+        state.soleWorkerNoted = true;
+        const why = reliefSoleWorkerReason(deps.reliefDecisionText?.() ?? null);
+        deps.db.addEvent(alone.id, "note", why);
+        narrate(deps, `${droneLabel(alone)} \u043E\u0434\u0438\u043D \u043D\u0430 \u043C\u0430\u0448\u0438\u043D\u0435 \u2014 \u0440\u0430\u0437\u0433\u0440\u0443\u0437\u043A\u0430 \u0435\u0433\u043E \u043D\u0435 \u0441\u043D\u0438\u043C\u0430\u0435\u0442. ${why}`);
+        console.warn(`[overmind] \u0440\u0430\u0437\u0433\u0440\u0443\u0437\u043A\u0430: ${why}`);
+      }
+      return;
+    }
+    const candidate = pickPauseCandidate(running, new Set(heavyRunsInFlight(deps).map((r) => r.id)));
     if (candidate) {
       const decisionText = deps.reliefDecisionText?.() ?? null;
       let stepsSinceResume = null;
@@ -19777,6 +20170,43 @@ async function manageRelief(deps, now, droneCap, stormActive) {
     return;
   }
 }
+function hostNotAcceptingReason(deps, droneCap, stormActive) {
+  if (stormActive) return "\u0440\u043E\u0439 \u0432 \u0448\u0442\u043E\u0440\u043C\u043E\u0432\u043E\u043C \u0440\u0435\u0436\u0438\u043C\u0435";
+  if (deps.control?.paused) return "\u043E\u043F\u0435\u0440\u0430\u0442\u043E\u0440 \u043E\u0441\u0442\u0430\u043D\u043E\u0432\u0438\u043B \u043F\u0440\u0438\u0451\u043C \u043D\u043E\u0432\u043E\u0439 \u0440\u0430\u0431\u043E\u0442\u044B \u043D\u0430 \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435";
+  if (deps.resourcesOk && !deps.resourcesOk()) return deps.gateReason?.() ?? "\u0440\u0435\u0441\u0443\u0440\u0441-\u0433\u0435\u0439\u0442 \u0437\u0430\u043A\u0440\u044B\u0442";
+  const active = countActiveDrones(deps.db);
+  if (active >= droneCap) return `\u0441\u043B\u043E\u0442\u043E\u0432 \u043D\u0435\u0442 (\u0434\u0440\u043E\u043D\u043E\u0432 ${active} \u0438\u0437 ${droneCap})`;
+  return null;
+}
+async function retryDeferredSpawns(deps, now, droneCap, stormActive) {
+  const state = deps.spawnRetry ??= /* @__PURE__ */ new Map();
+  const cfg = deps.spawnRetryConfig ? { ...DEFAULT_SPAWN_RETRY_CONFIG, ...deps.spawnRetryConfig } : DEFAULT_SPAWN_RETRY_CONFIG;
+  const waiting = orderQueue(deps.db.listRuns("queued").filter((r) => deps.db.unmetDeps(r.depends_on).length === 0));
+  pruneSpawnRetries(state, new Set(waiting.map((r) => r.id)));
+  if (!waiting.length) return;
+  for (const run of waiting) noteSpawnWaiting(state, run.id, now);
+  const closed = hostNotAcceptingReason(deps, droneCap, stormActive);
+  if (closed) {
+    holdSpawnRetries(state, now);
+    return;
+  }
+  const relief = deps.relief ?? (deps.relief = {});
+  const reliefCfg = relief.config ? resolveReliefConfig(relief.config) : DEFAULT_RELIEF_CONFIG;
+  if (!rampDue(relief.lastRampAt ?? null, now, reliefCfg)) return;
+  for (const run of waiting) {
+    if (!spawnRetryDue(state, run.id, now, cfg)) continue;
+    const entry = state.get(run.id);
+    const attempt = markSpawnRetry(state, run.id, now);
+    console.error(
+      `[overmind] \u043F\u043E\u0432\u0442\u043E\u0440 \u043E\u0442\u043B\u043E\u0436\u0435\u043D\u043D\u043E\u0433\u043E \u0441\u043F\u0430\u0432\u043D\u0430 \u2116${attempt}: ${droneLabel(run)} (${run.task_slug}) \u0436\u0434\u0451\u0442 \u0432 \u043E\u0447\u0435\u0440\u0435\u0434\u0438 ${humanMinutes(now - entry.since)}, \u0445\u043E\u0441\u0442 \u043F\u0440\u0438\u043D\u0438\u043C\u0430\u0435\u0442 \u2014 \u043F\u0440\u043E\u0431\u0443\u044E \u0441\u043D\u043E\u0432\u0430 (\u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0438\u0439 \u043E\u0442\u0441\u0442\u0443\u043F ${Math.round(spawnRetryBackoffMs(attempt, cfg) / 1e3)}\u0441, TASWM-549)`
+    );
+    const outcome = await trySpawnQueuedRun(deps, run);
+    if (outcome !== "skipped") clearSpawnRetry(state, run.id);
+    if (outcome === "closed") continue;
+    if (outcome !== "skipped") relief.lastRampAt = now;
+    return;
+  }
+}
 async function buildReliefCostCandidatesFor(deps, now, droneCap) {
   const state = deps.relief?.cost;
   if (!state) return [];
@@ -20162,6 +20592,11 @@ async function tickOnce(deps) {
   if (!stormActive) {
     await resumeWatchdogParked(deps, droneCap);
   }
+  try {
+    await retryDeferredSpawns(deps, now, droneCap, stormActive);
+  } catch (e) {
+    console.error("[overmind] \u043F\u043E\u0432\u0442\u043E\u0440 \u043E\u0442\u043B\u043E\u0436\u0435\u043D\u043D\u043E\u0433\u043E \u0441\u043F\u0430\u0432\u043D\u0430 \u0441\u043E\u0440\u0432\u0430\u043B\u0441\u044F:", e);
+  }
   for (let run of deps.db.listRuns("review")) {
     try {
       if (run.resolves_run_id != null) {
@@ -20800,6 +21235,27 @@ async function replayDecision(deps, qid, chosen, by = "human") {
   deps.db.supersede(old.id, fresh.id, by);
   return fresh;
 }
+var STOP_POLL_MS = 200;
+var STOP_TERM_GRACE_MS = 1e4;
+var STOP_KILL_GRACE_MS = 3e3;
+async function awaitDroneDeath(deps, pid) {
+  const isAlive = deps.isAlive;
+  if (!isAlive) return false;
+  const wait = deps.wait ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const poll = async (budgetMs) => {
+    for (let spent = 0; spent < budgetMs; spent += STOP_POLL_MS) {
+      if (!isAlive(pid)) return true;
+      await wait(STOP_POLL_MS);
+    }
+    return !isAlive(pid);
+  };
+  if (await poll(STOP_TERM_GRACE_MS)) return true;
+  try {
+    (deps.hardKill ?? deps.kill)(pid);
+  } catch {
+  }
+  return await poll(STOP_KILL_GRACE_MS);
+}
 async function cancelRun(deps, slug, reason) {
   const run = deps.db.activeRunForSlug(slug);
   if (!run) return null;
@@ -20808,11 +21264,21 @@ async function cancelRun(deps, slug, reason) {
       deps.kill(run.pid);
     } catch {
     }
+    if (deps.isAlive && !await awaitDroneDeath(deps, run.pid)) {
+      deps.db.addEvent(
+        run.id,
+        "anomaly",
+        `\u043F\u0440\u043E\u0446\u0435\u0441\u0441 \u0434\u0440\u043E\u043D\u0430 (pid ${run.pid}) \u043F\u0435\u0440\u0435\u0436\u0438\u043B \u0438 SIGTERM, \u0438 SIGKILL \u2014 worktree ${run.worktree_path ?? ""} \u0441\u043D\u043E\u0448\u0443 \u043F\u043E\u0432\u0435\u0440\u0445 \u0436\u0438\u0432\u043E\u0433\u043E. \u0415\u0441\u043B\u0438 \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0438\u0439 \u0441\u043F\u0430\u0432\u043D \u044D\u0442\u043E\u0433\u043E \u0441\u043B\u0430\u0433\u0430 \u0443\u043F\u0440\u0451\u0442\u0441\u044F \u0432 \u0437\u0430\u043D\u044F\u0442\u044B\u0439 \u043F\u0443\u0442\u044C, \u043D\u0430\u0447\u043D\u0438\u0442\u0435 \u043E\u0442\u0441\u044E\u0434\u0430.`
+      );
+    }
   }
   if (run.worktree_path) await deps.removeWorktree(run.repo, run.worktree_path).catch(() => {
   });
   return deps.db.cancel(run.id, reason);
 }
+function detachedHelperWorktree(db) {
+  return (repo, branch, wt) => prepareDetachedWorktree(repo, branch, wt, { isWorktreeHeldLive: (p) => worktreePathHeldLive(db, p) });
+}
 async function resolveConflict(deps, reviewRun) {
   const repo = normalizeRepo(reviewRun.repo || deps.repoFallback);
   const branch = await worktreeBranchFor(reviewRun, deps.prHeadBranch);
@@ -20830,7 +21296,7 @@ async function resolveConflict(deps, reviewRun) {
     model: reviewRun.model,
     review_model: reviewRun.review_model
   });
-  const wt = join33(deps.worktreesDir, basename6(repo), `${reviewRun.task_slug}-resolve-${resolver.id}`);
+  const wt = join34(deps.worktreesDir, basename6(repo), `${reviewRun.task_slug}-resolve-${resolver.id}`);
   try {
     await deps.git.prepareDetachedWorktree(repo, branch, wt);
     await deps.git.setWorktreeIdentity(wt, resolver.name);
@@ -20909,7 +21375,7 @@ async function spawnReviewer(deps, reviewRun, files) {
     // (своей у ревьюера нет, TASWM-204), и коммент с вердиктом должен уехать именно туда.
     workspace_id: reviewRun.workspace_id
   });
-  const wt = join33(deps.worktreesDir, basename6(repo), `${reviewRun.task_slug}-review-${reviewer.id}`);
+  const wt = join34(deps.worktreesDir, basename6(repo), `${reviewRun.task_slug}-review-${reviewer.id}`);
   try {
     await deps.git.prepareDetachedWorktree(repo, branch, wt);
     await deps.git.setWorktreeIdentity(wt, reviewer.name);
@@ -20990,7 +21456,7 @@ async function spawnVerifier(deps, verifiedRun, files) {
     // штамп цикла: фикс-итерацию проверяет свежий верификатор
     workspace_id: verifiedRun.workspace_id
   });
-  const wt = join33(deps.worktreesDir, basename6(repo), `${verifiedRun.task_slug}-verify-${verifier.id}`);
+  const wt = join34(deps.worktreesDir, basename6(repo), `${verifiedRun.task_slug}-verify-${verifier.id}`);
   try {
     await deps.git.prepareDetachedWorktree(repo, branch, wt);
     await deps.git.setWorktreeIdentity(wt, verifier.name);
@@ -21142,7 +21608,7 @@ async function makeStore(repo, worktreesDir, repoFlag) {
       console.warn(`[overmind] \u043D\u0435 \u0441\u043C\u043E\u0433 \u0437\u0430\u043F\u043E\u043C\u043D\u0438\u0442\u044C \u043F\u0443\u0442\u044C \u043A \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u044E (${e instanceof Error ? e.message : e}) \u2014 \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0438\u0439 \u0437\u0430\u043F\u0443\u0441\u043A \u0441\u043D\u043E\u0432\u0430 \u043F\u043E\u043F\u0440\u043E\u0441\u0438\u0442 --repo`);
     }
   }
-  const scanRootsList = resolveScanRoots(SWARM_SCAN_ROOTS_RAW, homedir6(), repoPaths);
+  const scanRootsList = resolveScanRoots(SWARM_SCAN_ROOTS_RAW, homedir7(), repoPaths);
   const repoMap = emptyRepoMapState(scanRootsList);
   if (SWARM_BACKEND !== "client") {
     const { SwarmDb: SwarmDb2 } = await loadSqlite();
@@ -21236,7 +21702,7 @@ async function migrateWorktreesAtStartup() {
       exists: (d) => existsSync20(d),
       isNonEmptyDir: (d) => {
         try {
-          return readdirSync13(d).length > 0;
+          return readdirSync14(d).length > 0;
         } catch {
           return false;
         }
@@ -21627,7 +22093,7 @@ async function runDaemon(opts) {
         repoFallback: opts.repo,
         worktreesDir,
         launch,
-        git: { prepareDetachedWorktree, setWorktreeIdentity, removeWorktree },
+        git: { prepareDetachedWorktree: detachedHelperWorktree(db), setWorktreeIdentity, removeWorktree },
         // TASWM-356: ветка ревьюера — фактическая ветка PR. Штатно она уже в поле прогона
         // (реконсайл синхронит её из headBranch), этот ридер — для прогонов без неё.
         prHeadBranch,
@@ -21662,7 +22128,7 @@ async function runDaemon(opts) {
         repoFallback: opts.repo,
         worktreesDir,
         launch,
-        git: { prepareDetachedWorktree, setWorktreeIdentity, removeWorktree },
+        git: { prepareDetachedWorktree: detachedHelperWorktree(db), setWorktreeIdentity, removeWorktree },
         prHeadBranch,
         ...verifyModeReader ? { verifyMode: verifyModeReader } : {},
         ...checkerAttachments ? { taskAttachments: checkerAttachments } : {}
@@ -22006,7 +22472,7 @@ async function runDaemon(opts) {
         repoFallback: opts.repo,
         worktreesDir,
         launch,
-        git: { prepareDetachedWorktree, setWorktreeIdentity, remoteMainRef, remoteBaseRef, mergeRef, pushHeadTo, removeWorktree },
+        git: { prepareDetachedWorktree: detachedHelperWorktree(db), setWorktreeIdentity, remoteMainRef, remoteBaseRef, mergeRef, pushHeadTo, removeWorktree },
         prHeadBranch
         // TASWM-356: ветка PR для прогонов без записанного поля branch
       },
@@ -22204,6 +22670,10 @@ async function runDaemon(opts) {
           {
             db,
             kill: (pid) => killProcessGroup(pid, "SIGTERM"),
+            // TASWM-553: остановка обязана ОСВОБОДИТЬ машину — значит, дождаться смерти
+            // процесса и только потом сносить worktree (иначе платит следующий спавн).
+            isAlive: pidAlive,
+            hardKill: (pid) => killProcessGroup(pid, "SIGKILL"),
             removeWorktree: (repo, p) => removeWorktree(repo || opts.repo, p)
           },
           slug,
@@ -22389,6 +22859,9 @@ async function runDaemon(opts) {
       {
         db,
         kill: (pid) => killProcessGroup(pid, "SIGTERM"),
+        isAlive: pidAlive,
+        // TASWM-553: снос worktree — после смерти процесса, не следом за SIGTERM
+        hardKill: (pid) => killProcessGroup(pid, "SIGKILL"),
         removeWorktree: (repo, p) => removeWorktree(repo || opts.repo, p)
       },
       slug,
@@ -22489,6 +22962,7 @@ export {
   CI_DENIED_LIMIT,
   CI_DENIED_MARK,
   CI_DENIED_STOP_MARK,
+  CI_INFRA_MARK,
   CI_NO_CHECKS_MARK,
   CI_POLL_LIMIT,
   CI_POLL_LIMIT_MARK,