@taskless-app/swarm 0.6.23 → 0.6.25

package/dist/overmind.js

@@ -525,6 +525,56 @@ var init_mergeQueue = __esm({
   }
 });
 
+// ../swarm-core/src/prRef.ts
+function prNumberOf(ref) {
+  const s = (ref || "").trim();
+  if (!s) return null;
+  const url = s.match(/\/pull\/(\d+)/);
+  if (url) return Number(url[1]);
+  const bare = s.match(/^#?(\d+)$/);
+  return bare ? Number(bare[1]) : null;
+}
+function repoKeyOf(raw) {
+  const s = (raw ?? "").trim().replace(/\/+$/, "").replace(/\.git$/i, "");
+  if (!s) return null;
+  const url = s.match(/github\.com[:/]([^/\s]+)\/([^/\s]+?)(?:\/(?:pull|tree|compare|commit|issues)\/.*)?$/i);
+  if (url) return `${url[1]}/${url[2]}`.toLowerCase();
+  const pair = s.match(/^([\w.-]+)\/([\w.-]+)$/);
+  return pair ? `${pair[1]}/${pair[2]}`.toLowerCase() : null;
+}
+function newest(rows) {
+  let best = null;
+  for (const r of rows) if (!best || r.order > best.order) best = r;
+  return best;
+}
+function pick(rows) {
+  return newest(rows.filter((r) => r.author)) ?? newest(rows);
+}
+function pickRunForPr(rows, ref, ctxRepo) {
+  const num = prNumberOf(ref);
+  if (num == null) return null;
+  const target = repoKeyOf(ref) ?? repoKeyOf(ctxRepo);
+  const hits = rows.filter((r) => r.prUrl && prNumberOf(r.prUrl) === num);
+  if (hits.length === 0) return null;
+  if (target) {
+    const mine = hits.filter((r) => keyOf(r) === target);
+    const blind = hits.filter((r) => keyOf(r) == null);
+    return pick(mine.length ? mine : blind);
+  }
+  const keys = new Set(hits.map((r) => keyOf(r) ?? ""));
+  if (keys.size === 1) return pick(hits);
+  const risky = hits.filter((r) => r.reviewVerdict !== "approve");
+  return pick(risky.length ? risky : hits);
+}
+function keyOf(r) {
+  return repoKeyOf(r.prUrl) ?? repoKeyOf(r.repoKey);
+}
+var init_prRef = __esm({
+  "../swarm-core/src/prRef.ts"() {
+    "use strict";
+  }
+});
+
 // ../swarm-core/src/modelPolicy.ts
 function findProvider(id) {
   const key = typeof id === "string" ? id.trim().toLowerCase() : "";
@@ -1632,6 +1682,7 @@ var init_src = __esm({
     init_reviewPhase();
     init_mergeGate();
     init_mergeQueue();
+    init_prRef();
     init_verifyVerdict();
     init_modelPolicy();
     init_status();
@@ -1784,6 +1835,43 @@ var init_swarmFiles = __esm({
   }
 });
 
+// src/mergeGateHook.ts
+import { chmodSync, copyFileSync, existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+function packagedHookPath() {
+  return join2(dirname(fileURLToPath(import.meta.url)), "..", "hooks", HOOK_FILE);
+}
+function wiredCommands(settings) {
+  const blocks = settings?.hooks?.PreToolUse;
+  if (!Array.isArray(blocks)) return [];
+  return blocks.flatMap((b) => Array.isArray(b?.hooks) ? b.hooks : []).flatMap((h) => isOurHook(h?.command) ? [h.command] : []);
+}
+function readSettings(path) {
+  if (!existsSync3(path)) return void 0;
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function droneMergeGateHookPath(worktree, packaged = packagedHookPath()) {
+  if (!existsSync3(packaged)) return null;
+  const projectSettings = readSettings(join2(worktree, ".claude", "settings.json"));
+  if (projectSettings && wiredCommands(projectSettings).length > 0) return null;
+  return packaged;
+}
+var HOOK_FILE, isOurHook;
+var init_mergeGateHook = __esm({
+  "src/mergeGateHook.ts"() {
+    "use strict";
+    HOOK_FILE = "pre-merge-gate.sh";
+    isOurHook = (command) => typeof command === "string" && command.trim().endsWith(HOOK_FILE);
+  }
+});
+
 // src/pricing.ts
 function costFromUsage(usage, model, table = MODEL_PRICING) {
   const entry = findModelPricing(model, table);
@@ -1872,9 +1960,9 @@ var init_claudeResult = __esm({
 });
 
 // src/executors/claudeCode.ts
-import { readdirSync as readdirSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
-import { homedir } from "os";
-import { join as join2 } from "path";
+import { readdirSync as readdirSync2, statSync, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
 function claudeArgs(cfgPath, prompt, continueSession = false, model, pluginDirs = [], settings, maxBudgetUsd, effort) {
   const pluginFlags = pluginDirs.flatMap((dir) => ["--plugin-dir", dir]);
   const budgetFlags = typeof maxBudgetUsd === "number" && maxBudgetUsd > 0 ? ["--max-budget-usd", String(maxBudgetUsd)] : [];
@@ -1900,20 +1988,23 @@ function droneDenyRules(paths) {
   const abs = (p) => `//${p.replace(/^\/+/, "")}`;
   return paths.flatMap((p) => [`Read(${abs(p)})`, `Edit(${abs(p)})`]);
 }
-function droneSettingsJson(paths) {
-  return JSON.stringify({ permissions: { deny: droneDenyRules(paths) } });
+function droneSettingsJson(paths, mergeGateHook = null) {
+  const settings = {};
+  if (paths.length > 0) settings.permissions = { deny: droneDenyRules(paths) };
+  if (mergeGateHook) settings.hooks = { PreToolUse: [{ matcher: "Bash", hooks: [{ type: "command", command: mergeGateHook }] }] };
+  return JSON.stringify(settings);
 }
 function transcriptDir(worktree, projectsDir) {
-  return join2(projectsDir, worktree.replace(/[/.]/g, "-"));
+  return join3(projectsDir, worktree.replace(/[/.]/g, "-"));
 }
-function sessionTranscriptExists(worktree, projectsDir = join2(homedir(), ".claude", "projects")) {
+function sessionTranscriptExists(worktree, projectsDir = join3(homedir2(), ".claude", "projects")) {
   try {
     return readdirSync2(transcriptDir(worktree, projectsDir)).some((f) => f.endsWith(".jsonl"));
   } catch {
     return false;
   }
 }
-function transcriptMtimeMs(worktree, projectsDir = join2(homedir(), ".claude", "projects")) {
+function transcriptMtimeMs(worktree, projectsDir = join3(homedir2(), ".claude", "projects")) {
   const dir = transcriptDir(worktree, projectsDir);
   let files;
   try {
@@ -1925,7 +2016,7 @@ function transcriptMtimeMs(worktree, projectsDir = join2(homedir(), ".claude", "
   for (const f of files) {
     if (!f.endsWith(".jsonl")) continue;
     try {
-      const mtime2 = statSync(join2(dir, f)).mtimeMs;
+      const mtime2 = statSync(join3(dir, f)).mtimeMs;
       if (latest === null || mtime2 > latest) latest = mtime2;
     } catch {
     }
@@ -1938,8 +2029,8 @@ function writeMcpConfig(spec) {
       [spec.mcp.name]: { command: spec.mcp.command, args: spec.mcp.args, env: spec.mcp.env }
     }
   };
-  const path = join2(spec.worktree, MCP_CONFIG_FILE);
-  writeFileSync2(path, JSON.stringify(cfg, null, 2));
+  const path = join3(spec.worktree, MCP_CONFIG_FILE);
+  writeFileSync3(path, JSON.stringify(cfg, null, 2));
   return path;
 }
 function abortField(abort) {
@@ -1951,6 +2042,7 @@ var init_claudeCode = __esm({
     "use strict";
     init_claudeBin();
     init_swarmFiles();
+    init_mergeGateHook();
     init_claudeResult();
     ISOLATION_FLAGS = ["--setting-sources", "project", "--strict-mcp-config"];
     MCP_CONFIG_FILE = SWARM_MCP_CONFIG_FILE;
@@ -1964,7 +2056,8 @@ var init_claudeCode = __esm({
       // проброс колбэком), и `this` тогда уедет в undefined.
       plan: (spec) => {
         const cfgPath = writeMcpConfig(spec);
-        const settings = spec.denyPaths.length > 0 ? droneSettingsJson(spec.denyPaths) : void 0;
+        const hook = droneMergeGateHookPath(spec.worktree);
+        const settings = spec.denyPaths.length > 0 || hook ? droneSettingsJson(spec.denyPaths, hook) : void 0;
         return {
           bin: resolveClaudeBin(),
           args: claudeArgs(cfgPath, spec.prompt, spec.continueSession, spec.model, spec.skillDirs, settings, spec.maxBudgetUsd, spec.effort)
@@ -2006,35 +2099,35 @@ var init_claudeCode = __esm({
 });
 
 // src/swarmHome.ts
-import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
-import { mkdirSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+import { mkdirSync as mkdirSync2 } from "fs";
 var SWARM_HOME;
 var init_swarmHome = __esm({
   "src/swarmHome.ts"() {
     "use strict";
-    SWARM_HOME = process.env.SWARM_HOME || join3(homedir2(), ".taskless-swarm");
-    mkdirSync(SWARM_HOME, { recursive: true });
+    SWARM_HOME = process.env.SWARM_HOME || join4(homedir3(), ".taskless-swarm");
+    mkdirSync2(SWARM_HOME, { recursive: true });
   }
 });
 
 // src/executors/codex.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync3, statSync as statSync2, symlinkSync } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync3, statSync as statSync2, symlinkSync } from "fs";
+import { join as join5 } from "path";
 function resolveCodexBin(env = process.env) {
   return (env.SWARM_CODEX_BIN ?? "").trim() || "codex";
 }
 function codexHomePath(worktree, swarmHome = SWARM_HOME) {
-  return join4(swarmHome, "executor-state", "codex", worktree.replace(/[/.]/g, "-"));
+  return join5(swarmHome, "executor-state", "codex", worktree.replace(/[/.]/g, "-"));
 }
 function ensureCodexHome(worktree, realHome, env = process.env, swarmHome = SWARM_HOME) {
   const home = codexHomePath(worktree, swarmHome);
-  mkdirSync2(home, { recursive: true });
-  const real = (env.CODEX_HOME ?? "").trim() || join4(realHome, ".codex");
+  mkdirSync3(home, { recursive: true });
+  const real = (env.CODEX_HOME ?? "").trim() || join5(realHome, ".codex");
   for (const file of ["auth.json", "config.toml"]) {
-    const target = join4(real, file);
-    const link = join4(home, file);
-    if (!existsSync3(target) || existsSync3(link)) continue;
+    const target = join5(real, file);
+    const link = join5(home, file);
+    if (!existsSync4(target) || existsSync4(link)) continue;
     try {
       symlinkSync(target, link);
     } catch {
@@ -2098,7 +2191,7 @@ function newestRolloutMtime(dir, depth = 4) {
   }
   let latest = null;
   for (const name of entries) {
-    const full = join4(dir, name);
+    const full = join5(dir, name);
     let st;
     try {
       st = statSync2(full);
@@ -2172,8 +2265,8 @@ ${notice}` : spec.prompt;
         return est.warning ? { costUsd: est.costUsd, warning: est.warning } : { costUsd: est.costUsd };
       },
       session: {
-        exists: (worktree) => newestRolloutMtime(join4(codexHomePath(worktree), "sessions")) !== null,
-        mtimeMs: (worktree) => newestRolloutMtime(join4(codexHomePath(worktree), "sessions"))
+        exists: (worktree) => newestRolloutMtime(join5(codexHomePath(worktree), "sessions")) !== null,
+        mtimeMs: (worktree) => newestRolloutMtime(join5(codexHomePath(worktree), "sessions"))
       },
       probe: {
         // Тот же принцип, что у claude: дешёвый реальный прогон — он проверяет и auth, и живость
@@ -2298,6 +2391,7 @@ __export(config_exports, {
   SWARM_WORKTREE_REAP_INTERVAL_MS: () => SWARM_WORKTREE_REAP_INTERVAL_MS,
   TASKLESS_API: () => TASKLESS_API,
   TASKLESS_MCP_PATH: () => TASKLESS_MCP_PATH,
+  TASKLESS_REST_PATH: () => TASKLESS_REST_PATH,
   TASKLESS_TASK_URL_BASE: () => TASKLESS_TASK_URL_BASE,
   TASKLESS_TOKEN: () => TASKLESS_TOKEN,
   TASKLESS_WORKSPACE: () => TASKLESS_WORKSPACE,
@@ -2309,14 +2403,16 @@ __export(config_exports, {
   WORKTREES_NOINDEX_DIR: () => WORKTREES_NOINDEX_DIR,
   droneWorktreePath: () => droneWorktreePath,
   droneWorktreeRoot: () => droneWorktreeRoot,
+  effectiveRepoOf: () => effectiveRepoOf,
   mcpEndpoint: () => mcpEndpoint,
   migrateWorktreesToNoindex: () => migrateWorktreesToNoindex,
   normalizeRepo: () => normalizeRepo,
   resolveEffectiveWorktreesDir: () => resolveEffectiveWorktreesDir,
+  restEndpoint: () => restEndpoint,
   reviewCutoffAt: () => reviewCutoffAt
 });
-import { basename, join as join5, resolve } from "path";
-import { readFileSync as readFileSync2, realpathSync, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "fs";
+import { basename, join as join6, resolve } from "path";
+import { readFileSync as readFileSync3, realpathSync, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "fs";
 function normalizeRepo(repo) {
   const r = (repo ?? "").trim();
   if (!r) return "";
@@ -2326,11 +2422,14 @@ function normalizeRepo(repo) {
     return resolve(r);
   }
 }
+function effectiveRepoOf(repo, fallback) {
+  return normalizeRepo(repo || fallback || "");
+}
 function droneWorktreePath(worktreesDir, repo, slug) {
-  return join5(droneWorktreeRoot(worktreesDir, repo), slug);
+  return join6(droneWorktreeRoot(worktreesDir, repo), slug);
 }
 function droneWorktreeRoot(worktreesDir, repo) {
-  return join5(worktreesDir, basename(normalizeRepo(repo)));
+  return join6(worktreesDir, basename(normalizeRepo(repo)));
 }
 function resolveEffectiveWorktreesDir(deps) {
   if (deps.envOverride) return deps.envOverride;
@@ -2365,6 +2464,12 @@ function envNum(name, def) {
   const n = Number(raw);
   return Number.isFinite(n) && n >= 0 ? n : def;
 }
+function restEndpoint(api, route, prefix = TASKLESS_REST_PATH) {
+  const base3 = api.replace(/\/$/, "");
+  const p = prefix === "/" ? "" : prefix.startsWith("/") ? prefix.replace(/\/$/, "") : `/${prefix.replace(/\/$/, "")}`;
+  const r = route.startsWith("/") ? route : `/${route}`;
+  return `${base3}${p}${r}`;
+}
 function mcpEndpoint(api, path = TASKLESS_MCP_PATH) {
   const base3 = api.replace(/\/$/, "");
   const p = path.startsWith("/") ? path : `/${path}`;
@@ -2372,27 +2477,27 @@ function mcpEndpoint(api, path = TASKLESS_MCP_PATH) {
 }
 function tokenFromFile() {
   try {
-    return readFileSync2(join5(SWARM_HOME, "token"), "utf8").trim();
+    return readFileSync3(join6(SWARM_HOME, "token"), "utf8").trim();
   } catch {
     return "";
   }
 }
 function reviewCutoffAt() {
   try {
-    const raw = JSON.parse(readFileSync2(REVIEW_CUTOFF_PATH, "utf8"));
+    const raw = JSON.parse(readFileSync3(REVIEW_CUTOFF_PATH, "utf8"));
     if (raw.at) return raw.at;
   } catch {
   }
   const at = stamp();
   try {
     const tmp = `${REVIEW_CUTOFF_PATH}.tmp`;
-    writeFileSync3(tmp, JSON.stringify({ at }));
+    writeFileSync4(tmp, JSON.stringify({ at }));
     renameSync2(tmp, REVIEW_CUTOFF_PATH);
   } catch {
   }
   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, SWARM_WORKTREE_REAP_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, SWARM_MERGE_QUEUE, 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 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, SWARM_WORKTREE_REAP_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_REST_PATH, TASKLESS_TOKEN, TASKLESS_WORKSPACE, TASKLESS_WORKSPACE_SLUG, TASKLESS_TASK_URL_BASE, SWARM_VERIFY, SWARM_AUTO_REVIEW, SWARM_AUTO_VERIFY, SWARM_MERGE_QUEUE, 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";
@@ -2400,22 +2505,22 @@ var init_config = __esm({
     init_executors();
     init_swarmHome();
     init_swarmHome();
-    DB_PATH = process.env.SWARM_DB || join5(SWARM_HOME, "swarm.db");
+    DB_PATH = process.env.SWARM_DB || join6(SWARM_HOME, "swarm.db");
     EXECUTOR = resolveExecutor(process.env.SWARM_EXECUTOR);
-    DRONE_HOME = process.env.SWARM_DRONE_HOME || join5(SWARM_HOME, "drone-home");
+    DRONE_HOME = process.env.SWARM_DRONE_HOME || join6(SWARM_HOME, "drone-home");
     DRONE_HOME_ISOLATION = process.env.SWARM_DRONE_ISOLATE_HOME !== "0" && process.platform !== "win32";
     DRONE_ISOLATION = DRONE_HOME_ISOLATION ? { home: DRONE_HOME, swarmHome: SWARM_HOME } : void 0;
-    WORKTREES_NOINDEX_DIR = join5(SWARM_HOME, "worktrees.noindex");
-    WORKTREES_LEGACY_DIR = join5(SWARM_HOME, "worktrees");
+    WORKTREES_NOINDEX_DIR = join6(SWARM_HOME, "worktrees.noindex");
+    WORKTREES_LEGACY_DIR = join6(SWARM_HOME, "worktrees");
     WORKTREES_DIR = process.env.SWARM_WORKTREES || WORKTREES_NOINDEX_DIR;
-    RUN_LOGS_DIR = process.env.SWARM_RUN_LOGS || join5(SWARM_HOME, "run-logs");
-    DAEMON_LOG_PATH = process.env.SWARM_DAEMON_LOG || join5(SWARM_HOME, "overmind.log");
+    RUN_LOGS_DIR = process.env.SWARM_RUN_LOGS || join6(SWARM_HOME, "run-logs");
+    DAEMON_LOG_PATH = process.env.SWARM_DAEMON_LOG || join6(SWARM_HOME, "overmind.log");
     DAEMON_LOG_MAX_BYTES = envNum("SWARM_DAEMON_LOG_MAX_BYTES", 16 * 1024 * 1024);
     DAEMON_LOG_KEEP = envNum("SWARM_DAEMON_LOG_KEEP", 2);
     DAEMON_LOG_CHECK_MS = envNum("SWARM_DAEMON_LOG_CHECK_MS", 6e4);
     DIST_BUILD = true;
     SWARM_BACKEND = process.env.SWARM_BACKEND === "client" ? "client" : process.env.SWARM_BACKEND === "sqlite" ? "sqlite" : DIST_BUILD ? "client" : "sqlite";
-    SWARM_OUTBOX = process.env.SWARM_OUTBOX || join5(SWARM_HOME, "outbox.jsonl");
+    SWARM_OUTBOX = process.env.SWARM_OUTBOX || join6(SWARM_HOME, "outbox.jsonl");
     SWARM_MAX_IN_FLIGHT = Math.trunc(envNum("SWARM_MAX_IN_FLIGHT", 3));
     SWARM_CLAIM_INTERVAL_MS = envNum("SWARM_CLAIM_INTERVAL_MS", 6e4);
     SWARM_MAX_LOAD_FACTOR = envNum("SWARM_MAX_LOAD_FACTOR", 0.9);
@@ -2445,20 +2550,21 @@ var init_config = __esm({
     DRONE_CHANNEL_ENABLED = process.env.SWARM_DRONE_CHANNEL !== "0";
     DRONE_CHANNEL_PORT = Number(process.env.SWARM_DRONE_CHANNEL_PORT) || 7421;
     DRONE_CHANNEL_URL = process.env.SWARM_DRONE_CHANNEL_URL || `http://127.0.0.1:${DRONE_CHANNEL_PORT}`;
-    DRONE_CHANNEL_SECRET_PATH = process.env.SWARM_DRONE_CHANNEL_SECRET || join5(SWARM_HOME, "drone-channel.key");
+    DRONE_CHANNEL_SECRET_PATH = process.env.SWARM_DRONE_CHANNEL_SECRET || join6(SWARM_HOME, "drone-channel.key");
     DRONE_CHANNEL_GRACE_MS = envNum("SWARM_DRONE_CHANNEL_GRACE_MS", 12e4);
-    HEARTBEAT_PATH = process.env.SWARM_HEARTBEAT || join5(SWARM_HOME, "overmind.heartbeat");
+    HEARTBEAT_PATH = process.env.SWARM_HEARTBEAT || join6(SWARM_HOME, "overmind.heartbeat");
     HEARTBEAT_STALE_MS = Number(process.env.SWARM_HEARTBEAT_STALE_MS) || 3e4;
     SWARM_REPO = process.env.SWARM_REPO || "";
     SWARM_SCAN_DEPTH = Number(process.env.SWARM_SCAN_DEPTH) || 3;
     SWARM_REPO_PATHS = (process.env.SWARM_REPOS || SWARM_REPO).split(",").map((s) => s.trim()).filter(Boolean);
     SWARM_SCAN_ROOTS_RAW = process.env.SWARM_SCAN_ROOTS || "";
-    REPO_MAP_PATH = process.env.SWARM_REPO_MAP || join5(SWARM_HOME, "repo-map.json");
+    REPO_MAP_PATH = process.env.SWARM_REPO_MAP || join6(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";
+    TASKLESS_REST_PATH = process.env.TASKLESS_REST_PATH || "/api";
     TASKLESS_TOKEN = process.env.TASKLESS_TOKEN || tokenFromFile();
     TASKLESS_WORKSPACE = process.env.TASKLESS_WORKSPACE || "";
     TASKLESS_WORKSPACE_SLUG = process.env.TASKLESS_WORKSPACE_SLUG || "";
@@ -2467,7 +2573,7 @@ var init_config = __esm({
     SWARM_AUTO_REVIEW = process.env.SWARM_AUTO_REVIEW !== "0";
     SWARM_AUTO_VERIFY = process.env.SWARM_AUTO_VERIFY !== "0";
     SWARM_MERGE_QUEUE = process.env.SWARM_MERGE_QUEUE !== "0";
-    REVIEW_CUTOFF_PATH = process.env.SWARM_REVIEW_CUTOFF || join5(SWARM_HOME, "review-cutoff.json");
+    REVIEW_CUTOFF_PATH = process.env.SWARM_REVIEW_CUTOFF || join6(SWARM_HOME, "review-cutoff.json");
     SWARM_REVIEW_CAP = Math.trunc(envNum("SWARM_REVIEW_CAP", 1));
     SWARM_STORM_URL = process.env.SWARM_STORM_URL || "";
     WEB_PORT = Number(process.env.SWARM_WEB_PORT) || 7420;
@@ -2507,7 +2613,7 @@ var init_quietExec = __esm({
 
 // src/resources.ts
 import os from "os";
-import { readFileSync as readFileSync3, statfsSync } from "fs";
+import { readFileSync as readFileSync4, statfsSync } from "fs";
 function isTransientResourceError(e) {
   const code = e?.code;
   return code === "ENFILE" || code === "EMFILE" || code === "EAGAIN";
@@ -2565,7 +2671,7 @@ function fileDescriptorLoadRatio() {
   }
   if (process.platform === "linux") {
     try {
-      const [allocated, , max] = readFileSync3("/proc/sys/fs/file-nr", "utf8").trim().split(/\s+/).map(Number);
+      const [allocated, , max] = readFileSync4("/proc/sys/fs/file-nr", "utf8").trim().split(/\s+/).map(Number);
       if (Number.isFinite(allocated ?? NaN) && Number.isFinite(max ?? NaN) && max) return allocated / max;
     } catch {
     }
@@ -2882,15 +2988,15 @@ var init_storm = __esm({
 });
 
 // src/heartbeat.ts
-import { readFileSync as readFileSync5, renameSync as renameSync4, writeFileSync as writeFileSync5 } from "fs";
+import { readFileSync as readFileSync6, renameSync as renameSync4, writeFileSync as writeFileSync6 } from "fs";
 function writeHeartbeat(path, now) {
   const tmp = `${path}.tmp`;
-  writeFileSync5(tmp, String(now));
+  writeFileSync6(tmp, String(now));
   renameSync4(tmp, path);
 }
 function readHeartbeat(path) {
   try {
-    const ms = Number(readFileSync5(path, "utf8").trim());
+    const ms = Number(readFileSync6(path, "utf8").trim());
     return Number.isFinite(ms) ? ms : null;
   } catch {
     return null;
@@ -2946,11 +3052,11 @@ var init_logNoise = __esm({
 });
 
 // src/agentToken.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, unlinkSync as unlinkSync3 } from "fs";
-import { join as join8 } from "path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3 } from "fs";
+import { join as join9 } from "path";
 function loadAgentToken() {
   try {
-    const s = JSON.parse(readFileSync6(STORE_PATH, "utf8"));
+    const s = JSON.parse(readFileSync7(STORE_PATH, "utf8"));
     return s.token ? s : null;
   } catch {
     return null;
@@ -3003,7 +3109,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;
   }
@@ -3441,9 +3547,9 @@ var init_netTimeout = __esm({
 });
 
 // src/git.ts
-import { existsSync as existsSync10, readdirSync as readdirSync11, statSync as statSync8 } from "fs";
+import { existsSync as existsSync11, readdirSync as readdirSync11, statSync as statSync8 } from "fs";
 import { appendFile, chmod, mkdir, readFile, rm, writeFile } from "fs/promises";
-import { isAbsolute as isAbsolute2, join as join17, sep as sep2 } from "path";
+import { isAbsolute as isAbsolute2, join as join18, sep as sep2 } from "path";
 import { $ as $2 } from "execa";
 function gitNet(repo, args, timeoutMs) {
   return withHardTimeout(
@@ -3466,7 +3572,7 @@ async function reclaimStaleWorktree(repo, worktree) {
 }
 function isLinkedWorktree(dir) {
   try {
-    return statSync8(join17(dir, ".git")).isFile();
+    return statSync8(join18(dir, ".git")).isFile();
   } catch {
     return false;
   }
@@ -3478,7 +3584,7 @@ async function detachWorktree(repo, worktree) {
   }
 }
 async function ensureWorktreeDirGone(worktree) {
-  if (!existsSync10(worktree)) return false;
+  if (!existsSync11(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.`
@@ -3493,7 +3599,7 @@ async function ensureWorktreeDirGone(worktree) {
     );
     return true;
   }
-  if (existsSync10(worktree)) {
+  if (existsSync11(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;
@@ -3541,7 +3647,7 @@ async function checkoutWorktree(repo, path, branch, opts) {
   }
   const busyAt = await worktreeForBranch(repo, branch);
   if (busyAt) {
-    const exists = existsSync10(busyAt);
+    const exists = existsSync11(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);
@@ -3576,8 +3682,8 @@ async function ensureGitExcluded(worktree, pattern) {
   try {
     const commonDir = await gitPath(worktree, "--git-common-dir");
     if (!commonDir) return false;
-    const infoDir = join17(commonDir, "info");
-    const excludeFile = join17(infoDir, "exclude");
+    const infoDir = join18(commonDir, "info");
+    const excludeFile = join18(infoDir, "exclude");
     let current = "";
     try {
       current = await readFile(excludeFile, "utf8");
@@ -3597,7 +3703,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 : join17(worktree, raw);
+  return isAbsolute2(raw) ? raw : join18(worktree, raw);
 }
 async function ensureWorktreeHygiene(worktree) {
   for (const pattern of SWARM_EXCLUDE_PATTERNS) await ensureGitExcluded(worktree, pattern);
@@ -3607,12 +3713,12 @@ async function installGuardHooks(worktree) {
   try {
     const gitDir = await gitPath(worktree, "--git-dir");
     if (!gitDir) return false;
-    const hooksDir = join17(gitDir, "swarm-hooks");
+    const hooksDir = join18(gitDir, "swarm-hooks");
     const prev = await previousHooksPath(worktree);
     await mkdir(hooksDir, { recursive: true });
     for (const hook of GUARD_HOOKS) {
-      await writeFile(join17(hooksDir, hook), guardHookScript(hook, prev ? `${posix(prev)}/${hook}` : null));
-      await chmod(join17(hooksDir, hook), 493);
+      await writeFile(join18(hooksDir, hook), guardHookScript(hook, prev ? `${posix(prev)}/${hook}` : null));
+      await chmod(join18(hooksDir, hook), 493);
     }
     await $2`git -C ${worktree} config extensions.worktreeConfig true`;
     await $2`git -C ${worktree} config --worktree core.hooksPath ${posix(hooksDir)}`;
@@ -3631,7 +3737,7 @@ async function previousHooksPath(worktree) {
     if (out.exitCode === 0 && value) return value;
   }
   const commonDir = await gitPath(worktree, "--git-common-dir");
-  return commonDir ? join17(commonDir, "hooks") : null;
+  return commonDir ? join18(commonDir, "hooks") : null;
 }
 async function removeWorktree(repo, path) {
   const branch = (await $2({ reject: false })`git -C ${path} symbolic-ref --quiet --short HEAD`).stdout.trim();
@@ -3656,7 +3762,7 @@ async function worktreeDirty(path) {
 async function repairMovedWorktrees(targetDir) {
   const subdirs = (dir) => {
     try {
-      return readdirSync11(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join17(dir, d.name));
+      return readdirSync11(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join18(dir, d.name));
     } catch {
       return [];
     }
@@ -3717,7 +3823,7 @@ async function mergeRef(worktree, ref) {
   return { clean: false, conflicts: u ? u.split("\n") : [], changed: false };
 }
 async function pushHeadTo(worktree, branch) {
-  await gitNetStrict(worktree, ["push", "origin", `HEAD:${branch}`], GIT_HEAVY_NET_TIMEOUT_MS);
+  await gitNetStrict(worktree, ["push", "origin", `HEAD:refs/heads/${branch}`], GIT_HEAVY_NET_TIMEOUT_MS);
 }
 async function snapshotWorktree(worktree, message) {
   try {
@@ -3785,20 +3891,20 @@ __export(droneChannel_exports, {
   verifyLocalCliToken: () => verifyLocalCliToken
 });
 import { createHmac, randomBytes, timingSafeEqual } from "crypto";
-import { chmodSync, mkdirSync as mkdirSync8, readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname3 } from "path";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname4 } from "path";
 import { serve } from "@hono/node-server";
 function loadChannelSecret(path) {
   try {
-    const s = readFileSync14(path, "utf8").trim();
+    const s = readFileSync15(path, "utf8").trim();
     if (s.length >= 32) return s;
   } catch {
   }
   const secret = randomBytes(32).toString("hex");
-  mkdirSync8(dirname3(path), { recursive: true });
-  writeFileSync10(path, secret, { mode: 384 });
+  mkdirSync9(dirname4(path), { recursive: true });
+  writeFileSync11(path, secret, { mode: 384 });
   try {
-    chmodSync(path, 384);
+    chmodSync2(path, 384);
   } catch {
   }
   return secret;
@@ -4140,7 +4246,7 @@ var init_droneChannel = __esm({
 
 // src/attachments.ts
 import { mkdir as mkdir2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 function attachmentsFromDoc(doc, origin) {
   const out = [];
   const walk2 = (node) => {
@@ -4231,7 +4337,7 @@ async function materializeAttachments(opts) {
   };
   const result = { files: [], skipped: [] };
   if (opts.refs.length === 0) return result;
-  const dir = join20(opts.worktree, ATTACHMENTS_DIR);
+  const dir = join21(opts.worktree, ATTACHMENTS_DIR);
   await io.removeDir(dir);
   let dirReady = false;
   let total = 0;
@@ -4277,7 +4383,7 @@ async function materializeAttachments(opts) {
         await io.mkdir(dir);
         dirReady = true;
       }
-      await io.writeFile(join20(dir, name), file.bytes);
+      await io.writeFile(join21(dir, name), file.bytes);
     } catch (e) {
       result.skipped.push(`${label2} \u2014 \u043D\u0435 \u0437\u0430\u043F\u0438\u0441\u0430\u043B\u043E\u0441\u044C \u043D\u0430 \u0434\u0438\u0441\u043A (${errText(e)})`);
       continue;
@@ -4430,7 +4536,7 @@ var init_attachments = __esm({
 
 // src/shotUpload.ts
 import { readFile as fsReadFile } from "fs/promises";
-import { basename as basename4, isAbsolute as isAbsolute3, join as join21 } from "path";
+import { basename as basename4, isAbsolute as isAbsolute3, join as join22 } from "path";
 function shotMimetype(path) {
   const dot = path.lastIndexOf(".");
   if (dot < 0) return null;
@@ -4456,7 +4562,7 @@ async function readShots(paths, opts) {
     }
     let bytes;
     try {
-      bytes = await read(isAbsolute3(path) ? path : join21(opts.worktree, path));
+      bytes = await read(isAbsolute3(path) ? path : join22(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;
@@ -4466,7 +4572,10 @@ async function readShots(paths, opts) {
       continue;
     }
     if (bytes.byteLength > maxBytes) {
-      skipped.push({ path, reason: `${(bytes.byteLength / 1024 / 1024).toFixed(1)} \u041C\u0411 \u2014 \u0431\u043E\u043B\u044C\u0448\u0435 \u043B\u0438\u043C\u0438\u0442\u0430 ${maxBytes / 1024 / 1024} \u041C\u0411` });
+      skipped.push({
+        path,
+        reason: `${(bytes.byteLength / 1024 / 1024).toFixed(1)} \u041C\u0411 \u2014 \u0431\u043E\u043B\u044C\u0448\u0435 \u043B\u0438\u043C\u0438\u0442\u0430 ${maxBytes / 1024 / 1024} \u041C\u0411; \u043F\u0435\u0440\u0435\u0441\u043D\u0438\u043C\u0438 \u043F\u043E\u043B\u0435\u0433\u0447\u0435: swarm shot \u2026 --scale 1 (\u0438\u043B\u0438 --scroll-to <\u0441\u0435\u043B\u0435\u043A\u0442\u043E\u0440> \u0432\u043C\u0435\u0441\u0442\u043E \u0434\u043B\u0438\u043D\u043D\u043E\u0433\u043E \u043A\u0430\u0434\u0440\u0430)`
+      });
       continue;
     }
     files.push({ path, fileName: basename4(path), mimetype, bytes });
@@ -4521,7 +4630,7 @@ var init_shotUpload = __esm({
   "src/shotUpload.ts"() {
     "use strict";
     SHOT_MAX_FILES = 6;
-    SHOT_MAX_FILE_BYTES = 10 * 1024 * 1024;
+    SHOT_MAX_FILE_BYTES = 20 * 1024 * 1024;
     MIME_BY_EXT = {
       ".png": "image/png",
       ".jpg": "image/jpeg",
@@ -4534,8 +4643,8 @@ 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 join22 } from "path";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync12, unlinkSync as unlinkSync4 } from "fs";
+import { join as join23 } from "path";
 function makePkce() {
   const verifier = randomBytes2(48).toString("base64url");
   const challenge = createHash2("sha256").update(verifier).digest("base64url");
@@ -4619,13 +4728,13 @@ function toStore(clientId, t, now) {
 }
 function loadStore() {
   try {
-    return JSON.parse(readFileSync15(STORE_PATH2, "utf8"));
+    return JSON.parse(readFileSync16(STORE_PATH2, "utf8"));
   } catch {
     return null;
   }
 }
 function saveStore(s) {
-  writeFileSync11(STORE_PATH2, JSON.stringify(s, null, 2), { mode: 384 });
+  writeFileSync12(STORE_PATH2, JSON.stringify(s, null, 2), { mode: 384 });
 }
 function clearStore() {
   try {
@@ -4635,7 +4744,7 @@ function clearStore() {
 }
 function loadClientId() {
   try {
-    return JSON.parse(readFileSync15(CLIENT_PATH, "utf8")).clientId;
+    return JSON.parse(readFileSync16(CLIENT_PATH, "utf8")).clientId;
   } catch {
     return null;
   }
@@ -4644,7 +4753,7 @@ async function ensureClientId(api, redirectUri, fetchFn = fetch) {
   const existing = loadClientId();
   if (existing) return existing;
   const clientId = await registerClient({ api, redirectUri }, fetchFn);
-  writeFileSync11(CLIENT_PATH, JSON.stringify({ clientId }, null, 2), { mode: 384 });
+  writeFileSync12(CLIENT_PATH, JSON.stringify({ clientId }, null, 2), { mode: 384 });
   return clientId;
 }
 async function ensureAccess(store, opts = {}) {
@@ -4670,8 +4779,8 @@ var init_oauth = __esm({
     AUTHORIZE = "/api/oauth/authorize";
     TOKEN = "/api/oauth/token";
     SCOPE = "openid profile email taskless:full";
-    STORE_PATH2 = join22(SWARM_HOME, "oauth.json");
-    CLIENT_PATH = join22(SWARM_HOME, "oauth-client.json");
+    STORE_PATH2 = join23(SWARM_HOME, "oauth.json");
+    CLIENT_PATH = join23(SWARM_HOME, "oauth-client.json");
     base2 = (api) => api.replace(/\/$/, "");
   }
 });
@@ -4789,11 +4898,11 @@ var init_authState = __esm({
 });
 
 // src/workspace.ts
-import { readFileSync as readFileSync16, writeFileSync as writeFileSync12, unlinkSync as unlinkSync5 } from "fs";
-import { join as join23 } from "path";
+import { readFileSync as readFileSync17, writeFileSync as writeFileSync13, unlinkSync as unlinkSync5 } from "fs";
+import { join as join24 } from "path";
 function loadWorkspace() {
   try {
-    const w = JSON.parse(readFileSync16(WORKSPACE_PATH, "utf8"));
+    const w = JSON.parse(readFileSync17(WORKSPACE_PATH, "utf8"));
     return w && typeof w.id === "string" && w.id ? w : null;
   } catch {
     return null;
@@ -4807,7 +4916,7 @@ var init_workspace = __esm({
   "src/workspace.ts"() {
     "use strict";
     init_config();
-    WORKSPACE_PATH = join23(SWARM_HOME, "workspace.json");
+    WORKSPACE_PATH = join24(SWARM_HOME, "workspace.json");
   }
 });
 
@@ -4844,7 +4953,7 @@ function isClosingTaskCategory(category) {
 function taskAuthor(u) {
   return u?.id ? { id: u.id, name: u.displayName || "\u0430\u0432\u0442\u043E\u0440 \u0437\u0430\u0434\u0430\u0447\u0438" } : null;
 }
-function toolErrorText(r) {
+function toolErrorText2(r) {
   const fromContent = (r.content ?? []).map((c) => c.text ?? "").filter(Boolean).join(" ").trim();
   return fromContent || JSON.stringify(r);
 }
@@ -4856,7 +4965,7 @@ function makeTasklessClient(call, workspaceId, taskUrlBase, fetchFile, fetchImpl
     try {
       const r = await call(name, WS_FREE_TOOLS.has(name) ? args : { ...args, ...ws });
       if (r?.isError) {
-        const raw = toolErrorText(r);
+        const raw = toolErrorText2(r);
         const detail = trimDetail(raw);
         console.error(`[taskless] \u0442\u0443\u043B ${name} \u0432\u0435\u0440\u043D\u0443\u043B \u043E\u0448\u0438\u0431\u043A\u0443:`, detail);
         return { ok: false, failure: { code: classifyToolFailure(raw), detail } };
@@ -5388,7 +5497,7 @@ __export(db_exports, {
 });
 import { createRequire as createRequire2 } from "module";
 import { randomUUID as randomUUID3 } from "crypto";
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { resolve as resolve3 } from "path";
 function rowToQuestion(row) {
   return {
@@ -5996,7 +6105,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 (!existsSync12(abs)) throw new Error(`import-db: \u0444\u0430\u0439\u043B\u0430 \u043D\u0435\u0442: ${abs}`);
+        if (!existsSync13(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();
@@ -6364,10 +6473,10 @@ var init_droneStore = __esm({
 });
 
 // src/overmind.ts
-import { homedir as homedir5 } from "os";
-import { existsSync as existsSync17, readFileSync as readFileSync20, readdirSync as readdirSync13, renameSync as renameSync11 } from "fs";
-import { basename as basename6, dirname as dirname4, join as join30 } from "path";
-import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
+import { homedir as homedir6 } from "os";
+import { existsSync as existsSync18, readFileSync as readFileSync21, readdirSync as readdirSync13, renameSync as renameSync11 } from "fs";
+import { basename as basename6, dirname as dirname5, join as join31 } from "path";
+import { fileURLToPath as fileURLToPath3, pathToFileURL } from "url";
 import { spawn as spawn3 } from "child_process";
 
 // src/restart.ts
@@ -6446,8 +6555,8 @@ init_config();
 init_resources();
 init_names2();
 init_storm();
-import { appendFileSync, existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-import { dirname } from "path";
+import { appendFileSync, existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname2 } from "path";
 import { randomUUID } from "crypto";
 
 // src/repoRules.ts
@@ -6499,12 +6608,12 @@ function renderPendingRulesBlock(rules) {
 }
 
 // src/logTail.ts
-import { closeSync, existsSync as existsSync5, openSync, readSync, readdirSync as readdirSync5, statSync as statSync4 } from "fs";
-import { join as join7 } from "path";
+import { closeSync, existsSync as existsSync6, openSync, readSync, readdirSync as readdirSync5, statSync as statSync4 } from "fs";
+import { join as join8 } 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";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readdirSync as readdirSync4, renameSync as renameSync3, statSync as statSync3 } from "fs";
+import { join as join7 } from "path";
 var LEGACY_RUN_LOGS_SUBDIR = "legacy";
 function runLogDirName(runLogKey) {
   const safe2 = runLogKey.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^[-_]+|[-_]+$/g, "");
@@ -6512,12 +6621,12 @@ function runLogDirName(runLogKey) {
   return /^\d+$/.test(safe2) ? `k-${safe2}` : safe2;
 }
 function runLogDirPath(runLogsDir, runLogKey) {
-  return join6(runLogsDir, runLogDirName(runLogKey));
+  return join7(runLogsDir, runLogDirName(runLogKey));
 }
 function findRunLogDir(runLogsDir, keys) {
   for (const key of keys) {
     const dir = runLogDirPath(runLogsDir, key);
-    if (existsSync4(dir)) return dir;
+    if (existsSync5(dir)) return dir;
   }
   return null;
 }
@@ -6527,7 +6636,7 @@ function runLogDirForWrite(runLogsDir, keys) {
   return findRunLogDir(runLogsDir, keys) ?? runLogDirPath(runLogsDir, canonical);
 }
 function sweepLegacyRunLogs(runLogsDir) {
-  const legacyDir = join6(runLogsDir, LEGACY_RUN_LOGS_SUBDIR);
+  const legacyDir = join7(runLogsDir, LEGACY_RUN_LOGS_SUBDIR);
   let entries;
   try {
     entries = readdirSync4(runLogsDir);
@@ -6538,12 +6647,12 @@ function sweepLegacyRunLogs(runLogsDir) {
   let failed = 0;
   for (const name of entries) {
     if (!/^\d+$/.test(name)) continue;
-    const from = join6(runLogsDir, name);
+    const from = join7(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}`);
+      mkdirSync5(legacyDir, { recursive: true });
+      let to = join7(legacyDir, name);
+      for (let n = 2; existsSync5(to) && n < 100; n++) to = join7(legacyDir, `${name}-${n}`);
       renameSync3(from, to);
       moved++;
     } catch {
@@ -6609,8 +6718,8 @@ function latestRunLaunch(runLogsDir, runLogKeys) {
   }
   if (indexes.size === 0) return null;
   const index = Math.max(...indexes);
-  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;
+  const out = [join8(dir, `${index}.json`), join8(dir, `${index}.json.done`)].find((p) => existsSync6(p)) ?? null;
+  const err = existsSync6(join8(dir, `${index}.err.log`)) ? join8(dir, `${index}.err.log`) : null;
   return { index, total: indexes.size, out, err };
 }
 function runLogTail(runLogsDir, runLogKeys, opts) {
@@ -6692,6 +6801,11 @@ async function serveLogRequests(deps, commands) {
 init_src();
 var RESOLVER_TERMINAL = /* @__PURE__ */ new Set([...TERMINAL_STATUSES, "stalled"]);
 var SLUG_TERMINAL = new Set(TERMINAL_STATUSES);
+function toolErrorText(res) {
+  const text = (res?.content ?? []).map((c) => c.text ?? "").join(" ").replace(/\s+/g, " ").trim();
+  if (!text) return "\u043F\u0440\u043E\u0434 \u043E\u0442\u0432\u0435\u0440\u0433 \u0432\u044B\u0437\u043E\u0432 \u0431\u0435\u0437 \u043E\u0431\u044A\u044F\u0441\u043D\u0435\u043D\u0438\u044F";
+  return text.length > 200 ? `${text.slice(0, 200)}\u2026` : text;
+}
 function runRef(runKey) {
   return { __runRef: runKey };
 }
@@ -6777,6 +6891,17 @@ var SwarmClient = class _SwarmClient {
   // нечего искать. Резолв делает прод (см. resolveDepRefs), здесь только запоминаем.
   depSlug = /* @__PURE__ */ new Map();
   static DEPS_TTL_MS = 6e4;
+  // TASWM-486: ссылки, по которым прод НЕ ОТВЕТИЛ (отверг вызов или не дозвонились) —
+  // с какого времени, сколько попыток и чем именно отказал. Отказ ≠ ответ: вердикта в
+  // `depsProd` не появляется, `depVerdicts` отдаёт `pending`, и ждущий прогон стоит,
+  // пока человек не разбудит его руками (21.08 — дважды за час). Отсюда две вещи:
+  // короткий backoff вместо полного TTL (переспросить, а не ждать минуту) и
+  // `depsUnconfirmed` — чтобы «стою вслепую» было ВИДНО в причине отказа и в аномалии.
+  depsUnanswered = /* @__PURE__ */ new Map();
+  // Первый переспрос — через 5 с (тик ~4 с, то есть буквально «на следующем тике»),
+  // дальше удвоением до потолка TTL: устойчиво отвергающий прод (старее демона, скоуп
+  // токена) не должен получать вопрос каждые четыре секунды до конца своей жизни.
+  static DEPS_RETRY_BASE_MS = 5e3;
   // TASWM-327: прод старее демона и не знает аргумент `level` у swarm_notify. Выясняется
   // ровно один раз (первой отвергнутой нотификацией) и держится всю жизнь процесса — иначе
   // каждый сигнал платил бы за это лишним отвергнутым вызовом. См. notifyAnomaly.
@@ -6835,26 +6960,26 @@ 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 ?? existsSync6;
+    this.repoExists = opts.repoExists ?? existsSync7;
     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`;
-    mkdirSync5(dirname(this.outboxPath), { recursive: true });
+    mkdirSync6(dirname2(this.outboxPath), { recursive: true });
     this.recover();
   }
   // ── рестарт: поднять outbox (незаписанные операции) и карту runKey→prodId ─────
   recover() {
-    if (existsSync6(this.mapPath)) {
+    if (existsSync7(this.mapPath)) {
       try {
-        const obj = JSON.parse(readFileSync4(this.mapPath, "utf8"));
+        const obj = JSON.parse(readFileSync5(this.mapPath, "utf8"));
         for (const [k, v] of Object.entries(obj)) this.prodIdByKey.set(k, v);
       } catch {
       }
     }
-    if (existsSync6(this.outboxPath)) {
-      const txt = readFileSync4(this.outboxPath, "utf8");
+    if (existsSync7(this.outboxPath)) {
+      const txt = readFileSync5(this.outboxPath, "utf8");
       for (const line of txt.split("\n")) {
         const s = line.trim();
         if (!s) continue;
@@ -6874,10 +6999,10 @@ var SwarmClient = class _SwarmClient {
   // eventsLog ПЕРВЫМИ (до hydrate), в порядке файла (= хронологический); id
   // переприсваиваем локально (id событий — только порядок, не корреляция с продом).
   replayGlobalEvents() {
-    if (!existsSync6(this.stormPath)) return;
+    if (!existsSync7(this.stormPath)) return;
     let txt;
     try {
-      txt = readFileSync4(this.stormPath, "utf8");
+      txt = readFileSync5(this.stormPath, "utf8");
     } catch {
       return;
     }
@@ -7354,27 +7479,41 @@ var SwarmClient = class _SwarmClient {
    * Одним вызовом на все просроченные ссылки, а не по вызову на ссылку: очередь ждущих
    * бывает в десятки прогонов, и N запросов на тик — это тот же самый поход в прод, только
    * дороже.
+   *
+   * TASWM-486: ОТКАЗ ПРОДА — НЕ ОТВЕТ. Раньше `isError` засчитывался как «спросили», и
+   * следующая попытка шла только через TTL; при УСТОЙЧИВОМ отказе (прод старее демона,
+   * просроченный скоуп токена демона, сбой на батче) вердикта не появлялось никогда —
+   * зависимость навсегда оставалась `pending`, а ждущий прогон стоял при свободной машине
+   * до ручного `wake_run`. Теперь отказ помнится отдельно (`depsUnanswered`): переспрос идёт
+   * по короткому нарастающему backoff, а сам факт «прод молчит» становится видимым —
+   * причина отказа спавна называет его вслух, и на затянувшуюся слепоту звенит аномалия.
    */
   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 (asked === void 0) return true;
+      return nowMs - asked >= this.depsRetryDelay(ref);
     });
     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 {
+    } catch (e) {
       for (const ref of ask) this.depsAskedAt.delete(ref);
+      this.noteDepsUnanswered(ask, nowMs, String(e));
+      return;
+    }
+    if (res?.isError) {
+      this.noteDepsUnanswered(ask, nowMs, toolErrorText(res));
       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;
+      this.depsUnanswered.delete(ref);
       const outcome = String(d.outcome ?? "pending");
       this.depsProd.set(ref, {
         outcome,
@@ -7386,6 +7525,75 @@ var SwarmClient = class _SwarmClient {
       if (typeof d.slug === "string" && d.slug) this.depSlug.set(ref, d.slug);
     }
   }
+  /**
+   * Через сколько переспрашивать ссылку (TASWM-486). Пауза зависит от того, ЧЕГО мы ждём —
+   * и сколько стоит опоздать с ответом:
+   *
+   *   • ПРОД ОТКАЗАЛ (isError / не дозвонились) — короткий backoff с удвоением (5с →
+   *     потолок TTL). Ждём, что прод вообще начнёт отвечать; до тех пор вердикта нет вовсе.
+   *   • БЛОКЕР ЖИВ либо вердикта ещё не было (`pending`) — КАЖДЫЙ ТИК. Это единственное
+   *     состояние, в котором ждущий прогон ЖЖЁТ ВРЕМЯ: блокер может закрыться в любую
+   *     секунду, и до TASWM-486 минута TTL превращалась в минуту простоя при свободной
+   *     машине (21.08: «стартует сам в пределах одного-двух тиков» не выполнялось даже
+   *     когда прод отвечал исправно). Цена — ОДИН батч-вызов на тик (все ссылки очереди
+   *     идут одним запросом, см. refreshDeps), и только пока кто-то реально ждёт.
+   *   • ЗАВИСИМОСТЬ УЖЕ СНЯТА неуспехом (`exhausted`) или блокера не знает никто
+   *     (`unknown`) — штатный TTL: прогон этими вердиктами больше не задерживается
+   *     (`exhausted`) либо не поедет в любом случае (`unknown`, там своя аномалия), и
+   *     переспрос нужен только на случай, что оператор переиграет блокер новым прогоном.
+   *   • `done` сюда не доходит вовсе — монотонен, отфильтрован раньше.
+   */
+  depsRetryDelay(ref) {
+    const fail = this.depsUnanswered.get(ref);
+    if (fail) {
+      const backoff = _SwarmClient.DEPS_RETRY_BASE_MS * 2 ** Math.min(fail.attempts - 1, 10);
+      return Math.min(backoff, _SwarmClient.DEPS_TTL_MS);
+    }
+    const known = this.depsProd.get(ref);
+    if (!known || known.outcome === "pending") return 0;
+    return _SwarmClient.DEPS_TTL_MS;
+  }
+  /** Запомнить, что прод по этим ссылкам не ответил (см. depsUnanswered / TASWM-486). */
+  noteDepsUnanswered(refs, nowMs, error) {
+    for (const ref of refs) {
+      const prev = this.depsUnanswered.get(ref);
+      this.depsUnanswered.set(ref, {
+        ref,
+        slug: this.depSlug.get(ref) ?? ref,
+        // `since` — начало ЭПИЗОДА слепоты, а не последняя попытка: именно возраст эпизода
+        // отвечает на вопрос «сколько прогон уже стоит вслепую».
+        since: prev?.since ?? nowMs,
+        attempts: (prev?.attempts ?? 0) + 1,
+        error
+      });
+    }
+  }
+  /**
+   * TASWM-486: ссылки `dependsOn`, по которым ВЕРДИКТА ПРОДА НЕТ — не «блокер жив», а «мы
+   * не знаем, жив ли он». Снаружи оба выглядели одинаково (`pending`) и вели себя одинаково
+   * молча, а разница ровно в том, дождётся ли ждущий чего-нибудь сам: живой блокер
+   * закончится, а неотвечающий прод — нет, и прогон стоит до ручной побудки.
+   *
+   * Что сюда НЕ попадает и почему:
+   *   • прод отвечает — слепоты нет вовсе (запись стирается первым же ответом);
+   *   • последний вердикт уже СНЯЛ зависимость (`met`) — прогон ею не задерживается,
+   *     свежесть ответа ничего не решает;
+   *   • последний вердикт — `unknown`: это территория `dep_missing`, у неё и текст
+   *     точнее («блокера не знает никто»), и лечение другое.
+   * А вот УСТАРЕВШИЙ `pending` при замолчавшем проде — как раз слепота: когда-то блокер
+   * был жив, с тех пор он мог закрыться, и узнать это не у кого.
+   */
+  depsUnconfirmed(refs) {
+    const out = [];
+    for (const ref of new Set(refs)) {
+      const known = this.depsProd.get(ref);
+      if (known?.met || known?.outcome === "unknown") continue;
+      const fail = this.depsUnanswered.get(ref);
+      if (!fail) continue;
+      out.push({ ...fail, slug: this.depSlug.get(ref) ?? fail.slug });
+    }
+    return out;
+  }
   /**
    * TASWM-300: точечно перечитать прогон из прода — см. докблок SwarmStore.refreshRun.
    * `swarm_list_runs` фильтруем по задаче прогона (taskId принимает человеко-слаг) и берём
@@ -7702,7 +7910,7 @@ var SwarmClient = class _SwarmClient {
    * транзиентным сбоем ОС, который этот PR должен переживать, а не превращать в мор.
    */
   reconcileRuntime(opts) {
-    const wtExists = opts.worktreeExists ?? existsSync6;
+    const wtExists = opts.worktreeExists ?? existsSync7;
     const pidByWorktree = /* @__PURE__ */ new Map();
     try {
       for (const p of opts.listProcesses()) if (p.worktree) pidByWorktree.set(p.worktree, p.pid);
@@ -8895,13 +9103,13 @@ var SwarmClient = class _SwarmClient {
   }
   persistPending() {
     try {
-      writeFileSync4(this.outboxPath, this.pending.map((e) => JSON.stringify(e)).join("\n") + (this.pending.length ? "\n" : ""));
+      writeFileSync5(this.outboxPath, this.pending.map((e) => JSON.stringify(e)).join("\n") + (this.pending.length ? "\n" : ""));
     } catch {
     }
   }
   persistMap() {
     try {
-      writeFileSync4(this.mapPath, JSON.stringify(Object.fromEntries(this.prodIdByKey)));
+      writeFileSync5(this.mapPath, JSON.stringify(Object.fromEntries(this.prodIdByKey)));
     } catch {
     }
   }
@@ -8971,7 +9179,7 @@ function tickPulse(health, now, intervalMs) {
 }
 
 // src/logRotate.ts
-import { copyFileSync, renameSync as renameSync5, statSync as statSync5, fstatSync, truncateSync, unlinkSync as unlinkSync2, existsSync as existsSync7 } from "fs";
+import { copyFileSync as copyFileSync2, renameSync as renameSync5, statSync as statSync5, fstatSync, truncateSync, unlinkSync as unlinkSync2, existsSync as existsSync8 } from "fs";
 var realIo = {
   size: (path) => {
     try {
@@ -8980,11 +9188,11 @@ var realIo = {
       return null;
     }
   },
-  copy: copyFileSync,
+  copy: copyFileSync2,
   rename: renameSync5,
   truncate: (path) => truncateSync(path, 0),
   unlink: unlinkSync2,
-  exists: existsSync7
+  exists: existsSync8
 };
 var realOwnerIo = {
   statFd: (fd) => {
@@ -9111,13 +9319,13 @@ async function buildRepoRegistry(paths) {
 }
 
 // src/repoMemory.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "fs";
-import { join as join9 } from "path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "fs";
+import { join as join10 } from "path";
 var FILE = "repos.json";
 function loadRememberedRepos(home) {
   let raw;
   try {
-    raw = readFileSync7(join9(home, FILE), "utf8");
+    raw = readFileSync8(join10(home, FILE), "utf8");
   } catch {
     return [];
   }
@@ -9132,7 +9340,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;
-  writeFileSync7(join9(home, FILE), `${JSON.stringify({ paths: clean, at: now().toISOString() }, null, 2)}
+  writeFileSync8(join10(home, FILE), `${JSON.stringify({ paths: clean, at: now().toISOString() }, null, 2)}
 `);
 }
 function pickRepoPaths(args) {
@@ -9146,13 +9354,13 @@ function pickRepoPaths(args) {
 init_src();
 init_config();
 init_linkFailure();
-import { homedir as homedir3 } from "os";
-import { readFileSync as readFileSync9, renameSync as renameSync6, writeFileSync as writeFileSync8 } from "fs";
-import { isAbsolute, join as join11, resolve as resolve2 } from "path";
+import { homedir as homedir4 } from "os";
+import { readFileSync as readFileSync10, renameSync as renameSync6, writeFileSync as writeFileSync9 } from "fs";
+import { isAbsolute, join as join12, resolve as resolve2 } from "path";
 
 // src/repoScan.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync8, statSync as statSync6 } from "fs";
-import { join as join10 } from "path";
+import { readdirSync as readdirSync6, readFileSync as readFileSync9, statSync as statSync6 } from "fs";
+import { join as join11 } from "path";
 var SKIP = /* @__PURE__ */ new Set([
   "node_modules",
   "vendor",
@@ -9182,7 +9390,7 @@ function parseOriginFromGitConfig(text) {
 }
 function originOf(dir) {
   try {
-    return parseOriginFromGitConfig(readFileSync8(join10(dir, ".git", "config"), "utf8"));
+    return parseOriginFromGitConfig(readFileSync9(join11(dir, ".git", "config"), "utf8"));
   } catch {
     return null;
   }
@@ -9217,7 +9425,7 @@ function walk(dir, depth, maxDepth, found) {
   }
   for (const name of entries) {
     if (name.startsWith(".") || SKIP.has(name)) continue;
-    const child = join10(dir, name);
+    const child = join11(dir, name);
     try {
       if (!statSync6(child).isDirectory()) continue;
     } catch {
@@ -9239,13 +9447,13 @@ 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(join10(home, name));
+    add(join11(home, name));
   }
   return out;
 }
 
 // src/repoDiscovery.ts
-function resolveScanRoots(raw, home = homedir3(), knownPaths = []) {
+function resolveScanRoots(raw, home = homedir4(), knownPaths = []) {
   const v = (raw ?? "").trim();
   if (!v) return defaultScanRoots(home, knownPaths);
   if (["off", "none", "0"].includes(v.toLowerCase())) return [];
@@ -9253,7 +9461,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("~/") ? join11(home, p.slice(2)) : isAbsolute(p) ? p : resolve2(home, p);
+    const abs = p === "~" ? home : p.startsWith("~/") ? join12(home, p.slice(2)) : isAbsolute(p) ? p : resolve2(home, p);
     if (!out.includes(abs)) out.push(abs);
   }
   return out;
@@ -9467,7 +9675,7 @@ function repoMapRows(state) {
 }
 function loadRepoMapCache(path) {
   try {
-    const raw = JSON.parse(readFileSync9(path, "utf8"));
+    const raw = JSON.parse(readFileSync10(path, "utf8"));
     if (!Array.isArray(raw?.entries)) return { scannedAt: null, entries: [] };
     return {
       scannedAt: typeof raw.scannedAt === "string" && raw.scannedAt ? raw.scannedAt : null,
@@ -9482,7 +9690,7 @@ function loadRepoMapCache(path) {
 function writeRepoMapCache(path, entries, scannedAt = stamp()) {
   try {
     const tmp = `${path}.tmp`;
-    writeFileSync8(tmp, JSON.stringify({ at: stamp(), scannedAt, entries }, null, 2));
+    writeFileSync9(tmp, JSON.stringify({ at: stamp(), scannedAt, entries }, null, 2));
     renameSync6(tmp, path);
   } catch {
   }
@@ -9490,17 +9698,17 @@ function writeRepoMapCache(path, entries, scannedAt = stamp()) {
 
 // src/hostIdentity.ts
 import { hostname } from "os";
-import { existsSync as existsSync8, readFileSync as readFileSync10, renameSync as renameSync7, writeFileSync as writeFileSync9 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync11, renameSync as renameSync7, writeFileSync as writeFileSync10 } from "fs";
+import { join as join13 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function hostIdentityPath(home) {
-  return join12(home, "host.json");
+  return join13(home, "host.json");
 }
 function loadHostIdentity(deps) {
-  const exists = deps.exists ?? existsSync8;
-  const readFile2 = deps.readFile ?? ((p) => readFileSync10(p, "utf8"));
+  const exists = deps.exists ?? existsSync9;
+  const readFile2 = deps.readFile ?? ((p) => readFileSync11(p, "utf8"));
   const writeFile3 = deps.writeFile ?? ((p, data) => {
-    writeFileSync9(`${p}.tmp`, data);
+    writeFileSync10(`${p}.tmp`, data);
     renameSync7(`${p}.tmp`, p);
   });
   const host = deps.hostname ?? hostname;
@@ -9683,15 +9891,15 @@ function buildReliefCostCandidates(cost, t, sustainMs, build) {
 
 // src/launcher.ts
 import { spawn } from "child_process";
-import { closeSync as closeSync2, existsSync as existsSync9, mkdirSync as mkdirSync7, openSync as openSync2, readdirSync as readdirSync8 } from "fs";
+import { closeSync as closeSync2, existsSync as existsSync10, mkdirSync as mkdirSync8, openSync as openSync2, readdirSync as readdirSync8 } from "fs";
 import { createRequire } from "module";
-import { homedir as homedir4 } from "os";
-import { dirname as dirname2, join as join14 } from "path";
-import { fileURLToPath } from "url";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname3, join as join15 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/droneHome.ts
-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";
+import { lstatSync, mkdirSync as mkdirSync7, readdirSync as readdirSync7, rmSync, statSync as statSync7, symlinkSync as symlinkSync2 } from "fs";
+import { join as join14, 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);
@@ -9709,26 +9917,26 @@ function buildDroneHome(opts) {
   const { realHome, droneHome } = opts;
   const deny = opts.deny ?? droneHomeDeny();
   const platform = opts.platform ?? process.platform;
-  mkdirSync6(droneHome, { recursive: true, mode: 448 });
+  mkdirSync7(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 readdirSync7(droneHome)) {
     if (wanted.has(existing)) continue;
-    const p = join13(droneHome, existing);
+    const p = join14(droneHome, existing);
     try {
       if (lstatSync(p).isSymbolicLink()) rmSync(p);
     } catch {
     }
   }
   for (const name of wanted) {
-    const link = join13(droneHome, name);
+    const link = join14(droneHome, name);
     try {
       lstatSync(link);
       continue;
     } catch {
     }
-    const target = join13(realHome, name);
+    const target = join14(realHome, name);
     let isDir;
     try {
       isDir = statSync7(target).isDirectory();
@@ -9749,7 +9957,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, join13(realHome, ...segments)]));
+  return Object.fromEntries(REAL_PATH_ENV_PINS.map(({ env, segments }) => [env, join14(realHome, ...segments)]));
 }
 function dronePrivatePaths(realHome, swarmHome) {
   return [
@@ -9805,7 +10013,7 @@ function droneTestEnv(droneCap, base3 = process.env, host = hostForkSpec()) {
 
 // src/swarmModels.ts
 init_src();
-function pick(v) {
+function pick2(v) {
   const s = typeof v === "string" ? v.trim() : "";
   return s.length > 0 ? s : null;
 }
@@ -9821,10 +10029,10 @@ function forKind(kind, swarm, norm) {
 }
 function resolveRunModelRef(run, swarm, env = process.env) {
   const configured = parseModelRef(
-    pick(run.model) ?? forKind(run.kind, swarm, pick) ?? pick(env.SWARM_DRONE_MODEL)
+    pick2(run.model) ?? forKind(run.kind, swarm, pick2) ?? pick2(env.SWARM_DRONE_MODEL)
   );
   if (configured) return configured;
-  const providerId = pick(env.SWARM_MODEL_PROVIDER) ?? DEFAULT_PROVIDER_ID;
+  const providerId = pick2(env.SWARM_MODEL_PROVIDER) ?? DEFAULT_PROVIDER_ID;
   return { providerId, model: defaultModelFor(modelRoleOf(run.kind), providerId) };
 }
 function resolveRunModel(run, swarm, env = process.env) {
@@ -9861,7 +10069,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 = join14(worktree, ".turbo", "cache");
+    env.TURBO_CACHE_DIR = join15(worktree, ".turbo", "cache");
   }
   Object.assign(env, droneTestEnv(droneCap, base3));
   for (const key of DAEMON_STATE_ENV) delete env[key];
@@ -9889,18 +10097,18 @@ var DAEMON_STATE_ENV = [
   "TASKLESS_TOKEN"
 ];
 function bundledRoleDir(kind) {
-  return join14(dirname2(fileURLToPath(import.meta.url)), "..", "roles", kind);
+  return join15(dirname3(fileURLToPath2(import.meta.url)), "..", "roles", kind);
 }
 function roleDir(worktree, kind) {
-  return join14(worktree, ".claude", "roles", kind);
+  return join15(worktree, ".claude", "roles", kind);
 }
 function roleDirs(worktree, kind) {
-  return [bundledRoleDir(kind), roleDir(worktree, kind)].filter((dir) => existsSync9(dir));
+  return [bundledRoleDir(kind), roleDir(worktree, kind)].filter((dir) => existsSync10(dir));
 }
 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 });
+  mkdirSync8(dir, { recursive: true });
   let files = [];
   try {
     files = readdirSync8(dir);
@@ -9911,7 +10119,7 @@ function nextRunLogPath(runLogsDir, runLogKeys) {
     const m = /^(\d+)\.json/.exec(f);
     if (m) next = Math.max(next, Number(m[1]) + 1);
   }
-  return join14(dir, `${next}.json`);
+  return join15(dir, `${next}.json`);
 }
 function openNextRunLog(runLogsDir, runLogKeys) {
   for (let attempt = 0; attempt < 50; attempt++) {
@@ -9992,11 +10200,11 @@ function makeLauncher(cfg) {
     } catch (e) {
       console.error(`[launcher] \u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0437\u0430\u043F\u0438\u0441\u0430\u0442\u044C \u0443\u0441\u0438\u043B\u0438\u0435 \u043F\u0440\u043E\u0433\u043E\u043D\u0430 #${run.id}: ${String(e)}`);
     }
-    const realHome = cfg.droneIsolation?.realHome ?? homedir4();
+    const realHome = cfg.droneIsolation?.realHome ?? homedir5();
     const home = cfg.droneIsolation ? buildDroneHome({ realHome, droneHome: cfg.droneIsolation.home }) : void 0;
-    if (cfg.droneIsolation && process.env.TASKLESS_TOKEN && !existsSync9(join14(cfg.droneIsolation.swarmHome, "token"))) {
+    if (cfg.droneIsolation && process.env.TASKLESS_TOKEN && !existsSync10(join15(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 ${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.`
+        `[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 ${join15(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();
@@ -10057,8 +10265,8 @@ 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";
+import { readFileSync as readFileSync12, readdirSync as readdirSync9, renameSync as renameSync8 } from "fs";
+import { join as join16 } from "path";
 init_executors();
 var UNPROCESSED_LOG_RE = /^\d+\.json$/;
 function unprocessedLogFiles(dir) {
@@ -10080,10 +10288,10 @@ function accountRunCost(deps, run) {
   let durationMs = 0;
   const processed = [];
   for (const f of files) {
-    const full = join15(dir, f);
+    const full = join16(dir, f);
     let raw = null;
     try {
-      raw = readFileSync11(full, "utf8");
+      raw = readFileSync12(full, "utf8");
     } catch {
       continue;
     }
@@ -10132,8 +10340,8 @@ function makeCostSweeper(deps) {
 }
 
 // src/runOutcome.ts
-import { readdirSync as readdirSync10, readFileSync as readFileSync12 } from "fs";
-import { join as join16 } from "path";
+import { readdirSync as readdirSync10, readFileSync as readFileSync13 } from "fs";
+import { join as join17 } from "path";
 init_executors();
 function endedItself(outcome) {
   return outcome === "graceful" || outcome === "budget" || outcome === "aborted";
@@ -10160,7 +10368,7 @@ function readLatestResultRaw(runLogsDir, runLogKeys) {
   }
   if (!latest) return null;
   try {
-    return readFileSync12(join16(dir, latest.name), "utf8");
+    return readFileSync13(join17(dir, latest.name), "utf8");
   } catch {
     return null;
   }
@@ -10193,20 +10401,20 @@ init_src();
 init_git();
 
 // src/deps.ts
-import { existsSync as existsSync11, readdirSync as readdirSync12, readFileSync as readFileSync13 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync12, readFileSync as readFileSync14 } from "fs";
+import { join as join20 } 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 statSync9, writeSync } from "fs";
-import { join as join18 } from "path";
+import { join as join19 } 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 join18(dir, `swarm-prepare-${createHash("sha1").update(key).digest("hex").slice(0, 16)}.lock`);
+  return join19(dir, `swarm-prepare-${createHash("sha1").update(key).digest("hex").slice(0, 16)}.lock`);
 }
 function defaultTryCreate(path, content) {
   try {
@@ -10280,7 +10488,7 @@ async function runCommand(cmd, worktree) {
 }
 function safeReadText(p) {
   try {
-    return readFileSync13(p, "utf8");
+    return readFileSync14(p, "utf8");
   } catch {
     return null;
   }
@@ -10320,21 +10528,21 @@ function overridePlan(override) {
   };
 }
 function detectPackageManager(worktree, io = {}) {
-  const exists = io.exists ?? existsSync11;
+  const exists = io.exists ?? existsSync12;
   const readText = io.readText ?? safeReadText;
-  const hasPkgJson = exists(join19(worktree, "package.json"));
+  const hasPkgJson = exists(join20(worktree, "package.json"));
   if (!hasPkgJson) {
-    if (exists(join19(worktree, "deno.json")) || exists(join19(worktree, "deno.jsonc")) || exists(join19(worktree, "deno.lock"))) return "deno";
+    if (exists(join20(worktree, "deno.json")) || exists(join20(worktree, "deno.jsonc")) || exists(join20(worktree, "deno.lock"))) return "deno";
     return null;
   }
-  const pkg = readJson(readText, join19(worktree, "package.json"));
+  const pkg = readJson(readText, join20(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(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";
+  if (exists(join20(worktree, "bun.lock")) || exists(join20(worktree, "bun.lockb"))) return "bun";
+  if (exists(join20(worktree, "pnpm-lock.yaml"))) return "pnpm";
+  if (exists(join20(worktree, "yarn.lock"))) return "yarn";
+  if (exists(join20(worktree, "package-lock.json"))) return "npm";
+  if (exists(join20(worktree, "deno.lock"))) return "deno";
   return "npm";
 }
 function jsInstallCommand(pm) {
@@ -10359,7 +10567,10 @@ var ECOSYSTEM_MARKERS = [
     // pyproject сам по себе не говорит, кем ставить — решает лок-файл рядом.
     command: null,
     refine: [
-      { file: "uv.lock", ecosystem: "python/uv", command: "uv sync" },
+      // --frozen: ставим ровно по локу и не переписываем его (TAS-572). Без
+      // флага uv доресолвливает лок под pyproject прямо в worktree дрона, и
+      // чужой дифф на полторы сотни строк уезжает в PR по несвязанной задаче.
+      { file: "uv.lock", ecosystem: "python/uv", command: "uv sync --frozen" },
       { file: "poetry.lock", ecosystem: "python/poetry", command: "poetry install" },
       { file: "requirements.txt", ecosystem: "python/pip", command: "pip install -r requirements.txt" }
     ]
@@ -10387,7 +10598,7 @@ var ECOSYSTEM_MARKERS = [
   // конфигурация — дело сборки, не подготовки
 ];
 function detectPlan(worktree, io) {
-  const exists = io.exists ?? existsSync11;
+  const exists = io.exists ?? existsSync12;
   const listFiles = io.listFiles ?? safeListFiles;
   const pm = detectPackageManager(worktree, io);
   if (pm) {
@@ -10395,7 +10606,7 @@ function detectPlan(worktree, io) {
       // node_modules на месте — установку пропускаем (быстрый путь переиспользованного worktree).
       // У deno каталога может не быть вовсе (кэш в DENO_DIR) — тогда `deno install` отработает
       // заново, но он дешёвый: тянет из того же общего кэша.
-      { label: `${pm} install`, run: jsInstallCommand(pm), skipIfExists: join19(worktree, "node_modules"), source: "detect" }
+      { label: `${pm} install`, run: jsInstallCommand(pm), skipIfExists: join20(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" });
@@ -10404,12 +10615,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(join19(worktree, f))) || marker.ext !== void 0 && listFiles(worktree).some((n) => n.endsWith(marker.ext));
+    const hit = marker.files.some((f) => exists(join20(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(join19(worktree, refine.file))) continue;
+      if (!exists(join20(worktree, refine.file))) continue;
       ecosystem = refine.ecosystem;
       command = refine.command;
       break;
@@ -10466,12 +10677,12 @@ var CI_INSTALL_PATTERNS = [
 function ciWorkflowPlan(worktree, io) {
   const readText = io.readText ?? safeReadText;
   const listFiles = io.listFiles ?? safeListFiles;
-  const dir = join19(worktree, ".github", "workflows");
+  const dir = join20(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(join19(dir, name));
+    const yaml = readText(join20(dir, name));
     if (yaml === null) continue;
     for (const raw of workflowRunLines(yaml)) {
       const line = raw.replace(/\s+/g, " ").trim();
@@ -10486,7 +10697,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(join19(worktree, "pnpm-workspace.yaml"));
+  const yaml = readText(join20(worktree, "pnpm-workspace.yaml"));
   if (yaml !== null) {
     const globs = [];
     let inPackages = false;
@@ -10506,7 +10717,7 @@ function workspaceGlobs(worktree, readText) {
     }
     if (globs.length) return globs;
   }
-  const pkg = readJson(readText, join19(worktree, "package.json"));
+  const pkg = readJson(readText, join20(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");
@@ -10517,14 +10728,14 @@ function workspaceDirs(worktree, globs, io) {
     if (glob.startsWith("!")) continue;
     const star = glob.indexOf("*");
     if (star === -1) {
-      const dir = join19(worktree, glob);
-      if (io.exists(join19(dir, "package.json"))) dirs.add(dir);
+      const dir = join20(worktree, glob);
+      if (io.exists(join20(dir, "package.json"))) dirs.add(dir);
       continue;
     }
-    const base3 = join19(worktree, glob.slice(0, star).replace(/\/$/, ""));
+    const base3 = join20(worktree, glob.slice(0, star).replace(/\/$/, ""));
     for (const name of io.listDirs(base3)) {
-      const dir = join19(base3, name);
-      if (io.exists(join19(dir, "package.json"))) dirs.add(dir);
+      const dir = join20(base3, name);
+      if (io.exists(join20(dir, "package.json"))) dirs.add(dir);
     }
   }
   return [...dirs];
@@ -10545,18 +10756,18 @@ function entryPaths(pkg) {
   return out;
 }
 function workspaceBuildTargets(worktree, io = {}) {
-  const exists = io.exists ?? existsSync11;
+  const exists = io.exists ?? existsSync12;
   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, join19(dir, "package.json"));
+    const pkg = readJson(readText, join20(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(join19(dir, e)));
+    const needsBuild = typeof scripts.build === "string" && entries.length > 0 && entries.some((e) => !exists(join20(dir, e)));
     const deps = Object.keys({ ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} });
     pkgs.push({ name: pkg.name, dir, deps, needsBuild });
   }
@@ -10584,7 +10795,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(join19(worktree, file));
+    const raw = readText(join20(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, "");
@@ -10600,11 +10811,11 @@ function isLocalDatabase(url) {
   }
 }
 function prismaPackages(worktree, io) {
-  const exists = io.exists ?? existsSync11;
+  const exists = io.exists ?? existsSync12;
   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(join19(dir, "prisma", "schema.prisma")) && listDirs(join19(dir, "prisma", "migrations")).length > 0);
+  return dirs.filter((dir) => exists(join20(dir, "prisma", "schema.prisma")) && listDirs(join20(dir, "prisma", "migrations")).length > 0);
 }
 function jsExecBin(pm, command) {
   switch (pm) {
@@ -10637,7 +10848,7 @@ function planPrepare(worktree, io = {}) {
   return { ...plan, commands: plan.commands.slice(0, MAX_PLAN_COMMANDS) };
 }
 async function ensureWorktreeDeps(worktree, io = {}) {
-  const exists = io.exists ?? existsSync11;
+  const exists = io.exists ?? existsSync12;
   const exec = io.exec ?? ((cmd) => runCommand(cmd, worktree));
   const approve = io.approve ?? (() => true);
   const plan = planPrepare(worktree, io);
@@ -10833,6 +11044,10 @@ function isPreStartFailure(run) {
 function isSpawnParked(run) {
   return (run.stop_reason ?? "").includes(SPAWN_PARK_MARK);
 }
+var UNRETRIABLE_PARK_MARK = "\u043F\u043E\u0432\u0442\u043E\u0440 \u043D\u0435 \u043F\u043E\u043C\u043E\u0436\u0435\u0442";
+function isUnretriableParked(run) {
+  return isPreStartFailure(run) && (run.stop_reason ?? "").includes(UNRETRIABLE_PARK_MARK);
+}
 var SPAWN_ATTEMPT_WINDOW_MS = 60 * 6e4;
 function preStartAttempts(runs, taskSlug, opts = {}) {
   const windowMs = opts.windowMs ?? SPAWN_ATTEMPT_WINDOW_MS;
@@ -10846,9 +11061,13 @@ function preStartAttempts(runs, taskSlug, opts = {}) {
     const at = run.created_at ? stampMs(run.created_at) : Number.NaN;
     if (Number.isFinite(at) && now - at >= windowMs) break;
     n += 1;
+    if (isUnretriableParked(run)) return Math.max(n, PRE_START_ATTEMPT_LIMIT);
   }
   return n;
 }
+function lastPreStartAttempt(runs, taskSlug) {
+  return runs.filter((r) => r.task_slug === taskSlug && isPreStartFailure(r)).sort((a, b) => b.id - a.id)[0] ?? null;
+}
 function unresolvedRepoReason(repo, served) {
   const raw = repo.trim();
   if (!raw || raw.startsWith("/") || raw.startsWith("~") || /^[a-z]:[\\/]/i.test(raw)) return null;
@@ -10858,6 +11077,9 @@ function unresolvedRepoReason(repo, served) {
 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}`;
 }
+function parkReasonUnretriable(reason) {
+  return `${PRE_START_MARK}, \u0438 ${UNRETRIABLE_PARK_MARK} \u2014 ${SPAWN_PARK_MARK} \u0441\u0440\u0430\u0437\u0443, \u043D\u0435 \u0442\u0440\u0430\u0442\u044F ${PRE_START_ATTEMPT_LIMIT} \u043F\u043E\u043F\u044B\u0442\u043A\u0438. \u0427\u0435\u0433\u043E \u043D\u0435 \u0445\u0432\u0430\u0442\u0438\u043B\u043E: ${reason}`;
+}
 
 // src/worktreeReap.ts
 init_src();
@@ -11046,7 +11268,7 @@ async function latestVerdictComment(prUrl, sinceIso, run = realCommentsRunner) {
     return APPROVE_RE.test(m[1]) ? "approve" : "changes";
   });
 }
-async function scanPrComments(prUrl, sinceIso, run, pick3) {
+async function scanPrComments(prUrl, sinceIso, run, pick4) {
   if (!isGithubPrUrl(prUrl)) return null;
   let out;
   try {
@@ -11066,7 +11288,7 @@ async function scanPrComments(prUrl, sinceIso, run, pick3) {
     const c = comments[i];
     if (!c?.body || !c.createdAt) continue;
     if (Number.isFinite(sinceMs) && Date.parse(c.createdAt) < sinceMs) continue;
-    const verdict = pick3(c.body);
+    const verdict = pick4(c.body);
     if (verdict == null) continue;
     return { verdict, createdAt: c.createdAt };
   }
@@ -11243,6 +11465,7 @@ ${logs.join("\n---\n")}` : header;
 // src/droneServer.ts
 init_droneChannel();
 init_taskless();
+init_toolFailure();
 init_attachments();
 init_shotUpload();
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -11300,8 +11523,11 @@ init_src();
 
 // src/reviewCycle.ts
 init_src();
+function needsFixIteration(run) {
+  return run.review_verdict === "changes" || isNegativeVerifyVerdict(toVerifyVerdict(run.verify_verdict));
+}
 function reviewTransitionPatch(run, prUrl) {
-  const isFixIteration = run.review_verdict === "changes" || isNegativeVerifyVerdict(toVerifyVerdict(run.verify_verdict));
+  const isFixIteration = needsFixIteration(run);
   if (isFixIteration) {
     const cycle = (run.review_cycle ?? 0) + 1;
     return {
@@ -11336,6 +11562,18 @@ function applyReviewTransition(db, run, prUrl) {
 
 // src/droneServer.ts
 init_src();
+function readTaskFailureInstruction(slug, failure) {
+  const why = describeToolFailure(failure);
+  if (TOOL_FAILURE_RETRIABLE[failure.code]) {
+    return `\u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043F\u0435\u0440\u0435\u0447\u0438\u0442\u0430\u0442\u044C \u0437\u0430\u0434\u0430\u0447\u0443 ${slug}: ${why}. \u042D\u0442\u043E \u0432\u0440\u0435\u043C\u0435\u043D\u043D\u043E \u0438 \u043B\u0435\u0447\u0438\u0442\u0441\u044F \u043F\u043E\u0432\u0442\u043E\u0440\u043E\u043C \u2014 \u0440\u0430\u0431\u043E\u0442\u0430\u0439 \u043F\u043E\u043A\u0430 \u043F\u043E \u0442\u043E\u043C\u0443, \u0447\u0442\u043E \u0443\u0436\u0435 \u0432 \u043F\u0440\u043E\u043C\u043F\u0442\u0435, \u0438 \u043F\u043E\u0437\u043E\u0432\u0438 read_task \u0435\u0449\u0451 \u0440\u0430\u0437 \u043F\u043E\u0437\u0436\u0435 (\u043F\u0435\u0440\u0435\u0434 \u0441\u0434\u0430\u0447\u0435\u0439 \u2014 \u043E\u0431\u044F\u0437\u0430\u0442\u0435\u043B\u044C\u043D\u043E).`;
+  }
+  return [
+    `\u26D4 \u0417\u0410\u0414\u0410\u0427\u0423 ${slug} \u041F\u0420\u041E\u0427\u0418\u0422\u0410\u0422\u042C \u041D\u0415\u041B\u042C\u0417\u042F: ${why}.`,
+    "\u041F\u043E\u0432\u0442\u043E\u0440 \u0442\u0443\u0442 \u043D\u0435 \u043F\u043E\u043C\u043E\u0436\u0435\u0442 \u2014 \u043F\u0440\u0438\u0447\u0438\u043D\u0430 \u043D\u0435 \u0432 \u0441\u0435\u0442\u0438, \u043E\u043D\u0430 \u0441\u0430\u043C\u0430 \u043D\u0435 \u0440\u0430\u0437\u043E\u0439\u0434\u0451\u0442\u0441\u044F.",
+    "\u041D\u0415 \u0440\u0430\u0431\u043E\u0442\u0430\u0439 \u043F\u043E \u0441\u043B\u0430\u0433\u0443 \u0438 \u043F\u043E \u043F\u0430\u043C\u044F\u0442\u0438: \u043F\u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043A\u0430, \u043A\u043E\u0442\u043E\u0440\u043E\u0439 \u0442\u044B \u043D\u0435 \u0432\u0438\u0434\u0435\u043B, \u043D\u0435 \u0432\u043E\u0441\u0441\u0442\u0430\u043D\u0430\u0432\u043B\u0438\u0432\u0430\u0435\u0442\u0441\u044F \u0438\u0437 \u043D\u0430\u0437\u0432\u0430\u043D\u0438\u044F \u0437\u0430\u0434\u0430\u0447\u0438 (TASWM-288).",
+    "\u0421\u043F\u0440\u043E\u0441\u0438 \u043E\u043F\u0435\u0440\u0430\u0442\u043E\u0440\u0430 \u0447\u0435\u0440\u0435\u0437 ask() \u2014 \u043D\u0430\u0437\u043E\u0432\u0438 \u0435\u043C\u0443 \u044D\u0442\u0443 \u043F\u0440\u0438\u0447\u0438\u043D\u0443 \u0434\u043E\u0441\u043B\u043E\u0432\u043D\u043E \u2014 \u0438 \u0434\u0430\u043B\u044C\u0448\u0435 \u0434\u0435\u043B\u0430\u0439 \u0442\u043E, \u0447\u0442\u043E \u043E\u043D \u043E\u0442\u0432\u0435\u0442\u0438\u0442."
+  ].join("\n");
+}
 function freezeInstruction(branch, reason = "\u0435\u0433\u043E \u043F\u0443\u043B\u044C\u0441 (heartbeat) \u0443\u0441\u0442\u0430\u0440\u0435\u043B") {
   return [
     `\u26D4 OVERMIND \u041D\u0415\u0414\u041E\u0421\u0422\u0423\u041F\u0415\u041D \u2014 ${reason}. \u041D\u0430\u0434\u0437\u043E\u0440\u0430 \u043D\u0430\u0434 \u0442\u043E\u0431\u043E\u0439 \u0441\u0435\u0439\u0447\u0430\u0441 \u043D\u0435\u0442: \u043D\u0435\u043A\u043E\u043C\u0443`,
@@ -11433,16 +11671,17 @@ async function buildDroneServer(store, opts = {}) {
         mismatchNote = `\u26A0\uFE0F \u0434\u0435\u043C\u043E\u043D \u0447\u0438\u0441\u043B\u0438\u0442 \u0442\u0432\u043E\u0439 \u043F\u0440\u043E\u0433\u043E\u043D \u043A\u0430\u043A \xAB${run.task_slug}\xBB \u2014 \u044D\u0442\u043E \u041D\u0415 \u0442\u0432\u043E\u044F \u0437\u0430\u0434\u0430\u0447\u0430 (TASWM-211). \u0418\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u043D \u0434\u043E\u0432\u0435\u0440\u0435\u043D\u043D\u044B\u0439 slug \u0438\u0437 \u0441\u043F\u0430\u0432\u043D\u0430.`;
       }
       if (!slug) return { content: [{ type: "text", text: "\u043F\u0440\u043E\u0433\u043E\u043D \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D" }], isError: true };
-      const task = await opts.taskless.getTask(slug);
-      if (!task) {
-        const notFoundText = `\u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043F\u043E\u043B\u0443\u0447\u0438\u0442\u044C \u0437\u0430\u0434\u0430\u0447\u0443 ${slug} \u0438\u0437 Taskless (\u0441\u043C. \u043B\u043E\u0433 \u0434\u0435\u043C\u043E\u043D\u0430) \u2014 \u0440\u0430\u0431\u043E\u0442\u0430\u0439 \u043F\u043E \u0442\u043E\u043C\u0443, \u0447\u0442\u043E \u0443\u0436\u0435 \u0432 \u043F\u0440\u043E\u043C\u043F\u0442\u0435.`;
+      const read = await opts.taskless.getTaskDetailed(slug);
+      if (!read.ok) {
+        const failText = readTaskFailureInstruction(slug, read.failure);
         return {
           content: [{ type: "text", text: mismatchNote ? `${mismatchNote}
 
-${notFoundText}` : notFoundText }],
+${failText}` : failText }],
           isError: true
         };
       }
+      const task = read.task;
       const context = await fetchTaskContext(opts.taskless, task);
       const attachments = await prepareTaskAttachments({
         worktree: opts.worktree ?? process.cwd(),
@@ -12062,8 +12301,9 @@ ${report}${shots.warning}`,
         if (!taskless) return errText2("Taskless \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D (slug-only \u0440\u0435\u0436\u0438\u043C) \u2014 \u0434\u0438\u0441\u043F\u0430\u0442\u0447 \u043D\u0435\u0432\u043E\u0437\u043C\u043E\u0436\u0435\u043D.");
         const hero = await heroRun();
         if (!hero) return errText2("\u0434\u0435\u043C\u043E\u043D \u043D\u0435 \u043E\u0442\u0434\u0430\u043B \u0442\u0432\u043E\u0439 \u043F\u0440\u043E\u0433\u043E\u043D \u2014 \u0434\u0438\u0441\u043F\u0430\u0442\u0447 \u043D\u0435\u0432\u043E\u0437\u043C\u043E\u0436\u0435\u043D, \u043F\u043E\u0432\u0442\u043E\u0440\u0438 \u043F\u043E\u0437\u0436\u0435.");
-        const task = await taskless.getTask(slug);
-        if (!task) return errText2(`\u0437\u0430\u0434\u0430\u0447\u0430 ${slug} \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u0430 \u0432 Taskless.`);
+        const read = await taskless.getTaskDetailed(slug);
+        if (!read.ok) return errText2(`\u043D\u0435 \u0441\u043C\u043E\u0433 \u043F\u043E\u0441\u043C\u043E\u0442\u0440\u0435\u0442\u044C \u0437\u0430\u0434\u0430\u0447\u0443 ${slug}: ${describeToolFailure(read.failure)}.`);
+        const task = read.task;
         const ep = await epic(hero.task_slug);
         if (!ep || task.parentId !== ep.id) {
           return errText2(`${slug} \u2014 \u043D\u0435 \u043F\u043E\u0434\u0437\u0430\u0434\u0430\u0447\u0430 \u0442\u0432\u043E\u0435\u0433\u043E \u044D\u043F\u0438\u043A\u0430 ${hero.task_slug}. \u0414\u0438\u0441\u043F\u0430\u0442\u0447\u0438\u0442\u044C \u043C\u043E\u0436\u043D\u043E \u0442\u043E\u043B\u044C\u043A\u043E \u0441\u0432\u043E\u0438 \u043F\u043E\u0434\u0437\u0430\u0434\u0430\u0447\u0438.`);
@@ -12576,6 +12816,31 @@ function buildAnomalyCandidates(db, now, thresholds, opts) {
       })
     });
   }
+  const GROUP_DEP_UNCONFIRMED = {
+    id: "dep_unconfirmed",
+    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"])} \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u044C, \u043A\u043E\u0442\u043E\u0440\u0443\u044E \u043F\u0440\u043E\u0434 \u043D\u0435 \u043F\u043E\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0430\u0435\u0442`
+  };
+  for (const run of allRuns) {
+    if (run.status !== "queued") continue;
+    if (!run.depends_on || run.depends_on.length === 0) continue;
+    const blind = db.depsUnconfirmed?.(run.depends_on) ?? [];
+    if (!blind.length) continue;
+    candidates.push({
+      key: `dep_unconfirmed:${run.task_slug}`,
+      // по СЛАГУ, а не по id зеркала (см. dep_missing)
+      minDurationMs: thresholds.depMissingMs,
+      group: GROUP_DEP_UNCONFIRMED,
+      build: () => ({
+        runId: run.id,
+        // Пуш: сам рой из этого не выйдет — вердикт приходит только от прода, а прод
+        // отказывает устойчиво. Лечит человек (обновить прод / перевыдать токен демона).
+        level: "decision",
+        title: runTitle(run, "\u0436\u0434\u0451\u0442 \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0438, \u043A\u043E\u0442\u043E\u0440\u0443\u044E \u043F\u0440\u043E\u0434 \u043D\u0435 \u043F\u043E\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0430\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(blind.map((d) => d.slug))}, \u043D\u043E \u043F\u0440\u043E\u0434 \u043D\u0430 swarm_deps_status \u043D\u0435 \u043E\u0442\u0432\u0435\u0447\u0430\u0435\u0442 (${blind[0].attempts} \u043F\u043E\u043F\u044B\u0442(\u043E\u043A), \u043F\u043E\u0441\u043B\u0435\u0434\u043D\u044F\u044F \u043E\u0448\u0438\u0431\u043A\u0430 \u2014 ${blind[0].error}). \u0412\u0435\u0440\u0434\u0438\u043A\u0442\u0430 \u043D\u0435 \u0431\u0443\u0434\u0435\u0442, \u043F\u043E\u043A\u0430 \u044D\u0442\u043E \u043D\u0435 \u043F\u043E\u0447\u0438\u043D\u0438\u0442\u044C: \u043F\u0440\u043E\u0433\u043E\u043D \u0441\u0430\u043C \u043D\u0435 \u043F\u043E\u0435\u0434\u0435\u0442, \u0430 \u043C\u0430\u0448\u0438\u043D\u0430 \u0441\u0432\u043E\u0431\u043E\u0434\u043D\u0430.`,
+        ...hrefOf(run.task_url)
+      })
+    });
+  }
   if (opts.gateReason && queuedCount > 0) {
     const reason = opts.gateReason;
     candidates.push({
@@ -12892,6 +13157,7 @@ function resilientSwarmMcp(opts = {}) {
 
 // src/overmind.ts
 init_taskless();
+init_toolFailure();
 
 // src/workspaceAccess.ts
 function workspaceAccessLines(input) {
@@ -13123,29 +13389,27 @@ function makeDroneCapReader(opts) {
 
 // src/mergeGate.ts
 init_src();
+init_config();
 
 // src/mergeQueue.ts
 init_src();
+init_config();
 
 // src/prNumber.ts
-function prNumberOf(ref) {
-  const s = (ref || "").trim();
-  if (!s) return null;
-  const url = s.match(/\/pull\/(\d+)/);
-  if (url) return Number(url[1]);
-  const bare = s.match(/^#?(\d+)$/);
-  return bare ? Number(bare[1]) : null;
-}
+init_src();
 
 // src/mergeQueue.ts
 var TERMINAL2 = /* @__PURE__ */ new Set(["done", "failed", "stalled", "stopped", "superseded", "returned"]);
 function isMergeCandidate(r) {
-  return !!r.pr_url && r.reviews_run_id == null && r.verifies_run_id == null && r.resolves_run_id == null && !TERMINAL2.has(r.status) && prNumberOf(r.pr_url) != null;
+  return !!r.pr_url && isPrAuthorRun(r) && !TERMINAL2.has(r.status) && prNumberOf(r.pr_url) != null;
+}
+function isPrAuthorRun(r) {
+  return r.reviews_run_id == null && r.verifies_run_id == null && r.resolves_run_id == null;
 }
-function mergeQueueCandidates(runs, repo) {
+function mergeQueueCandidates(runs, repo, repoFallback) {
   const byPr = /* @__PURE__ */ new Map();
   for (const r of runs) {
-    if (r.repo !== repo || !isMergeCandidate(r)) continue;
+    if (effectiveRepoOf(r.repo, repoFallback) !== repo || !isMergeCandidate(r)) continue;
     const num = prNumberOf(r.pr_url);
     const seen = byPr.get(num);
     if (!seen || r.id > seen.id) byPr.set(num, r);
@@ -13175,7 +13439,7 @@ function makeMergeQueueResolver(deps) {
     if (!deps.baseSync || !run.pr_url) return null;
     const num = prNumberOf(run.pr_url);
     if (num == null) return null;
-    const candidates = mergeQueueCandidates(deps.listRuns(), run.repo);
+    const candidates = mergeQueueCandidates(deps.listRuns(), effectiveRepoOf(run.repo, deps.repoFallback), deps.repoFallback);
     const mine = candidates.find((c) => prNumberOf(c.pr_url) === num);
     if (!mine) return null;
     const ready = [];
@@ -13209,15 +13473,16 @@ function needsBaseRefresh(d) {
 }
 
 // src/mergeGate.ts
-function findRunByPr(runs, ref) {
-  const num = prNumberOf(ref);
-  if (num == null) return null;
-  let best = null;
-  for (const r of runs) {
-    if (!r.pr_url || prNumberOf(r.pr_url) !== num) continue;
-    if (!best || r.id > best.id) best = r;
-  }
-  return best;
+function findRunByPr(runs, ref, scope = {}) {
+  const rows = runs.map((run) => ({
+    run,
+    prUrl: run.pr_url,
+    repoKey: scope.repoOfRun ? scope.repoOfRun(run) : null,
+    author: isPrAuthorRun(run),
+    reviewVerdict: run.review_verdict,
+    order: run.id
+  }));
+  return pickRunForPr(rows, ref, scope.repo ?? null)?.run ?? null;
 }
 function makeMergeGateResolver(deps) {
   return makeMergeGateParts(deps).gate;
@@ -13233,15 +13498,17 @@ function makeMergeGateParts(deps) {
       verifyVerdict: run.verify_verdict ?? null
     });
   };
+  const repoOfRun = deps.repoFullNameOf ? (r) => deps.repoFullNameOf(effectiveRepoOf(r.repo, deps.repoFallback)) : void 0;
   const queueFor = makeMergeQueueResolver({
     listRuns: deps.listRuns,
     gateAllows: async (r) => (await gateFor(r)).allowed,
+    ...deps.repoFallback ? { repoFallback: deps.repoFallback } : {},
     ...deps.baseSync ? { baseSync: deps.baseSync } : {},
     ...deps.checks ? { checks: deps.checks } : {},
     ...deps.ttlMs != null ? { ttlMs: deps.ttlMs } : {}
   });
-  const gate = async (ref) => {
-    const run = findRunByPr(deps.listRuns(), ref);
+  const gate = async (ref, ctxRepo) => {
+    const run = findRunByPr(deps.listRuns(), ref, { repo: ctxRepo ?? null, ...repoOfRun ? { repoOfRun } : {} });
     if (!run) {
       return { ...computeMergeDecision(computeMergeGate({ hasRun: false, autoReview: false, reviewVerdict: null }), null), run: null };
     }
@@ -13264,22 +13531,22 @@ function makeMergeGateParts(deps) {
 }
 
 // src/envGate.ts
-import { existsSync as existsSync14 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync15 } from "fs";
+import { join as join26 } from "path";
 import { createConnection } from "net";
 import { execa as execa2 } from "execa";
 
 // src/platform.ts
-import { existsSync as existsSync13, readFileSync as readFileSync17 } from "fs";
-import { delimiter, join as join24 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync18 } from "fs";
+import { delimiter, join as join25 } from "path";
 function resolveCommandPath(name, env = process.env, platform = process.platform) {
-  if (name.includes("/") || name.includes("\\")) return existsSync13(name) ? name : null;
+  if (name.includes("/") || name.includes("\\")) return existsSync14(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 = join24(dir, name + ext);
-      if (existsSync13(candidate)) return candidate;
+      const candidate = join25(dir, name + ext);
+      if (existsSync14(candidate)) return candidate;
     }
   }
   return null;
@@ -13362,8 +13629,8 @@ var COMPOSE_MARKERS = [
   "compose.yaml"
 ];
 function detectRequirements(repo, io = {}) {
-  const exists = io.exists ?? existsSync14;
-  const marker = COMPOSE_MARKERS.find((f) => exists(join25(repo, f)));
+  const exists = io.exists ?? existsSync15;
+  const marker = COMPOSE_MARKERS.find((f) => exists(join26(repo, f)));
   return marker ? [{ kind: "docker", raw: `docker (\u0434\u0435\u0442\u0435\u043A\u0442: ${marker})` }] : [];
 }
 function resolveRequirements(repo, declared, io = {}) {
@@ -13500,7 +13767,7 @@ import { serve as serve2 } from "@hono/node-server";
 
 // src/diff.ts
 import { statSync as statSync10 } from "fs";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 import { $ as $4 } from "execa";
 var MAX_FILES = 200;
 var MAX_LINES_PER_FILE = 1500;
@@ -13668,7 +13935,7 @@ async function collectRunDiff(worktree, opts = {}) {
       files.push(pf);
     }
   }
-  files.sort((a, b) => mtime(join26(worktree, b.path)) - mtime(join26(worktree, a.path)));
+  files.sort((a, b) => mtime(join27(worktree, b.path)) - mtime(join27(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);
@@ -13701,7 +13968,7 @@ async function changedPaths(worktree, opts = {}) {
 // package.json
 var package_default = {
   name: "@taskless-app/swarm",
-  version: "0.6.23",
+  version: "0.6.25",
   type: "module",
   description: "Local control plane for a fleet of AI coding agents (drones), coordinating through Taskless. The overmind runs the swarm.",
   keywords: [
@@ -13731,6 +13998,7 @@ var package_default = {
   files: [
     "dist",
     "docs/HERO.md",
+    "hooks",
     "roles"
   ],
   scripts: {
@@ -13751,7 +14019,7 @@ var package_default = {
     execa: "^10.0.0",
     zod: "3.25.76"
   },
-  gitHead: "af6c4af0f523891b5db805d9b4583021688ed1f5"
+  gitHead: "36aaed0414a46ea272ad762b81e051fecec40eaa"
 };
 
 // src/version.ts
@@ -15199,13 +15467,15 @@ function makeHandler(deps) {
     if (p === "/merge-gate") {
       const ref = url.searchParams.get("pr") ?? "";
       if (!ref.trim()) return Response.json({ error: "\u043D\u0443\u0436\u0435\u043D \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440 pr=<url|\u043D\u043E\u043C\u0435\u0440>" }, { status: 400 });
+      const ctxRepo = url.searchParams.get("repo");
       const resolve4 = deps.mergeGate ?? makeMergeGateResolver({
         listRuns: () => deps.db.listRuns(),
         fallbackAutoReview: SWARM_AUTO_REVIEW,
-        autoVerify: SWARM_AUTO_VERIFY
+        autoVerify: SWARM_AUTO_VERIFY,
         // TASWM-344
+        ...defaultRepo ? { repoFallback: defaultRepo } : {}
       });
-      return Response.json(await resolve4(ref));
+      return Response.json(await resolve4(ref, ctxRepo));
     }
     if (p === "/resources") return Response.json(hostResourceSnapshot());
     if (p === "/timeline") return Response.json(timelineState(deps.db, Date.now(), readNarratorLog(deps.narratorLog)));
@@ -15384,21 +15654,21 @@ async function checkDaemonVersion(start, opts = {}) {
 
 // src/hostCommands.ts
 init_src();
-import { readFileSync as readFileSync18, renameSync as renameSync9, writeFileSync as writeFileSync13 } from "fs";
-import { join as join27 } from "path";
+import { readFileSync as readFileSync19, renameSync as renameSync9, writeFileSync as writeFileSync14 } from "fs";
+import { join as join28 } from "path";
 function hostCommandStatePath(home) {
-  return join27(home, "host-command.json");
+  return join28(home, "host-command.json");
 }
 function readState(path) {
   try {
-    return JSON.parse(readFileSync18(path, "utf8"));
+    return JSON.parse(readFileSync19(path, "utf8"));
   } catch {
     return {};
   }
 }
 function writeState(path, state) {
   try {
-    writeFileSync13(`${path}.tmp`, JSON.stringify(state));
+    writeFileSync14(`${path}.tmp`, JSON.stringify(state));
     renameSync9(`${path}.tmp`, path);
   } catch {
   }
@@ -15561,8 +15831,8 @@ async function doRestart(cmd, opts, note) {
 
 // src/selfUpdate.ts
 init_git();
-import { existsSync as existsSync15 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync16 } from "fs";
+import { join as join29 } from "path";
 import { $ as $5 } from "execa";
 var DAEMON_PACKAGE = "@taskless-app/swarm";
 var defaultRun = async (cmd, args, cwd) => {
@@ -15575,7 +15845,7 @@ function tail(text, max = 400) {
 }
 async function runSelfUpdate(io) {
   const run = io.run ?? defaultRun;
-  const exists = io.exists ?? existsSync15;
+  const exists = io.exists ?? existsSync16;
   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);
@@ -15604,7 +15874,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(join28(repo, "pnpm-lock.yaml"))) {
+  if (!exists(join29(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 installed2 = await run("pnpm", ["install", "--frozen-lockfile"], repo);
@@ -15763,19 +16033,19 @@ async function fetchExternalStorm(url, opts = {}) {
 }
 
 // src/anomalyState.ts
-import { existsSync as existsSync16, readFileSync as readFileSync19, renameSync as renameSync10, writeFileSync as writeFileSync14 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync20, renameSync as renameSync10, writeFileSync as writeFileSync15 } from "fs";
+import { join as join30 } 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 join29(home, "anomaly-state.json");
+  return join30(home, "anomaly-state.json");
 }
 function loadAnomalyState(home, now = Date.now(), io = {}) {
-  const exists = io.exists ?? existsSync16;
-  const readFile2 = io.readFile ?? ((p) => readFileSync19(p, "utf8"));
+  const exists = io.exists ?? existsSync17;
+  const readFile2 = io.readFile ?? ((p) => readFileSync20(p, "utf8"));
   const path = anomalyStatePath(home);
   if (!exists(path)) return emptyState();
   try {
@@ -15789,9 +16059,9 @@ function loadAnomalyState(home, now = Date.now(), io = {}) {
       )
     );
     return {
-      since: pick2(since, fresh),
-      lastFiredAt: pick2(lastFiredAt, fresh),
-      fires: pick2(fires, fresh),
+      since: pick3(since, fresh),
+      lastFiredAt: pick3(lastFiredAt, fresh),
+      fires: pick3(fires, fresh),
       // TAS-485: очередь гашения НЕ фильтруем тем же TTL, что ключи. Она про
       // уведомление, которое УЖЕ висит у человека в инбоксе: пролежав неделю
       // недоставленным, гашение не становится лишним — оно становится нужнее.
@@ -15805,7 +16075,7 @@ function loadAnomalyState(home, now = Date.now(), io = {}) {
 function saveAnomalyState(home, state, io = {}) {
   const path = anomalyStatePath(home);
   const writeFile3 = io.writeFile ?? ((p, data) => {
-    writeFileSync14(`${p}.tmp`, data);
+    writeFileSync15(`${p}.tmp`, data);
     renameSync10(`${p}.tmp`, p);
   });
   writeFile3(path, JSON.stringify(state, null, 2));
@@ -15875,7 +16145,7 @@ function strings(raw) {
   if (!Array.isArray(raw)) return [];
   return raw.filter((v) => typeof v === "string" && v.length > 0);
 }
-function pick2(src, keys) {
+function pick3(src, keys) {
   const out = {};
   for (const k of keys) if (src[k] != null) out[k] = src[k];
   return out;
@@ -16227,7 +16497,7 @@ function withManualAreas(history, areas) {
 
 // src/overmind.ts
 var ANOMALY_RESOLVE_BATCH = 50;
-var THIS_FILE = fileURLToPath2(import.meta.url);
+var THIS_FILE = fileURLToPath3(import.meta.url);
 var executorHasSession = (p) => EXECUTOR.session.exists(p);
 var OVERMIND_ENTRY = THIS_FILE;
 var STALL_MS = Number(process.env.SWARM_STALL_MS) || 10 * 60 * 1e3;
@@ -16890,10 +17160,10 @@ ${task.description}` : `\u0417\u0430\u0434\u0430\u0447\u0430 ${run.task_slug} (\
   }
   return parts.join("\n");
 }
-var HERO_CHARTER_PATH = join30(dirname4(THIS_FILE), "..", "docs", "HERO.md");
+var HERO_CHARTER_PATH = join31(dirname5(THIS_FILE), "..", "docs", "HERO.md");
 function buildHeroPrompt(task, run, taskContext, attachmentsBlock) {
   const name = run.name || `#${run.id}`;
-  const charter = readFileSync20(HERO_CHARTER_PATH, "utf8");
+  const charter = readFileSync21(HERO_CHARTER_PATH, "utf8");
   const head = task ? `\u042D\u041F\u0418\u041A ${run.task_slug}: ${task.title}
 
 ${task.description}` : `\u042D\u041F\u0418\u041A ${run.task_slug} (\u0442\u0435\u043B\u043E \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u043D\u043E \u2014 \u0440\u0430\u0431\u043E\u0442\u0430\u0439 \u043F\u043E slug \u0438 \u0437\u0434\u0440\u0430\u0432\u043E\u043C\u0443 \u0441\u043C\u044B\u0441\u043B\u0443).`;
@@ -16936,7 +17206,7 @@ function buildResolverPrompt(reviewRun, resolver, conflicts, branch, mainRef) {
     `1. \u0420\u0430\u0437\u0440\u0435\u0448\u0438 \u043C\u0430\u0440\u043A\u0435\u0440\u044B \u0432\u043E \u0432\u0441\u0435\u0445 \u043A\u043E\u043D\u0444\u043B\u0438\u043A\u0442\u0443\u044E\u0449\u0438\u0445 \u0444\u0430\u0439\u043B\u0430\u0445 (${files}); \`git status\` \u043F\u043E\u043A\u0430\u0436\u0435\u0442, \u0435\u0441\u043B\u0438 \u043E\u0441\u0442\u0430\u043B\u043E\u0441\u044C.`,
     "2. `git add -A && git commit --no-edit` \u2014 \u0437\u0430\u0432\u0435\u0440\u0448\u0438 merge-\u043A\u043E\u043C\u043C\u0438\u0442 (\u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0435 \u043F\u043E \u0443\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E \u043E\u0441\u0442\u0430\u0432\u044C).",
     "3. \u041F\u0440\u043E\u0433\u043E\u043D\u0438 \u043F\u0440\u043E\u0432\u0435\u0440\u043A\u0438 \u043F\u0440\u043E\u0435\u043A\u0442\u0430 \u043A\u0430\u043A \u0432 CI (\u0437\u0430\u0433\u043B\u044F\u043D\u0438 \u0432 .github/workflows \u0438 package.json \u0440\u0435\u043F\u043E \u2014 \u0442\u0435\u0441\u0442\u044B/\u0442\u0438\u043F\u044B/\u0441\u0431\u043E\u0440\u043A\u0430/\u043B\u0438\u043D\u0442) \u0438 \u0443\u0431\u0435\u0434\u0438\u0441\u044C, \u0447\u0442\u043E \u0437\u0435\u043B\u0435\u043D\u043E. \u041A\u0440\u0430\u0441\u043D\u043E\u0435 \u2014 \u043F\u043E\u0447\u0438\u043D\u0438 \u0440\u0430\u0437\u0440\u0435\u0448\u0435\u043D\u0438\u0435, \u043D\u0435 \u0441\u0430\u043C\u0443 \u0444\u0438\u0447\u0443.",
-    `4. \`git push origin HEAD:${branch}\` \u2014 \u041E\u0411\u042B\u0427\u041D\u042B\u0419 push (\u044D\u0442\u043E fast-forward). \`--force\`/\`--force-with-lease\` \u041D\u0415 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439: \u0440\u0438\u0431\u0435\u0439\u0437/\u043F\u0435\u0440\u0435\u0437\u0430\u043F\u0438\u0441\u044C \u0438\u0441\u0442\u043E\u0440\u0438\u0438 \u0442\u0443\u0442 \u0437\u0430\u043F\u0440\u0435\u0449\u0435\u043D\u044B \u0438 \u0433\u0435\u0439\u0442\u044F\u0442\u0441\u044F.`,
+    `4. \`git push origin HEAD:refs/heads/${branch}\` \u2014 \u041E\u0411\u042B\u0427\u041D\u042B\u0419 push (\u044D\u0442\u043E fast-forward), \u043F\u043E\u043B\u043D\u044B\u0439 refspec (\u043D\u0435 \u0433\u043E\u043B\u043E\u0435 \`HEAD:${branch}\` \u2014 git \u043E\u0442\u043A\u0430\u0436\u0435\u0442\u0441\u044F \u0443\u0433\u0430\u0434\u044B\u0432\u0430\u0442\u044C, \u0435\u0441\u043B\u0438 \u0432\u0435\u0442\u043A\u0443 \u0442\u0435\u043C \u0432\u0440\u0435\u043C\u0435\u043D\u0435\u043C \u0443\u0434\u0430\u043B\u0438\u043B\u0438). \`--force\`/\`--force-with-lease\` \u041D\u0415 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439: \u0440\u0438\u0431\u0435\u0439\u0437/\u043F\u0435\u0440\u0435\u0437\u0430\u043F\u0438\u0441\u044C \u0438\u0441\u0442\u043E\u0440\u0438\u0438 \u0442\u0443\u0442 \u0437\u0430\u043F\u0440\u0435\u0449\u0435\u043D\u044B \u0438 \u0433\u0435\u0439\u0442\u044F\u0442\u0441\u044F.`,
     `5. \u0412\u044B\u0437\u043E\u0432\u0438 done(${prUrl}) \u2014 \u0440\u043E\u0439 \u043F\u043E\u0434\u0445\u0432\u0430\u0442\u0438\u0442, \u0447\u0442\u043E \u043A\u043E\u043D\u0444\u043B\u0438\u043A\u0442 \u0440\u0430\u0437\u0440\u0435\u0448\u0451\u043D \u0438 PR \u043E\u0431\u043D\u043E\u0432\u043B\u0451\u043D.`,
     "",
     `\u0412 \u043A\u0430\u0436\u0434\u044B\u0439 \u043A\u043E\u043C\u043C\u0438\u0442 \u0434\u043E\u0431\u0430\u0432\u043B\u044F\u0439 \u0442\u0440\u0435\u0439\u043B\u0435\u0440-\u0441\u0442\u0440\u043E\u043A\u0443 \xABDrone: ${name} \xB7 resolver run #${resolver.id}\xBB. \u041A\u043E\u043C\u043C\u0438\u0442\u044C \u0438 \u043F\u0443\u0448\u044C \u0440\u0435\u0437\u0443\u043B\u044C\u0442\u0430\u0442 \u2014 \u043D\u0435\u0437\u0430\u043F\u0443\u0448\u0435\u043D\u043D\u043E\u0435 \u0443\u043C\u0440\u0451\u0442 \u0432\u043C\u0435\u0441\u0442\u0435 \u0441 \u0434\u0440\u043E\u043D\u043E\u043C. \u0414\u043E\u043B\u0433\u043E\u0435 (\u0442\u0435\u0441\u0442\u044B) \u0434\u0435\u0440\u0436\u0438 \u0431\u043B\u043E\u043A\u0438\u0440\u0443\u044E\u0449\u0438\u043C \u0432\u044B\u0437\u043E\u0432\u043E\u043C, \u043D\u0435 \u0432 \u0444\u043E\u043D\u0435.`
@@ -17197,7 +17467,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 ?? existsSync17;
+  const worktreeExists = deps.worktreeExists ?? existsSync18;
   const hasTranscript = deps.hasTranscript ?? executorHasSession;
   const wt = run.worktree_path;
   const canContinue = !!wt && worktreeExists(wt) && hasTranscript(wt);
@@ -17303,7 +17573,7 @@ function repoHasCi(deps, run) {
 function repoHasCiWorkflows(worktreePath, repo) {
   for (const base3 of [worktreePath, repo]) {
     if (!base3) continue;
-    const dir = join30(base3, ".github", "workflows");
+    const dir = join31(base3, ".github", "workflows");
     try {
       if (readdirSync13(dir).some((f) => f.endsWith(".yml") || f.endsWith(".yaml"))) return true;
     } catch {
@@ -17489,7 +17759,7 @@ async function wakeReviewerOnCiReady(deps, run, over) {
   return true;
 }
 function worktreeAndTranscriptAlive(deps, worktree) {
-  const exists = deps.worktreeExists ?? existsSync17;
+  const exists = deps.worktreeExists ?? existsSync18;
   const transcript = deps.hasTranscript ?? executorHasSession;
   return exists(worktree) && transcript(worktree);
 }
@@ -17523,7 +17793,9 @@ async function spawnFreshReviewerAfterStall(deps, run, why) {
 async function wakeAuthorOnChanges(deps, run, now, droneCap) {
   if (!deps.respawn) return false;
   if (run.pid != null && deps.isAlive(run.pid)) return false;
-  if (deps.db.activeReviewersFor(run.id).some((r) => r.status !== "stalled")) return false;
+  if (deps.db.activeReviewersFor(run.id).some((r) => r.status !== "stalled" && !isAwaitingCi(r.status, r.stop_reason))) {
+    return false;
+  }
   if (deps.resourcesOk && !deps.resourcesOk()) return false;
   if (countActiveDrones(deps.db) >= droneCap) return false;
   if (!await projectQuotaGateAllows(deps, run)) return false;
@@ -17638,7 +17910,7 @@ async function envGateAllows(deps, run) {
   return true;
 }
 function effectiveRepo(deps, run) {
-  return normalizeRepo(run.repo || deps.repoFallback || "");
+  return effectiveRepoOf(run.repo, deps.repoFallback);
 }
 async function zoneConflictFor(db, models, activeFiles, run, repo, repoFallback) {
   const model = await models.forRepo(repo);
@@ -17797,7 +18069,8 @@ 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)`;
+    const last = lastPreStartAttempt(deps.db.listRuns(), run.task_slug);
+    const why = last && isUnretriableParked(last) ? `${SPAWN_PARK_MARK}: \u043F\u0440\u0438\u0447\u0438\u043D\u0430 \u043E\u0442\u043A\u0430\u0437\u0430 \u043F\u043E\u0432\u0442\u043E\u0440\u043E\u043C \u043D\u0435 \u043B\u0435\u0447\u0438\u0442\u0441\u044F, \u043D\u043E\u0432\u043E\u0433\u043E \u0437\u0430\u0445\u043E\u0434\u0430 \u043D\u0435 \u0434\u0435\u043B\u0430\u044E (TASWM-485). \u0427\u0435\u043C \u043A\u043E\u043D\u0447\u0438\u043B\u043E\u0441\u044C \u2014 \u0432 \u043F\u0440\u043E\u0433\u043E\u043D\u0435 #${last.id}` : `${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);
@@ -17816,7 +18089,8 @@ async function trySpawnQueuedRun(deps, run) {
   const unmet = depVerdicts.filter((d) => !d.met);
   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(", ")}`;
+    const blind = deps.db.depsUnconfirmed?.(run.depends_on) ?? [];
+    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)` : blind.length ? `\u0436\u0434\u0451\u0442 \u0437\u0430\u0432\u0438\u0441\u0438\u043C\u043E\u0441\u0442\u0438 ${blind.map((d) => d.slug).join(", ")}, \u043D\u043E \u041F\u0420\u041E\u0414 \u0415\u0401 \u041D\u0415 \u041F\u041E\u0414\u0422\u0412\u0415\u0420\u0416\u0414\u0410\u0415\u0422: ${blind[0].attempts} \u043F\u043E\u043F\u044B\u0442(\u043E\u043A) swarm_deps_status, \u043F\u043E\u0441\u043B\u0435\u0434\u043D\u044F\u044F \u043E\u0448\u0438\u0431\u043A\u0430 \u2014 ${blind[0].error}. \u041F\u043E\u043A\u0430 \u043F\u0440\u043E\u0434 \u043C\u043E\u043B\u0447\u0438\u0442, \u0432\u0435\u0440\u0434\u0438\u043A\u0442\u0430 \u043D\u0435 \u0431\u0443\u0434\u0435\u0442 \u0438 \u043F\u0440\u043E\u0433\u043E\u043D \u0441\u0430\u043C \u043D\u0435 \u043F\u043E\u0435\u0434\u0435\u0442 (TASWM-486)` : `\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";
@@ -17853,10 +18127,10 @@ async function trySpawnQueuedRun(deps, run) {
         narrate(deps, `\u0411\u0435\u0440\u0443 ${run.task_slug} \u0438\u0437 \u043E\u0447\u0435\u0440\u0435\u0434\u0438 \u2014 \u0441\u043F\u0430\u0432\u043D\u044E ${droneLabel(run)} (\u043F\u0440\u0438\u0431\u0440\u0430\u043B \u0437\u0430 \u043C\u0451\u0440\u0442\u0432\u043E\u0439 \u0441\u0435\u0441\u0441\u0438\u0435\u0439).`);
         return "spawned";
       } catch (again) {
-        return await failBeforeStart(deps, run, String(again));
+        return await failBeforeStart(deps, run, String(again), spawnRetryOpts(again));
       }
     }
-    return await failBeforeStart(deps, run, String(e));
+    return await failBeforeStart(deps, run, String(e), spawnRetryOpts(e));
   }
 }
 function holderStillHolds(deps, holder, now) {
@@ -17887,15 +18161,19 @@ async function healBusyWorktree(deps, run, e) {
   if (holder) deps.db.addEvent(holder.id, "step", `worktree ${path} \u043E\u0441\u0432\u043E\u0431\u043E\u0436\u0434\u0451\u043D: ${why}, \u0441\u043B\u0430\u0433 \u043F\u043E\u043D\u0430\u0434\u043E\u0431\u0438\u043B\u0441\u044F \u043F\u0440\u043E\u0433\u043E\u043D\u0443 #${run.id}`);
   return true;
 }
-async function failBeforeStart(deps, run, reason) {
+function spawnRetryOpts(e) {
+  if (!(e instanceof TaskBodyUnavailableError)) return {};
+  return { retriable: TOOL_FAILURE_RETRIABLE[e.code] };
+}
+async function failBeforeStart(deps, run, reason, opts = {}) {
   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) {
+  if (opts.retriable !== false && 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);
+  const parked = opts.retriable === false ? parkReasonUnretriable(reason) : parkReason(attempts, reason);
   deps.db.updateRun(run.id, { stop_reason: parked });
   deps.db.addEvent(run.id, "step", parked);
   narrate(deps, `${run.task_slug}: ${parked}`);
@@ -17931,7 +18209,7 @@ async function resumeWatchdogParked(deps, droneCap) {
   }
   if (!candidate) return;
   if (candidate.pid != null && deps.isAlive(candidate.pid)) return;
-  const worktreeExists = deps.worktreeExists ?? existsSync17;
+  const worktreeExists = deps.worktreeExists ?? existsSync18;
   const hasTranscript = deps.hasTranscript ?? executorHasSession;
   const wt = candidate.worktree_path;
   const canContinue = !!wt && worktreeExists(wt) && hasTranscript(wt);
@@ -18100,7 +18378,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 ?? existsSync17;
+    const worktreeExists = deps.worktreeExists ?? existsSync18;
     const hasTranscript = deps.hasTranscript ?? executorHasSession;
     const canContinue = !!wt && worktreeExists(wt) && hasTranscript(wt);
     const mode = canContinue ? "continue" : "fresh";
@@ -18378,7 +18656,7 @@ function buildEscalationCandidates(db) {
 }
 async function tickOnce(deps) {
   const now = deps.now ? deps.now() : Date.now();
-  const worktreeExists = deps.worktreeExists ?? existsSync17;
+  const worktreeExists = deps.worktreeExists ?? existsSync18;
   const hasTranscript = deps.hasTranscript ?? executorHasSession;
   deps.sampleHost?.();
   if (deps.rehydrate) {
@@ -18632,7 +18910,7 @@ async function tickOnce(deps) {
       } else if (!st.conflicting && deps.ci && deps.respawn && !stormActive) {
         await handleCi(deps, run, now, worktreeExists, hasTranscript, droneCap);
       }
-      if ((run.review_verdict === "changes" || isNegativeVerifyVerdict(toVerifyVerdict(run.verify_verdict))) && !stormActive && !st.conflicting && !deps.db.activeResolverFor(run.id) && await wakeAuthorOnChanges(deps, run, now, droneCap)) {
+      if (needsFixIteration(run) && !stormActive && !st.conflicting && !deps.db.activeResolverFor(run.id) && await wakeAuthorOnChanges(deps, run, now, droneCap)) {
         continue;
       }
       const reviewerGatesOk = !st.conflicting && !st.isDraft && !!deps.spawnReviewer && !stormActive && (!deps.reviewCutoffAt || run.updated_at >= deps.reviewCutoffAt) && deps.db.reviewerCountFor(run.id) === 0 && // ГЕЙТ ПЕРВЫМ: живой/успешный ревьюер уже есть — ни капа, ни спавна не трогаем
@@ -19140,7 +19418,7 @@ async function resolveConflict(deps, reviewRun) {
     model: reviewRun.model,
     review_model: reviewRun.review_model
   });
-  const wt = join30(deps.worktreesDir, basename6(repo), `${reviewRun.task_slug}-resolve-${resolver.id}`);
+  const wt = join31(deps.worktreesDir, basename6(repo), `${reviewRun.task_slug}-resolve-${resolver.id}`);
   try {
     await deps.git.prepareDetachedWorktree(repo, branch, wt);
     await deps.git.setWorktreeIdentity(wt, resolver.name);
@@ -19175,6 +19453,28 @@ async function resolveConflict(deps, reviewRun) {
     throw e;
   }
 }
+function makeCheckerAttachmentsReader(tl) {
+  return async (slug, worktree, workspaceId, onEvent) => {
+    const client = tl.forWorkspace(workspaceId);
+    const read = await client.getTaskDetailed(slug);
+    if (!read.ok) {
+      const why = `\u0432\u043B\u043E\u0436\u0435\u043D\u0438\u044F \u0437\u0430\u0434\u0430\u0447\u0438 ${slug} \u043D\u0435 \u0447\u0438\u0442\u0430\u044E\u0442\u0441\u044F: ${describeToolFailure(read.failure)}`;
+      onEvent?.(`${why} \u2014 \u043F\u0440\u043E\u0432\u0435\u0440\u043A\u0430 \u0438\u0434\u0451\u0442 \u0411\u0415\u0417 \u043C\u0430\u043A\u0435\u0442\u043E\u0432 \u0438 \u0444\u0430\u0439\u043B\u043E\u0432 \u0437\u0430\u0434\u0430\u0447\u0438`);
+      return [
+        `\u26A0\uFE0F \u0412\u041B\u041E\u0416\u0415\u041D\u0418\u042F \u0417\u0410\u0414\u0410\u0427\u0418 \u041D\u0415\u0414\u041E\u0421\u0422\u0423\u041F\u041D\u042B: ${why}.`,
+        "\u041C\u0430\u043A\u0435\u0442\u044B \u0438 \u0444\u0430\u0439\u043B\u044B \u0437\u0430\u0434\u0430\u0447\u0438 \u0442\u044B \u041D\u0415 \u0432\u0438\u0434\u0435\u043B \u2014 \u0438\u0445 \u043C\u043E\u0433\u043B\u043E \u043D\u0435 \u0431\u044B\u0442\u044C \u0432\u043E\u0432\u0441\u0435, \u0430 \u043C\u043E\u0433\u043B\u043E \u0431\u044B\u0442\u044C \u0441\u043A\u043E\u043B\u044C\u043A\u043E \u0443\u0433\u043E\u0434\u043D\u043E.",
+        "\u041F\u0443\u043D\u043A\u0442\u044B \u0432\u0438\u0434\u0430 \xAB\u0441\u0434\u0435\u043B\u0430\u043D\u043E \u043B\u0438 \u043A\u0430\u043A \u043D\u0430 \u043C\u0430\u043A\u0435\u0442\u0435\xBB \u043F\u0440\u043E\u0432\u0435\u0440\u0438\u0442\u044C \u043D\u0435\u0447\u0435\u043C: \u0442\u0430\u043A \u0438 \u043D\u0430\u043F\u0438\u0448\u0438 \u0432 \u0432\u0435\u0440\u0434\u0438\u043A\u0442\u0435, \u0430 \u043D\u0435 \u0441\u0443\u0434\u0438 \u043F\u043E \u043A\u043E\u0434\u0443."
+      ].join("\n");
+    }
+    return prepareTaskAttachments({
+      worktree,
+      refs: read.task.attachments,
+      fetchFile: client.fetchFile.bind(client),
+      // Выложенное и пропущенное — тоже в ленту проверяющего, как у исполнителя (respawnRun).
+      ...onEvent ? { onEvent } : {}
+    });
+  };
+}
 async function spawnReviewer(deps, reviewRun, files) {
   const repo = normalizeRepo(reviewRun.repo || deps.repoFallback);
   const branch = await worktreeBranchFor(reviewRun, deps.prHeadBranch);
@@ -19197,11 +19497,16 @@ async function spawnReviewer(deps, reviewRun, files) {
     // (своей у ревьюера нет, TASWM-204), и коммент с вердиктом должен уехать именно туда.
     workspace_id: reviewRun.workspace_id
   });
-  const wt = join30(deps.worktreesDir, basename6(repo), `${reviewRun.task_slug}-review-${reviewer.id}`);
+  const wt = join31(deps.worktreesDir, basename6(repo), `${reviewRun.task_slug}-review-${reviewer.id}`);
   try {
     await deps.git.prepareDetachedWorktree(repo, branch, wt);
     await deps.git.setWorktreeIdentity(wt, reviewer.name);
-    const attachments = await deps.taskAttachments?.(reviewRun.task_slug, wt, reviewRun.workspace_id);
+    const attachments = await deps.taskAttachments?.(
+      reviewRun.task_slug,
+      wt,
+      reviewRun.workspace_id,
+      (text) => deps.db.addEvent(reviewer.id, "step", text)
+    );
     const pendingRules = await deps.pendingRepoRules?.(repo, reviewRun.task_slug).catch(() => []) ?? [];
     const prompt = buildReviewerPrompt(reviewRun, reviewer, checklist, branch, attachments, verifyMode, pendingRules);
     const pid = deps.launch({ worktree: wt, run: reviewer, prompt });
@@ -19273,11 +19578,16 @@ async function spawnVerifier(deps, verifiedRun, files) {
     // штамп цикла: фикс-итерацию проверяет свежий верификатор
     workspace_id: verifiedRun.workspace_id
   });
-  const wt = join30(deps.worktreesDir, basename6(repo), `${verifiedRun.task_slug}-verify-${verifier.id}`);
+  const wt = join31(deps.worktreesDir, basename6(repo), `${verifiedRun.task_slug}-verify-${verifier.id}`);
   try {
     await deps.git.prepareDetachedWorktree(repo, branch, wt);
     await deps.git.setWorktreeIdentity(wt, verifier.name);
-    const attachments = await deps.taskAttachments?.(verifiedRun.task_slug, wt, verifiedRun.workspace_id);
+    const attachments = await deps.taskAttachments?.(
+      verifiedRun.task_slug,
+      wt,
+      verifiedRun.workspace_id,
+      (text) => deps.db.addEvent(verifier.id, "step", text)
+    );
     const prompt = buildVerifierPrompt(verifiedRun, verifier, branch, files, attachments, verifyMode);
     const pid = deps.launch({ worktree: wt, run: verifier, prompt });
     deps.db.updateRun(verifier.id, { status: "running", worktree_path: wt, branch, pid, pr_url: verifiedRun.pr_url });
@@ -19314,7 +19624,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 (!existsSync17(wt)) {
+  if (!existsSync18(wt)) {
     const branch = runToSpawn.branch || runToSpawn.task_slug;
     const source = await addWorktree(repo, wt, branch, {
       ...base3 ? { base: await remoteBaseRef(repo, base3) } : {},
@@ -19341,7 +19651,7 @@ async function respawnRun(deps, run, mode, nudge) {
   deps.db.updateRun(run.id, { status: "running", pid });
 }
 async function syncCrashedOnStartup(deps) {
-  const worktreeExists = deps.worktreeExists ?? existsSync17;
+  const worktreeExists = deps.worktreeExists ?? existsSync18;
   let orphaned = 0;
   let merged = 0;
   let requeued = 0;
@@ -19404,7 +19714,7 @@ async function makeStore(repo, worktreesDir, repoFlag) {
       console.warn(`[overmind] \u043D\u0435 \u0441\u043C\u043E\u0433 \u0437\u0430\u043F\u043E\u043C\u043D\u0438\u0442\u044C \u043F\u0443\u0442\u044C \u043A \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u044E (${e instanceof Error ? e.message : e}) \u2014 \u0441\u043B\u0435\u0434\u0443\u044E\u0449\u0438\u0439 \u0437\u0430\u043F\u0443\u0441\u043A \u0441\u043D\u043E\u0432\u0430 \u043F\u043E\u043F\u0440\u043E\u0441\u0438\u0442 --repo`);
     }
   }
-  const scanRootsList = resolveScanRoots(SWARM_SCAN_ROOTS_RAW, homedir5(), repoPaths);
+  const scanRootsList = resolveScanRoots(SWARM_SCAN_ROOTS_RAW, homedir6(), repoPaths);
   const repoMap = emptyRepoMapState(scanRootsList);
   if (SWARM_BACKEND !== "client") {
     const { SwarmDb: SwarmDb2 } = await loadSqlite();
@@ -19471,7 +19781,11 @@ async function makeStore(repo, worktreesDir, repoFlag) {
     // TASWM-422: что машина обслуживает ПРЯМО СЕЙЧАС — читается из ЖИВОГО реестра (он
     // пересобирается тиком выше), чтобы причина «клона нет на этой машине» называла
     // актуальный список, а не снимок на старте демона.
-    reposServed: () => repoRegistry.map((e) => e.repoFullName)
+    reposServed: () => repoRegistry.map((e) => e.repoFullName),
+    // TASWM-492: обратная сторона того же реестра — путь прогона в owner/repo. Читаем из
+    // живого `repoRegistry` (не из снимка на старте): репозиторий могли клонировать уже
+    // после запуска демона, и гейт мержа не должен считать его прогон «неопознанным».
+    repoFullNameOf: (repoPath) => repoRegistry.find((e) => e.path === repoPath)?.repoFullName ?? null
   };
 }
 var crashGuardsInstalled = false;
@@ -19491,7 +19805,7 @@ async function migrateWorktreesAtStartup() {
       legacyDir: WORKTREES_LEGACY_DIR,
       targetDir: WORKTREES_DIR,
       envOverride: process.env.SWARM_WORKTREES || "",
-      exists: (d) => existsSync17(d),
+      exists: (d) => existsSync18(d),
       isNonEmptyDir: (d) => {
         try {
           return readdirSync13(d).length > 0;
@@ -19506,7 +19820,7 @@ async function migrateWorktreesAtStartup() {
     });
   } 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 existsSync17(WORKTREES_DIR) ? WORKTREES_DIR : WORKTREES_LEGACY_DIR;
+    return existsSync18(WORKTREES_DIR) ? WORKTREES_DIR : WORKTREES_LEGACY_DIR;
   }
 }
 async function reportWorkspaceAccess(tl, db) {
@@ -19547,7 +19861,8 @@ async function runDaemon(opts) {
     repoMap: repoMapState,
     refreshRepoMap: rebuildRepoMap,
     prodMcp,
-    reposServed
+    reposServed,
+    repoFullNameOf
   } = await makeStore(opts.repo, worktreesDir, opts.repoFlag);
   await preflightAuth();
   const outdated = outdatedLine(PACKAGE_VERSION, await latestRelease);
@@ -19869,6 +20184,7 @@ async function runDaemon(opts) {
       ttlMs: 6e4
     });
   }
+  const checkerAttachments = tl?.fetchFile ? makeCheckerAttachmentsReader(tl) : void 0;
   let spawnReviewerFn;
   let verdictCommentFn;
   let reviewCutoffAtValue;
@@ -19892,20 +20208,10 @@ async function runDaemon(opts) {
         ...pendingRepoRules ? { pendingRepoRules } : {},
         // TASWM-283: те же вложения задачи, что у исполнителя — ревьюер без макета
         // не может проверить «сделано ли как просили».
-        ...tl?.fetchFile ? {
-          // TASWM-288: вложения читаем клиентом ВОРКСПЕЙСА проверяемого прогона —
-          // иначе ревьюер задачи из чужого воркспейса остался бы без макетов
-          // («сделано ли как просили» проверять нечем), как и исполнитель до фикса.
-          taskAttachments: async (slug, worktree, workspaceId) => {
-            const client = tl.forWorkspace(workspaceId);
-            const task = await client.getTask(slug);
-            return prepareTaskAttachments({
-              worktree,
-              refs: task?.attachments,
-              fetchFile: client.fetchFile.bind(client)
-            });
-          }
-        } : {}
+        // TASWM-288: вложения читаем клиентом ВОРКСПЕЙСА проверяемого прогона — иначе
+        // ревьюер задачи из чужого воркспейса остался бы без макетов («сделано ли как
+        // просили» проверять нечем), как и исполнитель до фикса.
+        ...checkerAttachments ? { taskAttachments: checkerAttachments } : {}
       },
       reviewRun,
       files
@@ -19927,17 +20233,7 @@ async function runDaemon(opts) {
         git: { prepareDetachedWorktree, setWorktreeIdentity, removeWorktree },
         prHeadBranch,
         ...verifyModeReader ? { verifyMode: verifyModeReader } : {},
-        ...tl?.fetchFile ? {
-          taskAttachments: async (slug, worktree, workspaceId) => {
-            const client = tl.forWorkspace(workspaceId);
-            const task = await client.getTask(slug);
-            return prepareTaskAttachments({
-              worktree,
-              refs: task?.attachments,
-              fetchFile: client.fetchFile.bind(client)
-            });
-          }
-        } : {}
+        ...checkerAttachments ? { taskAttachments: checkerAttachments } : {}
       },
       verifiedRun,
       files
@@ -19976,6 +20272,13 @@ async function runDaemon(opts) {
   const mergeParts = makeMergeGateParts({
     listRuns: () => db.listRuns(),
     ...autoReviewProject ? { autoReview: autoReviewProject } : {},
+    // TASWM-492: чей это PR. Номер PR у семи репозиториев роя независим, поэтому гейт
+    // сверяет и репозиторий: owner/repo из pr_url, а короткий `#N` — по репозиторию
+    // КОНТЕКСТА ВЫЗОВА (origin каталога, откуда спросили). repoFallback + репо-реестр
+    // нужны для второй стороны сравнения: у прогона в базе лежит локальный путь, и пустой
+    // он означает дефолт роя, а не «отдельный проект».
+    repoFallback: opts.repo,
+    ...repoFullNameOf ? { repoFullNameOf } : {},
     fallbackAutoReview: SWARM_AUTO_REVIEW,
     autoVerify: SWARM_AUTO_VERIFY,
     // TASWM-344: вторая ось приёмки — вердикт верификатора
@@ -20162,7 +20465,7 @@ async function runDaemon(opts) {
           isDirty: (p) => worktreeDirty(p),
           releaseWorktree: (repo, p) => releaseWorktree(repo || opts.repo, p),
           pruneWorktrees: (repo) => pruneWorktrees(repo || opts.repo),
-          worktreeExists: existsSync17,
+          worktreeExists: existsSync18,
           liveWorktrees: () => new Set(listDroneProcesses().map((p) => p.worktree)),
           narrate: narrator.narrate
         });
@@ -20285,7 +20588,7 @@ async function runDaemon(opts) {
       mode,
       nudge
     ),
-    worktreeExists: (p) => existsSync17(p),
+    worktreeExists: (p) => existsSync18(p),
     hasTranscript: executorHasSession,
     // CI-осведомлённость review-PR (TASWM-102): реальный `gh pr checks`/`gh run view --log-failed`
     // (gh.ts) — решение (будить ли дрона) и гейты живут в tickOnce/handleCiRed. failureSummary
@@ -20471,7 +20774,7 @@ async function runDaemon(opts) {
             onStep
           });
         }
-        const repo = await repoRoot(dirname4(THIS_FILE)).catch(() => null);
+        const repo = await repoRoot(dirname5(THIS_FILE)).catch(() => null);
         if (!repo) {
           return { ok: false, step: "fetch", message: "\u0431\u0435\u0433\u0443 \u0438\u0437 \u0438\u0441\u0445\u043E\u0434\u043D\u0438\u043A\u043E\u0432, \u043D\u043E git-\u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u044F \u043D\u0430\u0434 \u043D\u0438\u043C\u0438 \u043D\u0435\u0442 \u2014 \u043E\u0431\u043D\u043E\u0432\u043B\u044F\u0442\u044C \u043D\u0435\u0447\u0435\u0433\u043E" };
         }
@@ -20781,6 +21084,7 @@ export {
   lastChangesSummary,
   listDroneProcesses,
   livePpids,
+  makeCheckerAttachmentsReader,
   replayDecision,
   repoHasCiWorkflows,
   resolveConflict,