@taskless-app/swarm 0.6.67 → 0.6.68

package/dist/overmind.js

@@ -4092,7 +4092,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;
   }
 });
@@ -6024,6 +6024,47 @@ var init_oauth = __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/authState.ts
 function noteTokenRejected(nowMs = Date.now()) {
   if (!denial) {
@@ -6512,8 +6553,8 @@ function escapeRegExp(s) {
 }
 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 });
@@ -6538,9 +6579,9 @@ function resetLegacyTokenWarning() {
 async function preflightAuth(opts = {}) {
   const api = opts.api ?? TASKLESS_API;
   const out = opts.out ?? ((s) => console.error(s));
-  const agent = loadAgentToken();
-  if (!agent?.token) return true;
-  const probe = await probeAgentToken({ api, token: agent.token }, opts.fetchFn ?? fetch);
+  const agent2 = loadAgentToken();
+  if (!agent2?.token) return true;
+  const probe = await probeAgentToken({ api, token: agent2.token }, opts.fetchFn ?? fetch);
   if (probe === "revoked") {
     out(noteTokenRejected() ?? revokedTokenComplaint());
     return false;
@@ -6560,7 +6601,8 @@ async function connectTaskless(cfg) {
   if (!token) return null;
   const url = new URL(mcpEndpoint(api));
   const transport = new StreamableHTTPClientTransport(url, {
-    requestInit: { headers: { Authorization: `Bearer ${token}` } }
+    requestInit: { headers: { Authorization: `Bearer ${token}` } },
+    fetch: prodFetch
   });
   const client = new Client({ name: "taskless-swarm", version: "0.1.0" }, { capabilities: {} });
   try {
@@ -6575,7 +6617,14 @@ async function connectTaskless(cfg) {
     return null;
   }
   noteTokenAccepted();
-  const call = async (name, args) => await client.callTool({ name, arguments: args });
+  const call = async (name, args) => {
+    try {
+      return await client.callTool({ name, arguments: args }, void 0, { timeout: PROD_CALL_TIMEOUT_MS });
+    } catch (e) {
+      if (isProdTimeout(e)) console.warn(prodTimeoutLine("Taskless", name, PROD_CALL_TIMEOUT_MS));
+      throw e;
+    }
+  };
   return makeTasklessClient(
     call,
     workspace || void 0,
@@ -6593,7 +6642,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 {
@@ -6612,12 +6663,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 };
 }
@@ -6632,6 +6702,7 @@ var init_taskless = __esm({
     init_oauth();
     init_agentToken();
     init_linkFailure();
+    init_prodHttp();
     init_toolFailure();
     init_authState();
     init_workspace();
@@ -10340,7 +10411,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» на каждом флаше и СНОВА вставали
@@ -10355,12 +10426,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";
@@ -10370,10 +10449,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
@@ -10412,18 +10490,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`);
@@ -10475,6 +10554,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;
@@ -10597,8 +10677,39 @@ function tickPulse(health, now, intervalMs) {
   return { seq: health.seq, ageMs: tickAgeMs(health, now), intervalMs };
 }
 
+// src/tickSteps.ts
+var SLOW_PASS_MS = 3e4;
+function makeStepClock(now = Date.now) {
+  const startedAt = now();
+  const spent = /* @__PURE__ */ new Map();
+  let current = "\u043D\u0430\u0447\u0430\u043B\u043E \u043F\u0440\u043E\u0445\u043E\u0434\u0430";
+  let since = startedAt;
+  const close = () => {
+    const t = now();
+    spent.set(current, (spent.get(current) ?? 0) + (t - since));
+    since = t;
+  };
+  return {
+    mark(step) {
+      close();
+      current = step;
+    },
+    finish() {
+      close();
+      const steps = [...spent].map(([step, ms]) => ({ step, ms })).sort((a, b) => b.ms - a.ms);
+      return { totalMs: since - startedAt, steps };
+    }
+  };
+}
+function slowPassLine(seq, done, thresholdMs = SLOW_PASS_MS) {
+  if (done.totalMs <= thresholdMs) return null;
+  const sec = (ms) => `${Math.round(ms / 100) / 10}\u0441`;
+  const top = done.steps.slice(0, 3).map((s) => `${s.step} ${sec(s.ms)}`).join(", ");
+  return `[overmind] \u23F1 \u043F\u0440\u043E\u0445\u043E\u0434 \u0442\u0438\u043A\u0430 #${seq} \u0434\u043B\u0438\u043B\u0441\u044F ${sec(done.totalMs)} (\u043F\u043E\u0440\u043E\u0433 ${sec(thresholdMs)}); \u0434\u043E\u043B\u044C\u0448\u0435 \u0432\u0441\u0435\u0433\u043E: ${top}`;
+}
+
 // src/logRotate.ts
-import { copyFileSync as copyFileSync4, renameSync as renameSync5, statSync as statSync7, fstatSync, truncateSync, unlinkSync as unlinkSync3, existsSync as existsSync9 } from "fs";
+import { copyFileSync as copyFileSync4, renameSync as renameSync5, statSync as statSync7, fstatSync, truncateSync, unlinkSync as unlinkSync3, existsSync as existsSync9, openSync as openSync2, writeSync, closeSync as closeSync2 } from "fs";
 var realIo = {
   size: (path) => {
     try {
@@ -10632,6 +10743,7 @@ var realOwnerIo = {
   }
 };
 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);
@@ -10656,13 +10768,14 @@ function rotateDaemonLog(path, opts, io = realIo) {
   io.truncate(path);
   return "rotated";
 }
+var teedTo = null;
 
 // src/daemonLaunch.ts
-import { openSync as openSync2, closeSync as closeSync2, readFileSync as readFileSync9 } from "fs";
+import { openSync as openSync3, closeSync as closeSync3, readFileSync as readFileSync9 } from "fs";
 import { spawn } from "child_process";
 var realRespawnIo = {
   isTty: () => process.stdout.isTTY === true,
-  open: (path) => openSync2(path, "a")
+  open: (path) => openSync3(path, "a")
 };
 function respawnStdio(logPath, io = realRespawnIo) {
   if (io.isTty()) return "inherit";
@@ -11464,7 +11577,7 @@ function buildReliefCostCandidates(cost, t, sustainMs, build) {
 
 // src/launcher.ts
 import { spawn as spawn2 } from "child_process";
-import { closeSync as closeSync3, existsSync as existsSync12, mkdirSync as mkdirSync9, openSync as openSync3, readdirSync as readdirSync10 } from "fs";
+import { closeSync as closeSync4, existsSync as existsSync12, mkdirSync as mkdirSync9, openSync as openSync4, readdirSync as readdirSync10 } from "fs";
 import { createRequire } from "module";
 import { homedir as homedir6 } from "os";
 import { dirname as dirname3, join as join18 } from "path";
@@ -11673,14 +11786,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;
     }
@@ -11810,8 +11923,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;
@@ -12092,7 +12205,7 @@ import { execa } from "execa";
 
 // src/prepareLock.ts
 import { createHash } from "crypto";
-import { closeSync as closeSync4, openSync as openSync4, rmSync as rmSync2, statSync as statSync12, writeSync } from "fs";
+import { closeSync as closeSync5, openSync as openSync5, rmSync as rmSync2, statSync as statSync12, writeSync as writeSync2 } from "fs";
 import { join as join23 } from "path";
 import { tmpdir } from "os";
 var WAIT_TIMEOUT_MS = 5 * 6e4;
@@ -12103,11 +12216,11 @@ function machineLockPath(key, dir = tmpdir()) {
 }
 function defaultTryCreate(path, content) {
   try {
-    const fd = openSync4(path, "wx");
+    const fd = openSync5(path, "wx");
     try {
-      writeSync(fd, content);
+      writeSync2(fd, content);
     } finally {
-      closeSync4(fd);
+      closeSync5(fd);
     }
     return true;
   } catch {
@@ -12846,6 +12959,18 @@ var FileOverlapError = class extends SpawnDeferredError {
   }
   blockedByRunId;
 };
+var SpawnAbandonedError = class extends Error {
+  constructor(status) {
+    super(`\u043F\u0440\u043E\u0433\u043E\u043D \u0441\u043D\u044F\u0442 (${status}), \u043F\u043E\u043A\u0430 \u0433\u043E\u0442\u043E\u0432\u0438\u043B\u0430\u0441\u044C \u0440\u0430\u0431\u043E\u0447\u0430\u044F \u043A\u043E\u043F\u0438\u044F \u2014 \u0434\u0440\u043E\u043D\u0430 \u043D\u0435 \u043F\u043E\u0434\u043D\u0438\u043C\u0430\u044E`);
+    this.status = status;
+    this.name = "SpawnAbandonedError";
+  }
+  status;
+};
+function assertStillWanted(db, runId) {
+  const fresh = db.getRun(runId);
+  if (fresh && isTerminalStatus(fresh.status)) throw new SpawnAbandonedError(fresh.status);
+}
 function healTaskSlug(db, run2, task) {
   const slug = task?.slug;
   if (!slug || slug === run2.task_slug || !isTaskSlug(slug) || isTaskSlug(run2.task_slug)) return run2;
@@ -12863,6 +12988,7 @@ async function spawnDrone(deps, run2) {
     if (run2.area && deps.db.runningAreas("").includes(run2.area)) throw new AreaBusyError(run2.area);
     deps.db.addEvent(run2.id, "step", `repoless-\u043F\u0440\u043E\u0433\u043E\u043D: \u0441\u043A\u0440\u0430\u0442\u0447-\u043A\u0430\u0442\u0430\u043B\u043E\u0433 ${workdir} (\u0431\u0435\u0437 worktree/\u0432\u0435\u0442\u043A\u0438/PR \u2014 TASWM-595)`);
     const built2 = await deps.buildPrompt(run2, workdir);
+    assertStillWanted(deps.db, run2.id);
     const pid2 = deps.launch({ worktree: workdir, run: run2, prompt: built2 });
     deps.db.addEvent(run2.id, "step", `\u0434\u0440\u043E\u043D \u0437\u0430\u043F\u0443\u0449\u0435\u043D \u0432 ${workdir} (pid ${pid2})`);
     return deps.db.updateRun(run2.id, {
@@ -12898,6 +13024,7 @@ async function spawnDrone(deps, run2) {
   const prompt = notice ? `${built}
 
 ${notice}` : built;
+  assertStillWanted(deps.db, run2.id);
   const pid = deps.launch({ worktree, run: run2, prompt });
   deps.db.addEvent(run2.id, "step", `\u0434\u0440\u043E\u043D \u0437\u0430\u043F\u0443\u0449\u0435\u043D \u0432 ${worktree} (pid ${pid})`);
   return deps.db.updateRun(run2.id, {
@@ -13074,7 +13201,7 @@ function parkReasonUnretriable(reason) {
 // package.json
 var 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: [
@@ -13123,9 +13250,10 @@ var package_default = {
     "@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"
 };
 
 // src/version.ts
@@ -15798,11 +15926,17 @@ init_procList();
 // 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());
@@ -15810,6 +15944,13 @@ function resilientSwarmMcp(opts = {}) {
   const downAfterMs = opts.downAfterMs ?? DEFAULT_DOWN_AFTER_MS;
   const retryDelays = opts.retryDelaysMs ?? DEFAULT_RETRY_DELAYS_MS;
   const sleep2 = 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;
@@ -15832,6 +15973,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;
@@ -15848,17 +15990,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();
@@ -15866,13 +16021,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 sleep2(delay);
@@ -15880,6 +16036,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 })
@@ -19470,8 +19630,19 @@ function countInFlight(db) {
   return db.listRuns().filter((r) => r.kind !== "hero" && IN_FLIGHT_STATUSES.has(r.status)).length;
 }
 function countActiveDrones(db) {
-  return db.listRuns().filter((r) => r.kind !== "hero" && ACTIVE_DRONE_STATUSES.has(r.status)).length;
+  const preparing = preparingRuns(db);
+  return db.listRuns().filter((r) => r.kind !== "hero" && (ACTIVE_DRONE_STATUSES.has(r.status) || preparing.has(r.id))).length;
+}
+var preparingByStore = /* @__PURE__ */ new WeakMap();
+function preparingRuns(db) {
+  let map = preparingByStore.get(db);
+  if (!map) preparingByStore.set(db, map = /* @__PURE__ */ new Map());
+  return map;
 }
+function hasPreparingRuns(db) {
+  return preparingRuns(db).size > 0;
+}
+var SPAWN_INLINE_WAIT_MS = 2e3;
 function countActiveReviewers(db) {
   return db.listRuns().filter((r) => r.kind === "reviewer" && ACTIVE_DRONE_STATUSES.has(r.status)).length;
 }
@@ -21092,6 +21263,7 @@ function noteStormStall(deps) {
   for (const run2 of waiting) deferSpawn(deps, run2, reason, { quiet: true });
 }
 async function trySpawnQueuedRun(deps, run2) {
+  if (preparingRuns(deps.db).has(run2.id)) return "skipped";
   if (deps.control?.paused) {
     const why = deps.control.state?.reason;
     return deferSpawn(deps, run2, `\u043E\u043F\u0435\u0440\u0430\u0442\u043E\u0440 \u043E\u0441\u0442\u0430\u043D\u043E\u0432\u0438\u043B \u043F\u0440\u0438\u0451\u043C \u043D\u043E\u0432\u043E\u0439 \u0440\u0430\u0431\u043E\u0442\u044B \u043D\u0430 \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435${why ? ` \u2014 ${why}` : ""} (\u043F\u0430\u0443\u0437\u0430)`, {
@@ -21186,12 +21358,55 @@ async function trySpawnQueuedRun(deps, run2) {
   await fillSuggestedArea(deps, run2);
   const repoGap = unresolvedRepoReason(run2.repo, deps.reposServed ? deps.reposServed() : []);
   if (repoGap) return await failBeforeStart(deps, run2, repoGap);
+  return await spawnOrPrepareInBackground(deps, run2);
+}
+async function spawnOrPrepareInBackground(deps, run2) {
+  const preparing = preparingRuns(deps.db);
+  const repoKey = normalizeRepo(run2.repo || deps.repoFallback || "");
+  for (const [otherId, otherRepo] of preparing) {
+    if (otherId !== run2.id && otherRepo === repoKey) {
+      return deferSpawn(deps, run2, `\u0432 \u044D\u0442\u043E\u043C \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0438 \u0435\u0449\u0451 \u0433\u043E\u0442\u043E\u0432\u0438\u0442\u0441\u044F \u0440\u0430\u0431\u043E\u0447\u0430\u044F \u043A\u043E\u043F\u0438\u044F \u043F\u0440\u043E\u0433\u043E\u043D\u0430 #${otherId} \u2014 \u0436\u0434\u0443 \u0435\u0451, \u0447\u0442\u043E\u0431\u044B \u043D\u0435 \u043F\u043E\u0434\u043D\u044F\u0442\u044C \u0434\u0432\u0435 \u043F\u043E\u0434\u0433\u043E\u0442\u043E\u0432\u043A\u0438 \u0440\u0430\u0437\u043E\u043C (TASWM-611)`);
+    }
+  }
+  preparing.set(run2.id, repoKey);
+  const attempt = spawnQueuedRun(deps, run2);
+  const release = () => {
+    preparing.delete(run2.id);
+  };
+  void attempt.then(release, release);
+  let timer;
+  const background = /* @__PURE__ */ Symbol("background");
+  const waited = new Promise((resolve5) => {
+    timer = setTimeout(() => resolve5(background), SPAWN_INLINE_WAIT_MS);
+  });
+  try {
+    const first = await Promise.race([attempt, waited]);
+    if (first !== background) return first;
+  } finally {
+    clearTimeout(timer);
+  }
+  deps.db.addEvent(run2.id, "step", "\u0433\u043E\u0442\u043E\u0432\u0438\u0442\u0441\u044F: \u043F\u043E\u0434\u0433\u043E\u0442\u043E\u0432\u043A\u0430 \u0440\u0430\u0431\u043E\u0447\u0435\u0439 \u043A\u043E\u043F\u0438\u0438 \u0438\u0434\u0451\u0442 \u0444\u043E\u043D\u043E\u043C, \u0442\u0438\u043A \u0435\u0451 \u043D\u0435 \u0436\u0434\u0451\u0442 (TASWM-611)");
+  console.log(`[overmind] ${droneLabel(run2)} (${run2.task_slug}) \u0433\u043E\u0442\u043E\u0432\u0438\u0442\u0441\u044F \u0444\u043E\u043D\u043E\u043C \u2014 \u043F\u043E\u0434\u0433\u043E\u0442\u043E\u0432\u043A\u0430 \u0434\u043E\u043B\u044C\u0448\u0435 ${SPAWN_INLINE_WAIT_MS / 1e3}\u0441, \u0442\u0438\u043A \u0438\u0434\u0451\u0442 \u0434\u0430\u043B\u044C\u0448\u0435`);
+  void attempt.then(
+    (outcome) => {
+      if (outcome !== "spawned") console.warn(`[overmind] \u0444\u043E\u043D\u043E\u0432\u0430\u044F \u043F\u043E\u0434\u0433\u043E\u0442\u043E\u0432\u043A\u0430 ${run2.task_slug} \u043A\u043E\u043D\u0447\u0438\u043B\u0430\u0441\u044C \u0431\u0435\u0437 \u0434\u0440\u043E\u043D\u0430: ${outcome}`);
+    },
+    (e) => console.error(`[overmind] \u0444\u043E\u043D\u043E\u0432\u0430\u044F \u043F\u043E\u0434\u0433\u043E\u0442\u043E\u0432\u043A\u0430 ${run2.task_slug} \u0441\u043E\u0440\u0432\u0430\u043B\u0430\u0441\u044C: ${describeTickError(e)}`)
+  );
+  return "spawned";
+}
+async function spawnQueuedRun(deps, run2) {
   try {
     await deps.spawn(run2);
     if (deps.spawnDefer) clearDefer(deps.spawnDefer, `run:${run2.id}`);
     narrate(deps, `\u0411\u0435\u0440\u0443 ${run2.task_slug} \u0438\u0437 \u043E\u0447\u0435\u0440\u0435\u0434\u0438 \u2014 \u0441\u043F\u0430\u0432\u043D\u044E ${droneLabel(run2)}.`);
     return "spawned";
   } catch (e) {
+    if (e instanceof SpawnAbandonedError) {
+      deps.db.addEvent(run2.id, "step", e.message);
+      console.log(`[overmind] ${run2.task_slug}: ${e.message}`);
+      return "closed";
+    }
     if (e instanceof FileOverlapError) {
       const logged = deps.overlapLogged ??= /* @__PURE__ */ new Map();
       if (logged.get(run2.id) !== e.message) {
@@ -22165,7 +22380,9 @@ async function tickOnce(deps) {
   const now = deps.now ? deps.now() : Date.now();
   const worktreeExists = deps.worktreeExists ?? existsSync22;
   const hasTranscript = deps.hasTranscript ?? executorHasSession;
+  deps.stepClock?.mark("0 \u0437\u0430\u043C\u0435\u0440 \u0445\u043E\u0441\u0442\u0430");
   deps.sampleHost?.();
+  deps.stepClock?.mark("0a re-hydrate \u0437\u0435\u0440\u043A\u0430\u043B\u0430");
   if (deps.rehydrate) {
     const rh = deps.rehydrate;
     const sinceLast = rh.lastAt == null ? Infinity : now - rh.lastAt;
@@ -22178,6 +22395,7 @@ async function tickOnce(deps) {
       }
     }
   }
+  deps.stepClock?.mark("0a1 \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0438 \u043E\u0447\u0435\u0440\u0435\u0434\u0438");
   if (deps.db.refreshDeps) {
     const waiting = deps.db.listRuns("queued").flatMap((r) => r.depends_on ?? []);
     if (waiting.length) {
@@ -22188,6 +22406,7 @@ async function tickOnce(deps) {
       }
     }
   }
+  deps.stepClock?.mark("0a2b \u043C\u043E\u0441\u0442 \xABsqlite \u0434\u0440\u043E\u043D\u0430 \u2192 \u0437\u0435\u0440\u043A\u0430\u043B\u043E \u2192 \u043F\u0440\u043E\u0434\xBB");
   if (deps.droneBridge) {
     const br = deps.droneBridge;
     const sinceLast = br.lastAt == null ? Infinity : now - br.lastAt;
@@ -22200,6 +22419,7 @@ async function tickOnce(deps) {
       }
     }
   }
+  deps.stepClock?.mark("0a3 \u0441\u0432\u0435\u0440\u043A\u0430 \u043A\u043E\u0434\u0430 \u0434\u0435\u043C\u043E\u043D\u0430 \u0441 main");
   if (deps.daemonVersion) {
     const dv = deps.daemonVersion;
     const sinceLast = dv.lastAt == null ? Infinity : now - dv.lastAt;
@@ -22208,6 +22428,7 @@ async function tickOnce(deps) {
       await dv.run();
     }
   }
+  deps.stepClock?.mark("0a4 \u043A\u0430\u0440\u0442\u0430 \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0435\u0432 \u043C\u0430\u0448\u0438\u043D\u044B");
   if (deps.repoMap) {
     const rm4 = deps.repoMap;
     const sinceLast = rm4.lastAt == null ? Infinity : now - rm4.lastAt;
@@ -22220,6 +22441,7 @@ async function tickOnce(deps) {
       }
     }
   }
+  deps.stepClock?.mark("0b reap \u0432\u043D\u0435\u0448\u043D\u0435-\u0437\u0430\u0432\u0435\u0440\u0448\u0451\u043D\u043D\u044B\u0445");
   if (deps.rehydrate && deps.kill) {
     const kill = deps.kill;
     for (const run2 of deps.db.listRuns()) {
@@ -22233,6 +22455,7 @@ async function tickOnce(deps) {
       });
     }
   }
+  deps.stepClock?.mark("0c \u0437\u0430\u0449\u0438\u0442\u043D\u044B\u0439 sweep \u043E\u0441\u0438\u0440\u043E\u0442\u0435\u0432\u0448\u0438\u0445 \u043F\u0440\u043E\u0446\u0435\u0441\u0441\u043E\u0432/doc");
   if (deps.sweep) {
     const sw = deps.sweep;
     const sinceLast = sw.lastAt == null ? Infinity : now - sw.lastAt;
@@ -22245,6 +22468,7 @@ async function tickOnce(deps) {
       }
     }
   }
+  deps.stepClock?.mark("0c2 \u0436\u043D\u0435\u0446 worktree");
   if (deps.reapWorktrees) {
     const rw = deps.reapWorktrees;
     const sinceLast = rw.lastAt == null ? Infinity : now - rw.lastAt;
@@ -22257,6 +22481,7 @@ async function tickOnce(deps) {
       }
     }
   }
+  deps.stepClock?.mark("0d \u0445\u043E\u0437\u044F\u0439\u0441\u0442\u0432\u043E \u0434\u043E\u043B\u0433\u043E\u0436\u0438\u0432\u0443\u0449\u0435\u0433\u043E \u043F\u0440\u043E\u0446\u0435\u0441\u0441\u0430");
   if (deps.logRotate) {
     const lr = deps.logRotate;
     const sinceLast = lr.lastAt == null ? Infinity : now - lr.lastAt;
@@ -22270,6 +22495,7 @@ async function tickOnce(deps) {
     }
   }
   pruneGateLogs(deps);
+  deps.stepClock?.mark("0 \u0448\u0442\u043E\u0440\u043C");
   let stormActive = false;
   if (deps.storm) {
     for (const run2 of deps.db.listRuns("running")) {
@@ -22287,7 +22513,9 @@ async function tickOnce(deps) {
     stormActive = await manageStorm(deps, now, worktreeExists, hasTranscript);
   }
   const droneCap = deps.maxDrones ? await deps.maxDrones() : Infinity;
+  deps.stepClock?.mark("1 \u043F\u043E\u0434\u043D\u044F\u0442\u044C \u043E\u0447\u0435\u0440\u0435\u0434\u044C");
   if (stormActive) noteStormStall(deps);
+  deps.stepClock?.mark("0b \u0432\u0435\u0441 \u0437\u0430\u0434\u0430\u0447\u0438");
   try {
     await manageWeight(deps);
   } catch (e) {
@@ -22298,14 +22526,17 @@ async function tickOnce(deps) {
   } else if (!stormActive) {
     await batchSpawnQueue(deps, droneCap, now);
   }
+  deps.stepClock?.mark("1b \u0432\u043E\u0437\u0432\u0440\u0430\u0442 \u0437\u0430\u043F\u0430\u0440\u043A\u043E\u0432\u0430\u043D\u043D\u044B\u0445 \u0441\u0442\u043E\u0440\u043E\u0436\u0435\u043C \u043F\u0440\u043E\u0433\u0440\u0435\u0441\u0441\u0430");
   if (!stormActive) {
     await resumeWatchdogParked(deps, droneCap);
   }
+  deps.stepClock?.mark("1c \u043F\u043E\u0432\u0442\u043E\u0440 \u043E\u0442\u043B\u043E\u0436\u0435\u043D\u043D\u043E\u0433\u043E \u0441\u043F\u0430\u0432\u043D\u0430");
   try {
     await retryDeferredSpawns(deps, now, droneCap, stormActive);
   } catch (e) {
     console.error("[overmind] \u043F\u043E\u0432\u0442\u043E\u0440 \u043E\u0442\u043B\u043E\u0436\u0435\u043D\u043D\u043E\u0433\u043E \u0441\u043F\u0430\u0432\u043D\u0430 \u0441\u043E\u0440\u0432\u0430\u043B\u0441\u044F:", e);
   }
+  deps.stepClock?.mark("2 review \u2192 \u0441\u043C\u0435\u0440\u0436\u0435\u043D? \u0437\u0430\u043A\u0440\u044B\u0442\u044C");
   for (let run2 of deps.db.listRuns("review")) {
     try {
       if (run2.resolves_run_id != null) {
@@ -22555,12 +22786,19 @@ async function tickOnce(deps) {
       console.error(`[overmind] \u0440\u0435\u043A\u043E\u043D\u0441\u0430\u0439\u043B review-\u043F\u0440\u043E\u0433\u043E\u043D\u0430 #${run2.id} (${run2.task_slug}) \u0441\u043E\u0440\u0432\u0430\u043B\u0441\u044F:`, e);
     }
   }
+  deps.stepClock?.mark("2b \u0434\u0443\u0431\u043B\u0438-\u0440\u0430\u043D\u044B \u0437\u0430\u0434\u0430\u0447\u0438");
   await closeMergedTaskRuns(deps);
+  deps.stepClock?.mark("2b1 \u0430\u0432\u0442\u043E\u043F\u043E\u0434\u044A\u0451\u043C \u043F\u0440\u043E\u0432\u0435\u0440\u044F\u044E\u0449\u0435\u0433\u043E");
   await rescueReviewlessPrs(deps, stormActive, now);
+  deps.stepClock?.mark("2b1a \u0440\u0435\u0432\u044C\u044E\u0435\u0440 \u0431\u0435\u0437 \u043F\u0440\u0438\u0432\u044F\u0437\u043A\u0438");
   relinkUnboundReviewers(deps);
+  deps.stepClock?.mark("2b2 \u0440\u0435\u0432\u044C\u044E\u0435\u0440\u044B-\u0441\u0438\u0440\u043E\u0442\u044B");
   await closeOrphanedReviewers(deps);
+  deps.stepClock?.mark("2b3 \u0432\u0435\u0440\u0438\u0444\u0438\u043A\u0430\u0446\u0438\u044F");
   await spawnVerifiersForOpenPrs(deps, stormActive);
+  deps.stepClock?.mark("2c \u0432\u044B\u0447\u0438\u0441\u043B\u044F\u0435\u043C\u0430\u044F \u0444\u0430\u0437\u0430 \u0440\u0435\u0432\u044C\u044E");
   await refreshReviewPhases(deps);
+  deps.stepClock?.mark("3 liveness/stall/\u0430\u0432\u0442\u043E-\u043E\u0436\u0438\u0432\u043B\u0435\u043D\u0438\u0435");
   let liveChildPpids;
   try {
     liveChildPpids = deps.livePpids?.() ?? null;
@@ -22820,6 +23058,7 @@ async function tickOnce(deps) {
       });
     }
   }
+  deps.stepClock?.mark("3b \u043F\u043E\u043B \u0441\u043D\u0438\u0437\u0443");
   for (const run2 of deps.db.listRuns("paused")) {
     if (run2.kind === "hero") continue;
     if (run2.stop_reason === AWAITING_CI_REASON || isReliefPause(run2.stop_reason)) continue;
@@ -22834,7 +23073,9 @@ async function tickOnce(deps) {
     deps.db.addEvent(run2.id, "stalled", reason);
     narrate(deps, `${droneLabel(run2)} \u0432\u0438\u0441\u0435\u043B paused \u0431\u0435\u0437 \u0434\u0432\u0438\u0436\u0435\u043D\u0438\u044F ${Math.round(STALL_FLOOR_MS / 6e4)} \u043C\u0438\u043D \u2014 \u043F\u043E\u043C\u0435\u0447\u0430\u044E \u0437\u0430\u0432\u0438\u0441\u0448\u0438\u043C (TASWM-275).`);
   }
+  deps.stepClock?.mark("3c \u043F\u0440\u0435\u0434\u0435\u043B \u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044F \u043E\u0436\u0438\u0434\u0430\u043D\u0438\u044F ci");
   await escalateStaleCiWaits(deps, now);
+  deps.stepClock?.mark("4 \u043F\u0440\u043E\u0431\u0443\u0436\u0434\u0435\u043D\u0438\u0435 \u0437\u0430\u043C\u0435\u0440\u0448\u0438\u0445");
   if (deps.respawn && !stormActive) {
     for (const run2 of deps.db.listRuns("paused")) {
       if (run2.kind === "hero") continue;
@@ -22864,9 +23105,11 @@ async function tickOnce(deps) {
       }
     }
   }
+  deps.stepClock?.mark("4c \u0433\u0435\u0439\u0442-\u0443\u0432\u0430\u0436\u0430\u044E\u0449\u0438\u0439 \u043F\u043E\u0434\u044A\u0451\u043C \u043E\u0441\u0442\u0430\u0432\u0448\u0438\u0445\u0441\u044F storm_d");
   if (deps.respawn && deps.resourcesOk && !stormActive) {
     await resurrectStormDead(deps, worktreeExists, hasTranscript, { gateOpen: deps.resourcesOk(), cap: droneCap });
   }
+  deps.stepClock?.mark("4d \u043E\u0441\u0438\u0440\u043E\u0442\u0435\u0432\u0448\u0438\u0435 \u0432\u043E\u043F\u0440\u043E\u0441\u044B");
   try {
     const reaped = reapOrphanedQuestions(deps.db, now);
     if (reaped.withdrawn > 0) {
@@ -22877,11 +23120,13 @@ async function tickOnce(deps) {
   } catch (e) {
     console.error("[overmind] \u0443\u0431\u043E\u0440\u043A\u0430 \u043E\u0441\u0438\u0440\u043E\u0442\u0435\u0432\u0448\u0438\u0445 \u0432\u043E\u043F\u0440\u043E\u0441\u043E\u0432 \u0441\u043E\u0440\u0432\u0430\u043B\u0430\u0441\u044C:", e);
   }
+  deps.stepClock?.mark("4e \u043E\u0442\u0432\u0435\u0442 \u043D\u0430 \u0432\u043E\u043F\u0440\u043E\u0441 \u043E \u0431\u044E\u0434\u0436\u0435\u0442\u0435");
   try {
     await answerBudgetQuestions(deps, { stormActive, droneCap });
   } catch (e) {
     console.error("[overmind] \u0440\u0430\u0437\u0431\u043E\u0440 \u043E\u0442\u0432\u0435\u0442\u043E\u0432 \u043E \u0431\u044E\u0434\u0436\u0435\u0442\u0435 \u0441\u043E\u0440\u0432\u0430\u043B\u0441\u044F:", e);
   }
+  deps.stepClock?.mark("4b \u0432\u0441\u0442\u0440\u043E\u0435\u043D\u043D\u044B\u0439 \u043D\u0430\u0434\u0437\u043E\u0440");
   if (deps.anomalies && !deps.control?.paused) {
     const az = deps.anomalies;
     let ready = [];
@@ -22958,6 +23203,7 @@ async function tickOnce(deps) {
       }
     }
   }
+  deps.stepClock?.mark("4c \u0441\u0442\u043E\u0440\u043E\u0436 \u043F\u0440\u043E\u0433\u0440\u0435\u0441\u0441\u0430");
   if (deps.watchdog) {
     try {
       const action = decideWatchdogAction(deps.db, now, deps.watchdog.state, deps.watchdog.thresholds, droneCap, { exists: worktreeExists, hasTranscript }, await projectQuotaBlockedRunIds(deps));
@@ -22966,6 +23212,7 @@ async function tickOnce(deps) {
       console.error("[overmind] \u0441\u0442\u043E\u0440\u043E\u0436 \u043F\u0440\u043E\u0433\u0440\u0435\u0441\u0441\u0430: \u0442\u0438\u043A \u0441\u043E\u0440\u0432\u0430\u043B\u0441\u044F:", e);
     }
   }
+  deps.stepClock?.mark("5 \u0430\u0432\u0442\u043E-\u0438\u043D\u0442\u0435\u0439\u043A");
   const heavyInFlight = heavyRunsInFlight(deps);
   if (heavyInFlight.length && deps.intake) {
     const d = noteDefer(deps.spawnDefer ??= /* @__PURE__ */ new Map(), "weight-intake-hold", intakeHoldReason(heavyInFlight.map(droneLabel).join(", ")), GATE_LOG_HEARTBEAT_TICKS);
@@ -23404,7 +23651,11 @@ async function makeStore(repo, worktreesDir, repoFlag) {
     // Ретрай не молчит: обрыв, переигранный в том же вызове, всё равно виден.
     // Без этой строки самолечение связи — единственный путь, о котором в логе
     // ни слова, и разбор «почему тик подтормозил» упирается в тишину.
-    onRetry: ({ tool, attempt, reason }) => console.warn(`[overmind] \u043F\u0440\u043E\u0434-MCP: ${tool} \u043E\u0431\u043E\u0440\u0432\u0430\u043B\u0441\u044F (${reason}) \u2014 \u043F\u043E\u0432\u0442\u043E\u0440 ${attempt}.`)
+    onRetry: ({ tool, attempt, reason }) => console.warn(`[overmind] \u043F\u0440\u043E\u0434-MCP: ${tool} \u043E\u0431\u043E\u0440\u0432\u0430\u043B\u0441\u044F (${reason}) \u2014 \u043F\u043E\u0432\u0442\u043E\u0440 ${attempt}.`),
+    // TASWM-611: молчащий прод больше не держит проход минутами — остаток идёт без сети.
+    onBudgetSpent: ({ spentMs, budgetMs }) => console.warn(
+      `[overmind] \u043F\u0440\u043E\u0434-MCP \u043D\u0435 \u043E\u0442\u0432\u0435\u0447\u0430\u0435\u0442: \u043F\u0440\u043E\u0445\u043E\u0434 \u0443\u0436\u0435 \u043F\u043E\u0442\u0440\u0430\u0442\u0438\u043B \u043D\u0430 \u043D\u0435\u0433\u043E ${Math.round(spentMs / 1e3)}\u0441 (\u0431\u044E\u0434\u0436\u0435\u0442 ${Math.round(budgetMs / 1e3)}\u0441) \u2014 \u0434\u043E \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0435\u0433\u043E \u043F\u0440\u043E\u0445\u043E\u0434\u0430 \u0440\u0430\u0431\u043E\u0442\u0430\u044E \u0431\u0435\u0437 \u0441\u0435\u0442\u0438, \u0437\u0430\u043F\u0438\u0441\u0438 \u0436\u0434\u0443\u0442 \u0432 outbox.`
+    )
   });
   const explicitRegistry = await buildRepoRegistry(repoPaths);
   if (repoPaths.length > 0 && explicitRegistry.length < repoPaths.length) {
@@ -24774,12 +25025,14 @@ async function runDaemon(opts) {
   tickHealth.startedAt = Date.now();
   for (; ; ) {
     let tickError;
+    prodMcp?.beginPass?.();
+    deps.stepClock = makeStepClock();
     try {
       writeHeartbeat(HEARTBEAT_PATH, Date.now());
       await tickOnce(deps);
       if (restart.phase === "waiting") {
         const live2 = liveSessionIds(db, pidAlive);
-        if (live2.length === 0) performRestart([], restart.intent);
+        if (live2.length === 0 && !hasPreparingRuns(db)) performRestart([], restart.intent);
         else onRestartStillWaiting?.(live2.length);
       }
     } catch (e) {
@@ -24787,6 +25040,8 @@ async function runDaemon(opts) {
       console.error(`[overmind] \u0442\u0438\u043A \u0443\u043F\u0430\u043B: ${describeTickError(e)} \u2014 \u0446\u0438\u043A\u043B \u043F\u0440\u043E\u0434\u043E\u043B\u0436\u0430\u0435\u0442 \u0440\u0430\u0431\u043E\u0442\u0443`, e);
     }
     markTickDone(tickHealth, Date.now(), tickError);
+    const slow = slowPassLine(tickHealth.seq, deps.stepClock.finish());
+    if (slow) console.warn(slow);
     await new Promise((r) => setTimeout(r, interval));
   }
 }
@@ -24864,6 +25119,7 @@ export {
   REVIEW_SPAWN_LIMIT,
   REVIEW_UNRECOVERABLE_MARK,
   SELF_REFERENCE_MARK,
+  SPAWN_INLINE_WAIT_MS,
   STALL_FLOOR_MS,
   STALL_MS,
   STORM_DEAD_LIMIT,
@@ -24891,6 +25147,7 @@ export {
   cycleCapHolder,
   effectiveReviewCycleLimit,
   hasLiveDescendant,
+  hasPreparingRuns,
   isSubrun,
   lastChangesSummary,
   lastVerifySummary,