@taskless-app/swarm 0.6.14 → 0.6.15

package/dist/overmind.js

@@ -317,21 +317,28 @@ function computeReviewPhase(input) {
     return { kind: "reviewer_dead", label: REVIEW_PHASE_TEXT.reviewer_dead, ready: true };
   }
   const p = input.ciProgress;
+  if (p && p.total > 0 && p.pass >= p.total) {
+    return { kind: "awaiting_reviewer", label: REVIEW_PHASE_TEXT.awaiting_reviewer, ready: false };
+  }
   const label = p && p.total > 0 ? `${REVIEW_PHASE_TEXT.checks} \u2014 CI ${p.pass}/${p.total}` : REVIEW_PHASE_TEXT.checks;
   return { kind: "checks", label, ready: false };
 }
-var REVIEW_PHASE_TEXT;
+var REVIEW_PHASE_TEXT, PHASE_BY_LENGTH;
 var init_reviewPhase = __esm({
   "../swarm-core/src/reviewPhase.ts"() {
     "use strict";
     REVIEW_PHASE_TEXT = {
       checks: "\u0418\u0434\u0443\u0442 \u043F\u0440\u043E\u0432\u0435\u0440\u043A\u0438",
+      awaiting_reviewer: "\u0417\u0435\u043B\u0451\u043D\u044B\u0439 \u2014 \u0436\u0434\u0451\u0442 \u0440\u0435\u0432\u044C\u044E\u0435\u0440\u0430",
       ci_fixing: "CI \u043A\u0440\u0430\u0441\u043D\u044B\u0439 \u2014 \u0434\u0440\u043E\u043D \u0447\u0438\u043D\u0438\u0442",
       in_review: "\u041D\u0430 \u0440\u0435\u0432\u044C\u044E",
       changes: "\u041D\u0443\u0436\u043D\u044B \u043F\u0440\u0430\u0432\u043A\u0438 \u2014 \u0434\u0440\u043E\u043D \u043F\u0440\u0430\u0432\u0438\u0442",
       ready: "\u0417\u0435\u043B\u0451\u043D\u044B\u0439 \u2014 \u0433\u043E\u0442\u043E\u0432 \u043A \u043C\u0435\u0440\u0436\u0443",
       reviewer_dead: "\u0420\u0435\u0432\u044C\u044E\u0435\u0440 \u0443\u043C\u0435\u0440 \u2014 \u0432\u0435\u0440\u0434\u0438\u043A\u0442\u0430 \u043D\u0435\u0442, \u043D\u0443\u0436\u0435\u043D \u0447\u0435\u043B\u043E\u0432\u0435\u043A"
     };
+    PHASE_BY_LENGTH = Object.keys(REVIEW_PHASE_TEXT).sort(
+      (a, b) => REVIEW_PHASE_TEXT[b].length - REVIEW_PHASE_TEXT[a].length
+    );
   }
 });
 
@@ -511,7 +518,7 @@ var init_status = __esm({
 // ../swarm-core/src/deps.ts
 function judgeDep(runs) {
   const real = runs.filter((r) => !r.service);
-  if (real.length === 0) return { ...PENDING };
+  if (real.length === 0) return { ...UNKNOWN };
   if (real.some((r) => !isTerminalStatus(r.status))) return { ...PENDING };
   if (real.some((r) => r.status === "done")) {
     return { outcome: "done", met: true, status: "done", name: null, stopReason: null };
@@ -531,12 +538,13 @@ function depClearedText(slug, v) {
   const why = v.stopReason ? ` \u2014 ${v.stopReason}` : "";
   return `\u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u044C \u0441\u043D\u044F\u0442\u0430: \u0436\u0434\u0430\u043B ${who}, \u0442\u043E\u0442 ${how}${why}. \u0423\u0441\u043F\u0435\u0448\u043D\u043E\u0433\u043E \u0444\u0438\u043D\u0430\u043B\u0430 \u043D\u0435 \u0431\u0443\u0434\u0435\u0442 \u2014 \u0435\u0434\u0443.`;
 }
-var PENDING, DEP_END_LABEL;
+var PENDING, UNKNOWN, DEP_END_LABEL;
 var init_deps = __esm({
   "../swarm-core/src/deps.ts"() {
     "use strict";
     init_status();
     PENDING = { outcome: "pending", met: false, status: null, name: null, stopReason: null };
+    UNKNOWN = { outcome: "unknown", met: false, status: null, name: null, stopReason: null };
     DEP_END_LABEL = {
       stopped: "\u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D \u043E\u043F\u0435\u0440\u0430\u0442\u043E\u0440\u043E\u043C",
       failed: "\u0443\u043F\u0430\u043B",
@@ -555,6 +563,9 @@ function stampFromEpochSec(sec) {
 function sqliteMs(ts) {
   return Date.parse(ts.replace(" ", "T") + "Z");
 }
+function stampMs(at) {
+  return at.includes("T") ? Date.parse(at) : sqliteMs(at);
+}
 function toStamp(v) {
   if (typeof v !== "string" || !v) return null;
   const d = new Date(v);
@@ -1263,31 +1274,6 @@ function buildZoneModel(entries, opts = {}) {
   const entryTerms = tasks.map((t) => new Set(t.text ? tokenize(t.text) : []));
   return { tasks: tasks.length, zones, fileZone, spine, taskZone, zoneTerms, termZones, entries: tasks, entryTerms };
 }
-function zoneForFiles(model, files) {
-  if (!hasZoneModel(model) || !files.length) return null;
-  const spineSet = new Set(model.spine);
-  const touchedSpine = files.filter((f) => spineSet.has(f));
-  const votes = /* @__PURE__ */ new Map();
-  for (const f of new Set(files)) {
-    const z2 = model.fileZone.get(f) ?? (spineSet.has(f) ? null : pathZoneCandidate(f));
-    if (z2) bump(votes, z2);
-  }
-  const top = topKey(votes);
-  if (!top) {
-    return {
-      zone: SPINE_ZONE,
-      confidence: 1,
-      why: `\u0432\u0441\u0435 \u0444\u0430\u0439\u043B\u044B \u2014 \u043E\u0431\u0449\u0438\u0439 \u0445\u0440\u0435\u0431\u0435\u0442 (${touchedSpine.slice(0, 3).join(", ")})`,
-      spine: true
-    };
-  }
-  return {
-    zone: top.key,
-    confidence: top.share,
-    why: `${top.count} \u0438\u0437 ${[...votes.values()].reduce((a, b) => a + b, 0)} \u0444\u0430\u0439\u043B\u043E\u0432 \u2014 \u0437\u043E\u043D\u0430 ${top.key}`,
-    spine: touchedSpine.length > 0
-  };
-}
 function suggestZonesFromText(model, text, limit = 3) {
   if (!hasZoneModel(model)) return [];
   const terms = tokenize(text);
@@ -2105,6 +2091,7 @@ __export(config_exports, {
   REPO_MAP_PATH: () => REPO_MAP_PATH,
   REVIEW_CUTOFF_PATH: () => REVIEW_CUTOFF_PATH,
   RUN_LOGS_DIR: () => RUN_LOGS_DIR,
+  SWARM_ANOMALY_DEP_MISSING_MS: () => SWARM_ANOMALY_DEP_MISSING_MS,
   SWARM_ANOMALY_FAILED_SPIKE_COUNT: () => SWARM_ANOMALY_FAILED_SPIKE_COUNT,
   SWARM_ANOMALY_FAILED_SPIKE_WINDOW_MS: () => SWARM_ANOMALY_FAILED_SPIKE_WINDOW_MS,
   SWARM_ANOMALY_MAX_REPEATS: () => SWARM_ANOMALY_MAX_REPEATS,
@@ -2147,6 +2134,7 @@ __export(config_exports, {
   SWARM_REPO: () => SWARM_REPO,
   SWARM_REPO_MAP_MS: () => SWARM_REPO_MAP_MS,
   SWARM_REPO_PATHS: () => SWARM_REPO_PATHS,
+  SWARM_REPO_SCAN_TTL_MS: () => SWARM_REPO_SCAN_TTL_MS,
   SWARM_REVIEW_CAP: () => SWARM_REVIEW_CAP,
   SWARM_SCAN_DEPTH: () => SWARM_SCAN_DEPTH,
   SWARM_SCAN_ROOTS_RAW: () => SWARM_SCAN_ROOTS_RAW,
@@ -2168,6 +2156,7 @@ __export(config_exports, {
   WORKTREES_LEGACY_DIR: () => WORKTREES_LEGACY_DIR,
   WORKTREES_NOINDEX_DIR: () => WORKTREES_NOINDEX_DIR,
   droneWorktreePath: () => droneWorktreePath,
+  droneWorktreeRoot: () => droneWorktreeRoot,
   mcpEndpoint: () => mcpEndpoint,
   migrateWorktreesToNoindex: () => migrateWorktreesToNoindex,
   normalizeRepo: () => normalizeRepo,
@@ -2186,7 +2175,10 @@ function normalizeRepo(repo) {
   }
 }
 function droneWorktreePath(worktreesDir, repo, slug) {
-  return join5(worktreesDir, basename(normalizeRepo(repo)), slug);
+  return join5(droneWorktreeRoot(worktreesDir, repo), slug);
+}
+function droneWorktreeRoot(worktreesDir, repo) {
+  return join5(worktreesDir, basename(normalizeRepo(repo)));
 }
 function resolveEffectiveWorktreesDir(deps) {
   if (deps.envOverride) return deps.envOverride;
@@ -2248,7 +2240,7 @@ function reviewCutoffAt() {
   }
   return at;
 }
-var DB_PATH, EXECUTOR, 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_CPU_WINDOW_MS, SWARM_CPU_SANITY_BUSY, SWARM_CPU_SANITY_LOAD_FACTOR, SWARM_CPU_SANITY_LAG_MS, 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, SWARM_AUTO_VERIFY, 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 DB_PATH, EXECUTOR, 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_CPU_WINDOW_MS, SWARM_CPU_SANITY_BUSY, SWARM_CPU_SANITY_LOAD_FACTOR, SWARM_CPU_SANITY_LAG_MS, 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, SWARM_REPO_SCAN_TTL_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, SWARM_AUTO_VERIFY, 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_ANOMALY_DEP_MISSING_MS, SWARM_WATCHDOG_STALL_MS;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
@@ -2310,6 +2302,7 @@ var init_config = __esm({
     SWARM_SCAN_ROOTS_RAW = process.env.SWARM_SCAN_ROOTS || "";
     REPO_MAP_PATH = process.env.SWARM_REPO_MAP || join5(SWARM_HOME, "repo-map.json");
     SWARM_REPO_MAP_MS = envNum("SWARM_REPO_MAP_MS", 15 * 6e4);
+    SWARM_REPO_SCAN_TTL_MS = envNum("SWARM_REPO_SCAN_TTL_MS", 24 * 60 * 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";
@@ -2336,6 +2329,7 @@ var init_config = __esm({
     SWARM_ANOMALY_QUESTION_UNANSWERED_MS = envNum("SWARM_ANOMALY_QUESTION_UNANSWERED_MS", 20 * 6e4);
     SWARM_ANOMALY_OUTBOX_STUCK_MS = envNum("SWARM_ANOMALY_OUTBOX_STUCK_MS", 10 * 6e4);
     SWARM_ANOMALY_RESOURCE_GATE_STALL_MS = envNum("SWARM_ANOMALY_RESOURCE_GATE_STALL_MS", 5 * 6e4);
+    SWARM_ANOMALY_DEP_MISSING_MS = envNum("SWARM_ANOMALY_DEP_MISSING_MS", 2 * 6e4);
     SWARM_WATCHDOG_STALL_MS = envNum("SWARM_WATCHDOG_STALL_MS", 15 * 6e4);
   }
 });
@@ -2734,11 +2728,11 @@ var init_storm = __esm({
 });
 
 // src/heartbeat.ts
-import { readFileSync as readFileSync5, renameSync as renameSync3, writeFileSync as writeFileSync5 } from "fs";
+import { readFileSync as readFileSync5, renameSync as renameSync4, writeFileSync as writeFileSync5 } from "fs";
 function writeHeartbeat(path, now) {
   const tmp = `${path}.tmp`;
   writeFileSync5(tmp, String(now));
-  renameSync3(tmp, path);
+  renameSync4(tmp, path);
 }
 function readHeartbeat(path) {
   try {
@@ -2761,7 +2755,7 @@ var init_heartbeat = __esm({
 
 // src/agentToken.ts
 import { readFileSync as readFileSync7, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3 } from "fs";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 function loadAgentToken() {
   try {
     const s = JSON.parse(readFileSync7(STORE_PATH, "utf8"));
@@ -2817,7 +2811,7 @@ var init_agentToken = __esm({
   "src/agentToken.ts"() {
     "use strict";
     init_config();
-    STORE_PATH = join8(SWARM_HOME, "agent.json");
+    STORE_PATH = join9(SWARM_HOME, "agent.json");
     base = (api) => api.replace(/\/$/, "");
     TOKEN_PROBE_TIMEOUT_MS = 8e3;
   }
@@ -3177,9 +3171,9 @@ var init_procCleanup = __esm({
 });
 
 // src/git.ts
-import { existsSync as existsSync9, readdirSync as readdirSync10, statSync as statSync7 } from "fs";
+import { existsSync as existsSync10, readdirSync as readdirSync11, statSync as statSync8 } from "fs";
 import { appendFile, chmod, mkdir, readFile, rm, writeFile } from "fs/promises";
-import { isAbsolute as isAbsolute2, join as join16, sep as sep2 } from "path";
+import { isAbsolute as isAbsolute2, join as join17, sep as sep2 } from "path";
 import { $ as $2 } from "execa";
 function isUnrecoverableRefError(e) {
   if (e instanceof MissingRefError) return true;
@@ -3191,7 +3185,7 @@ async function reclaimStaleWorktree(repo, worktree) {
 }
 function isLinkedWorktree(dir) {
   try {
-    return statSync7(join16(dir, ".git")).isFile();
+    return statSync8(join17(dir, ".git")).isFile();
   } catch {
     return false;
   }
@@ -3203,7 +3197,7 @@ async function detachWorktree(repo, worktree) {
   }
 }
 async function ensureWorktreeDirGone(worktree) {
-  if (!existsSync9(worktree)) return false;
+  if (!existsSync10(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.`
@@ -3218,7 +3212,7 @@ async function ensureWorktreeDirGone(worktree) {
     );
     return true;
   }
-  if (existsSync9(worktree)) {
+  if (existsSync10(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;
@@ -3266,7 +3260,7 @@ async function checkoutWorktree(repo, path, branch, opts) {
   }
   const busyAt = await worktreeForBranch(repo, branch);
   if (busyAt) {
-    const exists = existsSync9(busyAt);
+    const exists = existsSync10(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);
@@ -3301,8 +3295,8 @@ async function ensureGitExcluded(worktree, pattern) {
   try {
     const commonDir = await gitPath(worktree, "--git-common-dir");
     if (!commonDir) return false;
-    const infoDir = join16(commonDir, "info");
-    const excludeFile = join16(infoDir, "exclude");
+    const infoDir = join17(commonDir, "info");
+    const excludeFile = join17(infoDir, "exclude");
     let current = "";
     try {
       current = await readFile(excludeFile, "utf8");
@@ -3322,7 +3316,7 @@ async function gitPath(worktree, flag) {
   const out = await $2({ reject: false })`git -C ${worktree} rev-parse ${flag}`;
   const raw = out.stdout.trim();
   if (out.exitCode !== 0 || !raw) return null;
-  return isAbsolute2(raw) ? raw : join16(worktree, raw);
+  return isAbsolute2(raw) ? raw : join17(worktree, raw);
 }
 async function ensureWorktreeHygiene(worktree) {
   for (const pattern of SWARM_EXCLUDE_PATTERNS) await ensureGitExcluded(worktree, pattern);
@@ -3332,12 +3326,12 @@ async function installGuardHooks(worktree) {
   try {
     const gitDir = await gitPath(worktree, "--git-dir");
     if (!gitDir) return false;
-    const hooksDir = join16(gitDir, "swarm-hooks");
+    const hooksDir = join17(gitDir, "swarm-hooks");
     const prev = await previousHooksPath(worktree);
     await mkdir(hooksDir, { recursive: true });
     for (const hook of GUARD_HOOKS) {
-      await writeFile(join16(hooksDir, hook), guardHookScript(hook, prev ? `${posix(prev)}/${hook}` : null));
-      await chmod(join16(hooksDir, hook), 493);
+      await writeFile(join17(hooksDir, hook), guardHookScript(hook, prev ? `${posix(prev)}/${hook}` : null));
+      await chmod(join17(hooksDir, hook), 493);
     }
     await $2`git -C ${worktree} config extensions.worktreeConfig true`;
     await $2`git -C ${worktree} config --worktree core.hooksPath ${posix(hooksDir)}`;
@@ -3356,7 +3350,7 @@ async function previousHooksPath(worktree) {
     if (out.exitCode === 0 && value) return value;
   }
   const commonDir = await gitPath(worktree, "--git-common-dir");
-  return commonDir ? join16(commonDir, "hooks") : null;
+  return commonDir ? join17(commonDir, "hooks") : null;
 }
 async function removeWorktree(repo, path) {
   const branch = (await $2({ reject: false })`git -C ${path} symbolic-ref --quiet --short HEAD`).stdout.trim();
@@ -3375,7 +3369,7 @@ async function worktreeDirty(path) {
 async function repairMovedWorktrees(targetDir) {
   const subdirs = (dir) => {
     try {
-      return readdirSync10(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join16(dir, d.name));
+      return readdirSync11(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join17(dir, d.name));
     } catch {
       return [];
     }
@@ -3502,7 +3496,7 @@ __export(droneChannel_exports, {
   verifyLocalCliToken: () => verifyLocalCliToken
 });
 import { createHmac, randomBytes, timingSafeEqual } from "crypto";
-import { chmodSync, mkdirSync as mkdirSync7, readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "fs";
+import { chmodSync, mkdirSync as mkdirSync8, readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "fs";
 import { dirname as dirname3 } from "path";
 import { serve } from "@hono/node-server";
 function loadChannelSecret(path) {
@@ -3512,7 +3506,7 @@ function loadChannelSecret(path) {
   } catch {
   }
   const secret = randomBytes(32).toString("hex");
-  mkdirSync7(dirname3(path), { recursive: true });
+  mkdirSync8(dirname3(path), { recursive: true });
   writeFileSync10(path, secret, { mode: 384 });
   try {
     chmodSync(path, 384);
@@ -3857,7 +3851,7 @@ var init_droneChannel = __esm({
 
 // src/attachments.ts
 import { mkdir as mkdir2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 function attachmentsFromDoc(doc, origin) {
   const out = [];
   const walk2 = (node) => {
@@ -3948,7 +3942,7 @@ async function materializeAttachments(opts) {
   };
   const result = { files: [], skipped: [] };
   if (opts.refs.length === 0) return result;
-  const dir = join19(opts.worktree, ATTACHMENTS_DIR);
+  const dir = join20(opts.worktree, ATTACHMENTS_DIR);
   await io.removeDir(dir);
   let dirReady = false;
   let total = 0;
@@ -3994,7 +3988,7 @@ async function materializeAttachments(opts) {
         await io.mkdir(dir);
         dirReady = true;
       }
-      await io.writeFile(join19(dir, name), file.bytes);
+      await io.writeFile(join20(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;
@@ -4147,7 +4141,7 @@ var init_attachments = __esm({
 
 // src/shotUpload.ts
 import { readFile as fsReadFile } from "fs/promises";
-import { basename as basename2, isAbsolute as isAbsolute3, join as join20 } from "path";
+import { basename as basename2, isAbsolute as isAbsolute3, join as join21 } from "path";
 function shotMimetype(path) {
   const dot = path.lastIndexOf(".");
   if (dot < 0) return null;
@@ -4173,7 +4167,7 @@ async function readShots(paths, opts) {
     }
     let bytes;
     try {
-      bytes = await read(isAbsolute3(path) ? path : join20(opts.worktree, path));
+      bytes = await read(isAbsolute3(path) ? path : join21(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;
@@ -4252,7 +4246,7 @@ var init_shotUpload = __esm({
 // src/oauth.ts
 import { createHash as createHash2, randomBytes as randomBytes2 } from "crypto";
 import { readFileSync as readFileSync15, writeFileSync as writeFileSync11, unlinkSync as unlinkSync4 } from "fs";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 function makePkce() {
   const verifier = randomBytes2(48).toString("base64url");
   const challenge = createHash2("sha256").update(verifier).digest("base64url");
@@ -4387,8 +4381,8 @@ var init_oauth = __esm({
     AUTHORIZE = "/api/oauth/authorize";
     TOKEN = "/api/oauth/token";
     SCOPE = "openid profile email taskless:full";
-    STORE_PATH2 = join21(SWARM_HOME, "oauth.json");
-    CLIENT_PATH = join21(SWARM_HOME, "oauth-client.json");
+    STORE_PATH2 = join22(SWARM_HOME, "oauth.json");
+    CLIENT_PATH = join22(SWARM_HOME, "oauth-client.json");
     base2 = (api) => api.replace(/\/$/, "");
   }
 });
@@ -4435,7 +4429,7 @@ var init_authState = __esm({
 
 // src/workspace.ts
 import { readFileSync as readFileSync16, writeFileSync as writeFileSync12, unlinkSync as unlinkSync5 } from "fs";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 function loadWorkspace() {
   try {
     const w = JSON.parse(readFileSync16(WORKSPACE_PATH, "utf8"));
@@ -4452,7 +4446,7 @@ var init_workspace = __esm({
   "src/workspace.ts"() {
     "use strict";
     init_config();
-    WORKSPACE_PATH = join22(SWARM_HOME, "workspace.json");
+    WORKSPACE_PATH = join23(SWARM_HOME, "workspace.json");
   }
 });
 
@@ -4947,7 +4941,8 @@ __export(db_exports, {
   SwarmDb: () => SwarmDb
 });
 import { createRequire as createRequire2 } from "module";
-import { existsSync as existsSync11 } from "fs";
+import { randomUUID as randomUUID3 } from "crypto";
+import { existsSync as existsSync12 } from "fs";
 import { resolve as resolve3 } from "path";
 function rowToQuestion(row) {
   return {
@@ -5109,6 +5104,12 @@ CREATE INDEX IF NOT EXISTS idx_runs_area ON runs(area);
 CREATE INDEX IF NOT EXISTS idx_questions_run ON questions(run_id);
 CREATE INDEX IF NOT EXISTS idx_questions_status ON questions(status);
 CREATE INDEX IF NOT EXISTS idx_events_run ON events(run_id);
+-- \u043A\u043B\u044E\u0447-\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u043F\u0440\u043E \u0421\u0410\u041C \u0424\u0410\u0419\u041B \u0431\u0430\u0437\u044B (\u043D\u0435 \u043F\u0440\u043E \u043F\u0440\u043E\u0433\u043E\u043D\u044B). \u041F\u043E\u043A\u0430 \u0432 \u043D\u0451\u043C \u043E\u0434\u043D\u0430 \u0437\u0430\u043F\u0438\u0441\u044C \u2014 instance_id
+-- (TASWM-419): \u0438\u0434\u0435\u043D\u0442\u0438\u0444\u0438\u043A\u0430\u0442\u043E\u0440 \u042D\u0422\u041E\u0419 \u0436\u0438\u0437\u043D\u0438 \u0431\u0430\u0437\u044B, \u043A\u043E\u0442\u043E\u0440\u044B\u043C \u043D\u0435\u0439\u043C\u0441\u043F\u0435\u0439\u0441\u044F\u0442\u0441\u044F \u043A\u0430\u0442\u0430\u043B\u043E\u0433\u0438 run-log'\u043E\u0432.
+CREATE TABLE IF NOT EXISTS meta (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
 -- \u043C\u0430\u0440\u043A\u0435\u0440 \u0432\u044B\u043F\u043E\u043B\u043D\u0435\u043D\u043D\u044B\u0445 \u0438\u043C\u043F\u043E\u0440\u0442\u043E\u0432 \u0438\u0441\u0442\u043E\u0440\u0438\u0438 \u0438\u0437 \u0434\u0440\u0443\u0433\u0438\u0445 \u0411\u0414 (\u0438\u0434\u0435\u043C\u043F\u043E\u0442\u0435\u043D\u0442\u043D\u043E\u0441\u0442\u044C importDb)
 CREATE TABLE IF NOT EXISTS imports (
   source TEXT PRIMARY KEY,
@@ -5121,6 +5122,8 @@ CREATE TABLE IF NOT EXISTS imports (
       defaultRepo;
       databaseCtor;
       // для importDb (второй Database, source)
+      /** Идентификатор этой жизни файла базы (TASWM-419) — им неймспейсятся каталоги run-log'ов. */
+      instanceId;
       constructor(path = "swarm.db", defaultRepo = "") {
         this.defaultRepo = normalizeRepo(defaultRepo);
         this.databaseCtor = loadBetterSqlite3();
@@ -5188,6 +5191,22 @@ CREATE TABLE IF NOT EXISTS imports (
         if (this.defaultRepo) {
           this.db.prepare("UPDATE runs SET repo = ? WHERE repo IS NULL").run(this.defaultRepo);
         }
+        this.instanceId = this.ensureInstanceId();
+      }
+      /**
+       * Идентификатор ЭТОЙ жизни файла базы (TASWM-419). Заводится при первом открытии и живёт
+       * в самой базе, поэтому переживает рестарт демона, но НЕ переживает пересоздание файла:
+       * снесли базу — новый id, и каталоги run-log'ов нового прогона #1 не подселяются к файлам
+       * прогона #1 из прошлой жизни. Именно это и было корнем «лог не того прогона»: номер там
+       * был вся информация об адресе.
+       */
+      ensureInstanceId() {
+        const read = () => this.db.prepare("SELECT value FROM meta WHERE key = 'instance_id'").get()?.value;
+        const existing = read();
+        if (existing) return existing;
+        const fresh = randomUUID3().replace(/-/g, "").slice(0, 12);
+        this.db.prepare("INSERT OR IGNORE INTO meta (key, value) VALUES ('instance_id', ?)").run(fresh);
+        return read() ?? fresh;
       }
       close() {
         this.db.close();
@@ -5282,6 +5301,15 @@ CREATE TABLE IF NOT EXISTS imports (
         const m = /^local:(\d+)$/.exec(key);
         return m ? this.getRun(Number(m[1])) : null;
       }
+      /**
+       * TASWM-419: адрес каталога run-log'ов — номер, НЕЙМСПЕЙСНУТЫЙ идентификатором файла базы
+       * (`local:<instance>:<id>`). Тот же номер в пересозданной базе даёт другой instance, то
+       * есть другой каталог: подселиться к файлам чужого прогона с тем же номером больше нечем.
+       * Псевдонимов у sqlite-прогона нет — ключ не меняется, пока жив файл базы.
+       */
+      runLogKeys(id) {
+        return this.getRun(id) ? [`local:${this.instanceId}:${id}`] : [];
+      }
       listRuns(status) {
         const rows = status ? this.db.prepare("SELECT * FROM runs WHERE status = ? ORDER BY id DESC").all(status) : this.db.prepare("SELECT * FROM runs ORDER BY id DESC").all();
         return rows.map(rowToRun);
@@ -5522,7 +5550,7 @@ CREATE TABLE IF NOT EXISTS imports (
         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 (!existsSync11(abs)) throw new Error(`import-db: \u0444\u0430\u0439\u043B\u0430 \u043D\u0435\u0442: ${abs}`);
+        if (!existsSync12(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();
@@ -5891,8 +5919,8 @@ var init_droneStore = __esm({
 
 // src/overmind.ts
 import { homedir as homedir5 } from "os";
-import { existsSync as existsSync16, readFileSync as readFileSync20, readdirSync as readdirSync12, renameSync as renameSync10 } from "fs";
-import { basename as basename4, dirname as dirname4, join as join29 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync20, readdirSync as readdirSync13, renameSync as renameSync11 } from "fs";
+import { basename as basename4, dirname as dirname4, join as join30 } from "path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
 import { spawn as spawn3 } from "child_process";
 
@@ -5972,13 +6000,66 @@ init_config();
 init_resources();
 init_names2();
 init_storm();
-import { appendFileSync, existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { appendFileSync, existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
 import { dirname } from "path";
 import { randomUUID } from "crypto";
 
 // src/logTail.ts
-import { closeSync, existsSync as existsSync4, openSync, readSync, readdirSync as readdirSync4, statSync as statSync3 } from "fs";
+import { closeSync, existsSync as existsSync5, openSync, readSync, readdirSync as readdirSync5, statSync as statSync4 } from "fs";
+import { join as join7 } from "path";
+
+// src/runLogDir.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readdirSync as readdirSync4, renameSync as renameSync3, statSync as statSync3 } from "fs";
 import { join as join6 } from "path";
+var LEGACY_RUN_LOGS_SUBDIR = "legacy";
+function runLogDirName(runLogKey) {
+  const safe2 = runLogKey.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^[-_]+|[-_]+$/g, "");
+  if (!safe2) throw new Error(`\u043A\u043B\u044E\u0447 \u043F\u0440\u043E\u0433\u043E\u043D\u0430 \u043D\u0435 \u0433\u043E\u0434\u0438\u0442\u0441\u044F \u0432 \u0438\u043C\u044F \u043A\u0430\u0442\u0430\u043B\u043E\u0433\u0430 run-log'\u043E\u0432: ${JSON.stringify(runLogKey)}`);
+  return /^\d+$/.test(safe2) ? `k-${safe2}` : safe2;
+}
+function runLogDirPath(runLogsDir, runLogKey) {
+  return join6(runLogsDir, runLogDirName(runLogKey));
+}
+function findRunLogDir(runLogsDir, keys) {
+  for (const key of keys) {
+    const dir = runLogDirPath(runLogsDir, key);
+    if (existsSync4(dir)) return dir;
+  }
+  return null;
+}
+function runLogDirForWrite(runLogsDir, keys) {
+  const canonical = keys[0];
+  if (!canonical) return null;
+  return findRunLogDir(runLogsDir, keys) ?? runLogDirPath(runLogsDir, canonical);
+}
+function sweepLegacyRunLogs(runLogsDir) {
+  const legacyDir = join6(runLogsDir, LEGACY_RUN_LOGS_SUBDIR);
+  let entries;
+  try {
+    entries = readdirSync4(runLogsDir);
+  } catch {
+    return { moved: 0, failed: 0, legacyDir };
+  }
+  let moved = 0;
+  let failed = 0;
+  for (const name of entries) {
+    if (!/^\d+$/.test(name)) continue;
+    const from = join6(runLogsDir, name);
+    try {
+      if (!statSync3(from).isDirectory()) continue;
+      mkdirSync4(legacyDir, { recursive: true });
+      let to = join6(legacyDir, name);
+      for (let n = 2; existsSync4(to) && n < 100; n++) to = join6(legacyDir, `${name}-${n}`);
+      renameSync3(from, to);
+      moved++;
+    } catch {
+      failed++;
+    }
+  }
+  return { moved, failed, legacyDir };
+}
+
+// src/logTail.ts
 var TAIL_LINES_FALLBACK = 200;
 var TAIL_MAX_BYTES_FALLBACK = 64 * 1024;
 function fileHeader(name, size, shown) {
@@ -5988,7 +6069,7 @@ function fileHeader(name, size, shown) {
 function readTail(path, opts) {
   let size;
   try {
-    size = statSync3(path).size;
+    size = statSync4(path).size;
   } catch {
     return null;
   }
@@ -6018,11 +6099,12 @@ function readTail(path, opts) {
   text = rows.join("\n");
   return { text, size, shown: Buffer.byteLength(text, "utf8") };
 }
-function latestRunLaunch(runLogsDir, localRunId) {
-  const dir = join6(runLogsDir, String(localRunId));
+function latestRunLaunch(runLogsDir, runLogKeys) {
+  const dir = findRunLogDir(runLogsDir, runLogKeys);
+  if (!dir) return null;
   let files;
   try {
-    files = readdirSync4(dir);
+    files = readdirSync5(dir);
   } catch {
     return null;
   }
@@ -6033,13 +6115,17 @@ function latestRunLaunch(runLogsDir, localRunId) {
   }
   if (indexes.size === 0) return null;
   const index = Math.max(...indexes);
-  const out = [join6(dir, `${index}.json`), join6(dir, `${index}.json.done`)].find((p) => existsSync4(p)) ?? null;
-  const err = existsSync4(join6(dir, `${index}.err.log`)) ? join6(dir, `${index}.err.log`) : null;
+  const out = [join7(dir, `${index}.json`), join7(dir, `${index}.json.done`)].find((p) => existsSync5(p)) ?? null;
+  const err = existsSync5(join7(dir, `${index}.err.log`)) ? join7(dir, `${index}.err.log`) : null;
   return { index, total: indexes.size, out, err };
 }
-function runLogTail(runLogsDir, localRunId, opts) {
-  const launch = latestRunLaunch(runLogsDir, localRunId);
-  if (!launch) return { error: `\u043B\u043E\u0433\u0430 \u043F\u0440\u043E\u0433\u043E\u043D\u0430 \u043D\u0430 \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435 \u043D\u0435\u0442 (${join6(runLogsDir, String(localRunId))} \u043F\u0443\u0441\u0442 \u0438\u043B\u0438 \u043E\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u0435\u0442)` };
+function runLogTail(runLogsDir, runLogKeys, opts) {
+  const launch = latestRunLaunch(runLogsDir, runLogKeys);
+  if (!launch) {
+    const canonical = runLogKeys[0];
+    const where = canonical ? runLogDirPath(runLogsDir, canonical) : runLogsDir;
+    return { error: `\u043B\u043E\u0433\u0430 \u043F\u0440\u043E\u0433\u043E\u043D\u0430 \u043D\u0430 \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435 \u043D\u0435\u0442 (${where} \u043F\u0443\u0441\u0442 \u0438\u043B\u0438 \u043E\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u0435\u0442)` };
+  }
   const parts = [];
   let budget = opts.maxBytes;
   if (launch.err) {
@@ -6094,8 +6180,8 @@ async function serveLogRequests(deps, commands) {
       } else if (!cmd.runId) {
         result = { error: "\u043A\u043E\u043C\u0430\u043D\u0434\u0430 \u0431\u0435\u0437 runId \u2014 \u043D\u0435\u0447\u0435\u0433\u043E \u0447\u0438\u0442\u0430\u0442\u044C" };
       } else {
-        const local = deps.localRunId(cmd.runId);
-        result = local == null ? { error: `\u043F\u0440\u043E\u0433\u043E\u043D ${cmd.runId} \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435 \u043D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u0435\u043D (\u0435\u0433\u043E \u0432\u0435\u043B\u043E \u043D\u0435 \u043E\u043D\u0430?)` } : runLogTail(deps.runLogsDir, local, opts);
+        const keys = deps.runLogKeys(cmd.runId);
+        result = keys.length === 0 ? { error: `\u043F\u0440\u043E\u0433\u043E\u043D ${cmd.runId} \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435 \u043D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u0435\u043D (\u0435\u0433\u043E \u0432\u0435\u043B\u043E \u043D\u0435 \u043E\u043D\u0430?)` } : runLogTail(deps.runLogsDir, keys, opts);
       }
     } catch (e) {
       result = { error: `\u043D\u0435 \u0441\u043C\u043E\u0433 \u043F\u0440\u043E\u0447\u0438\u0442\u0430\u0442\u044C \u043B\u043E\u0433: ${e instanceof Error ? e.message : String(e)}` };
@@ -6191,6 +6277,11 @@ var SwarmClient = class _SwarmClient {
   // Живёт в памяти: рестарт демона просто переспросит прод.
   depsProd = /* @__PURE__ */ new Map();
   depsAskedAt = /* @__PURE__ */ new Map();
+  // TASWM-399: ссылка dependsOn → человеко-слаг блокера, как его назвал прод. В колонке
+  // лежит cuid прогона или задачи, а в лог демона, в событие прогона и в аномалию должен
+  // уходить «TASWM-392», а не «cmsqqpphd011y2xtbckkut6bj» — иначе оператору всё равно
+  // нечего искать. Резолв делает прод (см. resolveDepRefs), здесь только запоминаем.
+  depSlug = /* @__PURE__ */ new Map();
   static DEPS_TTL_MS = 6e4;
   // TASWM-327: прод старее демона и не знает аргумент `level` у swarm_notify. Выясняется
   // ровно один раз (первой отвергнутой нотификацией) и держится всю жизнь процесса — иначе
@@ -6250,25 +6341,25 @@ var SwarmClient = class _SwarmClient {
     this.repoFullNames = registry.map((e) => e.repoFullName);
     this.repoPathByFullName = new Map(registry.map((e) => [e.repoFullName, normalizeRepo(e.path)]));
     this.host = opts.host ?? null;
-    this.repoExists = opts.repoExists ?? existsSync5;
+    this.repoExists = opts.repoExists ?? existsSync6;
     this.questionSyncMs = opts.questionSyncMs ?? 3e3;
     this.executorId = opts.executorId ?? EXECUTOR.id;
     this.outboxPath = opts.outboxPath;
     this.mapPath = `${opts.outboxPath}.prodmap.json`;
     this.stormPath = `${opts.outboxPath}.storm.jsonl`;
-    mkdirSync4(dirname(this.outboxPath), { recursive: true });
+    mkdirSync5(dirname(this.outboxPath), { recursive: true });
     this.recover();
   }
   // ── рестарт: поднять outbox (незаписанные операции) и карту runKey→prodId ─────
   recover() {
-    if (existsSync5(this.mapPath)) {
+    if (existsSync6(this.mapPath)) {
       try {
         const obj = JSON.parse(readFileSync4(this.mapPath, "utf8"));
         for (const [k, v] of Object.entries(obj)) this.prodIdByKey.set(k, v);
       } catch {
       }
     }
-    if (existsSync5(this.outboxPath)) {
+    if (existsSync6(this.outboxPath)) {
       const txt = readFileSync4(this.outboxPath, "utf8");
       for (const line of txt.split("\n")) {
         const s = line.trim();
@@ -6289,7 +6380,7 @@ var SwarmClient = class _SwarmClient {
   // eventsLog ПЕРВЫМИ (до hydrate), в порядке файла (= хронологический); id
   // переприсваиваем локально (id событий — только порядок, не корреляция с продом).
   replayGlobalEvents() {
-    if (!existsSync5(this.stormPath)) return;
+    if (!existsSync6(this.stormPath)) return;
     let txt;
     try {
       txt = readFileSync4(this.stormPath, "utf8");
@@ -6554,6 +6645,24 @@ var SwarmClient = class _SwarmClient {
     const viaProd = [...this.runs.values()].find((r) => r.runKey === `p:${prodId}` || this.prodIdByKey.get(r.runKey) === prodId);
     return viaProd ? this.mat(viaProd) : null;
   }
+  /**
+   * TASWM-419: адреса каталога run-log'ов прогона. КАНОНИЧЕСКИЙ — прод-вида `p:<cuid>`, как
+   * только cuid известен: он один и тот же во всех жизнях демона, а локальный uuid прогона
+   * после рестарта уже не воскресает (гидрированный прогон приезжает под прод-ключом).
+   * Дальше — псевдонимы: uuid, под которым каталог мог завестись в окно между спавном и
+   * первым флашем в прод. По ним каталог ищется, чтобы запуски одного прогона не расползлись
+   * по двум каталогам (иначе cost недосчитал бы часть, а хвост показал бы не тот запуск).
+   * Номер прогона в адресе не участвует вовсе — он и есть источник «лога чужого прогона».
+   */
+  runLogKeys(id) {
+    const key = this.runs.get(id)?.runKey;
+    if (!key) return [];
+    const prodId = key.startsWith("p:") ? key.slice(2) : this.prodIdByKey.get(key);
+    if (!prodId) return [key];
+    const canonical = `p:${prodId}`;
+    const aliases = [key, ...[...this.prodIdByKey.entries()].filter(([, v]) => v === prodId).map(([k]) => k)];
+    return [canonical, ...new Set(aliases.filter((k) => k !== canonical))];
+  }
   listRuns(status) {
     const all = [...this.runs.values()].filter((r) => status ? r.status === status : true);
     all.sort((a, b) => b.id - a.id);
@@ -6670,16 +6779,25 @@ var SwarmClient = class _SwarmClient {
   /**
    * TASWM-361: вердикт по каждой зависимости — см. докблок SwarmStore.depVerdicts.
    *
-   * АСИММЕТРИЯ ЗЕРКАЛА И ПРОДА, и почему она здесь намеренная. Зеркало — ЧАСТИЧНАЯ выборка
-   * (только прогоны этой машины, только окно гидрации), и по частичной выборке два вывода
-   * стоят разного:
-   *   • «есть смерженный прогон слага» — вывод от НАЛИЧИЯ: чего зеркало не видит, того он не
-   *     портит, поэтому успех подтверждаем и локально (так было до TASWM-361);
-   *   • «живых прогонов слага не осталось» — вывод от ОТСУТСТВИЯ: невидимый зеркалу прогон
-   *     на соседней машине как раз и может быть живым. Поэтому «исчерпана неуспешно»
-   *     принимаем ТОЛЬКО из ответа прода (refreshDeps) — он видит всех.
-   * Прод недоступен → вердикта нет → прогон честно ждёт следующего окна: лишняя минута
-   * очереди дешевле дрона, поднятого поверх работающего блокера.
+   * ИСТОЧНИК ПРАВДЫ — ПРОД (TASWM-399), зеркало здесь только быстрый путь. Зеркало —
+   * ЧАСТИЧНАЯ выборка (прогоны этой машины, окно гидрации), и по частичной выборке два
+   * вывода стоят разного:
+   *   • «есть смерженный прогон слага» — вывод от НАЛИЧИЯ: чего зеркало не видит, того он
+   *     не портит, поэтому успех подтверждаем и локально (так было до TASWM-361);
+   *   • всё остальное — вывод от ОТСУТСТВИЯ, и его принимаем ТОЛЬКО из ответа прода
+   *     (refreshDeps): невидимый зеркалу прогон на соседней машине как раз и может быть
+   *     живым, а закрытый с прода — давно смерженным.
+   *
+   * ССЫЛКА — НЕ ОБЯЗАТЕЛЬНО СЛАГ. В `dependsOn` лежит чаще всего cuid ПРОГОНА (так пишет
+   * overmind), реже cuid задачи, и только дев-спавн `--after` пишет человеко-слаг. Быстрый
+   * путь по зеркалу сравнивает `task_slug`, то есть срабатывает лишь на третьей форме —
+   * это нормально: остальные две резолвит прод. А вот считать «раз в зеркале не нашёл —
+   * значит не готово» было корнем TASWM-399.
+   *
+   * Прода ещё не спрашивали (первый тик) или он моргнул → `pending`: прогон честно ждёт
+   * следующего окна. Лишняя минута очереди дешевле дрона, поднятого поверх работающего
+   * блокера. `unknown` (блокера НЕ ЗНАЕТ И ПРОД) ставит только ответ прода — местным
+   * незнанием такой вывод не делается.
    */
   depVerdicts(depends_on) {
     if (!depends_on || depends_on.length === 0) return [];
@@ -6689,57 +6807,89 @@ var SwarmClient = class _SwarmClient {
         doneInMirror.add(r.task_slug);
       }
     }
-    return depends_on.map((slug) => {
-      if (doneInMirror.has(slug)) {
-        return { slug, outcome: "done", met: true, status: "done", name: null, stopReason: null };
+    return depends_on.map((ref) => {
+      if (doneInMirror.has(ref)) {
+        return { slug: ref, outcome: "done", met: true, status: "done", name: null, stopReason: null };
+      }
+      const fromProd = this.depsProd.get(ref);
+      if (fromProd) {
+        if (fromProd.outcome === "unknown" && this.knowsDepRef(ref)) {
+          return { slug: this.depSlug.get(ref) ?? ref, outcome: "pending", met: false, status: null, name: null, stopReason: null };
+        }
+        return { slug: this.depSlug.get(ref) ?? ref, ...fromProd };
       }
-      const fromProd = this.depsProd.get(slug);
-      if (fromProd) return { slug, ...fromProd };
-      return { slug, outcome: "pending", met: false, status: null, name: null, stopReason: null };
+      return { slug: ref, outcome: "pending", met: false, status: null, name: null, stopReason: null };
     });
   }
   /**
-   * TASWM-300: спросить ПРОД про зависимости — см. докблок SwarmStore.refreshDeps.
+   * Знает ли ЗЕРКАЛО хоть один прогон по ссылке `dependsOn` (TASWM-399). Ссылка бывает
+   * слагом, cuid'ом задачи и cuid'ом прогона — последний сверяем с прод-id, как это
+   * делают runByProdId/refreshRun. Служебные сабраны (ревьюер/резолвер/верификатор) не
+   * в счёт: их существование не означает, что жив сам блокер.
+   */
+  knowsDepRef(ref) {
+    for (const r of this.runs.values()) {
+      if (r.resolves_run_id != null || r.reviews_run_id != null || r.verifies_run_id != null) continue;
+      if (r.task_slug === ref) return true;
+      if (r.runKey === `p:${ref}` || this.prodIdByKey.get(r.runKey) === ref) return true;
+    }
+    return false;
+  }
+  /**
+   * TASWM-300 → TASWM-399: спросить ПРОД про зависимости — см. докблок SwarmStore.refreshDeps.
+   *
+   * Почему зеркала мало. В нём лежат только прогоны ЭТОЙ машины (гейт isMine, hydrateRun) и
+   * только те, что попали в окно гидрации (`swarm_list_runs limit`, сортировка по updatedAt
+   * desc — сутки работы роя). Зависимость, закрытая на соседней машине, обнулившаяся при
+   * рестарте демона или просто позавчерашняя, в зеркало не попадала — и `dependsOn` держал
+   * прогон в очереди вечно.
    *
-   * Почему зеркала было мало. В нём лежат только прогоны ЭТОЙ машины (гейт isMine,
-   * hydrateRun) и только те, что попали в окно гидрации (`swarm_list_runs limit`, сортировка
-   * по updatedAt desc — сутки работы роя). Зависимость, закрытая на соседней машине или
-   * просто позавчера, в зеркало не попадала — и `--after` держал прогон в очереди вечно
-   * (04.08: снимали руками).
+   * ЧЕМ СПРАШИВАЕМ И ПОЧЕМУ НЕ `swarm_list_runs` (корень TASWM-399). До этой задачи здесь
+   * шёл `swarm_list_runs { taskId: <ref> }` — то есть ссылка трактовалась как ЗАДАЧА. Но в
+   * `dependsOn` чаще всего лежит cuid ПРОГОНА: `resolveTaskRef` его задачей не признаёт,
+   * ответ приходит `isError`, вердикт не появляется НИКОГДА, и прогон стоит молча при
+   * свободной машине (12–13.08 — пять остановок роя за сутки). `swarm_deps_status` понимает
+   * все три формы ссылки и отвечает по единому правилу роя (`judgeDep` на прод-стороне).
    *
    * Кеш. «Смержено» МОНОТОННО: прогон, ставший done, назад не откатывается, — поэтому
    * положительный ответ помним навсегда и больше не спрашиваем. Остальные вердикты (включая
-   * «исчерпана неуспешно», TASWM-361 — блокер могут переиграть новым прогоном) переспрашиваем
-   * не чаще DEPS_TTL_MS: тик идёт раз в ~4с, а ждущих зависимость прогонов может быть
-   * много — без TTL это был бы поход в прод на каждый слаг каждый тик.
+   * «исчерпана неуспешно» и «блокера не знает никто») переспрашиваем не чаще DEPS_TTL_MS:
+   * оператор вправе переиграть блокер новым прогоном, а тик идёт раз в ~4 с — без TTL это
+   * был бы поход в прод на каждую ссылку каждый тик.
+   *
+   * Одним вызовом на все просроченные ссылки, а не по вызову на ссылку: очередь ждущих
+   * бывает в десятки прогонов, и N запросов на тик — это тот же самый поход в прод, только
+   * дороже.
    */
-  async refreshDeps(slugs, nowMs = Date.now()) {
-    for (const slug of new Set(slugs)) {
-      if (!slug || this.depsProd.get(slug)?.outcome === "done") continue;
-      const asked = this.depsAskedAt.get(slug);
-      if (asked !== void 0 && nowMs - asked < _SwarmClient.DEPS_TTL_MS) continue;
-      this.depsAskedAt.set(slug, nowMs);
-      let res;
-      try {
-        res = await this.call("swarm_list_runs", { taskId: slug });
-      } catch {
-        this.depsAskedAt.delete(slug);
-        continue;
-      }
-      if (res?.isError) continue;
-      const runs = res.structuredContent?.runs ?? [];
-      const facts = runs.slice().sort((a, b) => String(a.createdAt ?? "").localeCompare(String(b.createdAt ?? ""))).map((r) => ({
-        status: String(r.status ?? ""),
-        // Служебный сабран под тем же слагом (резолвер конфликта / ревьюер): его финал —
-        // не финал задачи. Резолвер вычёркивался и до TASWM-361, ревьюер добавлен вместе
-        // с расширением критерия — иначе остановленный ревьюер закрывал бы зависимость.
-        service: Boolean(r.resolvesRunId) || Boolean(r.reviewsRunId) || Boolean(r.verifiesRunId),
-        // В проде имя дрона — колонка droneName (см. hydrateRun); `name` терпим как
-        // запасной вариант ради фикстур и старых ответов.
-        name: r.droneName ?? r.name ?? null,
-        stopReason: r.stopReason ?? null
-      }));
-      this.depsProd.set(slug, judgeDep(facts));
+  async refreshDeps(refs, nowMs = Date.now()) {
+    const ask = [...new Set(refs)].filter((ref) => {
+      if (!ref || this.depsProd.get(ref)?.outcome === "done") return false;
+      const asked = this.depsAskedAt.get(ref);
+      return asked === void 0 || nowMs - asked >= _SwarmClient.DEPS_TTL_MS;
+    });
+    if (!ask.length) return;
+    for (const ref of ask) this.depsAskedAt.set(ref, nowMs);
+    let res;
+    try {
+      res = await this.call("swarm_deps_status", { refs: ask });
+    } catch {
+      for (const ref of ask) this.depsAskedAt.delete(ref);
+      return;
+    }
+    if (res?.isError) return;
+    const deps = res.structuredContent?.deps ?? [];
+    for (const d of deps) {
+      const ref = typeof d.ref === "string" ? d.ref : null;
+      if (!ref) continue;
+      const outcome = String(d.outcome ?? "pending");
+      this.depsProd.set(ref, {
+        outcome,
+        met: Boolean(d.met),
+        status: d.status ?? null,
+        name: d.name ?? null,
+        stopReason: d.stopReason ?? null
+      });
+      if (typeof d.slug === "string" && d.slug) this.depSlug.set(ref, d.slug);
     }
   }
   /**
@@ -7058,7 +7208,7 @@ var SwarmClient = class _SwarmClient {
    * транзиентным сбоем ОС, который этот PR должен переживать, а не превращать в мор.
    */
   reconcileRuntime(opts) {
-    const wtExists = opts.worktreeExists ?? existsSync5;
+    const wtExists = opts.worktreeExists ?? existsSync6;
     const pidByWorktree = /* @__PURE__ */ new Map();
     try {
       for (const p of opts.listProcesses()) if (p.worktree) pidByWorktree.set(p.worktree, p.pid);
@@ -7547,6 +7697,12 @@ var SwarmClient = class _SwarmClient {
         ...typeof h.paused === "boolean" ? { paused: h.paused } : {},
         ...typeof h.pausedAt === "string" ? { pausedAt: h.pausedAt } : {},
         ...typeof h.pauseReason === "string" ? { pauseReason: h.pauseReason } : {},
+        // TASWM-424: «доступ отозван» — состояние ровно того же рода, что пауза, и
+        // формулировка у него ОДНА на все поверхности (HOST_ACCESS_REVOKED_TEXT):
+        // `hostLines` зовёт тот же `hostStateText`, что и парк машин в /swarm. Без
+        // этого поля `swarm hosts` показывал отвергнутую машину просто молчащей —
+        // то самое различие, ради которого флаг и заводили (TASWM-324).
+        ...typeof h.accessRevoked === "boolean" ? { accessRevoked: h.accessRevoked } : {},
         // Показаний нет (старый прод, машина со старым демоном) — ключа не заводим вовсе,
         // ровно как с паузой выше: «не знаем» и так значит «не знаем».
         ...resources ? { resources } : {}
@@ -7632,9 +7788,18 @@ var SwarmClient = class _SwarmClient {
    * ВСЕГДА (в т.ч. `storm:false`), как паузу: это состояние, а не команда, и молчание тут
    * означало бы «прод помнит вчерашний шторм», когда рой давно работает.
    *
+   * TASWM-402: тем же пульсом уезжают КОРНИ WORKTREE'ЕВ этой машины (`worktreeRoots` —
+   * `owner/repo` → `<worktreesDir>/<repo-basename>`). Это НЕ рантайм и правило «pid и путь
+   * дрона в прод не уходят» не трогает: корень — статичная конфигурация машины, того же
+   * рода, что реестр репо и ёмкость, он не зависит ни от прогона, ни от живости процесса и
+   * не протухает между пульсами. Прод склеивает `<корень>/<слаг>` сам — и отвечает человеку
+   * на вопрос «куда идти руками», когда команда машине не доиграла (а в этом случае, по
+   * определению, спросить рантайм у молчащей машины уже нельзя). Не передали корень (не
+   * знаем своего каталога) → ключа нет, прод прошлое не трогает — как с capacity/resources.
+   *
    * Прод недоступен / ответ без поручений → пустые списки (демон работает дальше).
    */
-  async heartbeat(daemonVersion, pause, capacity, resources, storm, signIn) {
+  async heartbeat(daemonVersion, pause, capacity, resources, storm, worktreesDir, signIn) {
     try {
       const args = this.repoFullNames.length ? { repoFullNames: this.repoFullNames } : {};
       if (daemonVersion) args.daemonVersion = daemonVersion;
@@ -7652,6 +7817,11 @@ var SwarmClient = class _SwarmClient {
         args.storm = storm.active;
         if (storm.reason) args.stormReason = storm.reason;
       }
+      if (worktreesDir) {
+        const roots = {};
+        for (const [full, path] of this.repoPathByFullName) roots[full] = droneWorktreeRoot(worktreesDir, path);
+        if (Object.keys(roots).length) args.worktreeRoots = roots;
+      }
       if (this.host) {
         args.hostId = this.host.hostId;
         args.hostName = this.host.hostName;
@@ -7800,10 +7970,20 @@ var SwarmClient = class _SwarmClient {
    * именно путь. Не нашли в реестре (репо не наш / ручной `--repo <path>` спавн, где
    * repo — ВСЕГДА уже путь, старый формат) → возвращаем как есть без изменений
    * (обратная совместимость: раньше pr.repo ВСЕГДА был локальным путём).
+   *
+   * РЕГИСТР НЕ РАЗЛИЧАЕМ (TASWM-422). Ключи карты приведены к нижнему регистру
+   * (parseRepoFullName — «GitHub сам не различает case в owner/repo»), а прод присылает
+   * `run.repo` тем регистром, каким репозиторий записан в проекте. 17.08 это разошлось:
+   * машина объявляла `ilyasmurov/ansamblist`, задача пришла с `ilyasmurov/Ansamblist`,
+   * `Map.get` промахнулся — и вместо пути в прогон уехало полное имя репозитория. Дальше
+   * git-операции шли в несуществующий каталог, прогон умирал за 5 секунд, а задача
+   * возвращалась в очередь и бралась снова: пять павших прогонов за пять минут.
+   * Возвращаем ИСХОДНУЮ строку, а не приведённую: промах бывает и на локальном пути
+   * (ручной спавн), а путь регистр различает — вернув lowercase, мы сломали бы его.
    */
   resolveRepo(raw) {
     if (!raw) return "";
-    return this.repoPathByFullName.get(raw) ?? raw;
+    return this.repoPathByFullName.get(raw) ?? this.repoPathByFullName.get(raw.toLowerCase()) ?? raw;
   }
   /**
    * TASWM-281: МОЯ ли это работа. Три исхода:
@@ -8244,20 +8424,20 @@ init_config();
 init_heartbeat();
 
 // src/logRotate.ts
-import { copyFileSync, renameSync as renameSync4, statSync as statSync4, fstatSync, truncateSync, unlinkSync as unlinkSync2, existsSync as existsSync6 } from "fs";
+import { copyFileSync, renameSync as renameSync5, statSync as statSync5, fstatSync, truncateSync, unlinkSync as unlinkSync2, existsSync as existsSync7 } from "fs";
 var realIo = {
   size: (path) => {
     try {
-      return statSync4(path).size;
+      return statSync5(path).size;
     } catch {
       return null;
     }
   },
   copy: copyFileSync,
-  rename: renameSync4,
+  rename: renameSync5,
   truncate: (path) => truncateSync(path, 0),
   unlink: unlinkSync2,
-  exists: existsSync6
+  exists: existsSync7
 };
 var realOwnerIo = {
   statFd: (fd) => {
@@ -8270,7 +8450,7 @@ var realOwnerIo = {
   },
   statPath: (path) => {
     try {
-      const s = statSync4(path);
+      const s = statSync5(path);
       return { dev: s.dev, ino: s.ino };
     } catch {
       return null;
@@ -8342,12 +8522,12 @@ async function buildRepoRegistry(paths) {
 
 // src/repoMemory.ts
 import { readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var FILE = "repos.json";
 function loadRememberedRepos(home) {
   let raw;
   try {
-    raw = readFileSync6(join7(home, FILE), "utf8");
+    raw = readFileSync6(join8(home, FILE), "utf8");
   } catch {
     return [];
   }
@@ -8362,7 +8542,7 @@ function loadRememberedRepos(home) {
 function rememberRepos(home, paths, now = () => /* @__PURE__ */ new Date()) {
   const clean = paths.filter((p) => p.trim().length > 0);
   if (clean.length === 0) return;
-  writeFileSync6(join7(home, FILE), `${JSON.stringify({ paths: clean, at: now().toISOString() }, null, 2)}
+  writeFileSync6(join8(home, FILE), `${JSON.stringify({ paths: clean, at: now().toISOString() }, null, 2)}
 `);
 }
 function pickRepoPaths(args) {
@@ -8377,12 +8557,12 @@ init_src();
 init_config();
 init_linkFailure();
 import { homedir as homedir3 } from "os";
-import { readFileSync as readFileSync9, renameSync as renameSync5, writeFileSync as writeFileSync8 } from "fs";
-import { isAbsolute, join as join10, resolve as resolve2 } from "path";
+import { readFileSync as readFileSync9, renameSync as renameSync6, writeFileSync as writeFileSync8 } from "fs";
+import { isAbsolute, join as join11, resolve as resolve2 } from "path";
 
 // src/repoScan.ts
-import { readdirSync as readdirSync5, readFileSync as readFileSync8, statSync as statSync5 } from "fs";
-import { join as join9 } from "path";
+import { readdirSync as readdirSync6, readFileSync as readFileSync8, statSync as statSync6 } from "fs";
+import { join as join10 } from "path";
 var SKIP = /* @__PURE__ */ new Set([
   "node_modules",
   "vendor",
@@ -8412,7 +8592,7 @@ function parseOriginFromGitConfig(text) {
 }
 function originOf(dir) {
   try {
-    return parseOriginFromGitConfig(readFileSync8(join9(dir, ".git", "config"), "utf8"));
+    return parseOriginFromGitConfig(readFileSync8(join10(dir, ".git", "config"), "utf8"));
   } catch {
     return null;
   }
@@ -8441,15 +8621,15 @@ function walk(dir, depth, maxDepth, found) {
   }
   let entries;
   try {
-    entries = readdirSync5(dir);
+    entries = readdirSync6(dir);
   } catch {
     return;
   }
   for (const name of entries) {
     if (name.startsWith(".") || SKIP.has(name)) continue;
-    const child = join9(dir, name);
+    const child = join10(dir, name);
     try {
-      if (!statSync5(child).isDirectory()) continue;
+      if (!statSync6(child).isDirectory()) continue;
     } catch {
       continue;
     }
@@ -8469,7 +8649,7 @@ function defaultScanRoots(home, knownPaths = []) {
     if (parent && parent !== p) add(parent);
   }
   for (const name of ["projects", "code", "src", "dev", "work", "repos", "git", "Projects", "Code", "Developer", "Documents/GitHub", "go/src"]) {
-    add(join9(home, name));
+    add(join10(home, name));
   }
   return out;
 }
@@ -8483,7 +8663,7 @@ function resolveScanRoots(raw, home = homedir3(), knownPaths = []) {
   for (const part of v.split(",")) {
     const p = part.trim();
     if (!p) continue;
-    const abs = p === "~" ? home : p.startsWith("~/") ? join10(home, p.slice(2)) : isAbsolute(p) ? p : resolve2(home, p);
+    const abs = p === "~" ? home : p.startsWith("~/") ? join11(home, p.slice(2)) : isAbsolute(p) ? p : resolve2(home, p);
     if (!out.includes(abs)) out.push(abs);
   }
   return out;
@@ -8548,6 +8728,28 @@ function describeReposFailure(kind, detail) {
 function emptyRepoMapState(roots) {
   return { clones: [], missing: [], roots: [...roots], at: null, unknown: true };
 }
+var SCAN_REASON_TEXT = {
+  "list-unknown": "\u043F\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 \u0441\u043C\u043E\u0442\u0440\u044E \u0441\u0430\u043C, \u0447\u0435\u0433\u043E \u043D\u0430 \u043C\u0430\u0448\u0438\u043D\u0435 \u043F\u0440\u0438\u0431\u0430\u0432\u0438\u043B\u043E\u0441\u044C",
+  "wanted-missing": "\u0438\u0437 \u0441\u043F\u0438\u0441\u043A\u0430 \u0440\u043E\u044F \u0447\u0435\u0433\u043E-\u0442\u043E \u043D\u0435\u0442 \u043D\u0430 \u043C\u0430\u0448\u0438\u043D\u0435",
+  "cache-expired": "\u043A\u044D\u0448 \u043A\u0430\u0440\u0442\u044B \u043F\u0440\u043E\u0442\u0443\u0445"
+};
+var REPO_SCAN_TTL_MS = 24 * 60 * 6e4;
+var UNKNOWN_LIST_SCAN_TTL_MS = 60 * 6e4;
+function isScanStale(scannedAt, ttlMs, now = Date.now()) {
+  if (!scannedAt) return true;
+  const t = stampMs(scannedAt);
+  if (!Number.isFinite(t)) return true;
+  return now - t >= ttlMs;
+}
+function decideScan(opts) {
+  if (!opts.known) {
+    const ttl = Math.min(opts.ttlMs, UNKNOWN_LIST_SCAN_TTL_MS);
+    return isScanStale(opts.scannedAt, ttl, opts.now) ? { scan: true, reason: "list-unknown" } : { scan: false, reason: null };
+  }
+  if (opts.missingWanted > 0) return { scan: true, reason: "wanted-missing" };
+  if (isScanStale(opts.scannedAt, opts.ttlMs, opts.now)) return { scan: true, reason: "cache-expired" };
+  return { scan: false, reason: null };
+}
 async function refreshRepoMap(opts) {
   const log = opts.log ?? (() => {
   });
@@ -8561,14 +8763,21 @@ async function refreshRepoMap(opts) {
     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 cache = loadRepoMapCache(opts.cachePath);
+  for (const e of cache.entries) {
     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 decision = decideScan({
+    known: !!wanted,
+    missingWanted: wantedNames.filter((n) => !clones.has(n)).length,
+    scannedAt: cache.scannedAt,
+    ttlMs: opts.scanTtlMs ?? REPO_SCAN_TTL_MS
+  });
+  let scannedAt = cache.scannedAt;
+  if (decision.scan) {
     const startedAt = Date.now();
     const scanned = scan(opts.roots, opts.maxDepth !== void 0 ? { maxDepth: opts.maxDepth } : {});
     let added = 0;
@@ -8577,9 +8786,10 @@ async function refreshRepoMap(opts) {
       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`);
-    }
+    scannedAt = stamp();
+    log(
+      `[overmind] \u043F\u0440\u043E\u0448\u0451\u043B \u043F\u043E \u043A\u0430\u0442\u0430\u043B\u043E\u0433\u0430\u043C (${SCAN_REASON_TEXT[decision.reason]}): ${added > 0 ? `\u043D\u0430\u0448\u0451\u043B \u0435\u0449\u0451 ${added}` : "\u043D\u043E\u0432\u043E\u0433\u043E \u043D\u0435 \u043D\u0430\u0448\u0451\u043B"}, \u0432\u0441\u0435\u0433\u043E \u043A\u043B\u043E\u043D\u043E\u0432 ${clones.size}, \u0437\u0430 ${Date.now() - startedAt}\u043C\u0441. \u0418\u0441\u043A\u0430\u043B \u0432: ${opts.roots.length ? opts.roots.slice(0, 6).join(", ") : "\u043D\u0438\u0433\u0434\u0435 \u2014 \u043F\u043E\u0438\u0441\u043A \u0432\u044B\u043A\u043B\u044E\u0447\u0435\u043D (SWARM_SCAN_ROOTS)"}`
+    );
   }
   const registry = [...clones.values()].map((c) => ({
     repoFullName: c.repoFullName,
@@ -8587,10 +8797,12 @@ async function refreshRepoMap(opts) {
   }));
   writeRepoMapCache(
     opts.cachePath,
-    [...clones.values()].map((c) => ({ repoFullName: c.repoFullName, path: c.path }))
+    [...clones.values()].map((c) => ({ repoFullName: c.repoFullName, path: c.path })),
+    scannedAt
   );
   if (!answer.ok) {
     log(describeReposFailure(answer.kind, answer.detail));
+    log(`[overmind] \u0438\u0442\u043E\u0433: \u043A\u043B\u043E\u043D\u043E\u0432 \u043D\u0430 \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435 \u0438\u0437\u0432\u0435\u0441\u0442\u043D\u043E ${clones.size}, \u0441\u043F\u0438\u0441\u043E\u043A \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0435\u0432 \u0440\u043E\u044F \u043D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u0435\u043D (\u0441\u043C. \u0441\u0442\u0440\u043E\u043A\u0443 \u0432\u044B\u0448\u0435)`);
     return registry;
   }
   opts.state.unknown = false;
@@ -8602,7 +8814,7 @@ async function refreshRepoMap(opts) {
     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:`);
+  log(`[overmind] ${describeMapSummary(opts.state, opts.roots)}`);
   for (const c of opts.state.clones) log(`[overmind]   ${describeClone(c)}`);
   const prefixOf = new Map(answer.repos.map((r) => [r.repoFullName, r.taskPrefix]));
   for (const name of opts.state.missing) {
@@ -8611,6 +8823,11 @@ async function refreshRepoMap(opts) {
   }
   return registry;
 }
+function describeMapSummary(state, roots) {
+  const found = state.clones.length;
+  const where = roots.length ? 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 `\u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0438 \u0440\u043E\u044F (${found + state.missing.length}): \u043D\u0430\u0439\u0434\u0435\u043D\u043E \u043D\u0430 \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435 ${found}, \u0431\u0435\u0437 \u043A\u043B\u043E\u043D\u0430 ${state.missing.length}. \u0418\u0441\u043A\u0430\u043B \u0432: ${where}`;
+}
 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` : "";
@@ -8631,40 +8848,43 @@ function repoMapRows(state) {
     ...state.missing.map((repoFullName) => ({ repoFullName, path: null, source: null, alternatives: [] }))
   ];
 }
-function readRepoMapCache(path) {
+function loadRepoMapCache(path) {
   try {
     const raw = JSON.parse(readFileSync9(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
-    );
+    if (!Array.isArray(raw?.entries)) return { scannedAt: null, entries: [] };
+    return {
+      scannedAt: typeof raw.scannedAt === "string" && raw.scannedAt ? raw.scannedAt : null,
+      entries: raw.entries.filter(
+        (e) => !!e && typeof e.repoFullName === "string" && typeof e.path === "string" && !!e.repoFullName && !!e.path
+      )
+    };
   } catch {
-    return [];
+    return { scannedAt: null, entries: [] };
   }
 }
-function writeRepoMapCache(path, entries) {
+function writeRepoMapCache(path, entries, scannedAt = stamp()) {
   try {
     const tmp = `${path}.tmp`;
-    writeFileSync8(tmp, JSON.stringify({ at: stamp(), entries }, null, 2));
-    renameSync5(tmp, path);
+    writeFileSync8(tmp, JSON.stringify({ at: stamp(), scannedAt, entries }, null, 2));
+    renameSync6(tmp, path);
   } catch {
   }
 }
 
 // src/hostIdentity.ts
 import { hostname } from "os";
-import { existsSync as existsSync7, readFileSync as readFileSync10, renameSync as renameSync6, writeFileSync as writeFileSync9 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync10, renameSync as renameSync7, writeFileSync as writeFileSync9 } from "fs";
+import { join as join12 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function hostIdentityPath(home) {
-  return join11(home, "host.json");
+  return join12(home, "host.json");
 }
 function loadHostIdentity(deps) {
-  const exists = deps.exists ?? existsSync7;
+  const exists = deps.exists ?? existsSync8;
   const readFile2 = deps.readFile ?? ((p) => readFileSync10(p, "utf8"));
   const writeFile3 = deps.writeFile ?? ((p, data) => {
     writeFileSync9(`${p}.tmp`, data);
-    renameSync6(`${p}.tmp`, p);
+    renameSync7(`${p}.tmp`, p);
   });
   const host = deps.hostname ?? hostname;
   const newId = deps.newId ?? randomUUID2;
@@ -8846,15 +9066,15 @@ function buildReliefCostCandidates(cost, t, sustainMs, build) {
 
 // src/launcher.ts
 import { spawn } from "child_process";
-import { closeSync as closeSync2, existsSync as existsSync8, mkdirSync as mkdirSync6, openSync as openSync2, readdirSync as readdirSync7 } from "fs";
+import { closeSync as closeSync2, existsSync as existsSync9, mkdirSync as mkdirSync7, openSync as openSync2, readdirSync as readdirSync8 } from "fs";
 import { createRequire } from "module";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname2, join as join13 } from "path";
+import { dirname as dirname2, join as join14 } from "path";
 import { fileURLToPath } from "url";
 
 // src/droneHome.ts
-import { lstatSync, mkdirSync as mkdirSync5, readdirSync as readdirSync6, rmSync, statSync as statSync6, symlinkSync as symlinkSync2 } from "fs";
-import { join as join12, relative, sep } from "path";
+import { lstatSync, mkdirSync as mkdirSync6, readdirSync as readdirSync7, rmSync, statSync as statSync7, symlinkSync as symlinkSync2 } from "fs";
+import { join as join13, 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);
@@ -8872,29 +9092,29 @@ function buildDroneHome(opts) {
   const { realHome, droneHome } = opts;
   const deny = opts.deny ?? droneHomeDeny();
   const platform = opts.platform ?? process.platform;
-  mkdirSync5(droneHome, { recursive: true, mode: 448 });
-  const wanted = new Set(mirroredEntries(readdirSync6(realHome), deny, platform));
+  mkdirSync6(droneHome, { recursive: true, mode: 448 });
+  const wanted = new Set(mirroredEntries(readdirSync7(realHome), deny, platform));
   const rel = relative(realHome, droneHome);
   if (rel && !rel.startsWith("..") && !rel.includes(sep)) wanted.delete(rel);
-  for (const existing of readdirSync6(droneHome)) {
+  for (const existing of readdirSync7(droneHome)) {
     if (wanted.has(existing)) continue;
-    const p = join12(droneHome, existing);
+    const p = join13(droneHome, existing);
     try {
       if (lstatSync(p).isSymbolicLink()) rmSync(p);
     } catch {
     }
   }
   for (const name of wanted) {
-    const link = join12(droneHome, name);
+    const link = join13(droneHome, name);
     try {
       lstatSync(link);
       continue;
     } catch {
     }
-    const target = join12(realHome, name);
+    const target = join13(realHome, name);
     let isDir;
     try {
-      isDir = statSync6(target).isDirectory();
+      isDir = statSync7(target).isDirectory();
     } catch {
       continue;
     }
@@ -8912,7 +9132,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, join12(realHome, ...segments)]));
+  return Object.fromEntries(REAL_PATH_ENV_PINS.map(({ env, segments }) => [env, join13(realHome, ...segments)]));
 }
 function dronePrivatePaths(realHome, swarmHome) {
   return [
@@ -9024,7 +9244,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 = join13(worktree, ".turbo", "cache");
+    env.TURBO_CACHE_DIR = join14(worktree, ".turbo", "cache");
   }
   Object.assign(env, droneTestEnv(droneCap, base3));
   for (const key of DAEMON_STATE_ENV) delete env[key];
@@ -9052,20 +9272,21 @@ var DAEMON_STATE_ENV = [
   "TASKLESS_TOKEN"
 ];
 function bundledRoleDir(kind) {
-  return join13(dirname2(fileURLToPath(import.meta.url)), "..", "roles", kind);
+  return join14(dirname2(fileURLToPath(import.meta.url)), "..", "roles", kind);
 }
 function roleDir(worktree, kind) {
-  return join13(worktree, ".claude", "roles", kind);
+  return join14(worktree, ".claude", "roles", kind);
 }
 function roleDirs(worktree, kind) {
-  return [bundledRoleDir(kind), roleDir(worktree, kind)].filter((dir) => existsSync8(dir));
+  return [bundledRoleDir(kind), roleDir(worktree, kind)].filter((dir) => existsSync9(dir));
 }
-function nextRunLogPath(runLogsDir, runId) {
-  const dir = join13(runLogsDir, String(runId));
-  mkdirSync6(dir, { recursive: true });
+function nextRunLogPath(runLogsDir, runLogKeys) {
+  const dir = runLogDirForWrite(runLogsDir, runLogKeys);
+  if (!dir) throw new Error("\u043D\u0435\u0447\u0435\u043C \u0430\u0434\u0440\u0435\u0441\u043E\u0432\u0430\u0442\u044C \u043A\u0430\u0442\u0430\u043B\u043E\u0433 run-log'\u043E\u0432: \u0443 \u043F\u0440\u043E\u0433\u043E\u043D\u0430 \u043D\u0435\u0442 \u0441\u0442\u0430\u0431\u0438\u043B\u044C\u043D\u043E\u0433\u043E \u043A\u043B\u044E\u0447\u0430 (SwarmStore.runLogKeys)");
+  mkdirSync7(dir, { recursive: true });
   let files = [];
   try {
-    files = readdirSync7(dir);
+    files = readdirSync8(dir);
   } catch {
   }
   let next = 0;
@@ -9073,11 +9294,11 @@ function nextRunLogPath(runLogsDir, runId) {
     const m = /^(\d+)\.json/.exec(f);
     if (m) next = Math.max(next, Number(m[1]) + 1);
   }
-  return join13(dir, `${next}.json`);
+  return join14(dir, `${next}.json`);
 }
-function openNextRunLog(runLogsDir, runId) {
+function openNextRunLog(runLogsDir, runLogKeys) {
   for (let attempt = 0; attempt < 50; attempt++) {
-    const path = nextRunLogPath(runLogsDir, runId);
+    const path = nextRunLogPath(runLogsDir, runLogKeys);
     let out;
     try {
       out = openSync2(path, "wx");
@@ -9093,7 +9314,7 @@ function openNextRunLog(runLogsDir, runId) {
     }
     return { out, err };
   }
-  throw new Error(`\u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043D\u0430\u0439\u0442\u0438 \u0441\u0432\u043E\u0431\u043E\u0434\u043D\u044B\u0439 run-log \u0444\u0430\u0439\u043B \u0434\u043B\u044F \u043F\u0440\u043E\u0433\u043E\u043D\u0430 #${runId} (\u0433\u043E\u043D\u043A\u0430?)`);
+  throw new Error(`\u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043D\u0430\u0439\u0442\u0438 \u0441\u0432\u043E\u0431\u043E\u0434\u043D\u044B\u0439 run-log \u0444\u0430\u0439\u043B \u043F\u0440\u043E\u0433\u043E\u043D\u0430 (${runLogKeys[0]}) \u2014 \u0433\u043E\u043D\u043A\u0430?`);
 }
 function makeLauncher(cfg) {
   return ({ worktree, run, prompt, continueSession }) => {
@@ -9156,9 +9377,9 @@ function makeLauncher(cfg) {
     }
     const realHome = cfg.droneIsolation?.realHome ?? homedir4();
     const home = cfg.droneIsolation ? buildDroneHome({ realHome, droneHome: cfg.droneIsolation.home }) : void 0;
-    if (cfg.droneIsolation && process.env.TASKLESS_TOKEN && !existsSync8(join13(cfg.droneIsolation.swarmHome, "token"))) {
+    if (cfg.droneIsolation && process.env.TASKLESS_TOKEN && !existsSync9(join14(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 ${join13(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 ${join14(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.`
       );
     }
     const executor = cfg.executor ?? resolveExecutor();
@@ -9185,7 +9406,13 @@ function makeLauncher(cfg) {
     let outFd;
     let errFd;
     if (cfg.runLogsDir) {
-      const fds = openNextRunLog(cfg.runLogsDir, run.id);
+      const logKeys = cfg.runLogKeys?.(run) ?? [];
+      if (logKeys.length === 0) {
+        throw new Error(
+          `\u043F\u0440\u043E\u0433\u043E\u043D\u0443 #${run.id} (${run.task_slug}) \u043D\u0435\u0447\u0435\u043C \u0430\u0434\u0440\u0435\u0441\u043E\u0432\u0430\u0442\u044C \u043A\u0430\u0442\u0430\u043B\u043E\u0433 run-log'\u043E\u0432: \u0443 \u0441\u0442\u043E\u0440\u0430 \u043D\u0435\u0442 \u0441\u0442\u0430\u0431\u0438\u043B\u044C\u043D\u043E\u0433\u043E \u043A\u043B\u044E\u0447\u0430 \u043F\u0440\u043E\u0433\u043E\u043D\u0430. \u0414\u0440\u043E\u043D \u043D\u0435 \u0441\u043F\u0430\u0432\u043D\u0435\u043D \u2014 \u0438\u043D\u0430\u0447\u0435 \u0435\u0433\u043E \u043B\u043E\u0433 \u043B\u0451\u0433 \u0431\u044B \u0432 \u043A\u0430\u0442\u0430\u043B\u043E\u0433, \u043A\u043E\u0442\u043E\u0440\u044B\u0439 \u0447\u0438\u0442\u0430\u0435\u0442\u0441\u044F \u043A\u0430\u043A \u0447\u0443\u0436\u043E\u0439 (TASWM-419).`
+        );
+      }
+      const fds = openNextRunLog(cfg.runLogsDir, logKeys);
       outFd = fds.out;
       errFd = fds.err ?? void 0;
       stdio = ["ignore", outFd, errFd ?? "ignore"];
@@ -9213,21 +9440,21 @@ function makeLauncher(cfg) {
 init_procCleanup();
 
 // src/cost.ts
+import { readFileSync as readFileSync11, readdirSync as readdirSync9, renameSync as renameSync8 } from "fs";
+import { join as join15 } from "path";
 init_executors();
-import { readFileSync as readFileSync11, readdirSync as readdirSync8, renameSync as renameSync7 } from "fs";
-import { join as join14 } from "path";
 var UNPROCESSED_LOG_RE = /^\d+\.json$/;
 function unprocessedLogFiles(dir) {
   try {
-    return readdirSync8(dir).filter((f) => UNPROCESSED_LOG_RE.test(f));
+    return readdirSync9(dir).filter((f) => UNPROCESSED_LOG_RE.test(f));
   } catch {
     return [];
   }
 }
 function accountRunCost(deps, run) {
-  const dir = join14(deps.runLogsDir, String(run.id));
-  const files = unprocessedLogFiles(dir);
-  if (files.length === 0) return;
+  const dir = findRunLogDir(deps.runLogsDir, deps.db.runLogKeys(run.id));
+  const files = dir ? unprocessedLogFiles(dir) : [];
+  if (!dir || files.length === 0) return;
   const model = resolveRunModel(run, deps.swarmModels?.() ?? null);
   const executor = deps.executor ?? resolveExecutor();
   let added = 0;
@@ -9236,7 +9463,7 @@ function accountRunCost(deps, run) {
   let durationMs = 0;
   const processed = [];
   for (const f of files) {
-    const full = join14(dir, f);
+    const full = join15(dir, f);
     let raw = null;
     try {
       raw = readFileSync11(full, "utf8");
@@ -9265,7 +9492,7 @@ function accountRunCost(deps, run) {
   }
   for (const full of processed) {
     try {
-      renameSync7(full, `${full}.done`);
+      renameSync8(full, `${full}.done`);
     } catch {
     }
   }
@@ -9273,20 +9500,34 @@ function accountRunCost(deps, run) {
 function makeCostAccountant(deps) {
   return (run) => accountRunCost(deps, run);
 }
+function sweepPendingRunCosts(deps) {
+  for (const run of deps.db.listRuns()) {
+    if (run.pid != null && deps.isAlive(run.pid)) continue;
+    try {
+      accountRunCost(deps, run);
+    } catch (e) {
+      console.error(`[cost] \u043F\u0440\u043E\u0433\u043E\u043D #${run.id}: \u0443\u0447\u0451\u0442 \u043D\u0435 \u0443\u0434\u0430\u043B\u0441\u044F \u2014 ${String(e)}`);
+    }
+  }
+}
+function makeCostSweeper(deps) {
+  return () => sweepPendingRunCosts(deps);
+}
 
 // src/runOutcome.ts
+import { readdirSync as readdirSync10, readFileSync as readFileSync12 } from "fs";
+import { join as join16 } from "path";
 init_executors();
-import { readdirSync as readdirSync9, readFileSync as readFileSync12 } from "fs";
-import { join as join15 } from "path";
 function endedItself(outcome) {
   return outcome === "graceful" || outcome === "budget";
 }
 var RESULT_FILE_RE = /^(\d+)\.json(\.done)?$/;
-function classifyExit(runLogsDir, runId, executor = resolveExecutor()) {
-  const dir = join15(runLogsDir, String(runId));
+function classifyExit(runLogsDir, runLogKeys, executor = resolveExecutor()) {
+  const dir = findRunLogDir(runLogsDir, runLogKeys);
+  if (!dir) return "unknown";
   let files;
   try {
-    files = readdirSync9(dir);
+    files = readdirSync10(dir);
   } catch {
     return "unknown";
   }
@@ -9300,7 +9541,7 @@ function classifyExit(runLogsDir, runId, executor = resolveExecutor()) {
   if (!latest) return "unknown";
   let raw;
   try {
-    raw = readFileSync12(join15(dir, latest.name), "utf8");
+    raw = readFileSync12(join16(dir, latest.name), "utf8");
   } catch {
     return "unknown";
   }
@@ -9308,9 +9549,9 @@ function classifyExit(runLogsDir, runId, executor = resolveExecutor()) {
   if (!result) return "crash";
   return result.stoppedByBudget ? "budget" : "graceful";
 }
-function makeExitClassifier(runLogsDir, executor) {
+function makeExitClassifier(runLogsDir, runLogKeys, executor) {
   const exec = executor ?? resolveExecutor();
-  return (run) => classifyExit(runLogsDir, run.id, exec);
+  return (run) => classifyExit(runLogsDir, runLogKeys(run.id), exec);
 }
 
 // src/orchestrator.ts
@@ -9318,20 +9559,20 @@ init_src();
 init_git();
 
 // src/deps.ts
-import { existsSync as existsSync10, readdirSync as readdirSync11, readFileSync as readFileSync13 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync12, readFileSync as readFileSync13 } from "fs";
+import { join as join19 } from "path";
 import { execa } from "execa";
 
 // src/prepareLock.ts
 import { createHash } from "crypto";
-import { closeSync as closeSync3, openSync as openSync3, rmSync as rmSync2, statSync as statSync8, writeSync } from "fs";
-import { join as join17 } from "path";
+import { closeSync as closeSync3, openSync as openSync3, rmSync as rmSync2, statSync as statSync9, writeSync } from "fs";
+import { join as join18 } from "path";
 import { tmpdir } from "os";
 var WAIT_TIMEOUT_MS = 5 * 6e4;
 var POLL_MS = 300;
 var STALE_MS = 20 * 6e4;
 function machineLockPath(key, dir = tmpdir()) {
-  return join17(dir, `swarm-prepare-${createHash("sha1").update(key).digest("hex").slice(0, 16)}.lock`);
+  return join18(dir, `swarm-prepare-${createHash("sha1").update(key).digest("hex").slice(0, 16)}.lock`);
 }
 function defaultTryCreate(path, content) {
   try {
@@ -9348,7 +9589,7 @@ function defaultTryCreate(path, content) {
 }
 function defaultAgeMs(path) {
   try {
-    return Date.now() - statSync8(path).mtimeMs;
+    return Date.now() - statSync9(path).mtimeMs;
   } catch {
     return null;
   }
@@ -9412,14 +9653,14 @@ function safeReadText(p) {
 }
 function safeListDirs(p) {
   try {
-    return readdirSync11(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    return readdirSync12(p, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
   } catch {
     return [];
   }
 }
 function safeListFiles(p) {
   try {
-    return readdirSync11(p, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name);
+    return readdirSync12(p, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name);
   } catch {
     return [];
   }
@@ -9445,21 +9686,21 @@ function overridePlan(override) {
   };
 }
 function detectPackageManager(worktree, io = {}) {
-  const exists = io.exists ?? existsSync10;
+  const exists = io.exists ?? existsSync11;
   const readText = io.readText ?? safeReadText;
-  const hasPkgJson = exists(join18(worktree, "package.json"));
+  const hasPkgJson = exists(join19(worktree, "package.json"));
   if (!hasPkgJson) {
-    if (exists(join18(worktree, "deno.json")) || exists(join18(worktree, "deno.jsonc")) || exists(join18(worktree, "deno.lock"))) return "deno";
+    if (exists(join19(worktree, "deno.json")) || exists(join19(worktree, "deno.jsonc")) || exists(join19(worktree, "deno.lock"))) return "deno";
     return null;
   }
-  const pkg = readJson(readText, join18(worktree, "package.json"));
+  const pkg = readJson(readText, join19(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(join18(worktree, "bun.lock")) || exists(join18(worktree, "bun.lockb"))) return "bun";
-  if (exists(join18(worktree, "pnpm-lock.yaml"))) return "pnpm";
-  if (exists(join18(worktree, "yarn.lock"))) return "yarn";
-  if (exists(join18(worktree, "package-lock.json"))) return "npm";
-  if (exists(join18(worktree, "deno.lock"))) return "deno";
+  if (exists(join19(worktree, "bun.lock")) || exists(join19(worktree, "bun.lockb"))) return "bun";
+  if (exists(join19(worktree, "pnpm-lock.yaml"))) return "pnpm";
+  if (exists(join19(worktree, "yarn.lock"))) return "yarn";
+  if (exists(join19(worktree, "package-lock.json"))) return "npm";
+  if (exists(join19(worktree, "deno.lock"))) return "deno";
   return "npm";
 }
 function jsInstallCommand(pm) {
@@ -9512,7 +9753,7 @@ var ECOSYSTEM_MARKERS = [
   // конфигурация — дело сборки, не подготовки
 ];
 function detectPlan(worktree, io) {
-  const exists = io.exists ?? existsSync10;
+  const exists = io.exists ?? existsSync11;
   const listFiles = io.listFiles ?? safeListFiles;
   const pm = detectPackageManager(worktree, io);
   if (pm) {
@@ -9520,7 +9761,7 @@ function detectPlan(worktree, io) {
       // node_modules на месте — установку пропускаем (быстрый путь переиспользованного worktree).
       // У deno каталога может не быть вовсе (кэш в DENO_DIR) — тогда `deno install` отработает
       // заново, но он дешёвый: тянет из того же общего кэша.
-      { label: `${pm} install`, run: jsInstallCommand(pm), skipIfExists: join18(worktree, "node_modules"), source: "detect" }
+      { label: `${pm} install`, run: jsInstallCommand(pm), skipIfExists: join19(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" });
@@ -9529,12 +9770,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(join18(worktree, f))) || marker.ext !== void 0 && listFiles(worktree).some((n) => n.endsWith(marker.ext));
+    const hit = marker.files.some((f) => exists(join19(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(join18(worktree, refine.file))) continue;
+      if (!exists(join19(worktree, refine.file))) continue;
       ecosystem = refine.ecosystem;
       command = refine.command;
       break;
@@ -9591,12 +9832,12 @@ var CI_INSTALL_PATTERNS = [
 function ciWorkflowPlan(worktree, io) {
   const readText = io.readText ?? safeReadText;
   const listFiles = io.listFiles ?? safeListFiles;
-  const dir = join18(worktree, ".github", "workflows");
+  const dir = join19(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(join18(dir, name));
+    const yaml = readText(join19(dir, name));
     if (yaml === null) continue;
     for (const raw of workflowRunLines(yaml)) {
       const line = raw.replace(/\s+/g, " ").trim();
@@ -9611,7 +9852,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(join18(worktree, "pnpm-workspace.yaml"));
+  const yaml = readText(join19(worktree, "pnpm-workspace.yaml"));
   if (yaml !== null) {
     const globs = [];
     let inPackages = false;
@@ -9631,7 +9872,7 @@ function workspaceGlobs(worktree, readText) {
     }
     if (globs.length) return globs;
   }
-  const pkg = readJson(readText, join18(worktree, "package.json"));
+  const pkg = readJson(readText, join19(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");
@@ -9642,14 +9883,14 @@ function workspaceDirs(worktree, globs, io) {
     if (glob.startsWith("!")) continue;
     const star = glob.indexOf("*");
     if (star === -1) {
-      const dir = join18(worktree, glob);
-      if (io.exists(join18(dir, "package.json"))) dirs.add(dir);
+      const dir = join19(worktree, glob);
+      if (io.exists(join19(dir, "package.json"))) dirs.add(dir);
       continue;
     }
-    const base3 = join18(worktree, glob.slice(0, star).replace(/\/$/, ""));
+    const base3 = join19(worktree, glob.slice(0, star).replace(/\/$/, ""));
     for (const name of io.listDirs(base3)) {
-      const dir = join18(base3, name);
-      if (io.exists(join18(dir, "package.json"))) dirs.add(dir);
+      const dir = join19(base3, name);
+      if (io.exists(join19(dir, "package.json"))) dirs.add(dir);
     }
   }
   return [...dirs];
@@ -9670,18 +9911,18 @@ function entryPaths(pkg) {
   return out;
 }
 function workspaceBuildTargets(worktree, io = {}) {
-  const exists = io.exists ?? existsSync10;
+  const exists = io.exists ?? existsSync11;
   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, join18(dir, "package.json"));
+    const pkg = readJson(readText, join19(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(join18(dir, e)));
+    const needsBuild = typeof scripts.build === "string" && entries.length > 0 && entries.some((e) => !exists(join19(dir, e)));
     const deps = Object.keys({ ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} });
     pkgs.push({ name: pkg.name, dir, deps, needsBuild });
   }
@@ -9709,7 +9950,7 @@ function devDatabaseUrl(worktree, io = {}) {
   const fromEnv = (io.env ?? process.env).DATABASE_URL;
   if (fromEnv && fromEnv.trim()) return fromEnv.trim();
   for (const file of [".env", ".env.example"]) {
-    const raw = readText(join18(worktree, file));
+    const raw = readText(join19(worktree, file));
     if (raw === null) continue;
     const m = /^\s*(?:export\s+)?DATABASE_URL\s*=\s*(.*)$/m.exec(raw);
     const value = (m?.[1] ?? "").trim().replace(/^['"]|['"]$/g, "");
@@ -9725,11 +9966,11 @@ function isLocalDatabase(url) {
   }
 }
 function prismaPackages(worktree, io) {
-  const exists = io.exists ?? existsSync10;
+  const exists = io.exists ?? existsSync11;
   const readText = io.readText ?? safeReadText;
   const listDirs = io.listDirs ?? safeListDirs;
   const dirs = [worktree, ...workspaceDirs(worktree, workspaceGlobs(worktree, readText), { exists, listDirs })];
-  return dirs.filter((dir) => exists(join18(dir, "prisma", "schema.prisma")) && listDirs(join18(dir, "prisma", "migrations")).length > 0);
+  return dirs.filter((dir) => exists(join19(dir, "prisma", "schema.prisma")) && listDirs(join19(dir, "prisma", "migrations")).length > 0);
 }
 function jsExecBin(pm, command) {
   switch (pm) {
@@ -9762,7 +10003,7 @@ function planPrepare(worktree, io = {}) {
   return { ...plan, commands: plan.commands.slice(0, MAX_PLAN_COMMANDS) };
 }
 async function ensureWorktreeDeps(worktree, io = {}) {
-  const exists = io.exists ?? existsSync10;
+  const exists = io.exists ?? existsSync11;
   const exec = io.exec ?? ((cmd) => runCommand(cmd, worktree));
   const approve = io.approve ?? (() => true);
   const plan = planPrepare(worktree, io);
@@ -9947,6 +10188,43 @@ function pruneDefers(episodes, live) {
   for (const key of episodes.keys()) if (!live.has(key)) episodes.delete(key);
 }
 
+// src/spawnAttempts.ts
+init_src();
+var PRE_START_ATTEMPT_LIMIT = 3;
+var PRE_START_MARK = "\u0434\u0440\u043E\u043D \u043D\u0435 \u0441\u0442\u0430\u0440\u0442\u043E\u0432\u0430\u043B";
+var SPAWN_PARK_MARK = "\u0437\u0430\u0434\u0430\u0447\u0430 \u043E\u0442\u043B\u043E\u0436\u0435\u043D\u0430 \u0440\u043E\u0435\u043C";
+function isPreStartFailure(run) {
+  return run.status === "failed" && (run.stop_reason ?? "").includes(PRE_START_MARK);
+}
+function isSpawnParked(run) {
+  return (run.stop_reason ?? "").includes(SPAWN_PARK_MARK);
+}
+var SPAWN_ATTEMPT_WINDOW_MS = 60 * 6e4;
+function preStartAttempts(runs, taskSlug, opts = {}) {
+  const windowMs = opts.windowMs ?? SPAWN_ATTEMPT_WINDOW_MS;
+  const now = opts.now ?? Date.now();
+  const own = runs.filter((r) => r.task_slug === taskSlug && r.reviews_run_id == null && r.resolves_run_id == null && r.verifies_run_id == null).sort((a, b) => b.id - a.id);
+  let n = 0;
+  for (const run of own) {
+    if (run.status === "queued" || run.status === "running") continue;
+    if (isSpawnParked(run) && run.status !== "failed") continue;
+    if (!isPreStartFailure(run)) break;
+    const at = run.created_at ? stampMs(run.created_at) : Number.NaN;
+    if (Number.isFinite(at) && now - at >= windowMs) break;
+    n += 1;
+  }
+  return n;
+}
+function unresolvedRepoReason(repo, served) {
+  const raw = repo.trim();
+  if (!raw || raw.startsWith("/") || raw.startsWith("~") || /^[a-z]:[\\/]/i.test(raw)) return null;
+  const list = served.length ? served.join(", ") : "\u043D\u0438 \u043E\u0434\u043D\u043E\u0433\u043E (\u0440\u0435\u0435\u0441\u0442\u0440 \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0435\u0432 \u043F\u0443\u0441\u0442)";
+  return `\u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0439 ${raw} \u043D\u0435 \u0440\u0430\u0437\u0432\u0435\u0440\u043D\u0443\u043B\u0441\u044F \u0432 \u043B\u043E\u043A\u0430\u043B\u044C\u043D\u044B\u0439 \u043F\u0443\u0442\u044C: \u043D\u0430 \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435 \u0435\u0433\u043E \u043A\u043B\u043E\u043D\u0430 \u043D\u0435\u0442. \u041C\u0430\u0448\u0438\u043D\u0430 \u043E\u0431\u0441\u043B\u0443\u0436\u0438\u0432\u0430\u0435\u0442: ${list}. \u041A\u043B\u043E\u043D\u0438\u0440\u0443\u0439 \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0439 \u0438 \u0434\u043E\u0431\u0430\u0432\u044C \u0435\u0433\u043E \u0432 SWARM_REPO_PATHS (\u0438\u043B\u0438 swarm start --repo <\u043F\u0443\u0442\u044C>), \u043B\u0438\u0431\u043E \u043E\u0442\u0434\u0430\u0439 \u0437\u0430\u0434\u0430\u0447\u0443 \u043C\u0430\u0448\u0438\u043D\u0435, \u0433\u0434\u0435 \u043E\u043D \u0435\u0441\u0442\u044C.`;
+}
+function parkReason(attempts, reason) {
+  return `${PRE_START_MARK} ${attempts} \u0440\u0430\u0437\u0430 \u043F\u043E\u0434\u0440\u044F\u0434 \u2014 ${SPAWN_PARK_MARK}, \u0447\u0442\u043E\u0431\u044B \u043D\u0435 \u0441\u043F\u0430\u0432\u043D\u0438\u0442\u044C \u043F\u043E \u043A\u0440\u0443\u0433\u0443. \u0427\u0435\u0433\u043E \u043D\u0435 \u0445\u0432\u0430\u0442\u0438\u043B\u043E: ${reason}`;
+}
+
 // src/overmind.ts
 init_git();
 
@@ -11204,7 +11482,7 @@ function buildAnomalyCandidates(db, now, thresholds, opts) {
   };
   const closedBeforeStart = (run) => opts.daemonStartedAt != null && sqliteMs(run.updated_at) < opts.daemonStartedAt;
   const recentFailed = allRuns.filter(
-    (r) => r.status === "failed" && ageMs(now, r.updated_at) <= thresholds.failedSpikeWindowMs && !killedByOperator(r) && !closedBeforeStart(r)
+    (r) => r.status === "failed" && ageMs(now, r.updated_at) <= thresholds.failedSpikeWindowMs && !killedByOperator(r) && !closedBeforeStart(r) && !isPreStartFailure(r)
   );
   if (recentFailed.length >= thresholds.failedSpikeCount) {
     candidates.push({
@@ -11263,6 +11541,7 @@ function buildAnomalyCandidates(db, now, thresholds, opts) {
     if (ageMs(now, run.updated_at) > thresholds.runDownWindowMs) continue;
     if (killedByOperator(run)) continue;
     if (closedBeforeStart(run)) continue;
+    if (isPreStartFailure(run)) continue;
     const repeat = isRepeatDown(run);
     candidates.push({
       key: `run_failed:${run.id}`,
@@ -11277,6 +11556,23 @@ function buildAnomalyCandidates(db, now, thresholds, opts) {
       })
     });
   }
+  for (const run of allRuns) {
+    if (run.status !== "failed" || !isSpawnParked(run)) continue;
+    if (ageMs(now, run.updated_at) > thresholds.runDownWindowMs) continue;
+    if (closedBeforeStart(run)) continue;
+    candidates.push({
+      key: `spawn_parked:${run.id}`,
+      minDurationMs: 0,
+      // серия попыток УЖЕ прошла свой PRE_START_ATTEMPT_LIMIT — отлёживать нечего
+      build: () => ({
+        runId: run.id,
+        level: "decision",
+        title: runTitle(run, "\u0440\u043E\u0439 \u043D\u0435 \u0441\u043C\u043E\u0433 \u0432\u0437\u044F\u0442\u044C\u0441\u044F \u0437\u0430 \u0437\u0430\u0434\u0430\u0447\u0443"),
+        body: `${run.task_slug}: ${run.stop_reason ?? SPAWN_PARK_MARK}`,
+        ...hrefOf(run.task_url)
+      })
+    });
+  }
   const queuedCount = allRuns.filter((r) => r.status === "queued").length;
   const activeDroneCount2 = allRuns.filter((r) => r.kind !== "hero" && ACTIVE_DRONE_STATUSES.has(r.status)).length;
   if (queuedCount > 0 && activeDroneCount2 === 0) {
@@ -11294,6 +11590,31 @@ function buildAnomalyCandidates(db, now, thresholds, opts) {
       })
     });
   }
+  const GROUP_DEP_MISSING = {
+    id: "dep_missing",
+    title: (n) => `${n} ${plural2(n, ["\u043F\u0440\u043E\u0433\u043E\u043D \u0436\u0434\u0451\u0442", "\u043F\u0440\u043E\u0433\u043E\u043D\u0430 \u0436\u0434\u0443\u0442", "\u043F\u0440\u043E\u0433\u043E\u043D\u043E\u0432 \u0436\u0434\u0443\u0442"])} \u0431\u043B\u043E\u043A\u0435\u0440\u0430, \u043A\u043E\u0442\u043E\u0440\u043E\u0433\u043E \u043D\u0435\u0442`
+  };
+  for (const run of allRuns) {
+    if (run.status !== "queued") continue;
+    if (!run.depends_on || run.depends_on.length === 0) continue;
+    const lost = db.depVerdicts(run.depends_on).filter((d) => d.outcome === "unknown");
+    if (!lost.length) continue;
+    candidates.push({
+      key: `dep_missing:${run.task_slug}`,
+      // по СЛАГУ, а не по id зеркала: тот меняется на рестарте (TAS-485)
+      minDurationMs: thresholds.depMissingMs,
+      group: GROUP_DEP_MISSING,
+      build: () => ({
+        runId: run.id,
+        // Пуш: рой сам из этого не выйдет НИКОГДА, а лечение — одно действие человека.
+        // Ровно тот случай, ради которого уровень decision и заведён.
+        level: "decision",
+        title: runTitle(run, "\u0436\u0434\u0451\u0442 \u0431\u043B\u043E\u043A\u0435\u0440\u0430, \u043A\u043E\u0442\u043E\u0440\u043E\u0433\u043E \u043D\u0435\u0442"),
+        body: `${droneOf(run)}: \u043F\u0440\u043E\u0433\u043E\u043D \u0441\u0442\u043E\u0438\u0442 \u0432 \u043E\u0447\u0435\u0440\u0435\u0434\u0438 \u0441 \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u044C\u044E ${joinCapped(lost.map((d) => d.slug))}, \u043D\u043E \u043F\u043E \u044D\u0442\u043E\u0439 \u0441\u0441\u044B\u043B\u043A\u0435 \u043D\u0435\u0442 \u043D\u0438 \u043E\u0434\u043D\u043E\u0433\u043E \u043F\u0440\u043E\u0433\u043E\u043D\u0430 \u2014 \u043D\u0438 \u043D\u0430 \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435, \u043D\u0438 \u0432 \u043F\u0440\u043E\u0434\u0435. \u0421\u0430\u043C \u043E\u043D \u043D\u0435 \u043F\u043E\u0435\u0434\u0435\u0442: \u0441\u043D\u0438\u043C\u0438 \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u044C (swarm_run_upsert{runId, dependsOn:[]}) \u0438\u043B\u0438 \u0437\u0430\u0432\u0435\u0434\u0438 \u0431\u043B\u043E\u043A\u0435\u0440 \u0437\u0430\u043D\u043E\u0432\u043E.`,
+        ...hrefOf(run.task_url)
+      })
+    });
+  }
   if (opts.gateReason && queuedCount > 0) {
     const reason = opts.gateReason;
     candidates.push({
@@ -11378,6 +11699,7 @@ function buildAnomalyCandidates(db, now, thresholds, opts) {
   for (const q of db.openQuestions()) {
     const run = runsById.get(q.run_id);
     if (!run) continue;
+    if (isTerminalStatus(run.status)) continue;
     candidates.push({
       key: `question_unanswered:${q.id}`,
       minDurationMs: thresholds.questionUnansweredMs,
@@ -11860,22 +12182,22 @@ function makeMergeGateResolver(deps) {
 }
 
 // src/envGate.ts
-import { existsSync as existsSync13 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync14 } from "fs";
+import { join as join25 } from "path";
 import { createConnection } from "net";
 import { execa as execa2 } from "execa";
 
 // src/platform.ts
-import { existsSync as existsSync12, readFileSync as readFileSync17 } from "fs";
-import { delimiter, join as join23 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync17 } from "fs";
+import { delimiter, join as join24 } from "path";
 function resolveCommandPath(name, env = process.env, platform = process.platform) {
-  if (name.includes("/") || name.includes("\\")) return existsSync12(name) ? name : null;
+  if (name.includes("/") || name.includes("\\")) return existsSync13(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 = join23(dir, name + ext);
-      if (existsSync12(candidate)) return candidate;
+      const candidate = join24(dir, name + ext);
+      if (existsSync13(candidate)) return candidate;
     }
   }
   return null;
@@ -11958,8 +12280,8 @@ var COMPOSE_MARKERS = [
   "compose.yaml"
 ];
 function detectRequirements(repo, io = {}) {
-  const exists = io.exists ?? existsSync13;
-  const marker = COMPOSE_MARKERS.find((f) => exists(join24(repo, f)));
+  const exists = io.exists ?? existsSync14;
+  const marker = COMPOSE_MARKERS.find((f) => exists(join25(repo, f)));
   return marker ? [{ kind: "docker", raw: `docker (\u0434\u0435\u0442\u0435\u043A\u0442: ${marker})` }] : [];
 }
 function resolveRequirements(repo, declared, io = {}) {
@@ -12095,8 +12417,8 @@ import { basename as basename3 } from "path";
 import { serve as serve2 } from "@hono/node-server";
 
 // src/diff.ts
-import { statSync as statSync9 } from "fs";
-import { join as join25 } from "path";
+import { statSync as statSync10 } from "fs";
+import { join as join26 } from "path";
 import { $ as $4 } from "execa";
 var MAX_FILES = 200;
 var MAX_LINES_PER_FILE = 1500;
@@ -12239,7 +12561,7 @@ async function resolveBase(wt, baseBranch) {
 }
 function mtime(path) {
   try {
-    return statSync9(path).mtimeMs;
+    return statSync10(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -12264,7 +12586,7 @@ async function collectRunDiff(worktree, opts = {}) {
       files.push(pf);
     }
   }
-  files.sort((a, b) => mtime(join25(worktree, b.path)) - mtime(join25(worktree, a.path)));
+  files.sort((a, b) => mtime(join26(worktree, b.path)) - mtime(join26(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);
@@ -12297,7 +12619,7 @@ async function changedPaths(worktree, opts = {}) {
 // package.json
 var package_default = {
   name: "@taskless-app/swarm",
-  version: "0.6.14",
+  version: "0.6.15",
   type: "module",
   description: "Local control plane for a fleet of AI coding agents (drones), coordinating through Taskless. The overmind runs the swarm.",
   keywords: [
@@ -12347,7 +12669,7 @@ var package_default = {
     execa: "^10.0.0",
     zod: "3.25.76"
   },
-  gitHead: "a3b11498dbed5db3642fe4fc83bcd2054efde055"
+  gitHead: "5bc8e0c067de58fd72b0eb434e80ad29c7a00223"
 };
 
 // src/version.ts
@@ -13980,10 +14302,10 @@ async function checkDaemonVersion(start, opts = {}) {
 
 // src/hostCommands.ts
 init_src();
-import { readFileSync as readFileSync18, renameSync as renameSync8, writeFileSync as writeFileSync13 } from "fs";
-import { join as join26 } from "path";
+import { readFileSync as readFileSync18, renameSync as renameSync9, writeFileSync as writeFileSync13 } from "fs";
+import { join as join27 } from "path";
 function hostCommandStatePath(home) {
-  return join26(home, "host-command.json");
+  return join27(home, "host-command.json");
 }
 function readState(path) {
   try {
@@ -13995,7 +14317,7 @@ function readState(path) {
 function writeState(path, state) {
   try {
     writeFileSync13(`${path}.tmp`, JSON.stringify(state));
-    renameSync8(`${path}.tmp`, path);
+    renameSync9(`${path}.tmp`, path);
   } catch {
   }
 }
@@ -14157,8 +14479,8 @@ async function doRestart(cmd, opts, note) {
 
 // src/selfUpdate.ts
 init_git();
-import { existsSync as existsSync14 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync15 } from "fs";
+import { join as join28 } from "path";
 import { $ as $5 } from "execa";
 var DAEMON_PACKAGE = "@taskless-app/swarm";
 var defaultRun = async (cmd, args, cwd) => {
@@ -14171,7 +14493,7 @@ function tail(text, max = 400) {
 }
 async function runSelfUpdate(io) {
   const run = io.run ?? defaultRun;
-  const exists = io.exists ?? existsSync14;
+  const exists = io.exists ?? existsSync15;
   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);
@@ -14200,7 +14522,7 @@ async function runSelfUpdate(io) {
     };
   }
   await io.onStep("install", "\u0441\u0442\u0430\u0432\u043B\u044E \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0438");
-  if (!exists(join27(repo, "pnpm-lock.yaml"))) {
+  if (!exists(join28(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);
@@ -14258,6 +14580,47 @@ function makeOvermindNarrator() {
   };
 }
 
+// src/orphanQuestions.ts
+init_src();
+var ORPHAN_NOTE_WINDOW_MS = DAY_MS;
+var ORPHAN_NOTE_PREFIX = "\u0412\u043E\u043F\u0440\u043E\u0441 \u043E\u0441\u0442\u0430\u043B\u0441\u044F \u0431\u0435\u0437 \u043E\u0442\u0432\u0435\u0442\u0430 \u2014 \u043F\u0440\u043E\u0433\u043E\u043D \u0437\u0430\u043A\u043E\u043D\u0447\u0438\u043B\u0441\u044F \u0440\u0430\u043D\u044C\u0448\u0435";
+function orphanWithdrawReason(status) {
+  return `\u0441\u043D\u044F\u0442 \u0430\u0432\u0442\u043E\u043C\u0430\u0442\u0438\u0447\u0435\u0441\u043A\u0438: \u043F\u0440\u043E\u0433\u043E\u043D \u0437\u0430\u0432\u0435\u0440\u0448\u0451\u043D (${status}), \u043E\u0442\u0432\u0435\u0447\u0430\u0442\u044C \u043D\u0435\u043A\u043E\u043C\u0443`;
+}
+function reapOrphanedQuestions(db, now, windowMs = ORPHAN_NOTE_WINDOW_MS) {
+  const result = { withdrawn: 0, noted: 0 };
+  let open;
+  let runsById;
+  try {
+    open = db.openQuestions();
+    if (open.length === 0) return result;
+    runsById = new Map(db.listRuns().map((r) => [r.id, r]));
+  } catch {
+    return result;
+  }
+  for (const q of open) {
+    const run = runsById.get(q.run_id);
+    if (!run) continue;
+    if (!isTerminalStatus(run.status) && run.superseded_by == null) continue;
+    try {
+      if (now - sqliteMs(run.updated_at) <= windowMs) {
+        db.addEvent(run.id, NOTE_KIND, orphanNoteText(run, q), NOTE_ACTOR);
+        result.noted++;
+      }
+      db.withdrawQuestion(q.id, orphanWithdrawReason(run.status));
+      result.withdrawn++;
+    } catch (e) {
+      console.error(`[orphan-questions] \u0432\u043E\u043F\u0440\u043E\u0441 #${q.id} \u043D\u0435 \u0441\u043D\u044F\u0442, \u043F\u043E\u0432\u0442\u043E\u0440\u044E \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0438\u043C \u0442\u0438\u043A\u043E\u043C:`, e);
+    }
+  }
+  return result;
+}
+var NOTE_KIND = "note";
+var NOTE_ACTOR = "orchestrator";
+function orphanNoteText(run, q) {
+  return `${ORPHAN_NOTE_PREFIX} (${run.status}). \u041E\u0442\u0432\u0435\u0447\u0430\u0442\u044C \u043D\u0435\u043A\u043E\u043C\u0443, \u0437\u0432\u0430\u0442\u044C \u043D\u0438\u043A\u043E\u0433\u043E \u043D\u0435 \u0431\u0443\u0434\u0435\u043C \u2014 \u0442\u0435\u043A\u0441\u0442 \u0441\u043E\u0445\u0440\u0430\u043D\u044F\u044E: \xAB${q.text}\xBB`;
+}
+
 // src/probe.ts
 init_executors();
 import { spawn as spawn2 } from "child_process";
@@ -14318,18 +14681,18 @@ async function fetchExternalStorm(url, opts = {}) {
 }
 
 // src/anomalyState.ts
-import { existsSync as existsSync15, readFileSync as readFileSync19, renameSync as renameSync9, writeFileSync as writeFileSync14 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync19, renameSync as renameSync10, writeFileSync as writeFileSync14 } from "fs";
+import { join as join29 } from "path";
 var KEY_TTL_MS = 7 * 24 * 60 * 6e4;
 var MAX_RESOLVED = 200;
 function emptyState() {
   return { since: {}, lastFiredAt: {}, fires: {}, resolved: [], stopQuiet: null };
 }
 function anomalyStatePath(home) {
-  return join28(home, "anomaly-state.json");
+  return join29(home, "anomaly-state.json");
 }
 function loadAnomalyState(home, now = Date.now(), io = {}) {
-  const exists = io.exists ?? existsSync15;
+  const exists = io.exists ?? existsSync16;
   const readFile2 = io.readFile ?? ((p) => readFileSync19(p, "utf8"));
   const path = anomalyStatePath(home);
   if (!exists(path)) return emptyState();
@@ -14361,7 +14724,7 @@ function saveAnomalyState(home, state, io = {}) {
   const path = anomalyStatePath(home);
   const writeFile3 = io.writeFile ?? ((p, data) => {
     writeFileSync14(`${p}.tmp`, data);
-    renameSync9(`${p}.tmp`, p);
+    renameSync10(`${p}.tmp`, p);
   });
   writeFile3(path, JSON.stringify(state, null, 2));
 }
@@ -14687,6 +15050,9 @@ function short(files, n = 3) {
   return files.slice(0, n).join(", ") + (files.length > n ? ` \u0438 \u0435\u0449\u0451 ${files.length - n}` : "");
 }
 var SPINE_PREDICTION_WEIGHT = 0.7;
+function spineOfPrediction(spine, predicted) {
+  return predicted.filter((p) => spine.has(p.path) && p.weight >= SPINE_PREDICTION_WEIGHT).map((p) => p.path);
+}
 function decideConflict({ model, candidate, active }) {
   if ((candidate.kind ?? "drone") !== "drone") return { kind: "clear" };
   if (!hasZoneModel(model)) return { kind: "unknown" };
@@ -14694,23 +15060,16 @@ function decideConflict({ model, candidate, active }) {
   if (!predicted.length) return { kind: "unknown" };
   if (!active.length) return { kind: "clear" };
   const spine = new Set(model.spine);
-  const candidateSpine = predicted.filter((p) => spine.has(p.path) && p.weight >= SPINE_PREDICTION_WEIGHT).map((p) => p.path);
-  if (candidateSpine.length) {
-    const blocker = active[0];
-    return {
-      kind: "wait",
-      blockedBy: blocker.run,
-      message: `\u0437\u0430\u0434\u0430\u0447\u0430 \u0442\u0440\u043E\u0433\u0430\u0435\u0442 \u043E\u0431\u0449\u0438\u0439 \u0445\u0440\u0435\u0431\u0435\u0442 (${short(candidateSpine)}) \u2014 \u0442\u0430\u043A\u0438\u0435 \u0438\u0434\u0443\u0442 \u043F\u043E\u0441\u043B\u0435\u0434\u043E\u0432\u0430\u0442\u0435\u043B\u044C\u043D\u043E \u043D\u0435\u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E \u043E\u0442 \u0437\u043E\u043D\u044B; \u0436\u0434\u0443 ${blocker.run.task_slug} (#${blocker.run.id})`
-    };
-  }
-  for (const w of active) {
-    if (!w.actual) continue;
-    const theirSpine = w.files.filter((f) => spine.has(f));
-    if (theirSpine.length && zoneForFiles(model, w.files)?.zone === SPINE_ZONE) {
+  const candidateSpine = new Set(spineOfPrediction(spine, predicted));
+  if (candidateSpine.size) {
+    for (const w of active) {
+      const theirSpine = w.actual ? w.files.filter((f) => spine.has(f)) : spineOfPrediction(spine, predictForRun(model, w.run));
+      const shared = theirSpine.filter((f) => candidateSpine.has(f));
+      if (!shared.length) continue;
       return {
         kind: "wait",
         blockedBy: w.run,
-        message: `${w.run.task_slug} (#${w.run.id}) \u043F\u0440\u044F\u043C\u043E \u0441\u0435\u0439\u0447\u0430\u0441 \u043F\u0440\u0430\u0432\u0438\u0442 \u043E\u0431\u0449\u0438\u0439 \u0445\u0440\u0435\u0431\u0435\u0442 (${short(theirSpine)}) \u2014 \u043E\u0442\u0432\u0435\u0442\u0432\u043B\u044F\u0442\u044C\u0441\u044F \u043E\u0442 \u043D\u0435\u0433\u043E \u0440\u0430\u043D\u043E, \u0436\u0434\u0443`
+        message: `\u044D\u0442\u0438 \u0434\u0432\u0435 \u0437\u0430\u0434\u0430\u0447\u0438 \u0442\u0440\u043E\u0433\u0430\u044E\u0442 \u043E\u0434\u043D\u0438 \u0444\u0430\u0439\u043B\u044B \u043E\u0431\u0449\u0435\u0433\u043E \u0445\u0440\u0435\u0431\u0442\u0430 (${short(shared)}) \u2014 \u0442\u0430\u043A\u0438\u0435 \u0438\u0434\u0443\u0442 \u043F\u043E\u0441\u043B\u0435\u0434\u043E\u0432\u0430\u0442\u0435\u043B\u044C\u043D\u043E \u043D\u0435\u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E \u043E\u0442 \u0437\u043E\u043D\u044B: \u0436\u0434\u0443 ${w.run.task_slug} (#${w.run.id})` + (w.actual ? "" : " (\u043F\u043E \u043F\u0440\u0435\u0434\u0441\u043A\u0430\u0437\u0430\u043D\u0438\u044E \u2014 \u0434\u0440\u043E\u043D \u0435\u0449\u0451 \u043D\u0435 \u043D\u0430\u0447\u0430\u043B \u043F\u0438\u0441\u0430\u0442\u044C \u043A\u043E\u0434)")
       };
     }
   }
@@ -15322,7 +15681,7 @@ ${task.description}` : `\u0417\u0430\u0434\u0430\u0447\u0430 ${run.task_slug} (\
   }
   return parts.join("\n");
 }
-var HERO_CHARTER_PATH = join29(dirname4(THIS_FILE), "..", "docs", "HERO.md");
+var HERO_CHARTER_PATH = join30(dirname4(THIS_FILE), "..", "docs", "HERO.md");
 function buildHeroPrompt(task, run, taskContext, attachmentsBlock) {
   const name = run.name || `#${run.id}`;
   const charter = readFileSync20(HERO_CHARTER_PATH, "utf8");
@@ -15622,7 +15981,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 ?? existsSync16;
+  const worktreeExists = deps.worktreeExists ?? existsSync17;
   const hasTranscript = deps.hasTranscript ?? executorHasSession;
   const wt = run.worktree_path;
   const canContinue = !!wt && worktreeExists(wt) && hasTranscript(wt);
@@ -15707,9 +16066,9 @@ function repoHasCi(deps, run) {
 function repoHasCiWorkflows(worktreePath, repo) {
   for (const base3 of [worktreePath, repo]) {
     if (!base3) continue;
-    const dir = join29(base3, ".github", "workflows");
+    const dir = join30(base3, ".github", "workflows");
     try {
-      if (readdirSync12(dir).some((f) => f.endsWith(".yml") || f.endsWith(".yaml"))) return true;
+      if (readdirSync13(dir).some((f) => f.endsWith(".yml") || f.endsWith(".yaml"))) return true;
     } catch {
     }
   }
@@ -15858,7 +16217,7 @@ async function wakeReviewerOnCiReady(deps, run, over) {
   return true;
 }
 function worktreeAndTranscriptAlive(deps, worktree) {
-  const exists = deps.worktreeExists ?? existsSync16;
+  const exists = deps.worktreeExists ?? existsSync17;
   const transcript = deps.hasTranscript ?? executorHasSession;
   return exists(worktree) && transcript(worktree);
 }
@@ -16161,6 +16520,15 @@ async function trySpawnQueuedRun(deps, run) {
       // причина одна на машину — в лог уходит одной строкой, а не по строке на прогон
     });
   }
+  const spentAttempts = preStartAttempts(deps.db.listRuns(), run.task_slug);
+  if (spentAttempts >= PRE_START_ATTEMPT_LIMIT) {
+    const why = `${PRE_START_MARK} ${spentAttempts} \u0440\u0430\u0437\u0430 \u043F\u043E\u0434\u0440\u044F\u0434 \u2014 ${SPAWN_PARK_MARK}, \u0447\u0435\u0442\u0432\u0451\u0440\u0442\u043E\u0433\u043E \u0437\u0430\u0445\u043E\u0434\u0430 \u043D\u0435 \u0434\u0435\u043B\u0430\u044E (TASWM-422)`;
+    deps.db.updateRun(run.id, { status: "stopped", stop_reason: why });
+    deps.db.addEvent(run.id, "step", why);
+    const d = noteDefer(deps.spawnDefer ??= /* @__PURE__ */ new Map(), `pre-start-exhausted:${run.task_slug}`, why, GATE_LOG_HEARTBEAT_TICKS);
+    if (d.log) console.error(`[overmind] ${run.task_slug}: ${why}${d.changed ? "" : ` \u2014 \u0435\u0449\u0451 \u0432\u0438\u0441\u0438\u0442, \u0442\u0438\u043A ${d.ticks}`}`);
+    return "closed";
+  }
   const mergedUrl = doneMergedPrForSlug(deps.db, run.task_slug) ?? (deps.mergedPrForBranch ? await deps.mergedPrForBranch(run.task_slug, run.repo || "").catch(() => null) : null);
   if (mergedUrl) {
     await closeDuplicateTaskRun(deps, run, mergedUrl);
@@ -16171,7 +16539,11 @@ async function trySpawnQueuedRun(deps, run) {
   }
   const depVerdicts = deps.db.depVerdicts(run.depends_on);
   const unmet = depVerdicts.filter((d) => !d.met);
-  if (unmet.length) return deferSpawn(deps, run, `\u0436\u0434\u0451\u0442 \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0438: ${unmet.map((d) => d.slug).join(", ")}`);
+  if (unmet.length) {
+    const lost = unmet.filter((d) => d.outcome === "unknown");
+    const why = lost.length ? `\u0436\u0434\u0451\u0442 \u0431\u043B\u043E\u043A\u0435\u0440\u0430, \u043A\u043E\u0442\u043E\u0440\u043E\u0433\u043E \u041D\u0415\u0422: ${lost.map((d) => d.slug).join(", ")} \u2014 \u043F\u043E \u044D\u0442\u043E\u0439 \u0441\u0441\u044B\u043B\u043A\u0435 \u043D\u0435\u0442 \u043D\u0438 \u043E\u0434\u043D\u043E\u0433\u043E \u043F\u0440\u043E\u0433\u043E\u043D\u0430; \u0441\u0430\u043C \u043D\u0435 \u043F\u043E\u0435\u0434\u0435\u0442, \u0441\u043D\u0438\u043C\u0438 \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u044C (swarm_run_upsert{dependsOn:[]}) \u0438\u043B\u0438 \u0437\u0430\u0432\u0435\u0434\u0438 \u0431\u043B\u043E\u043A\u0435\u0440 \u0437\u0430\u043D\u043E\u0432\u043E (TASWM-399)` : `\u0436\u0434\u0451\u0442 \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0438: ${unmet.map((d) => d.slug).join(", ")}`;
+    return deferSpawn(deps, run, why);
+  }
   if (!await envGateAllows(deps, run)) return "skipped";
   if (!await projectQuotaGateAllows(deps, run)) return "skipped";
   const prodOverride = await prodOverrideReason(deps, run, ["queued"]);
@@ -16181,6 +16553,8 @@ async function trySpawnQueuedRun(deps, run) {
   }
   noteExhaustedDeps(deps, run, depVerdicts);
   await fillSuggestedArea(deps, run);
+  const repoGap = unresolvedRepoReason(run.repo, deps.reposServed ? deps.reposServed() : []);
+  if (repoGap) return await failBeforeStart(deps, run, repoGap);
   try {
     await deps.spawn(run);
     if (deps.spawnDefer) clearDefer(deps.spawnDefer, `run:${run.id}`);
@@ -16197,10 +16571,32 @@ async function trySpawnQueuedRun(deps, run) {
       return "skipped";
     }
     if (e instanceof AreaBusyError) return deferSpawn(deps, run, e.message);
-    deps.db.updateRun(run.id, { status: "failed" });
-    deps.db.addEvent(run.id, "failed", String(e));
+    return await failBeforeStart(deps, run, String(e));
+  }
+}
+async function failBeforeStart(deps, run, reason) {
+  deps.db.updateRun(run.id, { status: "failed", stop_reason: `${PRE_START_MARK}: ${reason}` });
+  deps.db.addEvent(run.id, "failed", `${PRE_START_MARK} \u2014 ${reason}`);
+  const attempts = preStartAttempts(deps.db.listRuns(), run.task_slug);
+  if (attempts < PRE_START_ATTEMPT_LIMIT) {
+    narrate(deps, `${droneLabel(run)} \u2014 ${PRE_START_MARK} (\u043F\u043E\u043F\u044B\u0442\u043A\u0430 ${attempts} \u0438\u0437 ${PRE_START_ATTEMPT_LIMIT}): ${reason}`);
     return "failed";
   }
+  const parked = parkReason(attempts, reason);
+  deps.db.updateRun(run.id, { stop_reason: parked });
+  deps.db.addEvent(run.id, "step", parked);
+  narrate(deps, `${run.task_slug}: ${parked}`);
+  if (deps.parkTask) {
+    const ok = await deps.parkTask(run, parked).catch(() => false);
+    if (!ok) {
+      deps.db.addEvent(
+        run.id,
+        "step",
+        `${SPAWN_PARK_MARK}: \u0443\u0432\u0435\u0441\u0442\u0438 \u0437\u0430\u0434\u0430\u0447\u0443 \u0438\u0437 \u043E\u0447\u0435\u0440\u0435\u0434\u0438 \u043D\u0435 \u0432\u044B\u0448\u043B\u043E (Taskless \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D \u0438\u043B\u0438 \u0437\u0430\u0434\u0430\u0447\u0430 \u043D\u0435 \u0440\u0435\u0437\u043E\u043B\u0432\u0438\u0442\u0441\u044F) \u2014 \u0441\u043F\u0430\u0432\u043D\u0438\u0442\u044C \u0435\u0451 \u044D\u0442\u0430 \u043C\u0430\u0448\u0438\u043D\u0430 \u0432\u0441\u0451 \u0440\u0430\u0432\u043D\u043E \u043D\u0435 \u0431\u0443\u0434\u0435\u0442, \u043D\u043E \u0443\u0431\u0440\u0430\u0442\u044C \u0438\u0437 \u043E\u0447\u0435\u0440\u0435\u0434\u0438 \u043F\u0440\u0438\u0434\u0451\u0442\u0441\u044F \u0440\u0443\u043A\u0430\u043C\u0438`
+      );
+    }
+  }
+  return "failed";
 }
 async function batchSpawnQueue(deps, droneCap) {
   for (const run of orderQueue(deps.db.listRuns("queued"))) {
@@ -16222,7 +16618,7 @@ async function resumeWatchdogParked(deps, droneCap) {
   }
   if (!candidate) return;
   if (candidate.pid != null && deps.isAlive(candidate.pid)) return;
-  const worktreeExists = deps.worktreeExists ?? existsSync16;
+  const worktreeExists = deps.worktreeExists ?? existsSync17;
   const hasTranscript = deps.hasTranscript ?? executorHasSession;
   const wt = candidate.worktree_path;
   const canContinue = !!wt && worktreeExists(wt) && hasTranscript(wt);
@@ -16391,7 +16787,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 ?? existsSync16;
+    const worktreeExists = deps.worktreeExists ?? existsSync17;
     const hasTranscript = deps.hasTranscript ?? executorHasSession;
     const canContinue = !!wt && worktreeExists(wt) && hasTranscript(wt);
     const mode = canContinue ? "continue" : "fresh";
@@ -16660,7 +17056,7 @@ function buildEscalationCandidates(db) {
 }
 async function tickOnce(deps) {
   const now = deps.now ? deps.now() : Date.now();
-  const worktreeExists = deps.worktreeExists ?? existsSync16;
+  const worktreeExists = deps.worktreeExists ?? existsSync17;
   const hasTranscript = deps.hasTranscript ?? executorHasSession;
   deps.sampleHost?.();
   if (deps.rehydrate) {
@@ -16991,6 +17387,13 @@ async function tickOnce(deps) {
     liveChildPpids = null;
     logTransientSpawnError("ps (livePpids)", e);
   }
+  if (deps.sweepCost) {
+    try {
+      deps.sweepCost();
+    } catch (e) {
+      console.error("[overmind] \u0441\u0432\u0438\u043F \u0443\u0447\u0451\u0442\u0430 \u0441\u0442\u043E\u0438\u043C\u043E\u0441\u0442\u0438 \u0441\u043E\u0440\u0432\u0430\u043B\u0441\u044F:", e);
+    }
+  }
   for (const run of [...deps.db.listRuns("running"), ...deps.db.listRuns("blocked")]) {
     const alive = run.pid != null && deps.isAlive(run.pid);
     if (!alive && deps.db.takeRun && !await deps.db.takeRun(run.id)) continue;
@@ -17216,6 +17619,16 @@ async function tickOnce(deps) {
   if (deps.respawn && deps.resourcesOk && !stormActive) {
     await resurrectStormDead(deps, worktreeExists, hasTranscript, { gateOpen: deps.resourcesOk(), cap: droneCap });
   }
+  try {
+    const reaped = reapOrphanedQuestions(deps.db, now);
+    if (reaped.withdrawn > 0) {
+      console.log(
+        `[overmind] \u043E\u0441\u0438\u0440\u043E\u0442\u0435\u0432\u0448\u0438\u0435 \u0432\u043E\u043F\u0440\u043E\u0441\u044B: \u0441\u043D\u044F\u0442\u043E ${reaped.withdrawn}, \u0437\u0430\u043C\u0435\u0442\u043A\u043E\u0439 \u0432 \u043B\u0435\u043D\u0442\u0443 \u0443\u0448\u043B\u043E ${reaped.noted}`
+      );
+    }
+  } 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);
+  }
   if (deps.anomalies && !deps.control?.paused) {
     const az = deps.anomalies;
     let ready = [];
@@ -17367,7 +17780,7 @@ async function resolveConflict(deps, reviewRun) {
     model: reviewRun.model,
     review_model: reviewRun.review_model
   });
-  const wt = join29(deps.worktreesDir, basename4(repo), `${reviewRun.task_slug}-resolve-${resolver.id}`);
+  const wt = join30(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);
@@ -17424,7 +17837,7 @@ async function spawnReviewer(deps, reviewRun, files) {
     // (своей у ревьюера нет, TASWM-204), и коммент с вердиктом должен уехать именно туда.
     workspace_id: reviewRun.workspace_id
   });
-  const wt = join29(deps.worktreesDir, basename4(repo), `${reviewRun.task_slug}-review-${reviewer.id}`);
+  const wt = join30(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);
@@ -17499,7 +17912,7 @@ async function spawnVerifier(deps, verifiedRun, files) {
     // штамп цикла: фикс-итерацию проверяет свежий верификатор
     workspace_id: verifiedRun.workspace_id
   });
-  const wt = join29(deps.worktreesDir, basename4(repo), `${verifiedRun.task_slug}-verify-${verifier.id}`);
+  const wt = join30(deps.worktreesDir, basename4(repo), `${verifiedRun.task_slug}-verify-${verifier.id}`);
   try {
     await deps.git.prepareDetachedWorktree(repo, branch, wt);
     await deps.git.setWorktreeIdentity(wt, verifier.name);
@@ -17537,7 +17950,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 (!existsSync16(wt)) {
+  if (!existsSync17(wt)) {
     const branch = runToSpawn.branch || runToSpawn.task_slug;
     const source = await addWorktree(repo, wt, branch, {
       ...base3 ? { base: await remoteBaseRef(repo, base3) } : {},
@@ -17564,7 +17977,7 @@ async function respawnRun(deps, run, mode, nudge) {
   deps.db.updateRun(run.id, { status: "running", pid });
 }
 async function syncCrashedOnStartup(deps) {
-  const worktreeExists = deps.worktreeExists ?? existsSync16;
+  const worktreeExists = deps.worktreeExists ?? existsSync17;
   let orphaned = 0;
   let merged = 0;
   let requeued = 0;
@@ -17653,10 +18066,12 @@ async function makeStore(repo, worktreesDir, repoFlag) {
     roots: scanRootsList,
     maxDepth: SWARM_SCAN_DEPTH,
     cachePath: REPO_MAP_PATH,
+    // TASWM-418: кэш обязан протухать — иначе новый клон на машине не находится никогда.
+    scanTtlMs: SWARM_REPO_SCAN_TTL_MS,
     state: repoMap,
     log: (m) => console.log(m)
   });
-  const repoRegistry = await rebuildRegistry();
+  let 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(", ")}. ` + // TASWM-336: почему пусто — три РАЗНЫЕ причины, и лечатся они по-разному. Одна
@@ -17686,8 +18101,13 @@ async function makeStore(repo, worktreesDir, repoFlag) {
     // Периодическая пересборка (шаг 0a4 тика): применяем новый реестр к ЖИВОМУ клиенту —
     // и список для claim/heartbeat, и обратную карту owner/repo → путь.
     refreshRepoMap: async () => {
-      client.setRepoRegistry(await rebuildRegistry());
-    }
+      repoRegistry = await rebuildRegistry();
+      client.setRepoRegistry(repoRegistry);
+    },
+    // TASWM-422: что машина обслуживает ПРЯМО СЕЙЧАС — читается из ЖИВОГО реестра (он
+    // пересобирается тиком выше), чтобы причина «клона нет на этой машине» называла
+    // актуальный список, а не снимок на старте демона.
+    reposServed: () => repoRegistry.map((e) => e.repoFullName)
   };
 }
 var crashGuardsInstalled = false;
@@ -17707,22 +18127,22 @@ async function migrateWorktreesAtStartup() {
       legacyDir: WORKTREES_LEGACY_DIR,
       targetDir: WORKTREES_DIR,
       envOverride: process.env.SWARM_WORKTREES || "",
-      exists: (d) => existsSync16(d),
+      exists: (d) => existsSync17(d),
       isNonEmptyDir: (d) => {
         try {
-          return readdirSync12(d).length > 0;
+          return readdirSync13(d).length > 0;
         } catch {
           return false;
         }
       },
       liveDronesUnder: (d) => pidsWithCwdUnder(d).length > 0,
-      rename: (from, to) => renameSync10(from, to),
+      rename: (from, to) => renameSync11(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 existsSync16(WORKTREES_DIR) ? WORKTREES_DIR : WORKTREES_LEGACY_DIR;
+    return existsSync17(WORKTREES_DIR) ? WORKTREES_DIR : WORKTREES_LEGACY_DIR;
   }
 }
 async function reportWorkspaceAccess(tl, db) {
@@ -17742,6 +18162,14 @@ async function runDaemon(opts) {
   const daemonStart = captureDaemonStart();
   const latestRelease = fetchLatestVersion();
   const worktreesDir = await migrateWorktreesAtStartup();
+  {
+    const swept = sweepLegacyRunLogs(RUN_LOGS_DIR);
+    if (swept.moved || swept.failed) {
+      console.log(
+        `[overmind] run-logs: ${swept.moved} \u043A\u0430\u0442\u0430\u043B\u043E\u0433(\u043E\u0432) \u0441\u0442\u0430\u0440\u043E\u0439 \u0440\u0430\u0441\u043A\u043B\u0430\u0434\u043A\u0438 (\u0430\u0434\u0440\u0435\u0441\u0430\u0446\u0438\u044F \u043D\u043E\u043C\u0435\u0440\u043E\u043C \u043F\u0440\u043E\u0433\u043E\u043D\u0430) \u0443\u0431\u0440\u0430\u043D\u043E \u0432 ${swept.legacyDir}` + (swept.failed ? `, \u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043F\u0435\u0440\u0435\u043D\u0435\u0441\u0442\u0438: ${swept.failed}` : "")
+      );
+    }
+  }
   if (!opts.repo) {
     const remembered = effectiveRepoPaths("", loadRememberedRepos(SWARM_HOME))[0];
     if (remembered) opts.repo = remembered;
@@ -17752,7 +18180,8 @@ async function runDaemon(opts) {
     host,
     repoMap: repoMapState,
     refreshRepoMap: rebuildRepoMap,
-    prodMcp
+    prodMcp,
+    reposServed
   } = await makeStore(opts.repo, worktreesDir, opts.repoFlag);
   await preflightAuth();
   const outdated = outdatedLine(PACKAGE_VERSION, await latestRelease);
@@ -17798,6 +18227,8 @@ async function runDaemon(opts) {
     overmindEntry: THIS_FILE,
     dbPath: DB_PATH,
     runLogsDir: RUN_LOGS_DIR,
+    // TASWM-419: чем именуется каталог лога прогона — стабильные ключи из стора, не номер.
+    runLogKeys: (run) => db.runLogKeys(run.id),
     // Кем исполнять (TASWM-349) — настройка SWARM_EXECUTOR, один резолв на весь демон.
     executor: EXECUTOR,
     droneIsolation: DRONE_ISOLATION,
@@ -17865,6 +18296,7 @@ async function runDaemon(opts) {
           lastOwnCapacity,
           hostResourcesForProd(),
           { active: stormActive, reason: stormStartedAt ? `\u043D\u043E\u0432\u044B\u0445 \u0441\u0435\u0441\u0441\u0438\u0439 \u043D\u0435 \u043F\u043E\u0434\u043D\u0438\u043C\u0430\u044E \u0441 ${stormStartedAt} UTC` : null },
+          worktreesDir,
           // TASWM-393: ВХОД в Taskless — та же природа, что пауза и шторм: состояние
           // машины, о котором знает только она. Пульс идёт и без входа, поэтому «на
           // связи» без этого поля читалось как «возьмёт работу» (12.08 — шесть прогонов
@@ -17883,7 +18315,13 @@ async function runDaemon(opts) {
             {
               runLogsDir: RUN_LOGS_DIR,
               daemonLogPath: DAEMON_LOG_PATH,
-              localRunId: (prodRunId) => client.localRunIdForProd(prodRunId),
+              // TASWM-419: каталог лога адресуется стабильными ключами прогона, а не его
+              // локальным номером — номера переиспользуются между жизнями зеркала, и
+              // оператору приезжал хвост чужого прогона.
+              runLogKeys: (prodRunId) => {
+                const local = client.localRunIdForProd(prodRunId);
+                return local == null ? [] : db.runLogKeys(local);
+              },
               deliver: (requestId, payload) => client.deliverLog(requestId, payload)
             },
             reply.logRequests
@@ -17941,6 +18379,7 @@ async function runDaemon(opts) {
         questionUnansweredMs: SWARM_ANOMALY_QUESTION_UNANSWERED_MS,
         outboxStuckMs: SWARM_ANOMALY_OUTBOX_STUCK_MS,
         resourceGateStallMs: SWARM_ANOMALY_RESOURCE_GATE_STALL_MS,
+        depMissingMs: SWARM_ANOMALY_DEP_MISSING_MS,
         runDownWindowMs: SWARM_ANOMALY_RUN_DOWN_WINDOW_MS
       },
       autoReviewEnabled: SWARM_AUTO_REVIEW,
@@ -18200,6 +18639,30 @@ async function runDaemon(opts) {
       taskClosed: (slug, ws) => tl.forWorkspace(ws).getTask(slug).then((t) => t ? isClosingTaskCategory(t.statusCategory) : null)
     } : {},
     finishTask: (slug, ws) => tlFor(ws)?.finishTask(slug) ?? Promise.resolve(),
+    ...reposServed ? { reposServed } : {},
+    // TASWM-422: ОТЛОЖИТЬ задачу, по которой рой трижды не сумел поднять дрона. Механика —
+    // ровно та же, что у return_task дрона (TASWM-412): `claimableTaskWhere` (api) требует
+    // категорию unstarted, и start_task её ломает — задача перестаёт быть claimable, то есть
+    // авто-интейк больше не берёт её раз в минуту. Успех проверяем ФАКТОМ (перечитываем
+    // задачу), а не кодом возврата: клиент глушит отказ сервера внутрь (safeCall), и по
+    // возврату «отложил» было бы неотличимо от «сказал, но не доехало» — то самое молчание,
+    // из-за которого 17.08 круг и крутился.
+    parkTask: async (run, reason) => {
+      const client = tlFor(run.workspace_id);
+      if (!client) return false;
+      await client.addComment(
+        run.task_slug,
+        `${reason}
+
+\u0417\u0430\u0434\u0430\u0447\u0430 \u0441\u043D\u044F\u0442\u0430 \u0441 \u043E\u0447\u0435\u0440\u0435\u0434\u0438 \u0440\u043E\u044F \u2014 \u043F\u043E\u043A\u0430 \u043F\u0440\u0438\u0447\u0438\u043D\u0430 \u043D\u0435 \u0443\u0441\u0442\u0440\u0430\u043D\u0435\u043D\u0430, \u0431\u0440\u0430\u0442\u044C \u0435\u0451 \u0441\u043D\u043E\u0432\u0430 \u0441\u043C\u044B\u0441\u043B\u0430 \u043D\u0435\u0442. \u0420\u0430\u0437\u0431\u0435\u0440\u0438\u0441\u044C \u0438 \u0432\u0435\u0440\u043D\u0438 \u0432 \u0431\u044D\u043A\u043B\u043E\u0433.`,
+        { swarmKind: "report", swarmDroneName: run.name }
+      ).catch(() => {
+      });
+      await client.startTask(run.task_slug).catch(() => {
+      });
+      const after = await client.getTask(run.task_slug).catch(() => null);
+      return after != null && after.statusCategory !== "unstarted";
+    },
     // TASWM-272: отчёт/вердикт-компенсация при усыновлении мёртвого дрона — реальный
     // TasklessClient.addComment + gh/git хелперы. Без tl (нет токена) ключи не задаём —
     // postAdoptionReport/postScrapedVerdictReport становятся no-op, как раньше.
@@ -18221,9 +18684,12 @@ async function runDaemon(opts) {
     // TASWM-364: swarmModels — ТОТ ЖЕ снимок, что уехал в launcher: цена токенов считается
     // по модели, на которой прогон реально работал.
     accountCost: makeCostAccountant({ runLogsDir: RUN_LOGS_DIR, db, executor: EXECUTOR, swarmModels: () => lastSwarmModels }),
+    // TASWM-413: тот же аккаунтант, но поводом служит завершённый ЗАПУСК, а не смерть
+    // прогона в running — иначе сданный через done() прогон не получает цену никогда.
+    sweepCost: makeCostSweeper({ runLogsDir: RUN_LOGS_DIR, db, executor: EXECUTOR, swarmModels: () => lastSwarmModels, isAlive: pidAlive }),
     // Классификация выхода прогона (TASWM-229): result-файл того же RUN_LOGS_DIR — «вышел сам»
     // (graceful) vs «убит на полпути» (crash). Тот же каталог, что читает accountCost.
-    exitOutcome: makeExitClassifier(RUN_LOGS_DIR, EXECUTOR),
+    exitOutcome: makeExitClassifier(RUN_LOGS_DIR, (runId) => db.runLogKeys(runId), EXECUTOR),
     // Живой child-процесс (TASWM-89): долгая Bash-команда (тесты/сборка) — не «завис».
     livePpids,
     // Погасить дрона (SIGTERM) — reap внешне-остановленных прогонов (kill из дашборда:
@@ -18370,7 +18836,7 @@ async function runDaemon(opts) {
       mode,
       nudge
     ),
-    worktreeExists: (p) => existsSync16(p),
+    worktreeExists: (p) => existsSync17(p),
     hasTranscript: executorHasSession,
     // CI-осведомлённость review-PR (TASWM-102): реальный `gh pr checks`/`gh run view --log-failed`
     // (gh.ts) — решение (будить ли дрона) и гейты живут в tickOnce/handleCiRed. failureSummary