@taskless-app/swarm 0.6.67 → 0.6.68

package/dist/cli.js

@@ -3530,7 +3530,7 @@ var init_linkFailure = __esm({
     "use strict";
     init_agentToken();
     UNKNOWN_LINK_REASON = "\u043F\u043E\u0434\u043A\u043B\u044E\u0447\u0435\u043D\u0438\u044F \u043D\u0435\u0442, \u0430 \u043F\u0440\u0438\u0447\u0438\u043D\u0443 \u043A\u043E\u043D\u043D\u0435\u043A\u0442\u043E\u0440 \u043D\u0435 \u043D\u0430\u0437\u0432\u0430\u043B";
-    OFFLINE_RE = /fetch failed|econnreset|econnrefused|econnaborted|enotfound|eai_again|etimedout|ehostunreach|enetunreach|epipe|socket hang up|und_err|network error|connection (?:closed|refused|reset|error)|connect timeout/i;
+    OFFLINE_RE = /fetch failed|econnreset|econnrefused|econnaborted|enotfound|eai_again|etimedout|ehostunreach|enetunreach|epipe|socket hang up|und_err|network error|connection (?:closed|refused|reset|error)|connect timeout|request timed out|-32001\b/i;
     MISSING_TOOL_RE = /tool[^.]{0,40}not found|unknown tool|tool_not_found|method not found|-32601\b/i;
   }
 });
@@ -3880,7 +3880,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@taskless-app/swarm",
-      version: "0.6.67",
+      version: "0.6.68",
       type: "module",
       description: "Local control plane for a fleet of AI coding agents (drones), coordinating through Taskless. The overmind runs the swarm.",
       keywords: [
@@ -3929,9 +3929,10 @@ var init_package = __esm({
         "@hono/node-server": "^2.0.12",
         "@modelcontextprotocol/sdk": "^1.29.0",
         execa: "^10.0.0",
+        undici: "^7.25.0",
         zod: "3.25.76"
       },
-      gitHead: "92a3176867bc1668677a4b6a25e02e0cb6661ce0"
+      gitHead: "4bfd78926aa37ef7de8ea06a6763d7e84a2fded6"
     };
   }
 });
@@ -4664,6 +4665,47 @@ var init_shotUpload = __esm({
   }
 });
 
+// src/prodHttp.ts
+import { Agent, fetch as undiciFetch } from "undici";
+function prodDispatcher() {
+  agent ??= new Agent({
+    keepAliveTimeout: PROD_KEEPALIVE_MS,
+    keepAliveMaxTimeout: PROD_KEEPALIVE_MS,
+    headersTimeout: PROD_SOCKET_TIMEOUT_MS,
+    bodyTimeout: PROD_SOCKET_TIMEOUT_MS,
+    connect: { timeout: PROD_CONNECT_TIMEOUT_MS }
+  });
+  return agent;
+}
+function isProdTimeout(e) {
+  for (let cur = e, depth = 0; cur != null && depth < 4; cur = cur.cause, depth++) {
+    const code = cur.code;
+    const name = cur.name;
+    const msg = cur instanceof Error ? cur.message : String(cur);
+    if (code === -32001 || code === "UND_ERR_HEADERS_TIMEOUT" || code === "UND_ERR_BODY_TIMEOUT") return true;
+    if (name === "TimeoutError" || /request timed out/i.test(msg)) return true;
+  }
+  return false;
+}
+var PROD_CALL_TIMEOUT_MS, FETCH_GRACE_MS, PROD_KEEPALIVE_MS, PROD_SOCKET_TIMEOUT_MS, PROD_CONNECT_TIMEOUT_MS, agent, prodFetch;
+var init_prodHttp = __esm({
+  "src/prodHttp.ts"() {
+    "use strict";
+    PROD_CALL_TIMEOUT_MS = 15e3;
+    FETCH_GRACE_MS = 5e3;
+    PROD_KEEPALIVE_MS = 1e4;
+    PROD_SOCKET_TIMEOUT_MS = 3e4;
+    PROD_CONNECT_TIMEOUT_MS = 1e4;
+    agent = null;
+    prodFetch = (url, init) => {
+      const method = (init?.method ?? "GET").toUpperCase();
+      const deadline = method === "GET" ? null : AbortSignal.timeout(PROD_CALL_TIMEOUT_MS + FETCH_GRACE_MS);
+      const signal = deadline && init?.signal ? AbortSignal.any([init.signal, deadline]) : deadline ?? init?.signal ?? void 0;
+      return undiciFetch(url, { ...init, ...signal ? { signal } : {}, dispatcher: prodDispatcher() });
+    };
+  }
+});
+
 // src/workspace.ts
 import { readFileSync as readFileSync11, writeFileSync as writeFileSync10, unlinkSync as unlinkSync4 } from "fs";
 import { join as join19 } from "path";
@@ -4715,8 +4757,8 @@ function parseJsonContent(res) {
 }
 async function resolveApiToken(api, explicit) {
   if (explicit) return explicit;
-  const agent = loadAgentToken();
-  if (agent?.token) return agent.token;
+  const agent2 = loadAgentToken();
+  if (agent2?.token) return agent2.token;
   const store = loadStore();
   if (store) {
     const r = await ensureAccess(store, { api });
@@ -4745,7 +4787,9 @@ async function connectSwarmMcp(cfg) {
   }
   const url = new URL(mcpEndpoint(api));
   const transport = new StreamableHTTPClientTransport(url, {
-    requestInit: { headers: { Authorization: `Bearer ${token}` } }
+    requestInit: { headers: { Authorization: `Bearer ${token}` } },
+    fetch: prodFetch
+    // TASWM-611
   });
   const client = new Client({ name: "taskless-swarm-client", version: "0.1.0" }, { capabilities: {} });
   try {
@@ -4764,12 +4808,31 @@ async function connectSwarmMcp(cfg) {
   }
   swarmConnectFailure = null;
   noteTokenAccepted();
-  return async (name, args) => await client.callTool({ name, arguments: swarmToolArgs(name, args, workspace) });
+  const timeout = cfg?.callTimeoutMs ?? PROD_CALL_TIMEOUT_MS;
+  return async (name, args) => {
+    try {
+      return await client.callTool({ name, arguments: swarmToolArgs(name, args, workspace) }, void 0, { timeout });
+    } catch (e) {
+      if (isProdTimeout(e)) {
+        console.warn(`${prodTimeoutLine("Swarm MCP", name, timeout)} \u2014 \u0441\u043E\u0435\u0434\u0438\u043D\u0435\u043D\u0438\u0435 \u0441\u0431\u0440\u043E\u0448\u0435\u043D\u043E, \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0438\u0439 \u0432\u044B\u0437\u043E\u0432 \u043F\u0435\u0440\u0435\u043F\u043E\u0434\u043A\u043B\u044E\u0447\u0438\u0442\u0441\u044F`);
+      }
+      void client.close().catch(() => {
+      });
+      throw e;
+    }
+  };
+}
+function prodTimeoutLine(scope, tool, timeoutMs) {
+  return `[${scope}] \u23F1 ${tool}: \u043F\u0440\u043E\u0434 \u043D\u0435 \u043E\u0442\u0432\u0435\u0442\u0438\u043B \u0437\u0430 ${Math.round(timeoutMs / 100) / 10}\u0441, \u0432\u044B\u0437\u043E\u0432 \u043F\u0440\u0435\u0440\u0432\u0430\u043D`;
 }
 function lastSwarmConnectFailure() {
   return swarmConnectFailure;
 }
 function swarmToolArgs(name, args, workspace) {
+  if ("workspaceId" in args && args.workspaceId == null) {
+    const { workspaceId: _drop, ...rest } = args;
+    return rest;
+  }
   if (!WS_SCOPED_SWARM_TOOLS.has(name) || !workspace) return args;
   return { workspaceId: workspace, ...args };
 }
@@ -4784,6 +4847,7 @@ var init_taskless = __esm({
     init_oauth();
     init_agentToken();
     init_linkFailure();
+    init_prodHttp();
     init_toolFailure();
     init_authState();
     init_workspace();
@@ -7697,7 +7761,7 @@ var init_updateCli = __esm({
 // src/cli.ts
 init_cliIo();
 import { basename as basename6, dirname as dirname5, join as join27 } from "path";
-import { existsSync as existsSync18, readFileSync as readFileSync19, writeFileSync as writeFileSync15, mkdirSync as mkdirSync11, readdirSync as readdirSync12, statSync as statSync12, openSync as openSync4, readSync as readSync2, closeSync as closeSync4 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync19, writeFileSync as writeFileSync15, mkdirSync as mkdirSync11, readdirSync as readdirSync12, statSync as statSync12, openSync as openSync5, readSync as readSync2, closeSync as closeSync5 } from "fs";
 import { setTimeout as sleep2 } from "timers/promises";
 
 // src/swarmClient.ts
@@ -10061,7 +10125,7 @@ var SwarmClient = class _SwarmClient {
   // 14.07/18.07, TASWM-201 — общий карантин; здесь — конкретный источник). Резолвим
   // слаг→cuid через get_task (кэш — taskIdCache) ПЕРЕД тем как слать create.
   taskIdCache = /* @__PURE__ */ new Map();
-  // task_slug → cuid прода
+  // task_slug → cuid прода и воркспейс задачи
   // Create для этого runKey резолвился окончательно неудачно (задача не найдена/
   // недоступна) — событие/вопросы того же прогона тоже никогда не получат prod-id,
   // без карантина они бы бросали «нет prod-id» на каждом флаше и СНОВА вставали
@@ -10076,12 +10140,20 @@ var SwarmClient = class _SwarmClient {
     const cacheKey = `${taskRef}\0${repoFullName ?? ""}\0${workspaceId ?? ""}`;
     const cached = this.taskIdCache.get(cacheKey);
     if (cached) return cached;
+    const first = await this.readTaskRef(taskRef, repoFullName, workspaceId);
+    const res = first === null && repoFullName && !workspaceId ? await this.readTaskRef(taskRef, repoFullName, null) : first;
+    if (res && res !== "transient") this.taskIdCache.set(cacheKey, res);
+    return res;
+  }
+  /** Один get_task: cuid задачи и её воркспейс; null — прод ответил «нет такой». */
+  async readTaskRef(taskRef, repoFullName, workspaceId) {
     let res;
     try {
       res = await this.call("get_task", {
         id: taskRef,
         ...repoFullName ? { repoFullName } : {},
-        ...workspaceId ? { workspaceId } : {}
+        // null — «без пина демона» (см. swarmToolArgs), undefined — пин по умолчанию.
+        ...workspaceId ? { workspaceId } : workspaceId === null ? { workspaceId: null } : {}
       });
     } catch {
       return "transient";
@@ -10091,10 +10163,9 @@ var SwarmClient = class _SwarmClient {
       const text = (res.content ?? []).map((c) => c.text ?? "").join(" ");
       return /not_found/i.test(text) ? null : "transient";
     }
-    const id = res.structuredContent?.task?.id;
-    if (!id) return null;
-    this.taskIdCache.set(cacheKey, id);
-    return id;
+    const task = res.structuredContent?.task;
+    if (!task?.id) return null;
+    return { id: task.id, workspaceId: typeof task.workspaceId === "string" ? task.workspaceId : null };
   }
   // MCP-31: привести repo прогона к owner/repo-форме для подсказки резолверу
   // задачи. Прод сматчит подсказку с ProjectRepo.repoFullName → воркспейс. repo
@@ -10133,18 +10204,19 @@ var SwarmClient = class _SwarmClient {
         this.poisonedRunKeys.add(e.runKey);
         return "skip";
       }
-      const taskId = await this.resolveTaskCuid(e.taskRef, this.repoFullNameFor(fields.repo), e.workspaceId);
-      if (taskId === "transient") {
+      const task = await this.resolveTaskCuid(e.taskRef, this.repoFullNameFor(fields.repo), e.workspaceId);
+      if (task === "transient") {
         throw new Error(`slug\u2192cuid \u0434\u043B\u044F \xAB${e.taskRef}\xBB \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D (\u043F\u0440\u043E\u0434 \u043C\u043E\u0440\u0433\u043D\u0443\u043B) \u2014 retry`);
       }
-      if (!taskId) {
+      if (!task) {
         console.error(
           `[swarm-client] create-\u0444\u043B\u0430\u0448 \u043F\u0440\u043E\u043F\u0443\u0449\u0435\u043D: \u043F\u0440\u043E\u0434 \u043D\u0435 \u0437\u043D\u0430\u0435\u0442 \u0437\u0430\u0434\u0430\u0447\u0443 \xAB${e.taskRef}\xBB (runKey=${e.runKey}) \u2014 \u0437\u0430\u043F\u0438\u0441\u044C \u0432\u044B\u0431\u0440\u043E\u0448\u0435\u043D\u0430 \u0438\u0437 outbox`
         );
         this.poisonedRunKeys.add(e.runKey);
         return "skip";
       }
-      return { tool: "swarm_run_upsert", args: { taskId, ...e.workspaceId ? { workspaceId: e.workspaceId } : {}, ...fields } };
+      const workspaceId = e.workspaceId || task.workspaceId;
+      return { tool: "swarm_run_upsert", args: { taskId: task.id, ...workspaceId ? { workspaceId } : {}, ...fields } };
     }
     if (this.poisonedRunKeys.has(e.runKey)) {
       console.error(`[swarm-client] ${e.t}-\u0444\u043B\u0430\u0448 \u043F\u0440\u043E\u043F\u0443\u0449\u0435\u043D: create \u043F\u0440\u043E\u0433\u043E\u043D\u0430 runKey=${e.runKey} \u043D\u0435 \u0440\u0435\u0437\u043E\u043B\u0432\u0438\u043B\u0441\u044F \u0440\u0430\u043D\u0435\u0435 \u2014 \u0437\u0430\u043F\u0438\u0441\u044C \u0432\u044B\u0431\u0440\u043E\u0448\u0435\u043D\u0430 \u0438\u0437 outbox`);
@@ -10196,6 +10268,7 @@ var SwarmClient = class _SwarmClient {
         } catch {
           break;
         }
+        if (res?.isError && res.unavailable) break;
         if (res?.isError) {
           const reason = (res.content ?? []).map((c) => c.text).filter(Boolean).join(" ").trim() || "\u0431\u0435\u0437 \u043E\u0431\u044A\u044F\u0441\u043D\u0435\u043D\u0438\u044F";
           const tries = (this.rejected.get(e.seq) ?? 0) + 1;
@@ -10448,7 +10521,7 @@ function tailFile(path, lines) {
 }
 
 // src/logRotate.ts
-import { copyFileSync as copyFileSync4, renameSync as renameSync3, statSync as statSync7, fstatSync, truncateSync, unlinkSync as unlinkSync2, existsSync as existsSync8 } from "fs";
+import { copyFileSync as copyFileSync4, renameSync as renameSync3, statSync as statSync7, fstatSync, truncateSync, unlinkSync as unlinkSync2, existsSync as existsSync8, openSync as openSync3, writeSync, closeSync as closeSync3 } from "fs";
 var realIo = {
   size: (path) => {
     try {
@@ -10463,6 +10536,31 @@ var realIo = {
   unlink: unlinkSync2,
   exists: existsSync8
 };
+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 = statSync7(path);
+      return { dev: s.dev, ino: s.ino };
+    } catch {
+      return null;
+    }
+  }
+};
+function stdoutGoesTo(path, io = realOwnerIo) {
+  if (teedTo === path) return true;
+  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);
@@ -10482,6 +10580,33 @@ function rotateDaemonLog(path, opts, io = realIo) {
   io.truncate(path);
   return "rotated";
 }
+var teedTo = null;
+function teeStdioToFile(path) {
+  if (teedTo === path || stdoutGoesTo(path)) return null;
+  const fd = openSync3(path, "a");
+  const restore = [];
+  for (const stream of [process.stdout, process.stderr]) {
+    const original = stream.write;
+    restore.push(() => {
+      stream.write = original;
+    });
+    const orig = original.bind(stream);
+    stream.write = ((chunk, ...rest) => {
+      try {
+        if (typeof chunk === "string") writeSync(fd, chunk);
+        else if (chunk instanceof Uint8Array) writeSync(fd, chunk);
+      } catch {
+      }
+      return orig(chunk, ...rest);
+    });
+  }
+  teedTo = path;
+  return () => {
+    for (const undo of restore) undo();
+    teedTo = null;
+    closeSync3(fd);
+  };
+}
 
 // src/cli.ts
 init_procCleanup();
@@ -12807,7 +12932,7 @@ import { cancelRun, respawnRun, runDaemon, wakeRun, OVERMIND_ENTRY, listDronePro
 
 // src/launcher.ts
 import { spawn as spawn2 } from "child_process";
-import { closeSync as closeSync3, existsSync as existsSync10, mkdirSync as mkdirSync10, openSync as openSync3, readdirSync as readdirSync9 } from "fs";
+import { closeSync as closeSync4, existsSync as existsSync10, mkdirSync as mkdirSync10, openSync as openSync4, readdirSync as readdirSync9 } from "fs";
 import { createRequire } from "module";
 import { homedir as homedir5 } from "os";
 import { dirname as dirname4, join as join15 } from "path";
@@ -13016,14 +13141,14 @@ function openNextRunLog(runLogsDir, runLogKeys) {
     const path = nextRunLogPath(runLogsDir, runLogKeys);
     let out;
     try {
-      out = openSync3(path, "wx");
+      out = openSync4(path, "wx");
     } catch (e) {
       if (e.code !== "EEXIST") throw e;
       continue;
     }
     let err = null;
     try {
-      err = openSync3(`${path.slice(0, -".json".length)}.err.log`, "w");
+      err = openSync4(`${path.slice(0, -".json".length)}.err.log`, "w");
     } catch {
       err = null;
     }
@@ -13153,8 +13278,8 @@ function makeLauncher(cfg) {
       // они про его собственное состояние, и перебивать их ройным нечем.
       env: { ...droneEnv(worktree, process.env, home ? { droneHome: home, realHome } : void 0, cfg.droneCap?.() ?? null), ...plan.env }
     });
-    if (outFd !== void 0) closeSync3(outFd);
-    if (errFd !== void 0) closeSync3(errFd);
+    if (outFd !== void 0) closeSync4(outFd);
+    if (errFd !== void 0) closeSync4(errFd);
     child.unref();
     if (child.pid == null) throw new Error("\u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0437\u0430\u043F\u0443\u0441\u0442\u0438\u0442\u044C \u0434\u0440\u043E\u043D\u0430 (\u043D\u0435\u0442 pid)");
     return child.pid;
@@ -13171,11 +13296,17 @@ init_taskless();
 // src/mcpResilient.ts
 init_linkFailure();
 init_taskless();
+init_prodHttp();
 var DEFAULT_BACKOFF_MS = [5e3, 15e3, 3e4, 6e4];
 var DEFAULT_DOWN_AFTER_MS = 5 * 6e4;
 var DEFAULT_RETRY_DELAYS_MS = [200, 800];
-function errorResult(reason) {
-  return { isError: true, content: [{ type: "text", text: `Swarm MCP \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D: ${reason}` }] };
+var PROD_PASS_BUDGET_MS = 2e4;
+function errorResult(reason, unavailable) {
+  return {
+    isError: true,
+    ...unavailable ? { unavailable: true } : {},
+    content: [{ type: "text", text: `Swarm MCP \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D: ${reason}` }]
+  };
 }
 function resilientSwarmMcp(opts = {}) {
   const connect = opts.connect ?? (() => connectSwarmMcp());
@@ -13183,6 +13314,13 @@ function resilientSwarmMcp(opts = {}) {
   const downAfterMs = opts.downAfterMs ?? DEFAULT_DOWN_AFTER_MS;
   const retryDelays = opts.retryDelaysMs ?? DEFAULT_RETRY_DELAYS_MS;
   const sleep3 = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const clock = opts.now ?? Date.now;
+  const passBudgetMs = opts.passBudgetMs ?? PROD_PASS_BUDGET_MS;
+  let passSpentMs = null;
+  let budgetNoted = false;
+  const spend = (since) => {
+    if (passSpentMs !== null) passSpentMs += Math.max(0, clock() - since);
+  };
   let caller = null;
   let lastTryAt = 0;
   let failures = 0;
@@ -13205,6 +13343,7 @@ function resilientSwarmMcp(opts = {}) {
     if (!force && lastTryAt !== 0 && now - lastTryAt < wait) return null;
     if (!force) lastTryAt = now;
     let fresh = null;
+    const connectStart = clock();
     try {
       fresh = await connect();
       if (!fresh) lastConnectReason = lastSwarmConnectFailure() ?? UNKNOWN_LINK_REASON;
@@ -13221,17 +13360,30 @@ function resilientSwarmMcp(opts = {}) {
       downReported = false;
       return caller;
     }
+    spend(connectStart);
     if (!force) failures += 1;
     if (downSince === null) downSince = now;
     return null;
   }
   const call = async (name, args) => {
     for (let attempt = 0; ; attempt++) {
+      if (passSpentMs !== null && passSpentMs >= passBudgetMs) {
+        if (!budgetNoted) {
+          budgetNoted = true;
+          opts.onBudgetSpent?.({ spentMs: passSpentMs, budgetMs: passBudgetMs });
+        }
+        maybeReportDown();
+        return errorResult(
+          `\u043F\u0440\u043E\u0434 \u043D\u0435 \u043E\u0442\u0432\u0435\u0447\u0430\u0435\u0442, \u0431\u044E\u0434\u0436\u0435\u0442 \u043F\u0440\u043E\u0445\u043E\u0434\u0430 \u043D\u0430 \u0441\u0435\u0442\u044C (${Math.round(passBudgetMs / 1e3)}\u0441) \u0438\u0441\u0447\u0435\u0440\u043F\u0430\u043D \u2014 \u0434\u043E \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0435\u0433\u043E \u043F\u0440\u043E\u0445\u043E\u0434\u0430 \u0431\u0435\u0437 \u0441\u0435\u0442\u0438${lastCallReason ?? lastConnectReason ? ` (\u043F\u043E\u0441\u043B\u0435\u0434\u043D\u044F\u044F \u043F\u0440\u0438\u0447\u0438\u043D\u0430: ${lastCallReason ?? lastConnectReason})` : ""}`,
+          true
+        );
+      }
       const active = await ensureCaller(attempt > 0);
       if (!active) {
         maybeReportDown();
-        return errorResult(lastConnectReason ?? UNKNOWN_LINK_REASON);
+        return errorResult(lastConnectReason ?? UNKNOWN_LINK_REASON, true);
       }
+      const callStart = clock();
       try {
         const res = await active(name, args);
         lastOkAt = Date.now();
@@ -13239,13 +13391,14 @@ function resilientSwarmMcp(opts = {}) {
         return res;
       } catch (e) {
         caller = null;
+        spend(callStart);
         if (downSince === null) downSince = Date.now();
         const { kind, detail: reason } = explainLinkFailure(e);
         lastCallReason = reason;
         const delay = retryDelays[attempt];
-        if (delay === void 0 || kind !== "offline") {
+        if (delay === void 0 || kind !== "offline" || isProdTimeout(e)) {
           maybeReportDown();
-          return errorResult(reason);
+          return errorResult(reason, kind === "offline" || kind === "unknown" || kind === "unauthorized" || isProdTimeout(e));
         }
         opts.onRetry?.({ tool: name, attempt: attempt + 1, reason });
         await sleep3(delay);
@@ -13253,6 +13406,10 @@ function resilientSwarmMcp(opts = {}) {
     }
   };
   return Object.assign(call, {
+    beginPass: () => {
+      passSpentMs = 0;
+      budgetNoted = false;
+    },
     // Причина — ТА ЖЕ, что уехала в лог: сначала свежий отказ вызова, иначе отказ
     // подключения. Своего разбора здесь нет намеренно (см. lastCallReason выше).
     link: () => ({ connected: caller !== null, downSince, lastOkAt, lastError: caller !== null ? null : lastCallReason ?? lastConnectReason })
@@ -13811,13 +13968,13 @@ async function stopDaemonForLogin() {
 async function runLoginFlow(db2, opts) {
   const web = startWeb({ db: db2 });
   try {
-    let agent = loadAgentToken();
-    if (agent && opts.force) {
+    let agent2 = loadAgentToken();
+    if (agent2 && opts.force) {
       console.log("--force: \u0432\u0445\u043E\u0436\u0443 \u0437\u0430\u043D\u043E\u0432\u043E, \u043D\u0435 \u043F\u0440\u043E\u0432\u0435\u0440\u044F\u044F \u0441\u0442\u0430\u0440\u044B\u0439 \u0442\u043E\u043A\u0435\u043D.");
-      agent = null;
+      agent2 = null;
     }
-    if (agent) {
-      const probe = await probeAgentToken({ api: TASKLESS_API, token: agent.token });
+    if (agent2) {
+      const probe = await probeAgentToken({ api: TASKLESS_API, token: agent2.token });
       if (probe === "ok") {
         console.log("\u0442\u043E\u043A\u0435\u043D \u0440\u043E\u044F \u043D\u0430 \u043C\u0435\u0441\u0442\u0435 \u2014 \u043E\u0431\u043D\u043E\u0432\u043B\u044F\u044E \u0442\u043E\u043B\u044C\u043A\u043E \u0432\u044B\u0431\u043E\u0440 \u0432\u043E\u0440\u043A\u0441\u043F\u0435\u0439\u0441\u0430.");
       } else {
@@ -13829,10 +13986,10 @@ async function runLoginFlow(db2, opts) {
             "\u043F\u0440\u043E\u0432\u0435\u0440\u0438\u0442\u044C \u0442\u043E\u043A\u0435\u043D \u0440\u043E\u044F \u043D\u0435 \u0432\u044B\u0448\u043B\u043E (\u0441\u0435\u0442\u044C/\u043F\u0440\u043E\u0434/\u043E\u0442\u043A\u0430\u0437) \u2014 \u0432\u0445\u043E\u0436\u0443 \u0437\u0430\u043D\u043E\u0432\u043E: \u0441\u0447\u0438\u0442\u0430\u0442\u044C \u043D\u0435\u043F\u0440\u043E\u0448\u0435\u0434\u0448\u0443\u044E \u043F\u0440\u043E\u0432\u0435\u0440\u043A\u0443 \u0437\u0430 \xAB\u0432\u0441\u0451 \u0432 \u043F\u043E\u0440\u044F\u0434\u043A\u0435\xBB \u043D\u0435\u043B\u044C\u0437\u044F."
           );
         }
-        agent = null;
+        agent2 = null;
       }
     }
-    if (!agent) {
+    if (!agent2) {
       let store = loadStore();
       if (!store) {
         const loginUrl = `http://127.0.0.1:${web.port}/login`;
@@ -14021,14 +14178,14 @@ async function runDaemonLogs(argv) {
     }
     if (size < pos) pos = 0;
     if (size === pos) continue;
-    const fd = openSync4(DAEMON_LOG_PATH, "r");
+    const fd = openSync5(DAEMON_LOG_PATH, "r");
     try {
       const buf = Buffer.alloc(size - pos);
       const read = readSync2(fd, buf, 0, buf.length, pos);
       process.stdout.write(buf.subarray(0, read).toString("utf8"));
       pos += read;
     } finally {
-      closeSync4(fd);
+      closeSync5(fd);
     }
   }
 }
@@ -14306,7 +14463,7 @@ async function makeCliStore(repo) {
     onDown: (ms) => console.warn(`Swarm MCP \u043C\u043E\u043B\u0447\u0438\u0442 ${Math.round(ms / 1e3)}\u0441 \u2014 \u0440\u0430\u0431\u043E\u0442\u0430\u0435\u043C \u0432\u0441\u043B\u0435\u043F\u0443\u044E, \u043F\u0440\u043E\u0432\u0435\u0440\u044C \u0441\u0432\u044F\u0437\u044C \u0441 \u043F\u0440\u043E\u0434\u043E\u043C.`),
     onUp: () => console.warn("Swarm MCP \u0441\u043D\u043E\u0432\u0430 \u043D\u0430 \u0441\u0432\u044F\u0437\u0438.")
   });
-  const repoRegistry = await buildRepoRegistry(SWARM_REPO_PATHS);
+  const repoRegistry = await buildRepoRegistry([...new Set([repo, ...SWARM_REPO_PATHS].filter(Boolean))]);
   const client = new SwarmClient({ call, outboxPath: SWARM_OUTBOX, defaultRepo: repo, repoRegistry });
   await client.hydrate();
   client.reconcileRuntime({ worktreesDir: effectiveWorktreesDir(), listProcesses: listDroneProcesses });
@@ -14563,6 +14720,12 @@ if (cmd === "start") {
   if (!foreground) {
     process.exit(await runStartDetached(startArgs));
   }
+  try {
+    rotateDaemonLog(DAEMON_LOG_PATH, { maxBytes: DAEMON_LOG_MAX_BYTES, keep: DAEMON_LOG_KEEP });
+    if (teeStdioToFile(DAEMON_LOG_PATH)) console.log(`\u043B\u043E\u0433 \u043F\u0438\u0448\u0435\u0442\u0441\u044F \u0438 \u0432 ${DAEMON_LOG_PATH}`);
+  } catch (e) {
+    console.warn(`\u043B\u043E\u0433 \u0432 \u0444\u0430\u0439\u043B \u043D\u0435 \u043F\u0438\u0448\u0435\u0442\u0441\u044F (${e instanceof Error ? e.message : e}) \u2014 \u0442\u043E\u043B\u044C\u043A\u043E \u0432 \u0442\u0435\u0440\u043C\u0438\u043D\u0430\u043B`);
+  }
   try {
     await runDaemon({ repo, repoFlag });
   } catch (e) {