@i14ks/ccv 0.15.3 → 0.16.1

package/bundle/ccv.mjs

@@ -1112,6 +1112,8 @@ var USAGE_MIN_INTERVAL_MS = 2e4;
 var HANDOFF_TOOL_DENIAL = "\u041B\u0438\u043C\u0438\u0442 \u043F\u043B\u0430\u043D\u0430 \u043F\u043E\u0447\u0442\u0438 \u0438\u0441\u0447\u0435\u0440\u043F\u0430\u043D, \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u044B \u043E\u0442\u043A\u043B\u044E\u0447\u0435\u043D\u044B. \u041E\u0442\u0432\u0435\u0442\u044C \u0445\u044D\u043D\u0434\u043E\u0444\u0444\u043E\u043C \u0442\u0435\u043A\u0441\u0442\u043E\u043C, \u0431\u0435\u0437 \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u043E\u0432.";
 var USAGE_TURN_INTERVAL_MS = 3e4;
 var INTERRUPT_SETTLE_MS = 15e3;
+var TASK_STOP_TIMEOUT_MS = 5e3;
+var TASK_WAKE_MS = 5e3;
 var CONTEXT_MIN_INTERVAL_MS = 5e3;
 var ClaudeSession = class extends EventEmitter {
   id;
@@ -1176,6 +1178,39 @@ var ClaudeSession = class extends EventEmitter {
    * `#setState` делает это сам, см. там же.
    */
   #backgroundWork = /* @__PURE__ */ new Set();
+  /**
+   * Запущенные задачи основного разговора — по `system/task_*` (см.
+   * `SessionTask`), в порядке запуска.
+   *
+   * Края (`task_started` / `task_notification`) могут потеряться, поэтому
+   * список ещё и подрезается: по `background_tasks_changed` уходят фоновые,
+   * которых нет в уровне, по `result` основного хода — задачи переднего
+   * плана, а перезапуск процесса CLI обнуляет его целиком.
+   */
+  #tasks = /* @__PURE__ */ new Map();
+  /**
+   * Живые фоновые задачи по `background_tasks_changed` — уровень, а не края:
+   * каждое событие заменяет набор целиком. В отличие от `#backgroundWork`,
+   * новый ход его не трогает — фоновый агент переживает любой ход.
+   *
+   * `null` — этот процесс CLI уровня ещё не присылал (или не умеет вовсе);
+   * тогда о фоновой работе судит `#backgroundWork`.
+   */
+  #backgroundLevel = null;
+  /**
+   * toolUseId вызовов, сделанных сабагентами. `owned_by_subagent` CLI ставит
+   * не всем их задачам — команда агента на переднем плане приходит без него, —
+   * поэтому вложенность узнаём ещё и по тому, чей вызов задачу запустил.
+   */
+  #subagentToolUses = /* @__PURE__ */ new Set();
+  /** Отложенная рассылка сводки по `task_progress` — он приходит на каждый инструмент агента. */
+  #taskSummaryTimer = null;
+  /**
+   * Когда сессия в последний раз работала — шла ход или крутились задачи.
+   * Сторожу лимита: порог мог перейти между опросами, и сессия, которая
+   * только что его перешла, к моменту проверки уже может простаивать.
+   */
+  #lastActiveAt = 0;
   #capabilities = null;
   #pendingPermissions = /* @__PURE__ */ new Map();
   #model = null;
@@ -1342,7 +1377,10 @@ var ClaudeSession = class extends EventEmitter {
       title: this.#title,
       state: this.#state,
       lastTurn: this.#lastTurn,
-      backgroundWork: this.#backgroundWork.size > 0,
+      backgroundWork: this.#backgroundLevel ? this.#backgroundLevel.size > 0 : this.#backgroundWork.size > 0,
+      // Команда на переднем плане — это просто идущий вызов инструмента, он и
+      // так виден в ленте; задачей она становится, только уйдя в фон.
+      tasks: [...this.#tasks.values()].filter((t) => t.kind !== "shell" || t.background),
       model: this.#model,
       permissionMode: this.#permissionMode,
       effort: this.#effort,
@@ -1445,6 +1483,7 @@ var ClaudeSession = class extends EventEmitter {
       options2.allowedTools = READ_ONLY_TOOLS;
       options2.strictMcpConfig = true;
     }
+    this.#resetTasks();
     const q = query({ prompt: this.#inbox, options: options2 });
     this.#query = q;
     void this.#consume(q);
@@ -1565,6 +1604,7 @@ var ClaudeSession = class extends EventEmitter {
     } catch {
     }
     this.#query = null;
+    this.#resetTasks();
   }
   // -------------------------------------------------------------------------
   // Переподключение
@@ -1621,8 +1661,8 @@ var ClaudeSession = class extends EventEmitter {
     if (this.#closing || this.#reconnectTimer)
       return;
     this.#teardown("\u043F\u0435\u0440\u0435\u043F\u043E\u0434\u043A\u043B\u044E\u0447\u0435\u043D\u0438\u0435");
-    const delay = RECONNECT_DELAYS_MS[this.#reconnectAttempt];
-    if (delay === void 0) {
+    const delay2 = RECONNECT_DELAYS_MS[this.#reconnectAttempt];
+    if (delay2 === void 0) {
       this.#pendingRetry = [];
       this.#record({
         kind: "error",
@@ -1634,13 +1674,13 @@ var ClaudeSession = class extends EventEmitter {
     this.#reconnectAttempt += 1;
     this.#record({
       kind: "error",
-      message: `\u0421\u0432\u044F\u0437\u044C \u0441 Claude \u043F\u043E\u0442\u0435\u0440\u044F\u043D\u0430: ${reason}. \u041F\u0435\u0440\u0435\u043F\u043E\u0434\u043A\u043B\u044E\u0447\u0435\u043D\u0438\u0435 \u0447\u0435\u0440\u0435\u0437 ${Math.round(delay / 1e3)} \u0441 (\u043F\u043E\u043F\u044B\u0442\u043A\u0430 ${this.#reconnectAttempt} \u0438\u0437 ${RECONNECT_DELAYS_MS.length}).`
+      message: `\u0421\u0432\u044F\u0437\u044C \u0441 Claude \u043F\u043E\u0442\u0435\u0440\u044F\u043D\u0430: ${reason}. \u041F\u0435\u0440\u0435\u043F\u043E\u0434\u043A\u043B\u044E\u0447\u0435\u043D\u0438\u0435 \u0447\u0435\u0440\u0435\u0437 ${Math.round(delay2 / 1e3)} \u0441 (\u043F\u043E\u043F\u044B\u0442\u043A\u0430 ${this.#reconnectAttempt} \u0438\u0437 ${RECONNECT_DELAYS_MS.length}).`
     });
     this.#setState("reconnecting");
     this.#reconnectTimer = setTimeout(() => {
       this.#reconnectTimer = null;
       this.#restart(reason);
-    }, delay);
+    }, delay2);
     this.#reconnectTimer.unref?.();
   }
   // -------------------------------------------------------------------------
@@ -1782,23 +1822,52 @@ var ClaudeSession = class extends EventEmitter {
     this.#interruptRequested = true;
     await this.#query?.interrupt();
   }
+  /** Когда сессия в последний раз работала (см. `#lastActiveAt`); идущий ход — сейчас. */
+  get lastActiveAt() {
+    return BUSY_STATES.has(this.#state) || this.#tasks.size > 0 ? Date.now() : this.#lastActiveAt;
+  }
+  /**
+   * Остановить одну задачу. Из списка она уйдёт по уведомлению CLI
+   * (`task_notification` со `stopped`), а не здесь: не остановилась — пусть
+   * и видно будет, что работает.
+   */
+  async stopTask(taskId) {
+    await this.#query?.stopTask(taskId);
+  }
+  /**
+   * Остановить все задачи сессии — и из списка, и из уровня фоновых (там же
+   * и вложенные). `interrupt()` фоновых агентов не трогает: они переживают
+   * ход. `true` — было что останавливать.
+   */
+  async stopTasks() {
+    const q = this.#query;
+    const ids = /* @__PURE__ */ new Set([...this.#tasks.keys(), ...this.#backgroundLevel ?? []]);
+    if (!q || ids.size === 0)
+      return false;
+    await Promise.all([...ids].map((id) => Promise.race([q.stopTask(id), delay(TASK_STOP_TIMEOUT_MS)]).catch(() => void 0)));
+    return true;
+  }
   /**
-   * Ход хэндоффа у лимита: прервать текущий ход (вместе с субагентами), затем
-   * отправить служебный `prompt` с запретом на любые инструменты и вернуть
-   * текст ответа. `null` — хода не вышло: ошибка, пустой ответ или ход не
-   * кончился за `timeoutMs`; тогда хэндофф собирают из журнала.
+   * Ход хэндоффа: остановить задачи сессии, прервать текущий ход (вместе с
+   * субагентами переднего плана), затем отправить служебный `prompt` с
+   * запретом на любые инструменты и вернуть текст ответа. `null` — хода не
+   * вышло: ошибка, пустой ответ, ход не кончился за `timeoutMs` или `prompt`
+   * не задан (спрашивать агента бессмысленно — например, окно уже исчерпано);
+   * тогда хэндофф собирают из журнала.
    */
   async runHandoff(prompt, timeoutMs) {
     if (this.#closing)
       return null;
     this.#handoffMode = true;
     try {
+      if (await this.stopTasks())
+        await this.#waitForState("running", TASK_WAKE_MS);
       if (this.#state === "running" || this.#state === "waiting_permission") {
         const settled = this.#nextTurnEnd(INTERRUPT_SETTLE_MS);
         await this.interrupt().catch(() => void 0);
         await settled;
       }
-      if (this.#closing || !this.#query || this.#state !== "idle")
+      if (!prompt || this.#closing || !this.#query || this.#state !== "idle")
         return null;
       const reply = this.#nextTurnEnd(timeoutMs);
       this.sendPrompt(prompt, void 0, true);
@@ -1816,6 +1885,25 @@ var ClaudeSession = class extends EventEmitter {
       this.#handoffMode = false;
     }
   }
+  /** Дождаться состояния `state` не дольше `timeoutMs`; `true` — дождались. */
+  #waitForState(state, timeoutMs) {
+    if (this.#state === state)
+      return Promise.resolve(true);
+    return new Promise((resolve) => {
+      const onSummary = (summary) => {
+        if (summary.state !== state)
+          return;
+        clearTimeout(timer);
+        this.off("summary", onSummary);
+        resolve(true);
+      };
+      const timer = setTimeout(() => {
+        this.off("summary", onSummary);
+        resolve(false);
+      }, timeoutMs);
+      this.on("summary", onSummary);
+    });
+  }
   /** Ближайший конец хода (`result`) или `null`, если не дождались. */
   #nextTurnEnd(timeoutMs) {
     return new Promise((resolve) => {
@@ -2208,7 +2296,7 @@ var ClaudeSession = class extends EventEmitter {
 \u0421\u0435\u0441\u0441\u0438\u044E \u043F\u043E\u0434\u043D\u0438\u043C\u0430\u043B Claude Code, ${whence}: ${this.#executable.path}. \u0415\u0441\u043B\u0438 \u0434\u0435\u043B\u043E \u0432 \u043D\u0451\u043C, CCV_CLAUDE_PATH \u0443\u043A\u0430\u0436\u0435\u0442 \u0434\u0440\u0443\u0433\u043E\u0439, \u0430 CCV_BUNDLED_CLAUDE=1 \u0432\u0435\u0440\u043D\u0451\u0442 ccv \u043D\u0430 \u0431\u0438\u043D\u0430\u0440\u043D\u0438\u043A \u0438\u0437 Agent SDK.`;
   }
   #handleMessage(message) {
-    if (this.#state === "idle" && (message.type === "assistant" || message.type === "stream_event")) {
+    if (this.#state === "idle" && (message.type === "assistant" || message.type === "stream_event") && message.parent_tool_use_id === null) {
       this.#setState("running");
     }
     switch (message.type) {
@@ -2242,6 +2330,14 @@ var ClaudeSession = class extends EventEmitter {
             });
             if (isBackgroundLaunch(block.input))
               this.#backgroundWork.add(block.id);
+            if (message.parent_tool_use_id !== null) {
+              this.#subagentToolUses.add(block.id);
+              if (this.#subagentToolUses.size > 256) {
+                const oldest = this.#subagentToolUses.values().next().value;
+                if (oldest !== void 0)
+                  this.#subagentToolUses.delete(oldest);
+              }
+            }
           }
         }
         break;
@@ -2298,6 +2394,10 @@ var ClaudeSession = class extends EventEmitter {
           }
         }
         this.#reconnectAttempt = 0;
+        for (const [id, task] of this.#tasks) {
+          if (!task.background && !this.#backgroundLevel?.has(id))
+            this.#tasks.delete(id);
+        }
         const alreadyIdle = this.#state === "idle";
         this.#setState("idle");
         if (alreadyIdle)
@@ -2351,9 +2451,120 @@ var ClaudeSession = class extends EventEmitter {
       void this.refreshContext(true);
       return;
     }
+    if (this.#handleTask(message))
+      return;
     const { type: _type, subtype, ...rest } = message;
     this.#record({ kind: "system", subtype, data: rest });
   }
+  /**
+   * События задач CLI → `#tasks` и `#backgroundLevel`. `true` — событие
+   * разобрано и в журнал не идёт; `task_started` и `task_notification`
+   * (редкие края) журнал по-прежнему получает.
+   *
+   * Типы SDK тут не помогают: подтипов в союзе `SDKMessage` больше, чем
+   * объявлено, и поля вроде `owned_by_subagent` в них не описаны — читаем
+   * как есть и проверяем форму сами.
+   */
+  #handleTask(message) {
+    const subtype = message.subtype;
+    const taskId = typeof message.task_id === "string" ? message.task_id : null;
+    switch (subtype) {
+      case "task_started": {
+        this.#lastActiveAt = Date.now();
+        const toolUseId = str(message.tool_use_id);
+        if (!taskId || message.owned_by_subagent === true || toolUseId !== null && this.#subagentToolUses.has(toolUseId)) {
+          return false;
+        }
+        this.#tasks.set(taskId, {
+          id: taskId,
+          toolUseId,
+          kind: taskKind(str(message.task_type) ?? (message.subagent_type ? "local_agent" : null)),
+          agentType: str(message.subagent_type),
+          description: str(message.description) ?? "",
+          activity: null,
+          lastTool: null,
+          background: message.is_backgrounded === true || this.#backgroundLevel?.has(taskId) === true,
+          startedAt: Date.now(),
+          tokens: 0,
+          toolUses: 0
+        });
+        this.emit("summary", this.summary());
+        return false;
+      }
+      case "task_progress": {
+        this.#lastActiveAt = Date.now();
+        if (Date.now() - this.#usageAt >= USAGE_TURN_INTERVAL_MS)
+          void this.refreshUsage();
+        const task = taskId ? this.#tasks.get(taskId) : void 0;
+        if (!task)
+          return true;
+        const usage = message.usage ?? {};
+        task.activity = str(message.summary) ?? str(message.description) ?? task.activity;
+        task.lastTool = str(message.last_tool_name) ?? task.lastTool;
+        if (typeof usage.total_tokens === "number")
+          task.tokens = usage.total_tokens;
+        if (typeof usage.tool_uses === "number")
+          task.toolUses = usage.tool_uses;
+        this.#emitTasksSoon();
+        return true;
+      }
+      case "task_updated": {
+        const task = taskId ? this.#tasks.get(taskId) : void 0;
+        if (!task)
+          return true;
+        const patch = message.patch ?? {};
+        const status = patch.status;
+        if (status === "completed" || status === "failed" || status === "killed") {
+          this.#tasks.delete(task.id);
+        } else {
+          if (typeof patch.is_backgrounded === "boolean")
+            task.background = patch.is_backgrounded;
+          if (typeof patch.description === "string")
+            task.description = patch.description;
+        }
+        this.emit("summary", this.summary());
+        return true;
+      }
+      case "task_notification":
+        this.#lastActiveAt = Date.now();
+        if (taskId && this.#tasks.delete(taskId))
+          this.emit("summary", this.summary());
+        return false;
+      case "background_tasks_changed": {
+        this.#lastActiveAt = Date.now();
+        const live = Array.isArray(message.tasks) ? message.tasks.flatMap((t) => typeof t.task_id === "string" ? [t.task_id] : []) : [];
+        this.#backgroundLevel = new Set(live);
+        for (const [id, task] of this.#tasks) {
+          if (this.#backgroundLevel.has(id))
+            task.background = true;
+          else if (task.background)
+            this.#tasks.delete(id);
+        }
+        this.emit("summary", this.summary());
+        return true;
+      }
+      default:
+        return false;
+    }
+  }
+  /** Сводка по прогрессу задач — не чаще раза в секунду. */
+  #emitTasksSoon() {
+    if (this.#taskSummaryTimer)
+      return;
+    this.#taskSummaryTimer = setTimeout(() => {
+      this.#taskSummaryTimer = null;
+      this.emit("summary", this.summary());
+    }, 1e3);
+  }
+  #resetTasks() {
+    this.#tasks.clear();
+    this.#backgroundLevel = null;
+    this.#backgroundWork.clear();
+    this.#subagentToolUses.clear();
+    if (this.#taskSummaryTimer)
+      clearTimeout(this.#taskSummaryTimer);
+    this.#taskSummaryTimer = null;
+  }
   /**
    * Слэш-команды и модели — то, из чего UI строит меню «/» и выбор модели.
    *
@@ -2464,6 +2675,8 @@ var ClaudeSession = class extends EventEmitter {
   #setState(state) {
     if (this.#state === state)
       return;
+    if (BUSY_STATES.has(this.#state) || BUSY_STATES.has(state))
+      this.#lastActiveAt = Date.now();
     this.#state = state;
     if (state === "running")
       this.#backgroundWork.clear();
@@ -2471,6 +2684,26 @@ var ClaudeSession = class extends EventEmitter {
     this.emit("summary", this.summary());
   }
 };
+var BUSY_STATES = /* @__PURE__ */ new Set(["running", "waiting_permission"]);
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function str(value) {
+  return typeof value === "string" && value ? value : null;
+}
+function taskKind(type) {
+  switch (type) {
+    case "local_agent":
+    case "remote_agent":
+      return "agent";
+    case "local_bash":
+      return "shell";
+    case "local_workflow":
+      return "workflow";
+    default:
+      return "other";
+  }
+}
 function describe(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -2850,6 +3083,7 @@ var AntigravitySession = class extends EventEmitter2 {
       state: this.#state,
       lastTurn: this.#lastTurn,
       backgroundWork: false,
+      tasks: [],
       model: this.#record.model,
       permissionMode: this.#record.permissionMode,
       effort: this.#record.effort,
@@ -4397,20 +4631,20 @@ var GitHubAccount = class {
         auto_init: false
       }
     });
-    const cloneUrl = str(created.clone_url);
+    const cloneUrl = str2(created.clone_url);
     if (!cloneUrl)
       throw new Error("GitHub \u0441\u043E\u0437\u0434\u0430\u043B \u0440\u0435\u043F\u043E\u0437\u0438\u0442\u043E\u0440\u0438\u0439, \u043D\u043E \u043D\u0435 \u0432\u0435\u0440\u043D\u0443\u043B \u0430\u0434\u0440\u0435\u0441 \u0434\u043B\u044F git");
     return {
       cloneUrl,
-      htmlUrl: str(created.html_url) || cloneUrl.replace(/\.git$/, ""),
-      fullName: str(created.full_name) || `${options2.owner}/${options2.name}`
+      htmlUrl: str2(created.html_url) || cloneUrl.replace(/\.git$/, ""),
+      fullName: str2(created.full_name) || `${options2.owner}/${options2.name}`
     };
   }
   // ---------------------------------------------------------------- внутреннее
   /** Логин владельца токена; заодно это и есть проверка токена на живость. */
   async #login(token) {
     const user = await this.#api(token, "/user");
-    const login = str(user.login);
+    const login = str2(user.login);
     if (!login)
       throw new Error("GitHub \u043D\u0435 \u043D\u0430\u0437\u0432\u0430\u043B \u0443\u0447\u0451\u0442\u043D\u0443\u044E \u0437\u0430\u043F\u0438\u0441\u044C \u2014 \u0442\u043E\u043A\u0435\u043D \u043D\u0435 \u043F\u043E\u0434\u043E\u0448\u0451\u043B");
     return login;
@@ -4471,9 +4705,9 @@ function apiError(status, body) {
   let details = "";
   try {
     const parsed = JSON.parse(body);
-    message = str(parsed.message);
+    message = str2(parsed.message);
     if (Array.isArray(parsed.errors)) {
-      details = parsed.errors.map((item) => str(item.message)).filter(Boolean).join("; ");
+      details = parsed.errors.map((item) => str2(item.message)).filter(Boolean).join("; ");
     }
   } catch {
     message = body.slice(0, 200).trim();
@@ -4492,7 +4726,7 @@ function apiError(status, body) {
       return `GitHub \u043E\u0442\u0432\u0435\u0442\u0438\u043B ${status}${text ? `: ${text}` : ""}`;
   }
 }
-function str(value) {
+function str2(value) {
   return typeof value === "string" ? value : "";
 }
 function describe4(error) {
@@ -5712,6 +5946,7 @@ var HandoffStore = class {
     return path18.join(this.#dir, `${sessionId}.json`);
   }
 };
+var SAME_WINDOW_MS = 5 * 6e4;
 var LimitStopState = class {
   #fired = {};
   #storePath;
@@ -5731,9 +5966,19 @@ var LimitStopState = class {
       this.#fired = {};
     }
   }
-  /** Окно `limit` уже сработало и ещё не сбросилось. */
-  fired(limit, now = Date.now()) {
-    return (this.#fired[limit] ?? 0) > now;
+  /**
+   * Окно `limit` со сроком сброса `resets` уже сработало и ещё не сбросилось.
+   *
+   * Срок сверяется с допуском: окно со сроком сброса дальше `SAME_WINDOW_MS`
+   * от записанного — уже другое, даже если прежний срок не наступил (так
+   * 7.10 новое окно до 21:20 пропустили, приняв его за сработавшее до 20:30).
+   * `null` — срок не разобрать, сверять не с чем, решает только записанный.
+   */
+  fired(limit, resets, now = Date.now()) {
+    const until = this.#fired[limit] ?? 0;
+    if (until <= now)
+      return false;
+    return resets === null || Math.abs(resets - until) <= SAME_WINDOW_MS;
   }
   /** Запомнить срабатывание до `until` (момент сброса окна). */
   async mark(limit, until) {
@@ -5746,6 +5991,7 @@ var LimitStopState = class {
 // ../host/dist/limit-guard.js
 var HANDOFF_TIMEOUT_MS = 3 * 6e4;
 var LIMIT_SWEEP_MS = 6e4;
+var LIMIT_RECENT_MS = 2 * LIMIT_SWEEP_MS;
 var WINDOW_SPAN_MS = {
   fiveHour: 5 * 60 * 6e4,
   sevenDay: 7 * 24 * 60 * 6e4
@@ -5764,10 +6010,11 @@ function crossedLimit(usage, settings, fired, now = Date.now()) {
   for (const [limit, window, threshold] of checks) {
     if (!window || threshold <= 0 || window.utilization < threshold)
       continue;
-    if (fired(limit))
+    const parsed = Date.parse(window.resetsAt);
+    const resets = Number.isFinite(parsed) && parsed > now ? parsed : null;
+    if (fired(limit, resets))
       continue;
-    const resets = Date.parse(window.resetsAt);
-    const until = Number.isFinite(resets) && resets > now ? resets : now + WINDOW_SPAN_MS[limit];
+    const until = resets ?? now + WINDOW_SPAN_MS[limit];
     return { limit, window, until };
   }
   return null;
@@ -6169,13 +6416,13 @@ function parseStatus2(raw) {
   }
   return {
     loggedIn: parsed.loggedIn === true,
-    method: str2(parsed.authMethod) || "none",
-    email: str2(parsed.email),
-    organization: str2(parsed.orgName),
-    plan: str2(parsed.subscriptionType)
+    method: str3(parsed.authMethod) || "none",
+    email: str3(parsed.email),
+    organization: str3(parsed.orgName),
+    plan: str3(parsed.subscriptionType)
   };
 }
-function str2(value) {
+function str3(value) {
   return typeof value === "string" ? value : "";
 }
 function describe5(error) {
@@ -6199,8 +6446,8 @@ var RETRY_MAX_MS = 6e4;
 var HANDSHAKE_TIMEOUT_MS = 15e3;
 var CONNECT_TIMEOUT_MS = 3e4;
 var SILENCE_TIMEOUT_MS = 95e3;
-function jitter(delay) {
-  return Math.round(delay * (0.8 + Math.random() * 0.4));
+function jitter(delay2) {
+  return Math.round(delay2 * (0.8 + Math.random() * 0.4));
 }
 var RelayLink = class extends EventEmitter4 {
   #credentials = null;
@@ -6493,12 +6740,12 @@ var RelayLink = class extends EventEmitter4 {
   #scheduleRetry(rejected) {
     if (this.#closed || !this.#credentials || this.#retryTimer)
       return;
-    const delay = rejected ? RETRY_MAX_MS : this.#retry;
+    const delay2 = rejected ? RETRY_MAX_MS : this.#retry;
     this.#retry = Math.min(this.#retry * 2, RETRY_MAX_MS);
     this.#retryTimer = setTimeout(() => {
       this.#retryTimer = null;
       this.#connect();
-    }, jitter(delay));
+    }, jitter(delay2));
     this.#retryTimer.unref();
   }
   #onMessage(socket, raw) {
@@ -6898,7 +7145,7 @@ var FINDER_TITLE = "\xB7 \u043F\u043E\u0438\u0441\u043A \u043F\u0440\u043E\u0435
 var HISTORY_PAGE = 250;
 var HISTORY_PAGE_MAX = 500;
 var AUTO_STOP_SWEEP_MS = 30 * 1e3;
-var BUSY_STATES = /* @__PURE__ */ new Set([
+var BUSY_STATES2 = /* @__PURE__ */ new Set([
   "running",
   "waiting_permission",
   "reconnecting"
@@ -7779,6 +8026,12 @@ var HostServer = class {
         await this.#handoffs.remove(frame.sessionId);
         this.#broadcast({ type: "handoff.state", sessionId: frame.sessionId, handoff: null });
         return;
+      case "task.stop": {
+        const session = this.#sessions.get(frame.sessionId);
+        if (session instanceof ClaudeSession)
+          await session.stopTask(frame.taskId);
+        return;
+      }
       case "session.handoff":
         this.#send(socket, {
           type: "handoff.written",
@@ -8032,10 +8285,10 @@ var HostServer = class {
         continue;
       if (drafted.has(session.id))
         continue;
-      if (BUSY_STATES.has(summary.state) || summary.backgroundWork)
+      if (BUSY_STATES2.has(summary.state) || summary.backgroundWork)
         continue;
       const side = this.#sides.get(session.id);
-      if (side && BUSY_STATES.has(side.state))
+      if (side && BUSY_STATES2.has(side.state))
         continue;
       const lastActivity = Math.max(summary.updatedAt, side?.summary().updatedAt ?? 0, this.#draftTouchedAt.get(session.id) ?? 0);
       if (now - lastActivity < after)
@@ -8057,7 +8310,7 @@ var HostServer = class {
   }
   #isBusy(session) {
     const summary = session.summary();
-    return BUSY_STATES.has(summary.state) || summary.backgroundWork;
+    return BUSY_STATES2.has(summary.state) || summary.backgroundWork || summary.tasks.length > 0;
   }
   /**
    * Перечитать лимиты, пока хоть одна сессия занята. Сама сессия делает это
@@ -8072,7 +8325,7 @@ var HostServer = class {
   async #checkLimit(usage) {
     if (this.#limitStopping)
       return;
-    const hit = crossedLimit(usage, this.#settings.current, (limit) => this.#limitStop.fired(limit));
+    const hit = crossedLimit(usage, this.#settings.current, (limit, resets) => this.#limitStop.fired(limit, resets));
     if (!hit)
       return;
     this.#limitStopping = true;
@@ -8096,8 +8349,9 @@ var HostServer = class {
     const sessions = this.#claudeUserSessions();
     if (sessions.length === 0)
       return;
-    const busy = sessions.filter((s) => this.#isBusy(s));
-    const prompt = handoffPrompt(hit);
+    const now = Date.now();
+    const busy = sessions.filter((s) => this.#isBusy(s) || now - s.lastActiveAt < LIMIT_RECENT_MS);
+    const prompt = hit.window.utilization >= 100 ? null : handoffPrompt(hit);
     const results = await Promise.all(busy.map(async (session) => {
       const text = await session.runHandoff(prompt, HANDOFF_TIMEOUT_MS);
       const summary = session.summary();
@@ -8699,6 +8953,7 @@ var HostServer = class {
       lastTurn: null,
       // Сессия с диска не поднята — фоновой задаче взяться неоткуда.
       backgroundWork: false,
+      tasks: [],
       model: null,
       permissionMode: "default",
       // Сессия с диска не поднята: чем она была настроена, знает только её
@@ -8810,6 +9065,7 @@ function antigravitySummary(record) {
     state: "closed",
     lastTurn: null,
     backgroundWork: false,
+    tasks: [],
     model: record.model,
     permissionMode: record.permissionMode,
     effort: record.effort,