@taskless-app/swarm 0.2.0 → 0.2.2

package/dist/cli.js

@@ -3,10 +3,10 @@
 // src/cli.ts
 import { basename as basename3 } from "path";
 import { createInterface } from "readline/promises";
-import { setTimeout as sleep } from "timers/promises";
+import { setTimeout as sleep2 } from "timers/promises";
 
 // src/db.ts
-import Database from "better-sqlite3";
+import { createRequire } from "module";
 import { existsSync } from "fs";
 import { resolve as resolve2 } from "path";
 
@@ -92,6 +92,17 @@ function buildSegments(created, events, laneEnd) {
         push(e.at);
         phase = "running";
         break;
+      // TASWM-166: раньше эти два kind'а не двигали фазу — хвост дорожки
+      // дорисовывался ТЕКУЩЕЙ (до остановки) фазой, напр. "running" сплошным
+      // зелёным до самого конца — визуально неотличимо от реально идущего прогона.
+      case "stopped":
+        push(e.at);
+        phase = "stopped";
+        break;
+      case "superseded":
+        push(e.at);
+        phase = "superseded";
+        break;
     }
   }
   push(laneEnd);
@@ -112,7 +123,7 @@ function computeBlocker(status, stopReason, lastStep, pr, ci, deps, openQ) {
     case "blocked":
       return { icon: "\u2753", text: openQ ? `\u0436\u0434\u0451\u0442 \u043E\u0442\u0432\u0435\u0442\u0430: ${openQ}` : "\u0436\u0434\u0451\u0442 \u043E\u0442\u0432\u0435\u0442\u0430 \u043E\u043F\u0435\u0440\u0430\u0442\u043E\u0440\u0430", tone: "blocked" };
     case "paused":
-      return { icon: "\u{1F4A4}", text: "\u0437\u0430\u043C\u0435\u0440 \u2014 overmind \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D, \u0436\u0434\u0451\u0442 \u043F\u0435\u0440\u0435\u043F\u043E\u0434\u044A\u0451\u043C\u0430", tone: "paused" };
+      return { icon: "\u{1F4A4}", text: stopReason || "\u0437\u0430\u043C\u0435\u0440 \u2014 overmind \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D, \u0436\u0434\u0451\u0442 \u043F\u0435\u0440\u0435\u043F\u043E\u0434\u044A\u0451\u043C\u0430", tone: "paused" };
     case "storm_dead":
       return { icon: "\u{1F4A4}", text: "\u0432 \u043A\u043E\u043A\u043E\u043D\u0435 \u2014 \u0448\u0442\u043E\u0440\u043C Anthropic, \u0436\u0434\u0451\u0442 \u043E\u0442\u0431\u043E\u044F", tone: "paused" };
     case "review": {
@@ -126,7 +137,9 @@ function computeBlocker(status, stopReason, lastStep, pr, ci, deps, openQ) {
     case "failed":
       return { icon: "\u274C", text: stopReason || "\u0443\u043F\u0430\u043B", tone: "fail" };
     case "stopped":
-      return { icon: "\u23F9", text: stopReason || "\u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D", tone: "queued" };
+      return { icon: "\u23F9", text: stopReason || "\u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D", tone: "stopped" };
+    case "superseded":
+      return { icon: "\u21BA", text: "\u043F\u0435\u0440\u0435\u0438\u0433\u0440\u0430\u043D \u043D\u0430 \u0434\u0440\u0443\u0433\u043E\u0439 \u0432\u0430\u0440\u0438\u0430\u043D\u0442", tone: "superseded" };
     case "done":
       return { icon: "\u2705", text: "\u0441\u043C\u0435\u0440\u0436\u0435\u043D\u043E", tone: "done" };
     default:
@@ -311,11 +324,16 @@ var SWARM_CLAIM_INTERVAL_MS = envNum("SWARM_CLAIM_INTERVAL_MS", 6e4);
 var SWARM_MAX_LOAD_FACTOR = envNum("SWARM_MAX_LOAD_FACTOR", 0.9);
 var SWARM_MIN_FREE_GB = envNum("SWARM_MIN_FREE_GB", 1.5);
 var SWARM_MAX_FD_LOAD_FACTOR = envNum("SWARM_MAX_FD_LOAD_FACTOR", 0.9);
+var SWARM_RELIEF_LOAD_FACTOR = envNum("SWARM_RELIEF_LOAD_FACTOR", 1.3);
+var SWARM_RELIEF_MIN_FREE_GB = envNum("SWARM_RELIEF_MIN_FREE_GB", 0.8);
+var SWARM_RELIEF_MAX_FD_LOAD_FACTOR = envNum("SWARM_RELIEF_MAX_FD_LOAD_FACTOR", 0.95);
 var SWARM_REHYDRATE_MS = envNum("SWARM_REHYDRATE_MS", 15e3);
 var SWARM_PROD_HEARTBEAT_MS = envNum("SWARM_PROD_HEARTBEAT_MS", 15e3);
+var SWARM_SWEEP_INTERVAL_MS = envNum("SWARM_SWEEP_INTERVAL_MS", 10 * 6e4);
 var HEARTBEAT_PATH = process.env.SWARM_HEARTBEAT || join(SWARM_HOME, "overmind.heartbeat");
 var HEARTBEAT_STALE_MS = Number(process.env.SWARM_HEARTBEAT_STALE_MS) || 3e4;
 var SWARM_REPO = process.env.SWARM_REPO || "";
+var SWARM_REPO_PATHS = (process.env.SWARM_REPOS || SWARM_REPO).split(",").map((s) => s.trim()).filter(Boolean);
 var TASKLESS_API = process.env.TASKLESS_API || "https://taskless.ru";
 var SWARM_SHOT_TIMEOUT_MS = envNum("SWARM_SHOT_TIMEOUT_MS", 2e4);
 var TASKLESS_MCP_PATH = process.env.TASKLESS_MCP_PATH || "/api/mcp";
@@ -515,12 +533,25 @@ function rowToRun(row) {
     updated_at: row.updated_at
   };
 }
+function loadBetterSqlite3() {
+  const require2 = createRequire(import.meta.url);
+  try {
+    return require2("better-sqlite3");
+  } catch (err) {
+    throw new Error(
+      `better-sqlite3 \u043D\u0435 \u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D. Sqlite-\u0440\u0435\u0436\u0438\u043C (SwarmDb) \u2014 \u0434\u0435\u0444\u043E\u043B\u0442 \u043C\u043E\u043D\u043E\u0440\u0435\u043F\u044B/\u0442\u0435\u0441\u0442\u043E\u0432; \u043E\u043F\u0443\u0431\u043B\u0438\u043A\u043E\u0432\u0430\u043D\u043D\u044B\u0439 \u043F\u0430\u043A\u0435\u0442 \u043F\u043E \u0443\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E \u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442 \u0432 client-\u0440\u0435\u0436\u0438\u043C\u0435 \u0438 sqlite \u043D\u0435 \u0442\u0440\u0435\u0431\u0443\u0435\u0442. \u0423\u0441\u0442\u0430\u043D\u043E\u0432\u0438\u0442\u0435 optional dependency (npm i, \u0431\u0435\u0437 --omit=optional) \u0438\u043B\u0438 \u0437\u0430\u0434\u0430\u0439\u0442\u0435 SWARM_BACKEND=client. \u0418\u0441\u0445\u043E\u0434\u043D\u0430\u044F \u043E\u0448\u0438\u0431\u043A\u0430: ${err.message}`
+    );
+  }
+}
 var SwarmDb = class {
   db;
   defaultRepo;
+  databaseCtor;
+  // для importDb (второй Database, source)
   constructor(path = "swarm.db", defaultRepo = "") {
     this.defaultRepo = normalizeRepo(defaultRepo);
-    this.db = new Database(path);
+    this.databaseCtor = loadBetterSqlite3();
+    this.db = new this.databaseCtor(path);
     this.db.exec("PRAGMA journal_mode = WAL;");
     this.db.exec(SCHEMA);
     for (const alter of [
@@ -656,6 +687,33 @@ var SwarmDb = class {
     const row = this.db.prepare("SELECT COUNT(*) n FROM runs WHERE reviews_run_id = ? AND status NOT IN ('failed','stalled')").get(reviewRunId);
     return row.n;
   }
+  /**
+   * Жёсткий кап ревью-спавнов (TASWM-204, карусель мёртвых ревьюеров): сколько ревьюеров
+   * ВСЕГО (любой статус, включая failed/stalled — специально в отличие от reviewerCountFor
+   * выше) когда-либо поднималось на review-прогон #reviewRunId. Зеркалит resolverCountFor —
+   * плоский потолок попыток. Именно это ловит карусель: reviewerCountFor исключает
+   * failed/stalled (чтобы ОДИН транзиентный сбой не блокировал ревью навсегда), но тем
+   * самым допускает бесконечный ретрай, если ревьюер стабильно умирает без done().
+   */
+  reviewerAttemptCountFor(reviewRunId) {
+    const row = this.db.prepare("SELECT COUNT(*) n FROM runs WHERE reviews_run_id = ?").get(reviewRunId);
+    return row.n;
+  }
+  /** Последняя (любой статус) попытка ревьюера на review-прогон #reviewRunId (TASWM-196) —
+   *  см. store.ts:lastReviewerAttemptFor. */
+  lastReviewerAttemptFor(reviewRunId) {
+    const row = this.db.prepare("SELECT * FROM runs WHERE reviews_run_id = ? ORDER BY id DESC LIMIT 1").get(reviewRunId);
+    return row ? rowToRun(row) : null;
+  }
+  /**
+   * Живые/ждущие ревьюер-прогоны review-прогона #reviewRunId (TASWM-204): для
+   * closeReviewersOnMerge — PR смержен раньше вердикта, зависшего ревьюера пора закрыть,
+   * не дожидаясь done(). Точечный WHERE, не полный скан listRuns() (code-review TASWM-204).
+   */
+  activeReviewersFor(reviewRunId) {
+    const rows = this.db.prepare(`SELECT * FROM runs WHERE reviews_run_id = ? AND status NOT IN (${TERMINAL_SQL}) ORDER BY id DESC`).all(reviewRunId);
+    return rows.map(rowToRun);
+  }
   /** Последний живой (не терминальный) прогон по slug — для swarm cancel. */
   activeRunForSlug(slug) {
     const row = this.db.prepare(
@@ -716,7 +774,7 @@ var SwarmDb = class {
     const already = this.db.prepare("SELECT run_count FROM imports WHERE source = ?").get(abs);
     if (already) return { imported: false, runs: already.run_count };
     if (!existsSync(abs)) throw new Error(`import-db: \u0444\u0430\u0439\u043B\u0430 \u043D\u0435\u0442: ${abs}`);
-    const src = new Database(abs);
+    const src = new this.databaseCtor(abs);
     try {
       const runs = src.prepare("SELECT * FROM runs ORDER BY id").all();
       const events = src.prepare("SELECT * FROM events ORDER BY id").all();
@@ -1027,6 +1085,10 @@ var SwarmClient = class _SwarmClient {
   defaultRepo;
   autoFlush;
   listLimit;
+  // TASWM-169: репо-реестр демона — repoFullName[] на claim/heartbeat + обратная
+  // карта repoFullName→локальный путь для трансляции run.repo из прода (см. resolveRepo).
+  repoFullNames;
+  repoPathByFullName;
   // Зеркало.
   runs = /* @__PURE__ */ new Map();
   runtime = /* @__PURE__ */ new Map();
@@ -1059,6 +1121,9 @@ var SwarmClient = class _SwarmClient {
     this.defaultRepo = normalizeRepo(opts.defaultRepo ?? "");
     this.autoFlush = opts.autoFlush ?? true;
     this.listLimit = opts.listLimit ?? 200;
+    const registry = opts.repoRegistry ?? [];
+    this.repoFullNames = registry.map((e) => e.repoFullName);
+    this.repoPathByFullName = new Map(registry.map((e) => [e.repoFullName, normalizeRepo(e.path)]));
     this.outboxPath = opts.outboxPath;
     this.mapPath = `${opts.outboxPath}.prodmap.json`;
     this.stormPath = `${opts.outboxPath}.storm.jsonl`;
@@ -1305,6 +1370,19 @@ var SwarmClient = class _SwarmClient {
       (r) => r.reviews_run_id === reviewRunId && r.status !== "failed" && r.status !== "stalled"
     ).length;
   }
+  // Жёсткий кап ревью-спавнов (TASWM-204) — см. db.ts:reviewerAttemptCountFor.
+  reviewerAttemptCountFor(reviewRunId) {
+    return [...this.runs.values()].filter((r) => r.reviews_run_id === reviewRunId).length;
+  }
+  // Последняя попытка ревьюера (TASWM-196) — см. db.ts:lastReviewerAttemptFor.
+  lastReviewerAttemptFor(reviewRunId) {
+    const cands = [...this.runs.values()].filter((r) => r.reviews_run_id === reviewRunId).sort((a, b) => b.id - a.id);
+    return cands.length ? this.mat(cands[0]) : null;
+  }
+  // Живые/ждущие ревьюер-прогоны (TASWM-204) — см. db.ts:activeReviewersFor.
+  activeReviewersFor(reviewRunId) {
+    return [...this.runs.values()].filter((r) => r.reviews_run_id === reviewRunId && !TERMINAL_STATUSES.includes(r.status)).sort((a, b) => b.id - a.id).map((d) => this.mat(d));
+  }
   activeRunForSlug(slug) {
     const cands = [...this.runs.values()].filter((r) => r.task_slug === slug && !SLUG_TERMINAL.has(r.status)).sort((a, b) => b.id - a.id);
     return cands.length ? this.mat(cands[0]) : null;
@@ -1625,11 +1703,17 @@ var SwarmClient = class _SwarmClient {
    * cuid известен сразу, никакого create-flush. Возвращает локальный Run (queued; overmind
    * заспавнит его следующим тиком) либо null: нет claimable-задачи / прод недоступен / тул
    * отверг — во всех случаях тик продолжается, следующий ретраит.
+   *
+   * TASWM-169: repoFullNames — ЖИВОЙ реестр демона на момент ЭТОГО вызова, а не
+   * последняя heartbeat-декларация (heartbeat — своя кадансность, ~15с; claim — ~60с;
+   * плюс окно до первого успешного heartbeat при рестарте) — свежий аргумент здесь
+   * убирает то окно рассинхрона целиком. Пусто (демон без SWARM_REPOS) → ключ не
+   * шлём — прод фолбэкается на последнюю heartbeat-декларацию (или без фильтра).
    */
   async claim() {
     let res;
     try {
-      res = await this.call("swarm_claim_work", {});
+      res = await this.call("swarm_claim_work", this.repoFullNames.length ? { repoFullNames: this.repoFullNames } : {});
     } catch {
       return null;
     }
@@ -1659,16 +1743,41 @@ var SwarmClient = class _SwarmClient {
     const n = obj?.maxDrones;
     return typeof n === "number" && Number.isFinite(n) && n > 0 ? Math.trunc(n) : null;
   }
+  /**
+   * Live verifyMode проекта из Taskless (TASWM-171): читает swarm_repo_config по
+   * repoFullName (owner/repo из origin — см. git.remoteRepoFullName) — Project.swarmConfig.
+   * verifyMode ("local"/"ci"). Прод недоступен / repo не смэплен на swarm-enabled проект
+   * владельца токена (config=null в ответе) → null: ридер (makeVerifyModeReader) берёт
+   * env-фолбэк SWARM_VERIFY.
+   */
+  async repoVerifyMode(repoFullName) {
+    let res;
+    try {
+      res = await this.call("swarm_repo_config", { repoFullName });
+    } catch {
+      return null;
+    }
+    if (res?.isError) return null;
+    const sc = res.structuredContent ?? {};
+    const v = sc.config?.verifyMode;
+    return v === "local" || v === "ci" ? v : null;
+  }
   /**
    * Пульс overmind в прод (TASWM-129): swarm_heartbeat обновляет User.swarmHeartbeatAt —
    * дашборд /swarm сравнивает свежесть со своим порогом устаревания («нет связи с
    * овермайндом» вместо устаревшего «живого» роя). Best-effort, как ownerMaxDrones/claim:
    * прод недоступен/тул отверг → просто не обновили в этом тике, следующий ретраит —
    * не роняем тик демона из-за упавшего пульса.
+   *
+   * TASWM-169: заодно декларирует repoFullNames (репо-реестр демона) — та же
+   * кадансность, что и пульс, естественная точка «сказать серверу, что обслуживаю».
+   * Пустой реестр (демон не сконфигурирован на multi-repo/SWARM_REPOS) → ключ не
+   * шлём вовсе (undefined) — прод НЕ трогает прошлую декларацию (см. swarm.ts), не
+   * стирает её ложным «репо больше нет» из-за демона без SWARM_REPOS в env.
    */
   async heartbeat() {
     try {
-      await this.call("swarm_heartbeat", {});
+      await this.call("swarm_heartbeat", this.repoFullNames.length ? { repoFullNames: this.repoFullNames } : {});
     } catch {
     }
   }
@@ -1702,6 +1811,19 @@ var SwarmClient = class _SwarmClient {
     });
     if (res?.isError) throw new Error(`swarm_notify \u043E\u0442\u0432\u0435\u0440\u0433 \xAB${signal.key}\xBB`);
   }
+  /**
+   * TASWM-169: прод присылает run.repo как GitHub `owner/repo` для задач, взятых
+   * через claim-фильтр (matchedRepo в swarm_claim_work, см. api/mcp/tools/swarm.ts) —
+   * сервер не знает локальных fs-путей. Транслируем в путь по СВОЕМУ репо-реестру
+   * (см. repoRegistry.ts), т.к. git-операции (addWorktree/droneWorktreePath) ждут
+   * именно путь. Не нашли в реестре (репо не наш / ручной `--repo <path>` спавн, где
+   * repo — ВСЕГДА уже путь, старый формат) → возвращаем как есть без изменений
+   * (обратная совместимость: раньше pr.repo ВСЕГДА был локальным путём).
+   */
+  resolveRepo(raw) {
+    if (!raw) return "";
+    return this.repoPathByFullName.get(raw) ?? raw;
+  }
   hydrateRun(pr) {
     const prodId = String(pr.id ?? "");
     if (!prodId) return null;
@@ -1757,7 +1879,7 @@ var SwarmClient = class _SwarmClient {
     const revProd = pr.reviewsRunId ?? null;
     if (revProd) local.reviews_run_id = this.localIdForProdId(revProd) ?? local.reviews_run_id;
     local.review_verdict = pr.reviewVerdict ?? local.review_verdict;
-    local.repo = pr.repo ?? "";
+    local.repo = this.resolveRepo(pr.repo ?? null);
     local.branch = pr.branch ?? null;
     local.status = pr.status ?? local.status;
     local.area = pr.area ?? null;
@@ -1823,11 +1945,66 @@ var SwarmClient = class _SwarmClient {
     }, this.backoffMs);
     if (typeof this.flushTimer.unref === "function") this.flushTimer.unref();
   }
-  resolveArgs(e) {
+  // TASWM-202: create-флаш без прод-id слал taskId=e.taskRef НАПРЯМУЮ — а taskRef это
+  // человеческий слаг (task_slug, напр. «TASWM-171»), не cuid. Резолверы конфликта
+  // рождаются ЛОКАЛЬНО (createRun с uuid-runKey) и попадают в outbox БЕЗ прод-id —
+  // обычные прогоны рождаются в проде (claim) и гидрируются сразу с cuid, эта ветка
+  // их не касается. Прод create-схема ждёт cuid → отбивает слаг → строго
+  // упорядоченный flush стоит на этой голове НАВЕЧНО (ядовитая голова, инцидент
+  // 14.07/18.07, TASWM-201 — общий карантин; здесь — конкретный источник). Резолвим
+  // слаг→cuid через get_task (кэш — taskIdCache) ПЕРЕД тем как слать create.
+  taskIdCache = /* @__PURE__ */ new Map();
+  // task_slug → cuid прода
+  // Create для этого runKey резолвился окончательно неудачно (задача не найдена/
+  // недоступна) — событие/вопросы того же прогона тоже никогда не получат prod-id,
+  // без карантина они бы бросали «нет prod-id» на каждом флаше и СНОВА вставали
+  // ядовитой головой (просто на одну запись ниже по очереди).
+  poisonedRunKeys = /* @__PURE__ */ new Set();
+  // "transient" — прод/сеть недоступны, ответа нет или ошибка НЕ про отсутствие задачи
+  // (offline-стаб CLI, auth-протух, 5xx): НЕ терминально — запись остаётся в outbox и
+  // повторится на следующем флаше (иначе сетевой сбой = потеря прогона). null —
+  // терминально: прод ЯВНО ответил «задачи нет» (task_not_found / not_found в тексте
+  // tool-ошибки) либо успешный ответ без id — только это карантиним.
+  async resolveTaskCuid(taskRef) {
+    const cached = this.taskIdCache.get(taskRef);
+    if (cached) return cached;
+    let res;
+    try {
+      res = await this.call("get_task", { id: taskRef });
+    } catch {
+      return "transient";
+    }
+    if (!res) return "transient";
+    if (res.isError) {
+      const text = (res.content ?? []).map((c) => c.text ?? "").join(" ");
+      return /not_found/i.test(text) ? null : "transient";
+    }
+    const id = res.structuredContent?.task?.id;
+    if (!id) return null;
+    this.taskIdCache.set(taskRef, id);
+    return id;
+  }
+  async resolveArgs(e) {
     if (e.t === "run") {
       const fields = this.materializeRefs(e.fields);
       const prodId2 = this.prodIdByKey.get(e.runKey);
-      return prodId2 ? { tool: "swarm_run_upsert", args: { runId: prodId2, ...fields } } : { tool: "swarm_run_upsert", args: { taskId: e.taskRef, ...fields } };
+      if (prodId2) return { tool: "swarm_run_upsert", args: { runId: prodId2, ...fields } };
+      const taskId = await this.resolveTaskCuid(e.taskRef);
+      if (taskId === "transient") {
+        throw new Error(`slug\u2192cuid \u0434\u043B\u044F \xAB${e.taskRef}\xBB \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D (\u043F\u0440\u043E\u0434 \u043C\u043E\u0440\u0433\u043D\u0443\u043B) \u2014 retry`);
+      }
+      if (!taskId) {
+        console.error(
+          `[swarm-client] create-\u0444\u043B\u0430\u0448 \u043F\u0440\u043E\u043F\u0443\u0449\u0435\u043D: \u043F\u0440\u043E\u0434 \u043D\u0435 \u0437\u043D\u0430\u0435\u0442 \u0437\u0430\u0434\u0430\u0447\u0443 \xAB${e.taskRef}\xBB (runKey=${e.runKey}) \u2014 \u0437\u0430\u043F\u0438\u0441\u044C \u0432\u044B\u0431\u0440\u043E\u0448\u0435\u043D\u0430 \u0438\u0437 outbox`
+        );
+        this.poisonedRunKeys.add(e.runKey);
+        return "skip";
+      }
+      return { tool: "swarm_run_upsert", args: { taskId, ...fields } };
+    }
+    if (this.poisonedRunKeys.has(e.runKey)) {
+      console.error(`[swarm-client] ${e.t}-\u0444\u043B\u0430\u0448 \u043F\u0440\u043E\u043F\u0443\u0449\u0435\u043D: create \u043F\u0440\u043E\u0433\u043E\u043D\u0430 runKey=${e.runKey} \u043D\u0435 \u0440\u0435\u0437\u043E\u043B\u0432\u0438\u043B\u0441\u044F \u0440\u0430\u043D\u0435\u0435 \u2014 \u0437\u0430\u043F\u0438\u0441\u044C \u0432\u044B\u0431\u0440\u043E\u0448\u0435\u043D\u0430 \u0438\u0437 outbox`);
+      return "skip";
     }
     const prodId = this.prodIdByKey.get(e.runKey);
     if (!prodId) throw new Error(`\u043D\u0435\u0442 prod-id \u0434\u043B\u044F ${e.runKey} \u2014 \u043F\u0440\u043E\u0433\u043E\u043D \u0435\u0449\u0451 \u043D\u0435 \u0441\u043E\u0437\u0434\u0430\u043D \u0432 \u043F\u0440\u043E\u0434\u0435`);
@@ -1861,10 +2038,14 @@ var SwarmClient = class _SwarmClient {
         const e = this.pending[0];
         let call;
         try {
-          call = this.resolveArgs(e);
+          call = await this.resolveArgs(e);
         } catch {
           break;
         }
+        if (call === "skip") {
+          this.pending.shift();
+          continue;
+        }
         let res;
         try {
           res = await this.call(call.tool, call.args);
@@ -1930,6 +2111,30 @@ function parseDecision(v) {
   }
 }
 
+// src/repoRegistry.ts
+import { $ } from "execa";
+function parseRepoFullName(remoteUrl) {
+  const m = remoteUrl.trim().match(/^(?:https?:\/\/(?:[^@/]+@)?github\.com\/|git@github\.com:)([^/]+)\/([^/]+?)(\.git)?\/?$/i);
+  if (!m) return null;
+  return `${m[1]}/${m[2]}`.toLowerCase();
+}
+async function resolveRepoFullName(path) {
+  const res = await $({ reject: false })`git -C ${path} remote get-url origin`;
+  if (res.exitCode !== 0) return null;
+  return parseRepoFullName(res.stdout);
+}
+async function buildRepoRegistry(paths) {
+  const resolved = await Promise.all(
+    paths.map(async (raw) => {
+      const path = normalizeRepo(raw);
+      if (!path) return null;
+      const repoFullName = await resolveRepoFullName(path);
+      return repoFullName ? { repoFullName, path } : null;
+    })
+  );
+  return resolved.filter((e) => e !== null);
+}
+
 // src/web.ts
 import { randomBytes as randomBytes2 } from "crypto";
 import { basename as basename2 } from "path";
@@ -1938,7 +2143,7 @@ import { serve } from "@hono/node-server";
 // src/diff.ts
 import { statSync } from "fs";
 import { join as join2 } from "path";
-import { $ } from "execa";
+import { $ as $2 } from "execa";
 var MAX_FILES = 200;
 var MAX_LINES_PER_FILE = 1500;
 var MAX_UNTRACKED = 60;
@@ -2058,12 +2263,12 @@ function truncateFile(f) {
 }
 async function resolveBase(wt) {
   const tryRef = async (ref) => {
-    const sha = (await $({ reject: false })`git -C ${wt} rev-parse --verify --quiet ${ref + "^{commit}"}`).stdout.trim();
+    const sha = (await $2({ reject: false })`git -C ${wt} rev-parse --verify --quiet ${ref + "^{commit}"}`).stdout.trim();
     if (!sha) return null;
-    const mb = (await $({ reject: false })`git -C ${wt} merge-base HEAD ${ref}`).stdout.trim();
+    const mb = (await $2({ reject: false })`git -C ${wt} merge-base HEAD ${ref}`).stdout.trim();
     return mb || null;
   };
-  const originHead = (await $({ reject: false })`git -C ${wt} symbolic-ref --quiet --short refs/remotes/origin/HEAD`).stdout.trim();
+  const originHead = (await $2({ reject: false })`git -C ${wt} symbolic-ref --quiet --short refs/remotes/origin/HEAD`).stdout.trim();
   const candidates = [originHead, "origin/main", "origin/master", "main", "master"].filter(Boolean);
   for (const c of candidates) {
     const mb = await tryRef(c);
@@ -2082,16 +2287,16 @@ async function collectRunDiff(worktree, opts = {}) {
   const stub = (reason) => ({ ok: false, reason, pr: opts.pr ?? null, files: [], added: 0, removed: 0 });
   const gone = opts.status === "queued" ? "\u0434\u0440\u043E\u043D \u0435\u0449\u0451 \u0432 \u043E\u0447\u0435\u0440\u0435\u0434\u0438 \u2014 \u043A\u043E\u0434\u0430 \u043F\u043E\u043A\u0430 \u043D\u0435\u0442" : "worktree \u0443\u0431\u0440\u0430\u043D \u2014 \u043A\u043E\u0434 \u0441\u043C\u043E\u0442\u0440\u0438 \u0432 PR";
   if (!worktree) return stub(gone);
-  const isWt = (await $({ reject: false })`git -C ${worktree} rev-parse --is-inside-work-tree`).stdout.trim();
+  const isWt = (await $2({ reject: false })`git -C ${worktree} rev-parse --is-inside-work-tree`).stdout.trim();
   if (isWt !== "true") return stub(gone);
   const base2 = await resolveBase(worktree);
   const from = base2 ?? "HEAD";
-  const trackedTxt = (await $({ reject: false })`git -C ${worktree} diff --no-color --find-renames ${from} --`).stdout;
+  const trackedTxt = (await $2({ reject: false })`git -C ${worktree} diff --no-color --find-renames ${from} --`).stdout;
   let files = parseUnifiedDiff(trackedTxt);
-  const untrackedRaw = (await $({ reject: false })`git -C ${worktree} ls-files --others --exclude-standard -z`).stdout;
+  const untrackedRaw = (await $2({ reject: false })`git -C ${worktree} ls-files --others --exclude-standard -z`).stdout;
   const untracked = untrackedRaw.split("\0").filter(Boolean).slice(0, MAX_UNTRACKED);
   for (const rel of untracked) {
-    const t = (await $({ reject: false })`git -C ${worktree} diff --no-color --no-index -- /dev/null ${rel}`).stdout;
+    const t = (await $2({ reject: false })`git -C ${worktree} diff --no-color --no-index -- /dev/null ${rel}`).stdout;
     for (const pf of parseUnifiedDiff(t)) {
       pf.status = "added";
       if (!pf.path || pf.path === "/dev/null") pf.path = rel;
@@ -2115,8 +2320,8 @@ async function collectRunDiff(worktree, opts = {}) {
 }
 
 // src/gh.ts
-import { $ as $2 } from "execa";
-var realChecksRunner = async (pr) => (await $2({ reject: false, timeout: 15e3 })`gh pr checks ${pr} --json state,name,bucket,link`).stdout;
+import { $ as $3 } from "execa";
+var realChecksRunner = async (pr) => (await $3({ reject: false, timeout: 15e3 })`gh pr checks ${pr} --json state,name,bucket,link`).stdout;
 async function prCheckRows(pr, run) {
   try {
     const out = await run(pr);
@@ -2459,7 +2664,8 @@ function timelineState(db2, now = Date.now(), overmindLog = []) {
       cost: r.cost_usd || 0,
       role: r.kind,
       heroRunId: r.hero_run_id,
-      reviewVerdict: r.review_verdict
+      reviewVerdict: r.review_verdict,
+      model: r.model
     });
   }
   const liveLanes = lanes.filter((l) => l.live);
@@ -2957,7 +3163,7 @@ function cardStep(d){
   if(d.status==='stalled') return d.reason || '\u0434\u0440\u043E\u043D \u0437\u0430\u0432\u0438\u0441/\u043F\u043E\u0433\u0438\u0431';
   if(d.status==='stopped') return d.stopReason || d.reason || '\u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D';
   if(d.status==='storm_dead') return '\u0434\u0440\u043E\u043D \u0432 \u043A\u043E\u043A\u043E\u043D\u0435 \u2014 \u043F\u0441\u0438\u043E\u043D\u043D\u0430\u044F \u0441\u0432\u044F\u0437\u044C \u043F\u043E\u0442\u0435\u0440\u044F\u043D\u0430 (Anthropic \u0448\u0442\u043E\u0440\u043C\u0438\u0442), worktree \u0446\u0435\u043B, \u043F\u043E\u0434\u043D\u0438\u043C\u0435\u0442\u0441\u044F \u043F\u043E\u0441\u043B\u0435 \u043E\u0442\u0431\u043E\u044F';
-  if(d.status==='paused') return '\u0437\u0430\u043C\u0435\u0440 \u2014 overmind \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D, \u0436\u0434\u0451\u0442 \u043F\u0435\u0440\u0435\u043F\u043E\u0434\u044A\u0451\u043C\u0430';
+  if(d.status==='paused') return d.stopReason || '\u0437\u0430\u043C\u0435\u0440 \u2014 overmind \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D, \u0436\u0434\u0451\u0442 \u043F\u0435\u0440\u0435\u043F\u043E\u0434\u044A\u0451\u043C\u0430'; // TASWM-151: \u0440\u0435\u0441\u0443\u0440\u0441-\u0440\u0430\u0437\u0433\u0440\u0443\u0437\u043A\u0430 \u0437\u0430\u0434\u0430\u0451\u0442 \u0441\u0432\u043E\u0439 stopReason
   if(d.status==='review') { var n=prNum(d.pr); return 'PR'+(n?(' #'+n):'')+' \u043D\u0430 \u0440\u0435\u0432\u044C\u044E'; }
   if(d.status==='done') return '\u0441\u043C\u0435\u0440\u0436\u0435\u043D';
   if(d.status==='queued') return (d.waiting&&d.waiting.length) ? '\u0436\u0434\u0451\u0442: '+d.waiting.join(', ') : '\u0432 \u043E\u0447\u0435\u0440\u0435\u0434\u0438 \u2014 \u0436\u0434\u0451\u0442 \u0441\u043B\u043E\u0442\u0430';
@@ -3626,7 +3832,10 @@ function makeLauncher(cfg) {
         overmind: {
           command: isCompiled ? process.execPath : "bun",
           args: isCompiled ? [cfg.overmindEntry, "--drone", "--run", String(run.id)] : ["run", cfg.overmindEntry, "--drone", "--run", String(run.id)],
-          env: { SWARM_DB: cfg.dbPath }
+          // SWARM_TASK_SLUG (TASWM-211): task_slug зафиксирован ЗДЕСЬ, на спавне — устойчив к
+          // пересозданию локального стора между спавном и вызовами read_task (droneServer.ts
+          // доверяет ему, а не db.getRun(run.id).task_slug, который может протухнуть/переехать).
+          env: { SWARM_DB: cfg.dbPath, SWARM_TASK_SLUG: run.task_slug }
         }
       }
     };
@@ -3654,11 +3863,132 @@ function makeLauncher(cfg) {
 }
 
 // src/git.ts
-import { $ as $3 } from "execa";
+import { $ as $4 } from "execa";
+
+// src/procCleanup.ts
+import { execFileSync as execFileSync2 } from "child_process";
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+function parseLsofCwd(output) {
+  const rows = [];
+  let pid = null;
+  for (const line of output.split("\n")) {
+    const pMatch = /^p(\d+)$/.exec(line);
+    if (pMatch) {
+      pid = Number(pMatch[1]);
+    } else if (line.startsWith("n") && pid != null) {
+      rows.push({ pid, cwd: line.slice(1) });
+      pid = null;
+    }
+  }
+  return rows;
+}
+function cwdUnder(cwd, dir) {
+  return cwd === dir || cwd.startsWith(`${dir}/`);
+}
+function pidsWithCwdUnder(dir) {
+  let out;
+  try {
+    out = execFileSync2("lsof", ["-a", "-d", "cwd", "-F", "pn"], { encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
+  } catch (e) {
+    logTransientSpawnError("lsof", e);
+    return [];
+  }
+  return parseLsofCwd(out).filter((r) => cwdUnder(r.cwd, dir));
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+async function killPidsGraceful(pids, opts = {}) {
+  const graceMs = opts.graceMs ?? 3e3;
+  const pollMs = opts.pollMs ?? 150;
+  const kill = opts.kill ?? ((pid, signal) => process.kill(pid, signal));
+  const isAlive = opts.isAlive ?? pidAlive;
+  const sleepFn = opts.sleepFn ?? sleep;
+  const signalled = [];
+  for (const pid of pids) {
+    try {
+      kill(pid, "SIGTERM");
+      signalled.push(pid);
+    } catch {
+    }
+  }
+  if (!signalled.length) return signalled;
+  const deadline = Date.now() + graceMs;
+  while (Date.now() < deadline && signalled.some((pid) => isAlive(pid))) {
+    await sleepFn(pollMs);
+  }
+  for (const pid of signalled) {
+    try {
+      if (isAlive(pid)) kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+  return signalled;
+}
+function composeProjectPrefix(worktreeDirName) {
+  return worktreeDirName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function containerBelongsToPrefix(name, prefix) {
+  return name === prefix || name.startsWith(`${prefix}-`);
+}
+function dockerContainerNames() {
+  try {
+    return execFileSync2("docker", ["ps", "-a", "--format", "{{.Names}}"], { encoding: "utf8" }).split("\n").map((s) => s.trim()).filter(Boolean);
+  } catch (e) {
+    logTransientSpawnError("docker ps", e);
+    return [];
+  }
+}
+function removeContainers(names) {
+  const removed = [];
+  for (const name of names) {
+    try {
+      execFileSync2("docker", ["rm", "-f", name], { encoding: "utf8" });
+      removed.push(name);
+    } catch (e) {
+      console.warn(`[procCleanup] docker rm -f ${name} \u0441\u043E\u0440\u0432\u0430\u043B\u0441\u044F: ${String(e)}`);
+    }
+  }
+  return removed;
+}
+async function cleanupWorktreeProcesses(worktree, opts = {}) {
+  try {
+    const found = pidsWithCwdUnder(worktree);
+    if (found.length) {
+      const killed = await killPidsGraceful(
+        found.map((f) => f.pid),
+        opts
+      );
+      if (killed.length) console.log(`[procCleanup] worktree ${worktree}: \u043F\u043E\u0433\u0430\u0448\u0435\u043D\u043E \u043F\u0440\u043E\u0446\u0435\u0441\u0441\u043E\u0432 ${killed.length} (${killed.join(", ")})`);
+    }
+  } catch (e) {
+    console.error(`[procCleanup] \u0433\u0430\u0448\u0435\u043D\u0438\u0435 \u043F\u0440\u043E\u0446\u0435\u0441\u0441\u043E\u0432 worktree ${worktree} \u0441\u043E\u0440\u0432\u0430\u043B\u043E\u0441\u044C:`, e);
+  }
+  try {
+    const prefix = composeProjectPrefix(worktree.split("/").filter(Boolean).pop() ?? "");
+    if (!prefix) return;
+    const names = dockerContainerNames().filter((n) => containerBelongsToPrefix(n, prefix));
+    if (!names.length) return;
+    const removed = removeContainers(names);
+    if (removed.length) console.log(`[procCleanup] worktree ${worktree}: \u0441\u043D\u0435\u0441\u0435\u043D\u043E docker-\u043A\u043E\u043D\u0442\u0435\u0439\u043D\u0435\u0440\u043E\u0432 ${removed.length} (${removed.join(", ")})`);
+  } catch (e) {
+    console.error(`[procCleanup] \u0441\u043D\u043E\u0441 docker-\u043A\u043E\u043D\u0442\u0435\u0439\u043D\u0435\u0440\u043E\u0432 worktree ${worktree} \u0441\u043E\u0440\u0432\u0430\u043B\u0441\u044F:`, e);
+  }
+}
+
+// src/git.ts
 async function removeWorktree(repo, path) {
-  const branch = (await $3({ reject: false })`git -C ${path} symbolic-ref --quiet --short HEAD`).stdout.trim();
-  await $3({ reject: false })`git -C ${repo} worktree remove --force ${path}`;
-  if (branch) await $3({ reject: false })`git -C ${repo} branch -D ${branch}`;
+  const branch = (await $4({ reject: false })`git -C ${path} symbolic-ref --quiet --short HEAD`).stdout.trim();
+  await cleanupWorktreeProcesses(path);
+  await $4({ reject: false })`git -C ${repo} worktree remove --force ${path}`;
+  if (branch) await $4({ reject: false })`git -C ${repo} branch -D ${branch}`;
 }
 
 // src/taskless.ts
@@ -3915,7 +4245,7 @@ async function runShotCli(argv, deps = {}) {
 // package.json
 var package_default = {
   name: "@taskless-app/swarm",
-  version: "0.2.0",
+  version: "0.2.2",
   type: "module",
   description: "Local control plane for a fleet of AI coding agents (drones), coordinating through Taskless. The overmind runs the swarm.",
   keywords: [
@@ -3959,15 +4289,17 @@ var package_default = {
     lint: "echo 'no lint in swarm-daemon yet'"
   },
   dependencies: {
-    "@hono/node-server": "^1.13.0",
+    "@hono/node-server": "^2.0.10",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "better-sqlite3": "^11.8.0",
-    execa: "^9.5.0",
+    execa: "^10.0.0",
     zod: "3.25.76"
   },
+  optionalDependencies: {
+    "better-sqlite3": "^12.11.1"
+  },
   devDependencies: {
     "@taskless/swarm-core": "workspace:*",
-    "@types/better-sqlite3": "^7.6.11",
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "22.10.5",
     "playwright-core": "1.49.1",
     tsup: "^8.5.1",
@@ -4032,7 +4364,7 @@ async function runLogin(db2, opts) {
         loadStore,
         beforeToken: null,
         now: Date.now,
-        sleep,
+        sleep: sleep2,
         timeoutMs: 5 * 6e4,
         pollMs: 1e3
       });
@@ -4113,8 +4445,11 @@ function usage() {
 async function makeCliStore(repo) {
   if (SWARM_BACKEND !== "client") return new SwarmDb(DB_PATH, repo);
   const failing = async () => ({ isError: true });
-  const call = await connectSwarmMcp() ?? failing;
-  const client = new SwarmClient({ call, outboxPath: SWARM_OUTBOX, defaultRepo: repo });
+  const [call, repoRegistry] = await Promise.all([
+    connectSwarmMcp().then((c) => c ?? failing),
+    buildRepoRegistry(SWARM_REPO_PATHS)
+  ]);
+  const client = new SwarmClient({ call, outboxPath: SWARM_OUTBOX, defaultRepo: repo, repoRegistry });
   await client.hydrate();
   client.reconcileRuntime({ worktreesDir: WORKTREES_DIR, listProcesses: listDroneProcesses });
   return client;