@taskless-app/swarm 0.6.32 → 0.6.33

package/dist/overmind.js

@@ -3764,9 +3764,9 @@ var init_procCleanup = __esm({
 });
 
 // src/git.ts
-import { existsSync as existsSync11, readdirSync as readdirSync11, statSync as statSync8 } from "fs";
+import { existsSync as existsSync12, readdirSync as readdirSync11, statSync as statSync8 } from "fs";
 import { appendFile, chmod, mkdir, readFile, rm, writeFile } from "fs/promises";
-import { isAbsolute as isAbsolute2, join as join18, sep as sep2 } from "path";
+import { isAbsolute as isAbsolute2, join as join19, sep as sep2 } from "path";
 import { $ as $2 } from "execa";
 function gitNet(repo, args, timeoutMs) {
   return withHardTimeout(
@@ -3789,7 +3789,7 @@ async function reclaimStaleWorktree(repo, worktree) {
 }
 function isLinkedWorktree(dir) {
   try {
-    return statSync8(join18(dir, ".git")).isFile();
+    return statSync8(join19(dir, ".git")).isFile();
   } catch {
     return false;
   }
@@ -3801,7 +3801,7 @@ async function detachWorktree(repo, worktree) {
   }
 }
 async function ensureWorktreeDirGone(worktree) {
-  if (!existsSync11(worktree)) return false;
+  if (!existsSync12(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.`
@@ -3816,7 +3816,7 @@ async function ensureWorktreeDirGone(worktree) {
     );
     return true;
   }
-  if (existsSync11(worktree)) {
+  if (existsSync12(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;
@@ -3864,7 +3864,7 @@ async function checkoutWorktree(repo, path, branch, opts) {
   }
   const busyAt = await worktreeForBranch(repo, branch);
   if (busyAt) {
-    const exists = existsSync11(busyAt);
+    const exists = existsSync12(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);
@@ -3899,8 +3899,8 @@ async function ensureGitExcluded(worktree, pattern) {
   try {
     const commonDir = await gitPath(worktree, "--git-common-dir");
     if (!commonDir) return false;
-    const infoDir = join18(commonDir, "info");
-    const excludeFile = join18(infoDir, "exclude");
+    const infoDir = join19(commonDir, "info");
+    const excludeFile = join19(infoDir, "exclude");
     let current = "";
     try {
       current = await readFile(excludeFile, "utf8");
@@ -3920,7 +3920,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 : join18(worktree, raw);
+  return isAbsolute2(raw) ? raw : join19(worktree, raw);
 }
 async function ensureWorktreeHygiene(worktree) {
   for (const pattern of SWARM_EXCLUDE_PATTERNS) await ensureGitExcluded(worktree, pattern);
@@ -3930,12 +3930,12 @@ async function installGuardHooks(worktree) {
   try {
     const gitDir = await gitPath(worktree, "--git-dir");
     if (!gitDir) return false;
-    const hooksDir = join18(gitDir, "swarm-hooks");
+    const hooksDir = join19(gitDir, "swarm-hooks");
     const prev = await previousHooksPath(worktree);
     await mkdir(hooksDir, { recursive: true });
     for (const hook of GUARD_HOOKS) {
-      await writeFile(join18(hooksDir, hook), guardHookScript(hook, prev ? `${posix(prev)}/${hook}` : null));
-      await chmod(join18(hooksDir, hook), 493);
+      await writeFile(join19(hooksDir, hook), guardHookScript(hook, prev ? `${posix(prev)}/${hook}` : null));
+      await chmod(join19(hooksDir, hook), 493);
     }
     await $2`git -C ${worktree} config extensions.worktreeConfig true`;
     await $2`git -C ${worktree} config --worktree core.hooksPath ${posix(hooksDir)}`;
@@ -3954,7 +3954,7 @@ async function previousHooksPath(worktree) {
     if (out.exitCode === 0 && value) return value;
   }
   const commonDir = await gitPath(worktree, "--git-common-dir");
-  return commonDir ? join18(commonDir, "hooks") : null;
+  return commonDir ? join19(commonDir, "hooks") : null;
 }
 async function removeWorktree(repo, path) {
   const branch = (await $2({ reject: false })`git -C ${path} symbolic-ref --quiet --short HEAD`).stdout.trim();
@@ -3979,7 +3979,7 @@ async function worktreeDirty(path) {
 async function repairMovedWorktrees(targetDir) {
   const subdirs = (dir) => {
     try {
-      return readdirSync11(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join18(dir, d.name));
+      return readdirSync11(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => join19(dir, d.name));
     } catch {
       return [];
     }
@@ -4096,6 +4096,7 @@ var init_git = __esm({
 var droneChannel_exports = {};
 __export(droneChannel_exports, {
   ChannelUnavailableError: () => ChannelUnavailableError,
+  PATCHABLE: () => PATCHABLE,
   channelDroneStore: () => channelDroneStore,
   closeDroneChannel: () => closeDroneChannel,
   loadChannelSecret: () => loadChannelSecret,
@@ -4108,18 +4109,18 @@ __export(droneChannel_exports, {
   verifyLocalCliToken: () => verifyLocalCliToken
 });
 import { createHmac, randomBytes, timingSafeEqual } from "crypto";
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync9, readFileSync as readFileSync17, writeFileSync as writeFileSync11 } from "fs";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync9, readFileSync as readFileSync18, writeFileSync as writeFileSync12 } from "fs";
 import { dirname as dirname4 } from "path";
 import { serve } from "@hono/node-server";
 function loadChannelSecret(path) {
   try {
-    const s = readFileSync17(path, "utf8").trim();
+    const s = readFileSync18(path, "utf8").trim();
     if (s.length >= 32) return s;
   } catch {
   }
   const secret = randomBytes(32).toString("hex");
   mkdirSync9(dirname4(path), { recursive: true });
-  writeFileSync11(path, secret, { mode: 384 });
+  writeFileSync12(path, secret, { mode: 384 });
   try {
     chmodSync2(path, 384);
   } catch {
@@ -4179,6 +4180,16 @@ function invalidPatchValue(field, v) {
       return typeof v === "number" && Number.isInteger(v) && v >= 0 ? null : `\u043D\u0435\u0434\u043E\u043F\u0443\u0441\u0442\u0438\u043C\u044B\u0439 \u0446\u0438\u043A\u043B \u0440\u0435\u0432\u044C\u044E: ${String(v)}`;
     case "pr_url":
       return v === null || typeof v === "string" ? null : "pr_url \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u0441\u0442\u0440\u043E\u043A\u043E\u0439";
+    // TASWM-532: имя ветки уходит в аргументы git у ревьюера и резолвера, поэтому проверяем
+    // форму, а не только тип: пустая строка и пробелы внутри — это не ref, а сбой чтения.
+    case "branch":
+      return typeof v === "string" && v.length > 0 && v.length <= BRANCH_LEN_MAX && !BAD_IN_BRANCH.test(v) ? null : `\u043D\u0435\u0434\u043E\u043F\u0443\u0441\u0442\u0438\u043C\u043E\u0435 \u0438\u043C\u044F \u0432\u0435\u0442\u043A\u0438: ${String(v).slice(0, 80)}`;
+    case "stop_reason":
+      return v === null || typeof v === "string" && v.length <= STOP_REASON_LEN_MAX ? null : "stop_reason \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u0441\u0442\u0440\u043E\u043A\u043E\u0439 (\u0438\u043B\u0438 null) \u0432 \u043F\u0440\u0435\u0434\u0435\u043B\u0430\u0445 \u043F\u043E\u0442\u043E\u043B\u043A\u0430 \u0434\u043B\u0438\u043D\u044B";
+    // Словарь кодов возврата один на весь продукт (swarm-core) — проверяем его же функцией,
+    // как verify_verdict выше, а не повторяем литералы ещё одним списком.
+    case "return_reason":
+      return v === null || isReturnReason(v) ? null : `\u043D\u0435\u0434\u043E\u043F\u0443\u0441\u0442\u0438\u043C\u044B\u0439 \u043A\u043E\u0434 \u0432\u043E\u0437\u0432\u0440\u0430\u0442\u0430: ${String(v)}`;
     case "changed_paths": {
       if (!Array.isArray(v)) return "changed_paths \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u043C\u0430\u0441\u0441\u0438\u0432\u043E\u043C \u043F\u0443\u0442\u0435\u0439";
       if (v.length > CHANGED_PATHS_MAX) return `changed_paths: \u0441\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u043D\u043E\u0433\u043E \u043F\u0443\u0442\u0435\u0439 (${v.length} > ${CHANGED_PATHS_MAX})`;
@@ -4242,10 +4253,18 @@ function makeChannelHandler(deps) {
         if (id == null) return bad(403, "\u043F\u0440\u043E\u0433\u043E\u043D \u0432\u043D\u0435 \u0441\u043A\u043E\u0443\u043F\u0430 \u043A\u0430\u043D\u0430\u043B\u0430");
         const raw = p.patch ?? {};
         const patch = {};
+        const refuse = (status, why) => {
+          log(`[\u043A\u0430\u043D\u0430\u043B] \u043F\u0430\u0442\u0447 \u043F\u0440\u043E\u0433\u043E\u043D\u0430 #${id} \u043E\u0442\u043A\u043B\u043E\u043D\u0451\u043D (${status}): ${why}`);
+          try {
+            deps.store.addEvent(id, "step", `\u043A\u0430\u043D\u0430\u043B \u043E\u0442\u043A\u043B\u043E\u043D\u0438\u043B \u043F\u0430\u0442\u0447 \u0434\u0440\u043E\u043D\u0430 (${status}): ${why}`, null);
+          } catch {
+          }
+          return bad(status, why);
+        };
         for (const [k, v] of Object.entries(raw)) {
-          if (!PATCHABLE.has(k)) return bad(403, `\u043F\u043E\u043B\u0435 \xAB${k}\xBB \u043A\u0430\u043D\u0430\u043B\u0443 \u0434\u0440\u043E\u043D\u0430 \u043D\u0435 \u043E\u0442\u0434\u0430\u0451\u0442\u0441\u044F`);
+          if (!PATCHABLE.has(k)) return refuse(403, `\u043F\u043E\u043B\u0435 \xAB${k}\xBB \u043A\u0430\u043D\u0430\u043B\u0443 \u0434\u0440\u043E\u043D\u0430 \u043D\u0435 \u043E\u0442\u0434\u0430\u0451\u0442\u0441\u044F`);
           const why = invalidPatchValue(k, v);
-          if (why) return bad(400, why);
+          if (why) return refuse(400, why);
           patch[k] = v;
         }
         deps.store.updateRun(id, patch);
@@ -4438,7 +4457,7 @@ function channelDroneStore(opts) {
     openQuestionsFor: async () => (await call("openQuestionsFor")).questions
   };
 }
-var LOCAL_CLI_KEY, PATCHABLE, CHANGED_PATHS_MAX, CHANGED_PATH_LEN_MAX, EVENT_KIND_SET, ChannelUnavailableError, BACKOFF_MS;
+var LOCAL_CLI_KEY, PATCHABLE, CHANGED_PATHS_MAX, CHANGED_PATH_LEN_MAX, BRANCH_LEN_MAX, STOP_REASON_LEN_MAX, BAD_IN_BRANCH, EVENT_KIND_SET, ChannelUnavailableError, BACKOFF_MS;
 var init_droneChannel = __esm({
   "src/droneChannel.ts"() {
     "use strict";
@@ -4458,10 +4477,24 @@ var init_droneChannel = __esm({
       // worktree), а не модель — со стороны канала это такой же самоотчёт прогона о себе, как
       // pr_url. Потолки на размер — ниже, в invalidPatchValue: список идёт в гейт раздачи, и
       // сорвавшийся дрон не должен уметь заявить занятым весь репозиторий.
-      "changed_paths"
+      "changed_paths",
+      // TASWM-532: ФАКТИЧЕСКАЯ ветка сданного PR. Её подмешивает в патч сдачи не модель, а наш код
+      // (droneServer.done → branchFromPrPatch по ответу `gh pr view --json headRefName`) — тот же
+      // довод, что у changed_paths строкой выше. «Ветка и так известна из прогона» — неправда:
+      // поле пишется на спавне из слага задачи, а дрон мог продолжать ЧУЖОЙ PR, и по этому полю
+      // ревьюер строит worktree `origin/<branch>` (TASWM-356).
+      "branch",
+      // TASWM-532: возврат задачи автору (`return_task`) пишет их одним патчем со статусом
+      // "returned" — проза для ленты задачи и код причины для распределения по бэклогу
+      // (TASWM-505). Без них 403 ложился на возврат ровно так же, как на сдачу.
+      "stop_reason",
+      "return_reason"
     ]);
     CHANGED_PATHS_MAX = 1e3;
     CHANGED_PATH_LEN_MAX = 1024;
+    BRANCH_LEN_MAX = 255;
+    STOP_REASON_LEN_MAX = 2e3;
+    BAD_IN_BRANCH = /[\s~^:?*[\\\p{Cc}]/u;
     EVENT_KIND_SET = new Set(EVENT_KINDS);
     ChannelUnavailableError = class extends Error {
       constructor(downMs, message) {
@@ -4477,7 +4510,7 @@ var init_droneChannel = __esm({
 
 // src/attachments.ts
 import { mkdir as mkdir3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 function attachmentsFromDoc(doc, origin) {
   const out = [];
   const walk2 = (node) => {
@@ -4568,7 +4601,7 @@ async function materializeAttachments(opts) {
   };
   const result = { files: [], skipped: [] };
   if (opts.refs.length === 0) return result;
-  const dir = join22(opts.worktree, ATTACHMENTS_DIR);
+  const dir = join23(opts.worktree, ATTACHMENTS_DIR);
   await io.removeDir(dir);
   let dirReady = false;
   let total = 0;
@@ -4614,7 +4647,7 @@ async function materializeAttachments(opts) {
         await io.mkdir(dir);
         dirReady = true;
       }
-      await io.writeFile(join22(dir, name), file.bytes);
+      await io.writeFile(join23(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 (${errText2(e)})`);
       continue;
@@ -4767,7 +4800,7 @@ var init_attachments = __esm({
 
 // src/shotUpload.ts
 import { readFile as fsReadFile } from "fs/promises";
-import { basename as basename4, isAbsolute as isAbsolute3, join as join23 } from "path";
+import { basename as basename4, isAbsolute as isAbsolute3, join as join24 } from "path";
 function shotMimetype(path) {
   const dot = path.lastIndexOf(".");
   if (dot < 0) return null;
@@ -4793,7 +4826,7 @@ async function readShots(paths, opts) {
     }
     let bytes;
     try {
-      bytes = await read(isAbsolute3(path) ? path : join23(opts.worktree, path));
+      bytes = await read(isAbsolute3(path) ? path : join24(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;
@@ -4874,8 +4907,8 @@ var init_shotUpload = __esm({
 
 // src/oauth.ts
 import { createHash as createHash3, randomBytes as randomBytes2 } from "crypto";
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync12, unlinkSync as unlinkSync4 } from "fs";
-import { join as join24 } from "path";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync13, unlinkSync as unlinkSync4 } from "fs";
+import { join as join25 } from "path";
 function makePkce() {
   const verifier = randomBytes2(48).toString("base64url");
   const challenge = createHash3("sha256").update(verifier).digest("base64url");
@@ -4959,13 +4992,13 @@ function toStore(clientId, t, now) {
 }
 function loadStore() {
   try {
-    return JSON.parse(readFileSync18(STORE_PATH2, "utf8"));
+    return JSON.parse(readFileSync19(STORE_PATH2, "utf8"));
   } catch {
     return null;
   }
 }
 function saveStore(s) {
-  writeFileSync12(STORE_PATH2, JSON.stringify(s, null, 2), { mode: 384 });
+  writeFileSync13(STORE_PATH2, JSON.stringify(s, null, 2), { mode: 384 });
 }
 function clearStore() {
   try {
@@ -4975,7 +5008,7 @@ function clearStore() {
 }
 function loadClientId() {
   try {
-    return JSON.parse(readFileSync18(CLIENT_PATH, "utf8")).clientId;
+    return JSON.parse(readFileSync19(CLIENT_PATH, "utf8")).clientId;
   } catch {
     return null;
   }
@@ -4984,7 +5017,7 @@ async function ensureClientId(api, redirectUri, fetchFn = fetch) {
   const existing = loadClientId();
   if (existing) return existing;
   const clientId = await registerClient({ api, redirectUri }, fetchFn);
-  writeFileSync12(CLIENT_PATH, JSON.stringify({ clientId }, null, 2), { mode: 384 });
+  writeFileSync13(CLIENT_PATH, JSON.stringify({ clientId }, null, 2), { mode: 384 });
   return clientId;
 }
 async function ensureAccess(store, opts = {}) {
@@ -5010,8 +5043,8 @@ var init_oauth = __esm({
     AUTHORIZE = "/api/oauth/authorize";
     TOKEN = "/api/oauth/token";
     SCOPE = "openid profile email taskless:full";
-    STORE_PATH2 = join24(SWARM_HOME, "oauth.json");
-    CLIENT_PATH = join24(SWARM_HOME, "oauth-client.json");
+    STORE_PATH2 = join25(SWARM_HOME, "oauth.json");
+    CLIENT_PATH = join25(SWARM_HOME, "oauth-client.json");
     base2 = (api) => api.replace(/\/$/, "");
   }
 });
@@ -5057,11 +5090,11 @@ var init_authState = __esm({
 });
 
 // src/workspace.ts
-import { readFileSync as readFileSync19, writeFileSync as writeFileSync13, unlinkSync as unlinkSync5 } from "fs";
-import { join as join25 } from "path";
+import { readFileSync as readFileSync20, writeFileSync as writeFileSync14, unlinkSync as unlinkSync5 } from "fs";
+import { join as join26 } from "path";
 function loadWorkspace() {
   try {
-    const w = JSON.parse(readFileSync19(WORKSPACE_PATH, "utf8"));
+    const w = JSON.parse(readFileSync20(WORKSPACE_PATH, "utf8"));
     return w && typeof w.id === "string" && w.id ? w : null;
   } catch {
     return null;
@@ -5075,7 +5108,7 @@ var init_workspace = __esm({
   "src/workspace.ts"() {
     "use strict";
     init_config();
-    WORKSPACE_PATH = join25(SWARM_HOME, "workspace.json");
+    WORKSPACE_PATH = join26(SWARM_HOME, "workspace.json");
   }
 });
 
@@ -5656,7 +5689,7 @@ __export(db_exports, {
 });
 import { createRequire as createRequire2 } from "module";
 import { randomUUID as randomUUID3 } from "crypto";
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { resolve as resolve3 } from "path";
 function rowToQuestion(row) {
   return {
@@ -6279,7 +6312,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 (!existsSync14(abs)) throw new Error(`import-db: \u0444\u0430\u0439\u043B\u0430 \u043D\u0435\u0442: ${abs}`);
+        if (!existsSync15(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();
@@ -6648,8 +6681,8 @@ var init_droneStore = __esm({
 
 // src/overmind.ts
 import { homedir as homedir6 } from "os";
-import { existsSync as existsSync19, readFileSync as readFileSync23, readdirSync as readdirSync13, renameSync as renameSync11 } from "fs";
-import { basename as basename6, dirname as dirname5, join as join32 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync24, readdirSync as readdirSync13, renameSync as renameSync12 } from "fs";
+import { basename as basename6, dirname as dirname5, join as join33 } from "path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "url";
 import { spawn as spawn4 } from "child_process";
 
@@ -9988,7 +10021,13 @@ var DEFAULT_RELIEF_CONFIG = {
 function resolveReliefConfig(cfg) {
   return { ...DEFAULT_RELIEF_CONFIG, ...cfg ?? {} };
 }
-var RELIEF_PAUSE_REASON = `${RELIEF_PAUSE_MARK}: \u0445\u043E\u0441\u0442 \u043F\u0435\u0440\u0435\u0433\u0440\u0443\u0436\u0435\u043D \u2014 \u0434\u0440\u043E\u043D \u043F\u0440\u0438\u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D (SIGTERM, \u0432\u0435\u0440\u043D\u0451\u0442\u0441\u044F \u0447\u0435\u0440\u0435\u0437 --continue), \u0432\u0435\u0440\u043D\u0451\u0442\u0441\u044F \u043F\u043E \u043E\u0434\u043D\u043E\u043C\u0443 \u043F\u043E\u0441\u043B\u0435 \u043D\u043E\u0440\u043C\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u0438 (TASWM-151)`;
+var RELIEF_PAUSE_REASON = `${RELIEF_PAUSE_MARK}: \u0445\u043E\u0441\u0442 \u043F\u0435\u0440\u0435\u0433\u0440\u0443\u0436\u0435\u043D \u2014 \u0434\u0440\u043E\u043D \u043F\u0440\u0438\u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D (SIGTERM), \u0432\u0435\u0440\u043D\u0451\u0442\u0441\u044F \u043F\u043E \u043E\u0434\u043D\u043E\u043C\u0443 \u043F\u043E\u0441\u043B\u0435 \u043D\u043E\u0440\u043C\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u0438 (TASWM-151)`;
+function reliefPauseReason(canContinue) {
+  return canContinue ? `${RELIEF_PAUSE_MARK}: \u0445\u043E\u0441\u0442 \u043F\u0435\u0440\u0435\u0433\u0440\u0443\u0436\u0435\u043D \u2014 \u0434\u0440\u043E\u043D \u043F\u0440\u0438\u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D (SIGTERM, \u0432\u0435\u0440\u043D\u0451\u0442\u0441\u044F \u0447\u0435\u0440\u0435\u0437 --continue: worktree \u0438 \u0441\u0435\u0441\u0441\u0438\u044F \u043D\u0430 \u043C\u0435\u0441\u0442\u0435)` : `${RELIEF_PAUSE_MARK}: \u0445\u043E\u0441\u0442 \u043F\u0435\u0440\u0435\u0433\u0440\u0443\u0436\u0435\u043D \u2014 \u0434\u0440\u043E\u043D \u043F\u0440\u0438\u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D (SIGTERM; \u043F\u0440\u043E\u0434\u043E\u043B\u0436\u0430\u0442\u044C \u043D\u0435\u0447\u0435\u043C \u2014 worktree/\u0441\u0435\u0441\u0441\u0438\u044F \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u043D\u044B, \u0432\u0435\u0440\u043D\u0451\u0442\u0441\u044F \u0441\u0442\u0430\u0440\u0442\u043E\u043C \u0437\u0430\u043D\u043E\u0432\u043E)`;
+}
+function isReliefPause(stopReason) {
+  return !!stopReason && stopReason.startsWith(RELIEF_PAUSE_MARK);
+}
 function reliefResumeReason(mode) {
   return mode === "continue" ? `${RELIEF_PAUSE_MARK} \u043E\u0442\u043F\u0443\u0441\u0442\u0438\u043B\u0430 \u2014 \u0432\u043E\u0437\u0432\u0440\u0430\u0442 \u043F\u043E \u043E\u0434\u043D\u043E\u043C\u0443 (--continue: \u0440\u0430\u0431\u043E\u0442\u0430 \u0432 origin + \u0441\u0435\u0441\u0441\u0438\u044F \u0446\u0435\u043B\u044B)` : `${RELIEF_PAUSE_MARK} \u043E\u0442\u043F\u0443\u0441\u0442\u0438\u043B\u0430 \u2014 \u0432\u043E\u0437\u0432\u0440\u0430\u0442 \u043F\u043E \u043E\u0434\u043D\u043E\u043C\u0443, \u0441\u0442\u0430\u0440\u0442 \u0437\u0430\u043D\u043E\u0432\u043E (\u0441\u0435\u0441\u0441\u0438\u044F/worktree \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u043D\u044B)`;
 }
@@ -10012,6 +10051,115 @@ function pickResumeCandidate(pausedForRelief) {
   return candidates.reduce((oldest, r) => r.updated_at < oldest.updated_at ? r : oldest);
 }
 
+// src/reliefLoop.ts
+import { existsSync as existsSync10, readFileSync as readFileSync13, renameSync as renameSync8, writeFileSync as writeFileSync11 } from "fs";
+import { join as join14 } from "path";
+var numEnv3 = (name, def) => {
+  const v = Number(process.env[name]);
+  return Number.isFinite(v) && v > 0 ? v : def;
+};
+var DEFAULT_RELIEF_LOOP_CONFIG = {
+  limit: numEnv3("SWARM_RELIEF_LOOP_LIMIT", 3),
+  backoffMaxMs: numEnv3("SWARM_RELIEF_BACKOFF_MAX_MS", 10 * 6e4),
+  seriesTtlMs: numEnv3("SWARM_RELIEF_LOOP_TTL_MS", 6 * 60 * 6e4)
+};
+function resolveReliefLoopConfig(cfg) {
+  return { ...DEFAULT_RELIEF_LOOP_CONFIG, ...cfg ?? {} };
+}
+function reliefLoopKey(repo, slug) {
+  return `${repo}#${slug}`;
+}
+function recordReliefLoopPause(state, key, now, delivered, cfg = DEFAULT_RELIEF_LOOP_CONFIG) {
+  const prev = state[key];
+  const continues = !!prev && !delivered && now - prev.lastPauseAt <= cfg.seriesTtlMs;
+  const entry = continues ? { pauses: prev.pauses + 1, lastPauseAt: now, ...prev.escalated ? { escalated: true } : {} } : { pauses: 1, lastPauseAt: now };
+  state[key] = entry;
+  return entry;
+}
+function clearReliefLoop(state, key) {
+  delete state[key];
+}
+function reliefBackoffMs(pauses, baseMs, cfg = DEFAULT_RELIEF_LOOP_CONFIG) {
+  if (pauses <= 1) return baseMs;
+  const grown = baseMs * 2 ** Math.min(pauses - 1, 30);
+  return Math.min(grown, cfg.backoffMaxMs);
+}
+function reliefLoopTripped(entry, cfg = DEFAULT_RELIEF_LOOP_CONFIG) {
+  return !!entry && entry.pauses >= cfg.limit;
+}
+function reliefLoopStatePath(home) {
+  return join14(home, "relief-loop.json");
+}
+function loadReliefLoopState(home, now = Date.now(), io = {}, cfg = DEFAULT_RELIEF_LOOP_CONFIG) {
+  const exists = io.exists ?? existsSync10;
+  const readFile2 = io.readFile ?? ((p) => readFileSync13(p, "utf8"));
+  const path = reliefLoopStatePath(home);
+  if (!exists(path)) return {};
+  try {
+    const raw = JSON.parse(readFile2(path));
+    const out = {};
+    for (const [key, value] of Object.entries(raw ?? {})) {
+      const v = value;
+      const pauses = Number(v?.pauses);
+      const lastPauseAt = Number(v?.lastPauseAt);
+      if (!Number.isFinite(pauses) || pauses <= 0 || !Number.isFinite(lastPauseAt)) continue;
+      if (now - lastPauseAt > cfg.seriesTtlMs) continue;
+      out[key] = { pauses, lastPauseAt, ...v?.escalated ? { escalated: true } : {} };
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+function saveReliefLoopState(home, state, io = {}) {
+  const path = reliefLoopStatePath(home);
+  const writeFile4 = io.writeFile ?? ((p, data) => {
+    writeFileSync11(`${p}.tmp`, data);
+    renameSync8(`${p}.tmp`, p);
+  });
+  writeFile4(path, JSON.stringify(state, null, 2));
+}
+var ReliefLoopStore = class {
+  constructor(home, now = Date.now(), io = {}, cfg = DEFAULT_RELIEF_LOOP_CONFIG) {
+    this.home = home;
+    this.io = io;
+    this.cfg = cfg;
+    this.state = loadReliefLoopState(home, now, io, cfg);
+  }
+  home;
+  io;
+  cfg;
+  state;
+  get(key) {
+    return this.state[key];
+  }
+  /** Учесть снятие и сразу сохранить. Возвращает запись после учёта. */
+  recordPause(key, now, delivered) {
+    const entry = recordReliefLoopPause(this.state, key, now, delivered, this.cfg);
+    this.flush();
+    return entry;
+  }
+  /** Пометить, что человека уже позвали — чтобы не звать на каждом тике. */
+  markEscalated(key) {
+    const entry = this.state[key];
+    if (!entry || entry.escalated) return;
+    entry.escalated = true;
+    this.flush();
+  }
+  clear(key) {
+    if (!(key in this.state)) return;
+    clearReliefLoop(this.state, key);
+    this.flush();
+  }
+  flush() {
+    try {
+      saveReliefLoopState(this.home, this.state, this.io);
+    } catch (e) {
+      console.warn("[overmind] \u0441\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435 \u043F\u0435\u0442\u043B\u0438 \u0440\u0430\u0437\u0433\u0440\u0443\u0437\u043A\u0438 \u043D\u0435 \u0437\u0430\u043F\u0438\u0441\u0430\u043B\u043E\u0441\u044C:", e);
+    }
+  }
+};
+
 // src/reliefCost.ts
 function median(xs) {
   const s = [...xs].sort((a, b) => a - b);
@@ -10128,15 +10276,15 @@ function buildReliefCostCandidates(cost, t, sustainMs, build) {
 
 // src/launcher.ts
 import { spawn as spawn2 } from "child_process";
-import { closeSync as closeSync3, existsSync as existsSync10, mkdirSync as mkdirSync8, openSync as openSync3, readdirSync as readdirSync8 } from "fs";
+import { closeSync as closeSync3, existsSync as existsSync11, mkdirSync as mkdirSync8, openSync as openSync3, readdirSync as readdirSync8 } from "fs";
 import { createRequire } from "module";
 import { homedir as homedir5 } from "os";
-import { dirname as dirname3, join as join15 } from "path";
+import { dirname as dirname3, join as join16 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/droneHome.ts
 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";
+import { join as join15, 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);
@@ -10160,20 +10308,20 @@ function buildDroneHome(opts) {
   if (rel && !rel.startsWith("..") && !rel.includes(sep)) wanted.delete(rel);
   for (const existing of readdirSync7(droneHome)) {
     if (wanted.has(existing)) continue;
-    const p = join14(droneHome, existing);
+    const p = join15(droneHome, existing);
     try {
       if (lstatSync(p).isSymbolicLink()) rmSync(p);
     } catch {
     }
   }
   for (const name of wanted) {
-    const link2 = join14(droneHome, name);
+    const link2 = join15(droneHome, name);
     try {
       lstatSync(link2);
       continue;
     } catch {
     }
-    const target = join14(realHome, name);
+    const target = join15(realHome, name);
     let isDir;
     try {
       isDir = statSync7(target).isDirectory();
@@ -10194,7 +10342,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, join14(realHome, ...segments)]));
+  return Object.fromEntries(REAL_PATH_ENV_PINS.map(({ env, segments }) => [env, join15(realHome, ...segments)]));
 }
 function dronePrivatePaths(realHome, swarmHome) {
   return [
@@ -10306,7 +10454,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 = join15(worktree, ".turbo", "cache");
+    env.TURBO_CACHE_DIR = join16(worktree, ".turbo", "cache");
   }
   Object.assign(env, droneTestEnv(droneCap, base3));
   for (const key of DAEMON_STATE_ENV) delete env[key];
@@ -10334,13 +10482,13 @@ var DAEMON_STATE_ENV = [
   "TASKLESS_TOKEN"
 ];
 function bundledRoleDir(kind) {
-  return join15(dirname3(fileURLToPath2(import.meta.url)), "..", "roles", kind);
+  return join16(dirname3(fileURLToPath2(import.meta.url)), "..", "roles", kind);
 }
 function roleDir(worktree, kind) {
-  return join15(worktree, ".claude", "roles", kind);
+  return join16(worktree, ".claude", "roles", kind);
 }
 function roleDirs(worktree, kind) {
-  return [bundledRoleDir(kind), roleDir(worktree, kind)].filter((dir) => existsSync10(dir));
+  return [bundledRoleDir(kind), roleDir(worktree, kind)].filter((dir) => existsSync11(dir));
 }
 function nextRunLogPath(runLogsDir, runLogKeys) {
   const dir = runLogDirForWrite(runLogsDir, runLogKeys);
@@ -10356,7 +10504,7 @@ function nextRunLogPath(runLogsDir, runLogKeys) {
     const m = /^(\d+)\.json/.exec(f);
     if (m) next = Math.max(next, Number(m[1]) + 1);
   }
-  return join15(dir, `${next}.json`);
+  return join16(dir, `${next}.json`);
 }
 function openNextRunLog(runLogsDir, runLogKeys) {
   for (let attempt = 0; attempt < 50; attempt++) {
@@ -10439,9 +10587,9 @@ function makeLauncher(cfg) {
     }
     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 && !existsSync10(join15(cfg.droneIsolation.swarmHome, "token"))) {
+    if (cfg.droneIsolation && process.env.TASKLESS_TOKEN && !existsSync11(join16(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 ${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.`
+        `[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 ${join16(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();
@@ -10502,8 +10650,8 @@ function makeLauncher(cfg) {
 init_procCleanup();
 
 // src/cost.ts
-import { readFileSync as readFileSync13, readdirSync as readdirSync9, renameSync as renameSync8 } from "fs";
-import { join as join16 } from "path";
+import { readFileSync as readFileSync14, readdirSync as readdirSync9, renameSync as renameSync9 } from "fs";
+import { join as join17 } from "path";
 init_executors();
 var UNPROCESSED_LOG_RE = /^\d+\.json$/;
 function unprocessedLogFiles(dir) {
@@ -10525,10 +10673,10 @@ function accountRunCost(deps, run) {
   let durationMs = 0;
   const processed = [];
   for (const f of files) {
-    const full = join16(dir, f);
+    const full = join17(dir, f);
     let raw = null;
     try {
-      raw = readFileSync13(full, "utf8");
+      raw = readFileSync14(full, "utf8");
     } catch {
       continue;
     }
@@ -10554,7 +10702,7 @@ function accountRunCost(deps, run) {
   }
   for (const full of processed) {
     try {
-      renameSync8(full, `${full}.done`);
+      renameSync9(full, `${full}.done`);
     } catch {
     }
   }
@@ -10577,8 +10725,8 @@ function makeCostSweeper(deps) {
 }
 
 // src/runOutcome.ts
-import { readdirSync as readdirSync10, readFileSync as readFileSync14 } from "fs";
-import { join as join17 } from "path";
+import { readdirSync as readdirSync10, readFileSync as readFileSync15 } from "fs";
+import { join as join18 } from "path";
 init_executors();
 function endedItself(outcome) {
   return outcome === "graceful" || outcome === "budget" || outcome === "aborted";
@@ -10605,7 +10753,7 @@ function readLatestResultRaw(runLogsDir, runLogKeys) {
   }
   if (!latest) return null;
   try {
-    return readFileSync14(join17(dir, latest.name), "utf8");
+    return readFileSync15(join18(dir, latest.name), "utf8");
   } catch {
     return null;
   }
@@ -10638,20 +10786,20 @@ init_src();
 init_git();
 
 // src/deps.ts
-import { existsSync as existsSync13, readdirSync as readdirSync12, readFileSync as readFileSync16 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync12, readFileSync as readFileSync17 } from "fs";
+import { join as join22 } from "path";
 import { execa } from "execa";
 
 // src/prepareLock.ts
 import { createHash } from "crypto";
 import { closeSync as closeSync4, openSync as openSync4, rmSync as rmSync2, statSync as statSync9, writeSync } from "fs";
-import { join as join19 } from "path";
+import { join as join20 } 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 join19(dir, `swarm-prepare-${createHash("sha1").update(key).digest("hex").slice(0, 16)}.lock`);
+  return join20(dir, `swarm-prepare-${createHash("sha1").update(key).digest("hex").slice(0, 16)}.lock`);
 }
 function defaultTryCreate(path, content) {
   try {
@@ -10712,8 +10860,8 @@ init_config();
 init_config();
 import { createHash as createHash2 } from "crypto";
 import { cp, link, lstat, mkdir as mkdir2, readdir, readlink, rename, rm as rm2, stat, symlink, utimes, writeFile as writeFile2 } from "fs/promises";
-import { existsSync as existsSync12, readFileSync as readFileSync15 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync16 } from "fs";
+import { join as join21 } from "path";
 function fingerprint(parts) {
   const h = createHash2("sha256");
   for (const p of parts) {
@@ -10727,8 +10875,8 @@ async function cloneTree(src, dst) {
   const entries = await readdir(src, { withFileTypes: true });
   await Promise.all(
     entries.map(async (e) => {
-      const from = join20(src, e.name);
-      const to = join20(dst, e.name);
+      const from = join21(src, e.name);
+      const to = join21(dst, e.name);
       if (e.isDirectory()) return cloneTree(from, to);
       if (e.isSymbolicLink()) {
         return symlink(await readlink(from), to).catch(() => cp(from, to, { recursive: true, verbatimSymlinks: true }));
@@ -10741,11 +10889,11 @@ function cacheRoot(io) {
   return io.root ?? ENV_CACHE_DIR;
 }
 function snapshotDir(io, key) {
-  return join20(cacheRoot(io), key);
+  return join21(cacheRoot(io), key);
 }
 function readManifest(dir) {
   try {
-    const parsed = JSON.parse(readFileSync15(join20(dir, "manifest.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync16(join21(dir, "manifest.json"), "utf8"));
     if (!parsed || typeof parsed !== "object") return null;
     const m = parsed;
     if (typeof m.key !== "string" || !Array.isArray(m.dirs)) return null;
@@ -10757,11 +10905,11 @@ function readManifest(dir) {
   }
 }
 function hasEnvSnapshot(key, io = {}) {
-  const exists = io.exists ?? existsSync12;
-  return exists(join20(snapshotDir(io, key), "manifest.json"));
+  const exists = io.exists ?? existsSync13;
+  return exists(join21(snapshotDir(io, key), "manifest.json"));
 }
 async function restoreEnvSnapshot(worktree, key, io = {}) {
-  const exists = io.exists ?? existsSync12;
+  const exists = io.exists ?? existsSync13;
   const clone = io.clone ?? cloneTree;
   const dir = snapshotDir(io, key);
   const manifest = readManifest(dir);
@@ -10770,13 +10918,13 @@ async function restoreEnvSnapshot(worktree, key, io = {}) {
   try {
     for (let i = 0; i < manifest.dirs.length; i++) {
       const rel = manifest.dirs[i] ?? "";
-      const target = join20(worktree, rel);
+      const target = join21(worktree, rel);
       if (exists(target)) continue;
-      await clone(join20(dir, "trees", String(i)), target);
+      await clone(join21(dir, "trees", String(i)), target);
       made.push(rel);
     }
   } catch {
-    for (const rel of made) await rm2(join20(worktree, rel), { recursive: true, force: true }).catch(() => {
+    for (const rel of made) await rm2(join21(worktree, rel), { recursive: true, force: true }).catch(() => {
     });
     return null;
   }
@@ -10789,19 +10937,19 @@ async function touch(dir) {
   });
 }
 async function saveEnvSnapshot(worktree, key, dirs, io = {}) {
-  const exists = io.exists ?? existsSync12;
+  const exists = io.exists ?? existsSync13;
   const clone = io.clone ?? cloneTree;
   if (hasEnvSnapshot(key, io)) return true;
-  const present = dirs.filter((rel) => exists(join20(worktree, rel)));
+  const present = dirs.filter((rel) => exists(join21(worktree, rel)));
   if (!present.length) return false;
   const root = cacheRoot(io);
-  const tmp = join20(root, `.tmp-${key}-${process.pid}`);
+  const tmp = join21(root, `.tmp-${key}-${process.pid}`);
   try {
     await rm2(tmp, { recursive: true, force: true });
-    await mkdir2(join20(tmp, "trees"), { recursive: true });
-    for (let i = 0; i < present.length; i++) await clone(join20(worktree, present[i] ?? ""), join20(tmp, "trees", String(i)));
+    await mkdir2(join21(tmp, "trees"), { recursive: true });
+    for (let i = 0; i < present.length; i++) await clone(join21(worktree, present[i] ?? ""), join21(tmp, "trees", String(i)));
     const manifest = { key, dirs: present, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
-    await writeFile2(join20(tmp, "manifest.json"), JSON.stringify(manifest, null, 2));
+    await writeFile2(join21(tmp, "manifest.json"), JSON.stringify(manifest, null, 2));
     await rename(tmp, snapshotDir(io, key));
     return true;
   } catch {
@@ -10821,13 +10969,13 @@ async function pruneEnvSnapshots(io = {}) {
   }
   const withTime = [];
   for (const name of names) {
-    const s = await stat(join20(root, name)).catch(() => null);
+    const s = await stat(join21(root, name)).catch(() => null);
     if (s) withTime.push({ name, mtime: s.mtimeMs });
   }
   withTime.sort((a, b) => b.mtime - a.mtime);
   let removed = 0;
   for (const { name } of withTime.slice(Math.max(0, keep))) {
-    await rm2(join20(root, name), { recursive: true, force: true }).catch(() => {
+    await rm2(join21(root, name), { recursive: true, force: true }).catch(() => {
     });
     removed++;
   }
@@ -10843,9 +10991,9 @@ async function sweepEnvCacheTemp(io = {}) {
   }
   let removed = 0;
   for (const name of names) {
-    const s = await lstat(join20(root, name)).catch(() => null);
+    const s = await lstat(join21(root, name)).catch(() => null);
     if (!s || Date.now() - s.mtimeMs < 60 * 6e4) continue;
-    await rm2(join20(root, name), { recursive: true, force: true }).catch(() => {
+    await rm2(join21(root, name), { recursive: true, force: true }).catch(() => {
     });
     removed++;
   }
@@ -10872,7 +11020,7 @@ async function runCommand(cmd, worktree) {
 }
 function safeReadText(p) {
   try {
-    return readFileSync16(p, "utf8");
+    return readFileSync17(p, "utf8");
   } catch {
     return null;
   }
@@ -10912,21 +11060,21 @@ function overridePlan(override) {
   };
 }
 function detectPackageManager(worktree, io = {}) {
-  const exists = io.exists ?? existsSync13;
+  const exists = io.exists ?? existsSync14;
   const readText = io.readText ?? safeReadText;
-  const hasPkgJson = exists(join21(worktree, "package.json"));
+  const hasPkgJson = exists(join22(worktree, "package.json"));
   if (!hasPkgJson) {
-    if (exists(join21(worktree, "deno.json")) || exists(join21(worktree, "deno.jsonc")) || exists(join21(worktree, "deno.lock"))) return "deno";
+    if (exists(join22(worktree, "deno.json")) || exists(join22(worktree, "deno.jsonc")) || exists(join22(worktree, "deno.lock"))) return "deno";
     return null;
   }
-  const pkg = readJson(readText, join21(worktree, "package.json"));
+  const pkg = readJson(readText, join22(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(join21(worktree, "bun.lock")) || exists(join21(worktree, "bun.lockb"))) return "bun";
-  if (exists(join21(worktree, "pnpm-lock.yaml"))) return "pnpm";
-  if (exists(join21(worktree, "yarn.lock"))) return "yarn";
-  if (exists(join21(worktree, "package-lock.json"))) return "npm";
-  if (exists(join21(worktree, "deno.lock"))) return "deno";
+  if (exists(join22(worktree, "bun.lock")) || exists(join22(worktree, "bun.lockb"))) return "bun";
+  if (exists(join22(worktree, "pnpm-lock.yaml"))) return "pnpm";
+  if (exists(join22(worktree, "yarn.lock"))) return "yarn";
+  if (exists(join22(worktree, "package-lock.json"))) return "npm";
+  if (exists(join22(worktree, "deno.lock"))) return "deno";
   return "npm";
 }
 function jsInstallCommand(pm) {
@@ -10982,7 +11130,7 @@ var ECOSYSTEM_MARKERS = [
   // конфигурация — дело сборки, не подготовки
 ];
 function detectPlan(worktree, io) {
-  const exists = io.exists ?? existsSync13;
+  const exists = io.exists ?? existsSync14;
   const listFiles = io.listFiles ?? safeListFiles;
   const pm = detectPackageManager(worktree, io);
   if (pm) {
@@ -10990,7 +11138,7 @@ function detectPlan(worktree, io) {
       // node_modules на месте — установку пропускаем (быстрый путь переиспользованного worktree).
       // У deno каталога может не быть вовсе (кэш в DENO_DIR) — тогда `deno install` отработает
       // заново, но он дешёвый: тянет из того же общего кэша.
-      { label: `${pm} install`, run: jsInstallCommand(pm), skipIfExists: join21(worktree, "node_modules"), source: "detect" }
+      { label: `${pm} install`, run: jsInstallCommand(pm), skipIfExists: join22(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" });
@@ -10999,12 +11147,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(join21(worktree, f))) || marker.ext !== void 0 && listFiles(worktree).some((n) => n.endsWith(marker.ext));
+    const hit = marker.files.some((f) => exists(join22(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(join21(worktree, refine.file))) continue;
+      if (!exists(join22(worktree, refine.file))) continue;
       ecosystem = refine.ecosystem;
       command = refine.command;
       break;
@@ -11061,12 +11209,12 @@ var CI_INSTALL_PATTERNS = [
 function ciWorkflowPlan(worktree, io) {
   const readText = io.readText ?? safeReadText;
   const listFiles = io.listFiles ?? safeListFiles;
-  const dir = join21(worktree, ".github", "workflows");
+  const dir = join22(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(join21(dir, name));
+    const yaml = readText(join22(dir, name));
     if (yaml === null) continue;
     for (const raw of workflowRunLines(yaml)) {
       const line = raw.replace(/\s+/g, " ").trim();
@@ -11081,7 +11229,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(join21(worktree, "pnpm-workspace.yaml"));
+  const yaml = readText(join22(worktree, "pnpm-workspace.yaml"));
   if (yaml !== null) {
     const globs = [];
     let inPackages = false;
@@ -11101,7 +11249,7 @@ function workspaceGlobs(worktree, readText) {
     }
     if (globs.length) return globs;
   }
-  const pkg = readJson(readText, join21(worktree, "package.json"));
+  const pkg = readJson(readText, join22(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");
@@ -11112,14 +11260,14 @@ function workspaceDirs(worktree, globs, io) {
     if (glob.startsWith("!")) continue;
     const star = glob.indexOf("*");
     if (star === -1) {
-      const dir = join21(worktree, glob);
-      if (io.exists(join21(dir, "package.json"))) dirs.add(dir);
+      const dir = join22(worktree, glob);
+      if (io.exists(join22(dir, "package.json"))) dirs.add(dir);
       continue;
     }
-    const base3 = join21(worktree, glob.slice(0, star).replace(/\/$/, ""));
+    const base3 = join22(worktree, glob.slice(0, star).replace(/\/$/, ""));
     for (const name of io.listDirs(base3)) {
-      const dir = join21(base3, name);
-      if (io.exists(join21(dir, "package.json"))) dirs.add(dir);
+      const dir = join22(base3, name);
+      if (io.exists(join22(dir, "package.json"))) dirs.add(dir);
     }
   }
   return [...dirs];
@@ -11140,18 +11288,18 @@ function entryPaths(pkg) {
   return out;
 }
 function workspaceBuildTargets(worktree, io = {}) {
-  const exists = io.exists ?? existsSync13;
+  const exists = io.exists ?? existsSync14;
   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, join21(dir, "package.json"));
+    const pkg = readJson(readText, join22(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(join21(dir, e)));
+    const needsBuild = typeof scripts.build === "string" && entries.length > 0 && entries.some((e) => !exists(join22(dir, e)));
     const deps = Object.keys({ ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} });
     pkgs.push({ name: pkg.name, dir, deps, needsBuild });
   }
@@ -11179,7 +11327,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(join21(worktree, file));
+    const raw = readText(join22(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, "");
@@ -11195,11 +11343,11 @@ function isLocalDatabase(url) {
   }
 }
 function prismaPackages(worktree, io) {
-  const exists = io.exists ?? existsSync13;
+  const exists = io.exists ?? existsSync14;
   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(join21(dir, "prisma", "schema.prisma")) && listDirs(join21(dir, "prisma", "migrations")).length > 0);
+  return dirs.filter((dir) => exists(join22(dir, "prisma", "schema.prisma")) && listDirs(join22(dir, "prisma", "migrations")).length > 0);
 }
 function jsExecBin(pm, command) {
   switch (pm) {
@@ -11229,25 +11377,25 @@ function migrateCommands(worktree, pm, io) {
 var ENV_DEFINING_FILES = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lock", "bun.lockb", "deno.lock", "pnpm-workspace.yaml"];
 function envCachePlan(worktree, io = {}) {
   if (!ENV_CACHE_ENABLED) return null;
-  const exists = io.exists ?? existsSync13;
+  const exists = io.exists ?? existsSync14;
   const readText = io.readText ?? safeReadText;
   const listDirs = io.listDirs ?? safeListDirs;
   const pm = detectPackageManager(worktree, io);
   if (!pm) return null;
   const parts = [`pm:${pm}`];
   for (const name of ENV_DEFINING_FILES) {
-    const raw = readText(join21(worktree, name));
+    const raw = readText(join22(worktree, name));
     if (raw !== null) parts.push(`${name}
 ${raw}`);
   }
   const pkgDirs = workspaceDirs(worktree, workspaceGlobs(worktree, readText), { exists, listDirs });
   const rels = pkgDirs.map((dir) => dir.slice(worktree.length + 1)).sort();
   for (const rel of ["", ...rels]) {
-    const raw = readText(join21(worktree, rel, "package.json"));
+    const raw = readText(join22(worktree, rel, "package.json"));
     if (raw !== null) parts.push(`${rel}/package.json
 ${raw}`);
   }
-  return { key: fingerprint(parts), dirs: ["node_modules", ...rels.map((rel) => join21(rel, "node_modules"))] };
+  return { key: fingerprint(parts), dirs: ["node_modules", ...rels.map((rel) => join22(rel, "node_modules"))] };
 }
 function planPrepare(worktree, io = {}) {
   const plan = overridePlan(io.override) ?? detectPlan(worktree, io) ?? ciWorkflowPlan(worktree, io);
@@ -11255,7 +11403,7 @@ function planPrepare(worktree, io = {}) {
   return { ...plan, commands: plan.commands.slice(0, MAX_PLAN_COMMANDS) };
 }
 async function ensureWorktreeDeps(worktree, io = {}) {
-  const exists = io.exists ?? existsSync13;
+  const exists = io.exists ?? existsSync14;
   const exec = io.exec ?? ((cmd) => runCommand(cmd, worktree));
   const approve = io.approve ?? (() => true);
   const cachePlan = envCachePlan(worktree, io);
@@ -11272,7 +11420,7 @@ async function ensureWorktreeDeps(worktree, io = {}) {
     restored: [],
     cached: false
   };
-  if (cachePlan && !exists(join21(worktree, "node_modules"))) {
+  if (cachePlan && !exists(join22(worktree, "node_modules"))) {
     report.restored = await restoreEnvSnapshot(worktree, cachePlan.key, cacheIO) ?? [];
   }
   const plan = planPrepare(worktree, io);
@@ -11561,7 +11709,7 @@ function parkReasonUnretriable(reason) {
 // package.json
 var package_default = {
   name: "@taskless-app/swarm",
-  version: "0.6.32",
+  version: "0.6.33",
   type: "module",
   description: "Local control plane for a fleet of AI coding agents (drones), coordinating through Taskless. The overmind runs the swarm.",
   keywords: [
@@ -11612,7 +11760,7 @@ var package_default = {
     execa: "^10.0.0",
     zod: "3.25.76"
   },
-  gitHead: "f40f0fb4d2f96809f88b7d6ae4f086c5f4f004da"
+  gitHead: "7b17b06b041af953afde46fbd41fc68ebc6dc4e9"
 };
 
 // src/version.ts
@@ -11688,6 +11836,7 @@ function reviewBudgetMark(cycle) {
 var SELF_REFERENCE_MARK = "PR \u0442\u0440\u043E\u0433\u0430\u0435\u0442 \u043A\u043E\u0434 \u0441\u0430\u043C\u043E\u0433\u043E \u0434\u0435\u043C\u043E\u043D\u0430";
 var VERIFY_ESCALATION_MARK = "\u0432\u0435\u0440\u0438\u0444\u0438\u043A\u0430\u0446\u0438\u044F: \u043F\u043E\u043F\u044B\u0442\u043A\u0438 \u0438\u0441\u0447\u0435\u0440\u043F\u0430\u043D\u044B";
 var CI_WAIT_ESCALATION_MARK = "\u043E\u0436\u0438\u0434\u0430\u043D\u0438\u0435 CI \u0437\u0430\u0442\u044F\u043D\u0443\u043B\u043E\u0441\u044C";
+var RELIEF_LOOP_ESCALATION_MARK = "\u0440\u0430\u0437\u0433\u0440\u0443\u0437\u043A\u0430 \u0437\u0430\u0446\u0438\u043A\u043B\u0438\u043B\u0430\u0441\u044C";
 var ESCALATIONS = [
   {
     mark: SELF_REFERENCE_MARK,
@@ -11750,6 +11899,21 @@ var ESCALATIONS = [
     sides: ["author"],
     why: "\u043F\u043E\u0442\u043E\u043B\u043E\u043A \u043F\u043E\u043F\u044B\u0442\u043E\u043A \u0432\u0435\u0440\u0438\u0444\u0438\u043A\u0430\u0446\u0438\u0438 \u0438\u0441\u0447\u0435\u0440\u043F\u0430\u043D \u2014 \u0432\u0435\u0440\u0434\u0438\u043A\u0442\u0430 \u0432\u0435\u0440\u0438\u0444\u0438\u043A\u0430\u0446\u0438\u0438 \u0443 PR \u043D\u0435 \u0431\u0443\u0434\u0435\u0442"
   },
+  {
+    mark: RELIEF_LOOP_ESCALATION_MARK,
+    // Проверяющего это не касается: работы, которую проверять, ещё нет. Автор — да, и это
+    // главное: сторож прогресса (watchdog.decideFreshAction) обязан УВИДЕТЬ, что рой уже
+    // сдался, иначе он поднимет свежего актора в ту же перегрузку — буквально следующий круг
+    // петли, ровно то, что он и делал 27.08. Ручную побудку `swarm wake` этот маркер, как и
+    // остальные author-маркеры, не запрещает — он открывает ей дверь (см. stoppedForHuman).
+    //
+    // Надзора НЕТ намеренно: маркер ложится на прогон в статусе `stalled`, а надзорная труба
+    // (buildEscalationCandidates) ходит только по `listRuns("review")` — запись там была бы
+    // мёртвой. Человека по такому прогону зовёт детектор run_stalled (anomalies.ts), причём
+    // повторный заход по той же задаче он поднимает до уровня «нужен оператор» сам.
+    sides: ["author"],
+    why: "\u0440\u0430\u0437\u0433\u0440\u0443\u0437\u043A\u0430 \u0441\u043D\u044F\u043B\u0430 \u043F\u0440\u043E\u0433\u043E\u043D N \u0440\u0430\u0437 \u043F\u043E\u0434\u0440\u044F\u0434 \u0431\u0435\u0437 \u0435\u0434\u0438\u043D\u043E\u0439 \u0441\u0434\u0430\u0447\u0438 \u2014 \u0440\u043E\u0439 \u043F\u0435\u0440\u0435\u0441\u0442\u0430\u043B \u0435\u0433\u043E \u043F\u043E\u0434\u043D\u0438\u043C\u0430\u0442\u044C, \u0437\u043E\u0432\u0451\u0442 \u0447\u0435\u043B\u043E\u0432\u0435\u043A\u0430 \u0447\u0435\u0440\u0435\u0437 run_stalled"
+  },
   {
     mark: CI_WAIT_ESCALATION_MARK,
     // Сторон НЕТ — и это решение, а не пропуск. Маркер лежит на прогоне РЕВЬЮЕРА (paused,
@@ -12213,7 +12377,7 @@ init_git();
 
 // 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;
@@ -12381,7 +12545,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);
@@ -14464,22 +14628,22 @@ function makeMergeGateParts(deps) {
 }
 
 // src/envGate.ts
-import { existsSync as existsSync16 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync17 } from "fs";
+import { join as join29 } from "path";
 import { createConnection } from "net";
 import { execa as execa2 } from "execa";
 
 // src/platform.ts
-import { existsSync as existsSync15, readFileSync as readFileSync20 } from "fs";
-import { delimiter, join as join27 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync21 } from "fs";
+import { delimiter, join as join28 } from "path";
 function resolveCommandPath(name, env = process.env, platform = process.platform) {
-  if (name.includes("/") || name.includes("\\")) return existsSync15(name) ? name : null;
+  if (name.includes("/") || name.includes("\\")) return existsSync16(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 = join27(dir, name + ext);
-      if (existsSync15(candidate)) return candidate;
+      const candidate = join28(dir, name + ext);
+      if (existsSync16(candidate)) return candidate;
     }
   }
   return null;
@@ -14562,8 +14726,8 @@ var COMPOSE_MARKERS = [
   "compose.yaml"
 ];
 function detectRequirements(repo, io = {}) {
-  const exists = io.exists ?? existsSync16;
-  const marker = COMPOSE_MARKERS.find((f) => exists(join28(repo, f)));
+  const exists = io.exists ?? existsSync17;
+  const marker = COMPOSE_MARKERS.find((f) => exists(join29(repo, f)));
   return marker ? [{ kind: "docker", raw: `docker (\u0434\u0435\u0442\u0435\u043A\u0442: ${marker})` }] : [];
 }
 function resolveRequirements(repo, declared, io = {}) {
@@ -16306,22 +16470,22 @@ function closeWebServer(server) {
 
 // src/hostCommands.ts
 init_src();
-import { readFileSync as readFileSync21, renameSync as renameSync9, writeFileSync as writeFileSync14 } from "fs";
-import { join as join29 } from "path";
+import { readFileSync as readFileSync22, renameSync as renameSync10, writeFileSync as writeFileSync15 } from "fs";
+import { join as join30 } from "path";
 function hostCommandStatePath(home) {
-  return join29(home, "host-command.json");
+  return join30(home, "host-command.json");
 }
 function readState(path) {
   try {
-    return JSON.parse(readFileSync21(path, "utf8"));
+    return JSON.parse(readFileSync22(path, "utf8"));
   } catch {
     return {};
   }
 }
 function writeState(path, state) {
   try {
-    writeFileSync14(`${path}.tmp`, JSON.stringify(state));
-    renameSync9(`${path}.tmp`, path);
+    writeFileSync15(`${path}.tmp`, JSON.stringify(state));
+    renameSync10(`${path}.tmp`, path);
   } catch {
   }
 }
@@ -16483,8 +16647,8 @@ async function doRestart(cmd, opts, note) {
 
 // src/selfUpdate.ts
 init_git();
-import { existsSync as existsSync17 } from "fs";
-import { join as join30 } from "path";
+import { existsSync as existsSync18 } from "fs";
+import { join as join31 } from "path";
 import { $ as $5 } from "execa";
 var DAEMON_PACKAGE = "@taskless-app/swarm";
 var defaultRun = async (cmd, args, cwd) => {
@@ -16497,7 +16661,7 @@ function tail(text, max = 400) {
 }
 async function runSelfUpdate(io) {
   const run = io.run ?? defaultRun;
-  const exists = io.exists ?? existsSync17;
+  const exists = io.exists ?? existsSync18;
   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);
@@ -16526,7 +16690,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(join30(repo, "pnpm-lock.yaml"))) {
+  if (!exists(join31(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);
@@ -16685,19 +16849,19 @@ async function fetchExternalStorm(url, opts = {}) {
 }
 
 // src/anomalyState.ts
-import { existsSync as existsSync18, readFileSync as readFileSync22, renameSync as renameSync10, writeFileSync as writeFileSync15 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync23, renameSync as renameSync11, writeFileSync as writeFileSync16 } from "fs";
+import { join as join32 } 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 join31(home, "anomaly-state.json");
+  return join32(home, "anomaly-state.json");
 }
 function loadAnomalyState(home, now = Date.now(), io = {}) {
-  const exists = io.exists ?? existsSync18;
-  const readFile2 = io.readFile ?? ((p) => readFileSync22(p, "utf8"));
+  const exists = io.exists ?? existsSync19;
+  const readFile2 = io.readFile ?? ((p) => readFileSync23(p, "utf8"));
   const path = anomalyStatePath(home);
   if (!exists(path)) return emptyState();
   try {
@@ -16727,8 +16891,8 @@ function loadAnomalyState(home, now = Date.now(), io = {}) {
 function saveAnomalyState(home, state, io = {}) {
   const path = anomalyStatePath(home);
   const writeFile4 = io.writeFile ?? ((p, data) => {
-    writeFileSync15(`${p}.tmp`, data);
-    renameSync10(`${p}.tmp`, p);
+    writeFileSync16(`${p}.tmp`, data);
+    renameSync11(`${p}.tmp`, p);
   });
   writeFile4(path, JSON.stringify(state, null, 2));
 }
@@ -16882,6 +17046,7 @@ function decideParkAction(db, droneCap, exclusivityBlocked) {
 function decideFreshAction(db, wt) {
   const stalled = db.listRuns("stalled").filter((r) => r.resolves_run_id == null && r.reviews_run_id == null);
   for (const r of stalled) {
+    if (findEscalation(db.events(r.id).map((e) => e.text ?? ""), r, "author")) continue;
     const path = r.worktree_path;
     const recoverable = !!path && wt.exists(path) && wt.hasTranscript(path);
     if (recoverable) continue;
@@ -17229,6 +17394,7 @@ function verdictCommentMark(createdAt) {
   return `\u043A\u043E\u043C\u043C\u0435\u043D\u0442-\u0432\u0435\u0440\u0434\u0438\u043A\u0442@${createdAt}`;
 }
 var WATCHDOG_PARK_REASON = "\u0441\u0442\u043E\u0440\u043E\u0436 \u043F\u0440\u043E\u0433\u0440\u0435\u0441\u0441\u0430: \u0441\u043B\u043E\u0442 \u0437\u0430\u043D\u044F\u0442 \u043D\u0438\u0437\u043A\u043E\u043F\u0440\u0438\u043E\u0440\u0438\u0442\u0435\u0442\u043D\u044B\u043C \u2014 \u043F\u0430\u0440\u043A\u0443\u044E, \u0432\u043F\u0443\u0441\u043A\u0430\u044E \u043F\u0440\u0438\u043E\u0440\u0438\u0442\u0435\u0442\u043D\u0435\u0435 \u0436\u0434\u0443\u0449\u0435\u0433\u043E (TASWM-270)";
+var RELIEF_LOOP_STOP_REASON = "\u0440\u0435\u0441\u0443\u0440\u0441-\u0440\u0430\u0437\u0433\u0440\u0443\u0437\u043A\u0430 \u0437\u0430\u0446\u0438\u043A\u043B\u0438\u043B\u0430\u0441\u044C: \u0441\u043D\u044F\u0442\u0438\u0439 \u043F\u043E\u0434\u0440\u044F\u0434 \u0431\u0435\u0437 \u0441\u0434\u0430\u0447\u0438 \u0431\u043E\u043B\u044C\u0448\u0435 \u043F\u043E\u0442\u043E\u043B\u043A\u0430 \u2014 \u043D\u0443\u0436\u0435\u043D \u0447\u0435\u043B\u043E\u0432\u0435\u043A (TASWM-531)";
 function livePpids() {
   return livePpidsFrom(listProcs());
 }
@@ -17854,10 +18020,10 @@ ${task.description}` : `\u0417\u0430\u0434\u0430\u0447\u0430 ${run.task_slug} (\
   }
   return parts.join("\n");
 }
-var HERO_CHARTER_PATH = join32(dirname5(THIS_FILE), "..", "docs", "HERO.md");
+var HERO_CHARTER_PATH = join33(dirname5(THIS_FILE), "..", "docs", "HERO.md");
 function buildHeroPrompt(task, run, taskContext, attachmentsBlock) {
   const name = run.name || `#${run.id}`;
-  const charter = readFileSync23(HERO_CHARTER_PATH, "utf8");
+  const charter = readFileSync24(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).`;
@@ -18165,7 +18331,7 @@ async function wakeRun(deps, runId) {
   if (run.status === "review" && run.pr_url && !needsFixIteration(run) && !stoppedForHuman) {
     return { ok: false, why: `\u043F\u0440\u043E\u0433\u043E\u043D #${runId} \u0443\u0436\u0435 \u0441\u0434\u0430\u043D \u043D\u0430 \u0440\u0435\u0432\u044C\u044E (${run.pr_url}) \u2014 \u0431\u0443\u0434\u0438\u0442\u044C \u043D\u0435\u0447\u0435\u0433\u043E; \u043F\u0440\u0430\u0432\u043A\u0438 \u043F\u043E\u0434\u043D\u0438\u043C\u0435\u0442 \u0440\u043E\u0439 \u043F\u043E \u0432\u0435\u0440\u0434\u0438\u043A\u0442\u0443` };
   }
-  const worktreeExists = deps.worktreeExists ?? existsSync19;
+  const worktreeExists = deps.worktreeExists ?? existsSync20;
   const hasTranscript = deps.hasTranscript ?? executorHasSession;
   const wt = run.worktree_path;
   const canContinue = !!wt && worktreeExists(wt) && hasTranscript(wt);
@@ -18285,7 +18451,7 @@ function repoHasCi(deps, run) {
 function repoHasCiWorkflows(worktreePath, repo) {
   for (const base3 of [worktreePath, repo]) {
     if (!base3) continue;
-    const dir = join32(base3, ".github", "workflows");
+    const dir = join33(base3, ".github", "workflows");
     try {
       if (readdirSync13(dir).some((f) => f.endsWith(".yml") || f.endsWith(".yaml"))) return true;
     } catch {
@@ -18471,7 +18637,7 @@ async function wakeReviewerOnCiReady(deps, run, over) {
   return true;
 }
 function worktreeAndTranscriptAlive(deps, worktree) {
-  const exists = deps.worktreeExists ?? existsSync19;
+  const exists = deps.worktreeExists ?? existsSync20;
   const transcript = deps.hasTranscript ?? executorHasSession;
   return exists(worktree) && transcript(worktree);
 }
@@ -18980,7 +19146,7 @@ async function resumeWatchdogParked(deps, droneCap) {
   }
   if (!candidate) return;
   if (candidate.pid != null && deps.isAlive(candidate.pid)) return;
-  const worktreeExists = deps.worktreeExists ?? existsSync19;
+  const worktreeExists = deps.worktreeExists ?? existsSync20;
   const hasTranscript = deps.hasTranscript ?? executorHasSession;
   const wt = candidate.worktree_path;
   const canContinue = !!wt && worktreeExists(wt) && hasTranscript(wt);
@@ -19095,17 +19261,31 @@ async function manageRelief(deps, now, droneCap, stormActive) {
           console.error(`[overmind] \u0440\u0435\u043A\u043B\u0435\u0439\u043C worktree \u043F\u0430\u0443\u0437\u043D\u0443\u0442\u043E\u0433\u043E ${droneLabel(candidate)} \u0441\u043E\u0440\u0432\u0430\u043B\u0441\u044F:`, e);
         }
       }
+      let saved = false;
       if (candidate.worktree_path && deps.pauseSnapshot) {
         try {
-          const saved = await deps.pauseSnapshot(candidate.worktree_path);
+          saved = await deps.pauseSnapshot(candidate.worktree_path);
           if (saved) deps.db.addEvent(candidate.id, "step", "\u043D\u0435\u0434\u043E\u0434\u0435\u043B\u0430\u043D\u043D\u043E\u0435 \u0437\u0430\u043A\u043E\u043C\u043C\u0438\u0447\u0435\u043D\u043E+\u0437\u0430\u043F\u0443\u0448\u0435\u043D\u043E \u043F\u0435\u0440\u0435\u0434 \u043F\u0430\u0443\u0437\u043E\u0439 (TASWM-229) \u2014 --continue \u043F\u0440\u043E\u0434\u043E\u043B\u0436\u0438\u0442 \u0441 \u044D\u0442\u043E\u0439 \u0442\u043E\u0447\u043A\u0438");
         } catch (e) {
           console.error(`[overmind] \u0441\u043D\u0430\u043F\u0448\u043E\u0442 worktree \u043F\u0430\u0443\u0437\u043D\u0443\u0442\u043E\u0433\u043E ${droneLabel(candidate)} \u0441\u043E\u0440\u0432\u0430\u043B\u0441\u044F:`, e);
         }
       }
+      const canContinue = !!candidate.worktree_path && worktreeAndTranscriptAlive(deps, candidate.worktree_path);
       deps.db.updateRun(candidate.id, { status: "paused", stop_reason: RELIEF_PAUSE_REASON });
-      deps.db.addEvent(candidate.id, "paused", RELIEF_PAUSE_REASON);
+      deps.db.addEvent(candidate.id, "paused", reliefPauseReason(canContinue));
       state.lastPauseAt = now;
+      const loopEntry = deps.reliefLoop?.recordPause(
+        reliefLoopKey(normalizeRepo(candidate.repo || deps.repoFallback), candidate.task_slug),
+        now,
+        candidate.pr_url != null || saved
+      );
+      if (loopEntry && loopEntry.pauses > 1) {
+        deps.db.addEvent(
+          candidate.id,
+          "step",
+          `${RELIEF_PAUSE_MARK}: \u0441\u043D\u044F\u0442\u0438\u0435 ${loopEntry.pauses}-\u0435 \u043F\u043E\u0434\u0440\u044F\u0434 \u0431\u0435\u0437 \u0441\u0434\u0430\u0447\u0438 \u2014 \u0432\u043E\u0437\u0432\u0440\u0430\u0442 \u043E\u0442\u043B\u043E\u0436\u0435\u043D \u043D\u0430 ${Math.round(reliefBackoffMs(loopEntry.pauses, cfg.rampWindowMs) / 1e3)}\u0441 (TASWM-531)`
+        );
+      }
       recordReliefPause(
         state.cost ??= { pauses: [] },
         { runId: candidate.id, label: droneLabel(candidate), at: now, resumedAt: null, stepsSinceResume },
@@ -19137,7 +19317,7 @@ async function manageRelief(deps, now, droneCap, stormActive) {
     state.lastLoggedGateReason = null;
   }
   if (countActiveDrones(deps.db) >= droneCap) return;
-  const pausedForRelief = deps.db.listRuns("paused").filter((r) => r.stop_reason === RELIEF_PAUSE_REASON);
+  const pausedForRelief = deps.db.listRuns("paused").filter((r) => isReliefPause(r.stop_reason));
   const recovering = pausedForRelief.length > 0 || state.overloadedAt != null && now - state.overloadedAt < cfg.rampWindowMs;
   if (!recovering) {
     await batchSpawnQueue(deps, droneCap);
@@ -19148,10 +19328,27 @@ async function manageRelief(deps, now, droneCap, stormActive) {
   if (resumeCandidate) {
     if (resumeCandidate.pid != null && deps.isAlive(resumeCandidate.pid)) return;
     if (!deps.respawn) return;
+    const loopKey = reliefLoopKey(normalizeRepo(resumeCandidate.repo || deps.repoFallback), resumeCandidate.task_slug);
+    const loopEntry = deps.reliefLoop?.get(loopKey);
+    if (loopEntry) {
+      const loopCfg = resolveReliefLoopConfig(deps.reliefLoopConfig);
+      if (reliefLoopTripped(loopEntry, loopCfg)) {
+        if (!loopEntry.escalated) {
+          deps.db.updateRun(resumeCandidate.id, { status: "stalled", stop_reason: RELIEF_LOOP_STOP_REASON });
+          deps.db.addEvent(
+            resumeCandidate.id,
+            "step",
+            `${RELIEF_LOOP_ESCALATION_MARK}: \u0440\u0430\u0437\u0433\u0440\u0443\u0437\u043A\u0430 \u0441\u043D\u0438\u043C\u0430\u043B\u0430 \u043F\u0440\u043E\u0433\u043E\u043D ${loopEntry.pauses} \u0440\u0430\u0437(\u0430) \u043F\u043E\u0434\u0440\u044F\u0434 \u0438 \u043D\u0438 \u043E\u0434\u0438\u043D \u043A\u0440\u0443\u0433 \u043D\u0435 \u043F\u0440\u0438\u043D\u0451\u0441 \u0441\u0434\u0430\u0447\u0438 (\u043D\u0438 PR, \u043D\u0438 \u043A\u043E\u043C\u043C\u0438\u0442\u0430) \u2014 \u0431\u043E\u043B\u044C\u0448\u0435 \u043D\u0435 \u043F\u043E\u0434\u043D\u0438\u043C\u0430\u044E, \u043D\u0443\u0436\u0435\u043D \u0447\u0435\u043B\u043E\u0432\u0435\u043A (\u043F\u043E\u0442\u043E\u043B\u043E\u043A ${loopCfg.limit}, TASWM-531)`
+          );
+          deps.reliefLoop?.markEscalated(loopKey);
+          narrate(deps, `${droneLabel(resumeCandidate)} \u0441\u043D\u0438\u043C\u0430\u043B\u0441\u044F \u0440\u0430\u0437\u0433\u0440\u0443\u0437\u043A\u043E\u0439 ${loopEntry.pauses} \u0440\u0430\u0437(\u0430) \u043F\u043E\u0434\u0440\u044F\u0434 \u0431\u0435\u0437 \u0435\u0434\u0438\u043D\u043E\u0433\u043E \u043A\u043E\u043C\u043C\u0438\u0442\u0430 \u2014 \u044D\u0442\u043E \u043F\u0435\u0442\u043B\u044F, \u0434\u0430\u043B\u044C\u0448\u0435 \u043E\u043F\u0435\u0440\u0430\u0442\u043E\u0440.`);
+        }
+        return;
+      }
+      if (now - loopEntry.lastPauseAt < reliefBackoffMs(loopEntry.pauses, cfg.rampWindowMs, loopCfg)) return;
+    }
     const wt = resumeCandidate.worktree_path;
-    const worktreeExists = deps.worktreeExists ?? existsSync19;
-    const hasTranscript = deps.hasTranscript ?? executorHasSession;
-    const canContinue = !!wt && worktreeExists(wt) && hasTranscript(wt);
+    const canContinue = !!wt && worktreeAndTranscriptAlive(deps, wt);
     const mode = canContinue ? "continue" : "fresh";
     if (mode === "continue" && wt && deps.reclaimWorktree) {
       try {
@@ -19190,7 +19387,7 @@ async function buildReliefCostCandidatesFor(deps, now, droneCap) {
     (runId) => {
       const run = runById.get(runId);
       if (!run) return now;
-      if (run.status === "paused" && run.stop_reason === RELIEF_PAUSE_REASON) return null;
+      if (run.status === "paused" && isReliefPause(run.stop_reason)) return null;
       return sqliteMs(run.updated_at);
     },
     now
@@ -19206,7 +19403,7 @@ async function buildReliefCostCandidatesFor(deps, now, droneCap) {
   if (!reliefAlertDue(cost, thresholds)) return [];
   const pressure = deps.hostPressure?.() ?? { culprits: [], readings: [], totalGb: 0 };
   const occupying = allRuns.filter(
-    (r) => r.kind !== "hero" && (ACTIVE_DRONE_STATUSES.has(r.status) || r.status === "paused" && r.stop_reason === RELIEF_PAUSE_REASON)
+    (r) => r.kind !== "hero" && (ACTIVE_DRONE_STATUSES.has(r.status) || r.status === "paused" && isReliefPause(r.stop_reason))
   );
   const repoOf = (r) => normalizeRepo(r.repo || deps.repoFallback || "");
   const busyRepos = [...new Set(occupying.map(repoOf).filter(Boolean))].filter(
@@ -19427,7 +19624,7 @@ function buildEscalationCandidates(db) {
 }
 async function tickOnce(deps) {
   const now = deps.now ? deps.now() : Date.now();
-  const worktreeExists = deps.worktreeExists ?? existsSync19;
+  const worktreeExists = deps.worktreeExists ?? existsSync20;
   const hasTranscript = deps.hasTranscript ?? executorHasSession;
   deps.sampleHost?.();
   if (deps.rehydrate) {
@@ -20013,7 +20210,7 @@ async function tickOnce(deps) {
   }
   for (const run of deps.db.listRuns("paused")) {
     if (run.kind === "hero") continue;
-    if (run.stop_reason === AWAITING_CI_REASON || run.stop_reason === RELIEF_PAUSE_REASON) continue;
+    if (run.stop_reason === AWAITING_CI_REASON || isReliefPause(run.stop_reason)) continue;
     const last = lastActivityMs(deps.db, run);
     if (now - last <= STALL_FLOOR_MS) continue;
     const evs = deps.db.events(run.id);
@@ -20029,7 +20226,7 @@ async function tickOnce(deps) {
     for (const run of deps.db.listRuns("paused")) {
       if (run.kind === "hero") continue;
       if (run.reviews_run_id != null) continue;
-      if (run.stop_reason === RELIEF_PAUSE_REASON) continue;
+      if (isReliefPause(run.stop_reason)) continue;
       if (NO_AUTO_WAKE_REASONS.some((r) => run.stop_reason?.startsWith(r))) continue;
       if (run.pid != null && deps.isAlive(run.pid)) continue;
       if (!await projectQuotaGateAllows(deps, run)) continue;
@@ -20223,7 +20420,7 @@ async function resolveConflict(deps, reviewRun) {
     model: reviewRun.model,
     review_model: reviewRun.review_model
   });
-  const wt = join32(deps.worktreesDir, basename6(repo), `${reviewRun.task_slug}-resolve-${resolver.id}`);
+  const wt = join33(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);
@@ -20302,7 +20499,7 @@ async function spawnReviewer(deps, reviewRun, files) {
     // (своей у ревьюера нет, TASWM-204), и коммент с вердиктом должен уехать именно туда.
     workspace_id: reviewRun.workspace_id
   });
-  const wt = join32(deps.worktreesDir, basename6(repo), `${reviewRun.task_slug}-review-${reviewer.id}`);
+  const wt = join33(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);
@@ -20383,7 +20580,7 @@ async function spawnVerifier(deps, verifiedRun, files) {
     // штамп цикла: фикс-итерацию проверяет свежий верификатор
     workspace_id: verifiedRun.workspace_id
   });
-  const wt = join32(deps.worktreesDir, basename6(repo), `${verifiedRun.task_slug}-verify-${verifier.id}`);
+  const wt = join33(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);
@@ -20416,7 +20613,7 @@ async function respawnRun(deps, run, mode, nudge) {
   if (mode === "continue") {
     const prompt2 = nudge ?? (run.kind === "hero" ? HERO_CONTINUE_NUDGE : CONTINUE_NUDGE);
     const pid2 = deps.launch({ worktree: wt, run, prompt: prompt2, continueSession: true });
-    deps.db.updateRun(run.id, { status: "running", pid: pid2 });
+    deps.db.updateRun(run.id, { status: "running", pid: pid2, ...worktreePathPatch(run, wt) });
     return;
   }
   const [task, verifyMode, projectBase, zoneNotes] = await Promise.all([
@@ -20429,7 +20626,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 (!existsSync19(wt)) {
+  if (!existsSync20(wt)) {
     const branch = runToSpawn.branch || runToSpawn.task_slug;
     const source = await addWorktree(repo, wt, branch, {
       ...base3 ? { base: await remoteBaseRef(repo, base3) } : {},
@@ -20453,10 +20650,13 @@ async function respawnRun(deps, run, mode, nudge) {
   const notice = depsPromptNotice(depsReport);
   const prompt = [freshPrompt, notice, nudge].filter(Boolean).join("\n\n");
   const pid = deps.launch({ worktree: wt, run: runToSpawn, prompt });
-  deps.db.updateRun(run.id, { status: "running", pid });
+  deps.db.updateRun(run.id, { status: "running", pid, ...worktreePathPatch(run, wt) });
+}
+function worktreePathPatch(run, wt) {
+  return run.worktree_path === wt ? {} : { worktree_path: wt };
 }
 async function syncCrashedOnStartup(deps) {
-  const worktreeExists = deps.worktreeExists ?? existsSync19;
+  const worktreeExists = deps.worktreeExists ?? existsSync20;
   let orphaned = 0;
   let merged = 0;
   let requeued = 0;
@@ -20610,7 +20810,7 @@ async function migrateWorktreesAtStartup() {
       legacyDir: WORKTREES_LEGACY_DIR,
       targetDir: WORKTREES_DIR,
       envOverride: process.env.SWARM_WORKTREES || "",
-      exists: (d) => existsSync19(d),
+      exists: (d) => existsSync20(d),
       isNonEmptyDir: (d) => {
         try {
           return readdirSync13(d).length > 0;
@@ -20619,13 +20819,13 @@ async function migrateWorktreesAtStartup() {
         }
       },
       liveDronesUnder: (d) => pidsWithCwdUnder(d).length > 0,
-      rename: (from, to) => renameSync11(from, to),
+      rename: (from, to) => renameSync12(from, to),
       repairMoved: (t) => repairMovedWorktrees(t),
       log: (m) => console.log(m)
     });
   } catch (e) {
     console.error("[migrate] \u043C\u0438\u0433\u0440\u0430\u0446\u0438\u044F worktrees \u0441\u043E\u0440\u0432\u0430\u043B\u0430\u0441\u044C \u2014 \u0444\u043E\u043B\u0431\u044D\u043A:", e);
-    return existsSync19(WORKTREES_DIR) ? WORKTREES_DIR : WORKTREES_LEGACY_DIR;
+    return existsSync20(WORKTREES_DIR) ? WORKTREES_DIR : WORKTREES_LEGACY_DIR;
   }
 }
 async function reportWorkspaceAccess(tl, db) {
@@ -21278,7 +21478,7 @@ async function runDaemon(opts) {
           isDirty: (p) => worktreeDirty(p),
           releaseWorktree: (repo, p) => releaseWorktree(repo || opts.repo, p),
           pruneWorktrees: (repo) => pruneWorktrees(repo || opts.repo),
-          worktreeExists: existsSync19,
+          worktreeExists: existsSync20,
           liveWorktrees: () => new Set(listDroneProcesses().map((p) => p.worktree)),
           narrate: narrator.narrate
         });
@@ -21318,6 +21518,9 @@ async function runDaemon(opts) {
     // разгрузки (TASWM-316) — заводим ОДИН раз на цикл демона, tickOnce (manageRelief)
     // мутирует эти же поля каждый тик.
     relief: { cost: { pauses: [] } },
+    // Счёт снятий разгрузкой подряд без сдачи (TASWM-531) — durable, в отличие от relief-состояния
+    // выше: он обязан пережить и рестарт демона, и подмену прогона сторожем прогресса.
+    reliefLoop: new ReliefLoopStore(SWARM_HOME),
     // Гейт окружения машины (TASWM-313): не спавним дрона, если проекту не хватает сервисов
     // (лежащий докер = заведомо красные api-тесты). Только client-режим — требования живут в
     // настройках проекта; без него гейта нет и рой работает как раньше. Дедуп событий —
@@ -21401,7 +21604,7 @@ async function runDaemon(opts) {
       mode,
       nudge
     ),
-    worktreeExists: (p) => existsSync19(p),
+    worktreeExists: (p) => existsSync20(p),
     // TASWM-514: с этого момента считаем попытки спавна — счётчик живёт ровно одну жизнь
     // процесса демона и рестарт не переживает (см. preStartAttempts).
     startedAt: Date.now(),
@@ -21870,6 +22073,7 @@ export {
   HERO_CONTINUE_NUDGE,
   OPEN_PR_HOLD_MARK,
   OVERMIND_ENTRY,
+  RELIEF_LOOP_STOP_REASON,
   RESOLVE_ESCALATION_MARK,
   RESOLVE_LIMIT,
   RESPAWN_LIMIT,