@taskless-app/swarm 0.4.9 → 0.5.0

package/dist/overmind.js

@@ -397,9 +397,14 @@ var init_windows = __esm({
 });
 
 // ../swarm-core/src/slug.ts
+function isTaskSlug(s) {
+  return !!s && TASK_SLUG_RE.test(s);
+}
+var TASK_SLUG_RE;
 var init_slug = __esm({
   "../swarm-core/src/slug.ts"() {
     "use strict";
+    TASK_SLUG_RE = /^(?:[A-Za-z0-9]{1,8}-\d+|#[A-Za-z0-9]{4,})$/;
   }
 });
 
@@ -419,14 +424,20 @@ function extractText(d) {
 function sanitizeEventText(text) {
   if (text == null) return null;
   const cleaned = text.replace(ANSI_CSI_RE, "").replace(CONTROL_CHARS_RE, " ").replace(/ {2,}/g, " ").trim();
-  return cleaned.length ? cleaned : null;
+  if (!cleaned.length) return null;
+  return cleaned.length <= EVENT_TEXT_MAX ? cleaned : clampEventText(cleaned);
+}
+function clampEventText(text) {
+  const note = ` \u2026 (\u043E\u0431\u0440\u0435\u0437\u0430\u043D\u043E, \u0431\u044B\u043B\u043E ${text.length} \u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432)`;
+  return text.slice(0, Math.max(0, EVENT_TEXT_MAX - note.length)) + note;
 }
-var ANSI_CSI_RE, CONTROL_CHARS_RE;
+var ANSI_CSI_RE, CONTROL_CHARS_RE, EVENT_TEXT_MAX;
 var init_text = __esm({
   "../swarm-core/src/text.ts"() {
     "use strict";
     ANSI_CSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
     CONTROL_CHARS_RE = /[\x00-\x1f\x7f]/g;
+    EVENT_TEXT_MAX = 16e3;
   }
 });
 
@@ -709,6 +720,50 @@ var init_hosts = __esm({
   }
 });
 
+// ../swarm-core/src/hostCommands.ts
+function isHostCommandKind(v) {
+  return typeof v === "string" && HOST_COMMAND_KINDS.includes(v);
+}
+function isHostCommandExpired(expiresAt, nowMs) {
+  if (!expiresAt) return false;
+  const at = Date.parse(expiresAt);
+  return Number.isFinite(at) && at <= nowMs;
+}
+function hostCommandLabel(cmd) {
+  const base3 = HOST_COMMAND_LABELS[cmd.kind];
+  if (cmd.kind === "set_max_drones" && cmd.maxDrones != null) return `${base3} \u2192 ${cmd.maxDrones}`;
+  if (cmd.kind === "stop_run" && cmd.runSlug) return `${base3} ${cmd.runSlug}`;
+  return base3;
+}
+var HOST_COMMAND_KINDS, HOST_COMMAND_STATUSES, TERMINAL, HOST_COMMAND_OPEN_STATUSES, UPDATE_STEP_LABELS, HOST_COMMAND_TTL_MS, HOST_COMMAND_KEEPALIVE_MS, HOST_COMMAND_LABELS, MAX_DRONES_LIMIT;
+var init_hostCommands = __esm({
+  "../swarm-core/src/hostCommands.ts"() {
+    "use strict";
+    HOST_COMMAND_KINDS = ["pause", "resume", "restart", "update", "set_max_drones", "stop_run"];
+    HOST_COMMAND_STATUSES = ["pending", "delivered", "running", "done", "failed", "rejected", "expired"];
+    TERMINAL = /* @__PURE__ */ new Set(["done", "failed", "rejected", "expired"]);
+    HOST_COMMAND_OPEN_STATUSES = HOST_COMMAND_STATUSES.filter((s) => !TERMINAL.has(s));
+    UPDATE_STEP_LABELS = {
+      fetch: "\u0442\u044F\u043D\u0443 \u0441\u0432\u0435\u0436\u0438\u0439 \u043A\u043E\u0434",
+      checkout: "\u043F\u0435\u0440\u0435\u043A\u043B\u044E\u0447\u0430\u044E\u0441\u044C \u043D\u0430 \u0441\u0432\u0435\u0436\u0438\u0439 main",
+      install: "\u0441\u0442\u0430\u0432\u043B\u044E \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0438",
+      build: "\u0441\u043E\u0431\u0438\u0440\u0430\u044E \u043F\u0430\u043A\u0435\u0442\u044B \u0432\u043E\u0440\u043A\u0441\u043F\u0435\u0439\u0441\u0430",
+      restart: "\u043F\u0435\u0440\u0435\u0437\u0430\u043F\u0443\u0441\u043A\u0430\u044E\u0441\u044C"
+    };
+    HOST_COMMAND_TTL_MS = 30 * 6e4;
+    HOST_COMMAND_KEEPALIVE_MS = 10 * 6e4;
+    HOST_COMMAND_LABELS = {
+      pause: "\u043F\u0430\u0443\u0437\u0430",
+      resume: "\u043F\u0440\u043E\u0434\u043E\u043B\u0436\u0438\u0442\u044C",
+      restart: "\u043F\u0435\u0440\u0435\u0437\u0430\u043F\u0443\u0441\u043A",
+      update: "\u043E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u0435 \u0434\u043E \u0441\u0432\u0435\u0436\u0435\u0433\u043E \u043A\u043E\u0434\u0430",
+      set_max_drones: "\u0441\u043C\u0435\u043D\u0430 \u0447\u0438\u0441\u043B\u0430 \u0434\u0440\u043E\u043D\u043E\u0432",
+      stop_run: "\u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043A\u0430 \u043F\u0440\u043E\u0433\u043E\u043D\u0430"
+    };
+    MAX_DRONES_LIMIT = 8;
+  }
+});
+
 // ../swarm-core/src/relief.ts
 var RELIEF_PAUSE_MARK;
 var init_relief = __esm({
@@ -735,6 +790,7 @@ var init_src = __esm({
     init_names();
     init_baseBranch();
     init_hosts();
+    init_hostCommands();
     init_relief();
   }
 });
@@ -742,6 +798,9 @@ var init_src = __esm({
 // src/config.ts
 var config_exports = {};
 __export(config_exports, {
+  DAEMON_LOG_CHECK_MS: () => DAEMON_LOG_CHECK_MS,
+  DAEMON_LOG_KEEP: () => DAEMON_LOG_KEEP,
+  DAEMON_LOG_MAX_BYTES: () => DAEMON_LOG_MAX_BYTES,
   DAEMON_LOG_PATH: () => DAEMON_LOG_PATH,
   DB_PATH: () => DB_PATH,
   DRONE_CHANNEL_ENABLED: () => DRONE_CHANNEL_ENABLED,
@@ -754,6 +813,7 @@ __export(config_exports, {
   DRONE_ISOLATION: () => DRONE_ISOLATION,
   HEARTBEAT_PATH: () => HEARTBEAT_PATH,
   HEARTBEAT_STALE_MS: () => HEARTBEAT_STALE_MS,
+  REPO_MAP_PATH: () => REPO_MAP_PATH,
   REVIEW_CUTOFF_PATH: () => REVIEW_CUTOFF_PATH,
   RUN_LOGS_DIR: () => RUN_LOGS_DIR,
   SWARM_ANOMALY_FAILED_SPIKE_COUNT: () => SWARM_ANOMALY_FAILED_SPIKE_COUNT,
@@ -791,9 +851,11 @@ __export(config_exports, {
   SWARM_RELIEF_MAX_FD_LOAD_FACTOR: () => SWARM_RELIEF_MAX_FD_LOAD_FACTOR,
   SWARM_RELIEF_MIN_FREE_GB: () => SWARM_RELIEF_MIN_FREE_GB,
   SWARM_REPO: () => SWARM_REPO,
+  SWARM_REPO_MAP_MS: () => SWARM_REPO_MAP_MS,
   SWARM_REPO_PATHS: () => SWARM_REPO_PATHS,
   SWARM_REVIEW_CAP: () => SWARM_REVIEW_CAP,
   SWARM_SCAN_DEPTH: () => SWARM_SCAN_DEPTH,
+  SWARM_SCAN_ROOTS_RAW: () => SWARM_SCAN_ROOTS_RAW,
   SWARM_SHOT_TIMEOUT_MS: () => SWARM_SHOT_TIMEOUT_MS,
   SWARM_STORM_URL: () => SWARM_STORM_URL,
   SWARM_SWEEP_INTERVAL_MS: () => SWARM_SWEEP_INTERVAL_MS,
@@ -893,7 +955,7 @@ function reviewCutoffAt() {
   }
   return at;
 }
-var SWARM_HOME, DB_PATH, DRONE_HOME, DRONE_HOME_ISOLATION, DRONE_ISOLATION, WORKTREES_NOINDEX_DIR, WORKTREES_LEGACY_DIR, WORKTREES_DIR, RUN_LOGS_DIR, DAEMON_LOG_PATH, DIST_BUILD, SWARM_BACKEND, SWARM_OUTBOX, SWARM_MAX_IN_FLIGHT, SWARM_CLAIM_INTERVAL_MS, SWARM_MAX_LOAD_FACTOR, SWARM_MIN_FREE_GB, SWARM_MAX_FD_LOAD_FACTOR, SWARM_MAX_CPU_BUSY, SWARM_RELIEF_LOAD_FACTOR, SWARM_RELIEF_MIN_FREE_GB, SWARM_RELIEF_MAX_FD_LOAD_FACTOR, SWARM_RELIEF_CPU_BUSY, SWARM_RELIEF_COST_WINDOW_MS, SWARM_RELIEF_ALERT_PAUSES, SWARM_RELIEF_ALERT_LOST_MS, SWARM_RELIEF_ALERT_MIN_STEPS, SWARM_RELIEF_ALERT_SUSTAIN_MS, SWARM_LOW_DISK_GB, SWARM_REHYDRATE_MS, SWARM_DRONE_BRIDGE_MS, SWARM_PROD_HEARTBEAT_MS, SWARM_VERSION_CHECK_MS, SWARM_SWEEP_INTERVAL_MS, DRONE_CHANNEL_ENABLED, DRONE_CHANNEL_PORT, DRONE_CHANNEL_URL, DRONE_CHANNEL_SECRET_PATH, DRONE_CHANNEL_GRACE_MS, HEARTBEAT_PATH, HEARTBEAT_STALE_MS, SWARM_REPO, SWARM_SCAN_DEPTH, SWARM_REPO_PATHS, TASKLESS_API, SWARM_SHOT_TIMEOUT_MS, TASKLESS_MCP_PATH, TASKLESS_TOKEN, TASKLESS_WORKSPACE, TASKLESS_WORKSPACE_SLUG, TASKLESS_TASK_URL_BASE, SWARM_VERIFY, SWARM_AUTO_REVIEW, REVIEW_CUTOFF_PATH, SWARM_REVIEW_CAP, SWARM_STORM_URL, WEB_PORT, WEB_REDIRECT_URI, SWARM_ANOMALY_RENOTIFY_MS, SWARM_ANOMALY_MAX_REPEATS, SWARM_ANOMALY_RUN_DOWN_WINDOW_MS, SWARM_ANOMALY_FAILED_SPIKE_COUNT, SWARM_ANOMALY_FAILED_SPIKE_WINDOW_MS, SWARM_ANOMALY_QUEUE_STALLED_MS, SWARM_ANOMALY_PR_STUCK_MERGE_MS, SWARM_ANOMALY_PR_NO_REVIEWER_MS, SWARM_ANOMALY_QUESTION_UNANSWERED_MS, SWARM_ANOMALY_OUTBOX_STUCK_MS, SWARM_ANOMALY_RESOURCE_GATE_STALL_MS, SWARM_WATCHDOG_STALL_MS;
+var SWARM_HOME, DB_PATH, DRONE_HOME, DRONE_HOME_ISOLATION, DRONE_ISOLATION, WORKTREES_NOINDEX_DIR, WORKTREES_LEGACY_DIR, WORKTREES_DIR, RUN_LOGS_DIR, DAEMON_LOG_PATH, DAEMON_LOG_MAX_BYTES, DAEMON_LOG_KEEP, DAEMON_LOG_CHECK_MS, DIST_BUILD, SWARM_BACKEND, SWARM_OUTBOX, SWARM_MAX_IN_FLIGHT, SWARM_CLAIM_INTERVAL_MS, SWARM_MAX_LOAD_FACTOR, SWARM_MIN_FREE_GB, SWARM_MAX_FD_LOAD_FACTOR, SWARM_MAX_CPU_BUSY, SWARM_RELIEF_LOAD_FACTOR, SWARM_RELIEF_MIN_FREE_GB, SWARM_RELIEF_MAX_FD_LOAD_FACTOR, SWARM_RELIEF_CPU_BUSY, SWARM_RELIEF_COST_WINDOW_MS, SWARM_RELIEF_ALERT_PAUSES, SWARM_RELIEF_ALERT_LOST_MS, SWARM_RELIEF_ALERT_MIN_STEPS, SWARM_RELIEF_ALERT_SUSTAIN_MS, SWARM_LOW_DISK_GB, SWARM_REHYDRATE_MS, SWARM_DRONE_BRIDGE_MS, SWARM_PROD_HEARTBEAT_MS, SWARM_VERSION_CHECK_MS, SWARM_SWEEP_INTERVAL_MS, DRONE_CHANNEL_ENABLED, DRONE_CHANNEL_PORT, DRONE_CHANNEL_URL, DRONE_CHANNEL_SECRET_PATH, DRONE_CHANNEL_GRACE_MS, HEARTBEAT_PATH, HEARTBEAT_STALE_MS, SWARM_REPO, SWARM_SCAN_DEPTH, SWARM_REPO_PATHS, SWARM_SCAN_ROOTS_RAW, REPO_MAP_PATH, SWARM_REPO_MAP_MS, TASKLESS_API, SWARM_SHOT_TIMEOUT_MS, TASKLESS_MCP_PATH, TASKLESS_TOKEN, TASKLESS_WORKSPACE, TASKLESS_WORKSPACE_SLUG, TASKLESS_TASK_URL_BASE, SWARM_VERIFY, SWARM_AUTO_REVIEW, REVIEW_CUTOFF_PATH, SWARM_REVIEW_CAP, SWARM_STORM_URL, WEB_PORT, WEB_REDIRECT_URI, SWARM_ANOMALY_RENOTIFY_MS, SWARM_ANOMALY_MAX_REPEATS, SWARM_ANOMALY_RUN_DOWN_WINDOW_MS, SWARM_ANOMALY_FAILED_SPIKE_COUNT, SWARM_ANOMALY_FAILED_SPIKE_WINDOW_MS, SWARM_ANOMALY_QUEUE_STALLED_MS, SWARM_ANOMALY_PR_STUCK_MERGE_MS, SWARM_ANOMALY_PR_NO_REVIEWER_MS, SWARM_ANOMALY_QUESTION_UNANSWERED_MS, SWARM_ANOMALY_OUTBOX_STUCK_MS, SWARM_ANOMALY_RESOURCE_GATE_STALL_MS, SWARM_WATCHDOG_STALL_MS;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
@@ -909,6 +971,9 @@ var init_config = __esm({
     WORKTREES_DIR = process.env.SWARM_WORKTREES || WORKTREES_NOINDEX_DIR;
     RUN_LOGS_DIR = process.env.SWARM_RUN_LOGS || join2(SWARM_HOME, "run-logs");
     DAEMON_LOG_PATH = process.env.SWARM_DAEMON_LOG || join2(SWARM_HOME, "overmind.log");
+    DAEMON_LOG_MAX_BYTES = envNum("SWARM_DAEMON_LOG_MAX_BYTES", 16 * 1024 * 1024);
+    DAEMON_LOG_KEEP = envNum("SWARM_DAEMON_LOG_KEEP", 2);
+    DAEMON_LOG_CHECK_MS = envNum("SWARM_DAEMON_LOG_CHECK_MS", 6e4);
     DIST_BUILD = true;
     SWARM_BACKEND = process.env.SWARM_BACKEND === "client" ? "client" : process.env.SWARM_BACKEND === "sqlite" ? "sqlite" : DIST_BUILD ? "client" : "sqlite";
     SWARM_OUTBOX = process.env.SWARM_OUTBOX || join2(SWARM_HOME, "outbox.jsonl");
@@ -943,6 +1008,9 @@ var init_config = __esm({
     SWARM_REPO = process.env.SWARM_REPO || "";
     SWARM_SCAN_DEPTH = Number(process.env.SWARM_SCAN_DEPTH) || 3;
     SWARM_REPO_PATHS = (process.env.SWARM_REPOS || SWARM_REPO).split(",").map((s) => s.trim()).filter(Boolean);
+    SWARM_SCAN_ROOTS_RAW = process.env.SWARM_SCAN_ROOTS || "";
+    REPO_MAP_PATH = process.env.SWARM_REPO_MAP || join2(SWARM_HOME, "repo-map.json");
+    SWARM_REPO_MAP_MS = envNum("SWARM_REPO_MAP_MS", 15 * 6e4);
     TASKLESS_API = process.env.TASKLESS_API || "https://taskless.ru";
     SWARM_SHOT_TIMEOUT_MS = envNum("SWARM_SHOT_TIMEOUT_MS", 2e4);
     TASKLESS_MCP_PATH = process.env.TASKLESS_MCP_PATH || "/api/mcp";
@@ -1435,7 +1503,7 @@ var init_procList = __esm({
 
 // src/procCleanup.ts
 function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 function parseLsofCwd(output) {
   const rows = [];
@@ -1498,8 +1566,8 @@ function pathUnderInCmd(cmd, dir) {
     if (before && !/["'\s=;]/.test(before)) continue;
     const after = hay.slice(at + needle.length);
     if (after && !after.startsWith("/")) continue;
-    const tail = after.match(/^(?:\/[^"';]*)?/)[0];
-    return needle + tail;
+    const tail2 = after.match(/^(?:\/[^"';]*)?/)[0];
+    return needle + tail2;
   }
   return null;
 }
@@ -1653,16 +1721,16 @@ var init_procCleanup = __esm({
 });
 
 // src/git.ts
-import { existsSync as existsSync7, readdirSync as readdirSync8, statSync as statSync5 } from "fs";
+import { existsSync as existsSync8, readdirSync as readdirSync8, statSync as statSync6 } from "fs";
 import { appendFile, mkdir, readFile, rm } from "fs/promises";
-import { isAbsolute, join as join11 } from "path";
+import { isAbsolute as isAbsolute2, join as join12 } from "path";
 import { $ as $2 } from "execa";
 async function reclaimStaleWorktree(repo, worktree) {
   await detachWorktree(repo, worktree);
 }
 function isLinkedWorktree(dir) {
   try {
-    return statSync5(join11(dir, ".git")).isFile();
+    return statSync6(join12(dir, ".git")).isFile();
   } catch {
     return false;
   }
@@ -1674,7 +1742,7 @@ async function detachWorktree(repo, worktree) {
   }
 }
 async function ensureWorktreeDirGone(worktree) {
-  if (!existsSync7(worktree)) return false;
+  if (!existsSync8(worktree)) return false;
   if (!isLinkedWorktree(worktree)) {
     console.error(
       `[git] ${worktree} \u2014 \u043D\u0435 \u043F\u0440\u0438\u0441\u0442\u0451\u0433\u043D\u0443\u0442\u044B\u0439 worktree (.git \u043D\u0435 \u0444\u0430\u0439\u043B): \u043A\u0430\u0442\u0430\u043B\u043E\u0433 \u041D\u0415 \u0442\u0440\u043E\u0433\u0430\u044E. \u0415\u0441\u043B\u0438 \u044D\u0442\u043E \u0434\u0435\u0439\u0441\u0442\u0432\u0438\u0442\u0435\u043B\u044C\u043D\u043E worktree \u0434\u0440\u043E\u043D\u0430 \u2014 \u0443\u0431\u0435\u0440\u0438\u0442\u0435 \u0435\u0433\u043E \u0440\u0443\u043A\u0430\u043C\u0438; \u0435\u0441\u043B\u0438 \u044D\u0442\u043E \u043E\u0441\u043D\u043E\u0432\u043D\u043E\u0439 \u0447\u0435\u043A\u0430\u0443\u0442, \u0437\u043D\u0430\u0447\u0438\u0442 \u0432\u0435\u0442\u043A\u0430 \u0441\u043B\u0430\u0433\u0430 \u0447\u0435\u043A\u043D\u0443\u0442\u0430 \u0432 \u043D\u0451\u043C (git checkout <slug>) \u2014 \u043F\u0435\u0440\u0435\u043A\u043B\u044E\u0447\u0438\u0442\u0435 \u0435\u0433\u043E \u043D\u0430 \u0434\u0440\u0443\u0433\u0443\u044E \u0432\u0435\u0442\u043A\u0443.`
@@ -1689,7 +1757,7 @@ async function ensureWorktreeDirGone(worktree) {
     );
     return true;
   }
-  if (existsSync7(worktree)) {
+  if (existsSync8(worktree)) {
     console.error(`[git] \u043A\u0430\u0442\u0430\u043B\u043E\u0433 worktree ${worktree} \u043F\u0435\u0440\u0435\u0436\u0438\u043B rm \u2014 \u0443\u0431\u0435\u0440\u0438\u0442\u0435 \u0440\u0443\u043A\u0430\u043C\u0438, \u0438\u043D\u0430\u0447\u0435 \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0438\u0439 \u0441\u043F\u0430\u0432\u043D \u0441\u043B\u0430\u0433\u0430 \u0432\u0441\u0442\u0430\u043D\u0435\u0442.`);
   }
   return true;
@@ -1732,7 +1800,7 @@ async function addWorktree(repo, path, branch, opts = {}) {
   }
   const busyAt = await worktreeForBranch(repo, branch);
   if (busyAt) {
-    const exists = existsSync7(busyAt);
+    const exists = existsSync8(busyAt);
     const live = exists && (opts.isWorktreeHeldLive ? await opts.isWorktreeHeldLive(busyAt) : true);
     if (live) throw new WorktreeBusyError(branch, busyAt);
     if (exists && await worktreeDirty(busyAt)) throw new WorktreeBusyError(branch, busyAt);
@@ -1768,9 +1836,9 @@ async function ensureGitExcluded(worktree, pattern) {
     const out = await $2({ reject: false })`git -C ${worktree} rev-parse --git-common-dir`;
     const raw = out.stdout.trim();
     if (out.exitCode !== 0 || !raw) return false;
-    const commonDir = isAbsolute(raw) ? raw : join11(worktree, raw);
-    const infoDir = join11(commonDir, "info");
-    const excludeFile = join11(infoDir, "exclude");
+    const commonDir = isAbsolute2(raw) ? raw : join12(worktree, raw);
+    const infoDir = join12(commonDir, "info");
+    const excludeFile = join12(infoDir, "exclude");
     let current = "";
     try {
       current = await readFile(excludeFile, "utf8");
@@ -1803,7 +1871,7 @@ async function worktreeDirty(path) {
 async function repairMovedWorktrees(targetDir) {
   const subdirs = (dir) => {
     try {
-      return readdirSync8(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join11(dir, d.name));
+      return readdirSync8(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join12(dir, d.name));
     } catch {
       return [];
     }
@@ -1915,18 +1983,18 @@ __export(droneChannel_exports, {
   verifyLocalCliToken: () => verifyLocalCliToken
 });
 import { createHmac, randomBytes, timingSafeEqual } from "crypto";
-import { chmodSync, mkdirSync as mkdirSync5, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "fs";
+import { chmodSync, mkdirSync as mkdirSync5, readFileSync as readFileSync13, writeFileSync as writeFileSync9 } from "fs";
 import { dirname as dirname3 } from "path";
 import { serve } from "@hono/node-server";
 function loadChannelSecret(path) {
   try {
-    const s = readFileSync12(path, "utf8").trim();
+    const s = readFileSync13(path, "utf8").trim();
     if (s.length >= 32) return s;
   } catch {
   }
   const secret = randomBytes(32).toString("hex");
   mkdirSync5(dirname3(path), { recursive: true });
-  writeFileSync8(path, secret, { mode: 384 });
+  writeFileSync9(path, secret, { mode: 384 });
   try {
     chmodSync(path, 384);
   } catch {
@@ -2133,8 +2201,8 @@ function startDroneChannel(deps, port) {
   return { port, server };
 }
 function closeDroneChannel(server) {
-  return new Promise((resolve3) => {
-    server.close(() => resolve3());
+  return new Promise((resolve4) => {
+    server.close(() => resolve4());
     server.closeAllConnections?.();
   });
 }
@@ -2256,7 +2324,7 @@ var init_droneChannel = __esm({
 
 // src/attachments.ts
 import { mkdir as mkdir2, rm as rm2, writeFile } from "fs/promises";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 function attachmentsFromDoc(doc, origin) {
   const out = [];
   const walk2 = (node) => {
@@ -2347,7 +2415,7 @@ async function materializeAttachments(opts) {
   };
   const result = { files: [], skipped: [] };
   if (opts.refs.length === 0) return result;
-  const dir = join13(opts.worktree, ATTACHMENTS_DIR);
+  const dir = join14(opts.worktree, ATTACHMENTS_DIR);
   await io.removeDir(dir);
   let dirReady = false;
   let total = 0;
@@ -2393,7 +2461,7 @@ async function materializeAttachments(opts) {
         await io.mkdir(dir);
         dirReady = true;
       }
-      await io.writeFile(join13(dir, name), file.bytes);
+      await io.writeFile(join14(dir, name), file.bytes);
     } catch (e) {
       result.skipped.push(`${label} \u2014 \u043D\u0435 \u0437\u0430\u043F\u0438\u0441\u0430\u043B\u043E\u0441\u044C \u043D\u0430 \u0434\u0438\u0441\u043A (${errText(e)})`);
       continue;
@@ -2464,8 +2532,8 @@ function pathOf(url) {
   return url.split(/[?#]/)[0] ?? "";
 }
 function extOf(nameOrPath) {
-  const tail = nameOrPath.split("/").pop() ?? "";
-  const m = /\.([A-Za-z0-9]{1,8})$/.exec(tail);
+  const tail2 = nameOrPath.split("/").pop() ?? "";
+  const m = /\.([A-Za-z0-9]{1,8})$/.exec(tail2);
   return m ? m[1].toLowerCase() : "";
 }
 function mb(bytes) {
@@ -2546,7 +2614,7 @@ var init_attachments = __esm({
 
 // src/shotUpload.ts
 import { readFile as fsReadFile } from "fs/promises";
-import { basename as basename2, isAbsolute as isAbsolute2, join as join14 } from "path";
+import { basename as basename2, isAbsolute as isAbsolute3, join as join15 } from "path";
 function shotMimetype(path) {
   const dot = path.lastIndexOf(".");
   if (dot < 0) return null;
@@ -2572,7 +2640,7 @@ async function readShots(paths, opts) {
     }
     let bytes;
     try {
-      bytes = await read(isAbsolute2(path) ? path : join14(opts.worktree, path));
+      bytes = await read(isAbsolute3(path) ? path : join15(opts.worktree, path));
     } catch (e) {
       skipped.push({ path, reason: `\u043D\u0435 \u043F\u0440\u043E\u0447\u0438\u0442\u0430\u043D: ${e instanceof Error ? e.message : String(e)}` });
       continue;
@@ -2650,8 +2718,8 @@ var init_shotUpload = __esm({
 
 // src/oauth.ts
 import { createHash, randomBytes as randomBytes2 } from "crypto";
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync9, unlinkSync as unlinkSync2 } from "fs";
-import { join as join15 } from "path";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync10, unlinkSync as unlinkSync3 } from "fs";
+import { join as join16 } from "path";
 function makePkce() {
   const verifier = randomBytes2(48).toString("base64url");
   const challenge = createHash("sha256").update(verifier).digest("base64url");
@@ -2735,23 +2803,23 @@ function toStore(clientId, t, now) {
 }
 function loadStore() {
   try {
-    return JSON.parse(readFileSync13(STORE_PATH, "utf8"));
+    return JSON.parse(readFileSync14(STORE_PATH, "utf8"));
   } catch {
     return null;
   }
 }
 function saveStore(s) {
-  writeFileSync9(STORE_PATH, JSON.stringify(s, null, 2), { mode: 384 });
+  writeFileSync10(STORE_PATH, JSON.stringify(s, null, 2), { mode: 384 });
 }
 function clearStore() {
   try {
-    unlinkSync2(STORE_PATH);
+    unlinkSync3(STORE_PATH);
   } catch {
   }
 }
 function loadClientId() {
   try {
-    return JSON.parse(readFileSync13(CLIENT_PATH, "utf8")).clientId;
+    return JSON.parse(readFileSync14(CLIENT_PATH, "utf8")).clientId;
   } catch {
     return null;
   }
@@ -2760,7 +2828,7 @@ async function ensureClientId(api, redirectUri, fetchFn = fetch) {
   const existing = loadClientId();
   if (existing) return existing;
   const clientId = await registerClient({ api, redirectUri }, fetchFn);
-  writeFileSync9(CLIENT_PATH, JSON.stringify({ clientId }, null, 2), { mode: 384 });
+  writeFileSync10(CLIENT_PATH, JSON.stringify({ clientId }, null, 2), { mode: 384 });
   return clientId;
 }
 async function ensureAccess(store, opts = {}) {
@@ -2786,18 +2854,18 @@ var init_oauth = __esm({
     AUTHORIZE = "/api/oauth/authorize";
     TOKEN = "/api/oauth/token";
     SCOPE = "openid profile email taskless:full";
-    STORE_PATH = join15(SWARM_HOME, "oauth.json");
-    CLIENT_PATH = join15(SWARM_HOME, "oauth-client.json");
+    STORE_PATH = join16(SWARM_HOME, "oauth.json");
+    CLIENT_PATH = join16(SWARM_HOME, "oauth-client.json");
     base = (api) => api.replace(/\/$/, "");
   }
 });
 
 // src/agentToken.ts
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync10, unlinkSync as unlinkSync3 } from "fs";
-import { join as join16 } from "path";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync11, unlinkSync as unlinkSync4 } from "fs";
+import { join as join17 } from "path";
 function loadAgentToken() {
   try {
-    const s = JSON.parse(readFileSync14(STORE_PATH2, "utf8"));
+    const s = JSON.parse(readFileSync15(STORE_PATH2, "utf8"));
     return s.token ? s : null;
   } catch {
     return null;
@@ -2834,17 +2902,17 @@ var init_agentToken = __esm({
   "src/agentToken.ts"() {
     "use strict";
     init_config();
-    STORE_PATH2 = join16(SWARM_HOME, "agent.json");
+    STORE_PATH2 = join17(SWARM_HOME, "agent.json");
     base2 = (api) => api.replace(/\/$/, "");
   }
 });
 
 // src/workspace.ts
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync11, unlinkSync as unlinkSync4 } from "fs";
-import { join as join17 } from "path";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync12, unlinkSync as unlinkSync5 } from "fs";
+import { join as join18 } from "path";
 function loadWorkspace() {
   try {
-    const w = JSON.parse(readFileSync15(WORKSPACE_PATH, "utf8"));
+    const w = JSON.parse(readFileSync16(WORKSPACE_PATH, "utf8"));
     return w && typeof w.id === "string" && w.id ? w : null;
   } catch {
     return null;
@@ -2858,7 +2926,7 @@ var init_workspace = __esm({
   "src/workspace.ts"() {
     "use strict";
     init_config();
-    WORKSPACE_PATH = join17(SWARM_HOME, "workspace.json");
+    WORKSPACE_PATH = join18(SWARM_HOME, "workspace.json");
   }
 });
 
@@ -3051,14 +3119,14 @@ async function fetchTaskContext(client, task) {
   const parts = [];
   const comments = task.comments ?? [];
   if (comments.length > 0) {
-    const tail = comments.slice(-TASK_CONTEXT_MAX_COMMENTS);
-    const skipped = comments.length - tail.length;
-    const lines = tail.map((c) => {
+    const tail2 = comments.slice(-TASK_CONTEXT_MAX_COMMENTS);
+    const skipped = comments.length - tail2.length;
+    const lines = tail2.map((c) => {
       const cut = c.text.length > TASK_CONTEXT_MAX_COMMENT_CHARS;
       const text = cut ? `${c.text.slice(0, TASK_CONTEXT_MAX_COMMENT_CHARS)}\u2026 (\u043E\u0431\u0440\u0435\u0437\u0430\u043D\u043E)` : c.text;
       return `\u2014 [${c.createdAt} \xB7 ${c.author}] ${text}`;
     });
-    const header = skipped > 0 ? `\u041A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0438 (${comments.length}, \u043F\u043E\u043A\u0430\u0437\u0430\u043D\u044B \u043F\u043E\u0441\u043B\u0435\u0434\u043D\u0438\u0435 ${tail.length} \u2014 \u0441\u0430\u043C\u044B\u0435 \u0441\u0432\u0435\u0436\u0438\u0435):` : `\u041A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0438 (${comments.length}):`;
+    const header = skipped > 0 ? `\u041A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0438 (${comments.length}, \u043F\u043E\u043A\u0430\u0437\u0430\u043D\u044B \u043F\u043E\u0441\u043B\u0435\u0434\u043D\u0438\u0435 ${tail2.length} \u2014 \u0441\u0430\u043C\u044B\u0435 \u0441\u0432\u0435\u0436\u0438\u0435):` : `\u041A\u043E\u043C\u043C\u0435\u043D\u0442\u0430\u0440\u0438\u0438 (${comments.length}):`;
     parts.push([header, ...lines].join("\n"));
   }
   const documents = task.documents ?? [];
@@ -3285,8 +3353,8 @@ __export(db_exports, {
   SwarmDb: () => SwarmDb
 });
 import { createRequire as createRequire2 } from "module";
-import { existsSync as existsSync9 } from "fs";
-import { resolve as resolve2 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { resolve as resolve3 } from "path";
 function rowToQuestion(row) {
   return {
     id: row.id,
@@ -3766,11 +3834,11 @@ CREATE TABLE IF NOT EXISTS imports (
        * транзакции: прервётся — маркер не встанет, повтор безопасен.
        */
       importDb(sourcePath, repo) {
-        const abs = resolve2(sourcePath);
+        const abs = resolve3(sourcePath);
         const repoN = normalizeRepo(repo);
         const already = this.db.prepare("SELECT run_count FROM imports WHERE source = ?").get(abs);
         if (already) return { imported: false, runs: already.run_count };
-        if (!existsSync9(abs)) throw new Error(`import-db: \u0444\u0430\u0439\u043B\u0430 \u043D\u0435\u0442: ${abs}`);
+        if (!existsSync10(abs)) throw new Error(`import-db: \u0444\u0430\u0439\u043B\u0430 \u043D\u0435\u0442: ${abs}`);
         const src = new this.databaseCtor(abs);
         try {
           const runs = src.prepare("SELECT * FROM runs ORDER BY id").all();
@@ -4138,9 +4206,9 @@ var init_droneStore = __esm({
 });
 
 // src/overmind.ts
-import { homedir as homedir3 } from "os";
-import { existsSync as existsSync12, readFileSync as readFileSync17, readdirSync as readdirSync10, renameSync as renameSync7 } from "fs";
-import { basename as basename4, dirname as dirname5, join as join21 } from "path";
+import { homedir as homedir4 } from "os";
+import { existsSync as existsSync15, readFileSync as readFileSync20, readdirSync as readdirSync10, renameSync as renameSync10 } from "fs";
+import { basename as basename4, dirname as dirname5, join as join25 } from "path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
 import { spawn as spawn3 } from "child_process";
 
@@ -4291,25 +4359,25 @@ function runLogTail(runLogsDir, localRunId, opts) {
   const parts = [];
   let budget = opts.maxBytes;
   if (launch.err) {
-    const tail = readTail(launch.err, { lines: opts.lines, maxBytes: Math.floor(opts.maxBytes / 2) });
-    if (tail && tail.text.trim() !== "") {
-      const block = `${fileHeader(`${launch.index}.err.log`, tail.size, tail.shown)}
-${tail.text}`;
+    const tail2 = readTail(launch.err, { lines: opts.lines, maxBytes: Math.floor(opts.maxBytes / 2) });
+    if (tail2 && tail2.text.trim() !== "") {
+      const block = `${fileHeader(`${launch.index}.err.log`, tail2.size, tail2.shown)}
+${tail2.text}`;
       parts.push(block);
       budget -= Buffer.byteLength(block, "utf8");
     }
   }
   if (launch.out) {
-    const tail = readTail(launch.out, { lines: opts.lines, maxBytes: Math.max(1024, budget) });
-    if (tail) {
+    const tail2 = readTail(launch.out, { lines: opts.lines, maxBytes: Math.max(1024, budget) });
+    if (tail2) {
       parts.push(
-        tail.size === 0 ? (
+        tail2.size === 0 ? (
           // Пустой stdout при живом дроне — норма, а не поломка: claude в headless-режиме
           // (`--output-format json`) печатает результат ОДНИМ объектом в самом конце.
           `=== ${launch.index}.json (\u043F\u0443\u0441\u0442) ===
 Stdout \u0435\u0449\u0451 \u043D\u0435 \u0437\u0430\u043F\u0438\u0441\u0430\u043D: claude \u043E\u0442\u0434\u0430\u0451\u0442 \u0440\u0435\u0437\u0443\u043B\u044C\u0442\u0430\u0442 \u043E\u0434\u043D\u0438\u043C JSON \u0432 \u043A\u043E\u043D\u0446\u0435 \u043F\u0440\u043E\u0433\u043E\u043D\u0430. \u0414\u0440\u043E\u043D, \u0441\u043A\u043E\u0440\u0435\u0435 \u0432\u0441\u0435\u0433\u043E, \u0435\u0449\u0451 \u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442 \u2014 \u0441\u043C\u043E\u0442\u0440\u0438 stderr \u0432\u044B\u0448\u0435 \u0438 \u0441\u043E\u0431\u044B\u0442\u0438\u044F \u043F\u0440\u043E\u0433\u043E\u043D\u0430.`
-        ) : `${fileHeader(`${launch.index}.json`, tail.size, tail.shown)}
-${tail.text}`
+        ) : `${fileHeader(`${launch.index}.json`, tail2.size, tail2.shown)}
+${tail2.text}`
       );
     }
   }
@@ -4319,15 +4387,15 @@ ${tail.text}`
   return { text: head + parts.join("\n\n") };
 }
 function daemonLogTail(path, opts) {
-  const tail = readTail(path, opts);
-  if (!tail) {
+  const tail2 = readTail(path, opts);
+  if (!tail2) {
     return {
       error: `\u043B\u043E\u0433\u0430 \u0434\u0435\u043C\u043E\u043D\u0430 \u043D\u0435\u0442: ${path} \u043D\u0435 \u0447\u0438\u0442\u0430\u0435\u0442\u0441\u044F. \u0414\u0435\u043C\u043E\u043D \u043F\u0438\u0448\u0435\u0442 \u0432 stdout \u2014 \u0437\u0430\u0432\u0435\u0434\u0438 \u0444\u0430\u0439\u043B \u043F\u0435\u0440\u0435\u043D\u0430\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u0438\u0435\u043C (\`swarm start >> ${path} 2>&1\`) \u0438\u043B\u0438 \u0443\u043A\u0430\u0436\u0438 \u0441\u0432\u043E\u0439 \u043F\u0443\u0442\u044C \u0432 SWARM_DAEMON_LOG.`
     };
   }
-  if (tail.size === 0) return { error: `\u043B\u043E\u0433 \u0434\u0435\u043C\u043E\u043D\u0430 \u043F\u0443\u0441\u0442 (${path})` };
-  return { text: `${fileHeader(path, tail.size, tail.shown)}
-${tail.text}` };
+  if (tail2.size === 0) return { error: `\u043B\u043E\u0433 \u0434\u0435\u043C\u043E\u043D\u0430 \u043F\u0443\u0441\u0442 (${path})` };
+  return { text: `${fileHeader(path, tail2.size, tail2.shown)}
+${tail2.text}` };
 }
 async function serveLogRequests(deps, commands) {
   for (const cmd of commands) {
@@ -4366,6 +4434,11 @@ function runRef(runKey) {
 function isRunRef(v) {
   return typeof v === "object" && v !== null && "__runRef" in v;
 }
+function isHostCommandShape(v) {
+  const c = v;
+  return !!c && typeof c === "object" && typeof c.id === "string" && !!c.id && typeof c.kind === "string";
+}
+var EMPTY_HEARTBEAT_REPLY = { commands: [], logRequests: [] };
 function jsonFromTextContent(res) {
   const text = res?.content?.find((c) => c.type === "text")?.text;
   if (text) {
@@ -4545,6 +4618,18 @@ var SwarmClient = class _SwarmClient {
   runKeyFor(localId) {
     return this.keyByLocal.get(localId);
   }
+  /**
+   * TASWM-336: заменить репо-реестр на лету. До этой задачи реестр собирался ОДИН РАЗ на
+   * старте из окружения и жил до рестарта демона; теперь машина сама находит клоны своих
+   * репозиториев и переспрашивает прод по TTL — у владельца появился новый swarm-проект,
+   * и машина обязана подхватить его без рестарта. Меняем обе стороны разом: и список для
+   * claim/heartbeat, и обратную карту `owner/repo` → путь (иначе прогон нового репо
+   * пришёл бы именем, которое не во что перевести).
+   */
+  setRepoRegistry(registry) {
+    this.repoFullNames = registry.map((e) => e.repoFullName);
+    this.repoPathByFullName = new Map(registry.map((e) => [e.repoFullName, normalizeRepo(e.path)]));
+  }
   // cuid прода → локальный id (по runKey гидрированного прогона `p:<cuid>`).
   // Для маппинга прод heroId → локальный hero_run_id при гидрации. Резолвится, когда
   // прогон-герой присутствует в зеркале; иначе null (уточнится следующим рефрешем).
@@ -5537,17 +5622,24 @@ var SwarmClient = class _SwarmClient {
    * прислал предыдущий (более свежий по коду) процесс демона.
    */
   /**
-   * TASWM-322: ответ на пульс — ЕДИНСТВЕННЫЙ канал «прод → демон» (демон за домашним
-   * роутером, прод к нему не постучится). Оттуда приезжают команды машине — сейчас одна:
-   * «пришли хвост лога» (logRequests). Возвращаем их вызывающему; пульс недоступен или
-   * прод старый (поля нет) → пустой список, всё как раньше.
-   */
-  /**
+   * TASWM-321: ВОЗВРАЩАЕТ команды этой машине (пауза/рестарт/обновление/…), приехавшие
+   * в ответе на пульс. Это единственный момент, когда прод может что-то сказать демону:
+   * тот живёт за домашним роутером без белого адреса, и связь всегда инициирует он сам.
+   * Прод, отдав команды, метит их доставленными — повторный пульс их не вернёт, поэтому
+   * потерять ответ здесь значит потерять команду; парсим бережно и не бросаем.
+   *
+   * TASWM-322: тем же ответом приезжают запросы «пришли хвост лога» (logRequests) —
+   * канал «прод → демон» один на оба вида поручений, поэтому и разбираем их вместе.
+   * Возвращаем ОБА списка объектом: два разных потребителя в overmind, и слепить их в
+   * один список значило бы заставить каждого фильтровать чужое.
+   *
    * TASWM-326: тем же пульсом уходит ПАУЗА этой машины (`pause` — durable-запись из
    * pause.json либо null). В парке машин «на паузе» обязано отличаться от «нет работы»
    * и от «молчит», а единственный канал «демон → прод» с нужной кадансностью — пульс.
    * Шлём ВСЕГДА (в т.ч. `paused:false`): это состояние, а не команда, и молчание тут
    * означало бы «прод помнит вчерашнюю паузу», когда рой давно работает.
+   *
+   * Прод недоступен / ответ без поручений → пустые списки (демон работает дальше).
    */
   async heartbeat(daemonVersion, pause) {
     try {
@@ -5562,9 +5654,33 @@ var SwarmClient = class _SwarmClient {
         args.hostName = this.host.hostName;
       }
       const res = await this.call("swarm_heartbeat", args);
-      return parseLogRequests(res?.structuredContent?.logRequests);
+      if (res?.isError) return EMPTY_HEARTBEAT_REPLY;
+      const data = res?.structuredContent ?? {};
+      return {
+        commands: Array.isArray(data.commands) ? data.commands.filter(isHostCommandShape) : [],
+        logRequests: parseLogRequests(data.logRequests)
+      };
+    } catch {
+      return EMPTY_HEARTBEAT_REPLY;
+    }
+  }
+  /**
+   * TASWM-321: подтвердить исполнение команды (`swarm_command_ack`). ПРЯМОЙ вызов, не
+   * outbox: подтверждение — «скажи СЕЙЧАС», ради него команду и заводили («без
+   * подтверждения непонятно, обновился он или команда потерялась по дороге»), а
+   * промежуточные шаги обновления, доехавшие после самого обновления, бессмысленны.
+   * Не бросает: сорвавшийся ack не должен рушить тик демона — команда останется в
+   * прошлом состоянии, следующий шаг/финал её всё равно подвинут.
+   */
+  async ackCommand(commandId, status, patch = {}) {
+    try {
+      await this.call("swarm_command_ack", {
+        commandId,
+        status,
+        ...patch.step ? { step: patch.step } : {},
+        ...patch.result ? { result: patch.result.slice(0, 2e3) } : {}
+      });
     } catch {
-      return [];
     }
   }
   /**
@@ -5733,8 +5849,9 @@ var SwarmClient = class _SwarmClient {
       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;
+    const prodSlug = pr.taskSlug ?? pr.task?.slug ?? null;
+    if (prodSlug) local.task_slug = prodSlug;
+    else if (!isTaskSlug(local.task_slug)) local.task_slug = pr.taskId || 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;
@@ -6053,6 +6170,66 @@ function parseDecision(v) {
 init_config();
 init_heartbeat();
 
+// src/logRotate.ts
+import { copyFileSync, renameSync as renameSync4, statSync as statSync2, fstatSync, truncateSync, unlinkSync as unlinkSync2, existsSync as existsSync4 } from "fs";
+var realIo = {
+  size: (path) => {
+    try {
+      return statSync2(path).size;
+    } catch {
+      return null;
+    }
+  },
+  copy: copyFileSync,
+  rename: renameSync4,
+  truncate: (path) => truncateSync(path, 0),
+  unlink: unlinkSync2,
+  exists: existsSync4
+};
+var realOwnerIo = {
+  statFd: (fd) => {
+    try {
+      const s = fstatSync(fd);
+      return { dev: s.dev, ino: s.ino, isFile: s.isFile() };
+    } catch {
+      return null;
+    }
+  },
+  statPath: (path) => {
+    try {
+      const s = statSync2(path);
+      return { dev: s.dev, ino: s.ino };
+    } catch {
+      return null;
+    }
+  }
+};
+function stdoutGoesTo(path, io = realOwnerIo) {
+  const out = io.statFd(1);
+  if (!out || !out.isFile) return false;
+  const file = io.statPath(path);
+  return file != null && file.dev === out.dev && file.ino === out.ino;
+}
+var STRAY_GENERATIONS = 8;
+function rotateDaemonLog(path, opts, io = realIo) {
+  const size = io.size(path);
+  if (size == null) return "missing";
+  if (size <= opts.maxBytes) return "kept";
+  const keep = Math.max(0, Math.trunc(opts.keep));
+  const gen = (n) => `${path}.${n}`;
+  for (let i = keep; i >= 1; i--) {
+    if (!io.exists(gen(i))) continue;
+    if (i === keep) io.unlink(gen(i));
+    else io.rename(gen(i), gen(i + 1));
+  }
+  for (let i = keep + 1; i <= keep + STRAY_GENERATIONS; i++) {
+    if (io.exists(gen(i))) io.unlink(gen(i));
+  }
+  if (keep >= 1) io.copy(path, gen(1));
+  io.truncate(path);
+  return "rotated";
+}
+
 // src/repoRegistry.ts
 init_config();
 import { $ } from "execa";
@@ -6122,8 +6299,15 @@ function pickRepoPaths(args) {
   return { paths: [], source: "none" };
 }
 
+// src/repoDiscovery.ts
+init_src();
+init_config();
+import { homedir as homedir2 } from "os";
+import { readFileSync as readFileSync8, renameSync as renameSync5, writeFileSync as writeFileSync6 } from "fs";
+import { isAbsolute, join as join6, resolve as resolve2 } from "path";
+
 // src/repoScan.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync7, statSync as statSync2 } from "fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync7, statSync as statSync3 } from "fs";
 import { join as join5 } from "path";
 var SKIP = /* @__PURE__ */ new Set([
   "node_modules",
@@ -6159,7 +6343,11 @@ function originOf(dir) {
     return null;
   }
 }
-function scanRoots(roots, opts = {}) {
+function repoFullNameAt(dir) {
+  const origin = originOf(dir);
+  return origin ? parseRepoFullName(origin) : null;
+}
+function scanRootsAll(roots, opts = {}) {
   const maxDepth = opts.maxDepth ?? 3;
   const found = /* @__PURE__ */ new Map();
   for (const root of roots) walk(root, 0, maxDepth, found);
@@ -6170,7 +6358,11 @@ function walk(dir, depth, maxDepth, found) {
   const origin = originOf(dir);
   if (origin) {
     const full = parseRepoFullName(origin);
-    if (full && !found.has(full)) found.set(full, dir);
+    if (full) {
+      const paths = found.get(full) ?? [];
+      if (!paths.includes(dir)) paths.push(dir);
+      found.set(full, paths);
+    }
     return;
   }
   let entries;
@@ -6183,7 +6375,7 @@ function walk(dir, depth, maxDepth, found) {
     if (name.startsWith(".") || SKIP.has(name)) continue;
     const child = join5(dir, name);
     try {
-      if (!statSync2(child).isDirectory()) continue;
+      if (!statSync3(child).isDirectory()) continue;
     } catch {
       continue;
     }
@@ -6208,20 +6400,173 @@ function defaultScanRoots(home, knownPaths = []) {
   return out;
 }
 
+// src/repoDiscovery.ts
+function resolveScanRoots(raw, home = homedir2(), knownPaths = []) {
+  const v = (raw ?? "").trim();
+  if (!v) return defaultScanRoots(home, knownPaths);
+  if (["off", "none", "0"].includes(v.toLowerCase())) return [];
+  const out = [];
+  for (const part of v.split(",")) {
+    const p = part.trim();
+    if (!p) continue;
+    const abs = p === "~" ? home : p.startsWith("~/") ? join6(home, p.slice(2)) : isAbsolute(p) ? p : resolve2(home, p);
+    if (!out.includes(abs)) out.push(abs);
+  }
+  return out;
+}
+function normalizeFullNames(list) {
+  const out = [];
+  for (const raw of list) {
+    const v = (raw ?? "").trim().toLowerCase();
+    if (v && !out.includes(v)) out.push(v);
+  }
+  return out;
+}
+async function fetchSwarmRepos(call) {
+  let res;
+  try {
+    res = await call("swarm_my_repos", {});
+  } catch {
+    return null;
+  }
+  if (!res || res.isError) return null;
+  const raw = res.structuredContent?.repos;
+  if (!Array.isArray(raw)) return null;
+  const out = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object") continue;
+    const r = item;
+    const repoFullName = typeof r.repoFullName === "string" ? r.repoFullName.trim().toLowerCase() : "";
+    if (!repoFullName) continue;
+    out.push({
+      repoFullName,
+      taskPrefix: typeof r.taskPrefix === "string" ? r.taskPrefix : null,
+      workspaceSlug: typeof r.workspaceSlug === "string" ? r.workspaceSlug : ""
+    });
+  }
+  return out;
+}
+function emptyRepoMapState(roots) {
+  return { clones: [], missing: [], roots: [...roots], at: null, unknown: true };
+}
+async function refreshRepoMap(opts) {
+  const log = opts.log ?? (() => {
+  });
+  const scan = opts.scan ?? scanRootsAll;
+  const repoAt = opts.repoAt ?? repoFullNameAt;
+  const wanted = await fetchSwarmRepos(opts.call);
+  const clones = /* @__PURE__ */ new Map();
+  const take = (repoFullName, path, source, alternatives = []) => {
+    if (clones.has(repoFullName)) return;
+    clones.set(repoFullName, { repoFullName, path, source, alternatives });
+  };
+  for (const e of opts.configured) take(e.repoFullName.toLowerCase(), e.path, "configured");
+  for (const e of readRepoMapCache(opts.cachePath)) {
+    const name = e.repoFullName.toLowerCase();
+    if (clones.has(name)) continue;
+    if (repoAt(e.path) === name) take(name, e.path, "cache");
+  }
+  const wantedNames = wanted ? normalizeFullNames(wanted.map((r) => r.repoFullName)) : [];
+  const needScan = wanted ? wantedNames.some((n) => !clones.has(n)) : clones.size === 0;
+  if (needScan) {
+    const startedAt = Date.now();
+    const scanned = scan(opts.roots, opts.maxDepth !== void 0 ? { maxDepth: opts.maxDepth } : {});
+    let added = 0;
+    for (const [full, paths] of scanned) {
+      if (clones.has(full) || !paths.length) continue;
+      take(full, paths[0], "scan", paths.slice(1));
+      added++;
+    }
+    if (added > 0) {
+      log(`[overmind] \u043D\u0430\u0448\u0451\u043B \u043D\u0430 \u043C\u0430\u0448\u0438\u043D\u0435 ${added} \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0439(\u0435\u0432) \u0441\u043A\u0430\u043D\u043E\u043C \u0437\u0430 ${Date.now() - startedAt}\u043C\u0441`);
+    }
+  }
+  const registry = [...clones.values()].map((c) => ({
+    repoFullName: c.repoFullName,
+    path: normalizeRepo(c.path)
+  }));
+  writeRepoMapCache(
+    opts.cachePath,
+    [...clones.values()].map((c) => ({ repoFullName: c.repoFullName, path: c.path }))
+  );
+  if (!wanted) {
+    log(
+      "[overmind] \u043F\u0440\u043E\u0434 \u043D\u0435 \u043E\u0442\u0432\u0435\u0442\u0438\u043B, \u043A\u0430\u043A\u0438\u0435 \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0438 \u0443 \u0440\u043E\u044F (swarm_my_repos) \u2014 \u0440\u0430\u0431\u043E\u0442\u0430\u044E \u043F\u043E \u043D\u0430\u0439\u0434\u0435\u043D\u043D\u043E\u043C\u0443 \u043D\u0430 \u043C\u0430\u0448\u0438\u043D\u0435. \u0421\u0435\u0440\u0432\u0435\u0440 \u0441\u0442\u0430\u0440\u0435\u0435 \u0434\u0435\u043C\u043E\u043D\u0430 \u2014 \u044D\u0442\u043E \u043E\u0436\u0438\u0434\u0430\u0435\u043C\u043E \u0438 \u043B\u0435\u0447\u0438\u0442\u0441\u044F \u043E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u0435\u043C \u043F\u0440\u043E\u0434\u0430."
+    );
+    return registry;
+  }
+  opts.state.unknown = false;
+  opts.state.clones = wantedNames.map((n) => clones.get(n)).filter((c) => !!c);
+  opts.state.missing = wantedNames.filter((n) => !clones.has(n));
+  opts.state.roots = [...opts.roots];
+  opts.state.at = stamp();
+  if (wantedNames.length === 0) {
+    log("[overmind] \u0443 \u0432\u043B\u0430\u0434\u0435\u043B\u044C\u0446\u0430 \u043D\u0435\u0442 \u043F\u0440\u043E\u0435\u043A\u0442\u043E\u0432 \u0441 \u0432\u043A\u043B\u044E\u0447\u0451\u043D\u043D\u044B\u043C \u0440\u043E\u0435\u043C \u2014 \u0440\u0430\u0431\u043E\u0442\u0430\u044E \u043F\u043E \u043D\u0430\u0439\u0434\u0435\u043D\u043D\u043E\u043C\u0443 \u043D\u0430 \u043C\u0430\u0448\u0438\u043D\u0435");
+    return registry;
+  }
+  log(`[overmind] \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0438 \u0440\u043E\u044F (${wantedNames.length}), \u043A\u0430\u0440\u0442\u0430 \u043D\u0430 \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435:`);
+  for (const c of opts.state.clones) log(`[overmind]   ${describeClone(c)}`);
+  const prefixOf = new Map(wanted.map((r) => [r.repoFullName, r.taskPrefix]));
+  for (const name of opts.state.missing) {
+    const prefix = prefixOf.get(name);
+    log(`[overmind]   ${describeMissing(prefix ? `${name} (\u043F\u0440\u043E\u0435\u043A\u0442 ${prefix})` : name, opts.roots)}`);
+  }
+  return registry;
+}
+function describeClone(c) {
+  const how = c.source === "configured" ? "\u043F\u0443\u0442\u044C \u0437\u0430\u0434\u0430\u043D \u043E\u043F\u0435\u0440\u0430\u0442\u043E\u0440\u043E\u043C" : c.source === "cache" ? "\u0438\u0437 \u043A\u044D\u0448\u0430 \u043C\u0430\u0448\u0438\u043D\u044B" : "\u043D\u0430\u0439\u0434\u0435\u043D \u0441\u043A\u0430\u043D\u043E\u043C";
+  const alt = c.alternatives.length ? ` \u26A0 \u043D\u0430\u0439\u0434\u0435\u043D\u043E \u0435\u0449\u0451 ${c.alternatives.length}: ${c.alternatives.join(", ")} \u2014 \u0440\u0430\u0431\u043E\u0442\u0430\u044E \u0432 \u043F\u0435\u0440\u0432\u043E\u043C \u043F\u043E \u043F\u043E\u0440\u044F\u0434\u043A\u0443 \u043A\u043E\u0440\u043D\u0435\u0439` : "";
+  return `${c.repoFullName} \u2192 ${c.path} (${how})${alt}`;
+}
+function describeMissing(repoFullName, roots) {
+  const where = roots.length ? `\u0438\u0441\u043A\u0430\u043B \u0432: ${roots.slice(0, 6).join(", ")}` : "\u043F\u043E\u0438\u0441\u043A \u043F\u043E \u043A\u0430\u0442\u0430\u043B\u043E\u0433\u0430\u043C \u0432\u044B\u043A\u043B\u044E\u0447\u0435\u043D (SWARM_SCAN_ROOTS)";
+  return `${repoFullName} \u2014 \u041A\u041B\u041E\u041D\u0410 \u041D\u0410 \u042D\u0422\u041E\u0419 \u041C\u0410\u0428\u0418\u041D\u0415 \u041D\u0415\u0422 (${where}). \u0421\u0430\u043C \u043D\u0435 \u043A\u043B\u043E\u043D\u0438\u0440\u0443\u044E: \u0441\u043A\u043B\u043E\u043D\u0438\u0440\u0443\u0439 \u0440\u0443\u043A\u0430\u043C\u0438 \u043B\u0438\u0431\u043E \u0443\u043A\u0430\u0436\u0438 \u043F\u0443\u0442\u044C \`swarm start --repo <\u043F\u0443\u0442\u044C>\`.`;
+}
+function repoMapRows(state) {
+  return [
+    ...state.clones.map((c) => ({
+      repoFullName: c.repoFullName,
+      path: c.path,
+      source: c.source,
+      alternatives: c.alternatives
+    })),
+    ...state.missing.map((repoFullName) => ({ repoFullName, path: null, source: null, alternatives: [] }))
+  ];
+}
+function readRepoMapCache(path) {
+  try {
+    const raw = JSON.parse(readFileSync8(path, "utf8"));
+    if (!Array.isArray(raw?.entries)) return [];
+    return raw.entries.filter(
+      (e) => !!e && typeof e.repoFullName === "string" && typeof e.path === "string" && !!e.repoFullName && !!e.path
+    );
+  } catch {
+    return [];
+  }
+}
+function writeRepoMapCache(path, entries) {
+  try {
+    const tmp = `${path}.tmp`;
+    writeFileSync6(tmp, JSON.stringify({ at: stamp(), entries }, null, 2));
+    renameSync5(tmp, path);
+  } catch {
+  }
+}
+
 // src/hostIdentity.ts
 import { hostname } from "os";
-import { existsSync as existsSync4, readFileSync as readFileSync8, renameSync as renameSync4, writeFileSync as writeFileSync6 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync9, renameSync as renameSync6, writeFileSync as writeFileSync7 } from "fs";
+import { join as join7 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function hostIdentityPath(home) {
-  return join6(home, "host.json");
+  return join7(home, "host.json");
 }
 function loadHostIdentity(deps) {
-  const exists = deps.exists ?? existsSync4;
-  const readFile2 = deps.readFile ?? ((p) => readFileSync8(p, "utf8"));
+  const exists = deps.exists ?? existsSync5;
+  const readFile2 = deps.readFile ?? ((p) => readFileSync9(p, "utf8"));
   const writeFile2 = deps.writeFile ?? ((p, data) => {
-    writeFileSync6(`${p}.tmp`, data);
-    renameSync4(`${p}.tmp`, p);
+    writeFileSync7(`${p}.tmp`, data);
+    renameSync6(`${p}.tmp`, p);
   });
   const host = deps.hostname ?? hostname;
   const newId = deps.newId ?? randomUUID2;
@@ -6403,14 +6748,14 @@ function buildReliefCostCandidates(cost, t, sustainMs, build) {
 
 // src/launcher.ts
 import { spawn } from "child_process";
-import { closeSync as closeSync2, existsSync as existsSync6, mkdirSync as mkdirSync4, openSync as openSync2, readdirSync as readdirSync5, statSync as statSync4, writeFileSync as writeFileSync7 } from "fs";
+import { closeSync as closeSync2, existsSync as existsSync7, mkdirSync as mkdirSync4, openSync as openSync2, readdirSync as readdirSync5, statSync as statSync5, writeFileSync as writeFileSync8 } from "fs";
 import { createRequire } from "module";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname2, join as join8 } from "path";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, join as join9 } from "path";
 import { fileURLToPath } from "url";
 
 // src/claudeBin.ts
-import { existsSync as existsSync5, readdirSync as readdirSync3 } from "fs";
+import { existsSync as existsSync6, readdirSync as readdirSync3 } from "fs";
 import { win32 as winPath } from "path";
 var CLAUDE_FALLBACK = "claude";
 function compareVersionDirs(a, b) {
@@ -6447,7 +6792,7 @@ function winVersionRoots(env, listDir) {
 function findWindowsClaude(opts = {}) {
   const env = opts.env ?? process.env;
   const listDir = opts.listDir ?? realListDir;
-  const fileExists = opts.fileExists ?? existsSync5;
+  const fileExists = opts.fileExists ?? existsSync6;
   let best = null;
   for (const root of winVersionRoots(env, listDir)) {
     for (const version of listDir(root)) {
@@ -6482,8 +6827,8 @@ function resolveClaudeBin(opts = {}) {
 }
 
 // src/droneHome.ts
-import { lstatSync, mkdirSync as mkdirSync3, readdirSync as readdirSync4, rmSync, statSync as statSync3, symlinkSync } from "fs";
-import { join as join7, relative, sep } from "path";
+import { lstatSync, mkdirSync as mkdirSync3, readdirSync as readdirSync4, rmSync, statSync as statSync4, symlinkSync } from "fs";
+import { join as join8, relative, sep } from "path";
 var DRONE_HOME_DENY_DEFAULT = [".taskless-swarm", ".bash_history", ".zsh_history"];
 function droneHomeDeny(env = process.env) {
   const extra = (env.SWARM_DRONE_HOME_DENY || "").split(",").map((s) => s.trim()).filter(Boolean);
@@ -6507,23 +6852,23 @@ function buildDroneHome(opts) {
   if (rel && !rel.startsWith("..") && !rel.includes(sep)) wanted.delete(rel);
   for (const existing of readdirSync4(droneHome)) {
     if (wanted.has(existing)) continue;
-    const p = join7(droneHome, existing);
+    const p = join8(droneHome, existing);
     try {
       if (lstatSync(p).isSymbolicLink()) rmSync(p);
     } catch {
     }
   }
   for (const name of wanted) {
-    const link = join7(droneHome, name);
+    const link = join8(droneHome, name);
     try {
       lstatSync(link);
       continue;
     } catch {
     }
-    const target = join7(realHome, name);
+    const target = join8(realHome, name);
     let isDir;
     try {
-      isDir = statSync3(target).isDirectory();
+      isDir = statSync4(target).isDirectory();
     } catch {
       continue;
     }
@@ -6541,7 +6886,7 @@ var REAL_PATH_ENV_PINS = [
   { env: "YARN_GLOBAL_FOLDER", segments: [".yarn", "berry"] }
 ];
 function realPathEnvPins(realHome) {
-  return Object.fromEntries(REAL_PATH_ENV_PINS.map(({ env, segments }) => [env, join7(realHome, ...segments)]));
+  return Object.fromEntries(REAL_PATH_ENV_PINS.map(({ env, segments }) => [env, join8(realHome, ...segments)]));
 }
 function droneDenyRules(realHome, swarmHome) {
   const paths = [
@@ -6633,7 +6978,7 @@ function droneEnv(worktree, base3 = process.env, isolation, droneCap = null) {
   const env = { ...base3 };
   const isolate = base3.SWARM_TURBO_ISOLATE !== "0";
   if (isolate && !base3.TURBO_CACHE_DIR) {
-    env.TURBO_CACHE_DIR = join8(worktree, ".turbo", "cache");
+    env.TURBO_CACHE_DIR = join9(worktree, ".turbo", "cache");
   }
   Object.assign(env, droneTestEnv(droneCap, base3));
   for (const key of DAEMON_STATE_ENV) delete env[key];
@@ -6661,25 +7006,25 @@ var DAEMON_STATE_ENV = [
   "TASKLESS_TOKEN"
 ];
 function bundledRoleDir(kind) {
-  return join8(dirname2(fileURLToPath(import.meta.url)), "..", "roles", kind);
+  return join9(dirname2(fileURLToPath(import.meta.url)), "..", "roles", kind);
 }
 function roleDir(worktree, kind) {
-  return join8(worktree, ".claude", "roles", kind);
+  return join9(worktree, ".claude", "roles", kind);
 }
 function roleDirs(worktree, kind) {
-  return [bundledRoleDir(kind), roleDir(worktree, kind)].filter((dir) => existsSync6(dir));
+  return [bundledRoleDir(kind), roleDir(worktree, kind)].filter((dir) => existsSync7(dir));
 }
 function transcriptDir(worktree, projectsDir) {
-  return join8(projectsDir, worktree.replace(/[/.]/g, "-"));
+  return join9(projectsDir, worktree.replace(/[/.]/g, "-"));
 }
-function sessionTranscriptExists(worktree, projectsDir = join8(homedir2(), ".claude", "projects")) {
+function sessionTranscriptExists(worktree, projectsDir = join9(homedir3(), ".claude", "projects")) {
   try {
     return readdirSync5(transcriptDir(worktree, projectsDir)).some((f) => f.endsWith(".jsonl"));
   } catch {
     return false;
   }
 }
-function transcriptMtimeMs(worktree, projectsDir = join8(homedir2(), ".claude", "projects")) {
+function transcriptMtimeMs(worktree, projectsDir = join9(homedir3(), ".claude", "projects")) {
   const dir = transcriptDir(worktree, projectsDir);
   let files;
   try {
@@ -6691,7 +7036,7 @@ function transcriptMtimeMs(worktree, projectsDir = join8(homedir2(), ".claude",
   for (const f of files) {
     if (!f.endsWith(".jsonl")) continue;
     try {
-      const mtime2 = statSync4(join8(dir, f)).mtimeMs;
+      const mtime2 = statSync5(join9(dir, f)).mtimeMs;
       if (latest === null || mtime2 > latest) latest = mtime2;
     } catch {
     }
@@ -6699,7 +7044,7 @@ function transcriptMtimeMs(worktree, projectsDir = join8(homedir2(), ".claude",
   return latest;
 }
 function nextRunLogPath(runLogsDir, runId) {
-  const dir = join8(runLogsDir, String(runId));
+  const dir = join9(runLogsDir, String(runId));
   mkdirSync4(dir, { recursive: true });
   let files = [];
   try {
@@ -6711,7 +7056,7 @@ function nextRunLogPath(runLogsDir, runId) {
     const m = /^(\d+)\.json/.exec(f);
     if (m) next = Math.max(next, Number(m[1]) + 1);
   }
-  return join8(dir, `${next}.json`);
+  return join9(dir, `${next}.json`);
 }
 function openNextRunLog(runLogsDir, runId) {
   for (let attempt = 0; attempt < 50; attempt++) {
@@ -6785,16 +7130,16 @@ function makeLauncher(cfg) {
         }
       }
     };
-    const cfgPath = join8(worktree, ".swarm-mcp.json");
-    writeFileSync7(cfgPath, JSON.stringify(mcpConfig, null, 2));
+    const cfgPath = join9(worktree, ".swarm-mcp.json");
+    writeFileSync8(cfgPath, JSON.stringify(mcpConfig, null, 2));
     const model = run.model ?? process.env.SWARM_DRONE_MODEL ?? void 0;
     const pluginDirs = roleDirs(worktree, run.kind);
-    const realHome = cfg.droneIsolation?.realHome ?? homedir2();
+    const realHome = cfg.droneIsolation?.realHome ?? homedir3();
     const home = cfg.droneIsolation ? buildDroneHome({ realHome, droneHome: cfg.droneIsolation.home }) : void 0;
     const settings = cfg.droneIsolation ? droneSettingsJson(realHome, cfg.droneIsolation.swarmHome) : void 0;
-    if (cfg.droneIsolation && process.env.TASKLESS_TOKEN && !existsSync6(join8(cfg.droneIsolation.swarmHome, "token"))) {
+    if (cfg.droneIsolation && process.env.TASKLESS_TOKEN && !existsSync7(join9(cfg.droneIsolation.swarmHome, "token"))) {
       console.error(
-        `[launcher] TASKLESS_TOKEN \u0437\u0430\u0434\u0430\u043D \u0442\u043E\u043B\u044C\u043A\u043E \u0432 env \u0434\u0435\u043C\u043E\u043D\u0430 \u2014 \u0434\u0440\u043E\u043D\u0443 \u043E\u043D \u043D\u0435 \u043D\u0430\u0441\u043B\u0435\u0434\u0443\u0435\u0442\u0441\u044F (TASWM-289), \u0430 \u0444\u0430\u0439\u043B\u0430 ${join8(cfg.droneIsolation.swarmHome, "token")} \u043D\u0435\u0442. read_task \u0434\u0440\u043E\u043D\u0430 \u0431\u0443\u0434\u0435\u0442 slug-only. \u041F\u043E\u0447\u0438\u043D\u0438: \`swarm login\` (oauth.json) \u0438\u043B\u0438 \u043F\u043E\u043B\u043E\u0436\u0438 \u0442\u043E\u043A\u0435\u043D \u0432 \u044D\u0442\u043E\u0442 \u0444\u0430\u0439\u043B.`
+        `[launcher] TASKLESS_TOKEN \u0437\u0430\u0434\u0430\u043D \u0442\u043E\u043B\u044C\u043A\u043E \u0432 env \u0434\u0435\u043C\u043E\u043D\u0430 \u2014 \u0434\u0440\u043E\u043D\u0443 \u043E\u043D \u043D\u0435 \u043D\u0430\u0441\u043B\u0435\u0434\u0443\u0435\u0442\u0441\u044F (TASWM-289), \u0430 \u0444\u0430\u0439\u043B\u0430 ${join9(cfg.droneIsolation.swarmHome, "token")} \u043D\u0435\u0442. read_task \u0434\u0440\u043E\u043D\u0430 \u0431\u0443\u0434\u0435\u0442 slug-only. \u041F\u043E\u0447\u0438\u043D\u0438: \`swarm login\` (oauth.json) \u0438\u043B\u0438 \u043F\u043E\u043B\u043E\u0436\u0438 \u0442\u043E\u043A\u0435\u043D \u0432 \u044D\u0442\u043E\u0442 \u0444\u0430\u0439\u043B.`
       );
     }
     let stdio = "ignore";
@@ -6828,8 +7173,8 @@ function makeLauncher(cfg) {
 init_procCleanup();
 
 // src/cost.ts
-import { readFileSync as readFileSync9, readdirSync as readdirSync6, renameSync as renameSync5 } from "fs";
-import { join as join9 } from "path";
+import { readFileSync as readFileSync10, readdirSync as readdirSync6, renameSync as renameSync7 } from "fs";
+import { join as join10 } from "path";
 
 // src/pricing.ts
 var MODEL_PRICING = {
@@ -6886,17 +7231,17 @@ function unprocessedLogFiles(dir) {
   }
 }
 function accountRunCost(deps, run) {
-  const dir = join9(deps.runLogsDir, String(run.id));
+  const dir = join10(deps.runLogsDir, String(run.id));
   const files = unprocessedLogFiles(dir);
   if (files.length === 0) return;
   const model = run.model ?? process.env.SWARM_DRONE_MODEL ?? null;
   let added = 0;
   const processed = [];
   for (const f of files) {
-    const full = join9(dir, f);
+    const full = join10(dir, f);
     let raw = null;
     try {
-      raw = readFileSync9(full, "utf8");
+      raw = readFileSync10(full, "utf8");
     } catch {
       continue;
     }
@@ -6913,7 +7258,7 @@ function accountRunCost(deps, run) {
   if (added > 0) deps.db.updateRun(run.id, { cost_usd: run.cost_usd + added });
   for (const full of processed) {
     try {
-      renameSync5(full, `${full}.done`);
+      renameSync7(full, `${full}.done`);
     } catch {
     }
   }
@@ -6923,11 +7268,11 @@ function makeCostAccountant(deps) {
 }
 
 // src/runOutcome.ts
-import { readdirSync as readdirSync7, readFileSync as readFileSync10 } from "fs";
-import { join as join10 } from "path";
+import { readdirSync as readdirSync7, readFileSync as readFileSync11 } from "fs";
+import { join as join11 } from "path";
 var RESULT_FILE_RE = /^(\d+)\.json(\.done)?$/;
 function classifyExit(runLogsDir, runId) {
-  const dir = join10(runLogsDir, String(runId));
+  const dir = join11(runLogsDir, String(runId));
   let files;
   try {
     files = readdirSync7(dir);
@@ -6944,7 +7289,7 @@ function classifyExit(runLogsDir, runId) {
   if (!latest) return "unknown";
   let raw;
   try {
-    raw = readFileSync10(join10(dir, latest.name), "utf8");
+    raw = readFileSync11(join11(dir, latest.name), "utf8");
   } catch {
     return "unknown";
   }
@@ -6955,11 +7300,12 @@ function makeExitClassifier(runLogsDir) {
 }
 
 // src/orchestrator.ts
+init_src();
 init_git();
 
 // src/deps.ts
-import { existsSync as existsSync8, readdirSync as readdirSync9, readFileSync as readFileSync11 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync9, readFileSync as readFileSync12 } from "fs";
+import { join as join13 } from "path";
 import { execa } from "execa";
 var PREPARE_TIMEOUT_MS = 15 * 6e4;
 var MAX_PLAN_COMMANDS = 12;
@@ -6975,7 +7321,7 @@ async function runCommand(cmd, worktree) {
 }
 function safeReadText(p) {
   try {
-    return readFileSync11(p, "utf8");
+    return readFileSync12(p, "utf8");
   } catch {
     return null;
   }
@@ -7015,21 +7361,21 @@ function overridePlan(override) {
   };
 }
 function detectPackageManager(worktree, io = {}) {
-  const exists = io.exists ?? existsSync8;
+  const exists = io.exists ?? existsSync9;
   const readText = io.readText ?? safeReadText;
-  const hasPkgJson = exists(join12(worktree, "package.json"));
+  const hasPkgJson = exists(join13(worktree, "package.json"));
   if (!hasPkgJson) {
-    if (exists(join12(worktree, "deno.json")) || exists(join12(worktree, "deno.jsonc")) || exists(join12(worktree, "deno.lock"))) return "deno";
+    if (exists(join13(worktree, "deno.json")) || exists(join13(worktree, "deno.jsonc")) || exists(join13(worktree, "deno.lock"))) return "deno";
     return null;
   }
-  const pkg = readJson(readText, join12(worktree, "package.json"));
+  const pkg = readJson(readText, join13(worktree, "package.json"));
   const declared = typeof pkg?.packageManager === "string" ? pkg.packageManager.split("@")[0] : void 0;
   if (declared === "pnpm" || declared === "bun" || declared === "npm" || declared === "yarn") return declared;
-  if (exists(join12(worktree, "bun.lock")) || exists(join12(worktree, "bun.lockb"))) return "bun";
-  if (exists(join12(worktree, "pnpm-lock.yaml"))) return "pnpm";
-  if (exists(join12(worktree, "yarn.lock"))) return "yarn";
-  if (exists(join12(worktree, "package-lock.json"))) return "npm";
-  if (exists(join12(worktree, "deno.lock"))) return "deno";
+  if (exists(join13(worktree, "bun.lock")) || exists(join13(worktree, "bun.lockb"))) return "bun";
+  if (exists(join13(worktree, "pnpm-lock.yaml"))) return "pnpm";
+  if (exists(join13(worktree, "yarn.lock"))) return "yarn";
+  if (exists(join13(worktree, "package-lock.json"))) return "npm";
+  if (exists(join13(worktree, "deno.lock"))) return "deno";
   return "npm";
 }
 function jsInstallCommand(pm) {
@@ -7082,7 +7428,7 @@ var ECOSYSTEM_MARKERS = [
   // конфигурация — дело сборки, не подготовки
 ];
 function detectPlan(worktree, io) {
-  const exists = io.exists ?? existsSync8;
+  const exists = io.exists ?? existsSync9;
   const listFiles = io.listFiles ?? safeListFiles;
   const pm = detectPackageManager(worktree, io);
   if (pm) {
@@ -7090,7 +7436,7 @@ function detectPlan(worktree, io) {
       // node_modules на месте — установку пропускаем (быстрый путь переиспользованного worktree).
       // У deno каталога может не быть вовсе (кэш в DENO_DIR) — тогда `deno install` отработает
       // заново, но он дешёвый: тянет из того же общего кэша.
-      { label: `${pm} install`, run: jsInstallCommand(pm), skipIfExists: join12(worktree, "node_modules"), source: "detect" }
+      { label: `${pm} install`, run: jsInstallCommand(pm), skipIfExists: join13(worktree, "node_modules"), source: "detect" }
     ];
     for (const target of workspaceBuildTargets(worktree, io)) {
       commands.push({ label: `\u0441\u0431\u043E\u0440\u043A\u0430 ${target.name}`, run: jsRunScript(pm, "build"), cwd: target.dir, source: "detect" });
@@ -7098,12 +7444,12 @@ function detectPlan(worktree, io) {
     return { source: "detect", ecosystem: `node/${pm}`, commands };
   }
   for (const marker of ECOSYSTEM_MARKERS) {
-    const hit = marker.files.some((f) => exists(join12(worktree, f))) || marker.ext !== void 0 && listFiles(worktree).some((n) => n.endsWith(marker.ext));
+    const hit = marker.files.some((f) => exists(join13(worktree, f))) || marker.ext !== void 0 && listFiles(worktree).some((n) => n.endsWith(marker.ext));
     if (!hit) continue;
     let ecosystem = marker.ecosystem;
     let command = marker.command;
     for (const refine of marker.refine ?? []) {
-      if (!exists(join12(worktree, refine.file))) continue;
+      if (!exists(join13(worktree, refine.file))) continue;
       ecosystem = refine.ecosystem;
       command = refine.command;
       break;
@@ -7160,12 +7506,12 @@ var CI_INSTALL_PATTERNS = [
 function ciWorkflowPlan(worktree, io) {
   const readText = io.readText ?? safeReadText;
   const listFiles = io.listFiles ?? safeListFiles;
-  const dir = join12(worktree, ".github", "workflows");
+  const dir = join13(worktree, ".github", "workflows");
   const files = listFiles(dir).filter((n) => n.endsWith(".yml") || n.endsWith(".yaml"));
   const seen = /* @__PURE__ */ new Set();
   const commands = [];
   for (const name of files.sort()) {
-    const yaml = readText(join12(dir, name));
+    const yaml = readText(join13(dir, name));
     if (yaml === null) continue;
     for (const raw of workflowRunLines(yaml)) {
       const line = raw.replace(/\s+/g, " ").trim();
@@ -7180,7 +7526,7 @@ function ciWorkflowPlan(worktree, io) {
   return commands.length ? { source: "ci-workflow", ecosystem: "ci-\u043A\u043E\u043D\u0444\u0438\u0433", commands } : null;
 }
 function workspaceGlobs(worktree, readText) {
-  const yaml = readText(join12(worktree, "pnpm-workspace.yaml"));
+  const yaml = readText(join13(worktree, "pnpm-workspace.yaml"));
   if (yaml !== null) {
     const globs = [];
     let inPackages = false;
@@ -7200,7 +7546,7 @@ function workspaceGlobs(worktree, readText) {
     }
     if (globs.length) return globs;
   }
-  const pkg = readJson(readText, join12(worktree, "package.json"));
+  const pkg = readJson(readText, join13(worktree, "package.json"));
   const ws = pkg?.workspaces;
   const list = Array.isArray(ws) ? ws : Array.isArray(ws?.packages) ? ws.packages : [];
   return list.filter((g) => typeof g === "string");
@@ -7211,14 +7557,14 @@ function workspaceDirs(worktree, globs, io) {
     if (glob.startsWith("!")) continue;
     const star = glob.indexOf("*");
     if (star === -1) {
-      const dir = join12(worktree, glob);
-      if (io.exists(join12(dir, "package.json"))) dirs.add(dir);
+      const dir = join13(worktree, glob);
+      if (io.exists(join13(dir, "package.json"))) dirs.add(dir);
       continue;
     }
-    const base3 = join12(worktree, glob.slice(0, star).replace(/\/$/, ""));
+    const base3 = join13(worktree, glob.slice(0, star).replace(/\/$/, ""));
     for (const name of io.listDirs(base3)) {
-      const dir = join12(base3, name);
-      if (io.exists(join12(dir, "package.json"))) dirs.add(dir);
+      const dir = join13(base3, name);
+      if (io.exists(join13(dir, "package.json"))) dirs.add(dir);
     }
   }
   return [...dirs];
@@ -7239,18 +7585,18 @@ function entryPaths(pkg) {
   return out;
 }
 function workspaceBuildTargets(worktree, io = {}) {
-  const exists = io.exists ?? existsSync8;
+  const exists = io.exists ?? existsSync9;
   const readText = io.readText ?? safeReadText;
   const listDirs = io.listDirs ?? safeListDirs;
   const globs = workspaceGlobs(worktree, readText);
   if (!globs.length) return [];
   const pkgs = [];
   for (const dir of workspaceDirs(worktree, globs, { exists, listDirs })) {
-    const pkg = readJson(readText, join12(dir, "package.json"));
+    const pkg = readJson(readText, join13(dir, "package.json"));
     if (!pkg || typeof pkg.name !== "string") continue;
     const scripts = pkg.scripts ?? {};
     const entries = entryPaths(pkg);
-    const needsBuild = typeof scripts.build === "string" && entries.length > 0 && entries.some((e) => !exists(join12(dir, e)));
+    const needsBuild = typeof scripts.build === "string" && entries.length > 0 && entries.some((e) => !exists(join13(dir, e)));
     const deps = Object.keys({ ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} });
     pkgs.push({ name: pkg.name, dir, deps, needsBuild });
   }
@@ -7278,7 +7624,7 @@ function planPrepare(worktree, io = {}) {
   return { ...plan, commands: plan.commands.slice(0, MAX_PLAN_COMMANDS) };
 }
 async function ensureWorktreeDeps(worktree, io = {}) {
-  const exists = io.exists ?? existsSync8;
+  const exists = io.exists ?? existsSync9;
   const exec = io.exec ?? ((cmd) => runCommand(cmd, worktree));
   const approve = io.approve ?? (() => true);
   const plan = planPrepare(worktree, io);
@@ -7377,6 +7723,12 @@ var AreaBusyError = class extends Error {
   }
   area;
 };
+function healTaskSlug(db, run, task) {
+  const slug = task?.slug;
+  if (!slug || slug === run.task_slug || !isTaskSlug(slug) || isTaskSlug(run.task_slug)) return run;
+  db.addEvent(run.id, "step", `\u0441\u043B\u0430\u0433 \u043F\u0440\u043E\u0433\u043E\u043D\u0430 \u0432\u043E\u0441\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D: ${run.task_slug} \u2192 ${slug} (\u043F\u0440\u043E\u0434 \u043E\u0442\u0434\u0430\u043B \u043F\u0440\u043E\u0433\u043E\u043D \u0431\u0435\u0437 \u0441\u043B\u0430\u0433\u0430 \u2014 TASWM-329)`);
+  return db.updateRun(run.id, { task_slug: slug }) ?? run;
+}
 async function spawnDrone(deps, run) {
   const repo = normalizeRepo(run.repo || deps.repo || "");
   if (!repo) throw new Error(`\u0443 \u043F\u0440\u043E\u0433\u043E\u043D\u0430 #${run.id} (${run.task_slug}) \u043D\u0435\u0442 repo \u0438 \u043D\u0435\u0442 \u0434\u0435\u0444\u043E\u043B\u0442\u0430 SWARM_REPO`);
@@ -7564,8 +7916,8 @@ function fullCommitHeadline(headline, body) {
   const head = typeof headline === "string" ? headline : "";
   if (!head) return null;
   if (!head.endsWith("\u2026") || typeof body !== "string" || !body.startsWith("\u2026")) return head;
-  const tail = body.slice(1).split("\n", 1)[0] ?? "";
-  return head.slice(0, -1) + tail;
+  const tail2 = body.slice(1).split("\n", 1)[0] ?? "";
+  return head.slice(0, -1) + tail2;
 }
 var NO_CHECKS_STDERR = /no checks reported/i;
 var realChecksRunner = async (pr) => {
@@ -8823,10 +9175,31 @@ function makeExclusiveReader(opts) {
 }
 
 // src/envGate.ts
-import { existsSync as existsSync10 } from "fs";
-import { join as join18, delimiter } from "path";
+import { existsSync as existsSync12 } from "fs";
+import { join as join20 } from "path";
 import { createConnection } from "net";
 import { execa as execa2 } from "execa";
+
+// src/platform.ts
+import { existsSync as existsSync11, readFileSync as readFileSync17 } from "fs";
+import { delimiter, join as join19 } from "path";
+function resolveCommandPath(name, env = process.env, platform = process.platform) {
+  if (name.includes("/") || name.includes("\\")) return existsSync11(name) ? name : null;
+  const dirs = (env.PATH ?? env.Path ?? "").split(delimiter).filter(Boolean);
+  const exts = platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").filter(Boolean) : [""];
+  for (const dir of dirs) {
+    for (const ext of exts) {
+      const candidate = join19(dir, name + ext);
+      if (existsSync11(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+function hasCommandInPath(name, env = process.env, platform = process.platform) {
+  return resolveCommandPath(name, env, platform) !== null;
+}
+
+// src/envGate.ts
 var PROBE_TIMEOUT_MS = 2500;
 var PORT_TIMEOUT_MS = 1e3;
 function parseRequirements(lines) {
@@ -8875,8 +9248,8 @@ var COMPOSE_MARKERS = [
   "compose.yaml"
 ];
 function detectRequirements(repo, io = {}) {
-  const exists = io.exists ?? existsSync10;
-  const marker = COMPOSE_MARKERS.find((f) => exists(join18(repo, f)));
+  const exists = io.exists ?? existsSync12;
+  const marker = COMPOSE_MARKERS.find((f) => exists(join20(repo, f)));
   return marker ? [{ kind: "docker", raw: `docker (\u0434\u0435\u0442\u0435\u043A\u0442: ${marker})` }] : [];
 }
 function resolveRequirements(repo, declared, io = {}) {
@@ -8895,17 +9268,14 @@ async function dockerAlive() {
   }
 }
 async function hasCommand(name, env) {
-  if (name.includes("/")) return existsSync10(name);
-  const dirs = (env.PATH ?? "").split(delimiter).filter(Boolean);
-  const exts = process.platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").filter(Boolean) : [""];
-  return dirs.some((dir) => exts.some((ext) => existsSync10(join18(dir, name + ext))));
+  return hasCommandInPath(name, env);
 }
 async function portOpen(host, port) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const socket = createConnection({ host, port });
     const finish = (ok) => {
       socket.destroy();
-      resolve3(ok);
+      resolve4(ok);
     };
     socket.setTimeout(PORT_TIMEOUT_MS);
     socket.once("connect", () => finish(true));
@@ -9015,8 +9385,8 @@ import { basename as basename3 } from "path";
 import { serve as serve2 } from "@hono/node-server";
 
 // src/diff.ts
-import { statSync as statSync6 } from "fs";
-import { join as join19 } from "path";
+import { statSync as statSync7 } from "fs";
+import { join as join21 } from "path";
 import { $ as $4 } from "execa";
 var MAX_FILES = 200;
 var MAX_LINES_PER_FILE = 1500;
@@ -9159,7 +9529,7 @@ async function resolveBase(wt, baseBranch) {
 }
 function mtime(path) {
   try {
-    return statSync6(path).mtimeMs;
+    return statSync7(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -9184,7 +9554,7 @@ async function collectRunDiff(worktree, opts = {}) {
       files.push(pf);
     }
   }
-  files.sort((a, b) => mtime(join19(worktree, b.path)) - mtime(join19(worktree, a.path)));
+  files.sort((a, b) => mtime(join21(worktree, b.path)) - mtime(join21(worktree, a.path)));
   const truncatedFiles = files.length > MAX_FILES;
   if (truncatedFiles) files = files.slice(0, MAX_FILES);
   const added = files.reduce((s, f) => s + f.added, 0);
@@ -9203,7 +9573,7 @@ async function collectRunDiff(worktree, opts = {}) {
 // package.json
 var package_default = {
   name: "@taskless-app/swarm",
-  version: "0.4.9",
+  version: "0.5.0",
   type: "module",
   description: "Local control plane for a fleet of AI coding agents (drones), coordinating through Taskless. The overmind runs the swarm.",
   keywords: [
@@ -9255,13 +9625,16 @@ var package_default = {
   }
 };
 
+// src/version.ts
+var PACKAGE_VERSION = package_default.version;
+var MIN_NODE_MAJOR = Number(/(\d+)/.exec(package_default.engines?.node ?? "")?.[1] ?? 0);
+
 // src/web.ts
 init_storm();
 init_resources();
 init_config();
 init_droneChannel();
 init_oauth();
-var PACKAGE_VERSION = package_default.version;
 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>`;
@@ -10569,7 +10942,8 @@ function daemonStatus(deps) {
     restart: deps.restart ? { phase: deps.restart.phase, intent: deps.restart.intent, sessions: live } : null,
     counts,
     live,
-    version: PACKAGE_VERSION
+    version: PACKAGE_VERSION,
+    repos: deps.repoMap?.() ?? []
   };
 }
 function eventsStream(db, narratorLog, control, daemonVersion, restart, liveSessionIds2, selfHost) {
@@ -10817,8 +11191,8 @@ function startWeb(deps, port = WEB_PORT) {
   return { port, server };
 }
 function closeWebServer(server) {
-  return new Promise((resolve3) => {
-    server.close(() => resolve3());
+  return new Promise((resolve4) => {
+    server.close(() => resolve4());
     server.closeAllConnections?.();
   });
 }
@@ -10862,6 +11236,253 @@ async function checkDaemonVersion(start, now = () => /* @__PURE__ */ new Date())
   }
 }
 
+// src/release.ts
+var SWARM_PACKAGE = "@taskless-app/swarm";
+var LATEST_TIMEOUT_MS = 4e3;
+async function fetchLatestVersion(opts = {}) {
+  const fetchFn = opts.fetchFn ?? fetch;
+  const timeoutMs = opts.timeoutMs ?? LATEST_TIMEOUT_MS;
+  const pkg = opts.pkg ?? SWARM_PACKAGE;
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const res = await fetchFn(`https://registry.npmjs.org/${pkg}/latest`, {
+      signal: ctrl.signal,
+      headers: { accept: "application/vnd.npm.install-v1+json, application/json" }
+    });
+    if (!res.ok) return null;
+    const body = await res.json();
+    return typeof body.version === "string" && body.version ? body.version : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function isOutdated(current, latest) {
+  if (!latest || !current) return false;
+  return compareVersionDirs(latest, current) > 0;
+}
+function outdatedLine(current, latest, updateCommand = "swarm update") {
+  if (!isOutdated(current, latest)) return null;
+  return `\u26A0 \u0432\u0435\u0440\u0441\u0438\u044F \u0440\u043E\u044F \u0443\u0441\u0442\u0430\u0440\u0435\u043B\u0430: \u0443 \u0442\u0435\u0431\u044F v${current}, \u043E\u043F\u0443\u0431\u043B\u0438\u043A\u043E\u0432\u0430\u043D\u0430 v${latest} \u2014 \u043E\u0431\u043D\u043E\u0432\u0438 \u043A\u043E\u043C\u0430\u043D\u0434\u043E\u0439: ${updateCommand}`;
+}
+
+// src/hostCommands.ts
+init_src();
+import { readFileSync as readFileSync18, renameSync as renameSync8, writeFileSync as writeFileSync13 } from "fs";
+import { join as join22 } from "path";
+function hostCommandStatePath(home) {
+  return join22(home, "host-command.json");
+}
+function readState(path) {
+  try {
+    return JSON.parse(readFileSync18(path, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeState(path, state) {
+  try {
+    writeFileSync13(`${path}.tmp`, JSON.stringify(state));
+    renameSync8(`${path}.tmp`, path);
+  } catch {
+  }
+}
+function savePendingAck(path, ack) {
+  writeState(path, { ...readState(path), pendingAck: ack });
+}
+function readPendingAck(path) {
+  return readState(path).pendingAck ?? null;
+}
+function clearPendingAck(path) {
+  const state = readState(path);
+  const pending2 = state.pendingAck ?? null;
+  if (pending2) writeState(path, { ...state, pendingAck: null });
+  return pending2;
+}
+async function flushPendingAck(path, ack) {
+  const state = readState(path);
+  const pending2 = state.pendingAck;
+  if (!pending2) return null;
+  writeState(path, { ...state, pendingAck: null });
+  try {
+    await ack(pending2.commandId, "done", { step: "restart", result: pending2.note });
+  } catch {
+  }
+  return pending2;
+}
+function loadMaxDronesOverride(path) {
+  const n = readState(path).maxDrones;
+  return typeof n === "number" && Number.isFinite(n) && n > 0 ? Math.trunc(n) : null;
+}
+function saveMaxDronesOverride(path, n) {
+  writeState(path, { ...readState(path), maxDrones: n });
+}
+async function executeHostCommands(opts) {
+  const now = opts.nowMs ?? Date.now();
+  let restarting = false;
+  for (const cmd of opts.commands) {
+    if (restarting) {
+      await opts.ack(cmd.id, "rejected", { result: "\u0434\u0435\u043C\u043E\u043D \u043F\u0435\u0440\u0435\u0437\u0430\u043F\u0443\u0441\u043A\u0430\u0435\u0442\u0441\u044F \u2014 \u043E\u0442\u0434\u0430\u0439 \u043A\u043E\u043C\u0430\u043D\u0434\u0443 \u0437\u0430\u043D\u043E\u0432\u043E, \u043A\u043E\u0433\u0434\u0430 \u043E\u043D \u043F\u043E\u0434\u043D\u0438\u043C\u0435\u0442\u0441\u044F" });
+      continue;
+    }
+    if (isHostCommandExpired(cmd.expiresAt, now)) {
+      await opts.ack(cmd.id, "rejected", { result: "\u043A\u043E\u043C\u0430\u043D\u0434\u0430 \u043F\u0440\u043E\u0441\u0440\u043E\u0447\u0435\u043D\u0430 \u2014 \u044F \u0431\u044B\u043B \u043D\u0435 \u043D\u0430 \u0441\u0432\u044F\u0437\u0438 \u0441\u043B\u0438\u0448\u043A\u043E\u043C \u0434\u043E\u043B\u0433\u043E" });
+      continue;
+    }
+    if (!isHostCommandKind(cmd.kind)) {
+      await opts.ack(cmd.id, "rejected", { result: `\u044D\u0442\u0430 \u0432\u0435\u0440\u0441\u0438\u044F \u0434\u0435\u043C\u043E\u043D\u0430 \u043D\u0435 \u0437\u043D\u0430\u0435\u0442 \u043A\u043E\u043C\u0430\u043D\u0434\u0443 \xAB${cmd.kind}\xBB \u2014 \u043E\u0431\u043D\u043E\u0432\u0438 \u0434\u0435\u043C\u043E\u043D` });
+      continue;
+    }
+    restarting = await executeOne(cmd, opts);
+  }
+}
+async function executeOne(cmd, opts) {
+  const { effects, ack, statePath } = opts;
+  const label = hostCommandLabel(cmd);
+  effects.narrate(`\u{1F4DF} \u041A\u043E\u043C\u0430\u043D\u0434\u0430 \u0438\u0437 Taskless: ${label}`);
+  try {
+    switch (cmd.kind) {
+      case "pause":
+        effects.pause();
+        await ack(cmd.id, "done", { result: "\u0440\u043E\u0439 \u043D\u0430 \u043F\u0430\u0443\u0437\u0435 \u2014 \u043D\u043E\u0432\u0443\u044E \u0440\u0430\u0431\u043E\u0442\u0443 \u043D\u0435 \u0431\u0435\u0440\u0443, \u0436\u0438\u0432\u044B\u0435 \u0434\u0440\u043E\u043D\u044B \u0434\u043E\u0440\u0430\u0431\u043E\u0442\u0430\u044E\u0442" });
+        return false;
+      case "resume":
+        if (!effects.resume()) {
+          await ack(cmd.id, "rejected", {
+            result: "\u0436\u0434\u0443 \u0431\u0435\u0437\u043E\u043F\u0430\u0441\u043D\u043E\u0433\u043E \u0440\u0435\u0441\u0442\u0430\u0440\u0442\u0430 \u2014 \u043F\u043E\u043A\u0430 \u043D\u0435 \u0441\u043D\u0438\u043C\u0443 \u043F\u0430\u0443\u0437\u0443, \u0438\u043D\u0430\u0447\u0435 \u0441\u043B\u043E\u0442\u044B \u043D\u0435 \u043E\u0441\u0432\u043E\u0431\u043E\u0434\u044F\u0442\u0441\u044F \u0438 \u0440\u0435\u0441\u0442\u0430\u0440\u0442 \u043D\u0435 \u0441\u043B\u0443\u0447\u0438\u0442\u0441\u044F"
+          });
+          return false;
+        }
+        await ack(cmd.id, "done", { result: "\u0441\u043D\u044F\u043B \u0441 \u043F\u0430\u0443\u0437\u044B \u2014 \u0441\u043D\u043E\u0432\u0430 \u0431\u0435\u0440\u0443 \u0437\u0430\u0434\u0430\u0447\u0438" });
+        return false;
+      case "set_max_drones": {
+        const n = cmd.maxDrones;
+        if (n == null || !Number.isFinite(n) || n < 1 || n > MAX_DRONES_LIMIT) {
+          await ack(cmd.id, "rejected", { result: `\u0447\u0438\u0441\u043B\u043E \u0434\u0440\u043E\u043D\u043E\u0432 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043E\u0442 1 \u0434\u043E ${MAX_DRONES_LIMIT}` });
+          return false;
+        }
+        const value = Math.trunc(n);
+        saveMaxDronesOverride(statePath, value);
+        effects.setMaxDrones(value);
+        await ack(cmd.id, "done", { result: `\u043F\u043E\u0442\u043E\u043B\u043E\u043A \u0434\u0440\u043E\u043D\u043E\u0432 \u043D\u0430 \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435: ${value}` });
+        return false;
+      }
+      case "stop_run": {
+        const slug = cmd.runSlug?.trim();
+        if (!slug) {
+          await ack(cmd.id, "rejected", { result: "\u043D\u0435 \u0441\u043A\u0430\u0437\u0430\u043D\u043E, \u043A\u0430\u043A\u043E\u0439 \u043F\u0440\u043E\u0433\u043E\u043D \u043E\u0441\u0442\u0430\u043D\u0430\u0432\u043B\u0438\u0432\u0430\u0442\u044C" });
+          return false;
+        }
+        const stopped = await effects.stopRun(slug, "\u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D \u043A\u043E\u043C\u0430\u043D\u0434\u043E\u0439 \u0438\u0437 Taskless");
+        if (!stopped) {
+          await ack(cmd.id, "rejected", { result: `\u0430\u043A\u0442\u0438\u0432\u043D\u043E\u0433\u043E \u043F\u0440\u043E\u0433\u043E\u043D\u0430 \u043F\u043E ${slug} \u0443 \u043C\u0435\u043D\u044F \u043D\u0435\u0442` });
+          return false;
+        }
+        await ack(cmd.id, "done", { result: `\u043F\u0440\u043E\u0433\u043E\u043D ${slug} \u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D` });
+        return false;
+      }
+      case "restart":
+        return await doRestart(cmd, opts, "\u043F\u0435\u0440\u0435\u0437\u0430\u043F\u0443\u0441\u0442\u0438\u043B\u0441\u044F \u043F\u043E \u043A\u043E\u043C\u0430\u043D\u0434\u0435 \u0438\u0437 Taskless");
+      case "update": {
+        const res = await effects.update(async (step, note) => {
+          await ack(cmd.id, "running", { step, result: note });
+        });
+        if (!res.ok) {
+          await ack(cmd.id, "failed", { step: res.step, result: `${UPDATE_STEP_LABELS[res.step]}: ${res.message}` });
+          effects.narrate(`\u26A0\uFE0F \u041E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u0435 \u0441\u043E\u0440\u0432\u0430\u043B\u043E\u0441\u044C \u043D\u0430 \u0448\u0430\u0433\u0435 \xAB${UPDATE_STEP_LABELS[res.step]}\xBB: ${res.message}`);
+          return false;
+        }
+        return await doRestart(cmd, opts, res.message);
+      }
+    }
+  } catch (e) {
+    await ack(cmd.id, "failed", { result: e instanceof Error ? e.message : String(e) });
+    return false;
+  }
+}
+async function doRestart(cmd, opts, note) {
+  const { effects, ack, statePath } = opts;
+  savePendingAck(statePath, { commandId: cmd.id, kind: cmd.kind, note });
+  const { waiting, sessions } = effects.requestRestart();
+  if (waiting) {
+    await ack(cmd.id, "running", {
+      step: "restart",
+      result: `\u043F\u0435\u0440\u0435\u0437\u0430\u043F\u0443\u0449\u0443, \u043A\u043E\u0433\u0434\u0430 \u043E\u0441\u0432\u043E\u0431\u043E\u0434\u044F\u0442\u0441\u044F \u0441\u043B\u043E\u0442\u044B: \u0441\u0435\u0439\u0447\u0430\u0441 \u0440\u0430\u0431\u043E\u0442\u0430\u044E\u0442 ${sessions.length} \u2014 \u043E\u043D\u0438 \u0431\u044B \u043E\u0441\u0438\u0440\u043E\u0442\u0435\u043B\u0438`
+    });
+    effects.narrate(`\u23F3 \u0420\u0435\u0441\u0442\u0430\u0440\u0442 \u043F\u043E \u043A\u043E\u043C\u0430\u043D\u0434\u0435 \u0438\u0437 Taskless \u043E\u0442\u043B\u043E\u0436\u0435\u043D: \u0436\u0434\u0443 \u0437\u0430\u0432\u0435\u0440\u0448\u0435\u043D\u0438\u044F \u0436\u0438\u0432\u044B\u0445 \u0441\u0435\u0441\u0441\u0438\u0439 (${sessions.length})`);
+    return true;
+  }
+  await ack(cmd.id, "running", { step: "restart", result: "\u043F\u0435\u0440\u0435\u0437\u0430\u043F\u0443\u0441\u043A\u0430\u044E\u0441\u044C" });
+  return true;
+}
+
+// src/selfUpdate.ts
+init_git();
+import { existsSync as existsSync13 } from "fs";
+import { join as join23 } from "path";
+import { $ as $6 } from "execa";
+var DAEMON_PACKAGE = "@taskless-app/swarm";
+var defaultRun = async (cmd, args, cwd) => {
+  const res = await $6({ reject: false, cwd })(cmd, args);
+  return { exitCode: res.exitCode ?? 1, stdout: res.stdout ?? "", stderr: res.stderr ?? "" };
+};
+function tail(text, max = 400) {
+  const t = text.trim();
+  return t.length <= max ? t : `\u2026${t.slice(-max)}`;
+}
+async function runSelfUpdate(io) {
+  const run = io.run ?? defaultRun;
+  const exists = io.exists ?? existsSync13;
+  const repo = io.repo;
+  await io.onStep("fetch", "\u0442\u044F\u043D\u0443 \u0441\u0432\u0435\u0436\u0438\u0439 \u043A\u043E\u0434");
+  const fetched = await run("git", ["-C", repo, "fetch", "--quiet", "origin"], repo);
+  if (fetched.exitCode !== 0) {
+    return { ok: false, step: "fetch", message: `git fetch \u043D\u0435 \u043F\u0440\u043E\u0448\u0451\u043B: ${tail(fetched.stderr || fetched.stdout)}` };
+  }
+  await io.onStep("checkout", "\u043F\u0435\u0440\u0435\u043A\u043B\u044E\u0447\u0430\u044E\u0441\u044C \u043D\u0430 \u0441\u0432\u0435\u0436\u0438\u0439 main");
+  const dirty = await run("git", ["-C", repo, "status", "--porcelain"], repo);
+  if (dirty.exitCode !== 0) {
+    return { ok: false, step: "checkout", message: `\u043D\u0435 \u0441\u043C\u043E\u0433 \u043F\u0440\u043E\u0447\u0438\u0442\u0430\u0442\u044C \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u044F: ${tail(dirty.stderr)}` };
+  }
+  if (dirty.stdout.trim()) {
+    return {
+      ok: false,
+      step: "checkout",
+      message: "\u0432 \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0438 \u0434\u0435\u043C\u043E\u043D\u0430 \u0435\u0441\u0442\u044C \u043D\u0435\u0437\u0430\u043A\u043E\u043C\u043C\u0438\u0447\u0435\u043D\u043D\u044B\u0435 \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u044F \u2014 \u043D\u0435 \u0442\u0440\u043E\u0433\u0430\u044E \u0438\u0445. \u041F\u0440\u0438\u0431\u0435\u0440\u0438 \u0440\u0443\u043A\u0430\u043C\u0438 \u0438 \u043F\u043E\u0432\u0442\u043E\u0440\u0438 \u043E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u0435."
+    };
+  }
+  const ref = await io.mainRef(repo);
+  const merged = await run("git", ["-C", repo, "merge", "--ff-only", ref], repo);
+  if (merged.exitCode !== 0) {
+    return {
+      ok: false,
+      step: "checkout",
+      message: `\u043D\u0435 \u043F\u0435\u0440\u0435\u043C\u0430\u0442\u044B\u0432\u0430\u0435\u0442\u0441\u044F \u043D\u0430 ${ref} (\u0441\u0432\u043E\u044F \u0432\u0435\u0442\u043A\u0430/\u0440\u0430\u0441\u0445\u043E\u0436\u0434\u0435\u043D\u0438\u0435 \u0441 main): ${tail(merged.stderr || merged.stdout)}`
+    };
+  }
+  await io.onStep("install", "\u0441\u0442\u0430\u0432\u043B\u044E \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0438");
+  if (!exists(join23(repo, "pnpm-lock.yaml"))) {
+    return { ok: false, step: "install", message: "\u0432 \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0438 \u0434\u0435\u043C\u043E\u043D\u0430 \u043D\u0435\u0442 pnpm-lock.yaml \u2014 \u043E\u0431\u043D\u043E\u0432\u043B\u044F\u0442\u044C \u0435\u0433\u043E \u044D\u0442\u0438\u043C \u043F\u0443\u0442\u0451\u043C \u043D\u0435 \u0431\u0435\u0440\u0443\u0441\u044C" };
+  }
+  const installed = await run("pnpm", ["install", "--frozen-lockfile"], repo);
+  if (installed.exitCode !== 0) {
+    return { ok: false, step: "install", message: `pnpm install \u043D\u0435 \u043F\u0440\u043E\u0448\u0451\u043B: ${tail(installed.stderr || installed.stdout)}` };
+  }
+  await io.onStep("build", "\u0441\u043E\u0431\u0438\u0440\u0430\u044E \u043F\u0430\u043A\u0435\u0442\u044B \u0432\u043E\u0440\u043A\u0441\u043F\u0435\u0439\u0441\u0430");
+  const built = await run("pnpm", ["--filter", `${DAEMON_PACKAGE}...`, "build"], repo);
+  if (built.exitCode !== 0) {
+    return { ok: false, step: "build", message: `\u0441\u0431\u043E\u0440\u043A\u0430 \u043D\u0435 \u043F\u0440\u043E\u0448\u043B\u0430: ${tail(built.stderr || built.stdout)}` };
+  }
+  const head = await run("git", ["-C", repo, "rev-parse", "--short", "HEAD"], repo);
+  const sha = head.exitCode === 0 ? head.stdout.trim() : "";
+  return { ok: true, step: "build", message: sha ? `\u043A\u043E\u0434 \u043E\u0431\u043D\u043E\u0432\u043B\u0451\u043D \u0434\u043E ${sha}, \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0438 \u0438 \u0441\u0431\u043E\u0440\u043A\u0430 \u0433\u043E\u0442\u043E\u0432\u044B` : "\u043A\u043E\u0434 \u043E\u0431\u043D\u043E\u0432\u043B\u0451\u043D, \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0438 \u0438 \u0441\u0431\u043E\u0440\u043A\u0430 \u0433\u043E\u0442\u043E\u0432\u044B" };
+}
+function defaultSelfUpdateIO(repo, onStep) {
+  return { repo, run: defaultRun, mainRef: remoteMainRef, onStep };
+}
+
 // src/narration.ts
 var RING_LIMIT = 20;
 function makeOvermindNarrator() {
@@ -10882,7 +11503,7 @@ var RESET_RE = /resets[^\n]*/i;
 function anthropicHealthy(opts = {}) {
   const bin = opts.claudeBin ?? resolveClaudeBin();
   const timeoutMs = opts.timeoutMs ?? 2e4;
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     let done = false;
     let out = "";
     const finish = (r) => {
@@ -10893,7 +11514,7 @@ function anthropicHealthy(opts = {}) {
         child.kill("SIGKILL");
       } catch {
       }
-      resolve3(r);
+      resolve4(r);
     };
     const child = spawn2(bin, [...ISOLATION_FLAGS, "-p", "ok", "--max-turns", "1"], { stdio: ["ignore", "pipe", "pipe"] });
     child.stdout?.on("data", (d) => {
@@ -10932,16 +11553,16 @@ async function fetchExternalStorm(url, opts = {}) {
 }
 
 // src/anomalyState.ts
-import { existsSync as existsSync11, readFileSync as readFileSync16, renameSync as renameSync6, writeFileSync as writeFileSync12 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync19, renameSync as renameSync9, writeFileSync as writeFileSync14 } from "fs";
+import { join as join24 } from "path";
 var KEY_TTL_MS = 7 * 24 * 60 * 6e4;
 var EMPTY = { since: {}, lastFiredAt: {}, fires: {}, stopQuiet: null };
 function anomalyStatePath(home) {
-  return join20(home, "anomaly-state.json");
+  return join24(home, "anomaly-state.json");
 }
 function loadAnomalyState(home, now = Date.now(), io = {}) {
-  const exists = io.exists ?? existsSync11;
-  const readFile2 = io.readFile ?? ((p) => readFileSync16(p, "utf8"));
+  const exists = io.exists ?? existsSync14;
+  const readFile2 = io.readFile ?? ((p) => readFileSync19(p, "utf8"));
   const path = anomalyStatePath(home);
   if (!exists(path)) return { ...EMPTY };
   try {
@@ -10967,8 +11588,8 @@ function loadAnomalyState(home, now = Date.now(), io = {}) {
 function saveAnomalyState(home, state, io = {}) {
   const path = anomalyStatePath(home);
   const writeFile2 = io.writeFile ?? ((p, data) => {
-    writeFileSync12(`${p}.tmp`, data);
-    renameSync6(`${p}.tmp`, p);
+    writeFileSync14(`${p}.tmp`, data);
+    renameSync9(`${p}.tmp`, p);
   });
   writeFile2(path, JSON.stringify(state, null, 2));
 }
@@ -11610,10 +12231,10 @@ ${task.description}` : `\u0417\u0430\u0434\u0430\u0447\u0430 ${run.task_slug} (\
   }
   return parts.join("\n");
 }
-var HERO_CHARTER_PATH = join21(dirname5(THIS_FILE), "..", "docs", "HERO.md");
+var HERO_CHARTER_PATH = join25(dirname5(THIS_FILE), "..", "docs", "HERO.md");
 function buildHeroPrompt(task, run, taskContext, attachmentsBlock) {
   const name = run.name || `#${run.id}`;
-  const charter = readFileSync17(HERO_CHARTER_PATH, "utf8");
+  const charter = readFileSync20(HERO_CHARTER_PATH, "utf8");
   const head = task ? `\u042D\u041F\u0418\u041A ${run.task_slug}: ${task.title}
 
 ${task.description}` : `\u042D\u041F\u0418\u041A ${run.task_slug} (\u0442\u0435\u043B\u043E \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u043D\u043E \u2014 \u0440\u0430\u0431\u043E\u0442\u0430\u0439 \u043F\u043E slug \u0438 \u0437\u0434\u0440\u0430\u0432\u043E\u043C\u0443 \u0441\u043C\u044B\u0441\u043B\u0443).`;
@@ -11864,7 +12485,7 @@ async function wakeRun(deps, runId) {
   if (!run) return { ok: false, why: `\u043F\u0440\u043E\u0433\u043E\u043D #${runId} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D \u0432 \u0437\u0435\u0440\u043A\u0430\u043B\u0435 \u0440\u043E\u044F` };
   if (run.pid != null && deps.isAlive(run.pid)) return { ok: false, why: `\u043F\u0440\u043E\u0433\u043E\u043D #${runId} \u0443\u0436\u0435 \u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442 (pid ${run.pid}) \u2014 \u0431\u0443\u0434\u0438\u0442\u044C \u043D\u0435\u0447\u0435\u0433\u043E` };
   if (isTerminalStatus(run.status)) return { ok: false, why: `\u043F\u0440\u043E\u0433\u043E\u043D #${runId} \u0442\u0435\u0440\u043C\u0438\u043D\u0430\u043B\u0435\u043D (${run.status}) \u2014 \u0431\u0443\u0434\u0438\u0442\u044C \u043D\u0435\u0447\u0435\u0433\u043E` };
-  const worktreeExists = deps.worktreeExists ?? existsSync12;
+  const worktreeExists = deps.worktreeExists ?? existsSync15;
   const hasTranscript = deps.hasTranscript ?? sessionTranscriptExists;
   const wt = run.worktree_path;
   const canContinue = !!wt && worktreeExists(wt) && hasTranscript(wt);
@@ -11949,7 +12570,7 @@ function repoHasCi(deps, run) {
 function repoHasCiWorkflows(worktreePath, repo) {
   for (const base3 of [worktreePath, repo]) {
     if (!base3) continue;
-    const dir = join21(base3, ".github", "workflows");
+    const dir = join25(base3, ".github", "workflows");
     try {
       if (readdirSync10(dir).some((f) => f.endsWith(".yml") || f.endsWith(".yaml"))) return true;
     } catch {
@@ -12098,7 +12719,7 @@ async function wakeReviewerOnCiReady(deps, run, over) {
   return true;
 }
 function worktreeAndTranscriptAlive(deps, worktree) {
-  const exists = deps.worktreeExists ?? existsSync12;
+  const exists = deps.worktreeExists ?? existsSync15;
   const transcript = deps.hasTranscript ?? sessionTranscriptExists;
   return exists(worktree) && transcript(worktree);
 }
@@ -12241,6 +12862,15 @@ async function exclusiveGateAllows(deps, run) {
   }
   return true;
 }
+function pruneGateLogs(deps) {
+  if (!deps.envGateLogged?.size && !deps.exclusiveLogged?.size) return;
+  const open = /* @__PURE__ */ new Set();
+  for (const run of deps.db.listRuns()) if (!isTerminalStatus(run.status)) open.add(run.id);
+  for (const map of [deps.envGateLogged, deps.exclusiveLogged]) {
+    if (!map) continue;
+    for (const id of [...map.keys()]) if (!open.has(id)) map.delete(id);
+  }
+}
 async function exclusivityBlockedRunIds(deps) {
   const blocked = /* @__PURE__ */ new Set();
   if (!deps.exclusiveProject) return blocked;
@@ -12303,7 +12933,7 @@ async function resumeWatchdogParked(deps, droneCap) {
   }
   if (!candidate) return;
   if (candidate.pid != null && deps.isAlive(candidate.pid)) return;
-  const worktreeExists = deps.worktreeExists ?? existsSync12;
+  const worktreeExists = deps.worktreeExists ?? existsSync15;
   const hasTranscript = deps.hasTranscript ?? sessionTranscriptExists;
   const wt = candidate.worktree_path;
   const canContinue = !!wt && worktreeExists(wt) && hasTranscript(wt);
@@ -12472,7 +13102,7 @@ async function manageRelief(deps, now, droneCap, stormActive) {
     if (resumeCandidate.pid != null && deps.isAlive(resumeCandidate.pid)) return;
     if (!deps.respawn) return;
     const wt = resumeCandidate.worktree_path;
-    const worktreeExists = deps.worktreeExists ?? existsSync12;
+    const worktreeExists = deps.worktreeExists ?? existsSync15;
     const hasTranscript = deps.hasTranscript ?? sessionTranscriptExists;
     const canContinue = !!wt && worktreeExists(wt) && hasTranscript(wt);
     const mode = canContinue ? "continue" : "fresh";
@@ -12634,7 +13264,7 @@ function buildEscalationCandidates(db) {
 }
 async function tickOnce(deps) {
   const now = deps.now ? deps.now() : Date.now();
-  const worktreeExists = deps.worktreeExists ?? existsSync12;
+  const worktreeExists = deps.worktreeExists ?? existsSync15;
   const hasTranscript = deps.hasTranscript ?? sessionTranscriptExists;
   if (deps.rehydrate) {
     const rh = deps.rehydrate;
@@ -12686,6 +13316,18 @@ async function tickOnce(deps) {
       await dv.run();
     }
   }
+  if (deps.repoMap) {
+    const rm3 = deps.repoMap;
+    const sinceLast = rm3.lastAt == null ? Infinity : now - rm3.lastAt;
+    if (sinceLast >= rm3.intervalMs) {
+      rm3.lastAt = now;
+      try {
+        await rm3.run();
+      } catch (e) {
+        console.error("[overmind] \u043E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u0435 \u043A\u0430\u0440\u0442\u044B \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0435\u0432 \u0441\u043E\u0440\u0432\u0430\u043B\u043E\u0441\u044C:", e);
+      }
+    }
+  }
   if (deps.rehydrate && deps.kill) {
     const kill = deps.kill;
     for (const run of deps.db.listRuns()) {
@@ -12711,6 +13353,19 @@ async function tickOnce(deps) {
       }
     }
   }
+  if (deps.logRotate) {
+    const lr = deps.logRotate;
+    const sinceLast = lr.lastAt == null ? Infinity : now - lr.lastAt;
+    if (sinceLast >= lr.intervalMs) {
+      lr.lastAt = now;
+      try {
+        lr.run();
+      } catch (e) {
+        console.error("[overmind] \u0440\u043E\u0442\u0430\u0446\u0438\u044F \u043B\u043E\u0433\u0430 \u0434\u0435\u043C\u043E\u043D\u0430 \u0441\u043E\u0440\u0432\u0430\u043B\u0430\u0441\u044C:", e);
+      }
+    }
+  }
+  pruneGateLogs(deps);
   let stormActive = false;
   if (deps.storm) {
     for (const run of deps.db.listRuns("running")) {
@@ -13240,7 +13895,7 @@ async function resolveConflict(deps, reviewRun) {
     workspace_id: reviewRun.workspace_id
     // та же задача, тот же воркспейс (TASWM-288)
   });
-  const wt = join21(deps.worktreesDir, basename4(repo), `${reviewRun.task_slug}-resolve-${resolver.id}`);
+  const wt = join25(deps.worktreesDir, basename4(repo), `${reviewRun.task_slug}-resolve-${resolver.id}`);
   try {
     await deps.git.prepareDetachedWorktree(repo, branch, wt);
     await deps.git.setWorktreeIdentity(wt, resolver.name);
@@ -13292,7 +13947,7 @@ async function spawnReviewer(deps, reviewRun, files) {
     // (своей у ревьюера нет, TASWM-204), и коммент с вердиктом должен уехать именно туда.
     workspace_id: reviewRun.workspace_id
   });
-  const wt = join21(deps.worktreesDir, basename4(repo), `${reviewRun.task_slug}-review-${reviewer.id}`);
+  const wt = join25(deps.worktreesDir, basename4(repo), `${reviewRun.task_slug}-review-${reviewer.id}`);
   try {
     await deps.git.prepareDetachedWorktree(repo, branch, wt);
     await deps.git.setWorktreeIdentity(wt, reviewer.name);
@@ -13327,7 +13982,7 @@ async function respawnRun(deps, run, mode, nudge) {
   ]);
   const base3 = effectiveBaseBranch(run.base_branch, projectBase);
   const runToSpawn = base3 && run.base_branch !== base3 ? deps.db.updateRun(run.id, { base_branch: base3 }) ?? run : run;
-  if (!existsSync12(wt)) {
+  if (!existsSync15(wt)) {
     const branch = runToSpawn.branch || runToSpawn.task_slug;
     const source = await addWorktree(repo, wt, branch, {
       ...base3 ? { base: await remoteBaseRef(repo, base3) } : {},
@@ -13352,11 +14007,11 @@ async function respawnRun(deps, run, mode, nudge) {
   const prompt = notice ? `${freshPrompt}
 
 ${notice}` : freshPrompt;
-  const pid = deps.launch({ worktree: wt, run, prompt });
+  const pid = deps.launch({ worktree: wt, run: runToSpawn, prompt });
   deps.db.updateRun(run.id, { status: "running", pid });
 }
 async function syncCrashedOnStartup(deps) {
-  const worktreeExists = deps.worktreeExists ?? existsSync12;
+  const worktreeExists = deps.worktreeExists ?? existsSync15;
   let orphaned = 0;
   let merged = 0;
   let requeued = 0;
@@ -13419,39 +14074,37 @@ async function makeStore(repo, worktreesDir, repoFlag) {
       console.warn(`[overmind] \u043D\u0435 \u0441\u043C\u043E\u0433 \u0437\u0430\u043F\u043E\u043C\u043D\u0438\u0442\u044C \u043F\u0443\u0442\u044C \u043A \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u044E (${e instanceof Error ? e.message : e}) \u2014 \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0438\u0439 \u0437\u0430\u043F\u0443\u0441\u043A \u0441\u043D\u043E\u0432\u0430 \u043F\u043E\u043F\u0440\u043E\u0441\u0438\u0442 --repo`);
     }
   }
+  const scanRootsList = resolveScanRoots(SWARM_SCAN_ROOTS_RAW, homedir4(), repoPaths);
+  const repoMap = emptyRepoMapState(scanRootsList);
   if (SWARM_BACKEND !== "client") {
     const { SwarmDb: SwarmDb2 } = await loadSqlite();
-    return { store: new SwarmDb2(DB_PATH, repo), reconciled: true, host };
+    return { store: new SwarmDb2(DB_PATH, repo), reconciled: true, host, repoMap };
   }
   const call = resilientSwarmMcp({
     onDown: (ms) => console.warn(`[overmind] \u043F\u0440\u043E\u0434-MCP \u043C\u043E\u043B\u0447\u0438\u0442 ${Math.round(ms / 1e3)}\u0441 \u2014 \u0440\u043E\u0439 \u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442 \u0432\u0441\u043B\u0435\u043F\u0443\u044E, \u0441\u0434\u0430\u0447\u0438 \u0438 \u0432\u0435\u0440\u0434\u0438\u043A\u0442\u044B \u043D\u0435 \u0434\u043E\u0435\u0437\u0436\u0430\u044E\u0442.`),
     onUp: () => console.warn("[overmind] \u043F\u0440\u043E\u0434-MCP \u0441\u043D\u043E\u0432\u0430 \u043D\u0430 \u0441\u0432\u044F\u0437\u0438.")
   });
   const explicitRegistry = await buildRepoRegistry(repoPaths);
-  const byName = new Map(explicitRegistry.map((e) => [e.repoFullName, e.path]));
-  const scanRootsList = defaultScanRoots(homedir3(), repoPaths);
-  const scanStartedAt = Date.now();
-  const scanned = scanRoots(scanRootsList, { maxDepth: SWARM_SCAN_DEPTH });
-  let addedByScan = 0;
-  for (const [full, path] of scanned) {
-    if (byName.has(full)) continue;
-    byName.set(full, path);
-    addedByScan++;
-  }
-  if (addedByScan > 0) {
-    console.log(
-      `[overmind] \u043D\u0430\u0448\u0451\u043B \u043D\u0430 \u043C\u0430\u0448\u0438\u043D\u0435 ${addedByScan} \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0439(\u0435\u0432) \u0441\u043A\u0430\u043D\u043E\u043C \u0437\u0430 ${Date.now() - scanStartedAt}\u043C\u0441: ${[...scanned.keys()].slice(0, 8).join(", ")}${scanned.size > 8 ? ` \u0438 \u0435\u0449\u0451 ${scanned.size - 8}` : ""}`
-    );
-  }
-  const repoRegistry = [...byName].map(([repoFullName, path]) => ({ repoFullName, path }));
-  if (repoPaths.length > 0 && repoRegistry.length < repoPaths.length) {
+  if (repoPaths.length > 0 && explicitRegistry.length < repoPaths.length) {
     console.warn(
-      `[overmind] \u0440\u0435\u043F\u043E-\u0440\u0435\u0435\u0441\u0442\u0440: ${repoRegistry.length}/${repoPaths.length} \u043F\u0443\u0442\u0435\u0439 \u0440\u0435\u0437\u043E\u043B\u0432\u043D\u0443\u043B\u0438\u0441\u044C \u0432 repoFullName (\u043E\u0441\u0442\u0430\u043B\u044C\u043D\u044B\u0435 \u2014 \u043D\u0435 git-\u0440\u0435\u043F\u043E \u0438\u043B\u0438 \u0431\u0435\u0437 remote origin)`
+      `[overmind] \u0440\u0435\u043F\u043E-\u0440\u0435\u0435\u0441\u0442\u0440: ${explicitRegistry.length}/${repoPaths.length} \u043F\u0443\u0442\u0435\u0439 \u0440\u0435\u0437\u043E\u043B\u0432\u043D\u0443\u043B\u0438\u0441\u044C \u0432 repoFullName (\u043E\u0441\u0442\u0430\u043B\u044C\u043D\u044B\u0435 \u2014 \u043D\u0435 git-\u0440\u0435\u043F\u043E \u0438\u043B\u0438 \u0431\u0435\u0437 remote origin)`
     );
   }
+  const rebuildRegistry = () => refreshRepoMap({
+    call,
+    configured: explicitRegistry,
+    roots: scanRootsList,
+    maxDepth: SWARM_SCAN_DEPTH,
+    cachePath: REPO_MAP_PATH,
+    state: repoMap,
+    log: (m) => console.log(m)
+  });
+  const repoRegistry = await rebuildRegistry();
   if (repoRegistry.length === 0) {
     console.warn(
-      `[overmind] \u041D\u0415 \u041D\u0410\u0428\u0401\u041B \u041D\u0418 \u041E\u0414\u041D\u041E\u0413\u041E \u0420\u0415\u041F\u041E\u0417\u0418\u0422\u041E\u0420\u0418\u042F \u043D\u0430 \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435 \u2014 \u0441\u0432\u043E\u0431\u043E\u0434\u043D\u044B\u0435 \u043F\u0440\u043E\u0433\u043E\u043D\u044B \u0431\u0440\u0430\u0442\u044C\u0441\u044F \u043D\u0435 \u0431\u0443\u0434\u0443\u0442: \u0438\u0445 \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0439 \u043F\u0440\u0438\u0445\u043E\u0434\u0438\u0442 \u0438\u043C\u0435\u043D\u0435\u043C owner/repo, \u0430 \u0441\u043E\u043F\u043E\u0441\u0442\u0430\u0432\u0438\u0442\u044C \u0435\u0433\u043E \u043D\u0435 \u0441 \u0447\u0435\u043C. \u0418\u0441\u043A\u0430\u043B \u0432: ${scanRootsList.slice(0, 6).join(", ")}. \u0415\u0441\u043B\u0438 \u043A\u043B\u043E\u043D\u044B \u043B\u0435\u0436\u0430\u0442 \u0432 \u0434\u0440\u0443\u0433\u043E\u043C \u043C\u0435\u0441\u0442\u0435 \u2014 \u0443\u043A\u0430\u0436\u0438: swarm start --repo <\u043F\u0443\u0442\u044C \u043A \u0440\u0435\u043F\u043E> (\u0437\u0430\u043F\u043E\u043C\u043D\u0438\u0442\u0441\u044F).`
+      `[overmind] \u041D\u0415 \u041D\u0410\u0428\u0401\u041B \u041D\u0418 \u041E\u0414\u041D\u041E\u0413\u041E \u0420\u0415\u041F\u041E\u0417\u0418\u0422\u041E\u0420\u0418\u042F \u043D\u0430 \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435 \u2014 \u0441\u0432\u043E\u0431\u043E\u0434\u043D\u044B\u0435 \u043F\u0440\u043E\u0433\u043E\u043D\u044B \u0431\u0440\u0430\u0442\u044C\u0441\u044F \u043D\u0435 \u0431\u0443\u0434\u0443\u0442: \u0438\u0445 \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0439 \u043F\u0440\u0438\u0445\u043E\u0434\u0438\u0442 \u0438\u043C\u0435\u043D\u0435\u043C owner/repo, \u0430 \u0441\u043E\u043F\u043E\u0441\u0442\u0430\u0432\u0438\u0442\u044C \u0435\u0433\u043E \u043D\u0435 \u0441 \u0447\u0435\u043C. \u0418\u0441\u043A\u0430\u043B \u0432: ${scanRootsList.slice(0, 6).join(", ")}. ` + // TASWM-336: почему пусто — три РАЗНЫЕ причины, и лечатся они по-разному. Одна
+      // общая фраза заставляла бы человека гадать, что из этого его случай.
+      (repoMap.unknown ? "\u041F\u0440\u043E\u0434 \u043D\u0435 \u0441\u043A\u0430\u0437\u0430\u043B, \u043A\u0430\u043A\u0438\u0435 \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0438 \u0443 \u0440\u043E\u044F, \u2014 \u043F\u0440\u043E\u0432\u0435\u0440\u044C `swarm login` \u0438 \u0434\u043E\u0441\u0442\u0443\u043F\u043D\u043E\u0441\u0442\u044C \u0441\u0435\u0440\u0432\u0435\u0440\u0430. " : repoMap.missing.length ? `\u041D\u0438 \u043E\u0434\u043D\u043E\u0433\u043E \u0438\u0437 ${repoMap.missing.length} \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0435\u0432 \u0440\u043E\u044F \u0442\u0443\u0442 \u043D\u0435\u0442. ` : "\u0423 \u0432\u043B\u0430\u0434\u0435\u043B\u044C\u0446\u0430 \u043D\u0435\u0442 \u043F\u0440\u043E\u0435\u043A\u0442\u043E\u0432 \u0441 \u0432\u043A\u043B\u044E\u0447\u0451\u043D\u043D\u044B\u043C \u0440\u043E\u0435\u043C. ") + "\u0415\u0441\u043B\u0438 \u043A\u043B\u043E\u043D\u044B \u043B\u0435\u0436\u0430\u0442 \u0432 \u0434\u0440\u0443\u0433\u043E\u043C \u043C\u0435\u0441\u0442\u0435 \u2014 \u0443\u043A\u0430\u0436\u0438: swarm start --repo <\u043F\u0443\u0442\u044C \u043A \u0440\u0435\u043F\u043E> (\u0437\u0430\u043F\u043E\u043C\u043D\u0438\u0442\u0441\u044F)."
     );
   }
   const client = new SwarmClient({ call, outboxPath: SWARM_OUTBOX, defaultRepo: repo, repoRegistry, host });
@@ -13466,7 +14119,17 @@ async function makeStore(repo, worktreesDir, repoFlag) {
       `overmind backend=client (\u0442\u043E\u043D\u043A\u0438\u0439 \u043A\u043B\u0438\u0435\u043D\u0442, outbox=${SWARM_OUTBOX}); \u0440\u0435\u043A\u043E\u043D\u0441\u0430\u0439\u043B \u043D\u0435 \u0443\u0434\u0430\u043B\u0441\u044F (ps \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D) \u2014 running/blocked \u043E\u0441\u0442\u0430\u044E\u0442\u0441\u044F \u043D\u0435\u0440\u0435\u043A\u043E\u043D\u0441\u0438\u043B\u0438\u0440\u043E\u0432\u0430\u043D\u044B, startup-sync (TASWM-128) \u0431\u0443\u0434\u0435\u0442 \u043F\u0440\u043E\u043F\u0443\u0449\u0435\u043D`
     );
   }
-  return { store: client, reconciled: rec.reconciled, host };
+  return {
+    store: client,
+    reconciled: rec.reconciled,
+    host,
+    repoMap,
+    // Периодическая пересборка (шаг 0a4 тика): применяем новый реестр к ЖИВОМУ клиенту —
+    // и список для claim/heartbeat, и обратную карту owner/repo → путь.
+    refreshRepoMap: async () => {
+      client.setRepoRegistry(await rebuildRegistry());
+    }
+  };
 }
 var crashGuardsInstalled = false;
 function installCrashGuards() {
@@ -13485,7 +14148,7 @@ async function migrateWorktreesAtStartup() {
       legacyDir: WORKTREES_LEGACY_DIR,
       targetDir: WORKTREES_DIR,
       envOverride: process.env.SWARM_WORKTREES || "",
-      exists: (d) => existsSync12(d),
+      exists: (d) => existsSync15(d),
       isNonEmptyDir: (d) => {
         try {
           return readdirSync10(d).length > 0;
@@ -13494,13 +14157,13 @@ async function migrateWorktreesAtStartup() {
         }
       },
       liveDronesUnder: (d) => pidsWithCwdUnder(d).length > 0,
-      rename: (from, to) => renameSync7(from, to),
+      rename: (from, to) => renameSync10(from, to),
       repairMoved: (t) => repairMovedWorktrees(t),
       log: (m) => console.log(m)
     });
   } catch (e) {
     console.error("[migrate] \u043C\u0438\u0433\u0440\u0430\u0446\u0438\u044F worktrees \u0441\u043E\u0440\u0432\u0430\u043B\u0430\u0441\u044C \u2014 \u0444\u043E\u043B\u0431\u044D\u043A:", e);
-    return existsSync12(WORKTREES_DIR) ? WORKTREES_DIR : WORKTREES_LEGACY_DIR;
+    return existsSync15(WORKTREES_DIR) ? WORKTREES_DIR : WORKTREES_LEGACY_DIR;
   }
 }
 async function reportWorkspaceAccess(tl, db) {
@@ -13518,13 +14181,22 @@ async function reportWorkspaceAccess(tl, db) {
 async function runDaemon(opts) {
   installCrashGuards();
   const daemonStart = await captureDaemonStart(THIS_FILE);
+  const latestRelease = fetchLatestVersion();
   const worktreesDir = await migrateWorktreesAtStartup();
   if (!opts.repo) {
     const remembered = effectiveRepoPaths("", loadRememberedRepos(SWARM_HOME))[0];
     if (remembered) opts.repo = remembered;
   }
-  const { store: db, reconciled, host } = await makeStore(opts.repo, worktreesDir, opts.repoFlag);
+  const {
+    store: db,
+    reconciled,
+    host,
+    repoMap: repoMapState,
+    refreshRepoMap: rebuildRepoMap
+  } = await makeStore(opts.repo, worktreesDir, opts.repoFlag);
   await preflightAuth();
+  const outdated = outdatedLine(PACKAGE_VERSION, await latestRelease);
+  if (outdated) console.warn(`[overmind] ${outdated}`);
   const tl = await connectTaskless();
   const tlFor = (workspaceId) => tl ? tl.forWorkspace(workspaceId) : null;
   if (tl) await reportWorkspaceAccess(tl, db);
@@ -13555,6 +14227,8 @@ async function runDaemon(opts) {
     }
   } : void 0;
   let lastDroneCap = null;
+  const hostCommandState = hostCommandStatePath(SWARM_HOME);
+  let hostMaxDrones = loadMaxDronesOverride(hostCommandState);
   const launch = makeLauncher({
     overmindEntry: THIS_FILE,
     dbPath: DB_PATH,
@@ -13582,6 +14256,10 @@ async function runDaemon(opts) {
     const client = db;
     rehydrate = { run: () => client.hydrate(), ready: () => client.pendingCount() === 0, intervalMs: SWARM_REHYDRATE_MS };
   }
+  let repoMap;
+  if (rebuildRepoMap && SWARM_REPO_MAP_MS > 0) {
+    repoMap = { run: rebuildRepoMap, intervalMs: SWARM_REPO_MAP_MS, lastAt: Date.now() };
+  }
   let daemonVersion;
   if (daemonStart && SWARM_VERSION_CHECK_MS > 0) {
     let cached = null;
@@ -13593,22 +14271,26 @@ async function runDaemon(opts) {
       intervalMs: SWARM_VERSION_CHECK_MS
     };
   }
+  let onHostCommands = () => {
+  };
   let heartbeat;
   if (SWARM_BACKEND === "client" && db instanceof SwarmClient && SWARM_PROD_HEARTBEAT_MS > 0) {
     const client = db;
     heartbeat = {
       push: async () => {
-        const commands = await client.heartbeat(daemonVersion?.get() ?? null, control.state ?? null);
-        if (commands.length === 0) return;
-        await serveLogRequests(
-          {
-            runLogsDir: RUN_LOGS_DIR,
-            daemonLogPath: DAEMON_LOG_PATH,
-            localRunId: (prodRunId) => client.localRunIdForProd(prodRunId),
-            deliver: (requestId, payload) => client.deliverLog(requestId, payload)
-          },
-          commands
-        );
+        const reply = await client.heartbeat(daemonVersion?.get() ?? null, control.state ?? null);
+        if (reply.commands.length) onHostCommands(reply.commands);
+        if (reply.logRequests.length) {
+          await serveLogRequests(
+            {
+              runLogsDir: RUN_LOGS_DIR,
+              daemonLogPath: DAEMON_LOG_PATH,
+              localRunId: (prodRunId) => client.localRunIdForProd(prodRunId),
+              deliver: (requestId, payload) => client.deliverLog(requestId, payload)
+            },
+            reply.logRequests
+          );
+        }
       },
       intervalMs: SWARM_PROD_HEARTBEAT_MS
     };
@@ -13682,7 +14364,7 @@ async function runDaemon(opts) {
       fallback: SWARM_MAX_IN_FLIGHT > 0 ? SWARM_MAX_IN_FLIGHT : 3,
       ttlMs: 1e4
     });
-    maxDrones = async () => lastDroneCap = await readMaxDrones();
+    maxDrones = async () => lastDroneCap = hostMaxDrones ?? await readMaxDrones();
   }
   let verifyModeReader;
   let baseBranchReader;
@@ -13809,8 +14491,9 @@ async function runDaemon(opts) {
         baseBranchReader ? baseBranchReader(repoOfRun) : Promise.resolve("")
       ]);
       const task = taskClient ? requireTaskBody(rawTask, run.task_slug, run.workspace_id) : null;
-      const base3 = effectiveBaseBranch(run.base_branch, projectBase);
-      const runToSpawn = base3 && run.base_branch !== base3 ? db.updateRun(run.id, { base_branch: base3 }) ?? run : run;
+      const healed = healTaskSlug(db, run, task);
+      const base3 = effectiveBaseBranch(healed.base_branch, projectBase);
+      const runToSpawn = base3 && healed.base_branch !== base3 ? db.updateRun(healed.id, { base_branch: base3 }) ?? healed : healed;
       const taskContext = task && taskClient ? await fetchTaskContext(taskClient, task) : void 0;
       await spawnDrone(
         {
@@ -13828,7 +14511,7 @@ async function runDaemon(opts) {
         runToSpawn
       );
       if (task) db.updateRun(run.id, { task_title: task.title, task_desc: task.description, task_url: task.url });
-      if (taskClient) await taskClient.startTask(run.task_slug);
+      if (taskClient) await taskClient.startTask(runToSpawn.task_slug);
     },
     prStatus: (url) => prStatus(url).then((s) => ({ merged: s.merged, conflicting: s.conflicting, isDraft: s.isDraft, files: s.files, state: s.state })),
     // Открытые PR ветки прогона (готча №14): gh pr list --head <slug> в репо прогона
@@ -13941,6 +14624,22 @@ async function runDaemon(opts) {
     ...exclusiveProject ? { exclusiveProject } : {},
     repoFallback: opts.repo,
     exclusiveLogged: /* @__PURE__ */ new Map(),
+    // Ротация своего лога (TASWM-330): демон пишет в него неделями, а до этого ротация была
+    // только при старте. Итог ротации печатаем в сам лог — первой строкой нового поколения
+    // видно, что история не потерялась, а уехала в `.1`.
+    logRotate: {
+      run: () => {
+        if (!stdoutGoesTo(DAEMON_LOG_PATH)) return;
+        const outcome = rotateDaemonLog(DAEMON_LOG_PATH, { maxBytes: DAEMON_LOG_MAX_BYTES, keep: DAEMON_LOG_KEEP });
+        if (outcome === "rotated") {
+          console.log(
+            `[overmind] \u043B\u043E\u0433 \u0434\u043E\u0440\u043E\u0441 \u0434\u043E ${Math.round(DAEMON_LOG_MAX_BYTES / 1024 / 1024)} \u041C\u0411 \u2014 \u043F\u0440\u043E\u0448\u043B\u043E\u0435 \u043F\u043E\u043A\u043E\u043B\u0435\u043D\u0438\u0435 \u0432 ${DAEMON_LOG_PATH}.1 (\u0434\u0435\u0440\u0436\u0438\u043C ${DAEMON_LOG_KEEP}; \u043F\u043E\u0442\u043E\u043B\u043E\u043A \u2014 SWARM_DAEMON_LOG_MAX_BYTES)`
+          );
+        }
+      },
+      intervalMs: DAEMON_LOG_CHECK_MS,
+      lastAt: null
+    },
     // merge-main-in: review-PR конфликтует с main → влить main в ветку PR, не переделывая
     // фичу. Реальные git-примитивы + launch; логика — в resolveConflict (тестируется).
     resolveConflict: (reviewRun) => resolveConflict(
@@ -13980,7 +14679,7 @@ async function runDaemon(opts) {
       mode,
       nudge
     ),
-    worktreeExists: (p) => existsSync12(p),
+    worktreeExists: (p) => existsSync15(p),
     hasTranscript: (p) => sessionTranscriptExists(p),
     // CI-осведомлённость review-PR (TASWM-102): реальный `gh pr checks`/`gh run view --log-failed`
     // (gh.ts) — решение (будить ли дрона) и гейты живут в tickOnce/handleCiRed. failureSummary
@@ -14008,6 +14707,8 @@ async function runDaemon(opts) {
     ...heartbeat ? { heartbeat } : {},
     // Сверка кода демона с main (TASWM-251): ключ есть только когда entryFile в git-репо.
     ...daemonVersion ? { daemonVersion } : {},
+    // Карта репозиториев машины (TASWM-336): ключ есть только в client-режиме с непустым TTL.
+    ...repoMap ? { repoMap } : {},
     // Встроенный надзор (client-режим, TASWM-194): ключ есть только когда сконфигурен.
     ...anomalies ? { anomalies } : {},
     // Сторож прогресса роя (TASWM-270): в отличие от anomalies выше — заведён БЕЗУСЛОВНО
@@ -14071,6 +14772,8 @@ async function runDaemon(opts) {
     narrator.narrate(`\u23F3 \u041E\u043F\u0435\u0440\u0430\u0442\u043E\u0440 \u0437\u0430\u043F\u0440\u043E\u0441\u0438\u043B \u0431\u0435\u0437\u043E\u043F\u0430\u0441\u043D\u044B\u0439 \u0440\u0435\u0441\u0442\u0430\u0440\u0442 \u0434\u0435\u043C\u043E\u043D\u0430 \u2014 \u0436\u0434\u0443 \u0437\u0430\u0432\u0435\u0440\u0448\u0435\u043D\u0438\u044F \u0436\u0438\u0432\u044B\u0445 \u0441\u0435\u0441\u0441\u0438\u0439: ${sessions.length}`);
     return { waiting: true, sessions };
   };
+  let onRestartWaitCancelled = null;
+  let onRestartStillWaiting = null;
   const requestStop = (o) => {
     const sessions = liveSessionIds(db, pidAlive);
     if (o.force || sessions.length === 0) {
@@ -14102,8 +14805,78 @@ async function runDaemon(opts) {
       restartAutoPaused = false;
       anomalyState.markResumed(Date.now());
     }
+    onRestartWaitCancelled?.();
     narrator.narrate(wasStop ? "\u25B6\uFE0F \u041E\u043F\u0435\u0440\u0430\u0442\u043E\u0440 \u043E\u0442\u043C\u0435\u043D\u0438\u043B \u043E\u0436\u0438\u0434\u0430\u043D\u0438\u0435 \u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043A\u0438 \u0434\u0435\u043C\u043E\u043D\u0430" : "\u25B6\uFE0F \u041E\u043F\u0435\u0440\u0430\u0442\u043E\u0440 \u043E\u0442\u043C\u0435\u043D\u0438\u043B \u043E\u0436\u0438\u0434\u0430\u043D\u0438\u0435 \u0431\u0435\u0437\u043E\u043F\u0430\u0441\u043D\u043E\u0433\u043E \u0440\u0435\u0441\u0442\u0430\u0440\u0442\u0430 \u0434\u0435\u043C\u043E\u043D\u0430");
   };
+  if (SWARM_BACKEND === "client" && db instanceof SwarmClient) {
+    const client = db;
+    const ack = (id, status, patch) => client.ackCommand(id, status, patch ?? {});
+    const effects = {
+      pause: () => {
+        control.paused = true;
+      },
+      resume: () => {
+        if (restart.phase === "waiting") return false;
+        control.paused = false;
+        return true;
+      },
+      requestRestart: () => requestRestart(false),
+      setMaxDrones: (n) => {
+        hostMaxDrones = n;
+        lastDroneCap = n;
+      },
+      stopRun: async (slug, reason) => {
+        const run = await cancelRun(
+          {
+            db,
+            kill: (pid) => killProcessGroup(pid, "SIGTERM"),
+            removeWorktree: (repo, p) => removeWorktree(repo || opts.repo, p)
+          },
+          slug,
+          reason
+        );
+        return run ? { id: run.id } : null;
+      },
+      update: async (onStep) => {
+        if (!daemonStart) {
+          return { ok: false, step: "fetch", message: "\u043A\u043E\u0434 \u0434\u0435\u043C\u043E\u043D\u0430 \u043B\u0435\u0436\u0438\u0442 \u043D\u0435 \u0432 git-\u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0438 \u2014 \u043E\u0431\u043D\u043E\u0432\u043B\u044F\u0442\u044C \u043D\u0435\u0447\u0435\u0433\u043E" };
+        }
+        return runSelfUpdate(defaultSelfUpdateIO(daemonStart.repo, onStep));
+      },
+      narrate: narrator.narrate
+    };
+    let commandQueue = Promise.resolve();
+    onHostCommands = (commands) => {
+      commandQueue = commandQueue.then(() => executeHostCommands({ commands, effects, ack, statePath: hostCommandState })).catch((e) => {
+        console.error("[overmind] \u0438\u0441\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u0435 \u043A\u043E\u043C\u0430\u043D\u0434\u044B \u043C\u0430\u0448\u0438\u043D\u044B \u0441\u043E\u0440\u0432\u0430\u043B\u043E\u0441\u044C:", e);
+      });
+    };
+    onRestartWaitCancelled = () => {
+      const pending2 = clearPendingAck(hostCommandState);
+      if (!pending2) return;
+      void ack(pending2.commandId, "rejected", {
+        step: "restart",
+        result: "\u043E\u0436\u0438\u0434\u0430\u043D\u0438\u0435 \u0440\u0435\u0441\u0442\u0430\u0440\u0442\u0430 \u043E\u0442\u043C\u0435\u043D\u0435\u043D\u043E \u043D\u0430 \u0441\u0430\u043C\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435 \u2014 \u043E\u0442\u0434\u0430\u0439 \u043A\u043E\u043C\u0430\u043D\u0434\u0443 \u0437\u0430\u043D\u043E\u0432\u043E"
+      }).catch(() => {
+      });
+    };
+    let lastWaitAck = 0;
+    onRestartStillWaiting = (sessions) => {
+      const nowMs = Date.now();
+      if (nowMs - lastWaitAck < HOST_COMMAND_KEEPALIVE_MS) return;
+      const pending2 = readPendingAck(hostCommandState);
+      if (!pending2) return;
+      lastWaitAck = nowMs;
+      void ack(pending2.commandId, "running", {
+        step: "restart",
+        result: `\u043F\u0435\u0440\u0435\u0437\u0430\u043F\u0443\u0449\u0443, \u043A\u043E\u0433\u0434\u0430 \u043E\u0441\u0432\u043E\u0431\u043E\u0434\u044F\u0442\u0441\u044F \u0441\u043B\u043E\u0442\u044B: \u0441\u0435\u0439\u0447\u0430\u0441 \u0440\u0430\u0431\u043E\u0442\u0430\u044E\u0442 ${sessions} \u2014 \u043E\u043D\u0438 \u0431\u044B \u043E\u0441\u0438\u0440\u043E\u0442\u0435\u043B\u0438`
+      }).catch(() => {
+      });
+    };
+    void flushPendingAck(hostCommandState, ack).then((done) => {
+      if (done) narrator.narrate(`\u2705 \u041A\u043E\u043C\u0430\u043D\u0434\u0430 \u0438\u0437 Taskless \u0432\u044B\u043F\u043E\u043B\u043D\u0435\u043D\u0430: ${done.note}`);
+    });
+  }
   if (channelSecret) {
     droneChannel = startDroneChannel(
       {
@@ -14149,6 +14922,10 @@ async function runDaemon(opts) {
     // Устаревший код демона (TASWM-251): тот же кэш, что читает heartbeat.push выше —
     // локальный дашборд :7420 видит ту же сверку, что уходит в прод, без отдельного git-похода.
     daemonVersion: () => daemonVersion?.get() ?? null,
+    // Карта репозиториев машины (TASWM-336): то же состояние, что мутирует шаг тика, — его
+    // печатает `swarm status`. Без него человек снова гадал бы, какие репозитории машина
+    // считает своими и в каком дереве работает при двух копиях одного клона.
+    repoMap: () => repoMapRows(repoMapState),
     // Оператор-пауза + «Оживить» (TASWM-214 Фаза 2): тот же shared-флаг, что читает тик;
     // narrate — операторские действия видны в ленте роя; revive — сброс залипшего шторма.
     control,
@@ -14210,8 +14987,10 @@ async function runDaemon(opts) {
     try {
       writeHeartbeat(HEARTBEAT_PATH, Date.now());
       await tickOnce(deps);
-      if (restart.phase === "waiting" && liveSessionIds(db, pidAlive).length === 0) {
-        performRestart([], restart.intent);
+      if (restart.phase === "waiting") {
+        const live = liveSessionIds(db, pidAlive);
+        if (live.length === 0) performRestart([], restart.intent);
+        else onRestartStillWaiting?.(live.length);
       }
     } catch (e) {
       console.error("[overmind] tick error:", e);