@taskless-app/swarm 0.1.1 → 0.2.2

package/dist/cli.js

@@ -1,62 +1,240 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { basename as basename2 } from "path";
+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";
 
 // src/config.ts
 import { homedir } from "os";
-import { join, resolve } from "path";
-import { mkdirSync, readFileSync, realpathSync } from "fs";
-var SWARM_HOME = process.env.SWARM_HOME || join(homedir(), ".taskless-swarm");
-mkdirSync(SWARM_HOME, { recursive: true });
-function normalizeRepo(repo) {
-  const r = (repo ?? "").trim();
-  if (!r) return "";
-  try {
-    return realpathSync(r);
-  } catch {
-    return resolve(r);
+import { basename, join, resolve } from "path";
+import { mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync } from "fs";
+
+// ../swarm-core/src/types.ts
+var MILESTONE_KINDS = [
+  "spawned",
+  "pr_opened",
+  "merged",
+  "done",
+  "failed",
+  "stalled",
+  "conflict",
+  "ci_wake",
+  // CI-побудка (TASWM-102) — тоже реконсайл-решение, веха как conflict
+  "stopped",
+  "superseded",
+  "paused",
+  "resumed",
+  "storm_start",
+  "storm_end",
+  "storm_dead",
+  "anomaly"
+  // надзор overmind (TASWM-194) — та же нотификация, что улетела в инбокс, вехой в Истории
+];
+var MILESTONE_KIND_SET = new Set(MILESTONE_KINDS);
+function isMilestoneKind(kind) {
+  return MILESTONE_KIND_SET.has(kind);
+}
+
+// ../swarm-core/src/timeline.ts
+function buildSegments(created, events, laneEnd) {
+  const segs = [];
+  let cursor = created;
+  let phase = "queued";
+  const push = (to) => {
+    if (to > cursor) segs.push({ phase, from: cursor, to });
+    cursor = to;
+  };
+  for (const e of events) {
+    switch (e.kind) {
+      case "step":
+        if (phase === "queued") {
+          push(e.at);
+          phase = "running";
+        }
+        break;
+      case "blocked":
+        push(e.at);
+        phase = "blocked";
+        break;
+      case "answered":
+        push(e.at);
+        phase = "running";
+        break;
+      case "pr_opened":
+        push(e.at);
+        phase = "review";
+        break;
+      case "merged":
+      case "done":
+        push(e.at);
+        phase = "done";
+        break;
+      case "failed":
+        push(e.at);
+        phase = "failed";
+        break;
+      case "stalled":
+        push(e.at);
+        phase = "stalled";
+        break;
+      case "paused":
+      case "storm_dead":
+        push(e.at);
+        phase = "paused";
+        break;
+      case "resumed":
+        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);
+  return segs;
 }
-var DB_PATH = process.env.SWARM_DB || join(SWARM_HOME, "swarm.db");
-var WORKTREES_DIR = process.env.SWARM_WORKTREES || join(SWARM_HOME, "worktrees");
-var SWARM_BACKEND = process.env.SWARM_BACKEND === "client" ? "client" : "sqlite";
-var SWARM_OUTBOX = process.env.SWARM_OUTBOX || join(SWARM_HOME, "outbox.jsonl");
-function envNum(name, def) {
-  const raw = process.env[name];
-  if (raw === void 0 || raw === "") return def;
-  const n = Number(raw);
-  return Number.isFinite(n) && n >= 0 ? n : def;
+function computeBlocker(status, stopReason, lastStep, pr, ci, deps, openQ) {
+  switch (status) {
+    case "queued": {
+      const unmet = deps.filter((d) => !d.met);
+      if (unmet.length) {
+        const who = unmet.map((d) => d.name ? `${d.slug}\xB7${d.name}` : d.slug).join(", ");
+        return { icon: "\u26D4", text: `\u0436\u0434\u0451\u0442 ${who}`, tone: "dep" };
+      }
+      return { icon: "\u23F8", text: "\u0436\u0434\u0451\u0442 \u0441\u043B\u043E\u0442\u0430 / \u0441\u043F\u0430\u0432\u043D\u0430", tone: "queued" };
+    }
+    case "running":
+      return { icon: "\u25B6", text: lastStep ? `\u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442: ${lastStep}` : "\u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442", tone: "run" };
+    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: 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": {
+      if (!pr) return { icon: "\u{1F440}", text: "review \u0431\u0435\u0437 PR", tone: "review" };
+      if (!ci) return { icon: "\u23F3", text: "CI: \u0436\u0434\u0443 \u0441\u0442\u0430\u0442\u0443\u0441\u2026", tone: "review" };
+      if (ci.tone === "merge") return { icon: "\u{1F535}", text: "CI \u0437\u0435\u043B\u0451\u043D\u044B\u0439 \u2014 \u0436\u0434\u0451\u0442 \u043C\u0435\u0440\u0436\u0430", tone: "merge" };
+      return { icon: ci.tone === "fail" ? "\u274C" : "\u23F3", text: ci.text.replace(/^[^ ]+ /, ""), tone: ci.tone };
+    }
+    case "stalled":
+      return { icon: "\u26A0\uFE0F", text: stopReason || (lastStep ? `\u043C\u043E\u043B\u0447\u0438\u0442: ${lastStep}` : "\u043C\u043E\u043B\u0447\u0438\u0442"), tone: "stalled" };
+    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: "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:
+      return { icon: "\u2022", text: status, tone: "queued" };
+  }
 }
-var SWARM_MAX_IN_FLIGHT = Math.trunc(envNum("SWARM_MAX_IN_FLIGHT", 3));
-var SWARM_CLAIM_INTERVAL_MS = envNum("SWARM_CLAIM_INTERVAL_MS", 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 TASKLESS_API = process.env.TASKLESS_API || "https://taskless.ru";
-function tokenFromFile() {
-  try {
-    return readFileSync(join(SWARM_HOME, "token"), "utf8").trim();
-  } catch {
-    return "";
+function pickHeadline(lanes) {
+  const live = lanes.filter((l2) => l2.live && !l2.obsolete);
+  const by = (pred) => live.find(pred);
+  const fmt = (l2, extra) => `${l2.name} \xB7 ${l2.slug} \u2014 ${extra}`;
+  let l = by((x) => x.status === "review" && x.ci?.tone === "fail");
+  if (l) return { icon: "\u274C", text: fmt(l, "CI \u0443\u043F\u0430\u043B \u2014 \u0447\u0438\u043D\u0438\u0442\u044C"), tone: "fail" };
+  l = by((x) => x.status === "blocked");
+  if (l) return { icon: "\u2753", text: fmt(l, "\u0436\u0434\u0451\u0442 \u043E\u0442\u0432\u0435\u0442\u0430 \u043E\u043F\u0435\u0440\u0430\u0442\u043E\u0440\u0430"), tone: "blocked" };
+  l = by((x) => x.status === "stalled");
+  if (l) return { icon: "\u26A0\uFE0F", text: fmt(l, "stalled \u2014 \u043F\u0440\u043E\u0432\u0435\u0440\u0438\u0442\u044C \u0434\u0440\u043E\u043D\u0430"), tone: "stalled" };
+  l = by((x) => x.status === "review" && x.blocker.tone === "merge");
+  if (l) return { icon: "\u{1F535}", text: fmt(l, "CI \u0437\u0435\u043B\u0451\u043D\u044B\u0439 \u2014 \u0436\u0434\u0451\u0442 \u043C\u0435\u0440\u0436\u0430"), tone: "merge" };
+  l = by((x) => x.status === "queued" && x.dependsOn.some((d) => !d.met));
+  if (l) {
+    const dep = l.dependsOn.find((d) => !d.met);
+    return { icon: "\u26D4", text: fmt(l, `\u0436\u0434\u0451\u0442 ${dep.slug}${dep.name ? " \xB7 " + dep.name : ""}`), tone: "dep" };
   }
+  l = by((x) => x.status === "review");
+  if (l) return { icon: "\u23F3", text: fmt(l, "review \u2014 CI \u0438\u0434\u0451\u0442"), tone: "review" };
+  l = by((x) => x.status === "running");
+  if (l) return { icon: "\u25B6", text: `${live.filter((x) => x.status === "running").length} \u0434\u0440\u043E\u043D\u0430 \u0432 \u0440\u0430\u0431\u043E\u0442\u0435 \u2014 \u0431\u043B\u043E\u043A\u0438\u0440\u043E\u0432\u043E\u043A \u043D\u0435\u0442`, tone: "run" };
+  return null;
 }
-var TASKLESS_TOKEN = process.env.TASKLESS_TOKEN || tokenFromFile();
-var TASKLESS_WORKSPACE = process.env.TASKLESS_WORKSPACE || "";
-var TASKLESS_WORKSPACE_SLUG = process.env.TASKLESS_WORKSPACE_SLUG || "";
-var TASKLESS_TASK_URL_BASE = process.env.TASKLESS_TASK_URL_BASE || (TASKLESS_WORKSPACE_SLUG ? `${TASKLESS_API.replace(/\/$/, "")}/app/${TASKLESS_WORKSPACE_SLUG}` : "");
-var SWARM_STORM_URL = process.env.SWARM_STORM_URL || "";
-var WEB_PORT = Number(process.env.SWARM_WEB_PORT) || 7420;
-var WEB_REDIRECT_URI = process.env.SWARM_REDIRECT_URI || `http://127.0.0.1:${WEB_PORT}/callback`;
+var DEFAULT_RUN_MS = 25 * 6e4;
 
-// src/names.ts
+// ../swarm-core/src/status.ts
+var STATUS_META = {
+  queued: { pill: "queued", label: "\u0432 \u043E\u0447\u0435\u0440\u0435\u0434\u0438", color: "--muted-foreground", terminal: false },
+  running: { pill: "run", label: "\u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442", color: "--primary", terminal: false },
+  blocked: { pill: "blocked", label: "\u0436\u0434\u0451\u0442 \u043E\u0442\u0432\u0435\u0442\u0430", color: "--warning", terminal: false },
+  paused: { pill: "paused", label: "\u0437\u0430\u043C\u0435\u0440", color: "--warning", terminal: false },
+  // overmind был недоступен — ждёт пробуждения (TASWM-41)
+  review: { pill: "review", label: "\u043D\u0430 \u0440\u0435\u0432\u044C\u044E", color: "--info", terminal: false },
+  done: { pill: "done", label: "\u0441\u043C\u0435\u0440\u0436\u0435\u043D\u043E", color: "--success", terminal: true },
+  failed: { pill: "failed", label: "\u0443\u043F\u0430\u043B", color: "--destructive", terminal: true },
+  stalled: { pill: "stalled", label: "\u043F\u043E\u0433\u0438\u0431/\u0437\u0430\u0432\u0438\u0441", color: "--destructive", terminal: false },
+  // молчит/погиб, но ещё разруливается — не терминал
+  storm_dead: { pill: "storm", label: "\u0448\u0442\u043E\u0440\u043C \u2014 \u0437\u0430\u043C\u043E\u0440\u043E\u0436\u0435\u043D", color: "--warning", terminal: false },
+  // умер в шторм Anthropic, поднимется после отбоя (TASWM-23)
+  stopped: { pill: "stopped", label: "\u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D", color: "--muted-foreground", terminal: true },
+  superseded: { pill: "superseded", label: "\u043F\u0435\u0440\u0435\u0438\u0433\u0440\u0430\u043D", color: "--muted-foreground", terminal: true }
+};
+var FALLBACK = STATUS_META.queued;
+var TERMINAL_STATUSES = Object.keys(STATUS_META).filter(
+  (s) => STATUS_META[s].terminal
+);
+function statusMeta(status) {
+  return STATUS_META[status] ?? FALLBACK;
+}
+function isTerminalStatus(status) {
+  return statusMeta(status).terminal;
+}
+function statusTuples() {
+  const out = {};
+  for (const [status, m] of Object.entries(STATUS_META)) {
+    out[status] = [m.pill, m.label, m.color];
+  }
+  return out;
+}
+
+// ../swarm-core/src/time.ts
+function stamp(d = /* @__PURE__ */ new Date()) {
+  return d.toISOString().slice(0, 19).replace("T", " ");
+}
+function stampFromEpochSec(sec) {
+  return stamp(new Date(sec * 1e3));
+}
+function sqliteMs(ts) {
+  return Date.parse(ts.replace(" ", "T") + "Z");
+}
+function toStamp(v) {
+  if (typeof v !== "string" || !v) return null;
+  const d = new Date(v);
+  if (Number.isNaN(d.getTime())) return v.includes("T") ? v.slice(0, 19).replace("T", " ") : v;
+  return stamp(d);
+}
+var DAY_MS = 864e5;
+
+// ../swarm-core/src/windows.ts
+var ROY_WINDOW_DEFAULTS = { windowH: 5, maxDone: 6, axisH: 6 };
+function resolveRoyWindows(env = {}) {
+  return {
+    windowMs: Number(env.ROY_WINDOW_H || ROY_WINDOW_DEFAULTS.windowH) * 36e5,
+    maxTerminalLanes: Number(env.ROY_MAX_DONE || ROY_WINDOW_DEFAULTS.maxDone),
+    maxAxisMs: Number(env.ROY_AXIS_H || ROY_WINDOW_DEFAULTS.axisH) * 36e5
+  };
+}
+
+// ../swarm-core/src/names.ts
 var DRONE_POOL = [
   // Латинский бестиарий (15)
   "SCARAB",
@@ -85,7 +263,7 @@ var DRONE_POOL = [
   "LEVIATHAN",
   "SURTUR"
 ];
-var NAME_LIVE = /* @__PURE__ */ new Set(["queued", "running", "blocked", "review"]);
+var ACTIVE_NAME_STATUSES = ["queued", "running", "blocked", "review"];
 function toRoman(n) {
   if (n < 1 || n > 3999) return String(n);
   const table = [
@@ -113,6 +291,86 @@ function genName(base2, g) {
 function baseName(name) {
   return name.split(" ")[0];
 }
+
+// src/config.ts
+var SWARM_HOME = process.env.SWARM_HOME || join(homedir(), ".taskless-swarm");
+mkdirSync(SWARM_HOME, { recursive: true });
+function normalizeRepo(repo) {
+  const r = (repo ?? "").trim();
+  if (!r) return "";
+  try {
+    return realpathSync(r);
+  } catch {
+    return resolve(r);
+  }
+}
+var DB_PATH = process.env.SWARM_DB || join(SWARM_HOME, "swarm.db");
+var WORKTREES_DIR = process.env.SWARM_WORKTREES || join(SWARM_HOME, "worktrees");
+var RUN_LOGS_DIR = process.env.SWARM_RUN_LOGS || join(SWARM_HOME, "run-logs");
+function droneWorktreePath(worktreesDir, repo, slug) {
+  return join(worktreesDir, basename(normalizeRepo(repo)), slug);
+}
+var DIST_BUILD = true;
+var SWARM_BACKEND = process.env.SWARM_BACKEND === "client" ? "client" : process.env.SWARM_BACKEND === "sqlite" ? "sqlite" : DIST_BUILD ? "client" : "sqlite";
+var SWARM_OUTBOX = process.env.SWARM_OUTBOX || join(SWARM_HOME, "outbox.jsonl");
+function envNum(name, def) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw === "") return def;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? n : def;
+}
+var SWARM_MAX_IN_FLIGHT = Math.trunc(envNum("SWARM_MAX_IN_FLIGHT", 3));
+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";
+function mcpEndpoint(api, path = TASKLESS_MCP_PATH) {
+  const base2 = api.replace(/\/$/, "");
+  const p = path.startsWith("/") ? path : `/${path}`;
+  return `${base2}${p}`;
+}
+function tokenFromFile() {
+  try {
+    return readFileSync(join(SWARM_HOME, "token"), "utf8").trim();
+  } catch {
+    return "";
+  }
+}
+var TASKLESS_TOKEN = process.env.TASKLESS_TOKEN || tokenFromFile();
+var TASKLESS_WORKSPACE = process.env.TASKLESS_WORKSPACE || "";
+var TASKLESS_WORKSPACE_SLUG = process.env.TASKLESS_WORKSPACE_SLUG || "";
+var TASKLESS_TASK_URL_BASE = process.env.TASKLESS_TASK_URL_BASE || (TASKLESS_WORKSPACE_SLUG ? `${TASKLESS_API.replace(/\/$/, "")}/app/${TASKLESS_WORKSPACE_SLUG}` : "");
+var SWARM_VERIFY = process.env.SWARM_VERIFY === "ci" ? "ci" : "local";
+var SWARM_AUTO_REVIEW = process.env.SWARM_AUTO_REVIEW !== "0";
+var REVIEW_CUTOFF_PATH = process.env.SWARM_REVIEW_CUTOFF || join(SWARM_HOME, "review-cutoff.json");
+var SWARM_REVIEW_CAP = Math.trunc(envNum("SWARM_REVIEW_CAP", 1));
+var SWARM_STORM_URL = process.env.SWARM_STORM_URL || "";
+var WEB_PORT = Number(process.env.SWARM_WEB_PORT) || 7420;
+var WEB_REDIRECT_URI = process.env.SWARM_REDIRECT_URI || `http://127.0.0.1:${WEB_PORT}/callback`;
+var SWARM_ANOMALY_RENOTIFY_MS = envNum("SWARM_ANOMALY_RENOTIFY_MS", 60 * 6e4);
+var SWARM_ANOMALY_FAILED_SPIKE_COUNT = Math.trunc(envNum("SWARM_ANOMALY_FAILED_SPIKE_COUNT", 3));
+var SWARM_ANOMALY_FAILED_SPIKE_WINDOW_MS = envNum("SWARM_ANOMALY_FAILED_SPIKE_WINDOW_MS", 30 * 6e4);
+var SWARM_ANOMALY_QUEUE_STALLED_MS = envNum("SWARM_ANOMALY_QUEUE_STALLED_MS", 10 * 6e4);
+var SWARM_ANOMALY_PR_STUCK_MERGE_MS = envNum("SWARM_ANOMALY_PR_STUCK_MERGE_MS", 30 * 6e4);
+var SWARM_ANOMALY_PR_NO_REVIEWER_MS = envNum("SWARM_ANOMALY_PR_NO_REVIEWER_MS", 20 * 6e4);
+var SWARM_ANOMALY_QUESTION_UNANSWERED_MS = envNum("SWARM_ANOMALY_QUESTION_UNANSWERED_MS", 20 * 6e4);
+var SWARM_ANOMALY_OUTBOX_STUCK_MS = envNum("SWARM_ANOMALY_OUTBOX_STUCK_MS", 10 * 6e4);
+
+// src/names.ts
+var NAME_LIVE = new Set(ACTIVE_NAME_STATUSES);
 function pickName(rows) {
   const live = /* @__PURE__ */ new Set();
   const lastUse = /* @__PURE__ */ new Map();
@@ -163,6 +421,8 @@ function decodeProbe(text) {
 }
 
 // src/db.ts
+var TERMINAL_SQL = TERMINAL_STATUSES.map((s) => `'${s}'`).join(",");
+var RESOLVER_TERMINAL_SQL = [...TERMINAL_STATUSES, "stalled"].map((s) => `'${s}'`).join(",");
 var SCHEMA = `
 CREATE TABLE IF NOT EXISTS runs (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -185,6 +445,8 @@ CREATE TABLE IF NOT EXISTS runs (
   stop_reason TEXT,
   respawns INTEGER NOT NULL DEFAULT 0,
   resolves_run_id INTEGER,
+  reviews_run_id INTEGER,
+  review_verdict TEXT,
   task_title TEXT,
   task_desc TEXT,
   task_url TEXT,
@@ -262,6 +524,8 @@ function rowToRun(row) {
     respawns: row.respawns ?? 0,
     // старые прогоны без колонки → 0
     resolves_run_id: row.resolves_run_id ?? null,
+    reviews_run_id: row.reviews_run_id ?? null,
+    review_verdict: row.review_verdict ?? null,
     task_title: row.task_title ?? null,
     task_desc: row.task_desc ?? null,
     task_url: row.task_url ?? null,
@@ -269,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 [
@@ -295,7 +572,11 @@ var SwarmDb = class {
       // Иерархия роя (TASWM-78): роль прогона (drone|hero) и ссылка на прогон-героя.
       "ALTER TABLE runs ADD COLUMN kind TEXT NOT NULL DEFAULT 'drone'",
       "ALTER TABLE runs ADD COLUMN hero_run_id INTEGER",
-      "ALTER TABLE events ADD COLUMN actor TEXT"
+      "ALTER TABLE events ADD COLUMN actor TEXT",
+      // Авто-ревью (TASWM-148): прогон-ревьюер (reviews_run_id → review-прогон) и
+      // вердикт (approve|changes), который ревьюер пишет на проверяемый прогон.
+      "ALTER TABLE runs ADD COLUMN reviews_run_id INTEGER",
+      "ALTER TABLE runs ADD COLUMN review_verdict TEXT"
     ]) {
       try {
         this.db.exec(alter);
@@ -315,7 +596,7 @@ var SwarmDb = class {
   createRun(input) {
     const name = input.name ?? pickName(this.db.prepare("SELECT id, name, status FROM runs").all());
     const res = this.db.prepare(
-      "INSERT INTO runs (task_slug, name, kind, hero_run_id, repo, area, depends_on, model, decision, resolves_run_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
+      "INSERT INTO runs (task_slug, name, kind, hero_run_id, repo, area, depends_on, model, decision, resolves_run_id, reviews_run_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
     ).run(
       input.task_slug,
       name,
@@ -329,10 +610,11 @@ var SwarmDb = class {
       input.depends_on && input.depends_on.length ? JSON.stringify(input.depends_on) : null,
       input.model ?? null,
       input.decision ? JSON.stringify(input.decision) : null,
-      input.resolves_run_id ?? null
+      input.resolves_run_id ?? null,
+      input.reviews_run_id ?? null
     );
     const id = Number(res.lastInsertRowid);
-    const spawnNote = input.resolves_run_id ? `\u0440\u0435\u0437\u043E\u043B\u0432\u0435\u0440 \u043A\u043E\u043D\u0444\u043B\u0438\u043A\u0442\u0430 \u0434\u043B\u044F #${input.resolves_run_id}` : input.decision ? `\u043F\u0435\u0440\u0435\u0437\u0430\u043F\u0443\u0441\u043A \u0441 \u0440\u0435\u0448\u0435\u043D\u0438\u0435\u043C \xAB${input.decision.chosen}\xBB` : `run for ${input.task_slug}`;
+    const spawnNote = input.resolves_run_id ? `\u0440\u0435\u0437\u043E\u043B\u0432\u0435\u0440 \u043A\u043E\u043D\u0444\u043B\u0438\u043A\u0442\u0430 \u0434\u043B\u044F #${input.resolves_run_id}` : input.reviews_run_id ? `\u0440\u0435\u0432\u044C\u044E\u0435\u0440 \u0434\u043B\u044F #${input.reviews_run_id}` : input.decision ? `\u043F\u0435\u0440\u0435\u0437\u0430\u043F\u0443\u0441\u043A \u0441 \u0440\u0435\u0448\u0435\u043D\u0438\u0435\u043C \xAB${input.decision.chosen}\xBB` : `run for ${input.task_slug}`;
     this.addEvent(id, "spawned", spawnNote);
     return this.getRun(id);
   }
@@ -385,7 +667,7 @@ var SwarmDb = class {
    */
   activeResolverFor(reviewRunId) {
     const row = this.db.prepare(
-      "SELECT * FROM runs WHERE resolves_run_id = ? AND status NOT IN ('done','failed','superseded','stopped','stalled') ORDER BY id DESC LIMIT 1"
+      `SELECT * FROM runs WHERE resolves_run_id = ? AND status NOT IN (${RESOLVER_TERMINAL_SQL}) ORDER BY id DESC LIMIT 1`
     ).get(reviewRunId);
     return row ? rowToRun(row) : null;
   }
@@ -394,10 +676,48 @@ var SwarmDb = class {
     const row = this.db.prepare("SELECT COUNT(*) n FROM runs WHERE resolves_run_id = ?").get(reviewRunId);
     return row.n;
   }
+  /**
+   * Сколько ЖИВЫХ/УСПЕШНЫХ ревьюеров уже поднимали на этот review-PR (авто-ревью, TASWM-148) —
+   * one-shot идемпотентность БЕЗ лимита попыток (в отличие от резолвера): >0 → повторно не
+   * спавним. failed/stalled ревьюеры (worktree/launch сорвались ДО вердикта) в счёт НЕ идут —
+   * иначе один транзиентный сбой спавна (диск/git/gh) навсегда блокировал бы ревью этого PR без
+   * единого шанса на повтор — тихо нарушая политику владельца «каждый PR ревьюится».
+   */
+  reviewerCountFor(reviewRunId) {
+    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(
-      "SELECT * FROM runs WHERE task_slug = ? AND status NOT IN ('done','failed','superseded','stopped') ORDER BY id DESC LIMIT 1"
+      `SELECT * FROM runs WHERE task_slug = ? AND status NOT IN (${TERMINAL_SQL}) ORDER BY id DESC LIMIT 1`
     ).get(slug);
     return row ? rowToRun(row) : null;
   }
@@ -454,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();
@@ -629,11 +949,10 @@ var SwarmDb = class {
         taskUrl: row.taskUrl ?? null
       });
     }
-    const MILESTONES = /* @__PURE__ */ new Set(["spawned", "pr_opened", "merged", "done", "failed", "stalled", "conflict", "stopped", "superseded", "paused", "resumed", "storm_start", "storm_end", "storm_dead"]);
     for (const row of this.db.prepare(
       "SELECT e.*, r.task_slug slug, r.name name, r.repo repo, r.task_title title, r.pr_url pr, r.task_url taskUrl FROM events e LEFT JOIN runs r ON r.id = e.run_id"
     ).all()) {
-      if (!MILESTONES.has(row.kind)) continue;
+      if (!isMilestoneKind(row.kind)) continue;
       const global = row.run_id == null;
       items.push({
         kind: "milestone",
@@ -694,12 +1013,13 @@ var SwarmDb = class {
     return row.n;
   }
   /**
-   * Спавн-фейлов (событий failed на НЕ-резолверных прогонах) с момента cutoff.
-   * Резолверные failed (merge-main-in) не считаем штормовым сигналом.
+   * Спавн-фейлов (событий failed на НЕ-резолверных/НЕ-ревьюерных прогонах) с момента
+   * cutoff. Резолверные (merge-main-in) и ревьюерные (авто-ревью, TASWM-148) failed не
+   * считаем штормовым сигналом.
    */
   spawnFailCountSince(cutoffSeconds) {
     const row = this.db.prepare(
-      "SELECT COUNT(*) n FROM events e JOIN runs r ON r.id = e.run_id WHERE e.kind='failed' AND r.resolves_run_id IS NULL AND e.at >= datetime(?, 'unixepoch')"
+      "SELECT COUNT(*) n FROM events e JOIN runs r ON r.id = e.run_id WHERE e.kind='failed' AND r.resolves_run_id IS NULL AND r.reviews_run_id IS NULL AND e.at >= datetime(?, 'unixepoch')"
     ).get(cutoffSeconds);
     return row.n;
   }
@@ -719,139 +1039,1111 @@ var SwarmDb = class {
   }
 };
 
-// src/web.ts
-import { randomBytes as randomBytes2 } from "crypto";
-import { basename } from "path";
-import { serve } from "@hono/node-server";
-import { $ as $2 } from "execa";
+// src/swarmClient.ts
+import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { dirname } from "path";
+import { randomUUID } from "crypto";
 
-// ../swarm-core/src/timeline.ts
-function buildSegments(created, events, laneEnd) {
-  const segs = [];
-  let cursor = created;
-  let phase = "queued";
-  const push = (to) => {
-    if (to > cursor) segs.push({ phase, from: cursor, to });
-    cursor = to;
-  };
-  for (const e of events) {
-    switch (e.kind) {
-      case "step":
-        if (phase === "queued") {
-          push(e.at);
-          phase = "running";
+// src/resources.ts
+import os from "os";
+import { execFileSync } from "child_process";
+import { readFileSync as readFileSync2 } from "fs";
+function isTransientResourceError(e) {
+  const code = e?.code;
+  return code === "ENFILE" || code === "EMFILE" || code === "EAGAIN";
+}
+function logTransientSpawnError(label, e) {
+  if (isTransientResourceError(e)) {
+    const code = e.code;
+    console.warn(`[overmind] ${label}: \u041E\u0421 \u043D\u0435 \u0434\u0430\u0451\u0442 \u0441\u043F\u0430\u0432\u043D\u0438\u0442\u044C \u043F\u0440\u043E\u0446\u0435\u0441\u0441\u044B (${code}) \u2014 \u043F\u0440\u043E\u043F\u0443\u0441\u043A\u0430\u044E \u0441\u0438\u0433\u043D\u0430\u043B \u044D\u0442\u043E\u0433\u043E \u0442\u0438\u043A\u0430, \u043D\u0435 \u043F\u0430\u0434\u0430\u044E`);
+  } else {
+    console.warn(`[overmind] ${label} \u0441\u043E\u0440\u0432\u0430\u043B\u0441\u044F (\u043D\u0435\u0442 \u0434\u0430\u043D\u043D\u044B\u0445 \u0437\u0430 \u044D\u0442\u043E\u0442 \u0442\u0438\u043A): ${String(e)}`);
+  }
+}
+
+// src/swarmClient.ts
+var RESOLVER_TERMINAL = /* @__PURE__ */ new Set([...TERMINAL_STATUSES, "stalled"]);
+var SLUG_TERMINAL = new Set(TERMINAL_STATUSES);
+function runRef(runKey) {
+  return { __runRef: runKey };
+}
+function isRunRef(v) {
+  return typeof v === "object" && v !== null && "__runRef" in v;
+}
+function jsonFromTextContent(res) {
+  const text = res?.content?.find((c) => c.type === "text")?.text;
+  if (text) {
+    try {
+      return JSON.parse(text);
+    } catch {
+    }
+  }
+  return res?.structuredContent ?? null;
+}
+var SwarmClient = class _SwarmClient {
+  call;
+  defaultRepo;
+  autoFlush;
+  listLimit;
+  // TASWM-169: репо-реестр демона — repoFullName[] на claim/heartbeat + обратная
+  // карта repoFullName→локальный путь для трансляции run.repo из прода (см. resolveRepo).
+  repoFullNames;
+  repoPathByFullName;
+  // Зеркало.
+  runs = /* @__PURE__ */ new Map();
+  runtime = /* @__PURE__ */ new Map();
+  eventsLog = [];
+  questionsLog = [];
+  nextRunId = 1;
+  nextEventId = 1;
+  nextQuestionId = 1;
+  // Корреляция с продом.
+  keyByLocal = /* @__PURE__ */ new Map();
+  // local run id → runKey
+  prodIdByKey = /* @__PURE__ */ new Map();
+  // runKey → prod cuid
+  seenProdEventIds = /* @__PURE__ */ new Set();
+  // дедуп событий при повторной гидрации
+  // Outbox / flush.
+  outboxPath;
+  mapPath;
+  stormPath;
+  // durable-сайдкар глобальных (штормовых) событий
+  pending = [];
+  nextSeq = 1;
+  flushing = false;
+  flushTimer = null;
+  backoffMs = 500;
+  static BACKOFF_BASE = 500;
+  static BACKOFF_MAX = 3e4;
+  constructor(opts) {
+    this.call = opts.call;
+    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`;
+    mkdirSync2(dirname(this.outboxPath), { recursive: true });
+    this.recover();
+  }
+  // ── рестарт: поднять outbox (незаписанные операции) и карту runKey→prodId ─────
+  recover() {
+    if (existsSync2(this.mapPath)) {
+      try {
+        const obj = JSON.parse(readFileSync3(this.mapPath, "utf8"));
+        for (const [k, v] of Object.entries(obj)) this.prodIdByKey.set(k, v);
+      } catch {
+      }
+    }
+    if (existsSync2(this.outboxPath)) {
+      const txt = readFileSync3(this.outboxPath, "utf8");
+      for (const line of txt.split("\n")) {
+        const s = line.trim();
+        if (!s) continue;
+        try {
+          this.pending.push(JSON.parse(s));
+        } catch {
         }
-        break;
-      case "blocked":
-        push(e.at);
-        phase = "blocked";
-        break;
-      case "answered":
-        push(e.at);
-        phase = "running";
-        break;
-      case "pr_opened":
-        push(e.at);
-        phase = "review";
-        break;
-      case "merged":
-      case "done":
-        push(e.at);
-        phase = "done";
-        break;
-      case "failed":
-        push(e.at);
-        phase = "failed";
-        break;
-      case "stalled":
-        push(e.at);
-        phase = "stalled";
-        break;
+      }
+      this.nextSeq = this.pending.reduce((m, e) => Math.max(m, e.seq), 0) + 1;
+      if (this.autoFlush && this.pending.length) this.scheduleFlush();
+    }
+    this.replayGlobalEvents();
+  }
+  // Реплей глобальных (штормовых) событий из сайдкара в зеркало на старте. Идут в
+  // eventsLog ПЕРВЫМИ (до hydrate), в порядке файла (= хронологический); id
+  // переприсваиваем локально (id событий — только порядок, не корреляция с продом).
+  replayGlobalEvents() {
+    if (!existsSync2(this.stormPath)) return;
+    let txt;
+    try {
+      txt = readFileSync3(this.stormPath, "utf8");
+    } catch {
+      return;
+    }
+    for (const line of txt.split("\n")) {
+      const s = line.trim();
+      if (!s) continue;
+      try {
+        const g = JSON.parse(s);
+        this.eventsLog.push({
+          id: this.nextEventId++,
+          run_id: null,
+          kind: g.kind,
+          text: g.text ?? null,
+          actor: g.actor ?? null,
+          at: g.at
+        });
+      } catch {
+      }
+    }
+  }
+  // Дописать глобальное событие в durable-сайдкар (append-only, синхронно — как outbox).
+  persistGlobalEvent(ev) {
+    try {
+      appendFileSync(this.stormPath, JSON.stringify(ev) + "\n");
+    } catch {
+    }
+  }
+  // ── зеркало: наложить рантайм на durable-прогон ──────────────────────────────
+  mat(d) {
+    const rt = this.runtime.get(d.id);
+    const { runKey: _k, ...rest } = d;
+    return { ...rest, pid: rt?.pid ?? null, worktree_path: rt?.worktree_path ?? null };
+  }
+  runKeyFor(localId) {
+    return this.keyByLocal.get(localId);
+  }
+  // cuid прода → локальный id (по runKey гидрированного прогона `p:<cuid>`).
+  // Для маппинга прод heroId → локальный hero_run_id при гидрации. Резолвится, когда
+  // прогон-герой присутствует в зеркале; иначе null (уточнится следующим рефрешем).
+  localIdForProdId(prodId) {
+    return [...this.runs.values()].find((r) => r.runKey === `p:${prodId}`)?.id;
+  }
+  // ── outbox: поставить операцию в очередь (зеркало уже обновлено вызывающим) ───
+  enqueue(e) {
+    const full = { ...e, seq: this.nextSeq++ };
+    this.pending.push(full);
+    try {
+      appendFileSync(this.outboxPath, JSON.stringify(full) + "\n");
+    } catch {
+    }
+    this.scheduleFlush();
+  }
+  // Прод-патч прогона: локальные поля Run → поля swarm_run_upsert (см. TASWM-74).
+  // pid/worktree_path (рантайм), respawns (нет в схеме тула) и снимок задачи (task_*,
+  // прод берёт join'ом из Task) в прод НЕ уходят. kind → role (плоский enum). Self-ref
+  // прогонов hero_run_id/resolves_run_id/superseded_by → heroId/resolvesRunId/
+  // supersededById как ОТЛОЖЕННЫЕ ссылки (RunRef) — cuid резолвится на флаше.
+  runFields(patch) {
+    const out = {};
+    if ("status" in patch && patch.status !== void 0) out.status = patch.status;
+    if ("area" in patch) out.area = patch.area ?? null;
+    if ("model" in patch) out.model = patch.model ?? null;
+    if ("name" in patch) out.droneName = patch.name ?? null;
+    if ("cost_usd" in patch && patch.cost_usd !== void 0) out.costUsd = patch.cost_usd;
+    if ("pr_url" in patch) out.prUrl = patch.pr_url ?? null;
+    if ("branch" in patch) out.branch = patch.branch ?? null;
+    if ("repo" in patch) out.repo = patch.repo ?? null;
+    if ("stop_reason" in patch) out.stopReason = patch.stop_reason ?? null;
+    if ("depends_on" in patch && patch.depends_on) out.dependsOn = patch.depends_on;
+    if ("decision" in patch) out.decision = patch.decision ? JSON.stringify(patch.decision) : null;
+    if ("kind" in patch && patch.kind !== void 0) out.role = patch.kind;
+    if ("review_verdict" in patch) out.reviewVerdict = patch.review_verdict ?? null;
+    this.setRunRefField(out, "heroId", patch, "hero_run_id");
+    this.setRunRefField(out, "resolvesRunId", patch, "resolves_run_id");
+    this.setRunRefField(out, "supersededById", patch, "superseded_by");
+    this.setRunRefField(out, "reviewsRunId", patch, "reviews_run_id");
+    return out;
+  }
+  // Положить self-ref прогона в прод-патч: локальный number → отложенная ссылка
+  // {__runRef: runKey} (резолв в cuid на флаше, resolveArgs/materializeRefs). Явный
+  // null → очистка поля. Локальный id без runKey (прогон не в зеркале) — пропускаем.
+  setRunRefField(out, prodKey, patch, localKey) {
+    if (!(localKey in patch)) return;
+    const localId = patch[localKey];
+    if (localId == null) {
+      out[prodKey] = null;
+      return;
+    }
+    const key = this.keyByLocal.get(localId);
+    if (key) out[prodKey] = runRef(key);
+  }
+  enqueueRun(run, fields) {
+    if (Object.keys(fields).length === 0) return;
+    this.enqueue({ t: "run", runKey: run.runKey, taskRef: run.task_slug, fields });
+  }
+  // ── runs ─────────────────────────────────────────────────────────────────────
+  createRun(input) {
+    const rows = [...this.runs.values()].map((r) => ({ id: r.id, name: r.name, status: r.status }));
+    const name = input.name ?? pickName(rows);
+    const id = this.nextRunId++;
+    const now = stamp();
+    const d = {
+      id,
+      runKey: randomUUID(),
+      task_slug: input.task_slug,
+      name,
+      kind: input.kind ?? "drone",
+      // роль прогона: дефолт — рабочий дрон (TASWM-78)
+      hero_run_id: input.hero_run_id ?? null,
+      // отряд героя (задел иерархии)
+      repo: normalizeRepo(input.repo || this.defaultRepo),
+      branch: null,
+      status: "queued",
+      area: input.area ?? null,
+      depends_on: input.depends_on && input.depends_on.length ? input.depends_on : [],
+      model: input.model ?? null,
+      cost_usd: 0,
+      pr_url: null,
+      superseded_by: null,
+      decision: input.decision ?? null,
+      stop_reason: null,
+      respawns: 0,
+      resolves_run_id: input.resolves_run_id ?? null,
+      reviews_run_id: input.reviews_run_id ?? null,
+      review_verdict: null,
+      task_title: null,
+      task_desc: null,
+      task_url: null,
+      created_at: now,
+      updated_at: now
+    };
+    this.runs.set(id, d);
+    this.keyByLocal.set(id, d.runKey);
+    this.enqueueRun(d, this.runFields({
+      status: "queued",
+      area: d.area,
+      model: d.model,
+      name: d.name,
+      repo: d.repo,
+      depends_on: d.depends_on,
+      decision: d.decision,
+      kind: d.kind,
+      hero_run_id: d.hero_run_id,
+      resolves_run_id: d.resolves_run_id,
+      // резолвер конфликта → связь на review-прогон
+      reviews_run_id: d.reviews_run_id
+      // ревьюер (авто-ревью, TASWM-148) → связь на review-прогон
+    }));
+    const spawnNote = input.resolves_run_id ? `\u0440\u0435\u0437\u043E\u043B\u0432\u0435\u0440 \u043A\u043E\u043D\u0444\u043B\u0438\u043A\u0442\u0430 \u0434\u043B\u044F #${input.resolves_run_id}` : input.reviews_run_id ? `\u0440\u0435\u0432\u044C\u044E\u0435\u0440 \u0434\u043B\u044F #${input.reviews_run_id}` : input.decision ? `\u043F\u0435\u0440\u0435\u0437\u0430\u043F\u0443\u0441\u043A \u0441 \u0440\u0435\u0448\u0435\u043D\u0438\u0435\u043C \xAB${input.decision.chosen}\xBB` : `run for ${input.task_slug}`;
+    this.addEvent(id, "spawned", spawnNote);
+    return this.mat(d);
+  }
+  getRun(id) {
+    const d = this.runs.get(id);
+    return d ? this.mat(d) : null;
+  }
+  listRuns(status) {
+    const all = [...this.runs.values()].filter((r) => status ? r.status === status : true);
+    all.sort((a, b) => b.id - a.id);
+    return all.map((d) => this.mat(d));
+  }
+  /** Прогоны отряда Героя-лейтенанта #heroId (его дроны: hero_run_id = heroId), новые сверху (TASWM-81). */
+  squadRuns(heroId) {
+    return [...this.runs.values()].filter((r) => r.hero_run_id === heroId).sort((a, b) => b.id - a.id).map((d) => this.mat(d));
+  }
+  updateRun(id, patch) {
+    const d = this.runs.get(id);
+    if (!d) return null;
+    if (Object.keys(patch).length === 0) return this.mat(d);
+    if ("pid" in patch || "worktree_path" in patch) {
+      const rt = this.runtime.get(id) ?? { pid: null, worktree_path: null };
+      if ("pid" in patch) rt.pid = patch.pid ?? null;
+      if ("worktree_path" in patch) rt.worktree_path = patch.worktree_path ?? null;
+      this.runtime.set(id, rt);
+    }
+    for (const [k, v] of Object.entries(patch)) {
+      if (k === "pid" || k === "worktree_path") continue;
+      d[k] = v;
+    }
+    d.updated_at = stamp();
+    this.enqueueRun(d, this.runFields(patch));
+    return this.mat(d);
+  }
+  incRespawn(id) {
+    const d = this.runs.get(id);
+    if (!d) return 0;
+    d.respawns += 1;
+    d.updated_at = stamp();
+    return d.respawns;
+  }
+  cancel(id, reason) {
+    const run = this.updateRun(id, { status: "stopped", stop_reason: reason });
+    if (run) this.addEvent(id, "stopped", reason);
+    return run;
+  }
+  activeResolverFor(reviewRunId) {
+    const cands = [...this.runs.values()].filter((r) => r.resolves_run_id === reviewRunId && !RESOLVER_TERMINAL.has(r.status)).sort((a, b) => b.id - a.id);
+    return cands.length ? this.mat(cands[0]) : null;
+  }
+  resolverCountFor(reviewRunId) {
+    return [...this.runs.values()].filter((r) => r.resolves_run_id === reviewRunId).length;
+  }
+  // failed/stalled ревьюеры (сорвался спавн ДО вердикта) в счёт НЕ идут — см. db.ts:reviewerCountFor.
+  reviewerCountFor(reviewRunId) {
+    return [...this.runs.values()].filter(
+      (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;
+  }
+  runningAreas(repo) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const r of this.runs.values()) {
+      if (!(r.status === "running" || r.status === "blocked")) continue;
+      if (r.area == null) continue;
+      if (repo !== void 0 && r.repo !== repo) continue;
+      seen.add(r.area);
+    }
+    return [...seen];
+  }
+  unmetDeps(depends_on) {
+    if (!depends_on || depends_on.length === 0) return [];
+    const done = /* @__PURE__ */ new Set();
+    for (const r of this.runs.values()) {
+      if (r.status === "done" && r.resolves_run_id == null) done.add(r.task_slug);
+    }
+    return depends_on.filter((slug) => !done.has(slug));
+  }
+  distinctRepos() {
+    const seen = /* @__PURE__ */ new Set();
+    for (const r of this.runs.values()) if (r.repo) seen.add(r.repo);
+    return [...seen];
+  }
+  // ── questions ──────────────────────────────────────────────────────────────
+  ask(run_id, text, options) {
+    const q = {
+      id: this.nextQuestionId++,
+      run_id,
+      text,
+      options: options && options.length ? options : null,
+      status: "open",
+      answer: null,
+      answered_by: null,
+      escalated: false,
+      asked_at: stamp(),
+      answered_at: null
+    };
+    this.questionsLog.push(q);
+    this.updateRun(run_id, { status: "blocked" });
+    this.addEvent(run_id, "blocked", text);
+    const key = this.runKeyFor(run_id);
+    if (key) this.enqueue({ t: "ask", runKey: key, text });
+    return q;
+  }
+  escalateQuestion(id) {
+    const q = this.questionsLog.find((x) => x.id === id);
+    if (q) q.escalated = true;
+  }
+  withdrawQuestion(id, reason) {
+    const q = this.questionsLog.find((x) => x.id === id);
+    if (q && q.status === "open") {
+      q.status = "withdrawn";
+      q.answer = reason;
+      q.answered_at = stamp();
+    }
+  }
+  answer(question_id, answer, by = "human") {
+    const q = this.questionsLog.find((x) => x.id === question_id);
+    if (q && q.status === "open") {
+      q.status = "answered";
+      q.answer = answer;
+      q.answered_by = by;
+      q.answered_at = stamp();
+      this.updateRun(q.run_id, { status: "running" });
+      this.addEvent(q.run_id, "answered", answer, by);
+    }
+    return q ? { ...q } : null;
+  }
+  supersede(oldId, newId, by = "human") {
+    this.updateRun(oldId, { superseded_by: newId });
+    this.addEvent(oldId, "superseded", `\u043F\u0435\u0440\u0435\u0438\u0433\u0440\u0430\u043D \u2192 #${newId}`, by);
+  }
+  getQuestion(id) {
+    const q = this.questionsLog.find((x) => x.id === id);
+    return q ? { ...q } : null;
+  }
+  openQuestions() {
+    return this.questionsLog.filter((q) => q.status === "open").sort((a, b) => a.id - b.id).map((q) => ({ ...q }));
+  }
+  runIdsWithQuestions() {
+    return [...new Set(this.questionsLog.map((q) => q.run_id))];
+  }
+  /**
+   * Открытые вопросы дронов отряда Героя #heroId (вопрос → его прогон → hero_run_id).
+   * Гейт «отвечать только своим» для answer_drone + список для squad_status (TASWM-81).
+   */
+  openQuestionsFor(heroId) {
+    return this.questionsLog.filter((q) => q.status === "open" && this.runs.get(q.run_id)?.hero_run_id === heroId).sort((a, b) => a.id - b.id).map((q) => ({ ...q }));
+  }
+  // ── events / хроника ─────────────────────────────────────────────────────────
+  addEvent(run_id, kind, text, actor = null) {
+    const ev = { id: this.nextEventId++, run_id, kind, text: text ?? null, actor: actor ?? null, at: stamp() };
+    this.eventsLog.push(ev);
+    if (run_id == null) {
+      this.persistGlobalEvent({ kind, text: ev.text, actor: ev.actor, at: ev.at });
+      return;
+    }
+    const key = this.runKeyFor(run_id);
+    if (key) this.enqueue({ t: "event", runKey: key, kind, text: text ?? null, actor: actor ?? null });
+  }
+  events(run_id) {
+    return this.eventsLog.filter((e) => e.run_id === run_id).sort((a, b) => a.id - b.id).map((e) => ({ ...e }));
+  }
+  history(limit = 50) {
+    const items = [];
+    const runById = (id) => id == null ? null : this.runs.get(id) ?? null;
+    const nameOf = (r, runId) => r?.name ?? `#${runId}`;
+    for (const q of this.questionsLog) {
+      const r = runById(q.run_id);
+      items.push({
+        kind: "qa",
+        at: q.answered_at ?? q.asked_at,
+        slug: r?.task_slug ?? "?",
+        name: nameOf(r, q.run_id),
+        repo: r?.repo ?? "",
+        area: r?.area ?? null,
+        qid: q.id,
+        question: q.text,
+        options: q.options,
+        answer: q.answer,
+        answered_by: q.answered_by,
+        escalated: q.escalated,
+        open: q.status === "open",
+        title: r?.task_title ?? null,
+        pr: r?.pr_url ?? null,
+        taskUrl: r?.task_url ?? null
+      });
+    }
+    for (const e of this.eventsLog) {
+      if (!isMilestoneKind(e.kind)) continue;
+      const global = e.run_id == null;
+      const r = runById(e.run_id);
+      items.push({
+        kind: "milestone",
+        at: e.at,
+        slug: r?.task_slug ?? (global ? "\u0440\u043E\u0439" : "?"),
+        name: global ? "\u0440\u043E\u0439" : nameOf(r, e.run_id),
+        repo: r?.repo ?? "",
+        event: e.kind,
+        text: e.text,
+        actor: e.actor,
+        title: r?.task_title ?? null,
+        pr: r?.pr_url ?? null,
+        taskUrl: r?.task_url ?? null
+      });
+    }
+    items.sort((a, b) => a.at < b.at ? 1 : a.at > b.at ? -1 : 0);
+    return items.slice(0, limit);
+  }
+  mergedToday() {
+    const today = stamp().slice(0, 10);
+    return this.eventsLog.filter((e) => e.kind === "merged" && e.at.slice(0, 10) === today).length;
+  }
+  // ── штормовой режим ──────────────────────────────────────────────────────────
+  lastGlobal(kinds) {
+    for (let i = this.eventsLog.length - 1; i >= 0; i--) {
+      const e = this.eventsLog[i];
+      if (e.run_id == null && kinds.includes(e.kind)) return e;
+    }
+    return null;
+  }
+  stormActive() {
+    return this.lastGlobal(["storm_start", "storm_end"])?.kind === "storm_start";
+  }
+  currentStormStartedAt() {
+    const e = this.lastGlobal(["storm_start", "storm_end"]);
+    return e?.kind === "storm_start" ? e.at : null;
+  }
+  startStorm(reason) {
+    this.addEvent(null, "storm_start", reason);
+  }
+  endStorm(reason) {
+    this.addEvent(null, "storm_end", reason);
+  }
+  recordDeath(runId, note) {
+    this.addEvent(runId, "died", note ?? "\u0434\u0440\u043E\u043D \u0443\u043C\u0435\u0440 (dead pid)");
+  }
+  deathCountSince(cutoffSeconds) {
+    const cutoff = stampFromEpochSec(cutoffSeconds);
+    return this.eventsLog.filter((e) => e.kind === "died" && e.at >= cutoff).length;
+  }
+  spawnFailCountSince(cutoffSeconds) {
+    const cutoff = stampFromEpochSec(cutoffSeconds);
+    return this.eventsLog.filter((e) => {
+      if (e.kind !== "failed" || e.run_id == null || e.at < cutoff) return false;
+      const r = this.runs.get(e.run_id);
+      return !!r && r.resolves_run_id == null && r.reviews_run_id == null;
+    }).length;
+  }
+  recordStormProbe(probe, ext) {
+    this.addEvent(null, "storm_probe", encodeProbe({ probe, ext }));
+  }
+  latestStormProbe() {
+    const e = this.lastGlobal(["storm_probe"]);
+    return e ? { rec: decodeProbe(e.text), at: e.at } : null;
+  }
+  stormProbeRecordsSince(sinceIso) {
+    return this.eventsLog.filter((e) => e.run_id == null && e.kind === "storm_probe" && e.at >= sinceIso).sort((a, b) => a.id - b.id).map((e) => decodeProbe(e.text));
+  }
+  // ── гидрация зеркала из прода (старт + реконсайл-рефреш) ──────────────────────
+  async hydrate() {
+    let res;
+    try {
+      res = await this.call("swarm_list_runs", { limit: this.listLimit });
+    } catch {
+      return;
+    }
+    if (res?.isError) return;
+    const runs = res.structuredContent?.runs ?? [];
+    for (const pr of runs) this.hydrateRun(pr);
+    for (const pr of runs) this.linkRefs(pr);
+  }
+  /**
+   * Реконсайл рантайма после рестарта демона (client-режим). pid/worktree_path живут в
+   * ОТДЕЛЬНОЙ Map (машинное — в прод не уходят) и рестарт демона НЕ переживают: гидрация
+   * из прода приносит running/blocked-прогоны с pid=null. Но демон и дроны — РАЗНЫЕ
+   * detached-процессы (launcher: detached+unref), поэтому рестарт демона дронов НЕ убивает
+   * — часть их ещё жива. Сопоставляем каждый running/blocked-прогон зеркала с живым
+   * процессом (ps, injected listProcesses) по детерминированному worktree
+   * (<worktreesDir>/<repo-basename>/<slug>):
+   *   • нашёлся живой процесс → восстанавливаем pid+worktree_path (дрон жив — overmind его
+   *     НЕ похоронит и не заспавнит второго поверх);
+   *   • не нашёлся → дрон не пережил рестарт: восстанавливаем worktree_path, если каталог
+   *     цел (для respawn --continue), pid оставляем null. overmind (tickOnce шаг 3) ловит
+   *     running/blocked с pid=null как смерть и оживляет/усыновляет/стопорит по общей ветке.
+   * Рантайм пишем ПРЯМО в runtime-Map (в обход updateRun) — чисто локально, без outbox и
+   * без прод-раунд-трипа. Идемпотентно; вызывается один раз на старте после hydrate().
+   * Возвращает счётчики (для лога демона) + reconciled (TASWM-145): false → listProcesses()
+   * бросил (ENFILE и т.п.), реконсайл этого запуска ПРОПУЩЕН целиком (не «confirmed пусто» —
+   * см. коммент в catch ниже). Вызывающий (runDaemon) ОБЯЗАН пропустить startup-sync
+   * (syncCrashedOnStartup) при reconciled=false: та трактует pid==null как «не пережил
+   * рестарт» и безусловно хоронит (stalled/done) — при пропущенном реконсайле это massively
+   * похоронило бы ВСЕХ running/blocked, включая реально живых detached-дронов, тем же
+   * транзиентным сбоем ОС, который этот PR должен переживать, а не превращать в мор.
+   */
+  reconcileRuntime(opts) {
+    const wtExists = opts.worktreeExists ?? existsSync2;
+    const pidByWorktree = /* @__PURE__ */ new Map();
+    try {
+      for (const p of opts.listProcesses()) if (p.worktree) pidByWorktree.set(p.worktree, p.pid);
+    } catch (e) {
+      logTransientSpawnError("ps (reconcileRuntime)", e);
+      return { alive: 0, dead: 0, reconciled: false };
+    }
+    let alive = 0;
+    let dead = 0;
+    for (const d of this.runs.values()) {
+      if (d.status !== "running" && d.status !== "blocked") continue;
+      if (this.runtime.get(d.id)?.pid != null) continue;
+      const workerWt = droneWorktreePath(opts.worktreesDir, d.repo || this.defaultRepo, d.task_slug);
+      let matchWt = null;
+      let matchPid = null;
+      if (d.resolves_run_id == null && d.reviews_run_id == null) {
+        const p = pidByWorktree.get(workerWt);
+        if (p != null) {
+          matchWt = workerWt;
+          matchPid = p;
+        }
+      } else if (d.resolves_run_id != null) {
+        const prefix = `${workerWt}-resolve-`;
+        for (const [wt, p] of pidByWorktree) {
+          if (wt.startsWith(prefix)) {
+            matchWt = wt;
+            matchPid = p;
+            break;
+          }
+        }
+      } else {
+        const reviewed = this.runs.get(d.reviews_run_id);
+        const reviewedWt = reviewed ? droneWorktreePath(opts.worktreesDir, reviewed.repo || this.defaultRepo, reviewed.task_slug) : workerWt;
+        const prefix = `${reviewedWt}-review-`;
+        for (const [wt, p] of pidByWorktree) {
+          if (wt.startsWith(prefix)) {
+            matchWt = wt;
+            matchPid = p;
+            break;
+          }
+        }
+      }
+      if (matchPid != null && matchWt) {
+        this.runtime.set(d.id, { pid: matchPid, worktree_path: matchWt });
+        alive++;
+      } else {
+        const wt = d.resolves_run_id == null && d.reviews_run_id == null && wtExists(workerWt) ? workerWt : null;
+        this.runtime.set(d.id, { pid: null, worktree_path: wt });
+        dead++;
+      }
+    }
+    return { alive, dead, reconciled: true };
+  }
+  // Долинковать self-ref прогона по прод-cuid → локальному id (после того как все
+  // прогоны гидрированы). Идемпотентно: ставит найденное, иначе не трогает.
+  linkRefs(pr) {
+    const localId = this.localIdForProdId(String(pr.id ?? ""));
+    const local = localId === void 0 ? void 0 : this.runs.get(localId);
+    if (!local) return;
+    const hero = pr.heroId ?? null;
+    if (hero) local.hero_run_id = this.localIdForProdId(hero) ?? local.hero_run_id;
+    const res = pr.resolvesRunId ?? null;
+    if (res) local.resolves_run_id = this.localIdForProdId(res) ?? local.resolves_run_id;
+    const sup = pr.supersededById ?? null;
+    if (sup) local.superseded_by = this.localIdForProdId(sup) ?? local.superseded_by;
+    const rev = pr.reviewsRunId ?? null;
+    if (rev) local.reviews_run_id = this.localIdForProdId(rev) ?? local.reviews_run_id;
+  }
+  /**
+   * Авто-интейк (TASWM-100): взять следующую claimable-задачу владельца токена через
+   * прод-тул swarm_claim_work и завести её прогон в зеркале. claim атомарен НА СЕРВЕРЕ
+   * (FIFO по createdAt + pg_advisory_xact_lock + дедуп «нет активного прогона») — гонку
+   * двух тиков overmind и двойной claim решает прод, клиенту делать этого не надо. Непустой
+   * ответ → ГИДРИРУЕМ созданный прогон как `p:<cuid>` (тот же путь, что hydrate/реконсайл),
+   * а НЕ createRun: локальный create завёл бы ВТОРОЙ прогон с create-outbox по taskRef и
+   * задвоил бы зеркало с уже существующим прод-прогоном. Гидрация лишь зеркалит прод — его
+   * 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", this.repoFullNames.length ? { repoFullNames: this.repoFullNames } : {});
+    } catch {
+      return null;
+    }
+    if (res?.isError) return null;
+    const sc = res.structuredContent ?? {};
+    if (!sc.claimed || typeof sc.run !== "object" || sc.run === null) return null;
+    const local = this.hydrateRun(sc.run);
+    return local ? this.mat(local) : null;
+  }
+  /**
+   * Живой потолок дронов владельца из Taskless (TASWM-126): читает who_am_i.maxDrones
+   * (личная настройка uiPrefs.swarm.maxDrones, дефолт 3). overmind капит им ВСЕ спавны —
+   * очередь (шаг 1), резолвер (шаг 2), авто-claim (шаг 5) — чтобы активных дронов не было
+   * больше числа из UI (инцидент 15.07: 4-6 дронов разом уронили ноут). who_am_i отдаёт
+   * плоский JSON в text-контенте (не {display,data}). Прод недоступен / нет валидного числа
+   * → null: ридер (makeMaxDronesReader) берёт env-фолбэк.
+   */
+  async ownerMaxDrones() {
+    let res;
+    try {
+      res = await this.call("who_am_i", {});
+    } catch {
+      return null;
+    }
+    if (res?.isError) return null;
+    const obj = jsonFromTextContent(res);
+    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", this.repoFullNames.length ? { repoFullNames: this.repoFullNames } : {});
+    } catch {
+    }
+  }
+  /**
+   * Встроенный надзор (TASWM-194): нотификация аномалии в инбокс владельца — прод-MCP
+   * `swarm_notify`, ПРЯМОЙ вызов (НЕ outbox): аномалия — «сообщи СЕЙЧАС», не durable-факт,
+   * который обязан пережить рестарт демона в неизменном порядке (как run-апдейты/события) —
+   * задержка на цикл outbox-флаша (обычно доли секунды, но в худшем случае — до
+   * восстановления сети) тут не оправдана.
+   * runId (локальный numeric) резолвим в прод-cuid по той же карте, что flush аутбокса
+   * (runKeyFor→prodIdByKey); прогон ещё не успел долететь до прода (cuid неизвестен) →
+   * шлём без runId (нотификация всё равно уйдёт, просто без SwarmEvent-вехи на прогоне).
+   *
+   * БРОСАЕТ при сбое (транспорт ИЛИ isError:true от тула) — НЕ глотает, в отличие от
+   * heartbeat() выше (code-review TASWM-194): вызывающий (overmind.ts tickOnce) коммитит
+   * AnomalyTracker ТОЛЬКО после успешного return — молча проглоченная ошибка означала бы,
+   * что трекер считает недоставленную нотификацию отправленной и молчит renotifyCooldownMs
+   * (по умолчанию час) без единой реальной попытки. `res?.isError` — тот же паттерн, что
+   * ownerMaxDrones() чуть выше: registerTool ловит throw внутри run() и превращает его в
+   * `{isError:true}`, а не в отклонённый промис — без этой проверки схемная/бизнес-ошибка
+   * тула (напр. TASWM-194 review: body > zod max) молча резолвилась бы успехом.
+   */
+  async notifyAnomaly(signal) {
+    const prodRunId = signal.runId != null ? this.prodIdByKey.get(this.runKeyFor(signal.runId) ?? "") : void 0;
+    const res = await this.call("swarm_notify", {
+      tag: signal.key,
+      title: signal.title,
+      body: signal.body,
+      ...signal.href ? { href: signal.href } : {},
+      ...prodRunId ? { runId: prodRunId } : {}
+    });
+    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;
+    const runKey = `p:${prodId}`;
+    this.prodIdByKey.set(runKey, prodId);
+    let local = [...this.runs.values()].find((r) => r.runKey === runKey);
+    if (!local) local = [...this.runs.values()].find((r) => this.prodIdByKey.get(r.runKey) === prodId);
+    if (!local) {
+      const id = this.nextRunId++;
+      local = {
+        id,
+        runKey,
+        task_slug: "",
+        name: `#${id}`,
+        kind: "drone",
+        hero_run_id: null,
+        repo: "",
+        branch: null,
+        status: "queued",
+        area: null,
+        depends_on: [],
+        model: null,
+        cost_usd: 0,
+        pr_url: null,
+        superseded_by: null,
+        decision: null,
+        stop_reason: null,
+        respawns: 0,
+        resolves_run_id: null,
+        reviews_run_id: null,
+        review_verdict: null,
+        task_title: null,
+        task_desc: null,
+        task_url: null,
+        created_at: stamp(),
+        updated_at: stamp()
+      };
+      this.runs.set(id, local);
+      this.keyByLocal.set(id, runKey);
+    }
+    const slug = pr.taskSlug ?? pr.task?.slug ?? pr.taskId ?? local.task_slug;
+    local.task_slug = slug || local.task_slug;
+    local.task_title = pr.taskTitle ?? local.task_title;
+    local.task_desc = pr.taskDesc ?? local.task_desc;
+    local.name = pr.droneName ?? local.name;
+    local.kind = pr.role ?? local.kind;
+    const heroProd = pr.heroId ?? null;
+    if (heroProd) local.hero_run_id = this.localIdForProdId(heroProd) ?? local.hero_run_id;
+    const resProd = pr.resolvesRunId ?? null;
+    if (resProd) local.resolves_run_id = this.localIdForProdId(resProd) ?? local.resolves_run_id;
+    const supProd = pr.supersededById ?? null;
+    if (supProd) local.superseded_by = this.localIdForProdId(supProd) ?? local.superseded_by;
+    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 = this.resolveRepo(pr.repo ?? null);
+    local.branch = pr.branch ?? null;
+    local.status = pr.status ?? local.status;
+    local.area = pr.area ?? null;
+    local.depends_on = Array.isArray(pr.dependsOn) ? pr.dependsOn : [];
+    local.model = pr.model ?? null;
+    local.cost_usd = typeof pr.costUsd === "number" ? pr.costUsd : 0;
+    local.pr_url = pr.prUrl ?? null;
+    local.stop_reason = pr.stopReason ?? null;
+    local.respawns = typeof pr.respawns === "number" ? pr.respawns : 0;
+    local.decision = parseDecision(pr.decision);
+    local.created_at = toStamp(pr.createdAt) ?? local.created_at;
+    local.updated_at = toStamp(pr.updatedAt) ?? local.updated_at;
+    const evs = pr.events ?? [];
+    for (const pe of evs) {
+      const eid = String(pe.id ?? "");
+      if (eid && this.seenProdEventIds.has(eid)) continue;
+      if (eid) this.seenProdEventIds.add(eid);
+      const kind = String(pe.kind ?? "");
+      const text = pe.text ?? null;
+      const at = toStamp(pe.at) ?? stamp();
+      if (kind === "question") {
+        this.questionsLog.push({
+          id: this.nextQuestionId++,
+          run_id: local.id,
+          text: text ?? "",
+          options: null,
+          status: "open",
+          answer: null,
+          answered_by: null,
+          escalated: false,
+          asked_at: at,
+          answered_at: null
+        });
+        continue;
+      }
+      const localKind = kind === "answer" ? "answered" : kind;
+      this.eventsLog.push({
+        id: this.nextEventId++,
+        run_id: local.id,
+        kind: localKind,
+        text,
+        actor: pe.actor ?? null,
+        at
+      });
+      if (kind === "answer" || kind === "answered") {
+        const open = [...this.questionsLog].reverse().find((q) => q.run_id === local.id && q.status === "open");
+        if (open) {
+          open.status = "answered";
+          open.answer = text;
+          open.answered_by = pe.actor ?? "human";
+          open.answered_at = at;
+        }
+      }
+    }
+    return local;
+  }
+  // ── flush outbox в прод ──────────────────────────────────────────────────────
+  scheduleFlush() {
+    if (!this.autoFlush || this.flushing || this.flushTimer || this.pending.length === 0) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      void this.flush();
+    }, this.backoffMs);
+    if (typeof this.flushTimer.unref === "function") this.flushTimer.unref();
+  }
+  // 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;
   }
-  push(laneEnd);
-  return segs;
-}
-function computeBlocker(status, stopReason, lastStep, pr, ci, deps, openQ) {
-  switch (status) {
-    case "queued": {
-      const unmet = deps.filter((d) => !d.met);
-      if (unmet.length) {
-        const who = unmet.map((d) => d.name ? `${d.slug}\xB7${d.name}` : d.slug).join(", ");
-        return { icon: "\u26D4", text: `\u0436\u0434\u0451\u0442 ${who}`, tone: "dep" };
+  async resolveArgs(e) {
+    if (e.t === "run") {
+      const fields = this.materializeRefs(e.fields);
+      const prodId2 = this.prodIdByKey.get(e.runKey);
+      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`);
       }
-      return { icon: "\u23F8", text: "\u0436\u0434\u0451\u0442 \u0441\u043B\u043E\u0442\u0430 / \u0441\u043F\u0430\u0432\u043D\u0430", tone: "queued" };
+      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 } };
     }
-    case "running":
-      return { icon: "\u25B6", text: lastStep ? `\u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442: ${lastStep}` : "\u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442", tone: "run" };
-    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: "blocked" };
-    case "review": {
-      if (!pr) return { icon: "\u{1F440}", text: "review \u0431\u0435\u0437 PR", tone: "review" };
-      if (!ci) return { icon: "\u23F3", text: "CI: \u0436\u0434\u0443 \u0441\u0442\u0430\u0442\u0443\u0441\u2026", tone: "review" };
-      if (ci.tone === "merge") return { icon: "\u{1F535}", text: "CI \u0437\u0435\u043B\u0451\u043D\u044B\u0439 \u2014 \u0436\u0434\u0451\u0442 \u043C\u0435\u0440\u0436\u0430", tone: "merge" };
-      return { icon: ci.tone === "fail" ? "\u274C" : "\u23F3", text: ci.text.replace(/^[^ ]+ /, ""), tone: ci.tone };
+    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";
     }
-    case "stalled":
-      return { icon: "\u26A0\uFE0F", text: stopReason || (lastStep ? `\u043C\u043E\u043B\u0447\u0438\u0442: ${lastStep}` : "\u043C\u043E\u043B\u0447\u0438\u0442"), tone: "stalled" };
-    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" };
-    case "done":
-      return { icon: "\u2705", text: "\u0441\u043C\u0435\u0440\u0436\u0435\u043D\u043E", tone: "done" };
-    default:
-      return { icon: "\u2022", text: status, tone: "queued" };
+    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`);
+    if (e.t === "event") return { tool: "swarm_event_append", args: { runId: prodId, kind: e.kind, text: e.text, actor: e.actor } };
+    return { tool: "swarm_ask", args: { runId: prodId, text: e.text } };
   }
-}
-function pickHeadline(lanes) {
-  const live = lanes.filter((l2) => l2.live && !l2.obsolete);
-  const by = (pred) => live.find(pred);
-  const fmt = (l2, extra) => `${l2.name} \xB7 ${l2.slug} \u2014 ${extra}`;
-  let l = by((x) => x.status === "review" && x.ci?.tone === "fail");
-  if (l) return { icon: "\u274C", text: fmt(l, "CI \u0443\u043F\u0430\u043B \u2014 \u0447\u0438\u043D\u0438\u0442\u044C"), tone: "fail" };
-  l = by((x) => x.status === "blocked");
-  if (l) return { icon: "\u2753", text: fmt(l, "\u0436\u0434\u0451\u0442 \u043E\u0442\u0432\u0435\u0442\u0430 \u043E\u043F\u0435\u0440\u0430\u0442\u043E\u0440\u0430"), tone: "blocked" };
-  l = by((x) => x.status === "stalled");
-  if (l) return { icon: "\u26A0\uFE0F", text: fmt(l, "stalled \u2014 \u043F\u0440\u043E\u0432\u0435\u0440\u0438\u0442\u044C \u0434\u0440\u043E\u043D\u0430"), tone: "stalled" };
-  l = by((x) => x.status === "review" && x.blocker.tone === "merge");
-  if (l) return { icon: "\u{1F535}", text: fmt(l, "CI \u0437\u0435\u043B\u0451\u043D\u044B\u0439 \u2014 \u0436\u0434\u0451\u0442 \u043C\u0435\u0440\u0436\u0430"), tone: "merge" };
-  l = by((x) => x.status === "queued" && x.dependsOn.some((d) => !d.met));
-  if (l) {
-    const dep = l.dependsOn.find((d) => !d.met);
-    return { icon: "\u26D4", text: fmt(l, `\u0436\u0434\u0451\u0442 ${dep.slug}${dep.name ? " \xB7 " + dep.name : ""}`), tone: "dep" };
+  // Резолв отложенных self-ref ({__runRef: runKey}) в прод-cuid на флаше. Цель уже
+  // создана в проде (её create-запись с меньшим seq флашится раньше) → cuid известен.
+  // Не резолвится (ещё не создан) — поле выкидываем: лучше не слать, чем слать мусор;
+  // догонит следующий апдейт/реконсайл. Обычные значения (null/строки) — как есть.
+  materializeRefs(fields) {
+    const out = {};
+    for (const [k, v] of Object.entries(fields)) {
+      if (isRunRef(v)) {
+        const cuid = this.prodIdByKey.get(v.__runRef);
+        if (cuid) out[k] = cuid;
+      } else {
+        out[k] = v;
+      }
+    }
+    return out;
+  }
+  /** Слить накопленное в прод. Возвращает число успешно отправленных операций.
+   *  Порядок сохраняется; ошибка/недоступность → стоп, буфер остаётся, retry-backoff. */
+  async flush() {
+    if (this.flushing) return 0;
+    this.flushing = true;
+    let sent = 0;
+    try {
+      while (this.pending.length) {
+        const e = this.pending[0];
+        let call;
+        try {
+          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);
+        } catch {
+          break;
+        }
+        if (res?.isError) break;
+        if (e.t === "run") {
+          const run = res.structuredContent?.run;
+          if (run?.id && this.prodIdByKey.get(e.runKey) !== run.id) {
+            this.prodIdByKey.set(e.runKey, run.id);
+            this.persistMap();
+          }
+        } else {
+          const evId = res.structuredContent?.event?.id;
+          if (evId) this.seenProdEventIds.add(evId);
+        }
+        this.pending.shift();
+        sent++;
+      }
+      this.persistPending();
+      if (this.pending.length === 0) {
+        this.backoffMs = _SwarmClient.BACKOFF_BASE;
+      } else {
+        this.backoffMs = Math.min(this.backoffMs * 2, _SwarmClient.BACKOFF_MAX);
+        this.scheduleFlush();
+      }
+    } finally {
+      this.flushing = false;
+    }
+    return sent;
+  }
+  persistPending() {
+    try {
+      writeFileSync2(this.outboxPath, this.pending.map((e) => JSON.stringify(e)).join("\n") + (this.pending.length ? "\n" : ""));
+    } catch {
+    }
+  }
+  persistMap() {
+    try {
+      writeFileSync2(this.mapPath, JSON.stringify(Object.fromEntries(this.prodIdByKey)));
+    } catch {
+    }
+  }
+  /** Незалитых операций в буфере (для тестов/наблюдаемости). */
+  pendingCount() {
+    return this.pending.length;
+  }
+  close() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    void this.flush();
+  }
+};
+function parseDecision(v) {
+  if (!v || typeof v !== "string") return null;
+  try {
+    return JSON.parse(v);
+  } catch {
+    return null;
   }
-  l = by((x) => x.status === "review");
-  if (l) return { icon: "\u23F3", text: fmt(l, "review \u2014 CI \u0438\u0434\u0451\u0442"), tone: "review" };
-  l = by((x) => x.status === "running");
-  if (l) return { icon: "\u25B6", text: `${live.filter((x) => x.status === "running").length} \u0434\u0440\u043E\u043D\u0430 \u0432 \u0440\u0430\u0431\u043E\u0442\u0435 \u2014 \u0431\u043B\u043E\u043A\u0438\u0440\u043E\u0432\u043E\u043A \u043D\u0435\u0442`, tone: "run" };
-  return null;
 }
 
-// ../swarm-core/src/status.ts
-var STATUS_META = {
-  queued: { pill: "queued", label: "\u0432 \u043E\u0447\u0435\u0440\u0435\u0434\u0438", color: "--muted-foreground" },
-  running: { pill: "run", label: "\u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442", color: "--primary" },
-  blocked: { pill: "blocked", label: "\u0436\u0434\u0451\u0442 \u043E\u0442\u0432\u0435\u0442\u0430", color: "--warning" },
-  paused: { pill: "paused", label: "\u0437\u0430\u043C\u0435\u0440", color: "--warning" },
-  // overmind был недоступен — ждёт пробуждения (TASWM-41)
-  review: { pill: "review", label: "\u043D\u0430 \u0440\u0435\u0432\u044C\u044E", color: "--info" },
-  done: { pill: "done", label: "\u0441\u043C\u0435\u0440\u0436\u0435\u043D\u043E", color: "--success" },
-  failed: { pill: "failed", label: "\u0443\u043F\u0430\u043B", color: "--destructive" },
-  stalled: { pill: "stalled", label: "\u043F\u043E\u0433\u0438\u0431/\u0437\u0430\u0432\u0438\u0441", color: "--destructive" },
-  storm_dead: { pill: "storm", label: "\u0448\u0442\u043E\u0440\u043C \u2014 \u0437\u0430\u043C\u043E\u0440\u043E\u0436\u0435\u043D", color: "--warning" },
-  // умер в шторм Anthropic, поднимется после отбоя (TASWM-23)
-  stopped: { pill: "stopped", label: "\u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D", color: "--muted-foreground" },
-  superseded: { pill: "superseded", label: "\u043F\u0435\u0440\u0435\u0438\u0433\u0440\u0430\u043D", color: "--muted-foreground" }
-};
-var FALLBACK = STATUS_META.queued;
+// 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";
+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;
@@ -971,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);
@@ -995,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;
@@ -1027,9 +2319,49 @@ async function collectRunDiff(worktree, opts = {}) {
   };
 }
 
+// src/gh.ts
+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);
+    const rows = JSON.parse(out);
+    if (!Array.isArray(rows) || rows.length === 0) return null;
+    return rows.map((r) => ({ name: r.name ?? "?", bucket: (r.bucket ?? "").toLowerCase(), link: r.link ?? "" }));
+  } catch {
+    return null;
+  }
+}
+async function ghChecks(pr, run = realChecksRunner) {
+  const rows = await prCheckRows(pr, run);
+  if (!rows) return null;
+  let pass = 0, fail = 0, pending2 = 0;
+  for (const r of rows) {
+    if (r.bucket === "pass") pass++;
+    else if (r.bucket === "fail" || r.bucket === "cancel") fail++;
+    else if (r.bucket === "pending") pending2++;
+  }
+  const total = rows.length;
+  let bucket, text, tone;
+  if (fail > 0) {
+    bucket = "fail";
+    tone = "fail";
+    text = `\u274C CI \u0443\u043F\u0430\u043B (${fail}/${total})`;
+  } else if (pending2 > 0) {
+    bucket = "pending";
+    tone = "review";
+    text = `\u23F3 CI \u0438\u0434\u0451\u0442 (${pass}/${total})`;
+  } else {
+    bucket = "pass";
+    tone = "merge";
+    text = `\u2705 CI \u0437\u0435\u043B\u0451\u043D\u044B\u0439 \u2014 \u043A \u043C\u0435\u0440\u0436\u0443`;
+  }
+  return { bucket, text, tone, total, pass, fail, pending: pending2 };
+}
+
 // src/oauth.ts
 import { createHash, randomBytes } from "crypto";
-import { readFileSync as readFileSync2, writeFileSync, unlinkSync } from "fs";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, unlinkSync } from "fs";
 import { join as join3 } from "path";
 var REGISTER = "/api/oauth/register";
 var AUTHORIZE = "/api/oauth/authorize";
@@ -1121,13 +2453,13 @@ function toStore(clientId, t, now) {
 }
 function loadStore() {
   try {
-    return JSON.parse(readFileSync2(STORE_PATH, "utf8"));
+    return JSON.parse(readFileSync4(STORE_PATH, "utf8"));
   } catch {
     return null;
   }
 }
 function saveStore(s) {
-  writeFileSync(STORE_PATH, JSON.stringify(s, null, 2), { mode: 384 });
+  writeFileSync3(STORE_PATH, JSON.stringify(s, null, 2), { mode: 384 });
 }
 function clearStore() {
   try {
@@ -1137,7 +2469,7 @@ function clearStore() {
 }
 function loadClientId() {
   try {
-    return JSON.parse(readFileSync2(CLIENT_PATH, "utf8")).clientId;
+    return JSON.parse(readFileSync4(CLIENT_PATH, "utf8")).clientId;
   } catch {
     return null;
   }
@@ -1146,7 +2478,7 @@ async function ensureClientId(api, redirectUri, fetchFn = fetch) {
   const existing = loadClientId();
   if (existing) return existing;
   const clientId = await registerClient({ api, redirectUri }, fetchFn);
-  writeFileSync(CLIENT_PATH, JSON.stringify({ clientId }, null, 2), { mode: 384 });
+  writeFileSync3(CLIENT_PATH, JSON.stringify({ clientId }, null, 2), { mode: 384 });
   return clientId;
 }
 async function ensureAccess(store, opts = {}) {
@@ -1168,13 +2500,11 @@ async function ensureAccess(store, opts = {}) {
 var esc = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
 var jsonForScript = (v) => JSON.stringify(v).replace(/</g, "\\u003c");
 var TASKLESS_MARK = `<svg viewBox="0 0 60 54" width="19" height="19" fill="none" aria-hidden="true" style="display:block"><g transform="matrix(1.0512,0,0,1.0512,0,-0.021)"><path fill="currentColor" fill-rule="nonzero" d="M46.92,0 L10.24,0 C4.59,0 0,4.59 0,10.24 L0,10.4 C0,16.05 4.59,20.64 10.24,20.64 L16.84,20.64 C19.56,20.64 22.12,19.59 24.05,17.67 L36.06,5.77 C37.25,4.6 38.82,3.95 40.49,3.95 L46.93,3.95 C50.4,3.95 53.22,6.77 53.22,10.24 L53.22,10.4 C53.22,13.87 50.4,16.69 46.93,16.69 L39.82,16.69 C37.05,16.69 34.36,17.83 32.44,19.83 L21.13,31.58 C19.28,33.5 18.27,36.02 18.27,38.68 L18.27,40.94 C18.27,46.59 22.86,51.18 28.51,51.18 C34.16,51.18 38.75,46.59 38.75,40.94 L38.75,20.74 C39.1,20.68 39.46,20.64 39.82,20.64 L46.93,20.64 C52.58,20.64 57.17,16.05 57.17,10.4 L57.17,10.24 C57.17,4.59 52.58,0 46.93,0 L46.92,0 Z M21.26,14.87 C20.07,16.04 18.5,16.69 16.83,16.69 L10.23,16.69 C6.76,16.69 3.94,13.87 3.94,10.4 L3.94,10.24 C3.94,6.77 6.76,3.95 10.23,3.95 L32.27,3.95 L21.25,14.87 L21.26,14.87 Z M34.79,40.94 C34.79,44.41 31.97,47.23 28.5,47.23 C25.03,47.23 22.21,44.41 22.21,40.94 L22.21,38.68 C22.21,37.05 22.83,35.5 23.97,34.32 L34.79,23.07 L34.79,40.94 L34.79,40.94 Z"/></g></svg>`;
-var DAY_MS = 24 * 60 * 60 * 1e3;
-var sqliteMs = (ts) => Date.parse(ts.replace(" ", "T") + "Z");
 var sqliteIso = (ts) => {
   const ms = sqliteMs(ts);
   return Number.isNaN(ms) ? ts : new Date(ms).toISOString();
 };
-function roySnapshot(db2, now = Date.now()) {
+function roySnapshot(db2, now = Date.now(), overmindLog = []) {
   const all = db2.listRuns();
   const c = (s) => all.filter((r) => r.status === s).length;
   const withQ = new Set(db2.runIdsWithQuestions());
@@ -1244,13 +2574,15 @@ function roySnapshot(db2, now = Date.now()) {
       active: db2.stormActive(),
       since: db2.currentStormStartedAt(),
       dead: all.filter((r) => r.status === "storm_dead").length
-    }
+    },
+    overmindLog
   };
 }
-var TL_RECENT_TERMINAL_MS = Number(process.env.ROY_WINDOW_H || 5) * 36e5;
-var TL_MAX_TERMINAL_LANES = Number(process.env.ROY_MAX_DONE || 6);
-var TL_MAX_AXIS_MS = Number(process.env.ROY_AXIS_H || 6) * 36e5;
-var TL_TERMINAL = /* @__PURE__ */ new Set(["done", "failed", "stopped", "superseded"]);
+var {
+  windowMs: TL_RECENT_TERMINAL_MS,
+  maxTerminalLanes: TL_MAX_TERMINAL_LANES,
+  maxAxisMs: TL_MAX_AXIS_MS
+} = resolveRoyWindows(process.env);
 var ciCache = /* @__PURE__ */ new Map();
 var CI_TTL = 2e4;
 var CI_MOCK = (() => {
@@ -1266,50 +2598,18 @@ function mockCi(bucket) {
   if (b === "pending") return { bucket: "pending", tone: "review", text: "\u23F3 CI \u0438\u0434\u0451\u0442 (1/2)", total: 2, pass: 1, fail: 0, pending: 1 };
   return { bucket: "pass", tone: "merge", text: "\u2705 CI \u0437\u0435\u043B\u0451\u043D\u044B\u0439 \u2014 \u043A \u043C\u0435\u0440\u0436\u0443", total: 2, pass: 2, fail: 0, pending: 0 };
 }
-async function ghChecks(pr) {
-  try {
-    const { stdout: out } = await $2({ reject: false, timeout: 15e3 })`gh pr checks ${pr} --json state,name,bucket,link`;
-    const rows = JSON.parse(out);
-    if (!Array.isArray(rows) || rows.length === 0) return null;
-    let pass = 0, fail = 0, pending2 = 0;
-    for (const r of rows) {
-      const b = (r.bucket || "").toLowerCase();
-      if (b === "pass") pass++;
-      else if (b === "fail" || b === "cancel") fail++;
-      else if (b === "pending") pending2++;
-    }
-    const total = rows.length;
-    let bucket, text, tone;
-    if (fail > 0) {
-      bucket = "fail";
-      tone = "fail";
-      text = `\u274C CI \u0443\u043F\u0430\u043B (${fail}/${total})`;
-    } else if (pending2 > 0) {
-      bucket = "pending";
-      tone = "review";
-      text = `\u23F3 CI \u0438\u0434\u0451\u0442 (${pass}/${total})`;
-    } else {
-      bucket = "pass";
-      tone = "merge";
-      text = `\u2705 CI \u0437\u0435\u043B\u0451\u043D\u044B\u0439 \u2014 \u043A \u043C\u0435\u0440\u0436\u0443`;
-    }
-    return { bucket, text, tone, total, pass, fail, pending: pending2 };
-  } catch {
-    return null;
-  }
-}
 async function refreshCI(prs) {
   await Promise.all(prs.map(async (pr) => {
     const ci = await ghChecks(pr);
     ciCache.set(pr, { ci, at: Date.now() });
   }));
 }
-function timelineState(db2, now = Date.now()) {
+function timelineState(db2, now = Date.now(), overmindLog = []) {
   const runs = db2.listRuns().slice().sort((a, b) => a.id - b.id);
   const doneNameBySlug = /* @__PURE__ */ new Map();
   const activeBySlug = /* @__PURE__ */ new Map();
   for (const r of runs) {
-    if (!TL_TERMINAL.has(r.status)) activeBySlug.set(r.task_slug, { id: r.id, name: r.name });
+    if (!isTerminalStatus(r.status)) activeBySlug.set(r.task_slug, { id: r.id, name: r.name });
     if (r.status === "done") doneNameBySlug.set(r.task_slug, r.name);
   }
   const openQ = /* @__PURE__ */ new Map();
@@ -1319,7 +2619,7 @@ function timelineState(db2, now = Date.now()) {
   const lanes = [];
   const reviewPRs = [];
   for (const r of runs) {
-    const live = !TL_TERMINAL.has(r.status);
+    const live = !isTerminalStatus(r.status);
     const recencyGated = !live || r.status === "stalled";
     if (recencyGated && sqliteMs(r.updated_at) < cutoff) continue;
     const events = db2.events(r.id).map((e) => ({ kind: e.kind, text: e.text ?? null, at: sqliteIso(e.at) }));
@@ -1347,7 +2647,7 @@ function timelineState(db2, now = Date.now()) {
       id: r.id,
       name: r.name,
       slug: r.task_slug,
-      repo: basename(r.repo || "") || "?",
+      repo: basename2(r.repo || "") || "?",
       status: r.status,
       area: r.area,
       start: sqliteIso(r.created_at),
@@ -1361,7 +2661,11 @@ function timelineState(db2, now = Date.now()) {
       ci,
       pr: r.pr_url,
       dependsOn: deps,
-      cost: r.cost_usd || 0
+      cost: r.cost_usd || 0,
+      role: r.kind,
+      heroRunId: r.hero_run_id,
+      reviewVerdict: r.review_verdict,
+      model: r.model
     });
   }
   const liveLanes = lanes.filter((l) => l.live);
@@ -1391,7 +2695,7 @@ function timelineState(db2, now = Date.now()) {
   const headline = pickHeadline(shown);
   const stale = [...new Set(reviewPRs)].filter((pr) => now - (ciCache.get(pr)?.at ?? 0) > CI_TTL);
   if (stale.length) void refreshCI(stale);
-  return { now: nowIso, axisStart, axisEnd: nowIso, counters: c, headline, lanes: shown };
+  return { now: nowIso, axisStart, axisEnd: nowIso, counters: c, headline, lanes: shown, overmindLog };
 }
 var CSS = `
 :root {
@@ -1529,7 +2833,7 @@ main { max-width: 1080px; margin: 0 auto; width: 100%; }
 .pill .sd { width: 6px; height: 6px; border-radius: 50%; background: currentColor; }
 .pill.run { color: var(--primary); background: var(--primary-soft); } .pill.run .sd { animation: pulse 1.8s infinite; }
 .pill.review { color: var(--info); background: color-mix(in oklch, var(--info) 14%, transparent); }
-.pill.blocked { color: var(--warning); background: color-mix(in oklch, var(--warning) 15%, transparent); }
+.pill.blocked, .pill.paused, .pill.storm { color: var(--warning); background: color-mix(in oklch, var(--warning) 15%, transparent); }
 .pill.done { color: var(--success); background: color-mix(in oklch, var(--success) 13%, transparent); }
 .pill.stalled, .pill.failed { color: var(--destructive); background: color-mix(in oklch, var(--destructive) 14%, transparent); }
 .pill.stopped, .pill.queued, .pill.superseded { color: var(--muted-foreground); background: var(--secondary); }
@@ -1822,9 +3126,11 @@ var GLYPH = {
   hex:'<path d="M12 2l8 4.6v9.2L12 21l-8-5.2V6.6L12 2z" stroke="currentColor" stroke-width="1.6" fill="none" stroke-linejoin="round"/><circle cx="12" cy="12" r="2" fill="currentColor"/>'
 };
 var GK = ['claw','spore','eye','hex'];
-var ST = { running:['run','\u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442','--primary'], review:['review','\u043D\u0430 \u0440\u0435\u0432\u044C\u044E','--info'], blocked:['blocked','\u0436\u0434\u0451\u0442 \u043E\u0442\u0432\u0435\u0442\u0430','--warning'], paused:['blocked','\u0437\u0430\u043C\u0435\u0440 \u2014 \u0436\u0434\u0451\u0442 overmind','--warning'], storm_dead:['blocked','\u0432 \u043A\u043E\u043A\u043E\u043D\u0435 (\u0448\u0442\u043E\u0440\u043C)','--warning'], done:['done','\u0441\u043C\u0435\u0440\u0436\u0435\u043D\u043E','--success'], stalled:['stalled','\u043F\u043E\u0433\u0438\u0431/\u0437\u0430\u0432\u0438\u0441','--destructive'], failed:['failed','\u0443\u043F\u0430\u043B','--destructive'], stopped:['stopped','\u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D','--muted-foreground'], queued:['queued','\u0432 \u043E\u0447\u0435\u0440\u0435\u0434\u0438','--muted-foreground'], superseded:['superseded','\u043F\u0435\u0440\u0435\u0438\u0433\u0440\u0430\u043D','--muted-foreground'] };
+/* \u041A\u0430\u0440\u0442\u0430 \u0441\u0442\u0430\u0442\u0443\u0441\u2192[pill,label,color] \u0438 \u0442\u0435\u0440\u043C\u0438\u043D\u0430\u043B\u044C\u043D\u043E\u0441\u0442\u044C \u2014 \u0438\u0437 swarm-core (statusTuples/
+   TERMINAL_STATUSES), \u0430 \u043D\u0435 \u0445\u0430\u0440\u0434\u043A\u043E\u0434-\u043A\u043E\u043F\u0438\u044F (\u043E\u043D\u0430 \u0443\u0436\u0435 \u0440\u0430\u0441\u0445\u043E\u0434\u0438\u043B\u0430\u0441\u044C: paused/storm_dead). */
+var ST = ${jsonForScript(statusTuples())};
 var ORDER = { running:0, blocked:1, paused:2, storm_dead:3, review:4, stalled:5, queued:6, stopped:7, done:8, failed:9, superseded:10 };
-var TERM = { done:1, stopped:1, failed:1, superseded:1 };
+var TERM = ${jsonForScript(Object.fromEntries(TERMINAL_STATUSES.map((s) => [s, 1])))};
 var EVL = { spawned:'\u0434\u0440\u043E\u043D \u0437\u0430\u043F\u0443\u0449\u0435\u043D', step:'', blocked:'\u0432\u043E\u043F\u0440\u043E\u0441 \u043E\u043F\u0435\u0440\u0430\u0442\u043E\u0440\u0443', answered:'\u043F\u043E\u043B\u0443\u0447\u0435\u043D \u043E\u0442\u0432\u0435\u0442', pr_opened:'PR \u043E\u0442\u043A\u0440\u044B\u0442', merged:'PR \u0441\u043C\u0435\u0440\u0436\u0451\u043D, \u0437\u0430\u0434\u0430\u0447\u0430 \u0437\u0430\u043A\u0440\u044B\u0442\u0430', done:'\u0433\u043E\u0442\u043E\u0432\u043E', failed:'\u0434\u0440\u043E\u043D \u0443\u043F\u0430\u043B', stalled:'\u0434\u0440\u043E\u043D \u0437\u0430\u0432\u0438\u0441/\u043F\u043E\u0433\u0438\u0431', respawned:'\u0430\u0432\u0442\u043E-\u043E\u0436\u0438\u0432\u043B\u0435\u043D\u0438\u0435', paused:'\u0437\u0430\u043C\u0435\u0440 \u2014 overmind \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D', resumed:'overmind \u0432\u0435\u0440\u043D\u0443\u043B\u0441\u044F \u2014 \u0440\u0430\u0437\u0431\u0443\u0434\u0438\u043B', rescued:'worktree \u0441\u043E\u0445\u0440\u0430\u043D\u0451\u043D \u2014 \u0437\u0430\u0431\u0435\u0440\u0438 \u0440\u0443\u043A\u0430\u043C\u0438', conflict:'\u043A\u043E\u043D\u0444\u043B\u0438\u043A\u0442 \u0441 main (merge-main-in)', died:'\u0434\u0440\u043E\u043D \u0443\u043C\u0435\u0440', storm_start:'\u26A1 \u043F\u0441\u0438\u043E\u043D\u043D\u0430\u044F \u0441\u0432\u044F\u0437\u044C \u043F\u043E\u0442\u0435\u0440\u044F\u043D\u0430 \u2014 Anthropic \u0448\u0442\u043E\u0440\u043C\u0438\u0442', storm_end:'\u0441\u0432\u044F\u0437\u044C \u0432\u043E\u0441\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\u0430 \u2014 \u0440\u043E\u0439 \u043F\u0440\u043E\u0431\u0443\u0436\u0434\u0430\u0435\u0442\u0441\u044F', storm_dead:'\u0434\u0440\u043E\u043D \u0432 \u043A\u043E\u043A\u043E\u043D\u0435 (\u0448\u0442\u043E\u0440\u043C)', stopped:'\u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D', superseded:'\u043F\u0435\u0440\u0435\u0438\u0433\u0440\u0430\u043D' };
 var MDOT = { merged:'--success', done:'--success', pr_opened:'--info', spawned:'--muted-foreground', stalled:'--destructive', failed:'--destructive', respawned:'--warning', paused:'--warning', resumed:'--success', rescued:'--destructive', conflict:'--warning', died:'--destructive', storm_start:'--destructive', storm_end:'--success', storm_dead:'--warning', stopped:'--muted-foreground', superseded:'--muted-foreground' };
 
@@ -1857,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';
@@ -2326,14 +3632,15 @@ async function runDiff(db2, id, now = Date.now()) {
   diffCache.set(id, { at: now, payload });
   return payload;
 }
-function eventsStream(db2) {
+var readNarratorLog = (log) => log?.() ?? [];
+function eventsStream(db2, narratorLog) {
   let iv;
   let last = "";
   const stream = new ReadableStream({
     start(controller) {
       const enc = new TextEncoder();
       const send = () => {
-        const snap = JSON.stringify(roySnapshot(db2));
+        const snap = JSON.stringify(roySnapshot(db2, Date.now(), readNarratorLog(narratorLog)));
         if (snap === last) return;
         last = snap;
         try {
@@ -2367,11 +3674,11 @@ function makeHandler(deps) {
     const p = url.pathname;
     if (p === "/") {
       const store = auth();
-      return html(store ? renderDashboard(store.email, roySnapshot(deps.db), taskUrlBase) : renderLogin());
+      return html(store ? renderDashboard(store.email, roySnapshot(deps.db, Date.now(), readNarratorLog(deps.narratorLog)), taskUrlBase) : renderLogin());
     }
-    if (p === "/events") return eventsStream(deps.db);
-    if (p === "/state") return Response.json(roySnapshot(deps.db));
-    if (p === "/timeline") return Response.json(timelineState(deps.db));
+    if (p === "/events") return eventsStream(deps.db, deps.narratorLog);
+    if (p === "/state") return Response.json(roySnapshot(deps.db, Date.now(), readNarratorLog(deps.narratorLog)));
+    if (p === "/timeline") return Response.json(timelineState(deps.db, Date.now(), readNarratorLog(deps.narratorLog)));
     const diffMatch = p.match(/^\/run\/(\d+)\/diff$/);
     if (diffMatch) {
       if (!auth()) return unauthorized();
@@ -2449,39 +3756,106 @@ function makeHandler(deps) {
 function startWeb(deps, port = WEB_PORT) {
   const handle = makeHandler(deps);
   const server = serve({ fetch: handle, port, hostname: "127.0.0.1" });
+  server.on("error", (err) => {
+    const e = err;
+    if (e.code === "EADDRINUSE") {
+      console.error(`\u043F\u043E\u0440\u0442 ${port} \u0437\u0430\u043D\u044F\u0442 \u2014 \u043F\u043E\u0445\u043E\u0436\u0435, overmind \u0443\u0436\u0435 \u0437\u0430\u043F\u0443\u0449\u0435\u043D (\u0432\u0435\u0431-\u043C\u043E\u0440\u0434\u0430: http://127.0.0.1:${port}).`);
+    } else {
+      console.error(`\u0432\u0435\u0431-\u043C\u043E\u0440\u0434\u0430 \u043D\u0435 \u043F\u043E\u0434\u043D\u044F\u043B\u0430\u0441\u044C: ${e.message}`);
+    }
+    process.exit(1);
+  });
   return { port, server };
 }
 
 // src/cli.ts
-import { cancelRun, respawnRun, OVERMIND_ENTRY } from "./overmind.js";
+import { cancelRun, respawnRun, runDaemon, OVERMIND_ENTRY, listDroneProcesses } from "./overmind.js";
 
 // src/launcher.ts
 import { spawn } from "child_process";
-import { readdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { closeSync, existsSync as existsSync3, mkdirSync as mkdirSync3, openSync, readdirSync, statSync as statSync2, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join4 } from "path";
-function claudeArgs(cfgPath, prompt, continueSession = false) {
-  const base2 = ["--dangerously-skip-permissions", "--mcp-config", cfgPath, "-p", prompt];
-  return continueSession ? ["--continue", ...base2] : base2;
+var ISOLATION_FLAGS = ["--setting-sources", "project", "--strict-mcp-config"];
+function claudeArgs(cfgPath, prompt, continueSession = false, model, pluginDirs = []) {
+  const pluginFlags = pluginDirs.flatMap((dir) => ["--plugin-dir", dir]);
+  const base2 = [
+    "--dangerously-skip-permissions",
+    ...ISOLATION_FLAGS,
+    "--mcp-config",
+    cfgPath,
+    ...pluginFlags,
+    "--output-format",
+    "json",
+    "-p",
+    prompt
+  ];
+  const withModel = model ? ["--model", model, ...base2] : base2;
+  return continueSession ? ["--continue", ...withModel] : withModel;
+}
+function roleDir(worktree, kind) {
+  return join4(worktree, ".claude", "roles", kind);
+}
+function nextRunLogPath(runLogsDir, runId) {
+  const dir = join4(runLogsDir, String(runId));
+  mkdirSync3(dir, { recursive: true });
+  let files = [];
+  try {
+    files = readdirSync(dir);
+  } catch {
+  }
+  let next = 0;
+  for (const f of files) {
+    const m = /^(\d+)\.json/.exec(f);
+    if (m) next = Math.max(next, Number(m[1]) + 1);
+  }
+  return join4(dir, `${next}.json`);
+}
+function openNextRunLog(runLogsDir, runId) {
+  for (let attempt = 0; attempt < 50; attempt++) {
+    try {
+      return openSync(nextRunLogPath(runLogsDir, runId), "wx");
+    } catch (e) {
+      if (e.code !== "EEXIST") throw e;
+    }
+  }
+  throw new Error(`\u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043D\u0430\u0439\u0442\u0438 \u0441\u0432\u043E\u0431\u043E\u0434\u043D\u044B\u0439 run-log \u0444\u0430\u0439\u043B \u0434\u043B\u044F \u043F\u0440\u043E\u0433\u043E\u043D\u0430 #${runId} (\u0433\u043E\u043D\u043A\u0430?)`);
 }
 function makeLauncher(cfg) {
   return ({ worktree, run, prompt, continueSession }) => {
+    const isCompiled = cfg.overmindEntry.endsWith(".js");
+    if (!isCompiled && !cfg.overmindEntry.endsWith(".ts")) {
+      throw new Error(`overmindEntry \u043D\u0438 .ts, \u043D\u0438 .js: ${cfg.overmindEntry}`);
+    }
     const mcpConfig = {
       mcpServers: {
         overmind: {
-          command: "bun",
-          args: ["run", cfg.overmindEntry, "--drone", "--run", String(run.id)],
-          env: { SWARM_DB: cfg.dbPath }
+          command: isCompiled ? process.execPath : "bun",
+          args: isCompiled ? [cfg.overmindEntry, "--drone", "--run", String(run.id)] : ["run", cfg.overmindEntry, "--drone", "--run", String(run.id)],
+          // 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 }
         }
       }
     };
     const cfgPath = join4(worktree, ".swarm-mcp.json");
-    writeFileSync2(cfgPath, JSON.stringify(mcpConfig, null, 2));
-    const child = spawn(cfg.claudeBin ?? "claude", claudeArgs(cfgPath, prompt, continueSession), {
+    writeFileSync4(cfgPath, JSON.stringify(mcpConfig, null, 2));
+    const model = run.model ?? process.env.SWARM_DRONE_MODEL ?? void 0;
+    const dir = roleDir(worktree, run.kind);
+    const pluginDirs = existsSync3(dir) ? [dir] : [];
+    let stdio = "ignore";
+    let outFd;
+    if (cfg.runLogsDir) {
+      outFd = openNextRunLog(cfg.runLogsDir, run.id);
+      stdio = ["ignore", outFd, "ignore"];
+    }
+    const child = spawn(cfg.claudeBin ?? "claude", claudeArgs(cfgPath, prompt, continueSession, model, pluginDirs), {
       cwd: worktree,
       detached: true,
-      stdio: "ignore"
+      stdio
     });
+    if (outFd !== void 0) closeSync(outFd);
     child.unref();
     if (child.pid == null) throw new Error("\u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0437\u0430\u043F\u0443\u0441\u0442\u0438\u0442\u044C \u0434\u0440\u043E\u043D\u0430 (\u043D\u0435\u0442 pid)");
     return child.pid;
@@ -2489,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
@@ -2501,19 +3996,19 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 
 // src/workspace.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2 } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, unlinkSync as unlinkSync2 } from "fs";
 import { join as join5 } from "path";
 var WORKSPACE_PATH = join5(SWARM_HOME, "workspace.json");
 function loadWorkspace() {
   try {
-    const w = JSON.parse(readFileSync3(WORKSPACE_PATH, "utf8"));
+    const w = JSON.parse(readFileSync5(WORKSPACE_PATH, "utf8"));
     return w && typeof w.id === "string" && w.id ? w : null;
   } catch {
     return null;
   }
 }
 function saveWorkspace(w) {
-  writeFileSync3(WORKSPACE_PATH, JSON.stringify(w, null, 2), { mode: 384 });
+  writeFileSync5(WORKSPACE_PATH, JSON.stringify(w, null, 2), { mode: 384 });
 }
 function clearWorkspace() {
   try {
@@ -2543,7 +4038,7 @@ async function connectSwarmMcp(cfg) {
   }
   if (!token) token = TASKLESS_TOKEN;
   if (!token) return null;
-  const url = new URL(`${api.replace(/\/$/, "")}/api/mcp`);
+  const url = new URL(mcpEndpoint(api));
   const transport = new StreamableHTTPClientTransport(url, {
     requestInit: { headers: { Authorization: `Bearer ${token}` } }
   });
@@ -2633,7 +4128,189 @@ async function openBrowser(url) {
   }
 }
 
+// src/screenshot.ts
+var DESKTOP_VIEWPORT = { name: "desktop", width: 1360, height: 940 };
+var MOBILE_VIEWPORT = { name: "mobile", width: 390, height: 844 };
+var DEFAULT_VIEWPORTS = [DESKTOP_VIEWPORT, MOBILE_VIEWPORT];
+var DEFAULT_SHOT_TIMEOUT_MS = 2e4;
+async function captureScreenshots(launchBrowser, opts) {
+  const viewports = opts.viewports ?? DEFAULT_VIEWPORTS;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_SHOT_TIMEOUT_MS;
+  const fullPage = opts.fullPage ?? true;
+  const browser = await launchBrowser();
+  try {
+    const results = [];
+    for (const vp of viewports) {
+      const ctx = await browser.newContext({
+        viewport: { width: vp.width, height: vp.height },
+        ...opts.storageStatePath ? { storageState: opts.storageStatePath } : {}
+      });
+      try {
+        const page = await ctx.newPage();
+        await page.goto(opts.url, { timeout: timeoutMs, waitUntil: "load" });
+        const path = `${opts.outPrefix}-${vp.name}.png`;
+        await page.screenshot({ path, fullPage, timeout: timeoutMs });
+        results.push({ viewport: vp.name, path });
+      } finally {
+        await ctx.close();
+      }
+    }
+    return results;
+  } finally {
+    await browser.close();
+  }
+}
+async function launchChromium(opts = {}) {
+  let mod;
+  try {
+    mod = await import("playwright-core");
+  } catch {
+    throw new Error(
+      "playwright-core \u043D\u0435 \u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D. \u0423\u0441\u0442\u0430\u043D\u043E\u0432\u0438 \u043E\u0434\u0438\u043D \u0440\u0430\u0437: (\u0432 \u044D\u0442\u043E\u043C \u043C\u043E\u043D\u043E\u0440\u0435\u043F\u043E) pnpm --filter @taskless-app/swarm add -D playwright-core; (\u043E\u0442\u0434\u0435\u043B\u044C\u043D\u043E) npm i -D playwright-core \u2014 \u0438 \u0432 \u043E\u0431\u043E\u0438\u0445 \u0441\u043B\u0443\u0447\u0430\u044F\u0445 npx playwright install chromium."
+    );
+  }
+  return mod.chromium.launch({ headless: true, ...opts.timeoutMs !== void 0 ? { timeout: opts.timeoutMs } : {} });
+}
+
+// src/shotCli.ts
+function isFlagValue(v) {
+  return v !== void 0 && !v.startsWith("--");
+}
+function parseShotArgs(argv) {
+  const url = argv[0];
+  const outPrefix = argv[1];
+  if (!url || !outPrefix) return null;
+  let timeoutMs = SWARM_SHOT_TIMEOUT_MS;
+  let storageStatePath = null;
+  for (let i = 2; i < argv.length; i++) {
+    if (argv[i] === "--timeout" && isFlagValue(argv[i + 1])) {
+      const n = Number(argv[i + 1]);
+      if (Number.isFinite(n) && n >= 0) timeoutMs = n;
+      i++;
+    } else if (argv[i] === "--storage-state" && isFlagValue(argv[i + 1])) {
+      storageStatePath = argv[i + 1];
+      i++;
+    }
+  }
+  return { url, outPrefix, timeoutMs, storageStatePath };
+}
+var VIEWPORTS_COUNT = DEFAULT_VIEWPORTS.length;
+var LAUNCH_BUDGET_MS = 15e3;
+async function runShotCli(argv, deps = {}) {
+  const log = deps.log ?? ((l) => console.log(l));
+  const error = deps.error ?? ((l) => console.error(l));
+  const args = parseShotArgs(argv);
+  if (!args) {
+    error("\u043D\u0443\u0436\u043D\u043E: swarm shot <url> <out-prefix> [--timeout <ms>] [--storage-state <path>]");
+    return 1;
+  }
+  const launchBudgetMs = deps.launchBudgetMs ?? LAUNCH_BUDGET_MS;
+  const launched = { browser: null };
+  const trackedLaunch = async () => {
+    const launch = deps.launchBrowser ?? (() => launchChromium({ timeoutMs: launchBudgetMs }));
+    const browser = await launch();
+    launched.browser = browser;
+    return browser;
+  };
+  const budgetMs = args.timeoutMs * VIEWPORTS_COUNT + launchBudgetMs;
+  let timer;
+  const watchdog = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`watchdog ${budgetMs}\u043C\u0441 \u0438\u0441\u0442\u0451\u043A \u2014 \u0447\u0442\u043E-\u0442\u043E \u0437\u0430\u0432\u0438\u0441\u043B\u043E \u0432\u043D\u0435 per-viewport \u0442\u0430\u0439\u043C\u0430\u0443\u0442\u0430`)),
+      budgetMs
+    );
+  });
+  try {
+    const results = await Promise.race([
+      captureScreenshots(trackedLaunch, {
+        url: args.url,
+        outPrefix: args.outPrefix,
+        timeoutMs: args.timeoutMs,
+        storageStatePath: args.storageStatePath
+      }),
+      watchdog
+    ]);
+    for (const r of results) log(`${r.viewport} \u2192 ${r.path}`);
+    return 0;
+  } catch (e) {
+    error(`swarm shot: ${e instanceof Error ? e.message : String(e)}`);
+    return 1;
+  } finally {
+    clearTimeout(timer);
+    await launched.browser?.close().catch(() => {
+    });
+  }
+}
+
+// package.json
+var package_default = {
+  name: "@taskless-app/swarm",
+  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: [
+    "ai-agents",
+    "coding-agents",
+    "swarm",
+    "orchestration",
+    "autonomous-agents",
+    "mcp",
+    "taskless",
+    "cli"
+  ],
+  license: "SEE LICENSE IN LICENSE",
+  author: "Ilya Smurov <ilya@smurov.com>",
+  homepage: "https://github.com/ilyasmurov/taskless/tree/main/packages/swarm-daemon#readme",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/ilyasmurov/taskless.git",
+    directory: "packages/swarm-daemon"
+  },
+  engines: {
+    node: ">=22"
+  },
+  bin: {
+    swarm: "dist/cli.js"
+  },
+  files: [
+    "dist",
+    "docs/HERO.md"
+  ],
+  scripts: {
+    overmind: 'NODE_OPTIONS="${NODE_OPTIONS:-} --conditions=development" tsx src/overmind.ts',
+    swarm: 'NODE_OPTIONS="${NODE_OPTIONS:-} --conditions=development" tsx src/cli.ts',
+    build: "tsup",
+    start: "node dist/overmind.js",
+    prepublishOnly: "pnpm run build",
+    test: "vitest run && SWARM_TEST_BACKEND=client vitest run src/overmind.test.ts src/overmind.storm.test.ts src/db.storm.test.ts",
+    "test:client": "SWARM_TEST_BACKEND=client vitest run src/overmind.test.ts src/overmind.storm.test.ts src/db.storm.test.ts",
+    "test:watch": "vitest",
+    typecheck: "tsc -p tsconfig.json --noEmit",
+    lint: "echo 'no lint in swarm-daemon yet'"
+  },
+  dependencies: {
+    "@hono/node-server": "^2.0.10",
+    "@modelcontextprotocol/sdk": "^1.29.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.13",
+    "@types/node": "22.10.5",
+    "playwright-core": "1.49.1",
+    tsup: "^8.5.1",
+    tsx: "4.19.2",
+    typescript: "5.7.3",
+    vitest: "2.1.8"
+  }
+};
+
 // src/cli.ts
+var PACKAGE_VERSION = package_default.version;
 function takeRepo(argv) {
   const i = argv.indexOf("--repo");
   if (i === -1) return { repo: null, rest: argv };
@@ -2687,7 +4364,7 @@ async function runLogin(db2, opts) {
         loadStore,
         beforeToken: null,
         now: Date.now,
-        sleep,
+        sleep: sleep2,
         timeoutMs: 5 * 6e4,
         pollMs: 1e3
       });
@@ -2716,7 +4393,7 @@ async function runLogin(db2, opts) {
     if (!chosen) return 1;
     saveWorkspace(toWorkspaceSel(chosen));
     console.log(`\u0432\u043E\u0440\u043A\u0441\u043F\u0435\u0439\u0441: ${chosen.name} (${chosen.slug}) \u2192 ${SWARM_HOME}/workspace.json`);
-    console.log("\u0433\u043E\u0442\u043E\u0432\u043E. \u0414\u0435\u043C\u043E\u043D \u0432 \u0442\u043E\u043D\u043A\u043E\u043C \u043A\u043B\u0438\u0435\u043D\u0442\u0435: SWARM_BACKEND=client pnpm --filter @taskless/swarm-daemon start");
+    console.log("\u0433\u043E\u0442\u043E\u0432\u043E. \u041F\u043E\u0434\u043D\u044F\u0442\u044C \u0434\u0435\u043C\u043E\u043D\u0430: swarm start --repo <\u043F\u0443\u0442\u044C \u043A \u0440\u0435\u043F\u043E>");
     return 0;
   } finally {
     web.server.close();
@@ -2737,14 +4414,16 @@ var STATUS_MARK = {
 function fmtRun(r) {
   const mark = STATUS_MARK[r.status] ?? "?";
   const area = r.area ? ` [${r.area}]` : "";
-  const repo = r.repo ? ` (${basename2(r.repo)})` : "";
+  const repo = r.repo ? ` (${basename3(r.repo)})` : "";
   const q = r.status === "blocked" ? "  \u2190 \u0436\u0434\u0451\u0442 \u043E\u0442\u0432\u0435\u0442\u0430" : "";
   const why = r.status === "stopped" && r.stop_reason ? `  \u2014 ${r.stop_reason}` : "";
   return `${mark} #${r.id} ${r.name}  ${r.task_slug}${repo}${area}  ${r.status}${q}${why}`;
 }
 function usage() {
-  console.log(`swarm \u2014 \u0440\u043E\u0439 \u0434\u0440\u043E\u043D\u043E\u0432
+  console.log(`swarm \u2014 \u0440\u043E\u0439 \u0434\u0440\u043E\u043D\u043E\u0432 (v${PACKAGE_VERSION})
 
+  swarm login [--workspace <slug|id>] [--no-open]  \u0432\u0445\u043E\u0434 \u0432 \u043F\u0440\u043E\u0434 + \u0432\u044B\u0431\u043E\u0440 \u0432\u043E\u0440\u043A\u0441\u043F\u0435\u0439\u0441\u0430
+  swarm start [--repo <path>]  \u043F\u043E\u0434\u043D\u044F\u0442\u044C \u0434\u0435\u043C\u043E\u043D\u0430: \u0440\u0430\u0437\u0431\u0438\u0440\u0430\u0435\u0442 \u043E\u0447\u0435\u0440\u0435\u0434\u044C, \u0441\u043F\u0430\u0432\u043D\u0438\u0442/\u0431\u0443\u0434\u0438\u0442 \u0434\u0440\u043E\u043D\u043E\u0432
   swarm ls [status]        \u0441\u043F\u0438\u0441\u043E\u043A \u043F\u0440\u043E\u0433\u043E\u043D\u043E\u0432 (\u043E\u043F\u0446. \u0444\u0438\u043B\u044C\u0442\u0440 \u043F\u043E \u0441\u0442\u0430\u0442\u0443\u0441\u0443)
   swarm spawn <slug> [area] [--repo <path>] [--after <s1,s2>]  \u0432 \u043E\u0447\u0435\u0440\u0435\u0434\u044C (--after \u2192 \u0436\u0434\u0430\u0442\u044C done \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0435\u0439)
   swarm spawn <slug> --hero [--name HYDRA] [--repo <path>] [--after <s1,s2>]  \u0413\u0435\u0440\u043E\u0439-\u043B\u0435\u0439\u0442\u0435\u043D\u0430\u043D\u0442 \u044D\u043F\u0438\u043A\u0430
@@ -2754,14 +4433,98 @@ function usage() {
   swarm cancel <slug> <\u043F\u0440\u0438\u0447\u0438\u043D\u0430\u2026>  \u043E\u0441\u0442\u0430\u043D\u043E\u0432\u0438\u0442\u044C \u0434\u0440\u043E\u043D\u0430 (\u0441\u0442\u0430\u0442\u0443\u0441 \xAB\u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\xBB + \u043F\u0440\u0438\u0447\u0438\u043D\u0430; \u0432 \u0438\u0441\u0442\u043E\u0440\u0438\u0438 \u043E\u0441\u0442\u0430\u0451\u0442\u0441\u044F)
   swarm import-db <path> --repo <path>  \u0438\u043C\u043F\u043E\u0440\u0442 \u0438\u0441\u0442\u043E\u0440\u0438\u0438 \u0438\u0437 \u0434\u0440\u0443\u0433\u043E\u0439 \u0411\u0414 (\u0438\u0434\u0435\u043C\u043F\u043E\u0442\u0435\u043D\u0442\u043D\u043E)
   swarm log <runId>        \u043B\u043E\u0433 \u043F\u0440\u043E\u0433\u043E\u043D\u0430
-  swarm login [--workspace <slug|id>] [--no-open]  \u0432\u0445\u043E\u0434 \u0432 \u043F\u0440\u043E\u0434 + \u0432\u044B\u0431\u043E\u0440 \u0432\u043E\u0440\u043A\u0441\u043F\u0435\u0439\u0441\u0430
   swarm logout             \u0437\u0430\u0431\u044B\u0442\u044C \u0442\u043E\u043A\u0435\u043D\u044B \u0438 \u0432\u044B\u0431\u043E\u0440 \u0432\u043E\u0440\u043A\u0441\u043F\u0435\u0439\u0441\u0430
   swarm whoami             \u043A\u0442\u043E \u0432\u043E\u0448\u0451\u043B \u0438 \u0432 \u043A\u0430\u043A\u043E\u043C \u0432\u043E\u0440\u043A\u0441\u043F\u0435\u0439\u0441\u0435
   swarm web                \u0432\u0435\u0431-\u043C\u043E\u0440\u0434\u0430 (\u0432\u0445\u043E\u0434 + \u0441\u0442\u0430\u0442\u0443\u0441) \u043D\u0430 127.0.0.1
+  swarm shot <url> <out-prefix> [--timeout <ms>] [--storage-state <path>]
+                           headless-\u0441\u043A\u0440\u0438\u043D desktop+mobile \u041E\u0414\u041D\u041E\u0419 \u043A\u043E\u043C\u0430\u043D\u0434\u043E\u0439 (TASWM-40):
+                           <out-prefix>-desktop.png, <out-prefix>-mobile.png
+  swarm --version          \u0432\u0435\u0440\u0441\u0438\u044F \u043F\u0430\u043A\u0435\u0442\u0430
 `);
 }
-var db = new SwarmDb(DB_PATH, SWARM_REPO);
+async function makeCliStore(repo) {
+  if (SWARM_BACKEND !== "client") return new SwarmDb(DB_PATH, repo);
+  const failing = async () => ({ isError: true });
+  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;
+}
+async function finishClient(db2) {
+  if (!(db2 instanceof SwarmClient)) return;
+  await db2.flush();
+  db2.close();
+  process.exit(0);
+}
 var [cmd, ...rawArgs] = process.argv.slice(2);
+if (cmd === "--version" || cmd === "-v") {
+  console.log(PACKAGE_VERSION);
+  process.exit(0);
+}
+if (cmd === "logout") {
+  clearStore();
+  clearWorkspace();
+  console.log("\u0432\u044B\u0448\u0435\u043B: \u0443\u0434\u0430\u043B\u0435\u043D\u044B oauth.json \u0438 workspace.json (DCR-\u043A\u043B\u0438\u0435\u043D\u0442 \u043E\u0441\u0442\u0430\u0432\u043B\u0435\u043D \u0434\u043B\u044F \u0441\u043B\u0435\u0434. \u0432\u0445\u043E\u0434\u0430).");
+  process.exit(0);
+}
+if (cmd === "whoami") {
+  const store = loadStore();
+  if (!store) {
+    console.log("\u043D\u0435 \u0432 \u0441\u0435\u0441\u0441\u0438\u0438. \u0412\u043E\u0439\u0442\u0438: swarm login");
+    process.exit(0);
+  }
+  const ws = loadWorkspace();
+  console.log(`\u0432\u043E\u0448\u0451\u043B \u043A\u0430\u043A ${store.email ?? "?"}`);
+  console.log(
+    ws ? `\u0432\u043E\u0440\u043A\u0441\u043F\u0435\u0439\u0441: ${ws.name ?? ws.slug ?? ws.id} (${ws.slug ?? ws.id})` : "\u0432\u043E\u0440\u043A\u0441\u043F\u0435\u0439\u0441: \u043D\u0435 \u0432\u044B\u0431\u0440\u0430\u043D (\u0441\u0435\u0440\u0432\u0435\u0440 \u043F\u0440\u0438\u043C\u0435\u043D\u0438\u0442 \u0444\u043E\u043B\u0431\u044D\u043A) \u2014 \u0432\u044B\u0431\u0435\u0440\u0438: swarm login"
+  );
+  process.exit(0);
+}
+if (cmd === "import-db") {
+  const { repo: repoFlag, rest: args } = takeRepo(rawArgs);
+  const path = args[0];
+  const repo = repoFlag ?? SWARM_REPO;
+  if (!path || !repo) {
+    console.error("\u043D\u0443\u0436\u043D\u043E: swarm import-db <path> --repo <path>");
+    process.exit(1);
+  }
+  const sdb = new SwarmDb(DB_PATH, repo);
+  const res = sdb.importDb(path, repo);
+  if (res.imported) console.log(`\u0438\u043C\u043F\u043E\u0440\u0442\u0438\u0440\u043E\u0432\u0430\u043D\u043E ${res.runs} \u043F\u0440\u043E\u0433\u043E\u043D\u043E\u0432 \u0438\u0437 ${path} (repo=${repo})`);
+  else console.log(`${path} \u0443\u0436\u0435 \u0438\u043C\u043F\u043E\u0440\u0442\u0438\u0440\u043E\u0432\u0430\u043D \u0440\u0430\u043D\u0435\u0435 (${res.runs} \u043F\u0440\u043E\u0433\u043E\u043D\u043E\u0432) \u2014 no-op`);
+  sdb.close();
+  process.exit(0);
+}
+if (cmd === "start") {
+  if (SWARM_BACKEND !== "client") {
+    console.warn("SWARM_BACKEND=client \u043D\u0435 \u0437\u0430\u0434\u0430\u043D \u2014 \u0434\u0435\u043C\u043E\u043D \u043F\u043E\u0434\u043D\u0438\u043C\u0435\u0442\u0441\u044F \u0432 \u043B\u043E\u043A\u0430\u043B\u044C\u043D\u043E\u043C sqlite-\u0440\u0435\u0436\u0438\u043C\u0435, \u0411\u0415\u0417 \u0441\u0432\u044F\u0437\u0438 \u0441 \u0432\u043E\u0440\u043A\u0441\u043F\u0435\u0439\u0441\u043E\u043C Taskless (\u043D\u0435 \u0443\u0432\u0438\u0434\u0438\u0442 \u0437\u0430\u0434\u0430\u0447\u0438, \u043D\u0435 \u043F\u043E\u0448\u043B\u0451\u0442 \u043F\u0443\u043B\u044C\u0441).");
+  }
+  const { repo: repoFlag } = takeRepo(rawArgs);
+  const repo = repoFlag ?? SWARM_REPO;
+  if (!repo) {
+    console.warn("SWARM_REPO \u043D\u0435 \u0437\u0430\u0434\u0430\u043D \u2014 \u043F\u0440\u043E\u0433\u043E\u043D\u044B \u0431\u0435\u0437 \u044F\u0432\u043D\u043E\u0433\u043E repo \u043D\u0435 \u0437\u0430\u043F\u0443\u0441\u0442\u044F\u0442\u0441\u044F (\u043D\u0443\u0436\u0435\u043D spawn --repo).");
+  }
+  try {
+    await runDaemon({ repo });
+  } catch (e) {
+    console.error(`\u0434\u0435\u043C\u043E\u043D \u043D\u0435 \u043F\u043E\u0434\u043D\u044F\u043B\u0441\u044F: ${e instanceof Error ? e.message : e}`);
+    process.exit(1);
+  }
+  process.exit(0);
+}
+if (cmd === "shot") {
+  const code = await runShotCli(rawArgs);
+  process.exit(code);
+}
+if (!cmd || cmd === "--help" || cmd === "-h") {
+  usage();
+  process.exit(0);
+}
+var db = await makeCliStore(SWARM_REPO);
 switch (cmd) {
   case "ls": {
     const runs = db.listRuns(rawArgs[0]);
@@ -2812,7 +4575,7 @@ switch (cmd) {
       console.error(`\u043F\u0440\u043E\u0433\u043E\u043D #${runId} \u0443\u0436\u0435 \u0437\u0430\u043F\u0443\u0449\u0435\u043D (running) \u2014 \u0431\u0443\u0434\u0438\u0442\u044C \u043D\u0435\u0447\u0435\u0433\u043E`);
       process.exit(1);
     }
-    const launch = makeLauncher({ overmindEntry: OVERMIND_ENTRY, dbPath: DB_PATH });
+    const launch = makeLauncher({ overmindEntry: OVERMIND_ENTRY, dbPath: DB_PATH, runLogsDir: RUN_LOGS_DIR });
     await respawnRun(
       { db, launch, repoFallback: SWARM_REPO, worktreesDir: WORKTREES_DIR, getTask: () => Promise.resolve(null) },
       run,
@@ -2821,19 +4584,6 @@ switch (cmd) {
     console.log(`\u0440\u0430\u0437\u0431\u0443\u0436\u0435\u043D (--continue): ${fmtRun(db.getRun(runId))}`);
     break;
   }
-  case "import-db": {
-    const { repo: repoFlag, rest: args } = takeRepo(rawArgs);
-    const path = args[0];
-    const repo = repoFlag ?? SWARM_REPO;
-    if (!path || !repo) {
-      console.error("\u043D\u0443\u0436\u043D\u043E: swarm import-db <path> --repo <path>");
-      process.exit(1);
-    }
-    const res = db.importDb(path, repo);
-    if (res.imported) console.log(`\u0438\u043C\u043F\u043E\u0440\u0442\u0438\u0440\u043E\u0432\u0430\u043D\u043E ${res.runs} \u043F\u0440\u043E\u0433\u043E\u043D\u043E\u0432 \u0438\u0437 ${path} (repo=${repo})`);
-    else console.log(`${path} \u0443\u0436\u0435 \u0438\u043C\u043F\u043E\u0440\u0442\u0438\u0440\u043E\u0432\u0430\u043D \u0440\u0430\u043D\u0435\u0435 (${res.runs} \u043F\u0440\u043E\u0433\u043E\u043D\u043E\u0432) \u2014 no-op`);
-    break;
-  }
   case "questions": {
     const qs = db.openQuestions();
     if (qs.length === 0) console.log("\u043E\u0442\u043A\u0440\u044B\u0442\u044B\u0445 \u0432\u043E\u043F\u0440\u043E\u0441\u043E\u0432 \u043D\u0435\u0442");
@@ -2887,7 +4637,7 @@ switch (cmd) {
       process.exit(1);
     }
     const run = db.getRun(runId);
-    if (run) console.log(`#${run.id} ${run.name}  ${run.task_slug}${run.repo ? ` (${basename2(run.repo)})` : ""}`);
+    if (run) console.log(`#${run.id} ${run.name}  ${run.task_slug}${run.repo ? ` (${basename3(run.repo)})` : ""}`);
     const events = db.events(runId);
     if (events.length === 0) console.log("\u0441\u043E\u0431\u044B\u0442\u0438\u0439 \u043D\u0435\u0442");
     else events.forEach((e) => console.log(`${e.at}  ${e.kind}${e.text ? "  " + e.text : ""}`));
@@ -2900,25 +4650,6 @@ switch (cmd) {
     db.close();
     process.exit(code);
   }
-  case "logout": {
-    clearStore();
-    clearWorkspace();
-    console.log("\u0432\u044B\u0448\u0435\u043B: \u0443\u0434\u0430\u043B\u0435\u043D\u044B oauth.json \u0438 workspace.json (DCR-\u043A\u043B\u0438\u0435\u043D\u0442 \u043E\u0441\u0442\u0430\u0432\u043B\u0435\u043D \u0434\u043B\u044F \u0441\u043B\u0435\u0434. \u0432\u0445\u043E\u0434\u0430).");
-    break;
-  }
-  case "whoami": {
-    const store = loadStore();
-    if (!store) {
-      console.log("\u043D\u0435 \u0432 \u0441\u0435\u0441\u0441\u0438\u0438. \u0412\u043E\u0439\u0442\u0438: swarm login");
-      break;
-    }
-    const ws = loadWorkspace();
-    console.log(`\u0432\u043E\u0448\u0451\u043B \u043A\u0430\u043A ${store.email ?? "?"}`);
-    console.log(
-      ws ? `\u0432\u043E\u0440\u043A\u0441\u043F\u0435\u0439\u0441: ${ws.name ?? ws.slug ?? ws.id} (${ws.slug ?? ws.id})` : "\u0432\u043E\u0440\u043A\u0441\u043F\u0435\u0439\u0441: \u043D\u0435 \u0432\u044B\u0431\u0440\u0430\u043D (\u0441\u0435\u0440\u0432\u0435\u0440 \u043F\u0440\u0438\u043C\u0435\u043D\u0438\u0442 \u0444\u043E\u043B\u0431\u044D\u043A) \u2014 \u0432\u044B\u0431\u0435\u0440\u0438: swarm login"
-    );
-    break;
-  }
   case "web": {
     const web = startWeb({ db });
     console.log(`\u0432\u0435\u0431-\u043C\u043E\u0440\u0434\u0430: http://127.0.0.1:${web.port}  \u2190 \u043E\u0442\u043A\u0440\u043E\u0439 \u0438 \u0432\u043E\u0439\u0434\u0438 \u0447\u0435\u0440\u0435\u0437 Taskless`);
@@ -2929,4 +4660,5 @@ switch (cmd) {
   default:
     usage();
 }
+await finishClient(db);
 db.close();