@taskless-app/swarm 0.6.62 → 0.6.63

package/dist/cli.js

@@ -607,10 +607,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);
@@ -650,6 +650,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;
@@ -701,6 +704,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».
@@ -1089,18 +1103,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
   };
 }
@@ -1137,6 +1151,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}`,
@@ -2109,10 +2124,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) {
@@ -2122,7 +2137,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 {
@@ -2214,9 +2229,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(usage2.input_tokens) + num(usage2.cache_creation_input_tokens) + num(usage2.cache_read_input_tokens);
-      tokensOut += num(usage2.output_tokens);
+      const num2 = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
+      tokensIn += num2(usage2.input_tokens) + num2(usage2.cache_creation_input_tokens) + num2(usage2.cache_read_input_tokens);
+      tokensOut += num2(usage2.output_tokens);
       if (firstAt === null || at < firstAt) firstAt = at;
       if (lastAt === null || at > lastAt) lastAt = at;
       replies += 1;
@@ -2444,13 +2459,15 @@ var init_swarmHome = __esm({
 });
 
 // src/executors/codex.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readdirSync as readdirSync4, statSync as statSync3, symlinkSync } from "fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync3, readdirSync as readdirSync4, statSync as statSync3, symlinkSync } from "fs";
 import { join as join5 } from "path";
 function resolveCodexBin(env = process.env) {
   return (env.SWARM_CODEX_BIN ?? "").trim() || "codex";
 }
 function codexHomePath(worktree, swarmHome = SWARM_HOME) {
-  return join5(swarmHome, "executor-state", "codex", worktree.replace(/[/.]/g, "-"));
+  const folded = worktree.replace(/[/.]/g, "-");
+  const key = /[:\\]/.test(folded) ? worktree.replace(/[^A-Za-z0-9]+/g, "-").replace(/^-|-$/g, "") || "worktree" : folded;
+  return join5(swarmHome, "executor-state", "codex", key);
 }
 function ensureCodexHome(worktree, realHome, env = process.env, swarmHome = SWARM_HOME) {
   const home = codexHomePath(worktree, swarmHome);
@@ -2463,6 +2480,10 @@ function ensureCodexHome(worktree, realHome, env = process.env, swarmHome = SWAR
     try {
       symlinkSync(target, link);
     } catch {
+      try {
+        copyFileSync2(target, link);
+      } catch {
+      }
     }
   }
   return home;
@@ -2613,6 +2634,206 @@ ${notice}` : spec.prompt;
   }
 });
 
+// src/executors/grok.ts
+import { copyFileSync as copyFileSync3, existsSync as existsSync4, mkdirSync as mkdirSync4, readdirSync as readdirSync5, statSync as statSync4, symlinkSync as symlinkSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join6 } 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 join6(swarmHome, "executor-state", "grok", key);
+}
+function grokSessionDir(worktree, swarmHome = SWARM_HOME) {
+  return join6(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() || join6(realHome, ".grok");
+  const target = join6(real, "auth.json");
+  const link = join6(home, "auth.json");
+  if (existsSync4(target) && !existsSync4(link)) {
+    try {
+      symlinkSync2(target, link);
+    } catch {
+      try {
+        copyFileSync3(target, link);
+      } 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 = join6(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 usage2 = rec.usage;
+  let tokensIn;
+  let tokensOut;
+  if (typeof usage2 === "object" && usage2 !== null) {
+    const u = usage2;
+    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);
+        writeFileSync3(join6(home, "config.toml"), grokMcpToml(spec));
+        writeFileSync3(
+          join6(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() : "";
@@ -2628,10 +2849,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) };
@@ -2678,21 +2911,24 @@ 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
     };
   }
 });
 
 // src/config.ts
-import { basename, join as join6, resolve } from "path";
-import { readFileSync as readFileSync3, realpathSync, renameSync, writeFileSync as writeFileSync3 } from "fs";
+import { basename, join as join7, resolve } from "path";
+import { readFileSync as readFileSync3, realpathSync, renameSync, writeFileSync as writeFileSync4 } from "fs";
 function normalizeRepo(repo) {
   const r = (repo ?? "").trim();
   if (!r) return "";
@@ -2706,10 +2942,10 @@ function effectiveRepoOf(repo, fallback) {
   return normalizeRepo(repo || fallback || "");
 }
 function droneWorktreePath(worktreesDir, repo, slug) {
-  return join6(droneWorktreeRoot(worktreesDir, repo), slug);
+  return join7(droneWorktreeRoot(worktreesDir, repo), slug);
 }
 function droneWorktreeRoot(worktreesDir, repo) {
-  return join6(worktreesDir, basename(normalizeRepo(repo)));
+  return join7(worktreesDir, basename(normalizeRepo(repo)));
 }
 function resolveEffectiveWorktreesDir(deps) {
   if (deps.envOverride) return deps.envOverride;
@@ -2736,7 +2972,7 @@ function mcpEndpoint(api, path = TASKLESS_MCP_PATH) {
 }
 function tokenFromFile() {
   try {
-    return readFileSync3(join6(SWARM_HOME, "token"), "utf8").trim();
+    return readFileSync3(join7(SWARM_HOME, "token"), "utf8").trim();
   } catch {
     return "";
   }
@@ -2749,25 +2985,25 @@ var init_config = __esm({
     init_executors();
     init_swarmHome();
     init_swarmHome();
-    DB_PATH = process.env.SWARM_DB || join6(SWARM_HOME, "swarm.db");
+    DB_PATH = process.env.SWARM_DB || join7(SWARM_HOME, "swarm.db");
     EXECUTOR = resolveExecutor(process.env.SWARM_EXECUTOR);
-    DRONE_HOME = process.env.SWARM_DRONE_HOME || join6(SWARM_HOME, "drone-home");
+    DRONE_HOME = process.env.SWARM_DRONE_HOME || join7(SWARM_HOME, "drone-home");
     DRONE_HOME_ISOLATION = process.env.SWARM_DRONE_ISOLATE_HOME !== "0" && process.platform !== "win32";
     DRONE_ISOLATION = DRONE_HOME_ISOLATION ? { home: DRONE_HOME, swarmHome: SWARM_HOME } : void 0;
-    WORKTREES_NOINDEX_DIR = join6(SWARM_HOME, "worktrees.noindex");
-    WORKTREES_LEGACY_DIR = join6(SWARM_HOME, "worktrees");
+    WORKTREES_NOINDEX_DIR = join7(SWARM_HOME, "worktrees.noindex");
+    WORKTREES_LEGACY_DIR = join7(SWARM_HOME, "worktrees");
     WORKTREES_DIR = process.env.SWARM_WORKTREES || WORKTREES_NOINDEX_DIR;
-    RUN_LOGS_DIR = process.env.SWARM_RUN_LOGS || join6(SWARM_HOME, "run-logs");
-    DAEMON_LOG_PATH = process.env.SWARM_DAEMON_LOG || join6(SWARM_HOME, "overmind.log");
+    RUN_LOGS_DIR = process.env.SWARM_RUN_LOGS || join7(SWARM_HOME, "run-logs");
+    DAEMON_LOG_PATH = process.env.SWARM_DAEMON_LOG || join7(SWARM_HOME, "overmind.log");
     DAEMON_LOG_MAX_BYTES = envNum("SWARM_DAEMON_LOG_MAX_BYTES", 16 * 1024 * 1024);
     DAEMON_LOG_KEEP = envNum("SWARM_DAEMON_LOG_KEEP", 2);
     DAEMON_LOG_CHECK_MS = envNum("SWARM_DAEMON_LOG_CHECK_MS", 6e4);
     DIST_BUILD = true;
     SWARM_BACKEND = process.env.SWARM_BACKEND === "client" ? "client" : process.env.SWARM_BACKEND === "sqlite" ? "sqlite" : DIST_BUILD ? "client" : "sqlite";
-    SWARM_OUTBOX = process.env.SWARM_OUTBOX || join6(SWARM_HOME, "outbox.jsonl");
+    SWARM_OUTBOX = process.env.SWARM_OUTBOX || join7(SWARM_HOME, "outbox.jsonl");
     SWARM_MAX_IN_FLIGHT = Math.trunc(envNum("SWARM_MAX_IN_FLIGHT", 3));
     SWARM_CLAIM_INTERVAL_MS = envNum("SWARM_CLAIM_INTERVAL_MS", 6e4);
-    ENV_CACHE_DIR = process.env.SWARM_ENV_CACHE_DIR || join6(SWARM_HOME, "env-cache");
+    ENV_CACHE_DIR = process.env.SWARM_ENV_CACHE_DIR || join7(SWARM_HOME, "env-cache");
     ENV_CACHE_ENABLED = process.env.SWARM_ENV_CACHE !== "0";
     ENV_CACHE_KEEP = Math.trunc(envNum("SWARM_ENV_CACHE_KEEP", 4));
     SWARM_MAX_LOAD_FACTOR = envNum("SWARM_MAX_LOAD_FACTOR", 0.9);
@@ -2797,15 +3033,15 @@ var init_config = __esm({
     DRONE_CHANNEL_ENABLED = process.env.SWARM_DRONE_CHANNEL !== "0";
     DRONE_CHANNEL_PORT = Number(process.env.SWARM_DRONE_CHANNEL_PORT) || 7421;
     DRONE_CHANNEL_URL = process.env.SWARM_DRONE_CHANNEL_URL || `http://127.0.0.1:${DRONE_CHANNEL_PORT}`;
-    DRONE_CHANNEL_SECRET_PATH = process.env.SWARM_DRONE_CHANNEL_SECRET || join6(SWARM_HOME, "drone-channel.key");
+    DRONE_CHANNEL_SECRET_PATH = process.env.SWARM_DRONE_CHANNEL_SECRET || join7(SWARM_HOME, "drone-channel.key");
     DRONE_CHANNEL_GRACE_MS = envNum("SWARM_DRONE_CHANNEL_GRACE_MS", 12e4);
-    HEARTBEAT_PATH = process.env.SWARM_HEARTBEAT || join6(SWARM_HOME, "overmind.heartbeat");
+    HEARTBEAT_PATH = process.env.SWARM_HEARTBEAT || join7(SWARM_HOME, "overmind.heartbeat");
     HEARTBEAT_STALE_MS = Number(process.env.SWARM_HEARTBEAT_STALE_MS) || 3e4;
     SWARM_REPO = process.env.SWARM_REPO || "";
     SWARM_SCAN_DEPTH = Number(process.env.SWARM_SCAN_DEPTH) || 3;
     SWARM_REPO_PATHS = (process.env.SWARM_REPOS || SWARM_REPO).split(",").map((s) => s.trim()).filter(Boolean);
     SWARM_SCAN_ROOTS_RAW = process.env.SWARM_SCAN_ROOTS || "";
-    REPO_MAP_PATH = process.env.SWARM_REPO_MAP || join6(SWARM_HOME, "repo-map.json");
+    REPO_MAP_PATH = process.env.SWARM_REPO_MAP || join7(SWARM_HOME, "repo-map.json");
     SWARM_REPO_MAP_MS = envNum("SWARM_REPO_MAP_MS", 15 * 6e4);
     SWARM_REPO_SCAN_TTL_MS = envNum("SWARM_REPO_SCAN_TTL_MS", 24 * 60 * 6e4);
     TASKLESS_API = process.env.TASKLESS_API || "https://taskless.ru";
@@ -2820,7 +3056,7 @@ var init_config = __esm({
     SWARM_AUTO_REVIEW = process.env.SWARM_AUTO_REVIEW !== "0";
     SWARM_AUTO_VERIFY = process.env.SWARM_AUTO_VERIFY !== "0";
     SWARM_MERGE_QUEUE = process.env.SWARM_MERGE_QUEUE !== "0";
-    REVIEW_CUTOFF_PATH = process.env.SWARM_REVIEW_CUTOFF || join6(SWARM_HOME, "review-cutoff.json");
+    REVIEW_CUTOFF_PATH = process.env.SWARM_REVIEW_CUTOFF || join7(SWARM_HOME, "review-cutoff.json");
     SWARM_REVIEW_CAP = Math.trunc(envNum("SWARM_REVIEW_CAP", 1));
     SWARM_STORM_URL = process.env.SWARM_STORM_URL || "";
     WEB_PORT = Number(process.env.SWARM_WEB_PORT) || 7420;
@@ -3148,8 +3384,8 @@ var init_store = __esm({
 });
 
 // src/agentToken.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, unlinkSync } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, unlinkSync } from "fs";
+import { join as join8 } from "path";
 function loadAgentToken() {
   try {
     const s = JSON.parse(readFileSync5(STORE_PATH, "utf8"));
@@ -3159,7 +3395,7 @@ function loadAgentToken() {
   }
 }
 function saveAgentToken(s) {
-  writeFileSync4(STORE_PATH, JSON.stringify(s, null, 2), { mode: 384 });
+  writeFileSync5(STORE_PATH, JSON.stringify(s, null, 2), { mode: 384 });
 }
 function clearAgentToken() {
   try {
@@ -3230,7 +3466,7 @@ var init_agentToken = __esm({
   "src/agentToken.ts"() {
     "use strict";
     init_config();
-    STORE_PATH = join7(SWARM_HOME, "agent.json");
+    STORE_PATH = join8(SWARM_HOME, "agent.json");
     base = (api) => api.replace(/\/$/, "");
     TOKEN_PROBE_TIMEOUT_MS = 8e3;
   }
@@ -3616,7 +3852,7 @@ var init_package = __esm({
   "package.json"() {
     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: [
@@ -3667,7 +3903,7 @@ var init_package = __esm({
         execa: "^10.0.0",
         zod: "3.25.76"
       },
-      gitHead: "e999630218010a25c03a6024e1b71ef34b2359ec"
+      gitHead: "8d438b6288da036308528cff1160a157b4b64abd"
     };
   }
 });
@@ -3833,7 +4069,7 @@ var init_netTimeout = __esm({
 
 // src/droneChannel.ts
 import { createHmac, randomBytes, timingSafeEqual } from "crypto";
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync7, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync8, readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "fs";
 import { dirname as dirname3 } from "path";
 import { serve } from "@hono/node-server";
 function loadChannelSecret(path) {
@@ -3843,8 +4079,8 @@ function loadChannelSecret(path) {
   } catch {
   }
   const secret = randomBytes(32).toString("hex");
-  mkdirSync7(dirname3(path), { recursive: true });
-  writeFileSync7(path, secret, { mode: 384 });
+  mkdirSync8(dirname3(path), { recursive: true });
+  writeFileSync8(path, secret, { mode: 384 });
   try {
     chmodSync2(path, 384);
   } catch {
@@ -3921,8 +4157,8 @@ var init_authState = __esm({
 
 // src/oauth.ts
 import { createHash, randomBytes as randomBytes2 } from "crypto";
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync8, unlinkSync as unlinkSync3 } from "fs";
-import { join as join12 } from "path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync9, unlinkSync as unlinkSync3 } from "fs";
+import { join as join13 } from "path";
 function makePkce() {
   const verifier = randomBytes2(48).toString("base64url");
   const challenge = createHash("sha256").update(verifier).digest("base64url");
@@ -4012,7 +4248,7 @@ function loadStore() {
   }
 }
 function saveStore(s) {
-  writeFileSync8(STORE_PATH2, JSON.stringify(s, null, 2), { mode: 384 });
+  writeFileSync9(STORE_PATH2, JSON.stringify(s, null, 2), { mode: 384 });
 }
 function clearStore() {
   try {
@@ -4031,7 +4267,7 @@ async function ensureClientId(api, redirectUri, fetchFn = fetch) {
   const existing = loadClientId();
   if (existing) return existing;
   const clientId = await registerClient({ api, redirectUri }, fetchFn);
-  writeFileSync8(CLIENT_PATH, JSON.stringify({ clientId }, null, 2), { mode: 384 });
+  writeFileSync9(CLIENT_PATH, JSON.stringify({ clientId }, null, 2), { mode: 384 });
   return clientId;
 }
 async function ensureAccess(store, opts = {}) {
@@ -4057,16 +4293,16 @@ var init_oauth = __esm({
     AUTHORIZE = "/api/oauth/authorize";
     TOKEN = "/api/oauth/token";
     SCOPE = "openid profile email taskless:full";
-    STORE_PATH2 = join12(SWARM_HOME, "oauth.json");
-    CLIENT_PATH = join12(SWARM_HOME, "oauth-client.json");
+    STORE_PATH2 = join13(SWARM_HOME, "oauth.json");
+    CLIENT_PATH = join13(SWARM_HOME, "oauth-client.json");
     base2 = (api) => api.replace(/\/$/, "");
   }
 });
 
 // src/git.ts
-import { existsSync as existsSync10, readdirSync as readdirSync9, realpathSync as realpathSync2, statSync as statSync9 } from "fs";
+import { existsSync as existsSync11, readdirSync as readdirSync10, realpathSync as realpathSync2, statSync as statSync10 } from "fs";
 import { appendFile, chmod, mkdir, readFile, rename, rm, writeFile } from "fs/promises";
-import { isAbsolute, join as join15, resolve as resolve2, sep as sep2 } from "path";
+import { isAbsolute, join as join16, resolve as resolve2, sep as sep2 } from "path";
 import { $ as $5 } from "execa";
 function gitNet(repo, args, timeoutMs) {
   return withHardTimeout(
@@ -4080,14 +4316,14 @@ async function reclaimStaleWorktree(repo, worktree) {
   await detachWorktree(repo, worktree);
 }
 async function inspectWorktreePath(path) {
-  if (!existsSync10(path)) return "free";
+  if (!existsSync11(path)) return "free";
   try {
-    if (readdirSync9(path).length === 0) return "free";
+    if (readdirSync10(path).length === 0) return "free";
   } catch {
     return "orphan";
   }
   try {
-    if (statSync9(join15(path, ".git")).isDirectory()) return "main-checkout";
+    if (statSync10(join16(path, ".git")).isDirectory()) return "main-checkout";
   } catch {
   }
   const top = await $5({ reject: false })`git -C ${path} rev-parse --show-toplevel`;
@@ -4126,7 +4362,7 @@ async function clearWorktreePath(repo, path, branch, opts = {}) {
     await detachWorktree(repo, path);
     opts.onStaleReclaim?.(path);
   }
-  if (!existsSync10(path)) return;
+  if (!existsSync11(path)) return;
   await parkOrphanDir(repo, path, branch);
 }
 async function parkOrphanDir(repo, path, branch) {
@@ -4147,7 +4383,7 @@ async function parkOrphanDir(repo, path, branch) {
 }
 function isLinkedWorktree(dir) {
   try {
-    return statSync9(join15(dir, ".git")).isFile();
+    return statSync10(join16(dir, ".git")).isFile();
   } catch {
     return false;
   }
@@ -4159,7 +4395,7 @@ async function detachWorktree(repo, worktree) {
   }
 }
 async function ensureWorktreeDirGone(worktree) {
-  if (!existsSync10(worktree)) return false;
+  if (!existsSync11(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.`
@@ -4174,7 +4410,7 @@ async function ensureWorktreeDirGone(worktree) {
     );
     return true;
   }
-  if (existsSync10(worktree)) {
+  if (existsSync11(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;
@@ -4223,7 +4459,7 @@ async function checkoutWorktree(repo, path, branch, opts) {
   }
   const busyAt = await worktreeForBranch(repo, branch);
   if (busyAt) {
-    const exists = existsSync10(busyAt);
+    const exists = existsSync11(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);
@@ -4254,8 +4490,8 @@ async function ensureGitExcluded(worktree, pattern) {
   try {
     const commonDir = await gitPath(worktree, "--git-common-dir");
     if (!commonDir) return false;
-    const infoDir = join15(commonDir, "info");
-    const excludeFile = join15(infoDir, "exclude");
+    const infoDir = join16(commonDir, "info");
+    const excludeFile = join16(infoDir, "exclude");
     let current = "";
     try {
       current = await readFile(excludeFile, "utf8");
@@ -4275,7 +4511,7 @@ async function gitPath(worktree, flag) {
   const out = await $5({ reject: false })`git -C ${worktree} rev-parse ${flag}`;
   const raw = out.stdout.trim();
   if (out.exitCode !== 0 || !raw) return null;
-  return isAbsolute(raw) ? raw : join15(worktree, raw);
+  return isAbsolute(raw) ? raw : join16(worktree, raw);
 }
 async function ensureWorktreeHygiene(worktree) {
   for (const pattern of SWARM_EXCLUDE_PATTERNS) await ensureGitExcluded(worktree, pattern);
@@ -4285,12 +4521,12 @@ async function installGuardHooks(worktree) {
   try {
     const gitDir = await gitPath(worktree, "--git-dir");
     if (!gitDir) return false;
-    const hooksDir = join15(gitDir, "swarm-hooks");
+    const hooksDir = join16(gitDir, "swarm-hooks");
     const prev = await previousHooksPath(worktree);
     await mkdir(hooksDir, { recursive: true });
     for (const hook of GUARD_HOOKS) {
-      await writeFile(join15(hooksDir, hook), guardHookScript(hook, prev ? `${posix(prev)}/${hook}` : null));
-      await chmod(join15(hooksDir, hook), 493);
+      await writeFile(join16(hooksDir, hook), guardHookScript(hook, prev ? `${posix(prev)}/${hook}` : null));
+      await chmod(join16(hooksDir, hook), 493);
     }
     await $5`git -C ${worktree} config extensions.worktreeConfig true`;
     await $5`git -C ${worktree} config --worktree core.hooksPath ${posix(hooksDir)}`;
@@ -4309,7 +4545,7 @@ async function previousHooksPath(worktree) {
     if (out.exitCode === 0 && value) return value;
   }
   const commonDir = await gitPath(worktree, "--git-common-dir");
-  return commonDir ? join15(commonDir, "hooks") : null;
+  return commonDir ? join16(commonDir, "hooks") : null;
 }
 async function removeWorktree(repo, path) {
   const branch = (await $5({ reject: false })`git -C ${path} symbolic-ref --quiet --short HEAD`).stdout.trim();
@@ -4372,7 +4608,7 @@ var init_git = __esm({
 
 // src/attachments.ts
 import { mkdir as mkdir2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 var ATTACHMENTS_DIR, ATTACH_MAX_TOTAL_BYTES, ATTACH_MAX_FILE_BYTES, IMAGE_EXT, DOC_EXT, TEXT_EXT, KNOWN_EXT;
 var init_attachments = __esm({
   "src/attachments.ts"() {
@@ -4391,7 +4627,7 @@ var init_attachments = __esm({
 
 // src/shotUpload.ts
 import { readFile as fsReadFile } from "fs/promises";
-import { basename as basename5, isAbsolute as isAbsolute2, join as join17 } from "path";
+import { basename as basename5, isAbsolute as isAbsolute2, join as join18 } from "path";
 var SHOT_MAX_FILE_BYTES;
 var init_shotUpload = __esm({
   "src/shotUpload.ts"() {
@@ -4401,8 +4637,8 @@ var init_shotUpload = __esm({
 });
 
 // src/workspace.ts
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync9, unlinkSync as unlinkSync4 } from "fs";
-import { join as join18 } from "path";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync10, unlinkSync as unlinkSync4 } from "fs";
+import { join as join19 } from "path";
 function loadWorkspace() {
   try {
     const w = JSON.parse(readFileSync11(WORKSPACE_PATH, "utf8"));
@@ -4412,7 +4648,7 @@ function loadWorkspace() {
   }
 }
 function saveWorkspace(w) {
-  writeFileSync9(WORKSPACE_PATH, JSON.stringify(w, null, 2), { mode: 384 });
+  writeFileSync10(WORKSPACE_PATH, JSON.stringify(w, null, 2), { mode: 384 });
 }
 function clearWorkspace() {
   try {
@@ -4428,7 +4664,7 @@ var init_workspace = __esm({
   "src/workspace.ts"() {
     "use strict";
     init_config();
-    WORKSPACE_PATH = join18(SWARM_HOME, "workspace.json");
+    WORKSPACE_PATH = join19(SWARM_HOME, "workspace.json");
   }
 });
 
@@ -4846,13 +5082,13 @@ var init_daemonLink = __esm({
 });
 
 // src/pauseState.ts
-import { existsSync as existsSync11, readFileSync as readFileSync12, renameSync as renameSync5, unlinkSync as unlinkSync5, writeFileSync as writeFileSync10 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync12, renameSync as renameSync5, unlinkSync as unlinkSync5, writeFileSync as writeFileSync11 } from "fs";
+import { join as join20 } from "path";
 function pauseStatePath(home) {
-  return join19(home, "pause.json");
+  return join20(home, "pause.json");
 }
 function loadPauseState(home, io = {}) {
-  const exists = io.exists ?? existsSync11;
+  const exists = io.exists ?? existsSync12;
   const readFile2 = io.readFile ?? ((p) => readFileSync12(p, "utf8"));
   const path = pauseStatePath(home);
   if (!exists(path)) return ACTIVE;
@@ -4872,12 +5108,12 @@ function loadPauseState(home, io = {}) {
 function savePauseState(home, state, io = {}) {
   const path = pauseStatePath(home);
   if (!state.paused) {
-    const remove = io.remove ?? ((p) => existsSync11(p) && unlinkSync5(p));
+    const remove = io.remove ?? ((p) => existsSync12(p) && unlinkSync5(p));
     remove(path);
     return;
   }
   const writeFile3 = io.writeFile ?? ((p, data) => {
-    writeFileSync10(`${p}.tmp`, data);
+    writeFileSync11(`${p}.tmp`, data);
     renameSync5(`${p}.tmp`, p);
   });
   writeFile3(path, JSON.stringify(state, null, 2));
@@ -4914,7 +5150,7 @@ var init_pauseState = __esm({
 });
 
 // src/heartbeat.ts
-import { readFileSync as readFileSync13, renameSync as renameSync6, writeFileSync as writeFileSync11 } from "fs";
+import { readFileSync as readFileSync13, renameSync as renameSync6, writeFileSync as writeFileSync12 } from "fs";
 function readHeartbeat(path) {
   try {
     const ms = Number(readFileSync13(path, "utf8").trim());
@@ -4936,7 +5172,7 @@ __export(db_exports, {
 });
 import { createRequire as createRequire2 } from "module";
 import { randomUUID as randomUUID3 } from "crypto";
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { resolve as resolve3 } from "path";
 function rowToQuestion(row) {
   return {
@@ -5600,7 +5836,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 (!existsSync12(abs)) throw new Error(`import-db: \u0444\u0430\u0439\u043B\u0430 \u043D\u0435\u0442: ${abs}`);
+        if (!existsSync13(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();
@@ -5928,8 +6164,8 @@ CREATE TABLE IF NOT EXISTS imports (
 });
 
 // src/repoScan.ts
-import { readdirSync as readdirSync10, readFileSync as readFileSync14, statSync as statSync10 } from "fs";
-import { join as join20 } from "path";
+import { readdirSync as readdirSync11, readFileSync as readFileSync14, statSync as statSync11 } from "fs";
+import { join as join21 } from "path";
 var init_repoScan = __esm({
   "src/repoScan.ts"() {
     "use strict";
@@ -5939,8 +6175,8 @@ var init_repoScan = __esm({
 
 // src/repoDiscovery.ts
 import { homedir as homedir6 } from "os";
-import { readFileSync as readFileSync15, renameSync as renameSync7, writeFileSync as writeFileSync12 } from "fs";
-import { isAbsolute as isAbsolute3, join as join21, resolve as resolve4 } from "path";
+import { readFileSync as readFileSync15, renameSync as renameSync7, writeFileSync as writeFileSync13 } from "fs";
+import { isAbsolute as isAbsolute3, join as join22, resolve as resolve4 } from "path";
 function repoMapLines(rows) {
   if (!rows?.length) return [];
   const missing = rows.filter((r) => !r.path).length;
@@ -6331,10 +6567,10 @@ __export(statusCli_exports, {
   probeLink: () => probeLink,
   runStatusCli: () => runStatusCli
 });
-import { existsSync as existsSync13, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync16 } from "fs";
 function outboxPending(path) {
   try {
-    if (!existsSync13(path)) return 0;
+    if (!existsSync14(path)) return 0;
     return readFileSync16(path, "utf8").split("\n").filter((l) => l.trim()).length;
   } catch {
     return null;
@@ -6542,8 +6778,8 @@ var init_prodMergeGate = __esm({
 });
 
 // src/platform.ts
-import { existsSync as existsSync14, readFileSync as readFileSync17 } from "fs";
-import { delimiter, join as join22 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync17 } from "fs";
+import { delimiter, join as join23 } from "path";
 function safeReadText(path) {
   try {
     return readFileSync17(path, "utf8");
@@ -6552,13 +6788,13 @@ function safeReadText(path) {
   }
 }
 function resolveCommandPath(name, env = process.env, platform = process.platform) {
-  if (name.includes("/") || name.includes("\\")) return existsSync14(name) ? name : null;
+  if (name.includes("/") || name.includes("\\")) return existsSync15(name) ? name : null;
   const dirs = (env.PATH ?? env.Path ?? "").split(delimiter).filter(Boolean);
   const exts = platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").filter(Boolean) : [""];
   for (const dir of dirs) {
     for (const ext of exts) {
-      const candidate = join22(dir, name + ext);
-      if (existsSync14(candidate)) return candidate;
+      const candidate = join23(dir, name + ext);
+      if (existsSync15(candidate)) return candidate;
     }
   }
   return null;
@@ -6661,13 +6897,13 @@ var init_platform = __esm({
 });
 
 // src/envGate.ts
-import { existsSync as existsSync15 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync16 } from "fs";
+import { join as join24 } from "path";
 import { createConnection } from "net";
 import { execa as execa3 } from "execa";
 function detectRequirements(repo, io = {}) {
-  const exists = io.exists ?? existsSync15;
-  const marker = COMPOSE_MARKERS.find((f) => exists(join23(repo, f)));
+  const exists = io.exists ?? existsSync16;
+  const marker = COMPOSE_MARKERS.find((f) => exists(join24(repo, f)));
   return marker ? [{ kind: "docker", raw: `docker (\u0434\u0435\u0442\u0435\u043A\u0442: ${marker})` }] : [];
 }
 async function dockerAlive() {
@@ -6699,7 +6935,7 @@ var init_envGate = __esm({
 });
 
 // src/doctor.ts
-import { isAbsolute as isAbsolute4, join as join24 } from "path";
+import { isAbsolute as isAbsolute4, join as join25 } from "path";
 function ok(id, title, detail) {
   return { id, title, status: "ok", detail, remedies: [], critical: false };
 }
@@ -6724,12 +6960,14 @@ function checkExecutor(io, executor = resolveExecutor()) {
   const bin = executor.resolveBin();
   const where = /[/\\]/.test(bin) ? `\u043D\u0430\u0439\u0434\u0435\u043D: ${bin}` : "\u043D\u0430\u0439\u0434\u0435\u043D \u0432 PATH";
   if (io.hasCommand(bin)) return ok("claude", executor.title, where);
+  const custom = executor.install.command == null ? null : io.platform.kind === "windows" && executor.install.windowsCommand ? executor.install.windowsCommand : executor.install.command;
   const remedies = [
     {
       what: executor.install.what,
-      command: globalInstallCommand(io.globalPm === "sources" ? "npm" : io.globalPm, executor.install.pkg),
+      command: custom ?? globalInstallCommand(io.globalPm === "sources" ? "npm" : io.globalPm, executor.install.pkg),
       sudo: false,
-      auto: true
+      // Свой инсталлер (не npm-пакет) человек ставит сам: автозапуск скрипта с сайта — нет.
+      auto: custom == null
     }
   ];
   const detail = io.platform.kind === "windows" ? `\u0432 PATH \u043D\u0435\u0442 \`${bin}\`. \u041D\u0430 Windows spawn \u0438\u0449\u0435\u0442 \u0444\u0430\u0439\u043B \u043F\u043E PATHEXT \u2014 bash-\u043E\u0431\u0451\u0440\u0442\u043A\u0430 \u0431\u0435\u0437 \u0440\u0430\u0441\u0448\u0438\u0440\u0435\u043D\u0438\u044F \u0435\u043C\u0443 \u043D\u0435 \u0432\u0438\u0434\u043D\u0430; \u043D\u0435\u0441\u0442\u0430\u043D\u0434\u0430\u0440\u0442\u043D\u0430\u044F \u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043A\u0430 \u0437\u0430\u0434\u0430\u0451\u0442\u0441\u044F ${executor.binEnv}` : `\u0432 PATH \u043D\u0435\u0442 \`${bin}\` \u2014 \u0434\u0440\u043E\u043D\u0443 \u043D\u0435\u0447\u0435\u043C \u043F\u0438\u0441\u0430\u0442\u044C \u043A\u043E\u0434`;
@@ -6906,7 +7144,7 @@ function checkRepos(io, snap) {
       critical: true
     };
   }
-  if (env && !io.exists(join24(env, ".git"))) {
+  if (env && !io.exists(join25(env, ".git"))) {
     return {
       id: "repos",
       title,
@@ -6916,7 +7154,7 @@ function checkRepos(io, snap) {
       critical: true
     };
   }
-  const broken = snap.paths.filter((p) => !io.exists(join24(p, ".git")));
+  const broken = snap.paths.filter((p) => !io.exists(join25(p, ".git")));
   if (broken.length) {
     return {
       id: "repos",
@@ -7106,12 +7344,12 @@ var init_doctor = __esm({
 });
 
 // src/repoMemory.ts
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync13 } from "fs";
-import { join as join25 } from "path";
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync14 } from "fs";
+import { join as join26 } from "path";
 function loadRememberedRepos(home) {
   let raw;
   try {
-    raw = readFileSync18(join25(home, FILE), "utf8");
+    raw = readFileSync18(join26(home, FILE), "utf8");
   } catch {
     return [];
   }
@@ -7147,7 +7385,7 @@ __export(installCli_exports, {
   runInstallHookCli: () => runInstallHookCli,
   shortenError: () => shortenError
 });
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 function classifyChromiumError(message) {
   if (/playwright-core не установлен|Cannot find (module|package)/i.test(message)) return "no-module";
   if (/error while loading shared libraries|cannot open shared object file|missing dependencies|\blib[\w.+-]*\.so[.\d]*\b/i.test(message)) return "no-libs";
@@ -7202,7 +7440,7 @@ function defaultDoctorIO(packageVersion) {
     packageVersion,
     entry,
     hasCommand: (name) => hasCommandInPath(name),
-    exists: existsSync16,
+    exists: existsSync17,
     run: (command) => runQuiet(command),
     latestVersion: () => latestMemo ??= fetchLatestVersion(),
     probeChromium: () => probeChromium(),
@@ -7430,8 +7668,8 @@ var init_updateCli = __esm({
 
 // src/cli.ts
 init_cliIo();
-import { basename as basename6, dirname as dirname5, join as join26 } from "path";
-import { existsSync as existsSync17, readFileSync as readFileSync19, writeFileSync as writeFileSync14, mkdirSync as mkdirSync10, readdirSync as readdirSync11, statSync as statSync11, openSync as openSync4, readSync as readSync2, closeSync as closeSync4 } from "fs";
+import { basename as basename6, dirname as dirname5, join as join27 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync19, writeFileSync as writeFileSync15, mkdirSync as mkdirSync11, readdirSync as readdirSync12, statSync as statSync12, openSync as openSync4, readSync as readSync2, closeSync as closeSync4 } from "fs";
 import { setTimeout as sleep2 } from "timers/promises";
 
 // src/swarmClient.ts
@@ -7439,7 +7677,7 @@ init_config();
 init_resources();
 init_names2();
 init_storm();
-import { appendFileSync, existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { appendFileSync, existsSync as existsSync7, mkdirSync as mkdirSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "fs";
 import { dirname as dirname2 } from "path";
 import { randomUUID } from "crypto";
 
@@ -7472,24 +7710,24 @@ init_store();
 init_toolFailure();
 
 // src/logTail.ts
-import { closeSync, existsSync as existsSync5, openSync, readSync, readdirSync as readdirSync6, statSync as statSync5 } from "fs";
-import { join as join9 } from "path";
+import { closeSync, existsSync as existsSync6, openSync, readSync, readdirSync as readdirSync7, statSync as statSync6 } from "fs";
+import { join as join10 } from "path";
 
 // src/runLogDir.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync5, readdirSync as readdirSync5, renameSync as renameSync2, statSync as statSync4 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync6, readdirSync as readdirSync6, renameSync as renameSync2, statSync as statSync5 } from "fs";
+import { join as join9 } from "path";
 function runLogDirName(runLogKey) {
   const safe = runLogKey.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^[-_]+|[-_]+$/g, "");
   if (!safe) throw new Error(`\u043A\u043B\u044E\u0447 \u043F\u0440\u043E\u0433\u043E\u043D\u0430 \u043D\u0435 \u0433\u043E\u0434\u0438\u0442\u0441\u044F \u0432 \u0438\u043C\u044F \u043A\u0430\u0442\u0430\u043B\u043E\u0433\u0430 run-log'\u043E\u0432: ${JSON.stringify(runLogKey)}`);
   return /^\d+$/.test(safe) ? `k-${safe}` : safe;
 }
 function runLogDirPath(runLogsDir, runLogKey) {
-  return join8(runLogsDir, runLogDirName(runLogKey));
+  return join9(runLogsDir, runLogDirName(runLogKey));
 }
 function findRunLogDir(runLogsDir, keys) {
   for (const key of keys) {
     const dir = runLogDirPath(runLogsDir, key);
-    if (existsSync4(dir)) return dir;
+    if (existsSync5(dir)) return dir;
   }
   return null;
 }
@@ -7695,25 +7933,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 ?? existsSync6;
+    this.repoExists = opts.repoExists ?? existsSync7;
     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 (existsSync6(this.mapPath)) {
+    if (existsSync7(this.mapPath)) {
       try {
         const obj = JSON.parse(readFileSync6(this.mapPath, "utf8"));
         for (const [k, v] of Object.entries(obj)) this.prodIdByKey.set(k, v);
       } catch {
       }
     }
-    if (existsSync6(this.outboxPath)) {
+    if (existsSync7(this.outboxPath)) {
       const txt = readFileSync6(this.outboxPath, "utf8");
       for (const line of txt.split("\n")) {
         const s = line.trim();
@@ -7734,7 +7972,7 @@ var SwarmClient = class _SwarmClient {
   // eventsLog ПЕРВЫМИ (до hydrate), в порядке файла (= хронологический); id
   // переприсваиваем локально (id событий — только порядок, не корреляция с продом).
   replayGlobalEvents() {
-    if (!existsSync6(this.stormPath)) return;
+    if (!existsSync7(this.stormPath)) return;
     let txt;
     try {
       txt = readFileSync6(this.stormPath, "utf8");
@@ -8734,7 +8972,7 @@ var SwarmClient = class _SwarmClient {
    * транзиентным сбоем ОС, который этот PR должен переживать, а не превращать в мор.
    */
   reconcileRuntime(opts) {
-    const wtExists = opts.worktreeExists ?? existsSync6;
+    const wtExists = opts.worktreeExists ?? existsSync7;
     const pidByWorktree = /* @__PURE__ */ new Map();
     try {
       for (const p of opts.listProcesses()) if (p.worktree) pidByWorktree.set(p.worktree, p.pid);
@@ -9354,7 +9592,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;
@@ -9385,6 +9623,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();
@@ -9972,13 +10211,13 @@ var SwarmClient = class _SwarmClient {
   }
   persistPending() {
     try {
-      writeFileSync5(this.outboxPath, this.pending.map((e) => JSON.stringify(e)).join("\n") + (this.pending.length ? "\n" : ""));
+      writeFileSync6(this.outboxPath, this.pending.map((e) => JSON.stringify(e)).join("\n") + (this.pending.length ? "\n" : ""));
     } catch {
     }
   }
   persistMap() {
     try {
-      writeFileSync5(this.mapPath, JSON.stringify(Object.fromEntries(this.prodIdByKey)));
+      writeFileSync6(this.mapPath, JSON.stringify(Object.fromEntries(this.prodIdByKey)));
     } catch {
     }
   }
@@ -10178,20 +10417,20 @@ function tailFile(path, lines) {
 }
 
 // src/logRotate.ts
-import { copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync6, fstatSync, truncateSync, unlinkSync as unlinkSync2, existsSync as existsSync7 } from "fs";
+import { copyFileSync as copyFileSync4, renameSync as renameSync3, statSync as statSync7, fstatSync, truncateSync, unlinkSync as unlinkSync2, existsSync as existsSync8 } from "fs";
 var realIo = {
   size: (path) => {
     try {
-      return statSync6(path).size;
+      return statSync7(path).size;
     } catch {
       return null;
     }
   },
-  copy: copyFileSync2,
+  copy: copyFileSync4,
   rename: renameSync3,
   truncate: (path) => truncateSync(path, 0),
   unlink: unlinkSync2,
-  exists: existsSync7
+  exists: existsSync8
 };
 var STRAY_GENERATIONS = 8;
 function rotateDaemonLog(path, opts, io = realIo) {
@@ -10219,17 +10458,17 @@ init_repoRegistry();
 
 // src/hostIdentity.ts
 import { hostname } from "os";
-import { existsSync as existsSync8, readFileSync as readFileSync8, renameSync as renameSync4, writeFileSync as writeFileSync6 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync8, renameSync as renameSync4, writeFileSync as writeFileSync7 } from "fs";
+import { join as join11 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function hostIdentityPath(home) {
-  return join10(home, "host.json");
+  return join11(home, "host.json");
 }
 function loadHostIdentity(deps) {
-  const exists = deps.exists ?? existsSync8;
+  const exists = deps.exists ?? existsSync9;
   const readFile2 = deps.readFile ?? ((p) => readFileSync8(p, "utf8"));
   const writeFile3 = deps.writeFile ?? ((p, data) => {
-    writeFileSync6(`${p}.tmp`, data);
+    writeFileSync7(`${p}.tmp`, data);
     renameSync4(`${p}.tmp`, p);
   });
   const host = deps.hostname ?? hostname;
@@ -10344,8 +10583,8 @@ import { basename as basename4 } from "path";
 import { serve as serve2 } from "@hono/node-server";
 
 // src/diff.ts
-import { statSync as statSync7 } from "fs";
-import { join as join11 } from "path";
+import { statSync as statSync8 } from "fs";
+import { join as join12 } from "path";
 import { $ as $3 } from "execa";
 var MAX_FILES = 200;
 var MAX_LINES_PER_FILE = 1500;
@@ -10488,7 +10727,7 @@ async function resolveBase(wt, baseBranch) {
 }
 function mtime(path) {
   try {
-    return statSync7(path).mtimeMs;
+    return statSync8(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -10513,7 +10752,7 @@ async function collectRunDiff(worktree, opts = {}) {
       files.push(pf);
     }
   }
-  files.sort((a, b) => mtime(join11(worktree, b.path)) - mtime(join11(worktree, a.path)));
+  files.sort((a, b) => mtime(join12(worktree, b.path)) - mtime(join12(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);
@@ -10683,9 +10922,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()];
 }
@@ -10698,10 +10937,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();
@@ -10817,10 +11056,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);
@@ -12537,15 +12776,15 @@ import { cancelRun, respawnRun, runDaemon, wakeRun, OVERMIND_ENTRY, listDronePro
 
 // src/launcher.ts
 import { spawn as spawn2 } from "child_process";
-import { closeSync as closeSync3, existsSync as existsSync9, mkdirSync as mkdirSync9, openSync as openSync3, readdirSync as readdirSync8 } from "fs";
+import { closeSync as closeSync3, existsSync as existsSync10, mkdirSync as mkdirSync10, openSync as openSync3, readdirSync as readdirSync9 } from "fs";
 import { createRequire } from "module";
 import { homedir as homedir5 } from "os";
-import { dirname as dirname4, join as join14 } from "path";
+import { dirname as dirname4, join as join15 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/droneHome.ts
-import { lstatSync, mkdirSync as mkdirSync8, readdirSync as readdirSync7, rmSync, statSync as statSync8, symlinkSync as symlinkSync2 } from "fs";
-import { join as join13, relative, sep } from "path";
+import { lstatSync, mkdirSync as mkdirSync9, readdirSync as readdirSync8, rmSync, statSync as statSync9, symlinkSync as symlinkSync3 } from "fs";
+import { join as join14, 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);
@@ -12563,34 +12802,34 @@ function buildDroneHome(opts) {
   const { realHome, droneHome } = opts;
   const deny = opts.deny ?? droneHomeDeny();
   const platform = opts.platform ?? process.platform;
-  mkdirSync8(droneHome, { recursive: true, mode: 448 });
-  const wanted = new Set(mirroredEntries(readdirSync7(realHome), deny, platform));
+  mkdirSync9(droneHome, { recursive: true, mode: 448 });
+  const wanted = new Set(mirroredEntries(readdirSync8(realHome), deny, platform));
   const rel = relative(realHome, droneHome);
   if (rel && !rel.startsWith("..") && !rel.includes(sep)) wanted.delete(rel);
-  for (const existing of readdirSync7(droneHome)) {
+  for (const existing of readdirSync8(droneHome)) {
     if (wanted.has(existing)) continue;
-    const p = join13(droneHome, existing);
+    const p = join14(droneHome, existing);
     try {
       if (lstatSync(p).isSymbolicLink()) rmSync(p);
     } catch {
     }
   }
   for (const name of wanted) {
-    const link = join13(droneHome, name);
+    const link = join14(droneHome, name);
     try {
       lstatSync(link);
       continue;
     } catch {
     }
-    const target = join13(realHome, name);
+    const target = join14(realHome, name);
     let isDir;
     try {
-      isDir = statSync8(target).isDirectory();
+      isDir = statSync9(target).isDirectory();
     } catch {
       continue;
     }
     try {
-      symlinkSync2(target, link, isDir ? "junction" : "file");
+      symlinkSync3(target, link, isDir ? "junction" : "file");
     } catch (e) {
       if (e.code !== "EEXIST") throw e;
     }
@@ -12603,7 +12842,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, join13(realHome, ...segments)]));
+  return Object.fromEntries(REAL_PATH_ENV_PINS.map(({ env, segments }) => [env, join14(realHome, ...segments)]));
 }
 function dronePrivatePaths(realHome, swarmHome) {
   return [
@@ -12686,7 +12925,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 = join14(worktree, ".turbo", "cache");
+    env.TURBO_CACHE_DIR = join15(worktree, ".turbo", "cache");
   }
   Object.assign(env, droneTestEnv(droneCap, base3));
   for (const key of DAEMON_STATE_ENV) delete env[key];
@@ -12717,21 +12956,21 @@ var DAEMON_STATE_ENV = [
   ...PROVIDER_TOKEN_ENV
 ];
 function bundledRoleDir(kind) {
-  return join14(dirname4(fileURLToPath2(import.meta.url)), "..", "roles", kind);
+  return join15(dirname4(fileURLToPath2(import.meta.url)), "..", "roles", kind);
 }
 function roleDir(worktree, kind) {
-  return join14(worktree, ".claude", "roles", kind);
+  return join15(worktree, ".claude", "roles", kind);
 }
 function roleDirs(worktree, kind) {
-  return [bundledRoleDir(kind), roleDir(worktree, kind)].filter((dir) => existsSync9(dir));
+  return [bundledRoleDir(kind), roleDir(worktree, kind)].filter((dir) => existsSync10(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)");
-  mkdirSync9(dir, { recursive: true });
+  mkdirSync10(dir, { recursive: true });
   let files = [];
   try {
-    files = readdirSync8(dir);
+    files = readdirSync9(dir);
   } catch {
   }
   let next = 0;
@@ -12739,7 +12978,7 @@ function nextRunLogPath(runLogsDir, runLogKeys) {
     const m = /^(\d+)\.json/.exec(f);
     if (m) next = Math.max(next, Number(m[1]) + 1);
   }
-  return join14(dir, `${next}.json`);
+  return join15(dir, `${next}.json`);
 }
 function openNextRunLog(runLogsDir, runLogKeys) {
   for (let attempt = 0; attempt < 50; attempt++) {
@@ -12831,9 +13070,9 @@ function makeLauncher(cfg) {
     }
     const realHome = cfg.droneIsolation?.realHome ?? homedir5();
     const home = cfg.droneIsolation ? buildDroneHome({ realHome, droneHome: cfg.droneIsolation.home }) : void 0;
-    if (cfg.droneIsolation && process.env.TASKLESS_TOKEN && !existsSync9(join14(cfg.droneIsolation.swarmHome, "token"))) {
+    if (cfg.droneIsolation && process.env.TASKLESS_TOKEN && !existsSync10(join15(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 ${join14(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 ${join15(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);
@@ -13732,7 +13971,7 @@ async function runDaemonLogs(argv) {
     console.error(`\u043B\u043E\u0433 \u041F\u0420\u041E\u0413\u041E\u041D\u0410 \u2014 \u044D\u0442\u043E \xABswarm log ${stray}\xBB (\u0431\u0435\u0437 s). \xABswarm logs\xBB \u043F\u043E\u043A\u0430\u0437\u044B\u0432\u0430\u0435\u0442 \u043B\u043E\u0433 \u0434\u0435\u043C\u043E\u043D\u0430; \u0447\u0438\u0441\u043B\u043E \u0441\u0442\u0440\u043E\u043A \u2014 \xABswarm logs -n 200\xBB.`);
     return 1;
   }
-  if (!existsSync17(DAEMON_LOG_PATH)) {
+  if (!existsSync18(DAEMON_LOG_PATH)) {
     console.error(`\u043B\u043E\u0433\u0430 \u0434\u0435\u043C\u043E\u043D\u0430 \u043D\u0435\u0442: ${DAEMON_LOG_PATH}`);
     console.error("\u043E\u043D \u043F\u0438\u0448\u0435\u0442\u0441\u044F \u043F\u0440\u0438 \u0444\u043E\u043D\u043E\u0432\u043E\u043C \u0437\u0430\u043F\u0443\u0441\u043A\u0435 (swarm start). \u0414\u0435\u043C\u043E\u043D \u043F\u043E\u0434\u043D\u044F\u0442 \u0432 \u0442\u0435\u0440\u043C\u0438\u043D\u0430\u043B\u0435 (--foreground) \u2014 \u0432\u044B\u0432\u043E\u0434 \u0438\u0434\u0451\u0442 \u0442\u0443\u0434\u0430.");
     return 1;
@@ -13740,12 +13979,12 @@ async function runDaemonLogs(argv) {
   const head = tailFile(DAEMON_LOG_PATH, lines);
   if (head) console.log(head);
   if (!follow) return 0;
-  let pos = statSync11(DAEMON_LOG_PATH).size;
+  let pos = statSync12(DAEMON_LOG_PATH).size;
   for (; ; ) {
     await sleep2(500);
     let size;
     try {
-      size = statSync11(DAEMON_LOG_PATH).size;
+      size = statSync12(DAEMON_LOG_PATH).size;
     } catch {
       continue;
     }
@@ -14014,10 +14253,10 @@ function effectiveWorktreesDir() {
       legacyDir: WORKTREES_LEGACY_DIR,
       targetDir: WORKTREES_DIR,
       envOverride: process.env.SWARM_WORKTREES || "",
-      exists: (d) => existsSync17(d),
+      exists: (d) => existsSync18(d),
       isNonEmptyDir: (d) => {
         try {
-          return readdirSync11(d).length > 0;
+          return readdirSync12(d).length > 0;
         } catch {
           return false;
         }
@@ -14073,15 +14312,15 @@ async function scoutRepo(repo) {
     await $6({ reject: false })`git -C ${worktree} reset --hard ${baseRef}`;
   }
   await setWorktreeIdentity(worktree, name);
-  const abs = (rel) => join26(worktree, rel);
+  const abs = (rel) => join27(worktree, rel);
   const code = await runRepoScout({
     repoFullName,
     repoPath: worktree,
     name,
-    readFile: (rel) => existsSync17(abs(rel)) ? readFileSync19(abs(rel), "utf8") : null,
+    readFile: (rel) => existsSync18(abs(rel)) ? readFileSync19(abs(rel), "utf8") : null,
     writeFile: (rel, text) => {
-      mkdirSync10(dirname5(abs(rel)), { recursive: true });
-      writeFileSync14(abs(rel), text);
+      mkdirSync11(dirname5(abs(rel)), { recursive: true });
+      writeFileSync15(abs(rel), text);
     },
     runScout: (prompt) => new Promise((resolve5) => {
       const child = spawn3(bin, [...ISOLATION_FLAGS, "--dangerously-skip-permissions", "-p", prompt], {