@taskless-app/swarm 0.6.38 → 0.6.40

package/dist/cli.js

@@ -1366,7 +1366,7 @@ function buildZoneModel(entries, opts = {}) {
     if (!m) labelVotes.set(z, m = /* @__PURE__ */ new Map());
     bump(m, manual);
   }
-  const rename = /* @__PURE__ */ new Map();
+  const rename2 = /* @__PURE__ */ new Map();
   const takenNames = /* @__PURE__ */ new Set([SPINE_ZONE]);
   const clustersByEvidence = [...labelVotes.entries()].sort((a, b) => {
     const sum = (m) => [...m.values()].reduce((x, y) => x + y, 0);
@@ -1375,11 +1375,11 @@ function buildZoneModel(entries, opts = {}) {
   for (const [zone, votes] of clustersByEvidence) {
     const top = topKey(votes);
     if (!top || top.share < 0.6 || takenNames.has(top.key) || top.key === zone) continue;
-    rename.set(zone, top.key);
+    rename2.set(zone, top.key);
     takenNames.add(top.key);
   }
-  const renamed = (z) => rename.get(z) ?? z;
-  if (rename.size) {
+  const renamed = (z) => rename2.get(z) ?? z;
+  if (rename2.size) {
     for (const [f, z] of fileZone) fileZone.set(f, renamed(z));
     for (const [s, z] of taskZone) taskZone.set(s, renamed(z));
   }
@@ -2018,10 +2018,94 @@ var init_claudeResult = __esm({
   }
 });
 
-// src/executors/claudeCode.ts
-import { readdirSync as readdirSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
+// src/transcriptSpend.ts
+import { readFileSync as readFileSync2, readdirSync as readdirSync2, statSync } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
+function transcriptDir(worktree, projectsDir) {
+  return join2(projectsDir, worktree.replace(/[/.]/g, "-"));
+}
+function transcriptSpendInWindow(worktree, fromMs, toMs, opts = {}) {
+  const projectsDir = opts.projectsDir ?? join2(homedir2(), ".claude", "projects");
+  const empty = { costUsd: 0, tokensIn: 0, tokensOut: 0, durationMs: 0, replies: 0, unpriced: 0, unpricedModel: null };
+  const dir = transcriptDir(worktree, projectsDir);
+  let files;
+  try {
+    files = readdirSync2(dir).filter((f) => f.endsWith(".jsonl"));
+  } catch {
+    return empty;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  let costUsd = 0;
+  let tokensIn = 0;
+  let tokensOut = 0;
+  let firstAt = null;
+  let lastAt = null;
+  let replies = 0;
+  let unpriced = 0;
+  let unpricedModel = null;
+  for (const f of files) {
+    const path = join2(dir, f);
+    let raw;
+    try {
+      if (statSync(path).mtimeMs < fromMs) continue;
+      raw = readFileSync2(path, "utf8");
+    } catch {
+      continue;
+    }
+    for (const line of raw.split("\n")) {
+      if (!line.startsWith("{") || !line.includes('"usage"')) continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (entry.type !== "assistant") continue;
+      const usage2 = entry.message?.usage;
+      if (!usage2) continue;
+      const at = entry.timestamp ? Date.parse(entry.timestamp) : NaN;
+      if (!Number.isFinite(at) || at < fromMs || at >= toMs) continue;
+      const key = entry.requestId ?? entry.message?.id ?? entry.uuid;
+      if (!key || seen.has(key)) continue;
+      seen.add(key);
+      const model = entry.message?.model ?? null;
+      const est = costFromUsage(usage2, model, opts.table);
+      costUsd += est.costUsd;
+      if (est.warning) {
+        unpriced += 1;
+        unpricedModel ??= model;
+      }
+      const num = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
+      tokensIn += num(usage2.input_tokens) + num(usage2.cache_creation_input_tokens) + num(usage2.cache_read_input_tokens);
+      tokensOut += num(usage2.output_tokens);
+      if (firstAt === null || at < firstAt) firstAt = at;
+      if (lastAt === null || at > lastAt) lastAt = at;
+      replies += 1;
+    }
+  }
+  if (replies === 0) return empty;
+  return {
+    costUsd,
+    tokensIn,
+    tokensOut,
+    durationMs: firstAt !== null && lastAt !== null ? lastAt - firstAt : 0,
+    replies,
+    unpriced,
+    unpricedModel
+  };
+}
+var init_transcriptSpend = __esm({
+  "src/transcriptSpend.ts"() {
+    "use strict";
+    init_pricing();
+  }
+});
+
+// src/executors/claudeCode.ts
+import { readdirSync as readdirSync3, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir3 } 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)] : [];
@@ -2053,21 +2137,21 @@ function droneSettingsJson(paths, mergeGateHook = null) {
   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, "-"));
+function transcriptDir2(worktree, projectsDir) {
+  return join3(projectsDir, worktree.replace(/[/.]/g, "-"));
 }
-function sessionTranscriptExists(worktree, projectsDir = join2(homedir2(), ".claude", "projects")) {
+function sessionTranscriptExists(worktree, projectsDir = join3(homedir3(), ".claude", "projects")) {
   try {
-    return readdirSync2(transcriptDir(worktree, projectsDir)).some((f) => f.endsWith(".jsonl"));
+    return readdirSync3(transcriptDir2(worktree, projectsDir)).some((f) => f.endsWith(".jsonl"));
   } catch {
     return false;
   }
 }
-function transcriptMtimeMs(worktree, projectsDir = join2(homedir2(), ".claude", "projects")) {
-  const dir = transcriptDir(worktree, projectsDir);
+function transcriptMtimeMs(worktree, projectsDir = join3(homedir3(), ".claude", "projects")) {
+  const dir = transcriptDir2(worktree, projectsDir);
   let files;
   try {
-    files = readdirSync2(dir);
+    files = readdirSync3(dir);
   } catch {
     return null;
   }
@@ -2075,7 +2159,7 @@ function transcriptMtimeMs(worktree, projectsDir = join2(homedir2(), ".claude",
   for (const f of files) {
     if (!f.endsWith(".jsonl")) continue;
     try {
-      const mtime2 = statSync(join2(dir, f)).mtimeMs;
+      const mtime2 = statSync2(join3(dir, f)).mtimeMs;
       if (latest === null || mtime2 > latest) latest = mtime2;
     } catch {
     }
@@ -2088,7 +2172,7 @@ 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);
+  const path = join3(spec.worktree, MCP_CONFIG_FILE);
   writeFileSync2(path, JSON.stringify(cfg, null, 2));
   return path;
 }
@@ -2103,6 +2187,7 @@ var init_claudeCode = __esm({
     init_swarmFiles();
     init_mergeGateHook();
     init_claudeResult();
+    init_transcriptSpend();
     ISOLATION_FLAGS = ["--setting-sources", "project", "--strict-mcp-config"];
     MCP_CONFIG_FILE = SWARM_MCP_CONFIG_FILE;
     claudeCodeExecutor = {
@@ -2141,6 +2226,26 @@ var init_claudeCode = __esm({
           ...abortField(sessionAbort(result))
         };
       },
+      // TASWM-548: итога нет — берём трату из транскрипта сессии. Тот пишется по ходу работы и
+      // переживает SIGTERM разгрузки, из-за которого итог и не был напечатан; формат usage там
+      // тот же, что в итоге, поэтому цена считается тем же прайсингом (см. transcriptSpend.ts).
+      rescueSpend(worktree, fromMs, toMs) {
+        const spend = transcriptSpendInWindow(worktree, fromMs, toMs);
+        if (spend.replies === 0) return null;
+        return {
+          costUsd: spend.costUsd,
+          tokensIn: spend.tokensIn,
+          tokensOut: spend.tokensOut,
+          durationMs: spend.durationMs,
+          // Часть ответов не по чему было тарифицировать (модели нет в MODEL_PRICING) — их
+          // токены в трату вошли, а деньги НЕТ. Тот же канал, что и у warning штатного итога
+          // (cost.accountRunCost его печатает): иначе спасённые $0 при сожжённых токенах
+          // выглядели бы как честный ноль.
+          ...spend.unpriced > 0 ? {
+            warning: `\u0437\u0430\u043F\u0438\u0441\u044C \u0441\u0435\u0441\u0441\u0438\u0438: ${spend.unpriced} \u0438\u0437 ${spend.replies} \u043E\u0442\u0432\u0435\u0442\u043E\u0432 \u0431\u0435\u0437 \u0441\u0442\u0440\u043E\u043A\u0438 \u0432 \u043F\u0440\u0430\u0439\u0441\u0438\u043D\u0433\u0435 (\u043C\u043E\u0434\u0435\u043B\u044C "${spend.unpricedModel ?? ""}") \u2014 \u0438\u0445 \u0446\u0435\u043D\u0430 \u0432 \u0441\u043F\u0430\u0441\u0451\u043D\u043D\u0443\u044E \u0442\u0440\u0430\u0442\u0443 \u041D\u0415 \u0432\u043E\u0448\u043B\u0430`
+          } : {}
+        };
+      },
       session: {
         exists: (worktree) => sessionTranscriptExists(worktree),
         mtimeMs: (worktree) => transcriptMtimeMs(worktree)
@@ -2158,34 +2263,34 @@ var init_claudeCode = __esm({
 });
 
 // src/swarmHome.ts
-import { homedir as homedir3 } from "os";
-import { join as join3 } from "path";
+import { homedir as homedir4 } 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(homedir3(), ".taskless-swarm");
+    SWARM_HOME = process.env.SWARM_HOME || join4(homedir4(), ".taskless-swarm");
     mkdirSync2(SWARM_HOME, { recursive: true });
   }
 });
 
 // src/executors/codex.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readdirSync as readdirSync3, statSync as statSync2, symlinkSync } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readdirSync as readdirSync4, statSync as statSync3, 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);
   mkdirSync3(home, { recursive: true });
-  const real = (env.CODEX_HOME ?? "").trim() || join4(realHome, ".codex");
+  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);
+    const target = join5(real, file);
+    const link = join5(home, file);
     if (!existsSync3(target) || existsSync3(link)) continue;
     try {
       symlinkSync(target, link);
@@ -2244,16 +2349,16 @@ function parseCodexStream(raw) {
 function newestRolloutMtime(dir, depth = 4) {
   let entries;
   try {
-    entries = readdirSync3(dir);
+    entries = readdirSync4(dir);
   } catch {
     return null;
   }
   let latest = null;
   for (const name of entries) {
-    const full = join4(dir, name);
+    const full = join5(dir, name);
     let st;
     try {
-      st = statSync2(full);
+      st = statSync3(full);
     } catch {
       continue;
     }
@@ -2324,8 +2429,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, и живость
@@ -2372,8 +2477,8 @@ var init_executors = __esm({
 });
 
 // src/config.ts
-import { basename, join as join5, resolve } from "path";
-import { readFileSync as readFileSync2, realpathSync, renameSync, writeFileSync as writeFileSync3 } from "fs";
+import { basename, join as join6, resolve } from "path";
+import { readFileSync as readFileSync3, realpathSync, renameSync, writeFileSync as writeFileSync3 } from "fs";
 function normalizeRepo(repo) {
   const r = (repo ?? "").trim();
   if (!r) return "";
@@ -2387,10 +2492,10 @@ 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;
@@ -2417,7 +2522,7 @@ 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 "";
   }
@@ -2430,25 +2535,25 @@ 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);
-    ENV_CACHE_DIR = process.env.SWARM_ENV_CACHE_DIR || join5(SWARM_HOME, "env-cache");
+    ENV_CACHE_DIR = process.env.SWARM_ENV_CACHE_DIR || join6(SWARM_HOME, "env-cache");
     ENV_CACHE_ENABLED = process.env.SWARM_ENV_CACHE !== "0";
     ENV_CACHE_KEEP = Math.trunc(envNum("SWARM_ENV_CACHE_KEEP", 4));
     SWARM_MAX_LOAD_FACTOR = envNum("SWARM_MAX_LOAD_FACTOR", 0.9);
@@ -2478,15 +2583,15 @@ 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";
@@ -2501,7 +2606,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;
@@ -2541,7 +2646,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";
@@ -2593,7 +2698,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 {
     }
@@ -2817,11 +2922,11 @@ var init_zoneNotes = __esm({
 });
 
 // src/agentToken.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, unlinkSync } from "fs";
-import { join as join6 } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, unlinkSync } from "fs";
+import { join as join7 } from "path";
 function loadAgentToken() {
   try {
-    const s = JSON.parse(readFileSync4(STORE_PATH, "utf8"));
+    const s = JSON.parse(readFileSync5(STORE_PATH, "utf8"));
     return s.token ? s : null;
   } catch {
     return null;
@@ -2899,7 +3004,7 @@ var init_agentToken = __esm({
   "src/agentToken.ts"() {
     "use strict";
     init_config();
-    STORE_PATH = join6(SWARM_HOME, "agent.json");
+    STORE_PATH = join7(SWARM_HOME, "agent.json");
     base = (api) => api.replace(/\/$/, "");
     TOKEN_PROBE_TIMEOUT_MS = 8e3;
   }
@@ -3086,7 +3191,7 @@ var init_procList = __esm({
 
 // src/procCleanup.ts
 function sleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 function parseLsofCwd(output) {
   const rows = [];
@@ -3285,7 +3390,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@taskless-app/swarm",
-      version: "0.6.38",
+      version: "0.6.40",
       type: "module",
       description: "Local control plane for a fleet of AI coding agents (drones), coordinating through Taskless. The overmind runs the swarm.",
       keywords: [
@@ -3336,7 +3441,7 @@ var init_package = __esm({
         execa: "^10.0.0",
         zod: "3.25.76"
       },
-      gitHead: "b605569670600b022ae6eec5d042c385cc4c77dd"
+      gitHead: "b58ef18678e8c0e03e0602a40bf76d6f0a6975c8"
     };
   }
 });
@@ -3502,12 +3607,12 @@ var init_netTimeout = __esm({
 
 // src/droneChannel.ts
 import { createHmac, randomBytes, timingSafeEqual } from "crypto";
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync7, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync7, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
 import { dirname as dirname3 } from "path";
 import { serve } from "@hono/node-server";
 function loadChannelSecret(path) {
   try {
-    const s = readFileSync8(path, "utf8").trim();
+    const s = readFileSync9(path, "utf8").trim();
     if (s.length >= 32) return s;
   } catch {
   }
@@ -3590,8 +3695,8 @@ var init_authState = __esm({
 
 // src/oauth.ts
 import { createHash, randomBytes as randomBytes2 } from "crypto";
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync8, unlinkSync as unlinkSync3 } from "fs";
-import { join as join11 } from "path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync8, unlinkSync as unlinkSync3 } from "fs";
+import { join as join12 } from "path";
 function makePkce() {
   const verifier = randomBytes2(48).toString("base64url");
   const challenge = createHash("sha256").update(verifier).digest("base64url");
@@ -3675,7 +3780,7 @@ function toStore(clientId, t, now) {
 }
 function loadStore() {
   try {
-    return JSON.parse(readFileSync9(STORE_PATH2, "utf8"));
+    return JSON.parse(readFileSync10(STORE_PATH2, "utf8"));
   } catch {
     return null;
   }
@@ -3691,7 +3796,7 @@ function clearStore() {
 }
 function loadClientId() {
   try {
-    return JSON.parse(readFileSync9(CLIENT_PATH, "utf8")).clientId;
+    return JSON.parse(readFileSync10(CLIENT_PATH, "utf8")).clientId;
   } catch {
     return null;
   }
@@ -3726,16 +3831,16 @@ var init_oauth = __esm({
     AUTHORIZE = "/api/oauth/authorize";
     TOKEN = "/api/oauth/token";
     SCOPE = "openid profile email taskless:full";
-    STORE_PATH2 = join11(SWARM_HOME, "oauth.json");
-    CLIENT_PATH = join11(SWARM_HOME, "oauth-client.json");
+    STORE_PATH2 = join12(SWARM_HOME, "oauth.json");
+    CLIENT_PATH = join12(SWARM_HOME, "oauth-client.json");
     base2 = (api) => api.replace(/\/$/, "");
   }
 });
 
 // src/git.ts
-import { existsSync as existsSync10, readdirSync as readdirSync8, statSync as statSync8 } from "fs";
-import { appendFile, chmod, mkdir, readFile, rm, writeFile } from "fs/promises";
-import { isAbsolute, join as join14, sep as sep2 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync9, realpathSync as realpathSync2, statSync as statSync9 } from "fs";
+import { appendFile, chmod, mkdir, readFile, rename, rm, writeFile } from "fs/promises";
+import { isAbsolute, join as join15, resolve as resolve2, sep as sep2 } from "path";
 import { $ as $5 } from "execa";
 function gitNet(repo, args, timeoutMs) {
   return withHardTimeout(
@@ -3748,9 +3853,75 @@ function gitNet(repo, args, timeoutMs) {
 async function reclaimStaleWorktree(repo, worktree) {
   await detachWorktree(repo, worktree);
 }
+async function inspectWorktreePath(path) {
+  if (!existsSync10(path)) return "free";
+  try {
+    if (readdirSync9(path).length === 0) return "free";
+  } catch {
+    return "orphan";
+  }
+  try {
+    if (statSync9(join15(path, ".git")).isDirectory()) return "main-checkout";
+  } catch {
+  }
+  const top = await $5({ reject: false })`git -C ${path} rev-parse --show-toplevel`;
+  return top.exitCode === 0 && samePath(top.stdout.trim(), path) ? "worktree" : "orphan";
+}
+function samePath(a, b) {
+  const norm = (p) => {
+    try {
+      return realpathSync2(p);
+    } catch {
+      return resolve2(p);
+    }
+  };
+  const [x, y] = [norm(a), norm(b)];
+  return process.platform === "win32" ? posix(x).toLowerCase() === posix(y).toLowerCase() : x === y;
+}
+async function clearWorktreePath(repo, path, branch, opts = {}) {
+  const holder = await inspectWorktreePath(path);
+  if (holder === "free") return;
+  if (holder === "main-checkout") {
+    throw new WorktreeBusyError(
+      branch,
+      path,
+      `\u043F\u043E \u043F\u0443\u0442\u0438 worktree ${path} \u043B\u0435\u0436\u0438\u0442 \u041E\u0421\u041D\u041E\u0412\u041D\u041E\u0419 \u0447\u0435\u043A\u0430\u0443\u0442 \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u044F (\`.git\` \u2014 \u043A\u0430\u0442\u0430\u043B\u043E\u0433, \u0430 \u043D\u0435 \u0444\u0430\u0439\u043B) \u2014 \u044F \u0435\u0433\u043E \u043D\u0435 \u0442\u0440\u043E\u0433\u0430\u044E. \u041F\u043E\u0445\u043E\u0436\u0435, \u043A\u0430\u0442\u0430\u043B\u043E\u0433 worktree'\u0435\u0432 \u0440\u043E\u044F \u043D\u0430\u0441\u0442\u0440\u043E\u0435\u043D \u043D\u0430 \u0440\u0430\u0431\u043E\u0447\u0443\u044E \u043A\u043E\u043F\u0438\u044E \u0447\u0435\u043B\u043E\u0432\u0435\u043A\u0430; \u043F\u043E\u043F\u0440\u0430\u0432\u044C\u0442\u0435 \u043F\u0443\u0442\u044C, \u0441\u043F\u0430\u0432\u043D \u0442\u0443\u0434\u0430 \u0437\u0430\u0441\u0435\u043B\u044F\u0442\u044C\u0441\u044F \u043D\u0435 \u0431\u0443\u0434\u0435\u0442.`
+    );
+  }
+  if (holder === "worktree") {
+    if (opts.isWorktreeHeldLive ? await opts.isWorktreeHeldLive(path) : true) throw new WorktreeBusyError(branch, path);
+    if (await worktreeDirty(path)) {
+      throw new WorktreeBusyError(
+        branch,
+        path,
+        `worktree ${path} \u043E\u0441\u0438\u0440\u043E\u0442\u0435\u043B, \u043D\u043E \u0432\u043D\u0443\u0442\u0440\u0438 \u0435\u0441\u0442\u044C \u043D\u0435\u0441\u0434\u0430\u043D\u043D\u0430\u044F \u0440\u0430\u0431\u043E\u0442\u0430 (\u043D\u0435\u0437\u0430\u043A\u043E\u043C\u043C\u0438\u0447\u0435\u043D\u043D\u043E\u0435 \u0438\u043B\u0438 \u043D\u0435\u0437\u0430\u043F\u0443\u0448\u0435\u043D\u043D\u043E\u0435) \u2014 \u043D\u0435 \u0441\u043D\u043E\u0448\u0443. \u041F\u043E\u0441\u043C\u043E\u0442\u0440\u0438\u0442\u0435 \u0441\u0430\u043C\u0438 (\`git -C ${path} status --untracked-files=all\`) \u0438 \u0443\u0431\u0435\u0440\u0438\u0442\u0435 \u043A\u0430\u0442\u0430\u043B\u043E\u0433, \u043A\u043E\u0433\u0434\u0430 \u0431\u0443\u0434\u0435\u0442 \u043D\u0435 \u0436\u0430\u043B\u043A\u043E.`
+      );
+    }
+    await detachWorktree(repo, path);
+    opts.onStaleReclaim?.(path);
+  }
+  if (!existsSync10(path)) return;
+  await parkOrphanDir(repo, path, branch);
+}
+async function parkOrphanDir(repo, path, branch) {
+  const parked = `${path}.orphan-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+  try {
+    await rename(path, parked);
+  } catch (e) {
+    throw new WorktreeBusyError(
+      branch,
+      path,
+      `\u043F\u0443\u0442\u044C ${path} \u0437\u0430\u043D\u044F\u0442 \u043F\u043E\u0441\u0442\u043E\u0440\u043E\u043D\u043D\u0438\u043C \u043A\u0430\u0442\u0430\u043B\u043E\u0433\u043E\u043C, \u0438 \u043E\u0442\u043E\u0434\u0432\u0438\u043D\u0443\u0442\u044C \u0435\u0433\u043E \u043D\u0435 \u0432\u044B\u0448\u043B\u043E (${String(e)}) \u2014 \u0441\u043F\u0430\u0432\u043D ${branch} \u0442\u0443\u0434\u0430 \u043D\u0435 \u0432\u0441\u0442\u0430\u043D\u0435\u0442. \u0423\u0431\u0435\u0440\u0438\u0442\u0435 \u043A\u0430\u0442\u0430\u043B\u043E\u0433 \u0440\u0443\u043A\u0430\u043C\u0438 \u0438 \u0441\u0434\u0435\u043B\u0430\u0439\u0442\u0435 \`git -C ${repo} worktree prune\`.`
+    );
+  }
+  console.error(
+    `[git] \u043F\u043E \u043F\u0443\u0442\u0438 worktree ${path} \u043B\u0435\u0436\u0430\u043B \u043A\u0430\u0442\u0430\u043B\u043E\u0433, \u043A\u043E\u0442\u043E\u0440\u044B\u0439 git \u0441\u0432\u043E\u0438\u043C \u0440\u0430\u0431\u043E\u0447\u0438\u043C \u0434\u0435\u0440\u0435\u0432\u043E\u043C \u043D\u0435 \u0441\u0447\u0438\u0442\u0430\u0435\u0442 \u2014 \u043E\u0442\u043E\u0434\u0432\u0438\u043D\u0443\u043B \u0432 ${parked}, \u0447\u0442\u043E\u0431\u044B \u0441\u043F\u0430\u0432\u043D ${branch} \u043F\u043E\u0434\u043D\u044F\u043B\u0441\u044F. \u041F\u043E\u0441\u043C\u043E\u0442\u0440\u0438\u0442\u0435, \u0447\u0442\u043E \u0432\u043D\u0443\u0442\u0440\u0438, \u0438 \u0443\u0434\u0430\u043B\u0438\u0442\u0435, \u0435\u0441\u043B\u0438 \u043D\u0435 \u043D\u0443\u0436\u043D\u043E.`
+  );
+  await $5({ reject: false })`git -C ${repo} worktree prune`;
+}
 function isLinkedWorktree(dir) {
   try {
-    return statSync8(join14(dir, ".git")).isFile();
+    return statSync9(join15(dir, ".git")).isFile();
   } catch {
     return false;
   }
@@ -3820,6 +3991,7 @@ async function checkoutWorktree(repo, path, branch, opts) {
   const originSha = await revParse(repo, `refs/remotes/origin/${branch}`);
   if (!localSha && !originSha) {
     const freshBase = opts.base ?? await freshWorktreeBase(repo);
+    await clearWorktreePath(repo, path, branch, opts);
     await $5`git -C ${repo} worktree add -b ${branch} ${path} ${freshBase}`;
     return { reused: false };
   }
@@ -3832,6 +4004,7 @@ async function checkoutWorktree(repo, path, branch, opts) {
     await reclaimStaleWorktree(repo, busyAt);
     opts.onStaleReclaim?.(busyAt);
   }
+  await clearWorktreePath(repo, path, branch, opts);
   if (originSha) {
     await $5`git -C ${repo} worktree add -B ${branch} ${path} ${`origin/${branch}`}`;
     return { reused: true, from: "origin", sha: originSha };
@@ -3855,8 +4028,8 @@ async function ensureGitExcluded(worktree, pattern) {
   try {
     const commonDir = await gitPath(worktree, "--git-common-dir");
     if (!commonDir) return false;
-    const infoDir = join14(commonDir, "info");
-    const excludeFile = join14(infoDir, "exclude");
+    const infoDir = join15(commonDir, "info");
+    const excludeFile = join15(infoDir, "exclude");
     let current = "";
     try {
       current = await readFile(excludeFile, "utf8");
@@ -3876,7 +4049,7 @@ async function gitPath(worktree, flag) {
   const out = await $5({ reject: false })`git -C ${worktree} rev-parse ${flag}`;
   const raw = out.stdout.trim();
   if (out.exitCode !== 0 || !raw) return null;
-  return isAbsolute(raw) ? raw : join14(worktree, raw);
+  return isAbsolute(raw) ? raw : join15(worktree, raw);
 }
 async function ensureWorktreeHygiene(worktree) {
   for (const pattern of SWARM_EXCLUDE_PATTERNS) await ensureGitExcluded(worktree, pattern);
@@ -3886,12 +4059,12 @@ async function installGuardHooks(worktree) {
   try {
     const gitDir = await gitPath(worktree, "--git-dir");
     if (!gitDir) return false;
-    const hooksDir = join14(gitDir, "swarm-hooks");
+    const hooksDir = join15(gitDir, "swarm-hooks");
     const prev = await previousHooksPath(worktree);
     await mkdir(hooksDir, { recursive: true });
     for (const hook of GUARD_HOOKS) {
-      await writeFile(join14(hooksDir, hook), guardHookScript(hook, prev ? `${posix(prev)}/${hook}` : null));
-      await chmod(join14(hooksDir, hook), 493);
+      await writeFile(join15(hooksDir, hook), guardHookScript(hook, prev ? `${posix(prev)}/${hook}` : null));
+      await chmod(join15(hooksDir, hook), 493);
     }
     await $5`git -C ${worktree} config extensions.worktreeConfig true`;
     await $5`git -C ${worktree} config --worktree core.hooksPath ${posix(hooksDir)}`;
@@ -3910,7 +4083,7 @@ async function previousHooksPath(worktree) {
     if (out.exitCode === 0 && value) return value;
   }
   const commonDir = await gitPath(worktree, "--git-common-dir");
-  return commonDir ? join14(commonDir, "hooks") : null;
+  return commonDir ? join15(commonDir, "hooks") : null;
 }
 async function removeWorktree(repo, path) {
   const branch = (await $5({ reject: false })`git -C ${path} symbolic-ref --quiet --short HEAD`).stdout.trim();
@@ -3952,8 +4125,14 @@ var init_git = __esm({
     init_netTimeout();
     init_swarmFiles();
     WorktreeBusyError = class extends Error {
-      constructor(branch, worktreePath) {
-        super(`worktree \u0437\u0430\u043D\u044F\u0442: ${worktreePath} (\u0432\u0435\u0442\u043A\u0430 ${branch}) \u2014 \u043F\u0440\u0438\u0431\u0435\u0440\u0438 worktree \u0438\u043B\u0438 \u043E\u0442\u043C\u0435\u043D\u0438 \u043F\u0440\u043E\u0433\u043E\u043D (swarm cancel ${branch})`);
+      /**
+       * `why` (TASWM-553) — ПОЧЕМУ путь не отдали, если причина не «его держит живой прогон»:
+       * основной чекаут по пути worktree, каталог с несданной работой, каталог, который не
+       * получилось убрать. Дефолтная формулировка («прибери worktree или отмени прогон»)
+       * человеку в таких случаях не помогает — она отправляет его не туда.
+       */
+      constructor(branch, worktreePath, why) {
+        super(why ?? `worktree \u0437\u0430\u043D\u044F\u0442: ${worktreePath} (\u0432\u0435\u0442\u043A\u0430 ${branch}) \u2014 \u043F\u0440\u0438\u0431\u0435\u0440\u0438 worktree \u0438\u043B\u0438 \u043E\u0442\u043C\u0435\u043D\u0438 \u043F\u0440\u043E\u0433\u043E\u043D (swarm cancel ${branch})`);
         this.branch = branch;
         this.worktreePath = worktreePath;
         this.name = "WorktreeBusyError";
@@ -3967,7 +4146,7 @@ var init_git = __esm({
 
 // src/attachments.ts
 import { mkdir as mkdir2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 var ATTACHMENTS_DIR, ATTACH_MAX_TOTAL_BYTES, ATTACH_MAX_FILE_BYTES, IMAGE_EXT, DOC_EXT, TEXT_EXT, KNOWN_EXT;
 var init_attachments = __esm({
   "src/attachments.ts"() {
@@ -3986,7 +4165,7 @@ var init_attachments = __esm({
 
 // src/shotUpload.ts
 import { readFile as fsReadFile } from "fs/promises";
-import { basename as basename5, isAbsolute as isAbsolute2, join as join16 } from "path";
+import { basename as basename5, isAbsolute as isAbsolute2, join as join17 } from "path";
 var SHOT_MAX_FILE_BYTES;
 var init_shotUpload = __esm({
   "src/shotUpload.ts"() {
@@ -3996,11 +4175,11 @@ var init_shotUpload = __esm({
 });
 
 // src/workspace.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync9, unlinkSync as unlinkSync4 } from "fs";
-import { join as join17 } from "path";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync9, unlinkSync as unlinkSync4 } from "fs";
+import { join as join18 } from "path";
 function loadWorkspace() {
   try {
-    const w = JSON.parse(readFileSync10(WORKSPACE_PATH, "utf8"));
+    const w = JSON.parse(readFileSync11(WORKSPACE_PATH, "utf8"));
     return w && typeof w.id === "string" && w.id ? w : null;
   } catch {
     return null;
@@ -4023,7 +4202,7 @@ var init_workspace = __esm({
   "src/workspace.ts"() {
     "use strict";
     init_config();
-    WORKSPACE_PATH = join17(SWARM_HOME, "workspace.json");
+    WORKSPACE_PATH = join18(SWARM_HOME, "workspace.json");
   }
 });
 
@@ -4248,14 +4427,14 @@ function createNetworkSettleTracker(target) {
   });
   target.on("requestfinished", onDone);
   target.on("requestfailed", onDone);
-  const settleOnce = (quietMs, budgetMs) => new Promise((resolve4) => {
+  const settleOnce = (quietMs, budgetMs) => new Promise((resolve5) => {
     let quietTimer;
     const hardTimer = setTimeout(finish, Math.max(0, budgetMs));
     function finish() {
       clearTimeout(quietTimer);
       clearTimeout(hardTimer);
       onChange.delete(check);
-      resolve4();
+      resolve5();
     }
     function check() {
       clearTimeout(quietTimer);
@@ -4441,14 +4620,14 @@ var init_daemonLink = __esm({
 });
 
 // src/pauseState.ts
-import { existsSync as existsSync11, readFileSync as readFileSync11, renameSync as renameSync5, unlinkSync as unlinkSync5, writeFileSync as writeFileSync10 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync12, renameSync as renameSync5, unlinkSync as unlinkSync5, writeFileSync as writeFileSync10 } from "fs";
+import { join as join19 } from "path";
 function pauseStatePath(home) {
-  return join18(home, "pause.json");
+  return join19(home, "pause.json");
 }
 function loadPauseState(home, io = {}) {
   const exists = io.exists ?? existsSync11;
-  const readFile2 = io.readFile ?? ((p) => readFileSync11(p, "utf8"));
+  const readFile2 = io.readFile ?? ((p) => readFileSync12(p, "utf8"));
   const path = pauseStatePath(home);
   if (!exists(path)) return ACTIVE;
   try {
@@ -4509,10 +4688,10 @@ var init_pauseState = __esm({
 });
 
 // src/heartbeat.ts
-import { readFileSync as readFileSync12, renameSync as renameSync6, writeFileSync as writeFileSync11 } from "fs";
+import { readFileSync as readFileSync13, renameSync as renameSync6, writeFileSync as writeFileSync11 } from "fs";
 function readHeartbeat(path) {
   try {
-    const ms = Number(readFileSync12(path, "utf8").trim());
+    const ms = Number(readFileSync13(path, "utf8").trim());
     return Number.isFinite(ms) ? ms : null;
   } catch {
     return null;
@@ -4532,7 +4711,7 @@ __export(db_exports, {
 import { createRequire as createRequire2 } from "module";
 import { randomUUID as randomUUID3 } from "crypto";
 import { existsSync as existsSync12 } from "fs";
-import { resolve as resolve2 } from "path";
+import { resolve as resolve3 } from "path";
 function rowToQuestion(row) {
   return {
     id: row.id,
@@ -4574,6 +4753,7 @@ function rowToRun(row) {
     tokens_in: row.tokens_in ?? 0,
     tokens_out: row.tokens_out ?? 0,
     duration_ms: row.duration_ms ?? 0,
+    cost_unmeasured: row.cost_unmeasured ?? 0,
     pr_url: row.pr_url ?? null,
     // TASWM-506: файлы, занятые прогоном с открытым PR — JSON-массив, как depends_on.
     changed_paths: row.changed_paths ? JSON.parse(row.changed_paths) : [],
@@ -4654,6 +4834,7 @@ CREATE TABLE IF NOT EXISTS runs (
   tokens_in INTEGER NOT NULL DEFAULT 0,
   tokens_out INTEGER NOT NULL DEFAULT 0,
   duration_ms INTEGER NOT NULL DEFAULT 0,
+  cost_unmeasured INTEGER NOT NULL DEFAULT 0,
   pr_url TEXT,
   superseded_by INTEGER,
   decision TEXT,
@@ -4769,6 +4950,10 @@ CREATE TABLE IF NOT EXISTS imports (
           "ALTER TABLE runs ADD COLUMN tokens_in INTEGER NOT NULL DEFAULT 0",
           "ALTER TABLE runs ADD COLUMN tokens_out INTEGER NOT NULL DEFAULT 0",
           "ALTER TABLE runs ADD COLUMN duration_ms INTEGER NOT NULL DEFAULT 0",
+          // TASWM-548: сколько запусков прогона остались без снятой цены — отличает «бесплатно»
+          // от «не измерено». Прогоны до фичи получают 0: их нули мы перепроверить уже не можем,
+          // а задним числом объявлять их неизмеренными значило бы утверждать непроверенное.
+          "ALTER TABLE runs ADD COLUMN cost_unmeasured INTEGER NOT NULL DEFAULT 0",
           // TASWM-395: усилие рассуждения прогона (`claude --effort`). Nullable без DEFAULT —
           // NULL это и все прогоны до фичи, и прогоны на дефолте харнесса.
           "ALTER TABLE runs ADD COLUMN effort TEXT",
@@ -5155,7 +5340,7 @@ CREATE TABLE IF NOT EXISTS imports (
        * транзакции: прервётся — маркер не встанет, повтор безопасен.
        */
       importDb(sourcePath, repo) {
-        const abs = resolve2(sourcePath);
+        const abs = resolve3(sourcePath);
         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 };
@@ -5486,8 +5671,8 @@ CREATE TABLE IF NOT EXISTS imports (
 });
 
 // src/repoScan.ts
-import { readdirSync as readdirSync9, readFileSync as readFileSync13, statSync as statSync9 } from "fs";
-import { join as join19 } from "path";
+import { readdirSync as readdirSync10, readFileSync as readFileSync14, statSync as statSync10 } from "fs";
+import { join as join20 } from "path";
 var init_repoScan = __esm({
   "src/repoScan.ts"() {
     "use strict";
@@ -5496,9 +5681,9 @@ var init_repoScan = __esm({
 });
 
 // src/repoDiscovery.ts
-import { homedir as homedir5 } from "os";
-import { readFileSync as readFileSync14, renameSync as renameSync7, writeFileSync as writeFileSync12 } from "fs";
-import { isAbsolute as isAbsolute3, join as join20, resolve as resolve3 } from "path";
+import { homedir as homedir6 } from "os";
+import { readFileSync as readFileSync15, renameSync as renameSync7, writeFileSync as writeFileSync12 } from "fs";
+import { isAbsolute as isAbsolute3, join as join21, resolve as resolve4 } from "path";
 function repoMapLines(rows) {
   if (!rows?.length) return [];
   const missing = rows.filter((r) => !r.path).length;
@@ -5513,7 +5698,7 @@ function repoMapLines(rows) {
 }
 function loadRepoMapCache(path) {
   try {
-    const raw = JSON.parse(readFileSync14(path, "utf8"));
+    const raw = JSON.parse(readFileSync15(path, "utf8"));
     if (!Array.isArray(raw?.entries)) return { scannedAt: null, entries: [] };
     return {
       scannedAt: typeof raw.scannedAt === "string" && raw.scannedAt ? raw.scannedAt : null,
@@ -5882,11 +6067,11 @@ __export(statusCli_exports, {
   probeLink: () => probeLink,
   runStatusCli: () => runStatusCli
 });
-import { existsSync as existsSync13, readFileSync as readFileSync15 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync16 } from "fs";
 function outboxPending(path) {
   try {
     if (!existsSync13(path)) return 0;
-    return readFileSync15(path, "utf8").split("\n").filter((l) => l.trim()).length;
+    return readFileSync16(path, "utf8").split("\n").filter((l) => l.trim()).length;
   } catch {
     return null;
   }
@@ -6093,11 +6278,11 @@ var init_prodMergeGate = __esm({
 });
 
 // src/platform.ts
-import { existsSync as existsSync14, readFileSync as readFileSync16 } from "fs";
-import { delimiter, join as join21 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync17 } from "fs";
+import { delimiter, join as join22 } from "path";
 function safeReadText(path) {
   try {
-    return readFileSync16(path, "utf8");
+    return readFileSync17(path, "utf8");
   } catch {
     return null;
   }
@@ -6108,7 +6293,7 @@ function resolveCommandPath(name, env = process.env, platform = process.platform
   const exts = platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").filter(Boolean) : [""];
   for (const dir of dirs) {
     for (const ext of exts) {
-      const candidate = join21(dir, name + ext);
+      const candidate = join22(dir, name + ext);
       if (existsSync14(candidate)) return candidate;
     }
   }
@@ -6213,12 +6398,12 @@ var init_platform = __esm({
 
 // src/envGate.ts
 import { existsSync as existsSync15 } from "fs";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 import { createConnection } from "net";
 import { execa as execa3 } from "execa";
 function detectRequirements(repo, io = {}) {
   const exists = io.exists ?? existsSync15;
-  const marker = COMPOSE_MARKERS.find((f) => exists(join22(repo, f)));
+  const marker = COMPOSE_MARKERS.find((f) => exists(join23(repo, f)));
   return marker ? [{ kind: "docker", raw: `docker (\u0434\u0435\u0442\u0435\u043A\u0442: ${marker})` }] : [];
 }
 async function dockerAlive() {
@@ -6250,7 +6435,7 @@ var init_envGate = __esm({
 });
 
 // src/doctor.ts
-import { isAbsolute as isAbsolute4, join as join23 } from "path";
+import { isAbsolute as isAbsolute4, join as join24 } from "path";
 function ok(id, title, detail) {
   return { id, title, status: "ok", detail, remedies: [], critical: false };
 }
@@ -6457,7 +6642,7 @@ function checkRepos(io, snap) {
       critical: true
     };
   }
-  if (env && !io.exists(join23(env, ".git"))) {
+  if (env && !io.exists(join24(env, ".git"))) {
     return {
       id: "repos",
       title,
@@ -6467,7 +6652,7 @@ function checkRepos(io, snap) {
       critical: true
     };
   }
-  const broken = snap.paths.filter((p) => !io.exists(join23(p, ".git")));
+  const broken = snap.paths.filter((p) => !io.exists(join24(p, ".git")));
   if (broken.length) {
     return {
       id: "repos",
@@ -6657,12 +6842,12 @@ var init_doctor = __esm({
 });
 
 // src/repoMemory.ts
-import { readFileSync as readFileSync17, writeFileSync as writeFileSync13 } from "fs";
-import { join as join24 } from "path";
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync13 } from "fs";
+import { join as join25 } from "path";
 function loadRememberedRepos(home) {
   let raw;
   try {
-    raw = readFileSync17(join24(home, FILE), "utf8");
+    raw = readFileSync18(join25(home, FILE), "utf8");
   } catch {
     return [];
   }
@@ -6981,8 +7166,8 @@ var init_updateCli = __esm({
 
 // src/cli.ts
 init_cliIo();
-import { basename as basename6, dirname as dirname5, join as join25 } from "path";
-import { existsSync as existsSync17, readFileSync as readFileSync18, writeFileSync as writeFileSync14, mkdirSync as mkdirSync10, readdirSync as readdirSync10, statSync as statSync10, openSync as openSync4, readSync as readSync2, closeSync as closeSync4 } from "fs";
+import { basename as basename6, dirname as dirname5, join as join26 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync19, writeFileSync as writeFileSync14, mkdirSync as mkdirSync10, readdirSync as readdirSync11, statSync as statSync11, openSync as openSync4, readSync as readSync2, closeSync as closeSync4 } from "fs";
 import { setTimeout as sleep2 } from "timers/promises";
 
 // src/swarmClient.ts
@@ -6990,7 +7175,7 @@ init_config();
 init_resources();
 init_names2();
 init_storm();
-import { appendFileSync, existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
+import { appendFileSync, existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
 import { dirname as dirname2 } from "path";
 import { randomUUID } from "crypto";
 
@@ -7022,19 +7207,19 @@ init_zoneNotes();
 init_toolFailure();
 
 // src/logTail.ts
-import { closeSync, existsSync as existsSync5, openSync, readSync, readdirSync as readdirSync5, statSync as statSync4 } from "fs";
-import { join as join8 } from "path";
+import { closeSync, existsSync as existsSync5, openSync, readSync, readdirSync as readdirSync6, statSync as statSync5 } from "fs";
+import { join as join9 } from "path";
 
 // src/runLogDir.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync5, readdirSync as readdirSync4, renameSync as renameSync2, statSync as statSync3 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync5, readdirSync as readdirSync5, renameSync as renameSync2, statSync as statSync4 } from "fs";
+import { join as join8 } from "path";
 function runLogDirName(runLogKey) {
   const safe = runLogKey.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^[-_]+|[-_]+$/g, "");
   if (!safe) throw new Error(`\u043A\u043B\u044E\u0447 \u043F\u0440\u043E\u0433\u043E\u043D\u0430 \u043D\u0435 \u0433\u043E\u0434\u0438\u0442\u0441\u044F \u0432 \u0438\u043C\u044F \u043A\u0430\u0442\u0430\u043B\u043E\u0433\u0430 run-log'\u043E\u0432: ${JSON.stringify(runLogKey)}`);
   return /^\d+$/.test(safe) ? `k-${safe}` : safe;
 }
 function runLogDirPath(runLogsDir, runLogKey) {
-  return join7(runLogsDir, runLogDirName(runLogKey));
+  return join8(runLogsDir, runLogDirName(runLogKey));
 }
 function findRunLogDir(runLogsDir, keys) {
   for (const key of keys) {
@@ -7246,13 +7431,13 @@ var SwarmClient = class _SwarmClient {
   recover() {
     if (existsSync6(this.mapPath)) {
       try {
-        const obj = JSON.parse(readFileSync5(this.mapPath, "utf8"));
+        const obj = JSON.parse(readFileSync6(this.mapPath, "utf8"));
         for (const [k, v] of Object.entries(obj)) this.prodIdByKey.set(k, v);
       } catch {
       }
     }
     if (existsSync6(this.outboxPath)) {
-      const txt = readFileSync5(this.outboxPath, "utf8");
+      const txt = readFileSync6(this.outboxPath, "utf8");
       for (const line of txt.split("\n")) {
         const s = line.trim();
         if (!s) continue;
@@ -7275,7 +7460,7 @@ var SwarmClient = class _SwarmClient {
     if (!existsSync6(this.stormPath)) return;
     let txt;
     try {
-      txt = readFileSync5(this.stormPath, "utf8");
+      txt = readFileSync6(this.stormPath, "utf8");
     } catch {
       return;
     }
@@ -7359,6 +7544,7 @@ var SwarmClient = class _SwarmClient {
     if ("tokens_in" in patch && patch.tokens_in !== void 0) out.tokensIn = patch.tokens_in;
     if ("tokens_out" in patch && patch.tokens_out !== void 0) out.tokensOut = patch.tokens_out;
     if ("duration_ms" in patch && patch.duration_ms !== void 0) out.durationMs = patch.duration_ms;
+    if ("cost_unmeasured" in patch && patch.cost_unmeasured !== void 0) out.costUnmeasured = patch.cost_unmeasured;
     if ("respawns" in patch && patch.respawns !== void 0) out.respawns = patch.respawns;
     if ("pr_url" in patch) out.prUrl = patch.pr_url ?? null;
     if ("changed_paths" in patch && patch.changed_paths) out.changedPaths = patch.changed_paths;
@@ -7441,6 +7627,8 @@ var SwarmClient = class _SwarmClient {
       // копятся учётом запусков claude (cost.ts), как cost_usd — TASWM-353
       tokens_out: 0,
       duration_ms: 0,
+      cost_unmeasured: 0,
+      // запусков без снятой цены (TASWM-548) — копится тем же учётом
       pr_url: null,
       changed_paths: [],
       // файлы прогона снимаются при открытии PR (TASWM-506)
@@ -9061,6 +9249,8 @@ var SwarmClient = class _SwarmClient {
         // токены и время работы (TASWM-353) — прод-поля, заполняются ниже
         tokens_out: 0,
         duration_ms: 0,
+        cost_unmeasured: 0,
+        // запусков без снятой цены (TASWM-548) — прод-поле, заполняется ниже
         pr_url: null,
         changed_paths: [],
         // занятые файлы (TASWM-506) — прод-поле, заполняется ниже
@@ -9142,6 +9332,7 @@ var SwarmClient = class _SwarmClient {
     local.tokens_in = typeof pr.tokensIn === "number" ? pr.tokensIn : 0;
     local.tokens_out = typeof pr.tokensOut === "number" ? pr.tokensOut : 0;
     local.duration_ms = typeof pr.durationMs === "number" ? pr.durationMs : 0;
+    local.cost_unmeasured = typeof pr.costUnmeasured === "number" ? pr.costUnmeasured : 0;
     local.pr_url = pr.prUrl ?? null;
     local.changed_paths = Array.isArray(pr.changedPaths) ? pr.changedPaths : local.changed_paths ?? [];
     local.stop_reason = pr.stopReason ?? null;
@@ -9539,7 +9730,7 @@ init_config();
 import { $ as $6 } from "execa";
 
 // src/daemonLaunch.ts
-import { openSync as openSync2, closeSync as closeSync2, readFileSync as readFileSync6 } from "fs";
+import { openSync as openSync2, closeSync as closeSync2, readFileSync as readFileSync7 } from "fs";
 import { spawn } from "child_process";
 var FOREGROUND_FLAGS = /* @__PURE__ */ new Set(["--foreground", "-f", "--attach"]);
 function parseStartMode(argv) {
@@ -9599,18 +9790,18 @@ function launchDetached(opts) {
 }
 function tailFile(path, lines) {
   try {
-    return tailText(readFileSync6(path, "utf8"), lines);
+    return tailText(readFileSync7(path, "utf8"), lines);
   } catch {
     return "";
   }
 }
 
 // src/logRotate.ts
-import { copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync5, fstatSync, truncateSync, unlinkSync as unlinkSync2, existsSync as existsSync7 } from "fs";
+import { copyFileSync as copyFileSync2, renameSync as renameSync3, statSync as statSync6, fstatSync, truncateSync, unlinkSync as unlinkSync2, existsSync as existsSync7 } from "fs";
 var realIo = {
   size: (path) => {
     try {
-      return statSync5(path).size;
+      return statSync6(path).size;
     } catch {
       return null;
     }
@@ -9647,15 +9838,15 @@ init_repoRegistry();
 
 // src/hostIdentity.ts
 import { hostname } from "os";
-import { existsSync as existsSync8, readFileSync as readFileSync7, renameSync as renameSync4, writeFileSync as writeFileSync6 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync8, renameSync as renameSync4, writeFileSync as writeFileSync6 } from "fs";
+import { join as join10 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function hostIdentityPath(home) {
-  return join9(home, "host.json");
+  return join10(home, "host.json");
 }
 function loadHostIdentity(deps) {
   const exists = deps.exists ?? existsSync8;
-  const readFile2 = deps.readFile ?? ((p) => readFileSync7(p, "utf8"));
+  const readFile2 = deps.readFile ?? ((p) => readFileSync8(p, "utf8"));
   const writeFile3 = deps.writeFile ?? ((p, data) => {
     writeFileSync6(`${p}.tmp`, data);
     renameSync4(`${p}.tmp`, p);
@@ -9772,8 +9963,8 @@ import { basename as basename4 } from "path";
 import { serve as serve2 } from "@hono/node-server";
 
 // src/diff.ts
-import { statSync as statSync6 } from "fs";
-import { join as join10 } from "path";
+import { statSync as statSync7 } from "fs";
+import { join as join11 } from "path";
 import { $ as $3 } from "execa";
 var MAX_FILES = 200;
 var MAX_LINES_PER_FILE = 1500;
@@ -9916,7 +10107,7 @@ async function resolveBase(wt, baseBranch) {
 }
 function mtime(path) {
   try {
-    return statSync6(path).mtimeMs;
+    return statSync7(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -9941,7 +10132,7 @@ async function collectRunDiff(worktree, opts = {}) {
       files.push(pf);
     }
   }
-  files.sort((a, b) => mtime(join10(worktree, b.path)) - mtime(join10(worktree, a.path)));
+  files.sort((a, b) => mtime(join11(worktree, b.path)) - mtime(join11(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);
@@ -11667,14 +11858,14 @@ function makeHandler(deps) {
       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({
+      const resolve5 = deps.mergeGate ?? makeMergeGateResolver({
         listRuns: () => deps.db.listRuns(),
         fallbackAutoReview: SWARM_AUTO_REVIEW,
         autoVerify: SWARM_AUTO_VERIFY,
         // TASWM-344
         ...defaultRepo ? { repoFallback: defaultRepo } : {}
       });
-      return Response.json(await resolve4(ref, ctxRepo));
+      return Response.json(await resolve5(ref, ctxRepo));
     }
     if (p === "/resources") return Response.json(hostResourceSnapshot());
     if (p === "/timeline") return Response.json(timelineState(deps.db, Date.now(), readNarratorLog(deps.narratorLog)));
@@ -11832,15 +12023,15 @@ import { cancelRun, respawnRun, runDaemon, wakeRun, OVERMIND_ENTRY, listDronePro
 
 // src/launcher.ts
 import { spawn as spawn2 } from "child_process";
-import { closeSync as closeSync3, existsSync as existsSync9, mkdirSync as mkdirSync9, openSync as openSync3, readdirSync as readdirSync7 } from "fs";
+import { closeSync as closeSync3, existsSync as existsSync9, mkdirSync as mkdirSync9, openSync as openSync3, readdirSync as readdirSync8 } from "fs";
 import { createRequire } from "module";
-import { homedir as homedir4 } from "os";
-import { dirname as dirname4, join as join13 } from "path";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname4, join as join14 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/droneHome.ts
-import { lstatSync, mkdirSync as mkdirSync8, readdirSync as readdirSync6, rmSync, statSync as statSync7, symlinkSync as symlinkSync2 } from "fs";
-import { join as join12, relative, sep } from "path";
+import { lstatSync, mkdirSync as mkdirSync8, readdirSync as readdirSync7, rmSync, statSync as statSync8, symlinkSync as symlinkSync2 } from "fs";
+import { join as join13, relative, sep } from "path";
 var DRONE_HOME_DENY_DEFAULT = [".taskless-swarm", ".bash_history", ".zsh_history"];
 function droneHomeDeny(env = process.env) {
   const extra = (env.SWARM_DRONE_HOME_DENY || "").split(",").map((s) => s.trim()).filter(Boolean);
@@ -11859,28 +12050,28 @@ function buildDroneHome(opts) {
   const deny = opts.deny ?? droneHomeDeny();
   const platform = opts.platform ?? process.platform;
   mkdirSync8(droneHome, { recursive: true, mode: 448 });
-  const wanted = new Set(mirroredEntries(readdirSync6(realHome), deny, platform));
+  const wanted = new Set(mirroredEntries(readdirSync7(realHome), deny, platform));
   const rel = relative(realHome, droneHome);
   if (rel && !rel.startsWith("..") && !rel.includes(sep)) wanted.delete(rel);
-  for (const existing of readdirSync6(droneHome)) {
+  for (const existing of readdirSync7(droneHome)) {
     if (wanted.has(existing)) continue;
-    const p = join12(droneHome, existing);
+    const p = join13(droneHome, existing);
     try {
       if (lstatSync(p).isSymbolicLink()) rmSync(p);
     } catch {
     }
   }
   for (const name of wanted) {
-    const link = join12(droneHome, name);
+    const link = join13(droneHome, name);
     try {
       lstatSync(link);
       continue;
     } catch {
     }
-    const target = join12(realHome, name);
+    const target = join13(realHome, name);
     let isDir;
     try {
-      isDir = statSync7(target).isDirectory();
+      isDir = statSync8(target).isDirectory();
     } catch {
       continue;
     }
@@ -11898,7 +12089,7 @@ var REAL_PATH_ENV_PINS = [
   { env: "YARN_GLOBAL_FOLDER", segments: [".yarn", "berry"] }
 ];
 function realPathEnvPins(realHome) {
-  return Object.fromEntries(REAL_PATH_ENV_PINS.map(({ env, segments }) => [env, join12(realHome, ...segments)]));
+  return Object.fromEntries(REAL_PATH_ENV_PINS.map(({ env, segments }) => [env, join13(realHome, ...segments)]));
 }
 function dronePrivatePaths(realHome, swarmHome) {
   return [
@@ -12010,7 +12201,7 @@ function droneEnv(worktree, base3 = process.env, isolation, droneCap = null) {
   const env = { ...base3 };
   const isolate = base3.SWARM_TURBO_ISOLATE !== "0";
   if (isolate && !base3.TURBO_CACHE_DIR) {
-    env.TURBO_CACHE_DIR = join13(worktree, ".turbo", "cache");
+    env.TURBO_CACHE_DIR = join14(worktree, ".turbo", "cache");
   }
   Object.assign(env, droneTestEnv(droneCap, base3));
   for (const key of DAEMON_STATE_ENV) delete env[key];
@@ -12038,10 +12229,10 @@ var DAEMON_STATE_ENV = [
   "TASKLESS_TOKEN"
 ];
 function bundledRoleDir(kind) {
-  return join13(dirname4(fileURLToPath2(import.meta.url)), "..", "roles", kind);
+  return join14(dirname4(fileURLToPath2(import.meta.url)), "..", "roles", kind);
 }
 function roleDir(worktree, kind) {
-  return join13(worktree, ".claude", "roles", kind);
+  return join14(worktree, ".claude", "roles", kind);
 }
 function roleDirs(worktree, kind) {
   return [bundledRoleDir(kind), roleDir(worktree, kind)].filter((dir) => existsSync9(dir));
@@ -12052,7 +12243,7 @@ function nextRunLogPath(runLogsDir, runLogKeys) {
   mkdirSync9(dir, { recursive: true });
   let files = [];
   try {
-    files = readdirSync7(dir);
+    files = readdirSync8(dir);
   } catch {
   }
   let next = 0;
@@ -12060,7 +12251,7 @@ function nextRunLogPath(runLogsDir, runLogKeys) {
     const m = /^(\d+)\.json/.exec(f);
     if (m) next = Math.max(next, Number(m[1]) + 1);
   }
-  return join13(dir, `${next}.json`);
+  return join14(dir, `${next}.json`);
 }
 function openNextRunLog(runLogsDir, runLogKeys) {
   for (let attempt = 0; attempt < 50; attempt++) {
@@ -12141,11 +12332,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(join13(cfg.droneIsolation.swarmHome, "token"))) {
+    if (cfg.droneIsolation && process.env.TASKLESS_TOKEN && !existsSync9(join14(cfg.droneIsolation.swarmHome, "token"))) {
       console.error(
-        `[launcher] TASKLESS_TOKEN \u0437\u0430\u0434\u0430\u043D \u0442\u043E\u043B\u044C\u043A\u043E \u0432 env \u0434\u0435\u043C\u043E\u043D\u0430 \u2014 \u0434\u0440\u043E\u043D\u0443 \u043E\u043D \u043D\u0435 \u043D\u0430\u0441\u043B\u0435\u0434\u0443\u0435\u0442\u0441\u044F (TASWM-289), \u0430 \u0444\u0430\u0439\u043B\u0430 ${join13(cfg.droneIsolation.swarmHome, "token")} \u043D\u0435\u0442. read_task \u0434\u0440\u043E\u043D\u0430 \u0431\u0443\u0434\u0435\u0442 slug-only. \u041F\u043E\u0447\u0438\u043D\u0438: \`swarm login\` (oauth.json) \u0438\u043B\u0438 \u043F\u043E\u043B\u043E\u0436\u0438 \u0442\u043E\u043A\u0435\u043D \u0432 \u044D\u0442\u043E\u0442 \u0444\u0430\u0439\u043B.`
+        `[launcher] TASKLESS_TOKEN \u0437\u0430\u0434\u0430\u043D \u0442\u043E\u043B\u044C\u043A\u043E \u0432 env \u0434\u0435\u043C\u043E\u043D\u0430 \u2014 \u0434\u0440\u043E\u043D\u0443 \u043E\u043D \u043D\u0435 \u043D\u0430\u0441\u043B\u0435\u0434\u0443\u0435\u0442\u0441\u044F (TASWM-289), \u0430 \u0444\u0430\u0439\u043B\u0430 ${join14(cfg.droneIsolation.swarmHome, "token")} \u043D\u0435\u0442. read_task \u0434\u0440\u043E\u043D\u0430 \u0431\u0443\u0434\u0435\u0442 slug-only. \u041F\u043E\u0447\u0438\u043D\u0438: \`swarm login\` (oauth.json) \u0438\u043B\u0438 \u043F\u043E\u043B\u043E\u0436\u0438 \u0442\u043E\u043A\u0435\u043D \u0432 \u044D\u0442\u043E\u0442 \u0444\u0430\u0439\u043B.`
       );
     }
     const executor = cfg.executor ?? resolveExecutor();
@@ -12561,10 +12752,10 @@ async function restoreDaemon(d, loginOk) {
   d.err("\u0434\u0435\u043C\u043E\u043D \u043E\u0431\u0440\u0430\u0442\u043D\u043E \u041D\u0415 \u043F\u043E\u0434\u043D\u044F\u043B\u0441\u044F (\u043F\u0440\u0438\u0447\u0438\u043D\u0430 \u0432\u044B\u0448\u0435) \u2014 \u0440\u043E\u0439 \u0441\u0442\u043E\u0438\u0442. \u041F\u043E\u0434\u043D\u0438\u043C\u0438 \u0432\u0440\u0443\u0447\u043D\u0443\u044E: swarm start");
 }
 function isPortFree(port, host = "127.0.0.1") {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const probe = createServer();
-    probe.once("error", () => resolve4(false));
-    probe.listen(port, host, () => probe.close(() => resolve4(true)));
+    probe.once("error", () => resolve5(false));
+    probe.listen(port, host, () => probe.close(() => resolve5(true)));
   });
 }
 async function chooseWorkspace(d) {
@@ -13051,12 +13242,12 @@ async function runDaemonLogs(argv) {
   const head = tailFile(DAEMON_LOG_PATH, lines);
   if (head) console.log(head);
   if (!follow) return 0;
-  let pos = statSync10(DAEMON_LOG_PATH).size;
+  let pos = statSync11(DAEMON_LOG_PATH).size;
   for (; ; ) {
     await sleep2(500);
     let size;
     try {
-      size = statSync10(DAEMON_LOG_PATH).size;
+      size = statSync11(DAEMON_LOG_PATH).size;
     } catch {
       continue;
     }
@@ -13328,7 +13519,7 @@ function effectiveWorktreesDir() {
       exists: (d) => existsSync17(d),
       isNonEmptyDir: (d) => {
         try {
-          return readdirSync10(d).length > 0;
+          return readdirSync11(d).length > 0;
         } catch {
           return false;
         }
@@ -13384,17 +13575,17 @@ async function scoutRepo(repo) {
     await $6({ reject: false })`git -C ${worktree} reset --hard ${baseRef}`;
   }
   await setWorktreeIdentity(worktree, name);
-  const abs = (rel) => join25(worktree, rel);
+  const abs = (rel) => join26(worktree, rel);
   const code = await runRepoScout({
     repoFullName,
     repoPath: worktree,
     name,
-    readFile: (rel) => existsSync17(abs(rel)) ? readFileSync18(abs(rel), "utf8") : null,
+    readFile: (rel) => existsSync17(abs(rel)) ? readFileSync19(abs(rel), "utf8") : null,
     writeFile: (rel, text) => {
       mkdirSync10(dirname5(abs(rel)), { recursive: true });
       writeFileSync14(abs(rel), text);
     },
-    runScout: (prompt) => new Promise((resolve4) => {
+    runScout: (prompt) => new Promise((resolve5) => {
       const child = spawn3(bin, [...ISOLATION_FLAGS, "--dangerously-skip-permissions", "-p", prompt], {
         cwd: worktree,
         stdio: ["ignore", "inherit", "inherit"]
@@ -13402,9 +13593,9 @@ async function scoutRepo(repo) {
       });
       child.on("error", (e) => {
         console.error(`\u043D\u0435 \u0437\u0430\u043F\u0443\u0441\u0442\u0438\u043B\u0441\u044F \u0438\u0441\u043F\u043E\u043B\u043D\u0438\u0442\u0435\u043B\u044C (${bin}): ${e.message}`);
-        resolve4(1);
+        resolve5(1);
       });
-      child.on("exit", (c) => resolve4(c ?? 1));
+      child.on("exit", (c) => resolve5(c ?? 1));
     }),
     publish: (files) => publishScoutPr({ worktree, repo, files, name, baseBranch, openPr: openPr.url, fresh: openPr.known && !openPr.url }),
     log: (line) => console.log(line)
@@ -13942,6 +14133,11 @@ switch (cmd) {
       {
         db,
         kill: (pid) => process.kill(pid, "SIGTERM"),
+        // TASWM-553: тот же порядок, что у демона (stop_run / POST /cancel) — снос worktree
+        // ПОСЛЕ смерти процесса, а не следом за просьбой умереть. Здесь это нужнее всего:
+        // сюда попадают ровно тогда, когда демон не ответил, и подчистить за собой некому.
+        isAlive: pidAlive,
+        hardKill: (pid) => process.kill(pid, "SIGKILL"),
         removeWorktree: (repo, p) => {
           const r = repo || SWARM_REPO;
           return r ? removeWorktree(r, p) : Promise.resolve();