@taskless-app/swarm 0.6.62 → 0.6.63

package/dist/overmind.js

@@ -592,10 +592,10 @@ function pick(rows) {
   return newest(rows.filter((r) => r.author)) ?? newest(rows);
 }
 function pickRunForPr(rows, ref, ctxRepo) {
-  const num = prNumberOf(ref);
-  if (num == null) return null;
+  const num2 = prNumberOf(ref);
+  if (num2 == null) return null;
   const target = repoKeyOf(ref) ?? repoKeyOf(ctxRepo);
-  const hits = rows.filter((r) => r.prUrl && prNumberOf(r.prUrl) === num);
+  const hits = rows.filter((r) => r.prUrl && prNumberOf(r.prUrl) === num2);
   if (hits.length === 0) return null;
   if (target) {
     const mine = hits.filter((r) => keyOf(r) === target);
@@ -647,6 +647,9 @@ var init_returnReason = __esm({
 });
 
 // ../swarm-core/src/modelPolicy.ts
+function isHarnessDefaultModel(model) {
+  return typeof model === "string" && model.trim().toLowerCase() === HARNESS_DEFAULT_MODEL;
+}
 function findProvider(id) {
   const key = typeof id === "string" ? id.trim().toLowerCase() : "";
   return MODEL_PROVIDERS.find((p) => p.id === key) ?? null;
@@ -698,6 +701,17 @@ var init_modelPolicy = __esm({
         selectable: true,
         roles: { executor: "glm-5.3", review: "glm-5.3" }
       },
+      // Grok CLI. Каталог — живой `grok models` (16.10.2026), целиком и без выдуманных
+      // имён: grok-4.7 (дефолт CLI и исполнителя), grok-4.7-build-fast, grok-4.6, grok-4.5
+      // (проверка — младшая, та же идея, что sonnet против opus). Тарифа нет: цену пишет CLI.
+      {
+        id: "xai",
+        label: "xAI (Grok)",
+        executorId: "grok",
+        selectable: true,
+        roles: { executor: "grok-4.7", review: "grok-4.5" },
+        models: ["grok-4.7", "grok-4.7-build-fast", "grok-4.6", "grok-4.5"]
+      },
       // TASWM-565 · шаг 1 из четырёх: провайдер в реестре ЕСТЬ, выбрать его ещё нельзя.
       // Имён моделей здесь нет СОЗНАТЕЛЬНО: у владельца подписка, состав моделей в ней нам
       // неизвестен, а выдуманное имя хуже маркера «решает Codex».
@@ -1183,18 +1197,18 @@ var init_hosts = __esm({
 function parseHostResources(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
   const v = raw;
-  const num = (x) => typeof x === "number" && Number.isFinite(x) ? x : null;
-  const memFreeGb = num(v.memFreeGb);
-  const memTotalGb = num(v.memTotalGb);
+  const num2 = (x) => typeof x === "number" && Number.isFinite(x) ? x : null;
+  const memFreeGb = num2(v.memFreeGb);
+  const memTotalGb = num2(v.memTotalGb);
   if (memFreeGb == null || memTotalGb == null) return null;
   if (typeof v.measuredAt !== "string" || Number.isNaN(Date.parse(v.measuredAt))) return null;
-  const cpu = num(v.cpuBusyPct);
+  const cpu = num2(v.cpuBusyPct);
   return {
     cpuBusyPct: cpu == null ? null : Math.min(100, Math.max(0, cpu)),
     memFreeGb,
     memTotalGb,
-    diskFreeGb: num(v.diskFreeGb),
-    diskTotalGb: num(v.diskTotalGb),
+    diskFreeGb: num2(v.diskFreeGb),
+    diskTotalGb: num2(v.diskTotalGb),
     measuredAt: v.measuredAt
   };
 }
@@ -1211,6 +1225,7 @@ var init_hostPool = __esm({
   "../swarm-core/src/hostPool.ts"() {
     "use strict";
     init_hosts();
+    init_modelPolicy();
     HOST_REJECTION_TEXT = {
       offline: "\u043D\u0435 \u043D\u0430 \u0441\u0432\u044F\u0437\u0438",
       tick_stalled: `\u0446\u0438\u043A\u043B \u0440\u0435\u043A\u043E\u043D\u0441\u0430\u0439\u043B\u0430 \u0432\u0441\u0442\u0430\u043B \u2014 \u043F\u0443\u043B\u044C\u0441 \u0438\u0434\u0451\u0442, \u0440\u0430\u0431\u043E\u0442\u0443 \u043D\u0435 \u0431\u0435\u0440\u0451\u0442; ${HOST_TICK_STALLED_ACTION}`,
@@ -2330,10 +2345,10 @@ function launchCostUsd(result, model) {
   return costFromUsage(result.usage, model);
 }
 function launchSpend(result) {
-  const num = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
+  const num2 = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
   const sum = (u) => ({
-    tokensIn: num(u.input_tokens) + num(u.cache_creation_input_tokens) + num(u.cache_read_input_tokens),
-    tokensOut: num(u.output_tokens)
+    tokensIn: num2(u.input_tokens) + num2(u.cache_creation_input_tokens) + num2(u.cache_read_input_tokens),
+    tokensOut: num2(u.output_tokens)
   });
   const spend = sum(result.usage ?? {});
   if (spend.tokensIn === 0 && spend.tokensOut === 0 && result.modelUsage) {
@@ -2343,7 +2358,7 @@ function launchSpend(result) {
       spend.tokensOut += perModel.tokensOut;
     }
   }
-  return { ...spend, durationMs: num(result.duration_ms) };
+  return { ...spend, durationMs: num2(result.duration_ms) };
 }
 function asTokenUsage(m) {
   return {
@@ -2435,9 +2450,9 @@ function transcriptSpendInWindow(worktree, fromMs, toMs, opts = {}) {
         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);
+      const num2 = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
+      tokensIn += num2(usage.input_tokens) + num2(usage.cache_creation_input_tokens) + num2(usage.cache_read_input_tokens);
+      tokensOut += num2(usage.output_tokens);
       if (firstAt === null || at < firstAt) firstAt = at;
       if (lastAt === null || at > lastAt) lastAt = at;
       replies += 1;
@@ -2665,13 +2680,15 @@ var init_swarmHome = __esm({
 });
 
 // src/executors/codex.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync4, statSync as statSync3, symlinkSync } from "fs";
+import { copyFileSync as copyFileSync2, 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 join6(swarmHome, "executor-state", "codex", worktree.replace(/[/.]/g, "-"));
+  const folded = worktree.replace(/[/.]/g, "-");
+  const key = /[:\\]/.test(folded) ? worktree.replace(/[^A-Za-z0-9]+/g, "-").replace(/^-|-$/g, "") || "worktree" : folded;
+  return join6(swarmHome, "executor-state", "codex", key);
 }
 function ensureCodexHome(worktree, realHome, env = process.env, swarmHome = SWARM_HOME) {
   const home = codexHomePath(worktree, swarmHome);
@@ -2684,6 +2701,10 @@ function ensureCodexHome(worktree, realHome, env = process.env, swarmHome = SWAR
     try {
       symlinkSync(target, link2);
     } catch {
+      try {
+        copyFileSync2(target, link2);
+      } catch {
+      }
     }
   }
   return home;
@@ -2834,6 +2855,206 @@ ${notice}` : spec.prompt;
   }
 });
 
+// src/executors/grok.ts
+import { copyFileSync as copyFileSync3, existsSync as existsSync5, mkdirSync as mkdirSync4, readdirSync as readdirSync5, statSync as statSync4, symlinkSync as symlinkSync2, writeFileSync as writeFileSync4 } from "fs";
+import { join as join7 } from "path";
+function resolveGrokBin(env = process.env) {
+  return (env.SWARM_GROK_BIN ?? "").trim() || "grok";
+}
+function grokHomePath(worktree, swarmHome = SWARM_HOME) {
+  const key = worktree.replace(/[^A-Za-z0-9]+/g, "-").replace(/^-|-$/g, "") || "worktree";
+  return join7(swarmHome, "executor-state", "grok", key);
+}
+function grokSessionDir(worktree, swarmHome = SWARM_HOME) {
+  return join7(grokHomePath(worktree, swarmHome), "sessions", encodeURIComponent(worktree));
+}
+function tomlBasic(value) {
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+  return `"${escaped}"`;
+}
+function grokMcpToml(spec) {
+  const env = Object.entries(spec.mcp.env).map(([k, v]) => `${k} = ${tomlBasic(v)}`).join(", ");
+  const args = spec.mcp.args.map((a) => tomlBasic(a)).join(", ");
+  return [
+    "[mcp_servers." + spec.mcp.name + "]",
+    "command = " + tomlBasic(spec.mcp.command),
+    "args = [" + args + "]",
+    "env = { " + env + " }",
+    ""
+  ].join("\n");
+}
+function ensureGrokHome(worktree, realHome, env = process.env, swarmHome = SWARM_HOME) {
+  const home = grokHomePath(worktree, swarmHome);
+  mkdirSync4(home, { recursive: true });
+  const real = (env.GROK_HOME ?? "").trim() || join7(realHome, ".grok");
+  const target = join7(real, "auth.json");
+  const link2 = join7(home, "auth.json");
+  if (existsSync5(target) && !existsSync5(link2)) {
+    try {
+      symlinkSync2(target, link2);
+    } catch {
+      try {
+        copyFileSync3(target, link2);
+      } catch {
+      }
+    }
+  }
+  return home;
+}
+function modelArgs(model) {
+  if (!model || isHarnessDefaultModel(model)) return [];
+  return ["--model", model];
+}
+function denyArgs(paths) {
+  return paths.flatMap((p) => ["--deny", `Read(${p}) Edit(${p}) Write(${p})`]);
+}
+function newestSessionMtime(dir, depth = 3) {
+  let entries;
+  try {
+    entries = readdirSync5(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  let latest = null;
+  for (const entry of entries) {
+    const full = join7(dir, entry.name);
+    try {
+      if (entry.isDirectory()) {
+        if (depth <= 0) continue;
+        const nested = newestSessionMtime(full, depth - 1);
+        if (nested != null && (latest == null || nested > latest)) latest = nested;
+      } else if (entry.isFile()) {
+        const mtime2 = statSync4(full).mtimeMs;
+        if (latest == null || mtime2 > latest) latest = mtime2;
+      }
+    } catch {
+    }
+  }
+  return latest;
+}
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+function grokAbort(rec) {
+  if (rec.type === "error") {
+    const raw = typeof rec.message === "string" && rec.message ? rec.message : "error";
+    const kind = /tool/i.test(raw) ? "tools" : /401|unauthorized|network|fetch|ECONN|api/i.test(raw) ? "link" : "other";
+    return { kind, raw: raw.slice(0, 300) };
+  }
+  const stop = typeof rec.stopReason === "string" ? rec.stopReason : "";
+  if (rec.is_error === true || stop === "error" || stop.startsWith("error_")) {
+    const raw = stop || "is_error";
+    return { kind: /tool/i.test(raw) ? "tools" : "other", raw };
+  }
+  return void 0;
+}
+function parseGrokResult(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+  const rec = parsed;
+  const hasShape = typeof rec.text === "string" || typeof rec.stopReason === "string" || typeof rec.sessionId === "string" || rec.type === "error";
+  if (!hasShape) return null;
+  const reported = typeof rec.total_cost_usd === "number" && Number.isFinite(rec.total_cost_usd);
+  const usage = rec.usage;
+  let tokensIn;
+  let tokensOut;
+  if (typeof usage === "object" && usage !== null) {
+    const u = usage;
+    const hasAny = ["input_tokens", "output_tokens", "cache_read_input_tokens", "cache_creation_input_tokens"].some(
+      (k) => typeof u[k] === "number"
+    );
+    if (hasAny) {
+      tokensIn = num(u.input_tokens) + num(u.cache_read_input_tokens) + num(u.cache_creation_input_tokens);
+      tokensOut = num(u.output_tokens);
+    }
+  }
+  const aborted = grokAbort(rec);
+  const result = {
+    costUsd: reported ? rec.total_cost_usd : 0
+  };
+  if (!reported) result.warning = "grok: total_cost_usd \u043D\u0435\u0442 \u2014 \u0441\u0442\u043E\u0438\u043C\u043E\u0441\u0442\u044C \u043F\u0440\u043E\u0433\u043E\u043D\u0430 \u043D\u0435 \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0430 (\u044D\u0442\u043E \u043D\u0435 \u043D\u043E\u043B\u044C)";
+  if (tokensIn != null && tokensOut != null) {
+    result.tokensIn = tokensIn;
+    result.tokensOut = tokensOut;
+  }
+  if (aborted) result.aborted = aborted;
+  return result;
+}
+var grokExecutor;
+var init_grok = __esm({
+  "src/executors/grok.ts"() {
+    "use strict";
+    init_src();
+    init_swarmHome();
+    init_swarmFiles();
+    init_codex();
+    grokExecutor = {
+      id: "grok",
+      title: "Grok CLI (grok)",
+      binEnv: "SWARM_GROK_BIN",
+      install: {
+        what: "Grok CLI (xAI). \u0421\u0442\u0430\u0432\u0438\u0442\u0441\u044F \u043E\u0444\u0438\u0446\u0438\u0430\u043B\u044C\u043D\u044B\u043C \u0438\u043D\u0441\u0442\u0430\u043B\u043B\u0435\u0440\u043E\u043C, \u043D\u0435 \u0447\u0435\u0440\u0435\u0437 npm.",
+        pkg: "grok",
+        command: "curl -fsSL https://x.ai/cli/install.sh | bash",
+        windowsCommand: "irm https://x.ai/cli/install.ps1 | iex"
+      },
+      resolveBin: (env) => resolveGrokBin(env ?? process.env),
+      plan: (spec) => {
+        const home = ensureGrokHome(spec.worktree, spec.realHome);
+        writeFileSync4(join7(home, "config.toml"), grokMcpToml(spec));
+        writeFileSync4(
+          join7(spec.worktree, SWARM_MCP_CONFIG_FILE),
+          JSON.stringify(
+            { mcpServers: { [spec.mcp.name]: { command: spec.mcp.command, args: spec.mcp.args, env: spec.mcp.env } } },
+            null,
+            2
+          )
+        );
+        const notice = skillsNotice(spec.skillDirs);
+        const prompt = notice ? `${spec.prompt}
+
+${notice}` : spec.prompt;
+        const args = [
+          // `--cwd` стоит первым: по нему реконсайл узнаёт worktree живого процесса.
+          // Флаг настоящий. Выдуманный `--mcp-config` grok отверг бы и дрон не стартовал.
+          "--cwd",
+          spec.worktree,
+          "--no-auto-update",
+          "--output-format",
+          "json",
+          "--yolo",
+          ...spec.continueSession ? ["--continue"] : [],
+          ...modelArgs(spec.model),
+          ...spec.effort ? ["--effort", spec.effort] : [],
+          ...denyArgs(spec.denyPaths),
+          "-p",
+          prompt
+        ];
+        return { bin: resolveGrokBin(), args, env: { GROK_HOME: home } };
+      },
+      parseResult(raw) {
+        return parseGrokResult(raw);
+      },
+      session: {
+        exists: (worktree) => newestSessionMtime(grokSessionDir(worktree)) !== null,
+        mtimeMs: (worktree) => newestSessionMtime(grokSessionDir(worktree))
+      },
+      probe: {
+        args: ["-p", "ok", "--output-format", "json", "--yolo", "--max-turns", "1", "--no-auto-update"],
+        limitPattern: /usage limit/i,
+        authPattern: /not logged in|unauthorized|\b401\b|authentication required|auth required/i
+      }
+    };
+  }
+});
+
 // src/swarmModels.ts
 function pick2(v) {
   const s = typeof v === "string" ? v.trim() : "";
@@ -2849,10 +3070,22 @@ function forKind(kind, swarm, norm) {
   if (!swarm) return null;
   return isReviewKind(kind) ? norm(swarm.reviewer) ?? norm(swarm.drone) : norm(swarm.drone);
 }
+function providersFromEnv(env = process.env) {
+  const raw = (env.SWARM_PROVIDERS ?? "").trim();
+  if (!raw) return null;
+  const known = new Set(MODEL_PROVIDERS.map((p) => p.id));
+  const list = [...new Set(raw.split(/[\s,]+/).map((p) => p.trim().toLowerCase()).filter((p) => known.has(p)))];
+  return list.length ? list : null;
+}
 function resolveRunModelRef(run, swarm, env = process.env) {
-  const configured = parseModelRef(
-    pick2(run.model) ?? forKind(run.kind, swarm, pick2) ?? pick2(env.SWARM_DRONE_MODEL)
-  );
+  const pinned = parseModelRef(pick2(run.model));
+  if (pinned) return pinned;
+  const configured = parseModelRef(forKind(run.kind, swarm, pick2) ?? pick2(env.SWARM_DRONE_MODEL));
+  const own = providersFromEnv(env);
+  if (own) {
+    if (configured && own.includes(configured.providerId)) return configured;
+    return { providerId: own[0], model: defaultModelFor(modelRoleOf(run.kind), own[0]) };
+  }
   if (configured) return configured;
   const providerId = pick2(env.SWARM_MODEL_PROVIDER) ?? DEFAULT_PROVIDER_ID;
   return { providerId, model: defaultModelFor(modelRoleOf(run.kind), providerId) };
@@ -2899,14 +3132,17 @@ var init_executors = __esm({
     init_src();
     init_claudeCode();
     init_codex();
+    init_grok();
     init_swarmModels();
     init_types2();
     init_claudeCode();
     init_codex();
+    init_grok();
     DEFAULT_EXECUTOR_ID = "claude-code";
     EXECUTORS = {
       [claudeCodeExecutor.id]: claudeCodeExecutor,
-      [codexExecutor.id]: codexExecutor
+      [codexExecutor.id]: codexExecutor,
+      [grokExecutor.id]: grokExecutor
     };
   }
 });
@@ -3013,8 +3249,8 @@ __export(config_exports, {
   restEndpoint: () => restEndpoint,
   reviewCutoffAt: () => reviewCutoffAt
 });
-import { basename, join as join7, resolve } from "path";
-import { readFileSync as readFileSync4, realpathSync, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "fs";
+import { basename, join as join8, resolve } from "path";
+import { readFileSync as readFileSync4, realpathSync, renameSync as renameSync2, writeFileSync as writeFileSync5 } from "fs";
 function normalizeRepo(repo) {
   const r = (repo ?? "").trim();
   if (!r) return "";
@@ -3028,10 +3264,10 @@ function effectiveRepoOf(repo, fallback) {
   return normalizeRepo(repo || fallback || "");
 }
 function droneWorktreePath(worktreesDir, repo, slug) {
-  return join7(droneWorktreeRoot(worktreesDir, repo), slug);
+  return join8(droneWorktreeRoot(worktreesDir, repo), slug);
 }
 function droneWorktreeRoot(worktreesDir, repo) {
-  return join7(worktreesDir, basename(normalizeRepo(repo)));
+  return join8(worktreesDir, basename(normalizeRepo(repo)));
 }
 function resolveEffectiveWorktreesDir(deps) {
   if (deps.envOverride) return deps.envOverride;
@@ -3079,7 +3315,7 @@ function mcpEndpoint(api, path = TASKLESS_MCP_PATH) {
 }
 function tokenFromFile() {
   try {
-    return readFileSync4(join7(SWARM_HOME, "token"), "utf8").trim();
+    return readFileSync4(join8(SWARM_HOME, "token"), "utf8").trim();
   } catch {
     return "";
   }
@@ -3093,7 +3329,7 @@ function reviewCutoffAt() {
   const at = stamp();
   try {
     const tmp = `${REVIEW_CUTOFF_PATH}.tmp`;
-    writeFileSync4(tmp, JSON.stringify({ at }));
+    writeFileSync5(tmp, JSON.stringify({ at }));
     renameSync2(tmp, REVIEW_CUTOFF_PATH);
   } catch {
   }
@@ -3107,25 +3343,25 @@ var init_config = __esm({
     init_executors();
     init_swarmHome();
     init_swarmHome();
-    DB_PATH = process.env.SWARM_DB || join7(SWARM_HOME, "swarm.db");
+    DB_PATH = process.env.SWARM_DB || join8(SWARM_HOME, "swarm.db");
     EXECUTOR = resolveExecutor(process.env.SWARM_EXECUTOR);
-    DRONE_HOME = process.env.SWARM_DRONE_HOME || join7(SWARM_HOME, "drone-home");
+    DRONE_HOME = process.env.SWARM_DRONE_HOME || join8(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 = join7(SWARM_HOME, "worktrees.noindex");
-    WORKTREES_LEGACY_DIR = join7(SWARM_HOME, "worktrees");
+    WORKTREES_NOINDEX_DIR = join8(SWARM_HOME, "worktrees.noindex");
+    WORKTREES_LEGACY_DIR = join8(SWARM_HOME, "worktrees");
     WORKTREES_DIR = process.env.SWARM_WORKTREES || WORKTREES_NOINDEX_DIR;
-    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");
+    RUN_LOGS_DIR = process.env.SWARM_RUN_LOGS || join8(SWARM_HOME, "run-logs");
+    DAEMON_LOG_PATH = process.env.SWARM_DAEMON_LOG || join8(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 || join7(SWARM_HOME, "outbox.jsonl");
+    SWARM_OUTBOX = process.env.SWARM_OUTBOX || join8(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 || join7(SWARM_HOME, "env-cache");
+    ENV_CACHE_DIR = process.env.SWARM_ENV_CACHE_DIR || join8(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);
@@ -3155,15 +3391,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 || join7(SWARM_HOME, "drone-channel.key");
+    DRONE_CHANNEL_SECRET_PATH = process.env.SWARM_DRONE_CHANNEL_SECRET || join8(SWARM_HOME, "drone-channel.key");
     DRONE_CHANNEL_GRACE_MS = envNum("SWARM_DRONE_CHANNEL_GRACE_MS", 12e4);
-    HEARTBEAT_PATH = process.env.SWARM_HEARTBEAT || join7(SWARM_HOME, "overmind.heartbeat");
+    HEARTBEAT_PATH = process.env.SWARM_HEARTBEAT || join8(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 || join7(SWARM_HOME, "repo-map.json");
+    REPO_MAP_PATH = process.env.SWARM_REPO_MAP || join8(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";
@@ -3178,7 +3414,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 || join7(SWARM_HOME, "review-cutoff.json");
+    REVIEW_CUTOFF_PATH = process.env.SWARM_REVIEW_CUTOFF || join8(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;
@@ -3702,8 +3938,8 @@ var init_store = __esm({
 });
 
 // src/agentToken.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, unlinkSync as unlinkSync2 } from "fs";
-import { join as join8 } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, unlinkSync as unlinkSync2 } from "fs";
+import { join as join9 } from "path";
 function loadAgentToken() {
   try {
     const s = JSON.parse(readFileSync6(STORE_PATH, "utf8"));
@@ -3759,7 +3995,7 @@ var init_agentToken = __esm({
   "src/agentToken.ts"() {
     "use strict";
     init_config();
-    STORE_PATH = join8(SWARM_HOME, "agent.json");
+    STORE_PATH = join9(SWARM_HOME, "agent.json");
     base = (api) => api.replace(/\/$/, "");
     TOKEN_PROBE_TIMEOUT_MS = 8e3;
   }
@@ -3873,10 +4109,10 @@ var init_toolFailure = __esm({
 });
 
 // src/heartbeat.ts
-import { readFileSync as readFileSync8, renameSync as renameSync4, writeFileSync as writeFileSync7 } from "fs";
+import { readFileSync as readFileSync8, renameSync as renameSync4, writeFileSync as writeFileSync8 } from "fs";
 function writeHeartbeat(path, now) {
   const tmp = `${path}.tmp`;
-  writeFileSync7(tmp, String(now));
+  writeFileSync8(tmp, String(now));
   renameSync4(tmp, path);
 }
 function readHeartbeat(path) {
@@ -4367,9 +4603,9 @@ var init_procCleanup = __esm({
 });
 
 // src/git.ts
-import { existsSync as existsSync12, readdirSync as readdirSync12, realpathSync as realpathSync2, statSync as statSync10 } from "fs";
+import { existsSync as existsSync13, readdirSync as readdirSync13, realpathSync as realpathSync2, statSync as statSync11 } from "fs";
 import { appendFile, chmod, mkdir, readFile, rename, rm, writeFile } from "fs/promises";
-import { isAbsolute as isAbsolute3, join as join21, resolve as resolve3, sep as sep2 } from "path";
+import { isAbsolute as isAbsolute3, join as join22, resolve as resolve3, sep as sep2 } from "path";
 import { $ as $2 } from "execa";
 function gitNet(repo, args, timeoutMs) {
   return withHardTimeout(
@@ -4391,14 +4627,14 @@ async function reclaimStaleWorktree(repo, worktree) {
   await detachWorktree(repo, worktree);
 }
 async function inspectWorktreePath(path) {
-  if (!existsSync12(path)) return "free";
+  if (!existsSync13(path)) return "free";
   try {
-    if (readdirSync12(path).length === 0) return "free";
+    if (readdirSync13(path).length === 0) return "free";
   } catch {
     return "orphan";
   }
   try {
-    if (statSync10(join21(path, ".git")).isDirectory()) return "main-checkout";
+    if (statSync11(join22(path, ".git")).isDirectory()) return "main-checkout";
   } catch {
   }
   const top = await $2({ reject: false })`git -C ${path} rev-parse --show-toplevel`;
@@ -4437,7 +4673,7 @@ async function clearWorktreePath(repo, path, branch, opts = {}) {
     await detachWorktree(repo, path);
     opts.onStaleReclaim?.(path);
   }
-  if (!existsSync12(path)) return;
+  if (!existsSync13(path)) return;
   await parkOrphanDir(repo, path, branch);
 }
 async function parkOrphanDir(repo, path, branch) {
@@ -4458,7 +4694,7 @@ async function parkOrphanDir(repo, path, branch) {
 }
 function isLinkedWorktree(dir) {
   try {
-    return statSync10(join21(dir, ".git")).isFile();
+    return statSync11(join22(dir, ".git")).isFile();
   } catch {
     return false;
   }
@@ -4470,7 +4706,7 @@ async function detachWorktree(repo, worktree) {
   }
 }
 async function ensureWorktreeDirGone(worktree) {
-  if (!existsSync12(worktree)) return false;
+  if (!existsSync13(worktree)) return false;
   if (!isLinkedWorktree(worktree)) {
     console.error(
       `[git] ${worktree} \u2014 \u043D\u0435 \u043F\u0440\u0438\u0441\u0442\u0451\u0433\u043D\u0443\u0442\u044B\u0439 worktree (.git \u043D\u0435 \u0444\u0430\u0439\u043B): \u043A\u0430\u0442\u0430\u043B\u043E\u0433 \u041D\u0415 \u0442\u0440\u043E\u0433\u0430\u044E. \u0415\u0441\u043B\u0438 \u044D\u0442\u043E \u0434\u0435\u0439\u0441\u0442\u0432\u0438\u0442\u0435\u043B\u044C\u043D\u043E worktree \u0434\u0440\u043E\u043D\u0430 \u2014 \u0443\u0431\u0435\u0440\u0438\u0442\u0435 \u0435\u0433\u043E \u0440\u0443\u043A\u0430\u043C\u0438; \u0435\u0441\u043B\u0438 \u044D\u0442\u043E \u043E\u0441\u043D\u043E\u0432\u043D\u043E\u0439 \u0447\u0435\u043A\u0430\u0443\u0442, \u0437\u043D\u0430\u0447\u0438\u0442 \u0432\u0435\u0442\u043A\u0430 \u0441\u043B\u0430\u0433\u0430 \u0447\u0435\u043A\u043D\u0443\u0442\u0430 \u0432 \u043D\u0451\u043C (git checkout <slug>) \u2014 \u043F\u0435\u0440\u0435\u043A\u043B\u044E\u0447\u0438\u0442\u0435 \u0435\u0433\u043E \u043D\u0430 \u0434\u0440\u0443\u0433\u0443\u044E \u0432\u0435\u0442\u043A\u0443.`
@@ -4485,7 +4721,7 @@ async function ensureWorktreeDirGone(worktree) {
     );
     return true;
   }
-  if (existsSync12(worktree)) {
+  if (existsSync13(worktree)) {
     console.error(`[git] \u043A\u0430\u0442\u0430\u043B\u043E\u0433 worktree ${worktree} \u043F\u0435\u0440\u0435\u0436\u0438\u043B rm \u2014 \u0443\u0431\u0435\u0440\u0438\u0442\u0435 \u0440\u0443\u043A\u0430\u043C\u0438, \u0438\u043D\u0430\u0447\u0435 \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0438\u0439 \u0441\u043F\u0430\u0432\u043D \u0441\u043B\u0430\u0433\u0430 \u0432\u0441\u0442\u0430\u043D\u0435\u0442.`);
   }
   return true;
@@ -4534,7 +4770,7 @@ async function checkoutWorktree(repo, path, branch, opts) {
   }
   const busyAt = await worktreeForBranch(repo, branch);
   if (busyAt) {
-    const exists = existsSync12(busyAt);
+    const exists = existsSync13(busyAt);
     const live = exists && (opts.isWorktreeHeldLive ? await opts.isWorktreeHeldLive(busyAt) : true);
     if (live) throw new WorktreeBusyError(branch, busyAt);
     if (exists && await worktreeDirty(busyAt)) throw new WorktreeBusyError(branch, busyAt);
@@ -4570,8 +4806,8 @@ async function ensureGitExcluded(worktree, pattern) {
   try {
     const commonDir = await gitPath(worktree, "--git-common-dir");
     if (!commonDir) return false;
-    const infoDir = join21(commonDir, "info");
-    const excludeFile = join21(infoDir, "exclude");
+    const infoDir = join22(commonDir, "info");
+    const excludeFile = join22(infoDir, "exclude");
     let current = "";
     try {
       current = await readFile(excludeFile, "utf8");
@@ -4591,7 +4827,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 isAbsolute3(raw) ? raw : join21(worktree, raw);
+  return isAbsolute3(raw) ? raw : join22(worktree, raw);
 }
 async function ensureWorktreeHygiene(worktree) {
   for (const pattern of SWARM_EXCLUDE_PATTERNS) await ensureGitExcluded(worktree, pattern);
@@ -4601,12 +4837,12 @@ async function installGuardHooks(worktree) {
   try {
     const gitDir = await gitPath(worktree, "--git-dir");
     if (!gitDir) return false;
-    const hooksDir = join21(gitDir, "swarm-hooks");
+    const hooksDir = join22(gitDir, "swarm-hooks");
     const prev = await previousHooksPath(worktree);
     await mkdir(hooksDir, { recursive: true });
     for (const hook of GUARD_HOOKS) {
-      await writeFile(join21(hooksDir, hook), guardHookScript(hook, prev ? `${posix(prev)}/${hook}` : null));
-      await chmod(join21(hooksDir, hook), 493);
+      await writeFile(join22(hooksDir, hook), guardHookScript(hook, prev ? `${posix(prev)}/${hook}` : null));
+      await chmod(join22(hooksDir, hook), 493);
     }
     await $2`git -C ${worktree} config extensions.worktreeConfig true`;
     await $2`git -C ${worktree} config --worktree core.hooksPath ${posix(hooksDir)}`;
@@ -4625,7 +4861,7 @@ async function previousHooksPath(worktree) {
     if (out.exitCode === 0 && value) return value;
   }
   const commonDir = await gitPath(worktree, "--git-common-dir");
-  return commonDir ? join21(commonDir, "hooks") : null;
+  return commonDir ? join22(commonDir, "hooks") : null;
 }
 async function removeWorktree(repo, path) {
   const branch = (await $2({ reject: false })`git -C ${path} symbolic-ref --quiet --short HEAD`).stdout.trim();
@@ -4650,7 +4886,7 @@ async function worktreeDirty(path) {
 async function repairMovedWorktrees(targetDir) {
   const subdirs = (dir) => {
     try {
-      return readdirSync12(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join21(dir, d.name));
+      return readdirSync13(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join22(dir, d.name));
     } catch {
       return [];
     }
@@ -4787,7 +5023,7 @@ __export(droneChannel_exports, {
   verifyLocalCliToken: () => verifyLocalCliToken
 });
 import { createHmac, randomBytes, timingSafeEqual } from "crypto";
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync10, readFileSync as readFileSync19, writeFileSync as writeFileSync12 } from "fs";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync11, readFileSync as readFileSync19, writeFileSync as writeFileSync13 } from "fs";
 import { dirname as dirname5 } from "path";
 import { serve } from "@hono/node-server";
 function loadChannelSecret(path) {
@@ -4797,8 +5033,8 @@ function loadChannelSecret(path) {
   } catch {
   }
   const secret = randomBytes(32).toString("hex");
-  mkdirSync10(dirname5(path), { recursive: true });
-  writeFileSync12(path, secret, { mode: 384 });
+  mkdirSync11(dirname5(path), { recursive: true });
+  writeFileSync13(path, secret, { mode: 384 });
   try {
     chmodSync2(path, 384);
   } catch {
@@ -4916,13 +5152,13 @@ function makeChannelHandler(deps) {
         log(`[\u043A\u0430\u043D\u0430\u043B] \u0432\u043E\u043F\u0440\u043E\u0441\u044B \u043F\u0440\u043E\u0433\u043E\u043D\u0430 #${id} \u043D\u0435 \u0434\u043E\u0447\u0438\u0442\u0430\u043B\u0438\u0441\u044C \u0438\u0437 \u043F\u0440\u043E\u0434\u0430 (\u043E\u0442\u0432\u0435\u0447\u0430\u044E \u043F\u043E \u0437\u0435\u0440\u043A\u0430\u043B\u0443): ${e instanceof Error ? e.message : String(e)}`);
       }
     };
-    const num = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+    const num2 = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
     const str2 = (v) => typeof v === "string" ? v : "";
     switch (method) {
       case "myRun":
         return Response.json({ run });
       case "getRun": {
-        const id = num(p.id);
+        const id = num2(p.id);
         if (id == null || !inScope(id)) return bad(403, "\u043F\u0440\u043E\u0433\u043E\u043D \u0432\u043D\u0435 \u0441\u043A\u043E\u0443\u043F\u0430 \u043A\u0430\u043D\u0430\u043B\u0430");
         return Response.json({ run: deps.store.getRun(id) });
       }
@@ -4986,7 +5222,7 @@ function makeChannelHandler(deps) {
       }
       case "answer": {
         if (!heroOnly()) return bad(403, "\u043E\u0442\u0432\u0435\u0447\u0430\u0442\u044C \u0434\u0440\u043E\u043D\u0430\u043C \u043C\u043E\u0436\u0435\u0442 \u0442\u043E\u043B\u044C\u043A\u043E \u0413\u0435\u0440\u043E\u0439");
-        const qid = num(p.id);
+        const qid = num2(p.id);
         if (qid == null) return bad(400, "\u043D\u0443\u0436\u0435\u043D id \u0432\u043E\u043F\u0440\u043E\u0441\u0430");
         const q = deps.store.getQuestion(qid);
         const squad = new Set(deps.store.squadRuns(run.id).map((r) => r.id));
@@ -5188,7 +5424,7 @@ var init_droneChannel = __esm({
 
 // src/attachments.ts
 import { mkdir as mkdir3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 function attachmentsFromDoc(doc, origin) {
   const out = [];
   const walk2 = (node) => {
@@ -5256,9 +5492,9 @@ function slugifyCaption(caption) {
   return translit.replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40).replace(/-+$/, "");
 }
 function attachmentFileName(index, caption, ext) {
-  const num = String(index).padStart(2, "0");
+  const num2 = String(index).padStart(2, "0");
   const slug = slugifyCaption(caption) || "attachment";
-  return `${num}-${slug}.${ext}`;
+  return `${num2}-${slug}.${ext}`;
 }
 function attachmentExt(ref, contentType) {
   const fromName = extOf(ref.caption) || extOf(pathOf(ref.url));
@@ -5279,7 +5515,7 @@ async function materializeAttachments(opts) {
   };
   const result = { files: [], skipped: [] };
   if (opts.refs.length === 0) return result;
-  const dir = join26(opts.worktree, ATTACHMENTS_DIR);
+  const dir = join27(opts.worktree, ATTACHMENTS_DIR);
   await io.removeDir(dir);
   let dirReady = false;
   let total = 0;
@@ -5325,7 +5561,7 @@ async function materializeAttachments(opts) {
         await io.mkdir(dir);
         dirReady = true;
       }
-      await io.writeFile(join26(dir, name), file.bytes);
+      await io.writeFile(join27(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;
@@ -5478,7 +5714,7 @@ var init_attachments = __esm({
 
 // src/shotUpload.ts
 import { readFile as fsReadFile } from "fs/promises";
-import { basename as basename4, isAbsolute as isAbsolute4, join as join27 } from "path";
+import { basename as basename4, isAbsolute as isAbsolute4, join as join28 } from "path";
 function shotMimetype(path) {
   const dot = path.lastIndexOf(".");
   if (dot < 0) return null;
@@ -5504,7 +5740,7 @@ async function readShots(paths, opts) {
     }
     let bytes;
     try {
-      bytes = await read(isAbsolute4(path) ? path : join27(opts.worktree, path));
+      bytes = await read(isAbsolute4(path) ? path : join28(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;
@@ -5585,8 +5821,8 @@ var init_shotUpload = __esm({
 
 // src/oauth.ts
 import { createHash as createHash3, randomBytes as randomBytes2 } from "crypto";
-import { readFileSync as readFileSync20, writeFileSync as writeFileSync13, unlinkSync as unlinkSync4 } from "fs";
-import { join as join28 } from "path";
+import { readFileSync as readFileSync20, writeFileSync as writeFileSync14, unlinkSync as unlinkSync4 } from "fs";
+import { join as join29 } from "path";
 function makePkce() {
   const verifier = randomBytes2(48).toString("base64url");
   const challenge = createHash3("sha256").update(verifier).digest("base64url");
@@ -5676,7 +5912,7 @@ function loadStore() {
   }
 }
 function saveStore(s) {
-  writeFileSync13(STORE_PATH2, JSON.stringify(s, null, 2), { mode: 384 });
+  writeFileSync14(STORE_PATH2, JSON.stringify(s, null, 2), { mode: 384 });
 }
 function clearStore() {
   try {
@@ -5695,7 +5931,7 @@ async function ensureClientId(api, redirectUri, fetchFn = fetch) {
   const existing = loadClientId();
   if (existing) return existing;
   const clientId = await registerClient({ api, redirectUri }, fetchFn);
-  writeFileSync13(CLIENT_PATH, JSON.stringify({ clientId }, null, 2), { mode: 384 });
+  writeFileSync14(CLIENT_PATH, JSON.stringify({ clientId }, null, 2), { mode: 384 });
   return clientId;
 }
 async function ensureAccess(store, opts = {}) {
@@ -5721,8 +5957,8 @@ var init_oauth = __esm({
     AUTHORIZE = "/api/oauth/authorize";
     TOKEN = "/api/oauth/token";
     SCOPE = "openid profile email taskless:full";
-    STORE_PATH2 = join28(SWARM_HOME, "oauth.json");
-    CLIENT_PATH = join28(SWARM_HOME, "oauth-client.json");
+    STORE_PATH2 = join29(SWARM_HOME, "oauth.json");
+    CLIENT_PATH = join29(SWARM_HOME, "oauth-client.json");
     base2 = (api) => api.replace(/\/$/, "");
   }
 });
@@ -5768,8 +6004,8 @@ var init_authState = __esm({
 });
 
 // src/workspace.ts
-import { readFileSync as readFileSync21, writeFileSync as writeFileSync14, unlinkSync as unlinkSync5 } from "fs";
-import { join as join29 } from "path";
+import { readFileSync as readFileSync21, writeFileSync as writeFileSync15, unlinkSync as unlinkSync5 } from "fs";
+import { join as join30 } from "path";
 function loadWorkspace() {
   try {
     const w = JSON.parse(readFileSync21(WORKSPACE_PATH, "utf8"));
@@ -5786,7 +6022,7 @@ var init_workspace = __esm({
   "src/workspace.ts"() {
     "use strict";
     init_config();
-    WORKSPACE_PATH = join29(SWARM_HOME, "workspace.json");
+    WORKSPACE_PATH = join30(SWARM_HOME, "workspace.json");
   }
 });
 
@@ -6389,7 +6625,7 @@ __export(db_exports, {
 });
 import { createRequire as createRequire2 } from "module";
 import { randomUUID as randomUUID3 } from "crypto";
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import { resolve as resolve4 } from "path";
 function rowToQuestion(row) {
   return {
@@ -7053,7 +7289,7 @@ CREATE TABLE IF NOT EXISTS imports (
         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 };
-        if (!existsSync16(abs)) throw new Error(`import-db: \u0444\u0430\u0439\u043B\u0430 \u043D\u0435\u0442: ${abs}`);
+        if (!existsSync17(abs)) throw new Error(`import-db: \u0444\u0430\u0439\u043B\u0430 \u043D\u0435\u0442: ${abs}`);
         const src = new this.databaseCtor(abs);
         try {
           const runs = src.prepare("SELECT * FROM runs ORDER BY id").all();
@@ -7423,8 +7659,8 @@ var init_droneStore = __esm({
 
 // src/overmind.ts
 import { homedir as homedir7 } from "os";
-import { existsSync as existsSync21, readFileSync as readFileSync25, readdirSync as readdirSync14, renameSync as renameSync12, statSync as statSync13 } from "fs";
-import { basename as basename6, dirname as dirname6, join as join36 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync25, readdirSync as readdirSync15, renameSync as renameSync12, statSync as statSync14 } from "fs";
+import { basename as basename6, dirname as dirname6, join as join37 } from "path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "url";
 import { spawn as spawn4 } from "child_process";
 
@@ -7504,7 +7740,7 @@ init_config();
 init_resources();
 init_names2();
 init_storm();
-import { appendFileSync, existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { appendFileSync, existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "fs";
 import { dirname as dirname2 } from "path";
 import { randomUUID } from "crypto";
 
@@ -7562,12 +7798,12 @@ init_store();
 init_toolFailure();
 
 // src/logTail.ts
-import { closeSync, existsSync as existsSync6, openSync, readSync, readdirSync as readdirSync6, statSync as statSync5 } from "fs";
-import { join as join10 } from "path";
+import { closeSync, existsSync as existsSync7, openSync, readSync, readdirSync as readdirSync7, statSync as statSync6 } from "fs";
+import { join as join11 } from "path";
 
 // src/runLogDir.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync5, readdirSync as readdirSync5, renameSync as renameSync3, statSync as statSync4 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync6, readdirSync as readdirSync6, renameSync as renameSync3, statSync as statSync5 } from "fs";
+import { join as join10 } from "path";
 var LEGACY_RUN_LOGS_SUBDIR = "legacy";
 function runLogDirName(runLogKey) {
   const safe2 = runLogKey.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^[-_]+|[-_]+$/g, "");
@@ -7575,12 +7811,12 @@ function runLogDirName(runLogKey) {
   return /^\d+$/.test(safe2) ? `k-${safe2}` : safe2;
 }
 function runLogDirPath(runLogsDir, runLogKey) {
-  return join9(runLogsDir, runLogDirName(runLogKey));
+  return join10(runLogsDir, runLogDirName(runLogKey));
 }
 function findRunLogDir(runLogsDir, keys) {
   for (const key of keys) {
     const dir = runLogDirPath(runLogsDir, key);
-    if (existsSync5(dir)) return dir;
+    if (existsSync6(dir)) return dir;
   }
   return null;
 }
@@ -7590,10 +7826,10 @@ function runLogDirForWrite(runLogsDir, keys) {
   return findRunLogDir(runLogsDir, keys) ?? runLogDirPath(runLogsDir, canonical);
 }
 function sweepLegacyRunLogs(runLogsDir) {
-  const legacyDir = join9(runLogsDir, LEGACY_RUN_LOGS_SUBDIR);
+  const legacyDir = join10(runLogsDir, LEGACY_RUN_LOGS_SUBDIR);
   let entries;
   try {
-    entries = readdirSync5(runLogsDir);
+    entries = readdirSync6(runLogsDir);
   } catch {
     return { moved: 0, failed: 0, legacyDir };
   }
@@ -7601,12 +7837,12 @@ function sweepLegacyRunLogs(runLogsDir) {
   let failed = 0;
   for (const name of entries) {
     if (!/^\d+$/.test(name)) continue;
-    const from = join9(runLogsDir, name);
+    const from = join10(runLogsDir, name);
     try {
-      if (!statSync4(from).isDirectory()) continue;
-      mkdirSync5(legacyDir, { recursive: true });
-      let to = join9(legacyDir, name);
-      for (let n = 2; existsSync5(to) && n < 100; n++) to = join9(legacyDir, `${name}-${n}`);
+      if (!statSync5(from).isDirectory()) continue;
+      mkdirSync6(legacyDir, { recursive: true });
+      let to = join10(legacyDir, name);
+      for (let n = 2; existsSync6(to) && n < 100; n++) to = join10(legacyDir, `${name}-${n}`);
       renameSync3(from, to);
       moved++;
     } catch {
@@ -7626,7 +7862,7 @@ function fileHeader(name, size, shown) {
 function readTail(path, opts) {
   let size;
   try {
-    size = statSync5(path).size;
+    size = statSync6(path).size;
   } catch {
     return null;
   }
@@ -7661,7 +7897,7 @@ function latestRunLaunch(runLogsDir, runLogKeys) {
   if (!dir) return null;
   let files;
   try {
-    files = readdirSync6(dir);
+    files = readdirSync7(dir);
   } catch {
     return null;
   }
@@ -7672,8 +7908,8 @@ function latestRunLaunch(runLogsDir, runLogKeys) {
   }
   if (indexes.size === 0) return null;
   const index = Math.max(...indexes);
-  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;
+  const out = [join11(dir, `${index}.json`), join11(dir, `${index}.json.done`)].find((p) => existsSync7(p)) ?? null;
+  const err = existsSync7(join11(dir, `${index}.err.log`)) ? join11(dir, `${index}.err.log`) : null;
   return { index, total: indexes.size, out, err };
 }
 function runLogTail(runLogsDir, runLogKeys, opts) {
@@ -7943,25 +8179,25 @@ var SwarmClient = class _SwarmClient {
     this.repoFullNames = registry.map((e) => e.repoFullName);
     this.repoPathByFullName = new Map(registry.map((e) => [e.repoFullName, normalizeRepo(e.path)]));
     this.host = opts.host ?? null;
-    this.repoExists = opts.repoExists ?? existsSync7;
+    this.repoExists = opts.repoExists ?? existsSync8;
     this.questionSyncMs = opts.questionSyncMs ?? 3e3;
     this.executorId = opts.executorId ?? EXECUTOR.id;
     this.outboxPath = opts.outboxPath;
     this.mapPath = `${opts.outboxPath}.prodmap.json`;
     this.stormPath = `${opts.outboxPath}.storm.jsonl`;
-    mkdirSync6(dirname2(this.outboxPath), { recursive: true });
+    mkdirSync7(dirname2(this.outboxPath), { recursive: true });
     this.recover();
   }
   // ── рестарт: поднять outbox (незаписанные операции) и карту runKey→prodId ─────
   recover() {
-    if (existsSync7(this.mapPath)) {
+    if (existsSync8(this.mapPath)) {
       try {
         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)) {
+    if (existsSync8(this.outboxPath)) {
       const txt = readFileSync7(this.outboxPath, "utf8");
       for (const line of txt.split("\n")) {
         const s = line.trim();
@@ -7982,7 +8218,7 @@ var SwarmClient = class _SwarmClient {
   // eventsLog ПЕРВЫМИ (до hydrate), в порядке файла (= хронологический); id
   // переприсваиваем локально (id событий — только порядок, не корреляция с продом).
   replayGlobalEvents() {
-    if (!existsSync7(this.stormPath)) return;
+    if (!existsSync8(this.stormPath)) return;
     let txt;
     try {
       txt = readFileSync7(this.stormPath, "utf8");
@@ -8982,7 +9218,7 @@ var SwarmClient = class _SwarmClient {
    * транзиентным сбоем ОС, который этот PR должен переживать, а не превращать в мор.
    */
   reconcileRuntime(opts) {
-    const wtExists = opts.worktreeExists ?? existsSync7;
+    const wtExists = opts.worktreeExists ?? existsSync8;
     const pidByWorktree = /* @__PURE__ */ new Map();
     try {
       for (const p of opts.listProcesses()) if (p.worktree) pidByWorktree.set(p.worktree, p.pid);
@@ -9602,7 +9838,7 @@ var SwarmClient = class _SwarmClient {
    *
    * Прод недоступен / ответ без поручений → пустые списки (демон работает дальше).
    */
-  async heartbeat(daemonVersion, pause, capacity, resources, storm, worktreesDir, signIn, tick, executors) {
+  async heartbeat(daemonVersion, pause, capacity, resources, storm, worktreesDir, signIn, tick, executors, providers) {
     try {
       const args = this.repoFullNames.length ? { repoFullNames: this.repoFullNames } : {};
       if (daemonVersion) args.daemonVersion = daemonVersion;
@@ -9633,6 +9869,7 @@ var SwarmClient = class _SwarmClient {
         args.tick = { seq: Math.max(0, Math.trunc(tick.seq)), ageMs: Math.max(0, Math.trunc(tick.ageMs)), intervalMs: Math.trunc(tick.intervalMs) };
       }
       if (executors) args.executorsAvailable = executors;
+      if (providers) args.providersAvailable = providers;
       const res = await this.call("swarm_heartbeat", args);
       if (res?.isError) return EMPTY_HEARTBEAT_REPLY;
       this.heartbeatOkAt = this.now();
@@ -10220,13 +10457,13 @@ var SwarmClient = class _SwarmClient {
   }
   persistPending() {
     try {
-      writeFileSync6(this.outboxPath, this.pending.map((e) => JSON.stringify(e)).join("\n") + (this.pending.length ? "\n" : ""));
+      writeFileSync7(this.outboxPath, this.pending.map((e) => JSON.stringify(e)).join("\n") + (this.pending.length ? "\n" : ""));
     } catch {
     }
   }
   persistMap() {
     try {
-      writeFileSync6(this.mapPath, JSON.stringify(Object.fromEntries(this.prodIdByKey)));
+      writeFileSync7(this.mapPath, JSON.stringify(Object.fromEntries(this.prodIdByKey)));
     } catch {
     }
   }
@@ -10297,20 +10534,20 @@ function tickPulse(health, now, intervalMs) {
 }
 
 // src/logRotate.ts
-import { copyFileSync as copyFileSync2, renameSync as renameSync5, statSync as statSync6, fstatSync, truncateSync, unlinkSync as unlinkSync3, existsSync as existsSync8 } from "fs";
+import { copyFileSync as copyFileSync4, renameSync as renameSync5, statSync as statSync7, fstatSync, truncateSync, unlinkSync as unlinkSync3, existsSync as existsSync9 } from "fs";
 var realIo = {
   size: (path) => {
     try {
-      return statSync6(path).size;
+      return statSync7(path).size;
     } catch {
       return null;
     }
   },
-  copy: copyFileSync2,
+  copy: copyFileSync4,
   rename: renameSync5,
   truncate: (path) => truncateSync(path, 0),
   unlink: unlinkSync3,
-  exists: existsSync8
+  exists: existsSync9
 };
 var realOwnerIo = {
   statFd: (fd) => {
@@ -10323,7 +10560,7 @@ var realOwnerIo = {
   },
   statPath: (path) => {
     try {
-      const s = statSync6(path);
+      const s = statSync7(path);
       return { dev: s.dev, ino: s.ino };
     } catch {
       return null;
@@ -10457,13 +10694,13 @@ async function buildRepoRegistry(paths) {
 }
 
 // src/repoMemory.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "fs";
-import { join as join11 } from "path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "fs";
+import { join as join12 } from "path";
 var FILE = "repos.json";
 function loadRememberedRepos(home) {
   let raw;
   try {
-    raw = readFileSync10(join11(home, FILE), "utf8");
+    raw = readFileSync10(join12(home, FILE), "utf8");
   } catch {
     return [];
   }
@@ -10478,7 +10715,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(join11(home, FILE), `${JSON.stringify({ paths: clean, at: now().toISOString() }, null, 2)}
+  writeFileSync9(join12(home, FILE), `${JSON.stringify({ paths: clean, at: now().toISOString() }, null, 2)}
 `);
 }
 function pickRepoPaths(args) {
@@ -10493,12 +10730,12 @@ init_src();
 init_config();
 init_linkFailure();
 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";
+import { readFileSync as readFileSync12, renameSync as renameSync6, writeFileSync as writeFileSync10 } from "fs";
+import { isAbsolute, join as join14, resolve as resolve2 } from "path";
 
 // src/repoScan.ts
-import { readdirSync as readdirSync7, readFileSync as readFileSync11, statSync as statSync7 } from "fs";
-import { join as join12 } from "path";
+import { readdirSync as readdirSync8, readFileSync as readFileSync11, statSync as statSync8 } from "fs";
+import { join as join13 } from "path";
 var SKIP = /* @__PURE__ */ new Set([
   "node_modules",
   "vendor",
@@ -10528,7 +10765,7 @@ function parseOriginFromGitConfig(text) {
 }
 function originOf(dir) {
   try {
-    return parseOriginFromGitConfig(readFileSync11(join12(dir, ".git", "config"), "utf8"));
+    return parseOriginFromGitConfig(readFileSync11(join13(dir, ".git", "config"), "utf8"));
   } catch {
     return null;
   }
@@ -10557,15 +10794,15 @@ function walk(dir, depth, maxDepth, found) {
   }
   let entries;
   try {
-    entries = readdirSync7(dir);
+    entries = readdirSync8(dir);
   } catch {
     return;
   }
   for (const name of entries) {
     if (name.startsWith(".") || SKIP.has(name)) continue;
-    const child = join12(dir, name);
+    const child = join13(dir, name);
     try {
-      if (!statSync7(child).isDirectory()) continue;
+      if (!statSync8(child).isDirectory()) continue;
     } catch {
       continue;
     }
@@ -10585,7 +10822,7 @@ 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(join12(home, name));
+    add(join13(home, name));
   }
   return out;
 }
@@ -10599,7 +10836,7 @@ function resolveScanRoots(raw, home = homedir5(), knownPaths = []) {
   for (const part of v.split(",")) {
     const p = part.trim();
     if (!p) continue;
-    const abs = p === "~" ? home : p.startsWith("~/") ? join13(home, p.slice(2)) : isAbsolute(p) ? p : resolve2(home, p);
+    const abs = p === "~" ? home : p.startsWith("~/") ? join14(home, p.slice(2)) : isAbsolute(p) ? p : resolve2(home, p);
     if (!out.includes(abs)) out.push(abs);
   }
   return out;
@@ -10828,7 +11065,7 @@ function loadRepoMapCache(path) {
 function writeRepoMapCache(path, entries, scannedAt = stamp()) {
   try {
     const tmp = `${path}.tmp`;
-    writeFileSync9(tmp, JSON.stringify({ at: stamp(), scannedAt, entries }, null, 2));
+    writeFileSync10(tmp, JSON.stringify({ at: stamp(), scannedAt, entries }, null, 2));
     renameSync6(tmp, path);
   } catch {
   }
@@ -10836,17 +11073,17 @@ function writeRepoMapCache(path, entries, scannedAt = stamp()) {
 
 // src/hostIdentity.ts
 import { hostname } from "os";
-import { existsSync as existsSync9, readFileSync as readFileSync13, renameSync as renameSync7, writeFileSync as writeFileSync10 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync13, renameSync as renameSync7, writeFileSync as writeFileSync11 } from "fs";
+import { join as join15 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function hostIdentityPath(home) {
-  return join14(home, "host.json");
+  return join15(home, "host.json");
 }
 function loadHostIdentity(deps) {
-  const exists = deps.exists ?? existsSync9;
+  const exists = deps.exists ?? existsSync10;
   const readFile2 = deps.readFile ?? ((p) => readFileSync13(p, "utf8"));
   const writeFile4 = deps.writeFile ?? ((p, data) => {
-    writeFileSync10(`${p}.tmp`, data);
+    writeFileSync11(`${p}.tmp`, data);
     renameSync7(`${p}.tmp`, p);
   });
   const host = deps.hostname ?? hostname;
@@ -10939,8 +11176,8 @@ function pickResumeCandidate(pausedForRelief) {
 }
 
 // src/reliefLoop.ts
-import { existsSync as existsSync10, readFileSync as readFileSync14, renameSync as renameSync8, writeFileSync as writeFileSync11 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync14, renameSync as renameSync8, writeFileSync as writeFileSync12 } from "fs";
+import { join as join16 } from "path";
 var numEnv3 = (name, def) => {
   const v = Number(process.env[name]);
   return Number.isFinite(v) && v > 0 ? v : def;
@@ -10975,10 +11212,10 @@ function reliefLoopTripped(entry, cfg = DEFAULT_RELIEF_LOOP_CONFIG) {
   return !!entry && entry.pauses >= cfg.limit;
 }
 function reliefLoopStatePath(home) {
-  return join15(home, "relief-loop.json");
+  return join16(home, "relief-loop.json");
 }
 function loadReliefLoopState(home, now = Date.now(), io = {}, cfg = DEFAULT_RELIEF_LOOP_CONFIG) {
-  const exists = io.exists ?? existsSync10;
+  const exists = io.exists ?? existsSync11;
   const readFile2 = io.readFile ?? ((p) => readFileSync14(p, "utf8"));
   const path = reliefLoopStatePath(home);
   if (!exists(path)) return {};
@@ -11001,7 +11238,7 @@ function loadReliefLoopState(home, now = Date.now(), io = {}, cfg = DEFAULT_RELI
 function saveReliefLoopState(home, state, io = {}) {
   const path = reliefLoopStatePath(home);
   const writeFile4 = io.writeFile ?? ((p, data) => {
-    writeFileSync11(`${p}.tmp`, data);
+    writeFileSync12(`${p}.tmp`, data);
     renameSync8(`${p}.tmp`, p);
   });
   writeFile4(path, JSON.stringify(state, null, 2));
@@ -11163,15 +11400,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 readdirSync9 } from "fs";
+import { closeSync as closeSync3, existsSync as existsSync12, mkdirSync as mkdirSync9, openSync as openSync3, readdirSync as readdirSync10 } from "fs";
 import { createRequire } from "module";
 import { homedir as homedir6 } from "os";
-import { dirname as dirname3, join as join17 } from "path";
+import { dirname as dirname3, join as join18 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/droneHome.ts
-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";
+import { lstatSync, mkdirSync as mkdirSync8, readdirSync as readdirSync9, rmSync, statSync as statSync9, symlinkSync as symlinkSync3 } from "fs";
+import { join as join17, 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);
@@ -11189,34 +11426,34 @@ function buildDroneHome(opts) {
   const { realHome, droneHome } = opts;
   const deny = opts.deny ?? droneHomeDeny();
   const platform = opts.platform ?? process.platform;
-  mkdirSync7(droneHome, { recursive: true, mode: 448 });
-  const wanted = new Set(mirroredEntries(readdirSync8(realHome), deny, platform));
+  mkdirSync8(droneHome, { recursive: true, mode: 448 });
+  const wanted = new Set(mirroredEntries(readdirSync9(realHome), deny, platform));
   const rel = relative(realHome, droneHome);
   if (rel && !rel.startsWith("..") && !rel.includes(sep)) wanted.delete(rel);
-  for (const existing of readdirSync8(droneHome)) {
+  for (const existing of readdirSync9(droneHome)) {
     if (wanted.has(existing)) continue;
-    const p = join16(droneHome, existing);
+    const p = join17(droneHome, existing);
     try {
       if (lstatSync(p).isSymbolicLink()) rmSync(p);
     } catch {
     }
   }
   for (const name of wanted) {
-    const link2 = join16(droneHome, name);
+    const link2 = join17(droneHome, name);
     try {
       lstatSync(link2);
       continue;
     } catch {
     }
-    const target = join16(realHome, name);
+    const target = join17(realHome, name);
     let isDir;
     try {
-      isDir = statSync8(target).isDirectory();
+      isDir = statSync9(target).isDirectory();
     } catch {
       continue;
     }
     try {
-      symlinkSync2(target, link2, isDir ? "junction" : "file");
+      symlinkSync3(target, link2, isDir ? "junction" : "file");
     } catch (e) {
       if (e.code !== "EEXIST") throw e;
     }
@@ -11229,7 +11466,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, join16(realHome, ...segments)]));
+  return Object.fromEntries(REAL_PATH_ENV_PINS.map(({ env, segments }) => [env, join17(realHome, ...segments)]));
 }
 function dronePrivatePaths(realHome, swarmHome) {
   return [
@@ -11312,7 +11549,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 = join17(worktree, ".turbo", "cache");
+    env.TURBO_CACHE_DIR = join18(worktree, ".turbo", "cache");
   }
   Object.assign(env, droneTestEnv(droneCap, base3));
   for (const key of DAEMON_STATE_ENV) delete env[key];
@@ -11343,21 +11580,21 @@ var DAEMON_STATE_ENV = [
   ...PROVIDER_TOKEN_ENV
 ];
 function bundledRoleDir(kind) {
-  return join17(dirname3(fileURLToPath2(import.meta.url)), "..", "roles", kind);
+  return join18(dirname3(fileURLToPath2(import.meta.url)), "..", "roles", kind);
 }
 function roleDir(worktree, kind) {
-  return join17(worktree, ".claude", "roles", kind);
+  return join18(worktree, ".claude", "roles", kind);
 }
 function roleDirs(worktree, kind) {
-  return [bundledRoleDir(kind), roleDir(worktree, kind)].filter((dir) => existsSync11(dir));
+  return [bundledRoleDir(kind), roleDir(worktree, kind)].filter((dir) => existsSync12(dir));
 }
 function nextRunLogPath(runLogsDir, runLogKeys) {
   const dir = runLogDirForWrite(runLogsDir, runLogKeys);
   if (!dir) throw new Error("\u043D\u0435\u0447\u0435\u043C \u0430\u0434\u0440\u0435\u0441\u043E\u0432\u0430\u0442\u044C \u043A\u0430\u0442\u0430\u043B\u043E\u0433 run-log'\u043E\u0432: \u0443 \u043F\u0440\u043E\u0433\u043E\u043D\u0430 \u043D\u0435\u0442 \u0441\u0442\u0430\u0431\u0438\u043B\u044C\u043D\u043E\u0433\u043E \u043A\u043B\u044E\u0447\u0430 (SwarmStore.runLogKeys)");
-  mkdirSync8(dir, { recursive: true });
+  mkdirSync9(dir, { recursive: true });
   let files = [];
   try {
-    files = readdirSync9(dir);
+    files = readdirSync10(dir);
   } catch {
   }
   let next = 0;
@@ -11365,7 +11602,7 @@ function nextRunLogPath(runLogsDir, runLogKeys) {
     const m = /^(\d+)\.json/.exec(f);
     if (m) next = Math.max(next, Number(m[1]) + 1);
   }
-  return join17(dir, `${next}.json`);
+  return join18(dir, `${next}.json`);
 }
 function openNextRunLog(runLogsDir, runLogKeys) {
   for (let attempt = 0; attempt < 50; attempt++) {
@@ -11457,9 +11694,9 @@ function makeLauncher(cfg) {
     }
     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(join17(cfg.droneIsolation.swarmHome, "token"))) {
+    if (cfg.droneIsolation && process.env.TASKLESS_TOKEN && !existsSync12(join18(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 ${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.`
+        `[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 ${join18(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 ?? executorForRun(run, cfg.swarmModels?.() ?? null);
@@ -11521,8 +11758,8 @@ function makeLauncher(cfg) {
 init_procCleanup();
 
 // src/cost.ts
-import { readFileSync as readFileSync15, readdirSync as readdirSync10, renameSync as renameSync9, statSync as statSync9 } from "fs";
-import { join as join18 } from "path";
+import { readFileSync as readFileSync15, readdirSync as readdirSync11, renameSync as renameSync9, statSync as statSync10 } from "fs";
+import { join as join19 } from "path";
 init_executors();
 init_swarmModels();
 var UNPROCESSED_LOG_RE = /^\d+\.json$/;
@@ -11530,7 +11767,7 @@ var SEGMENT_LOG_RE = /^(\d+)\.json(\.done)?$/;
 var RESCUE_OPEN_WINDOW_MAX_MS = 12 * 60 * 60 * 1e3;
 function unprocessedLogFiles(dir) {
   try {
-    return readdirSync10(dir).filter((f) => UNPROCESSED_LOG_RE.test(f));
+    return readdirSync11(dir).filter((f) => UNPROCESSED_LOG_RE.test(f));
   } catch {
     return [];
   }
@@ -11539,7 +11776,7 @@ function segmentStarts(dir) {
   const starts = /* @__PURE__ */ new Map();
   let entries;
   try {
-    entries = readdirSync10(dir);
+    entries = readdirSync11(dir);
   } catch {
     return starts;
   }
@@ -11547,7 +11784,7 @@ function segmentStarts(dir) {
     const m = SEGMENT_LOG_RE.exec(f);
     if (!m) continue;
     try {
-      const st = statSync9(join18(dir, f));
+      const st = statSync10(join19(dir, f));
       starts.set(Number(m[1]), st.birthtimeMs > 0 ? st.birthtimeMs : st.ctimeMs);
     } catch {
     }
@@ -11600,7 +11837,7 @@ function accountRunCost(deps, run) {
   let unmeasured = 0;
   const processed = [];
   for (const f of files) {
-    const full = join18(dir, f);
+    const full = join19(dir, f);
     let raw = null;
     try {
       raw = readFileSync15(full, "utf8");
@@ -11657,8 +11894,8 @@ function makeCostSweeper(deps) {
 }
 
 // src/runOutcome.ts
-import { readdirSync as readdirSync11, readFileSync as readFileSync16 } from "fs";
-import { join as join19 } from "path";
+import { readdirSync as readdirSync12, readFileSync as readFileSync16 } from "fs";
+import { join as join20 } from "path";
 init_executors();
 function endedItself(outcome) {
   return outcome === "graceful" || outcome === "budget" || outcome === "aborted";
@@ -11672,7 +11909,7 @@ function readLatestResultRaw(runLogsDir, runLogKeys) {
   if (!dir) return null;
   let files;
   try {
-    files = readdirSync11(dir);
+    files = readdirSync12(dir);
   } catch {
     return null;
   }
@@ -11685,7 +11922,7 @@ function readLatestResultRaw(runLogsDir, runLogKeys) {
   }
   if (!latest) return null;
   try {
-    return readFileSync16(join19(dir, latest.name), "utf8");
+    return readFileSync16(join20(dir, latest.name), "utf8");
   } catch {
     return null;
   }
@@ -11717,9 +11954,11 @@ init_claudeCode();
 init_swarmModels();
 
 // src/executors/detect.ts
+init_src();
+init_swarmModels();
 init_executors();
 import { accessSync, constants } from "fs";
-import { delimiter, join as join20 } from "path";
+import { delimiter, join as join21 } from "path";
 function binRunnable(bin, env) {
   if (!bin) return false;
   if (bin.includes("/") || bin.includes("\\")) {
@@ -11735,7 +11974,7 @@ function binRunnable(bin, env) {
     if (!dir) continue;
     for (const ext of exts) {
       try {
-        accessSync(join20(dir, bin + ext), constants.X_OK);
+        accessSync(join21(dir, bin + ext), constants.X_OK);
         return true;
       } catch {
       }
@@ -11766,26 +12005,36 @@ function cachedInstalledExecutorIds(now = Date.now(), ttlMs = 3e5, env = process
   }
   return cachedIds;
 }
+function availableProviders(installedExecutors, env = process.env) {
+  const explicit = providersFromEnv(env);
+  if (explicit) return explicit;
+  const installed2 = new Set(installedExecutors);
+  return MODEL_PROVIDERS.filter((p) => installed2.has(p.executorId)).map((p) => p.id);
+}
+function providerUnavailableReason(providerId, available) {
+  if (available.length === 0 || available.includes(providerId)) return null;
+  return `provider_unavailable: \u043C\u043E\u0434\u0435\u043B\u044C \u043F\u0440\u043E\u0433\u043E\u043D\u0430 \u0442\u0440\u0435\u0431\u0443\u0435\u0442 \u043F\u0440\u043E\u0432\u0430\u0439\u0434\u0435\u0440\u0430 \xAB${providerId}\xBB, \u0430 \u043D\u0430 \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435 \u0442\u043E\u043B\u044C\u043A\u043E ${available.join(", ")} \u2014 \u043F\u0440\u043E\u0433\u043E\u043D \u043D\u0435 \u0431\u0435\u0440\u0443, \u0435\u0433\u043E \u0432\u043E\u0437\u044C\u043C\u0451\u0442 \u0434\u0440\u0443\u0433\u0430\u044F \u043C\u0430\u0448\u0438\u043D\u0430`;
+}
 
 // src/orchestrator.ts
 init_src();
 init_git();
 
 // src/deps.ts
-import { existsSync as existsSync14, readdirSync as readdirSync13, readFileSync as readFileSync18 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync15, readdirSync as readdirSync14, readFileSync as readFileSync18 } from "fs";
+import { join as join25 } 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 statSync11, writeSync } from "fs";
-import { join as join22 } from "path";
+import { closeSync as closeSync4, openSync as openSync4, rmSync as rmSync2, statSync as statSync12, writeSync } from "fs";
+import { join as join23 } 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 join22(dir, `swarm-prepare-${createHash("sha1").update(key).digest("hex").slice(0, 16)}.lock`);
+  return join23(dir, `swarm-prepare-${createHash("sha1").update(key).digest("hex").slice(0, 16)}.lock`);
 }
 function defaultTryCreate(path, content) {
   try {
@@ -11802,7 +12051,7 @@ function defaultTryCreate(path, content) {
 }
 function defaultAgeMs(path) {
   try {
-    return Date.now() - statSync11(path).mtimeMs;
+    return Date.now() - statSync12(path).mtimeMs;
   } catch {
     return null;
   }
@@ -11846,8 +12095,8 @@ init_config();
 init_config();
 import { createHash as createHash2 } from "crypto";
 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 join23 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync17 } from "fs";
+import { join as join24 } from "path";
 function fingerprint(parts) {
   const h = createHash2("sha256");
   for (const p of parts) {
@@ -11861,8 +12110,8 @@ async function cloneTree(src, dst) {
   const entries = await readdir(src, { withFileTypes: true });
   await Promise.all(
     entries.map(async (e) => {
-      const from = join23(src, e.name);
-      const to = join23(dst, e.name);
+      const from = join24(src, e.name);
+      const to = join24(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 }));
@@ -11875,11 +12124,11 @@ function cacheRoot(io) {
   return io.root ?? ENV_CACHE_DIR;
 }
 function snapshotDir(io, key) {
-  return join23(cacheRoot(io), key);
+  return join24(cacheRoot(io), key);
 }
 function readManifest(dir) {
   try {
-    const parsed = JSON.parse(readFileSync17(join23(dir, "manifest.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync17(join24(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;
@@ -11891,11 +12140,11 @@ function readManifest(dir) {
   }
 }
 function hasEnvSnapshot(key, io = {}) {
-  const exists = io.exists ?? existsSync13;
-  return exists(join23(snapshotDir(io, key), "manifest.json"));
+  const exists = io.exists ?? existsSync14;
+  return exists(join24(snapshotDir(io, key), "manifest.json"));
 }
 async function restoreEnvSnapshot(worktree, key, io = {}) {
-  const exists = io.exists ?? existsSync13;
+  const exists = io.exists ?? existsSync14;
   const clone = io.clone ?? cloneTree;
   const dir = snapshotDir(io, key);
   const manifest = readManifest(dir);
@@ -11904,13 +12153,13 @@ async function restoreEnvSnapshot(worktree, key, io = {}) {
   try {
     for (let i = 0; i < manifest.dirs.length; i++) {
       const rel = manifest.dirs[i] ?? "";
-      const target = join23(worktree, rel);
+      const target = join24(worktree, rel);
       if (exists(target)) continue;
-      await clone(join23(dir, "trees", String(i)), target);
+      await clone(join24(dir, "trees", String(i)), target);
       made.push(rel);
     }
   } catch {
-    for (const rel of made) await rm2(join23(worktree, rel), { recursive: true, force: true }).catch(() => {
+    for (const rel of made) await rm2(join24(worktree, rel), { recursive: true, force: true }).catch(() => {
     });
     return null;
   }
@@ -11923,19 +12172,19 @@ async function touch(dir) {
   });
 }
 async function saveEnvSnapshot(worktree, key, dirs, io = {}) {
-  const exists = io.exists ?? existsSync13;
+  const exists = io.exists ?? existsSync14;
   const clone = io.clone ?? cloneTree;
   if (hasEnvSnapshot(key, io)) return true;
-  const present = dirs.filter((rel) => exists(join23(worktree, rel)));
+  const present = dirs.filter((rel) => exists(join24(worktree, rel)));
   if (!present.length) return false;
   const root = cacheRoot(io);
-  const tmp = join23(root, `.tmp-${key}-${process.pid}`);
+  const tmp = join24(root, `.tmp-${key}-${process.pid}`);
   try {
     await rm2(tmp, { recursive: true, force: true });
-    await mkdir2(join23(tmp, "trees"), { recursive: true });
-    for (let i = 0; i < present.length; i++) await clone(join23(worktree, present[i] ?? ""), join23(tmp, "trees", String(i)));
+    await mkdir2(join24(tmp, "trees"), { recursive: true });
+    for (let i = 0; i < present.length; i++) await clone(join24(worktree, present[i] ?? ""), join24(tmp, "trees", String(i)));
     const manifest = { key, dirs: present, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
-    await writeFile2(join23(tmp, "manifest.json"), JSON.stringify(manifest, null, 2));
+    await writeFile2(join24(tmp, "manifest.json"), JSON.stringify(manifest, null, 2));
     await rename2(tmp, snapshotDir(io, key));
     return true;
   } catch {
@@ -11955,13 +12204,13 @@ async function pruneEnvSnapshots(io = {}) {
   }
   const withTime = [];
   for (const name of names) {
-    const s = await stat(join23(root, name)).catch(() => null);
+    const s = await stat(join24(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(join23(root, name), { recursive: true, force: true }).catch(() => {
+    await rm2(join24(root, name), { recursive: true, force: true }).catch(() => {
     });
     removed++;
   }
@@ -11977,9 +12226,9 @@ async function sweepEnvCacheTemp(io = {}) {
   }
   let removed = 0;
   for (const name of names) {
-    const s = await lstat(join23(root, name)).catch(() => null);
+    const s = await lstat(join24(root, name)).catch(() => null);
     if (!s || Date.now() - s.mtimeMs < 60 * 6e4) continue;
-    await rm2(join23(root, name), { recursive: true, force: true }).catch(() => {
+    await rm2(join24(root, name), { recursive: true, force: true }).catch(() => {
     });
     removed++;
   }
@@ -12013,14 +12262,14 @@ function safeReadText(p) {
 }
 function safeListDirs(p) {
   try {
-    return readdirSync13(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    return readdirSync14(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
   } catch {
     return [];
   }
 }
 function safeListFiles(p) {
   try {
-    return readdirSync13(p, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name);
+    return readdirSync14(p, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name);
   } catch {
     return [];
   }
@@ -12046,21 +12295,21 @@ function overridePlan(override) {
   };
 }
 function detectPackageManager(worktree, io = {}) {
-  const exists = io.exists ?? existsSync14;
+  const exists = io.exists ?? existsSync15;
   const readText = io.readText ?? safeReadText;
-  const hasPkgJson = exists(join24(worktree, "package.json"));
+  const hasPkgJson = exists(join25(worktree, "package.json"));
   if (!hasPkgJson) {
-    if (exists(join24(worktree, "deno.json")) || exists(join24(worktree, "deno.jsonc")) || exists(join24(worktree, "deno.lock"))) return "deno";
+    if (exists(join25(worktree, "deno.json")) || exists(join25(worktree, "deno.jsonc")) || exists(join25(worktree, "deno.lock"))) return "deno";
     return null;
   }
-  const pkg = readJson(readText, join24(worktree, "package.json"));
+  const pkg = readJson(readText, join25(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(join24(worktree, "bun.lock")) || exists(join24(worktree, "bun.lockb"))) return "bun";
-  if (exists(join24(worktree, "pnpm-lock.yaml"))) return "pnpm";
-  if (exists(join24(worktree, "yarn.lock"))) return "yarn";
-  if (exists(join24(worktree, "package-lock.json"))) return "npm";
-  if (exists(join24(worktree, "deno.lock"))) return "deno";
+  if (exists(join25(worktree, "bun.lock")) || exists(join25(worktree, "bun.lockb"))) return "bun";
+  if (exists(join25(worktree, "pnpm-lock.yaml"))) return "pnpm";
+  if (exists(join25(worktree, "yarn.lock"))) return "yarn";
+  if (exists(join25(worktree, "package-lock.json"))) return "npm";
+  if (exists(join25(worktree, "deno.lock"))) return "deno";
   return "npm";
 }
 function jsInstallCommand(pm) {
@@ -12116,7 +12365,7 @@ var ECOSYSTEM_MARKERS = [
   // конфигурация — дело сборки, не подготовки
 ];
 function detectPlan(worktree, io) {
-  const exists = io.exists ?? existsSync14;
+  const exists = io.exists ?? existsSync15;
   const listFiles = io.listFiles ?? safeListFiles;
   const pm = detectPackageManager(worktree, io);
   if (pm) {
@@ -12124,7 +12373,7 @@ function detectPlan(worktree, io) {
       // node_modules на месте — установку пропускаем (быстрый путь переиспользованного worktree).
       // У deno каталога может не быть вовсе (кэш в DENO_DIR) — тогда `deno install` отработает
       // заново, но он дешёвый: тянет из того же общего кэша.
-      { label: `${pm} install`, run: jsInstallCommand(pm), skipIfExists: join24(worktree, "node_modules"), source: "detect" }
+      { label: `${pm} install`, run: jsInstallCommand(pm), skipIfExists: join25(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" });
@@ -12133,12 +12382,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(join24(worktree, f))) || marker.ext !== void 0 && listFiles(worktree).some((n) => n.endsWith(marker.ext));
+    const hit = marker.files.some((f) => exists(join25(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(join24(worktree, refine.file))) continue;
+      if (!exists(join25(worktree, refine.file))) continue;
       ecosystem = refine.ecosystem;
       command = refine.command;
       break;
@@ -12195,12 +12444,12 @@ var CI_INSTALL_PATTERNS = [
 function ciWorkflowPlan(worktree, io) {
   const readText = io.readText ?? safeReadText;
   const listFiles = io.listFiles ?? safeListFiles;
-  const dir = join24(worktree, ".github", "workflows");
+  const dir = join25(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(join24(dir, name));
+    const yaml = readText(join25(dir, name));
     if (yaml === null) continue;
     for (const raw of workflowRunLines(yaml)) {
       const line = raw.replace(/\s+/g, " ").trim();
@@ -12215,7 +12464,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(join24(worktree, "pnpm-workspace.yaml"));
+  const yaml = readText(join25(worktree, "pnpm-workspace.yaml"));
   if (yaml !== null) {
     const globs = [];
     let inPackages = false;
@@ -12235,7 +12484,7 @@ function workspaceGlobs(worktree, readText) {
     }
     if (globs.length) return globs;
   }
-  const pkg = readJson(readText, join24(worktree, "package.json"));
+  const pkg = readJson(readText, join25(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");
@@ -12246,14 +12495,14 @@ function workspaceDirs(worktree, globs, io) {
     if (glob.startsWith("!")) continue;
     const star = glob.indexOf("*");
     if (star === -1) {
-      const dir = join24(worktree, glob);
-      if (io.exists(join24(dir, "package.json"))) dirs.add(dir);
+      const dir = join25(worktree, glob);
+      if (io.exists(join25(dir, "package.json"))) dirs.add(dir);
       continue;
     }
-    const base3 = join24(worktree, glob.slice(0, star).replace(/\/$/, ""));
+    const base3 = join25(worktree, glob.slice(0, star).replace(/\/$/, ""));
     for (const name of io.listDirs(base3)) {
-      const dir = join24(base3, name);
-      if (io.exists(join24(dir, "package.json"))) dirs.add(dir);
+      const dir = join25(base3, name);
+      if (io.exists(join25(dir, "package.json"))) dirs.add(dir);
     }
   }
   return [...dirs];
@@ -12274,18 +12523,18 @@ function entryPaths(pkg) {
   return out;
 }
 function workspaceBuildTargets(worktree, io = {}) {
-  const exists = io.exists ?? existsSync14;
+  const exists = io.exists ?? existsSync15;
   const readText = io.readText ?? safeReadText;
   const listDirs = io.listDirs ?? safeListDirs;
   const globs = workspaceGlobs(worktree, readText);
   if (!globs.length) return [];
   const pkgs = [];
   for (const dir of workspaceDirs(worktree, globs, { exists, listDirs })) {
-    const pkg = readJson(readText, join24(dir, "package.json"));
+    const pkg = readJson(readText, join25(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(join24(dir, e)));
+    const needsBuild = typeof scripts.build === "string" && entries.length > 0 && entries.some((e) => !exists(join25(dir, e)));
     const deps = Object.keys({ ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} });
     pkgs.push({ name: pkg.name, dir, deps, needsBuild });
   }
@@ -12313,7 +12562,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(join24(worktree, file));
+    const raw = readText(join25(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, "");
@@ -12329,11 +12578,11 @@ function isLocalDatabase(url) {
   }
 }
 function prismaPackages(worktree, io) {
-  const exists = io.exists ?? existsSync14;
+  const exists = io.exists ?? existsSync15;
   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(join24(dir, "prisma", "schema.prisma")) && listDirs(join24(dir, "prisma", "migrations")).length > 0);
+  return dirs.filter((dir) => exists(join25(dir, "prisma", "schema.prisma")) && listDirs(join25(dir, "prisma", "migrations")).length > 0);
 }
 function jsExecBin(pm, command) {
   switch (pm) {
@@ -12363,25 +12612,25 @@ function migrateCommands(worktree, pm, io) {
 var ENV_DEFINING_FILES = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lock", "bun.lockb", "deno.lock", "pnpm-workspace.yaml"];
 function envCachePlan(worktree, io = {}) {
   if (!ENV_CACHE_ENABLED) return null;
-  const exists = io.exists ?? existsSync14;
+  const exists = io.exists ?? existsSync15;
   const readText = io.readText ?? safeReadText;
   const listDirs = io.listDirs ?? safeListDirs;
   const pm = detectPackageManager(worktree, io);
   if (!pm) return null;
   const parts = [`pm:${pm}`];
   for (const name of ENV_DEFINING_FILES) {
-    const raw = readText(join24(worktree, name));
+    const raw = readText(join25(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(join24(worktree, rel, "package.json"));
+    const raw = readText(join25(worktree, rel, "package.json"));
     if (raw !== null) parts.push(`${rel}/package.json
 ${raw}`);
   }
-  return { key: fingerprint(parts), dirs: ["node_modules", ...rels.map((rel) => join24(rel, "node_modules"))] };
+  return { key: fingerprint(parts), dirs: ["node_modules", ...rels.map((rel) => join25(rel, "node_modules"))] };
 }
 function planPrepare(worktree, io = {}) {
   const plan = overridePlan(io.override) ?? detectPlan(worktree, io) ?? ciWorkflowPlan(worktree, io);
@@ -12389,7 +12638,7 @@ function planPrepare(worktree, io = {}) {
   return { ...plan, commands: plan.commands.slice(0, MAX_PLAN_COMMANDS) };
 }
 async function ensureWorktreeDeps(worktree, io = {}) {
-  const exists = io.exists ?? existsSync14;
+  const exists = io.exists ?? existsSync15;
   const exec = io.exec ?? ((cmd) => runCommand(cmd, worktree));
   const approve = io.approve ?? (() => true);
   const cachePlan = envCachePlan(worktree, io);
@@ -12406,7 +12655,7 @@ async function ensureWorktreeDeps(worktree, io = {}) {
     restored: [],
     cached: false
   };
-  if (cachePlan && !exists(join24(worktree, "node_modules"))) {
+  if (cachePlan && !exists(join25(worktree, "node_modules"))) {
     report.restored = await restoreEnvSnapshot(worktree, cachePlan.key, cacheIO) ?? [];
   }
   const plan = planPrepare(worktree, io);
@@ -12493,10 +12742,10 @@ function depsPromptNotice(report) {
 
 // src/orchestrator.ts
 init_config();
-import { existsSync as existsSync15, mkdirSync as mkdirSync9, rmSync as rmSync3 } from "fs";
-import { join as join25, dirname as dirname4 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync10, rmSync as rmSync3 } from "fs";
+import { join as join26, dirname as dirname4 } from "path";
 function repolessRunDir(worktreesDir, taskSlug) {
-  return join25(dirname4(worktreesDir), "runs", taskSlug);
+  return join26(dirname4(worktreesDir), "runs", taskSlug);
 }
 var WORKTREE_HELD_STATUSES = /* @__PURE__ */ new Set(["running", "blocked", "review", "paused", "storm_dead"]);
 function worktreePathHeldLive(db, path, exceptRunId) {
@@ -12541,11 +12790,11 @@ function healTaskSlug(db, run, task) {
 async function spawnDrone(deps, run) {
   if (run.repoless) {
     const workdir = repolessRunDir(deps.worktreesDir, run.task_slug);
-    if (existsSync15(workdir)) {
+    if (existsSync16(workdir)) {
       rmSync3(workdir, { recursive: true, force: true });
       deps.db.addEvent(run.id, "step", `\u0440\u0435\u043A\u043B\u0435\u0439\u043C \u043E\u0441\u0438\u0440\u043E\u0442\u0435\u0432\u0448\u0435\u0433\u043E \u0441\u043A\u0440\u0430\u0442\u0447-\u043A\u0430\u0442\u0430\u043B\u043E\u0433\u0430 ${workdir} (\u0434\u0435\u0440\u0436\u0430\u043B \u043C\u0451\u0440\u0442\u0432\u044B\u0439 \u043F\u0440\u043E\u0433\u043E\u043D)`);
     }
-    mkdirSync9(workdir, { recursive: true });
+    mkdirSync10(workdir, { recursive: true });
     if (run.area && deps.db.runningAreas("").includes(run.area)) throw new AreaBusyError(run.area);
     deps.db.addEvent(run.id, "step", `repoless-\u043F\u0440\u043E\u0433\u043E\u043D: \u0441\u043A\u0440\u0430\u0442\u0447-\u043A\u0430\u0442\u0430\u043B\u043E\u0433 ${workdir} (\u0431\u0435\u0437 worktree/\u0432\u0435\u0442\u043A\u0438/PR \u2014 TASWM-595)`);
     const built2 = await deps.buildPrompt(run, workdir);
@@ -12760,7 +13009,7 @@ function parkReasonUnretriable(reason) {
 // package.json
 var package_default = {
   name: "@taskless-app/swarm",
-  version: "0.6.62",
+  version: "0.6.63",
   type: "module",
   description: "Local control plane for a fleet of AI coding agents (drones), coordinating through Taskless. The overmind runs the swarm.",
   keywords: [
@@ -12811,7 +13060,7 @@ var package_default = {
     execa: "^10.0.0",
     zod: "3.25.76"
   },
-  gitHead: "e999630218010a25c03a6024e1b71ef34b2359ec"
+  gitHead: "8d438b6288da036308528cff1160a157b4b64abd"
 };
 
 // src/version.ts
@@ -13599,8 +13848,8 @@ import { z } from "zod";
 init_git();
 
 // src/diff.ts
-import { statSync as statSync12 } from "fs";
-import { join as join30 } from "path";
+import { statSync as statSync13 } from "fs";
+import { join as join31 } from "path";
 import { $ as $4 } from "execa";
 var MAX_FILES = 200;
 var MAX_LINES_PER_FILE = 1500;
@@ -13743,7 +13992,7 @@ async function resolveBase(wt, baseBranch) {
 }
 function mtime(path) {
   try {
-    return statSync12(path).mtimeMs;
+    return statSync13(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -13768,7 +14017,7 @@ async function collectRunDiff(worktree, opts = {}) {
       files.push(pf);
     }
   }
-  files.sort((a, b) => mtime(join30(worktree, b.path)) - mtime(join30(worktree, a.path)));
+  files.sort((a, b) => mtime(join31(worktree, b.path)) - mtime(join31(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);
@@ -15768,9 +16017,9 @@ function mergeQueueCandidates(runs, repo, repoFallback) {
   const byPr = /* @__PURE__ */ new Map();
   for (const r of runs) {
     if (effectiveRepoOf(r.repo, repoFallback) !== repo || !isMergeCandidate(r)) continue;
-    const num = prNumberOf(r.pr_url);
-    const seen = byPr.get(num);
-    if (!seen || r.id > seen.id) byPr.set(num, r);
+    const num2 = prNumberOf(r.pr_url);
+    const seen = byPr.get(num2);
+    if (!seen || r.id > seen.id) byPr.set(num2, r);
   }
   return [...byPr.values()];
 }
@@ -15783,10 +16032,10 @@ function makeMergeQueueResolver(deps) {
   };
   return async (run) => {
     if (!deps.baseSync || !run.pr_url) return null;
-    const num = prNumberOf(run.pr_url);
-    if (num == null) return null;
+    const num2 = prNumberOf(run.pr_url);
+    if (num2 == null) return null;
     const candidates = mergeQueueCandidates(deps.listRuns(), effectiveRepoOf(run.repo, deps.repoFallback), deps.repoFallback);
-    const mine = candidates.find((c) => prNumberOf(c.pr_url) === num);
+    const mine = candidates.find((c) => prNumberOf(c.pr_url) === num2);
     if (!mine) return null;
     const ready = [];
     const urlOf = /* @__PURE__ */ new Map();
@@ -15902,10 +16151,10 @@ function makeMergeIntentResolver(deps) {
   };
   return async (run) => {
     if (!deps.baseSync || !run.pr_url || !hasMergeIntent(run)) return null;
-    const num = prNumberOf(run.pr_url);
-    if (num == null) return null;
+    const num2 = prNumberOf(run.pr_url);
+    if (num2 == null) return null;
     const marked = mergeQueueCandidates(deps.listRuns(), effectiveRepoOf(run.repo, deps.repoFallback), deps.repoFallback).filter(hasMergeIntent);
-    const mine = marked.find((c) => prNumberOf(c.pr_url) === num);
+    const mine = marked.find((c) => prNumberOf(c.pr_url) === num2);
     if (!mine) return null;
     const queue = orderMergeQueue(marked.map(entryOf));
     const entry = entryOf(mine);
@@ -16062,22 +16311,22 @@ async function prodClearMergeIntent(runId, deps = {}) {
 }
 
 // src/envGate.ts
-import { existsSync as existsSync18 } from "fs";
-import { join as join32 } from "path";
+import { existsSync as existsSync19 } from "fs";
+import { join as join33 } from "path";
 import { createConnection } from "net";
 import { execa as execa2 } from "execa";
 
 // src/platform.ts
-import { existsSync as existsSync17, readFileSync as readFileSync22 } from "fs";
-import { delimiter as delimiter2, join as join31 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync22 } from "fs";
+import { delimiter as delimiter2, join as join32 } from "path";
 function resolveCommandPath(name, env = process.env, platform = process.platform) {
-  if (name.includes("/") || name.includes("\\")) return existsSync17(name) ? name : null;
+  if (name.includes("/") || name.includes("\\")) return existsSync18(name) ? name : null;
   const dirs = (env.PATH ?? env.Path ?? "").split(delimiter2).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 = join31(dir, name + ext);
-      if (existsSync17(candidate)) return candidate;
+      const candidate = join32(dir, name + ext);
+      if (existsSync18(candidate)) return candidate;
     }
   }
   return null;
@@ -16160,8 +16409,8 @@ var COMPOSE_MARKERS = [
   "compose.yaml"
 ];
 function detectRequirements(repo, io = {}) {
-  const exists = io.exists ?? existsSync18;
-  const marker = COMPOSE_MARKERS.find((f) => exists(join32(repo, f)));
+  const exists = io.exists ?? existsSync19;
+  const marker = COMPOSE_MARKERS.find((f) => exists(join33(repo, f)));
   return marker ? [{ kind: "docker", raw: `docker (\u0434\u0435\u0442\u0435\u043A\u0442: ${marker})` }] : [];
 }
 function resolveRequirements(repo, declared, io = {}) {
@@ -17916,10 +18165,10 @@ function closeWebServer(server) {
 
 // src/hostCommands.ts
 init_src();
-import { readFileSync as readFileSync23, renameSync as renameSync10, writeFileSync as writeFileSync15 } from "fs";
-import { join as join33 } from "path";
+import { readFileSync as readFileSync23, renameSync as renameSync10, writeFileSync as writeFileSync16 } from "fs";
+import { join as join34 } from "path";
 function hostCommandStatePath(home) {
-  return join33(home, "host-command.json");
+  return join34(home, "host-command.json");
 }
 function readState(path) {
   try {
@@ -17930,7 +18179,7 @@ function readState(path) {
 }
 function writeState(path, state) {
   try {
-    writeFileSync15(`${path}.tmp`, JSON.stringify(state));
+    writeFileSync16(`${path}.tmp`, JSON.stringify(state));
     renameSync10(`${path}.tmp`, path);
   } catch {
   }
@@ -18093,8 +18342,8 @@ async function doRestart(cmd, opts, note) {
 
 // src/selfUpdate.ts
 init_git();
-import { existsSync as existsSync19 } from "fs";
-import { join as join34 } from "path";
+import { existsSync as existsSync20 } from "fs";
+import { join as join35 } from "path";
 import { $ as $5 } from "execa";
 var DAEMON_PACKAGE = "@taskless-app/swarm";
 var defaultRun = async (cmd, args, cwd) => {
@@ -18107,7 +18356,7 @@ function tail(text, max = 400) {
 }
 async function runSelfUpdate(io) {
   const run = io.run ?? defaultRun;
-  const exists = io.exists ?? existsSync19;
+  const exists = io.exists ?? existsSync20;
   const repo = io.repo;
   await io.onStep("fetch", "\u0442\u044F\u043D\u0443 \u0441\u0432\u0435\u0436\u0438\u0439 \u043A\u043E\u0434");
   const fetched = await run("git", ["-C", repo, "fetch", "--quiet", "origin"], repo);
@@ -18136,7 +18385,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(join34(repo, "pnpm-lock.yaml"))) {
+  if (!exists(join35(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);
@@ -18301,18 +18550,18 @@ async function fetchExternalStorm(url, opts = {}) {
 }
 
 // src/anomalyState.ts
-import { existsSync as existsSync20, readFileSync as readFileSync24, renameSync as renameSync11, writeFileSync as writeFileSync16 } from "fs";
-import { join as join35 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync24, renameSync as renameSync11, writeFileSync as writeFileSync17 } from "fs";
+import { join as join36 } 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 join35(home, "anomaly-state.json");
+  return join36(home, "anomaly-state.json");
 }
 function loadAnomalyState(home, now = Date.now(), io = {}) {
-  const exists = io.exists ?? existsSync20;
+  const exists = io.exists ?? existsSync21;
   const readFile2 = io.readFile ?? ((p) => readFileSync24(p, "utf8"));
   const path = anomalyStatePath(home);
   if (!exists(path)) return emptyState();
@@ -18343,7 +18592,7 @@ function loadAnomalyState(home, now = Date.now(), io = {}) {
 function saveAnomalyState(home, state, io = {}) {
   const path = anomalyStatePath(home);
   const writeFile4 = io.writeFile ?? ((p, data) => {
-    writeFileSync16(`${p}.tmp`, data);
+    writeFileSync17(`${p}.tmp`, data);
     renameSync11(`${p}.tmp`, p);
   });
   writeFile4(path, JSON.stringify(state, null, 2));
@@ -18870,8 +19119,16 @@ function worktreeFromCmd(args) {
   const quoted = args.match(/--mcp-config\s+"([^"]+[/\\]\.swarm-mcp\.json)"/);
   const bare = quoted ? null : args.match(/--mcp-config\s+(\S+[/\\]\.swarm-mcp\.json)/);
   const path = quoted?.[1] ?? bare?.[1];
-  if (!path) return null;
-  return path.replace(/[/\\]\.swarm-mcp\.json$/, "");
+  if (path) return path.replace(/[/\\]\.swarm-mcp\.json$/, "");
+  return worktreeFromGrokCwd(args);
+}
+function worktreeFromGrokCwd(args) {
+  const trimmed = args.trim();
+  const first = trimmed.startsWith('"') ? trimmed.slice(1, trimmed.indexOf('"', 1)) : trimmed.split(/\s/)[0] ?? "";
+  if (!/(?:^|[\\/])grok(?:\.exe)?$/i.test(first)) return null;
+  const cwdQuoted = args.match(/--cwd\s+"([^"]+)"/);
+  const cwdBare = cwdQuoted ? null : args.match(/--cwd\s+(\S+)/);
+  return cwdQuoted?.[1] ?? cwdBare?.[1] ?? null;
 }
 function listDroneProcesses() {
   const rows = [];
@@ -19616,7 +19873,7 @@ ${task.description}` : `\u0417\u0430\u0434\u0430\u0447\u0430 ${run.task_slug} (\
   }
   return parts.join("\n");
 }
-var HERO_CHARTER_PATH = join36(dirname6(THIS_FILE), "..", "docs", "HERO.md");
+var HERO_CHARTER_PATH = join37(dirname6(THIS_FILE), "..", "docs", "HERO.md");
 function buildHeroPrompt(task, run, taskContext, attachmentsBlock) {
   const name = run.name || `#${run.id}`;
   const charter = readFileSync25(HERO_CHARTER_PATH, "utf8");
@@ -19676,7 +19933,7 @@ function ciTrustLine(prUrl, verifyMode) {
   }
   return `\u041D\u0435 \u043F\u0435\u0440\u0435\u0433\u043E\u043D\u044F\u0439 \u0442\u0435\u0441\u0442-\u0441\u044C\u044E\u0442/typecheck \u0437\u0430\u043D\u043E\u0432\u043E \u2014 \u044D\u0442\u043E \u0443\u0436\u0435 \u0441\u0434\u0435\u043B\u0430\u043B CI \u043D\u0430 \u044D\u0442\u043E\u043C \u0436\u0435 \u043A\u043E\u043C\u043C\u0438\u0442\u0435 (\u0434\u0432\u043E\u0439\u043D\u043E\u0439 \u043F\u0440\u043E\u0433\u043E\u043D \u043D\u0430 \u043C\u0430\u0448\u0438\u043D\u0435 \u0432\u043B\u0430\u0434\u0435\u043B\u044C\u0446\u0430 \u043E\u0442\u043C\u0435\u043D\u0451\u043D, TASWM-249). \u041F\u0440\u043E\u0447\u0438\u0442\u0430\u0439 \u0435\u0433\u043E \u0440\u0435\u0437\u0443\u043B\u044C\u0442\u0430\u0442 \u0441\u0430\u043C: ${readChecks}. \u0414\u0430\u043B\u044C\u0448\u0435 \u0442\u0440\u0438 \u0440\u0430\u0437\u043D\u044B\u0445 \u0441\u043B\u0443\u0447\u0430\u044F: \u2460 \u0445\u043E\u0442\u044C \u043E\u0434\u0438\u043D \u0447\u0435\u043A \u0435\u0449\u0451 PENDING \u2014 \u0432\u0435\u0440\u0434\u0438\u043A\u0442 \u0432\u043E\u043E\u0431\u0449\u0435 \u043D\u0435 \u0432\u044B\u043D\u043E\u0441\u0438: \u043D\u0435 \u043F\u043E\u0441\u0442\u0438 REQUEST CHANGES, \u043D\u0435 \u0437\u043E\u0432\u0438 done(), \u043F\u0440\u043E\u0441\u0442\u043E \u0437\u0430\u0432\u0435\u0440\u0448\u0438 \u0441\u0435\u0441\u0441\u0438\u044E \u043A\u0430\u043A \u0435\u0441\u0442\u044C \u2014 \u0440\u043E\u0439 \u0441\u0430\u043C \u0437\u0430\u043C\u0435\u0442\u0438\u0442, \u0447\u0442\u043E \u0442\u044B \u0436\u0434\u0451\u0448\u044C CI, \u0438 \u0440\u0430\u0437\u0431\u0443\u0434\u0438\u0442 \u0434\u043E\u0434\u0435\u043B\u0430\u0442\u044C \u0440\u0435\u0432\u044C\u044E, \u043A\u043E\u0433\u0434\u0430 \u0432\u0441\u0435 \u0447\u0435\u043A\u0438 \u0437\u0430\u0432\u0435\u0440\u0448\u0430\u0442\u0441\u044F (\u044D\u0442\u043E \u0448\u0442\u0430\u0442\u043D\u044B\u0439 \u043F\u0443\u0442\u044C, \u043E\u043F\u0435\u0440\u0430\u0442\u043E\u0440\u0430 \u0437\u0432\u0430\u0442\u044C \u043D\u0435 \u043D\u0443\u0436\u043D\u043E). \u2461 \u0432\u0441\u0435 \u0447\u0435\u043A\u0438 \u0437\u0430\u0432\u0435\u0440\u0448\u0438\u043B\u0438\u0441\u044C \u0438 \u0435\u0441\u0442\u044C FAIL \u2014 REQUEST CHANGES, \u043D\u0430\u0437\u043E\u0432\u0438 \u043F\u043E\u0438\u043C\u0451\u043D\u043D\u043E, \u0447\u0442\u043E \u0443\u043F\u0430\u043B\u043E. \u2462 \u043D\u0430 \u044D\u0442\u043E\u043C \u043A\u043E\u043C\u043C\u0438\u0442\u0435 \u0447\u0435\u043A\u043E\u0432 \u043D\u0435\u0442 \u0432\u043E\u0432\u0441\u0435 \u2014 \u0442\u043E\u0436\u0435 REQUEST CHANGES: \u043F\u0440\u043E\u0432\u0435\u0440\u0438\u0442\u044C \u043D\u0435\u0447\u0435\u043C (\u0443 \u044D\u0442\u043E\u0433\u043E \u043F\u0440\u043E\u0435\u043A\u0442\u0430 verifyMode=ci, \u0442\u043E \u0435\u0441\u0442\u044C CI \u043E\u0431\u044F\u0437\u0430\u043D \u0431\u044B\u0442\u044C). ${dontTrustAuthor}`;
 }
-var REVIEW_SKILL_PATH = join36(bundledRoleDir("drone"), "skills", "taskless-review", "SKILL.md");
+var REVIEW_SKILL_PATH = join37(bundledRoleDir("drone"), "skills", "taskless-review", "SKILL.md");
 function reviewDefectClasses(skillPath = REVIEW_SKILL_PATH) {
   const text = readFileSync25(skillPath, "utf8");
   const m = /^## Классы дефектов\n([\s\S]*?)(?=^## |(?![\s\S]))/m.exec(text);
@@ -19942,7 +20199,7 @@ async function wakeRun(deps, runId, opts = {}) {
   if (run.status === "review" && run.pr_url && !needsFixIteration(run) && !stoppedForHuman) {
     return { ok: false, why: `\u043F\u0440\u043E\u0433\u043E\u043D #${runId} \u0443\u0436\u0435 \u0441\u0434\u0430\u043D \u043D\u0430 \u0440\u0435\u0432\u044C\u044E (${run.pr_url}) \u2014 \u0431\u0443\u0434\u0438\u0442\u044C \u043D\u0435\u0447\u0435\u0433\u043E; \u043F\u0440\u0430\u0432\u043A\u0438 \u043F\u043E\u0434\u043D\u0438\u043C\u0435\u0442 \u0440\u043E\u0439 \u043F\u043E \u0432\u0435\u0440\u0434\u0438\u043A\u0442\u0443` };
   }
-  const worktreeExists = deps.worktreeExists ?? existsSync21;
+  const worktreeExists = deps.worktreeExists ?? existsSync22;
   const hasTranscript = deps.hasTranscript ?? executorHasSession;
   const wt = run.worktree_path;
   const canContinue = !!wt && worktreeExists(wt) && hasTranscript(run);
@@ -20067,9 +20324,9 @@ function repoHasCi(deps, run) {
 function repoHasCiWorkflows(worktreePath, repo) {
   for (const base3 of [worktreePath, repo]) {
     if (!base3) continue;
-    const dir = join36(base3, ".github", "workflows");
+    const dir = join37(base3, ".github", "workflows");
     try {
-      if (readdirSync14(dir).some((f) => f.endsWith(".yml") || f.endsWith(".yaml"))) return true;
+      if (readdirSync15(dir).some((f) => f.endsWith(".yml") || f.endsWith(".yaml"))) return true;
     } catch {
     }
   }
@@ -20268,7 +20525,7 @@ async function wakeReviewerOnCiReady(deps, run, over) {
   return true;
 }
 function worktreeAndTranscriptAlive(deps, run) {
-  const exists = deps.worktreeExists ?? existsSync21;
+  const exists = deps.worktreeExists ?? existsSync22;
   const transcript = deps.hasTranscript ?? executorHasSession;
   const wt = run.worktree_path;
   return !!wt && exists(wt) && transcript(run);
@@ -20368,7 +20625,7 @@ async function wakeAuthorOnChanges(deps, snapshot, now, droneCap) {
   }
   const wt = run.worktree_path;
   const wtPath = wt || (deps.worktreesDir ? droneWorktreePath(deps.worktreesDir, normalizeRepo(run.repo || deps.repoFallback || ""), run.task_slug) : null);
-  const worktreeReady = !!wtPath && (deps.worktreeExists ?? existsSync21)(wtPath);
+  const worktreeReady = !!wtPath && (deps.worktreeExists ?? existsSync22)(wtPath);
   if (!worktreeReady && !await freshChangesWakeAllowed(deps, run, prUrl, now)) return false;
   try {
     await deps.respawn(run, "fix");
@@ -20451,7 +20708,7 @@ async function zoneConflictFor(db, models, activeFiles, run, repo, repoFallback)
   activeFiles.prune(holders.map((r) => r.id));
   const fileExists = (p) => {
     try {
-      return statSync13(join36(repo, p), { throwIfNoEntry: false })?.isFile() ?? false;
+      return statSync14(join37(repo, p), { throwIfNoEntry: false })?.isFile() ?? false;
     } catch {
       return false;
     }
@@ -20687,6 +20944,8 @@ async function trySpawnQueuedRun(deps, run) {
   if (!await projectQuotaGateAllows(deps, run)) return "skipped";
   const prodOverride = await prodOverrideReason(deps, run, ["queued"]);
   if (prodOverride) return deferSpawn(deps, run, prodOverride, { event: false });
+  const providerGap = deps.providerGap?.(run) ?? null;
+  if (providerGap) return deferSpawn(deps, run, providerGap);
   if (deps.db.takeRun && !await deps.db.takeRun(run.id)) {
     return deferSpawn(deps, run, "\u043D\u0435 \u0432\u0437\u044F\u043B \u043F\u0440\u043E\u0433\u043E\u043D \u043D\u0430 \u0441\u0432\u043E\u044E \u043C\u0430\u0448\u0438\u043D\u0443 \u2014 \u0441\u0435\u0440\u0432\u0435\u0440 \u043E\u0442\u0434\u0430\u043B \u0435\u0433\u043E \u0434\u0440\u0443\u0433\u043E\u043C\u0443 \u0434\u0435\u043C\u043E\u043D\u0443 (TASWM-281)");
   }
@@ -20843,7 +21102,7 @@ async function liftReturners(deps, returners, now, droneCap) {
         deps.returners?.delete(run.id);
         continue;
       }
-      lifted = await wakeAuthorOnRedCi(deps, run, now, entry.ci, deps.worktreeExists ?? existsSync21, deps.hasTranscript ?? executorHasSession, droneCap);
+      lifted = await wakeAuthorOnRedCi(deps, run, now, entry.ci, deps.worktreeExists ?? existsSync22, deps.hasTranscript ?? executorHasSession, droneCap);
     }
     if (lifted) deps.returners?.delete(run.id);
   }
@@ -20862,7 +21121,7 @@ async function resumeWatchdogParked(deps, droneCap) {
   }
   if (!candidate) return;
   if (candidate.pid != null && deps.isAlive(candidate.pid)) return;
-  const worktreeExists = deps.worktreeExists ?? existsSync21;
+  const worktreeExists = deps.worktreeExists ?? existsSync22;
   const hasTranscript = deps.hasTranscript ?? executorHasSession;
   const wt = candidate.worktree_path;
   const canContinue = !!wt && worktreeExists(wt) && hasTranscript(candidate);
@@ -21649,7 +21908,7 @@ function buildEscalationCandidates(db) {
 }
 async function tickOnce(deps) {
   const now = deps.now ? deps.now() : Date.now();
-  const worktreeExists = deps.worktreeExists ?? existsSync21;
+  const worktreeExists = deps.worktreeExists ?? existsSync22;
   const hasTranscript = deps.hasTranscript ?? executorHasSession;
   deps.sampleHost?.();
   if (deps.rehydrate) {
@@ -22550,7 +22809,7 @@ async function resolveConflict(deps, reviewRun) {
     model: reviewRun.model,
     review_model: reviewRun.review_model
   });
-  const wt = join36(deps.worktreesDir, basename6(repo), `${reviewRun.task_slug}-resolve-${resolver.id}`);
+  const wt = join37(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);
@@ -22630,7 +22889,7 @@ async function spawnReviewer(deps, reviewRun, files) {
     // (своей у ревьюера нет, TASWM-204), и коммент с вердиктом должен уехать именно туда.
     workspace_id: reviewRun.workspace_id
   });
-  const wt = join36(deps.worktreesDir, basename6(repo), `${reviewRun.task_slug}-review-${reviewer.id}`);
+  const wt = join37(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);
@@ -22711,7 +22970,7 @@ async function spawnVerifier(deps, verifiedRun, files) {
     // штамп цикла: фикс-итерацию проверяет свежий верификатор
     workspace_id: verifiedRun.workspace_id
   });
-  const wt = join36(deps.worktreesDir, basename6(repo), `${verifiedRun.task_slug}-verify-${verifier.id}`);
+  const wt = join37(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);
@@ -22759,7 +23018,7 @@ async function respawnRun(deps, run, mode, nudge) {
   ]);
   const base3 = effectiveBaseBranch(run.base_branch, projectBase);
   const runToSpawn = base3 && run.base_branch !== base3 ? deps.db.updateRun(run.id, { base_branch: base3 }) ?? run : run;
-  if (!existsSync21(wt)) {
+  if (!existsSync22(wt)) {
     const branch = runToSpawn.branch || runToSpawn.task_slug;
     const source = await addWorktree(repo, wt, branch, {
       ...base3 ? { base: await remoteBaseRef(repo, base3) } : {},
@@ -22800,7 +23059,7 @@ function worktreePathPatch(run, wt) {
   return run.worktree_path === wt ? {} : { worktree_path: wt };
 }
 async function syncCrashedOnStartup(deps) {
-  const worktreeExists = deps.worktreeExists ?? existsSync21;
+  const worktreeExists = deps.worktreeExists ?? existsSync22;
   let orphaned = 0;
   let merged = 0;
   let requeued = 0;
@@ -22954,10 +23213,10 @@ async function migrateWorktreesAtStartup() {
       legacyDir: WORKTREES_LEGACY_DIR,
       targetDir: WORKTREES_DIR,
       envOverride: process.env.SWARM_WORKTREES || "",
-      exists: (d) => existsSync21(d),
+      exists: (d) => existsSync22(d),
       isNonEmptyDir: (d) => {
         try {
-          return readdirSync14(d).length > 0;
+          return readdirSync15(d).length > 0;
         } catch {
           return false;
         }
@@ -22969,7 +23228,7 @@ async function migrateWorktreesAtStartup() {
     });
   } catch (e) {
     console.error("[migrate] \u043C\u0438\u0433\u0440\u0430\u0446\u0438\u044F worktrees \u0441\u043E\u0440\u0432\u0430\u043B\u0430\u0441\u044C \u2014 \u0444\u043E\u043B\u0431\u044D\u043A:", e);
-    return existsSync21(WORKTREES_DIR) ? WORKTREES_DIR : WORKTREES_LEGACY_DIR;
+    return existsSync22(WORKTREES_DIR) ? WORKTREES_DIR : WORKTREES_LEGACY_DIR;
   }
 }
 async function reportWorkspaceAccess(tl, db) {
@@ -23153,7 +23412,8 @@ async function runDaemon(opts) {
           // настенным временем. Не «демон запущен», а «цикл прокрутился».
           tickPulse(tickHealth, Date.now(), tickIntervalMs),
           // TASWM-592: установленные агенты машины — справочник для парка машин.
-          cachedInstalledExecutorIds()
+          cachedInstalledExecutorIds(),
+          availableProviders(cachedInstalledExecutorIds())
         );
         if (reply.maxDrones !== void 0) operatorMaxDrones = reply.maxDrones;
         if (reply.commands.length) onHostCommands(reply.commands);
@@ -23594,6 +23854,7 @@ async function runDaemon(opts) {
     // TASWM-364: swarmModels — ТОТ ЖЕ снимок, что уехал в launcher: цена токенов считается
     // по модели, на которой прогон реально работал. TASWM-592: исполнитель НЕ пинится —
     // аккаунтант сам резолвит его по прогону (итог писал харнесс ЭТОГО прогона).
+    providerGap: (run) => providerUnavailableReason(resolveRunModelRef(run, lastSwarmModels).providerId, availableProviders(cachedInstalledExecutorIds())),
     accountCost: makeCostAccountant({ runLogsDir: RUN_LOGS_DIR, db, swarmModels: () => lastSwarmModels, modelRefFor: (run) => runModelRefPin.get(run.id) ?? null }),
     // TASWM-413: тот же аккаунтант, но поводом служит завершённый ЗАПУСК, а не смерть
     // прогона в running — иначе сданный через done() прогон не получает цену никогда.
@@ -23659,7 +23920,7 @@ async function runDaemon(opts) {
           isDirty: (p) => worktreeDirty(p),
           releaseWorktree: (repo, p) => releaseWorktree(repo || opts.repo, p),
           pruneWorktrees: (repo) => pruneWorktrees(repo || opts.repo),
-          worktreeExists: existsSync21,
+          worktreeExists: existsSync22,
           liveWorktrees: () => new Set(listDroneProcesses().map((p) => p.worktree)),
           narrate: narrator.narrate
         });
@@ -23794,7 +24055,7 @@ async function runDaemon(opts) {
       mode,
       nudge
     ),
-    worktreeExists: (p) => existsSync21(p),
+    worktreeExists: (p) => existsSync22(p),
     // TASWM-514: с этого момента считаем попытки спавна — счётчик живёт ровно одну жизнь
     // процесса демона и рестарт не переживает (см. preStartAttempts).
     startedAt: Date.now(),