@i14ks/ccv 0.15.0 → 0.16.0

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,27 +1822,61 @@ 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);
+  }
   /**
-   * Ход хэндоффа у лимита: прервать текущий ход (вместе с субагентами), затем
-   * отправить служебный `prompt` с запретом на любые инструменты и вернуть
-   * текст ответа. `null` — хода не вышло: ошибка, пустой ответ или ход не
-   * кончился за `timeoutMs`; тогда хэндофф собирают из журнала.
+   * Остановить все задачи сессии — и из списка, и из уровня фоновых (там же
+   * и вложенные). `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`
+   * не задан (спрашивать агента бессмысленно — например, окно уже исчерпано);
+   * тогда хэндофф собирают из журнала.
    */
   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);
       const turn = await reply;
+      if (!turn && !this.#closing && this.#state !== "idle") {
+        const settled = this.#nextTurnEnd(INTERRUPT_SETTLE_MS);
+        await this.interrupt().catch(() => void 0);
+        await settled;
+      }
       const text = turn?.text?.trim();
       return turn && !turn.isError && text ? text : null;
     } catch {
@@ -1811,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) => {
@@ -2203,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) {
@@ -2237,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;
@@ -2293,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)
@@ -2346,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 строит меню «/» и выбор модели.
    *
@@ -2459,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();
@@ -2466,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);
 }
@@ -2845,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,
@@ -4392,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;
@@ -4466,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();
@@ -4487,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) {
@@ -5170,6 +5409,28 @@ var SessionPins = class {
     await this.#persist();
     return true;
   }
+  /**
+   * Передать закрепление другой сессии — «Продолжить в новой сессии» из
+   * хэндоффа: работа переехала в новую, и закреплённой должна быть она.
+   *
+   * `fromIds` — все id прежней сессии (дисковый и, если она ещё жива,
+   * локальный uuid): закрепление пишется под оба, и снять его надо с обоих,
+   * иначе прежняя так и останется в панели. Время берётся у первой найденной
+   * записи — новая встаёт ровно на место прежней, а не в конец панели.
+   * Возвращает `true`, если прежняя была закреплена.
+   */
+  async transfer(fromIds, toId) {
+    let record;
+    for (const id of fromIds) {
+      record ??= this.#pinned.get(id);
+      this.#pinned.delete(id);
+    }
+    if (!record)
+      return false;
+    this.#pinned.set(toId, record);
+    await this.#persist();
+    return true;
+  }
   /**
    * Забыть записи о сессиях, которых больше нет на диске.
    *
@@ -5451,6 +5712,21 @@ var Folders = class {
     await this.#persist();
     return true;
   }
+  /**
+   * Перенести место в папке закреплённых с одного id сессии на другой — вслед
+   * за самим закреплением (см. `SessionPins.migrate` и `SessionPins.transfer`).
+   * Без этого строка, переехав, выпала бы из своей папки в общий список.
+   */
+  async migratePinnedSession(fromId, toId) {
+    const folderId = this.#pinnedAssignments.get(fromId);
+    if (!folderId || fromId === toId)
+      return false;
+    this.#pinnedAssignments.delete(fromId);
+    if (!this.#pinnedAssignments.has(toId))
+      this.#pinnedAssignments.set(toId, folderId);
+    await this.#persist();
+    return true;
+  }
   folderIdForWorkspace(workspaceId) {
     return this.#workspaceAssignments.get(workspaceId);
   }
@@ -5704,6 +5980,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
@@ -5732,7 +6009,7 @@ function crossedLimit(usage, settings, fired, now = Date.now()) {
 }
 function handoffPrompt(hit) {
   return [
-    `[ccv] ${capitalize(LIMIT_LABEL[hit.limit])} \u043F\u043E\u0447\u0442\u0438 \u0438\u0441\u0447\u0435\u0440\u043F\u0430\u043D (${Math.round(hit.window.utilization)} %), \u0440\u0430\u0431\u043E\u0442\u0430 \u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\u0430.`,
+    hit ? `[ccv] ${capitalize(LIMIT_LABEL[hit.limit])} \u043F\u043E\u0447\u0442\u0438 \u0438\u0441\u0447\u0435\u0440\u043F\u0430\u043D (${Math.round(hit.window.utilization)} %), \u0440\u0430\u0431\u043E\u0442\u0430 \u043E\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D\u0430.` : "[ccv] \u041F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044C \u0437\u0430\u043A\u0440\u044B\u0432\u0430\u0435\u0442 \u044D\u0442\u043E\u0442 \u044D\u0442\u0430\u043F: \u0434\u0430\u043B\u044C\u0448\u0435 \u0440\u0430\u0431\u043E\u0442\u0430 \u043F\u043E\u0439\u0434\u0451\u0442 \u0432 \u043D\u043E\u0432\u043E\u0439 \u0441\u0435\u0441\u0441\u0438\u0438.",
     "\u0418\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u044B \u0432 \u044D\u0442\u043E\u043C \u0445\u043E\u0434\u0435 \u043E\u0442\u043A\u043B\u044E\u0447\u0435\u043D\u044B \u2014 \u043D\u0435 \u0432\u044B\u0437\u044B\u0432\u0430\u0439 \u0438\u0445.",
     "\u041E\u0442\u0432\u0435\u0442\u044C \u043E\u0434\u043D\u0438\u043C \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0435\u043C \u2014 \u0445\u044D\u043D\u0434\u043E\u0444\u0444\u043E\u043C, \u0441 \u043A\u043E\u0442\u043E\u0440\u043E\u0433\u043E \u0440\u0430\u0431\u043E\u0442\u0443 \u043F\u0440\u043E\u0434\u043E\u043B\u0436\u0430\u0442 \u0432 \u043D\u043E\u0432\u043E\u0439 \u0441\u0435\u0441\u0441\u0438\u0438.",
     "Markdown, \u0440\u0430\u0437\u0434\u0435\u043B\u044B: \xAB## \u0426\u0435\u043B\u044C\xBB, \xAB## \u0421\u043E\u0441\u0442\u043E\u044F\u043D\u0438\u0435\xBB (\u0447\u0442\u043E \u0441\u0434\u0435\u043B\u0430\u043D\u043E, \u0447\u0442\u043E \u043D\u0435\u0442, \u0447\u0442\u043E \u043F\u0440\u043E\u0432\u0435\u0440\u0435\u043D\u043E),",
@@ -6127,13 +6404,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) {
@@ -6157,8 +6434,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;
@@ -6451,12 +6728,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) {
@@ -6856,7 +7133,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"
@@ -6906,6 +7183,8 @@ var HostServer = class {
   #limitTimer = null;
   /** Идёт остановка у лимита — второй снимок лимитов её не запускает. */
   #limitStopping = false;
+  /** Живые id сессий, у которых сейчас пишется ручной хэндофф. */
+  #handoffBusy = /* @__PURE__ */ new Set();
   #hostId = randomUUID5();
   #plugins = new PluginCli();
   #auth = new AuthCli();
@@ -7735,6 +8014,19 @@ 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",
+          sessionId: frame.sessionId,
+          handoff: await this.#manualHandoff(frame.sessionId)
+        });
+        return;
       case "settings.update": {
         const before = this.#settings.current;
         const settings = await this.#settings.update(frame.settings);
@@ -7981,10 +8273,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)
@@ -8006,7 +8298,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;
   }
   /**
    * Перечитать лимиты, пока хоть одна сессия занята. Сама сессия делает это
@@ -8035,40 +8327,41 @@ var HostServer = class {
     }
   }
   /**
-   * Остановить все живые сессии Claude: занятые — после хода хэндоффа (или с
-   * хэндоффом из журнала, если агент не ответил), простаивающие — сразу.
+   * Прервать работу у лимита: занятые сессии пишут хэндофф (или он
+   * собирается из журнала, если агент не ответил), простаивающие не
+   * трогаются. Процессы сессий остаются жить — гаснет сессия только тогда,
+   * когда из её хэндоффа продолжили в новой (см. `continueFromHandoff` в
+   * окне).
    */
   async #stopAtLimit(hit) {
     const sessions = this.#claudeUserSessions();
     if (sessions.length === 0)
       return;
-    const prompt = handoffPrompt(hit);
-    const results = await Promise.all(sessions.map(async (session) => {
-      let saved = false;
-      if (this.#isBusy(session)) {
-        const text = await session.runHandoff(prompt, HANDOFF_TIMEOUT_MS);
-        const summary = session.summary();
-        const handoff = {
-          sessionId: summary.claudeSessionId ?? session.id,
-          workspaceId: session.workspaceId,
-          title: summary.title ?? "",
-          limit: hit.limit,
-          utilization: hit.window.utilization,
-          resetsAt: hit.window.resetsAt,
-          stoppedAt: Date.now(),
-          source: text ? "agent" : "journal",
-          text: text ?? journalHandoff(session.journal.since(0))
-        };
-        try {
-          await this.#handoffs.save(handoff);
-          saved = true;
-          this.#broadcast({ type: "handoff.state", sessionId: handoff.sessionId, handoff });
-        } catch (error) {
-          console.error("[limit-stop]", error instanceof Error ? error.message : String(error));
-        }
+    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();
+      const handoff = {
+        sessionId: summary.claudeSessionId ?? session.id,
+        workspaceId: session.workspaceId,
+        title: summary.title ?? "",
+        limit: hit.limit,
+        utilization: hit.window.utilization,
+        resetsAt: hit.window.resetsAt,
+        stoppedAt: Date.now(),
+        source: text ? "agent" : "journal",
+        text: text ?? journalHandoff(session.journal.since(0))
+      };
+      try {
+        await this.#handoffs.save(handoff);
+        this.#broadcast({ type: "handoff.state", sessionId: handoff.sessionId, handoff });
+        return true;
+      } catch (error) {
+        console.error("[limit-stop]", error instanceof Error ? error.message : String(error));
+        return false;
       }
-      await this.#dropSession(session.id, "limit").catch(() => false);
-      return saved;
     }));
     this.#broadcast({
       type: "limit.stopped",
@@ -8079,6 +8372,42 @@ var HostServer = class {
       handoffs: results.filter(Boolean).length
     });
   }
+  /**
+   * «Хэндофф и новая сессия»: тот же ход хэндоффа, что у лимита, только по
+   * просьбе пользователя. Сессия после него останавливается — работа
+   * переезжает в новую, которую заведёт спросившее окно (см.
+   * `handoff.written`). `null` — писать не из чего: сессии нет, она не
+   * Claude или уже пишет хэндофф (например, второе нажатие).
+   */
+  async #manualHandoff(sessionId) {
+    const session = this.#sessions.get(sessionId);
+    if (!(session instanceof ClaudeSession) || session.summary().state === "closed")
+      return null;
+    if (this.#handoffBusy.has(sessionId))
+      return null;
+    this.#handoffBusy.add(sessionId);
+    try {
+      const text = await session.runHandoff(handoffPrompt(null), HANDOFF_TIMEOUT_MS);
+      const summary = session.summary();
+      const handoff = {
+        sessionId: summary.claudeSessionId ?? session.id,
+        workspaceId: session.workspaceId,
+        title: summary.title ?? "",
+        limit: null,
+        utilization: 0,
+        resetsAt: "",
+        stoppedAt: Date.now(),
+        source: text ? "agent" : "journal",
+        text: text ?? journalHandoff(session.journal.since(0))
+      };
+      await this.#handoffs.save(handoff);
+      this.#broadcast({ type: "handoff.state", sessionId: handoff.sessionId, handoff });
+      await this.#dropSession(session.id, "handoff").catch(() => false);
+      return handoff;
+    } finally {
+      this.#handoffBusy.delete(sessionId);
+    }
+  }
   /**
    * Живые сессии всех проектов — вкладке запущенных.
    *
@@ -8176,6 +8505,44 @@ var HostServer = class {
     session.start();
     this.#sendLive();
     this.#send(socket, { type: "session.summary", session: session.summary() });
+    if (frame.continuesFrom)
+      await this.#carryPin(workspace.id, frame.continuesFrom, session.id);
+  }
+  /**
+   * «Продолжить в новой сессии» из хэндоффа: закрепление прежней сессии
+   * переезжает на новую — вместе с местом в панели и папкой закреплённых.
+   * Работа продолжается уже там, и мёртвая сессия у лимита не должна
+   * занимать её строку, а новая — теряться в общем списке.
+   *
+   * Новая закрепляется под своим локальным uuid: дискового id у неё ещё нет,
+   * на него запись переедет сама, как у любой свежей закреплённой (см.
+   * `#wire`). У прежней снимаем оба id — она может быть ещё жива, и тогда
+   * закрепление записано и под её uuid (см. `case 'session.pin'`).
+   */
+  async #carryPin(workspaceId, fromId, toId) {
+    const fromIds = [fromId];
+    for (const live of this.#sessions.values()) {
+      if (live.id !== toId && live.claudeSessionId === fromId)
+        fromIds.push(live.id);
+    }
+    if (!await this.#pins.transfer(fromIds, toId))
+      return;
+    for (const id of fromIds)
+      await this.#folders.migratePinnedSession(id, toId);
+    await this.#sendSessionList(workspaceId);
+  }
+  /**
+   * Переезд закрепления на новый id той же сессии — вместе с папкой
+   * закреплённых, иначе строка выпала бы из своей папки в общий список.
+   */
+  async #migratePin(fromId, toId) {
+    try {
+      const moved = await this.#pins.migrate(fromId, toId);
+      await this.#folders.migratePinnedSession(fromId, toId);
+      if (moved)
+        await this.#sendPinned();
+    } catch {
+    }
   }
   /**
    * Подписка на события сессии.
@@ -8191,12 +8558,12 @@ var HostServer = class {
       this.#broadcast({ type: "session.summary", session: summary });
       if (!summary.claudeSessionId || !this.#pins.has(summary.id))
         return;
-      void this.#pins.migrate(summary.id, summary.claudeSessionId).then((moved) => moved ? this.#sendPinned() : void 0).catch(() => void 0);
+      void this.#migratePin(summary.id, summary.claudeSessionId);
     });
     session.on("claudeSessionId", ({ from, to }) => {
       if (!this.#pins.has(from))
         return;
-      void this.#pins.migrate(from, to).then((moved) => moved ? this.#sendPinned() : void 0).catch(() => void 0);
+      void this.#migratePin(from, to);
     });
     session.on("capabilities", () => {
       if (!session.capabilities)
@@ -8574,6 +8941,7 @@ var HostServer = class {
       lastTurn: null,
       // Сессия с диска не поднята — фоновой задаче взяться неоткуда.
       backgroundWork: false,
+      tasks: [],
       model: null,
       permissionMode: "default",
       // Сессия с диска не поднята: чем она была настроена, знает только её
@@ -8685,6 +9053,7 @@ function antigravitySummary(record) {
     state: "closed",
     lastTurn: null,
     backgroundWork: false,
+    tasks: [],
     model: record.model,
     permissionMode: record.permissionMode,
     effort: record.effort,