@i14ks/ccv 0.14.0 → 0.15.0

package/bundle/ccv.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // dist/ccv.js
-import { spawn as spawn2 } from "node:child_process";
-import { readFile as readFile15 } from "node:fs/promises";
-import path20 from "node:path";
+import { spawn as spawn3 } from "node:child_process";
+import { readFile as readFile17 } from "node:fs/promises";
+import path24 from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 
@@ -146,9 +146,9 @@ function envDefaults() {
 // ../host/dist/server.js
 import { createServer } from "node:http";
 import { createReadStream, existsSync as existsSync4, statSync as statSync3 } from "node:fs";
-import path19 from "node:path";
+import path23 from "node:path";
 import { homedir as homedir6 } from "node:os";
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 import { WebSocketServer } from "ws";
 import { renameSession as renameSession2 } from "@anthropic-ai/claude-agent-sdk";
 
@@ -164,8 +164,6 @@ function workspaceIdFromPath(absolutePath) {
 // ../host/dist/session.js
 import { EventEmitter } from "node:events";
 import { randomUUID } from "node:crypto";
-import { existsSync, writeFileSync } from "node:fs";
-import { homedir as homedir3 } from "node:os";
 import path5 from "node:path";
 import { query, renameSession } from "@anthropic-ai/claude-agent-sdk";
 
@@ -1111,7 +1109,9 @@ function previewAnnotations(questions, answers) {
   return annotations;
 }
 var USAGE_MIN_INTERVAL_MS = 2e4;
-var USAGE_TURN_INTERVAL_MS = 12e4;
+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 CONTEXT_MIN_INTERVAL_MS = 5e3;
 var ClaudeSession = class extends EventEmitter {
   id;
@@ -1201,6 +1201,11 @@ var ClaudeSession = class extends EventEmitter {
   #titleIsDefault = false;
   /** Настоящий id сессии Claude Code — известен только после system/init. */
   #claudeSessionId = null;
+  /**
+   * Идёт ход хэндоффа (`runHandoff`): любой вызов инструмента отклоняется —
+   * и хуком, и `canUseTool`, в любом режиме прав.
+   */
+  #handoffMode = false;
   /**
    * Имя, которое пользователь задал, но записать на диск ещё не удалось.
    *
@@ -1329,6 +1334,7 @@ var ClaudeSession = class extends EventEmitter {
   summary() {
     return {
       id: this.id,
+      provider: "claude",
       claudeSessionId: this.#claudeSessionId,
       workspaceId: this.workspaceId,
       cwd: this.cwd,
@@ -1407,7 +1413,10 @@ var ClaudeSession = class extends EventEmitter {
           {
             matcher: WRITE_TOOLS,
             hooks: [(input) => this.#guardWrite(input)]
-          }
+          },
+          // Без matcher — на все инструменты, включая MCP и инструменты
+          // субагентов: в ходе хэндоффа отклоняется всё.
+          { hooks: [async () => this.#guardHandoff()] }
         ]
       },
       stderr: (data) => this.emit("stderr", data)
@@ -1637,11 +1646,11 @@ var ClaudeSession = class extends EventEmitter {
   // -------------------------------------------------------------------------
   // Ввод от пользователя
   // -------------------------------------------------------------------------
-  sendPrompt(text, images) {
+  sendPrompt(text, images, service = false) {
     if (this.#closing)
       throw new Error("session is closed");
     this.#record({ kind: "user.message", text, images });
-    if (!this.#title || this.#titleIsDefault) {
+    if (!service && (!this.#title || this.#titleIsDefault)) {
       this.#title = text.slice(0, 80);
       this.#titleIsDefault = false;
     }
@@ -1773,6 +1782,49 @@ var ClaudeSession = class extends EventEmitter {
     this.#interruptRequested = true;
     await this.#query?.interrupt();
   }
+  /**
+   * Ход хэндоффа у лимита: прервать текущий ход (вместе с субагентами), затем
+   * отправить служебный `prompt` с запретом на любые инструменты и вернуть
+   * текст ответа. `null` — хода не вышло: ошибка, пустой ответ или ход не
+   * кончился за `timeoutMs`; тогда хэндофф собирают из журнала.
+   */
+  async runHandoff(prompt, timeoutMs) {
+    if (this.#closing)
+      return null;
+    this.#handoffMode = true;
+    try {
+      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")
+        return null;
+      const reply = this.#nextTurnEnd(timeoutMs);
+      this.sendPrompt(prompt, void 0, true);
+      const turn = await reply;
+      const text = turn?.text?.trim();
+      return turn && !turn.isError && text ? text : null;
+    } catch {
+      return null;
+    } finally {
+      this.#handoffMode = false;
+    }
+  }
+  /** Ближайший конец хода (`result`) или `null`, если не дождались. */
+  #nextTurnEnd(timeoutMs) {
+    return new Promise((resolve) => {
+      const onEnd = (turn) => {
+        clearTimeout(timer);
+        resolve(turn);
+      };
+      const timer = setTimeout(() => {
+        this.off("turnEnd", onEnd);
+        resolve(null);
+      }, timeoutMs);
+      this.once("turnEnd", onEnd);
+    });
+  }
   /**
    * Смена режима прав на лету.
    *
@@ -1867,7 +1919,6 @@ var ClaudeSession = class extends EventEmitter {
       const raw = await q.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET();
       this.#usage = toUsageState(raw);
       this.emit("usage", this.#usage);
-      writeFinisherSnapshot(this.#usage, this.#claudeSessionId, this.cwd);
     } catch {
     } finally {
       this.#usageAt = Date.now();
@@ -2036,6 +2087,18 @@ var ClaudeSession = class extends EventEmitter {
       }
     };
   };
+  #guardHandoff() {
+    if (!this.#handoffMode)
+      return { continue: true };
+    return {
+      continue: true,
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "deny",
+        permissionDecisionReason: HANDOFF_TOOL_DENIAL
+      }
+    };
+  }
   /**
    * Мост между `canUseTool` из SDK и решением человека в UI.
    *
@@ -2053,6 +2116,9 @@ var ClaudeSession = class extends EventEmitter {
    * это и происходило, пока вопросы показывались обычной карточкой прав.
    */
   #canUseTool = (toolName, input, { signal, decisionReason, toolUseID }) => {
+    if (this.#handoffMode) {
+      return Promise.resolve({ behavior: "deny", message: HANDOFF_TOOL_DENIAL });
+    }
     if (this.#options.readOnly) {
       this.#record({
         kind: "error",
@@ -2202,6 +2268,10 @@ var ClaudeSession = class extends EventEmitter {
           contextTokens: this.#contextTokens,
           text: "result" in message ? message.result : null
         });
+        this.emit("turnEnd", {
+          text: "result" in message ? message.result : null,
+          isError: message.is_error
+        });
         if (this.#options.outputFormat) {
           this.emit("structured", {
             data: "structured_output" in message ? message.structured_output : void 0,
@@ -2427,60 +2497,1178 @@ function toUsageState(raw) {
     fetchedAt: Date.now()
   };
 }
-function writeFinisherSnapshot(usage, sessionId, cwd) {
-  if (!usage.available)
-    return;
-  const dir = path5.join(homedir3(), ".claude", "finisher");
-  if (!existsSync(dir))
-    return;
-  const snapshot = {
-    updated_at: Date.now(),
-    session_id: sessionId,
-    cwd,
-    rate_limits: {
-      five_hour: usage.fiveHour?.utilization ?? null,
-      seven_day: usage.sevenDay?.utilization ?? null,
-      spend_limit: null
+function toUsageWindow(raw) {
+  if (!raw || typeof raw.utilization !== "number")
+    return null;
+  return {
+    // Доля окна и так приходит в 0–100, но полоса шире дорожки — это уже не
+    // «почти всё израсходовано», а сломанная вёрстка.
+    utilization: Math.min(100, Math.max(0, raw.utilization)),
+    resetsAt: typeof raw.resets_at === "string" ? raw.resets_at : ""
+  };
+}
+function contentToText2(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.map((block) => {
+    if (typeof block === "string")
+      return block;
+    if (block && typeof block === "object" && "text" in block) {
+      return String(block.text);
+    }
+    if (block && typeof block === "object" && "type" in block) {
+      return `[${String(block.type)}]`;
+    }
+    return "";
+  }).join("");
+}
+
+// ../host/dist/antigravity-session.js
+import { EventEmitter as EventEmitter2 } from "node:events";
+import { spawn as spawn2, execFile as execFile3 } from "node:child_process";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path7 from "node:path";
+import { createInterface } from "node:readline";
+
+// ../host/dist/antigravity-cli.js
+import { execFile as execFile2 } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import path6 from "node:path";
+function agyExecutable() {
+  const forced = process.env.CCV_AGY_PATH;
+  if (forced && existsSync(forced))
+    return forced;
+  const names2 = process.platform === "win32" ? ["agy.exe", "agy"] : ["agy"];
+  const dirs = (process.env.PATH ?? "").split(path6.delimiter).filter(Boolean);
+  if (process.platform === "win32") {
+    const local = process.env.LOCALAPPDATA ?? path6.join(homedir3(), "AppData", "Local");
+    dirs.push(path6.join(local, "agy", "bin"));
+  } else {
+    dirs.push(path6.join(homedir3(), ".local", "bin"), "/usr/local/bin", "/opt/homebrew/bin");
+  }
+  for (const dir of dirs) {
+    for (const name of names2) {
+      const candidate = path6.join(dir, name);
+      if (existsSync(candidate))
+        return candidate;
+    }
+  }
+  return null;
+}
+var AGY_MISSING_HINT = "Antigravity CLI (agy) \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D. \u0423\u0441\u0442\u0430\u043D\u043E\u0432\u0438\u0442\u0435 \u0435\u0433\u043E \u0441 https://antigravity.google \u0438 \u0432\u043E\u0439\u0434\u0438\u0442\u0435, \u0437\u0430\u043F\u0443\u0441\u0442\u0438\u0432 `agy` \u0432 \u0442\u0435\u0440\u043C\u0438\u043D\u0430\u043B\u0435, \u2014 \u0438\u043B\u0438 \u0443\u043A\u0430\u0436\u0438\u0442\u0435 \u043F\u0443\u0442\u044C \u0432 \u043F\u0435\u0440\u0435\u043C\u0435\u043D\u043D\u043E\u0439 CCV_AGY_PATH.";
+var modelsCache = null;
+function agyModels(file) {
+  if (modelsCache)
+    return modelsCache;
+  const pending = new Promise((resolve) => {
+    execFile2(file, ["models"], { timeout: 3e4, windowsHide: true }, (error, stdout) => {
+      if (error) {
+        resolve([]);
+        return;
+      }
+      const models = [];
+      for (const line of stdout.split(/\r?\n/)) {
+        const [value, displayName] = line.split("	");
+        if (!value || !displayName || /\s/.test(value))
+          continue;
+        models.push({
+          value,
+          resolvedModel: value,
+          displayName: displayName.trim(),
+          description: "",
+          supportsEffort: false,
+          effortLevels: [],
+          supportsThinking: false,
+          supportsAutoMode: false
+        });
+      }
+      resolve(models);
+    });
+  });
+  modelsCache = pending;
+  void pending.then((models) => {
+    if (models.length === 0)
+      modelsCache = null;
+  });
+  return pending;
+}
+function agyCommand(file, command, cwd) {
+  return new Promise((resolve) => {
+    execFile2(file, ["--output-format", "json", "-p", command], {
+      cwd,
+      timeout: 6e4,
+      windowsHide: true,
+      maxBuffer: 8 * 1024 * 1024,
+      env: { ...process.env, NO_COLOR: "1" }
+    }, (error, stdout) => {
+      const line = stdout.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.startsWith("{")).pop();
+      if (line) {
+        try {
+          resolve(JSON.parse(line));
+          return;
+        } catch {
+        }
+      }
+      resolve({ status: "ERROR", error: error ? error.message : "agy \u043D\u0435 \u043E\u0442\u0432\u0435\u0442\u0438\u043B" });
+    });
+  });
+}
+var USAGE_TTL_MS = 3e4;
+var usageCache = null;
+var usageInFlight = null;
+var usageError = null;
+function agyUsageError() {
+  return usageError;
+}
+function agyUsage(file, force = false) {
+  if (!force && usageCache && Date.now() - usageCache.at < USAGE_TTL_MS) {
+    return Promise.resolve(usageCache.value);
+  }
+  if (usageInFlight)
+    return usageInFlight;
+  usageInFlight = agyCommand(file, "/usage").then((reply) => {
+    const value = parseUsage(reply);
+    if (value)
+      usageCache = { at: Date.now(), value };
+    usageError = value ? null : reply.error || "agy \u043D\u0435 \u043E\u0442\u0434\u0430\u043B \u043A\u0432\u043E\u0442\u0443";
+    return value;
+  }).finally(() => {
+    usageInFlight = null;
+  });
+  return usageInFlight;
+}
+var PERIOD_LABELS = {
+  weekly: "\u043D\u0435\u0434\u0435\u043B\u044C\u043D\u044B\u0439 \u043B\u0438\u043C\u0438\u0442",
+  daily: "\u0434\u043D\u0435\u0432\u043D\u043E\u0439 \u043B\u0438\u043C\u0438\u0442",
+  monthly: "\u043C\u0435\u0441\u044F\u0447\u043D\u044B\u0439 \u043B\u0438\u043C\u0438\u0442"
+};
+function parseUsage(reply) {
+  if (reply.status !== "SUCCESS")
+    return null;
+  const data = reply.command?.data;
+  if (!data || !Array.isArray(data.groups))
+    return null;
+  const buckets = [];
+  for (const group of data.groups) {
+    const groupName = group.name ?? "";
+    for (const bucket of group.buckets ?? []) {
+      if (typeof bucket.remaining_fraction !== "number")
+        continue;
+      const used = Math.min(100, Math.max(0, (1 - bucket.remaining_fraction) * 100));
+      buckets.push({
+        id: bucket.id ?? `${groupName}:${bucket.name ?? ""}`,
+        label: shortGroupLabel(groupName),
+        // Имя окна у `agy` — «Weekly Limit Remaining», а полоса показывает
+        // израсходованное: подпись с «Remaining» читалась бы наоборот.
+        title: [groupName, PERIOD_LABELS[bucket.window ?? ""] ?? bucket.name].filter(Boolean).join(" \u2014 "),
+        description: group.description ?? "",
+        period: bucket.window ?? "",
+        window: { utilization: used, resetsAt: bucket.reset_time ?? "" }
+      });
+    }
+  }
+  return {
+    available: buckets.length > 0,
+    plan: "",
+    fiveHour: null,
+    sevenDay: null,
+    sevenDayOpus: null,
+    buckets,
+    fetchedAt: Date.now()
+  };
+}
+function shortGroupLabel(name) {
+  const short = name.replace(/\s+models?$/i, "").replace(/\s+and\s+/gi, "/").trim();
+  return short || name;
+}
+var INTERACTIVE_COMMANDS = /* @__PURE__ */ new Set(["config", "hooks", "permissions", "context"]);
+var AGY_CLI_COMMANDS = /* @__PURE__ */ new Set([
+  "help",
+  "usage",
+  "quota",
+  "skills",
+  "agents",
+  "changelog",
+  "credits",
+  "model",
+  "effort"
+]);
+var COMMAND_ARGS = { model: "[\u043C\u043E\u0434\u0435\u043B\u044C]", effort: "[low|medium|high|max]" };
+var catalogCache = null;
+function agyCommandCatalog(file, cwd) {
+  if (catalogCache)
+    return catalogCache;
+  const pending = Promise.all([agyCommand(file, "/help", cwd), agyCommand(file, "/skills", cwd)]).then(([help, skills]) => {
+    const commands = [];
+    const helpData = help.command?.data;
+    for (const c of helpData?.commands ?? []) {
+      if (!c.name || INTERACTIVE_COMMANDS.has(c.name))
+        continue;
+      commands.push({
+        name: c.name,
+        description: c.description ?? "",
+        argumentHint: COMMAND_ARGS[c.name] ?? "",
+        aliases: c.aliases ?? []
+      });
+    }
+    const skillsData = skills.command?.data;
+    for (const s of skillsData?.skills ?? []) {
+      if (!s.name || commands.some((c) => c.name === s.name))
+        continue;
+      commands.push({ name: s.name, description: s.description ?? "", argumentHint: "", aliases: [] });
+    }
+    return commands;
+  });
+  catalogCache = pending;
+  void pending.then((commands) => {
+    if (commands.length === 0)
+      catalogCache = null;
+  });
+  return pending;
+}
+function agyContextWindow(model) {
+  if (!model)
+    return null;
+  const id = model.toLowerCase();
+  if (id.startsWith("gemini-"))
+    return 1048576;
+  if (id.startsWith("claude-"))
+    return 2e5;
+  if (id.startsWith("gpt-oss"))
+    return 131072;
+  return null;
+}
+
+// ../host/dist/antigravity-session.js
+var TRANSIENT = /* @__PURE__ */ new Set(["assistant.delta", "thinking.delta", "state"]);
+var AntigravitySession = class extends EventEmitter2 {
+  id;
+  workspaceId;
+  cwd;
+  journal = new Journal();
+  provider = "antigravity";
+  #store;
+  #record;
+  #history = Promise.resolve([]);
+  #child = null;
+  #executable = null;
+  #state = "starting";
+  #lastTurn = null;
+  #capabilities = null;
+  #titleIsDefault = false;
+  #closing = false;
+  /** Ходы, отправленные процессу и ещё не закрытые его `result`. */
+  #pendingTurns = 0;
+  /** Перезапуск (смена модели/режима), отложенный до конца хода. */
+  #restartPending = false;
+  #interrupting = false;
+  /** Накопленный текст шагов-ответов: на `DONE` уходит одним `assistant.text`. */
+  #texts = /* @__PURE__ */ new Map();
+  #thinking = /* @__PURE__ */ new Map();
+  /** Шаги-инструменты, о которых уже сказано `tool.use`. */
+  #tools = /* @__PURE__ */ new Set();
+  #contextTokens = null;
+  /** Модель, на которой `agy` реально работает (`init.model`) — с учётом его умолчания. */
+  #activeModel = null;
+  #usage = null;
+  #context = null;
+  #commands = [];
+  #stderrTail = "";
+  #unsaved = [];
+  #flushTimer = null;
+  #updatedAt = Date.now();
+  constructor(options2) {
+    super();
+    this.#store = options2.store;
+    this.workspaceId = options2.workspaceId;
+    this.cwd = options2.cwd;
+    const now = Date.now();
+    this.#record = options2.record ? { ...options2.record } : {
+      id: randomUUID2(),
+      conversationId: null,
+      workspaceId: options2.workspaceId,
+      cwd: options2.cwd,
+      title: options2.defaultTitle ?? null,
+      model: options2.model ?? null,
+      permissionMode: options2.permissionMode ?? "default",
+      effort: null,
+      createdAt: now,
+      updatedAt: now
+    };
+    if (!options2.record)
+      this.#titleIsDefault = options2.defaultTitle !== void 0;
+    if (options2.record && options2.permissionMode) {
+      this.#record.permissionMode = options2.permissionMode;
+    }
+    this.id = this.#record.id;
+    this.#updatedAt = this.#record.updatedAt;
+  }
+  // -------------------------------------------------------------------------
+  // Публичное состояние — та же форма, что у ClaudeSession
+  // -------------------------------------------------------------------------
+  get state() {
+    return this.#state;
+  }
+  get capabilities() {
+    return this.#capabilities;
+  }
+  /** Постоянный id сессии: под ним она в архиве, закреплённых и папках. */
+  get claudeSessionId() {
+    return this.id;
+  }
+  get parentSessionId() {
+    return null;
+  }
+  get usage() {
+    return this.#usage;
+  }
+  get context() {
+    return this.#context;
+  }
+  history() {
+    return this.#history;
+  }
+  summary() {
+    return {
+      id: this.id,
+      provider: "antigravity",
+      claudeSessionId: this.id,
+      workspaceId: this.workspaceId,
+      cwd: this.cwd,
+      parentSessionId: null,
+      title: this.#record.title,
+      state: this.#state,
+      lastTurn: this.#lastTurn,
+      backgroundWork: false,
+      model: this.#record.model,
+      permissionMode: this.#record.permissionMode,
+      effort: this.#record.effort,
+      ultracode: false,
+      thinking: true,
+      switchModelsOnFlag: true,
+      createdAt: this.#record.createdAt,
+      updatedAt: this.#updatedAt,
+      lastSeq: this.journal.lastSeq,
+      totalCostUsd: 0
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Жизненный цикл
+  // -------------------------------------------------------------------------
+  start() {
+    if (this.#record.conversationId) {
+      this.#history = this.#store.readEvents(this.id);
+      void this.#history.then((entries) => {
+        if (this.#contextTokens !== null)
+          return;
+        for (let i = entries.length - 1; i >= 0; i -= 1) {
+          const event = entries[i].event;
+          if (event.kind === "result" && event.contextTokens !== null) {
+            this.#contextTokens = event.contextTokens;
+            this.#emitContext();
+            return;
+          }
+        }
+      });
+    }
+    void this.#store.save(this.#record);
+    this.#executable = agyExecutable();
+    if (!this.#executable) {
+      this.#record_({ kind: "error", message: AGY_MISSING_HINT });
+      this.#setState("error");
+      return;
+    }
+    this.#capabilities = this.#baseCapabilities();
+    this.emit("capabilities");
+    void agyModels(this.#executable).then((models) => {
+      if (!this.#capabilities || models.length === 0)
+        return;
+      this.#capabilities = { ...this.#capabilities, models };
+      this.emit("capabilities");
+    });
+    void agyCommandCatalog(this.#executable, this.cwd).then((commands) => {
+      if (!this.#capabilities || commands.length === 0)
+        return;
+      this.#commands = commands;
+      this.#capabilities = this.#baseCapabilities();
+      this.emit("capabilities");
+    });
+    void this.refreshUsage();
+    this.#spawn();
+  }
+  #baseCapabilities() {
+    return {
+      cwd: this.cwd,
+      model: this.#record.model ?? this.#activeModel ?? "",
+      permissionMode: this.#record.permissionMode,
+      slashCommands: this.#commands.map((c) => c.name),
+      commands: this.#commands,
+      models: this.#capabilities?.models ?? [],
+      tools: this.#capabilities?.tools ?? [],
+      agents: [],
+      mcpServers: [],
+      flags: []
+    };
+  }
+  #args() {
+    const args = ["--input-format", "stream-json", "--output-format", "stream-json"];
+    switch (this.#record.permissionMode) {
+      case "acceptEdits":
+        args.push("--mode", "accept-edits");
+        break;
+      case "plan":
+        args.push("--mode", "plan");
+        break;
+      case "bypassPermissions":
+        args.push("--dangerously-skip-permissions");
+        break;
+      default:
+        break;
+    }
+    if (this.#record.model)
+      args.push("--model", this.#record.model);
+    const effort = agyEffort(this.#record.effort);
+    if (effort)
+      args.push("--effort", effort);
+    if (this.#record.conversationId)
+      args.push("--conversation", this.#record.conversationId);
+    args.push("-p=");
+    return args;
+  }
+  #spawn() {
+    if (!this.#executable || this.#closing)
+      return;
+    let child;
+    try {
+      child = spawn2(this.#executable, this.#args(), {
+        cwd: this.cwd,
+        windowsHide: true,
+        env: { ...process.env, NO_COLOR: "1" }
+      });
+    } catch (error) {
+      this.#record_({ kind: "error", message: `\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0437\u0430\u043F\u0443\u0441\u0442\u0438\u0442\u044C agy: ${describe2(error)}` });
+      this.#setState("error");
+      return;
+    }
+    this.#child = child;
+    this.#stderrTail = "";
+    this.#texts.clear();
+    this.#thinking.clear();
+    this.#tools.clear();
+    const lines = createInterface({ input: child.stdout });
+    lines.on("line", (line) => {
+      if (this.#child !== child)
+        return;
+      this.#handleLine(line);
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (data) => {
+      this.#stderrTail = (this.#stderrTail + data).slice(-4e3);
+      this.emit("stderr", data);
+    });
+    child.stdin.on("error", () => void 0);
+    child.on("error", (error) => {
+      if (this.#child !== child)
+        return;
+      this.#record_({ kind: "error", message: `agy: ${describe2(error)}` });
+    });
+    child.on("exit", (code) => {
+      if (this.#child !== child)
+        return;
+      this.#child = null;
+      this.#onExit(code);
+    });
+  }
+  /** Процесс ушёл сам — не по нашей просьбе. */
+  #onExit(code) {
+    if (this.#closing)
+      return;
+    const busy = this.#pendingTurns > 0;
+    this.#pendingTurns = 0;
+    if (code === 0 && !busy) {
+      this.#setState("idle");
+      return;
+    }
+    const tail = this.#stderrTail.trim().split(/\r?\n/).slice(-3).join("\n");
+    this.#lastTurn = busy ? "failed" : this.#lastTurn;
+    this.#record_({
+      kind: "error",
+      message: `Antigravity CLI \u0437\u0430\u0432\u0435\u0440\u0448\u0438\u043B\u0441\u044F (\u043A\u043E\u0434 ${code ?? "\u2014"})${tail ? `: ${tail}` : ""}`
+    });
+    this.#setState("error");
+  }
+  async close(_reason = "closed by client") {
+    this.#closing = true;
+    this.#kill();
+    this.#flush();
+    this.#setState("closed");
+  }
+  #kill() {
+    const child = this.#child;
+    this.#child = null;
+    if (!child || child.exitCode !== null)
+      return;
+    try {
+      child.stdin.end();
+    } catch {
+    }
+    if (process.platform === "win32" && child.pid) {
+      execFile3("taskkill", ["/pid", String(child.pid), "/T", "/F"], { windowsHide: true }, () => {
+        if (child.exitCode === null)
+          child.kill();
+      });
+    } else {
+      child.kill("SIGTERM");
+    }
+  }
+  /** Новый процесс на том же разговоре — смена настроек, ручная починка. */
+  #restart() {
+    if (this.#closing)
+      return;
+    this.#restartPending = false;
+    this.#kill();
+    this.#pendingTurns = 0;
+    this.#spawn();
+    if (this.#state !== "error" && this.#state !== "closed")
+      this.#setState("idle");
+  }
+  reconnect(_reason) {
+    this.#restart();
+  }
+  // -------------------------------------------------------------------------
+  // Ввод
+  // -------------------------------------------------------------------------
+  sendPrompt(text, images) {
+    if (this.#closing)
+      throw new Error("session is closed");
+    const command = /^\/([\w-]+)(?:\s+([\s\S]*))?$/.exec(text.trim());
+    if (command && AGY_CLI_COMMANDS.has(command[1]) && (!images || images.length === 0)) {
+      void this.#runCliCommand(text, command[1], command[2]?.trim() ?? "");
+      return;
+    }
+    this.#record_({ kind: "user.message", text, images });
+    if (!this.#record.title || this.#titleIsDefault) {
+      this.#record.title = text.slice(0, 80);
+      this.#titleIsDefault = false;
+    }
+    this.#lastTurn = null;
+    if (!this.#child)
+      this.#spawn();
+    if (!this.#child)
+      return;
+    this.#pendingTurns += 1;
+    this.#setState("running");
+    const child = this.#child;
+    void this.#composePrompt(text, images).then((prompt) => {
+      if (this.#child !== child)
+        return;
+      const line = JSON.stringify({
+        event: "user",
+        message: { role: "user", content: [{ type: "text", text: prompt }] }
+      });
+      child.stdin.write(line + "\n");
+    });
+  }
+  /**
+   * Встроенная команда `agy` — отдельным вызовом, без хода модели.
+   *
+   * `/model` и `/effort` с аргументом меняют настройки сессии ровно как
+   * дропдауны (своё значение у `agy -p` прожило бы один процесс), без
+   * аргумента — называют текущее. `/usage` заодно обновляет шкалу в шапке.
+   * Остальное — как ответил сам `agy`. Посреди хода команда отвечает в ленту,
+   * но ни состояния, ни `result` не трогает: ход закроет его собственный.
+   */
+  async #runCliCommand(text, name, arg) {
+    this.#record_({ kind: "user.message", text });
+    const turnRunning = this.#pendingTurns > 0;
+    if (!turnRunning) {
+      this.#lastTurn = null;
+      this.#setState("running");
+    }
+    const started = Date.now();
+    let reply = null;
+    let error = null;
+    try {
+      if (!this.#executable) {
+        error = AGY_MISSING_HINT;
+      } else if (name === "model") {
+        ({ reply, error } = await this.#modelCommand(arg));
+      } else if (name === "effort") {
+        ({ reply, error } = await this.#effortCommand(arg));
+      } else if (name === "usage" || name === "quota") {
+        const usage = await agyUsage(this.#executable, true);
+        if (usage) {
+          this.#usage = usage;
+          this.emit("usage", usage);
+          reply = formatUsage(usage);
+        } else {
+          error = `agy \u043D\u0435 \u043E\u0442\u0434\u0430\u043B \u043A\u0432\u043E\u0442\u0443 (\`/usage\`): ${agyUsageError() ?? "\u043D\u0435\u0442 \u043E\u0442\u0432\u0435\u0442\u0430"}`;
+        }
+      } else {
+        const result = await agyCommand(this.#executable, `/${name}${arg ? ` ${arg}` : ""}`, this.cwd);
+        if (result.status === "SUCCESS")
+          reply = formatCommandReply(name, result.response ?? "");
+        else
+          error = result.error || `/${name} \u0437\u0430\u0432\u0435\u0440\u0448\u0438\u043B\u0430\u0441\u044C \u043E\u0448\u0438\u0431\u043A\u043E\u0439`;
+      }
+    } catch (e) {
+      error = describe2(e);
+    }
+    if (this.#closing)
+      return;
+    if (reply)
+      this.#record_({ kind: "assistant.text", text: reply, blockId: `cmd:${randomUUID2()}` });
+    if (error)
+      this.#record_({ kind: "error", message: error });
+    if (turnRunning || this.#pendingTurns > 0)
+      return;
+    this.#record_({
+      kind: "result",
+      subtype: error ? "error" : "success",
+      isError: Boolean(error),
+      durationMs: Date.now() - started,
+      costUsd: null,
+      usage: null,
+      contextTokens: this.#contextTokens,
+      text: reply
+    });
+    this.#lastTurn = error ? "failed" : "completed";
+    if (this.#state === "running")
+      this.#setState("idle");
+    else
+      this.emit("summary", this.summary());
+  }
+  async #modelCommand(arg) {
+    const models = this.#capabilities?.models ?? [];
+    const label = (id2) => id2 ? models.find((m) => m.value === id2)?.displayName ?? id2 : "\u043F\u043E \u0443\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E agy";
+    if (!arg) {
+      const current = this.#record.model ?? this.#activeModel;
+      return { reply: `\u041C\u043E\u0434\u0435\u043B\u044C: **${label(current)}**${current ? ` (\`${current}\`)` : ""}`, error: null };
+    }
+    const wanted = arg.toLowerCase();
+    const match = models.find((m) => m.value.toLowerCase() === wanted) ?? models.find((m) => m.displayName.toLowerCase() === wanted);
+    if (models.length > 0 && !match) {
+      return {
+        reply: null,
+        error: `\u041D\u0435\u0442 \u043C\u043E\u0434\u0435\u043B\u0438 \xAB${arg}\xBB. \u0414\u043E\u0441\u0442\u0443\u043F\u043D\u044B: ${models.map((m) => m.value).join(", ")}`
+      };
+    }
+    const id = match?.value ?? arg;
+    await this.setModel(id);
+    return { reply: `\u041C\u043E\u0434\u0435\u043B\u044C \u043F\u0435\u0440\u0435\u043A\u043B\u044E\u0447\u0435\u043D\u0430: **${label(id)}** (\`${id}\`)`, error: null };
+  }
+  async #effortCommand(arg) {
+    const levels = ["low", "medium", "high", "max"];
+    if (!arg) {
+      return { reply: `\u0423\u0441\u0438\u043B\u0438\u0435: **${this.#record.effort ?? "\u043F\u043E \u0443\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E \u043C\u043E\u0434\u0435\u043B\u0438"}**`, error: null };
+    }
+    const level = arg.toLowerCase();
+    if (!levels.includes(level)) {
+      return { reply: null, error: `\u0423\u0440\u043E\u0432\u0435\u043D\u044C \u0443\u0441\u0438\u043B\u0438\u044F \u2014 \u043E\u0434\u0438\u043D \u0438\u0437: ${levels.join(", ")}` };
+    }
+    await this.setEffort(level);
+    return { reply: `\u0423\u0441\u0438\u043B\u0438\u0435: **${level}**`, error: null };
+  }
+  /** Картинки — файлами во временном каталоге, а в текст — их пути. */
+  async #composePrompt(text, images) {
+    if (!images || images.length === 0)
+      return text;
+    const dir = path7.join(tmpdir(), "ccv-antigravity", this.id);
+    await mkdir2(dir, { recursive: true });
+    const paths = [];
+    for (const image of images) {
+      const ext = image.mediaType.split("/")[1] === "jpeg" ? "jpg" : image.mediaType.split("/")[1];
+      const file = path7.join(dir, `${randomUUID2()}.${ext}`);
+      await writeFile2(file, Buffer.from(image.data, "base64"));
+      paths.push(file);
+    }
+    return `${text}
+
+Attached image${paths.length > 1 ? "s" : ""} (view them with your file viewing tool):
+` + paths.map((p) => `- ${p}`).join("\n");
+  }
+  async editPrompt(_userIndex, _text, _images) {
+    throw new Error("\u0412 \u0441\u0435\u0441\u0441\u0438\u0438 Antigravity \u043F\u0440\u0430\u0432\u043A\u0430 \u043F\u0440\u043E\u0448\u043B\u044B\u0445 \u0440\u0435\u043F\u043B\u0438\u043A \u043D\u0435 \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442\u0441\u044F");
+  }
+  respondPermission(_requestId, _decision, _reason, _answers, _annotations, _plan) {
+  }
+  async interrupt() {
+    if (this.#pendingTurns === 0)
+      return;
+    this.#interrupting = true;
+    this.#kill();
+    this.#closeOpenSteps();
+    this.#pendingTurns = 0;
+    this.#lastTurn = "interrupted";
+    this.#record_({
+      kind: "result",
+      subtype: "interrupted",
+      isError: false,
+      durationMs: 0,
+      costUsd: null,
+      usage: null,
+      contextTokens: this.#contextTokens,
+      text: null
+    });
+    this.#interrupting = false;
+    this.#spawn();
+    if (this.#state !== "error")
+      this.#setState("idle");
+  }
+  async setPermissionMode(mode) {
+    if (this.#record.permissionMode === mode)
+      return;
+    this.#record.permissionMode = mode;
+    this.#settingsChanged();
+  }
+  async setModel(model) {
+    if (this.#record.model === model)
+      return;
+    this.#record.model = model;
+    this.#settingsChanged();
+  }
+  async setEffort(effort) {
+    if (this.#record.effort === effort)
+      return;
+    this.#record.effort = effort;
+    this.#settingsChanged();
+  }
+  /** Флаги запуска поменялись: новый процесс — сейчас или после хода. */
+  #settingsChanged() {
+    if (this.#capabilities) {
+      this.#capabilities = this.#baseCapabilities();
+      this.emit("capabilities");
+    }
+    this.emit("summary", this.summary());
+    void this.#store.save(this.#record);
+    if (!this.#executable || this.#state === "closed")
+      return;
+    if (this.#pendingTurns > 0)
+      this.#restartPending = true;
+    else
+      this.#restart();
+  }
+  // Claude-only управление: у agy этого нет — молча ничего не делаем.
+  async setUltracode(_enabled) {
+  }
+  async setThinking(_enabled) {
+  }
+  async setSwitchModelsOnFlag(_enabled) {
+  }
+  /** Квота `agy` (`/usage`) — общая на аккаунт, кэш один на хост. */
+  async refreshUsage(force = false) {
+    if (!this.#executable)
+      return;
+    const usage = await agyUsage(this.#executable, force);
+    if (!usage)
+      return;
+    this.#usage = usage;
+    this.emit("usage", usage);
+  }
+  async refreshContext(_force = false) {
+    this.#emitContext();
+  }
+  /**
+   * Снимок окна контекста: занятое — из `usage` последнего шага модели,
+   * всего — по модели из таблицы. Чего-то из двух нет — молчим: полоса
+   * останется со своим умолчанием и числом из `result`.
+   */
+  #emitContext() {
+    const maxTokens = agyContextWindow(this.#record.model ?? this.#activeModel);
+    if (this.#contextTokens === null || maxTokens === null)
+      return;
+    this.#context = { tokens: this.#contextTokens, maxTokens, fetchedAt: Date.now() };
+    this.emit("context", this.#context);
+  }
+  async reloadPlugins() {
+  }
+  async mcpServerStatus() {
+    return [];
+  }
+  async addMcpServer(_name, _config) {
+    throw new Error("MCP-\u0441\u0435\u0440\u0432\u0435\u0440\u044B Antigravity \u043D\u0430\u0441\u0442\u0440\u0430\u0438\u0432\u0430\u044E\u0442\u0441\u044F \u0432 \u0441\u0430\u043C\u043E\u043C agy (`agy mcp`)");
+  }
+  async removeMcpServer(_name) {
+    return false;
+  }
+  setTitle(title) {
+    this.#record.title = title;
+    this.#titleIsDefault = false;
+    void this.#store.save(this.#record);
+    this.emit("summary", this.summary());
+  }
+  // -------------------------------------------------------------------------
+  // Поток agy
+  // -------------------------------------------------------------------------
+  #handleLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{"))
+      return;
+    let message;
+    try {
+      message = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    switch (message.event) {
+      case "init": {
+        const conversationId = typeof message.conversation_id === "string" ? message.conversation_id : null;
+        if (conversationId && conversationId !== this.#record.conversationId) {
+          this.#record.conversationId = conversationId;
+          void this.#store.save(this.#record);
+        }
+        const init = message.init;
+        if (typeof init?.model === "string" && init.model && init.model !== this.#activeModel) {
+          this.#activeModel = init.model;
+          if (this.#capabilities) {
+            this.#capabilities = this.#baseCapabilities();
+            this.emit("capabilities");
+          }
+          this.#emitContext();
+        }
+        if (this.#capabilities && Array.isArray(init?.tools)) {
+          this.#capabilities = {
+            ...this.#capabilities,
+            tools: init.tools.filter((t) => typeof t === "string")
+          };
+          this.emit("capabilities");
+        }
+        if (this.#state === "starting")
+          this.#setState("idle");
+        return;
+      }
+      case "step_update":
+        this.#handleStep(message.step_update);
+        return;
+      case "result":
+        this.#handleResult(message.result);
+        return;
+      default:
+        return;
+    }
+  }
+  #handleStep(step2) {
+    if (!step2 || typeof step2.step_index !== "number")
+      return;
+    const index = step2.step_index;
+    const blockId = `${this.#record.conversationId ?? this.id}:${index}`;
+    if (step2.step_type === "user_input")
+      return;
+    if (step2.step_type === "tool" || step2.tool_info || step2.tool_name) {
+      const name = step2.tool_name ?? step2.tool_info?.name ?? "tool";
+      if (!this.#tools.has(index)) {
+        this.#tools.add(index);
+        this.#record_({
+          kind: "tool.use",
+          toolUseId: blockId,
+          name,
+          input: toolInput(step2.tool_info?.parameters)
+        });
+      }
+      if (step2.state === "DONE" || step2.state === "ERROR") {
+        const error = step2.tool_info?.error?.message;
+        this.#record_({
+          kind: "tool.result",
+          toolUseId: blockId,
+          content: error ?? step2.tool_info?.output ?? "",
+          isError: step2.state === "ERROR" || Boolean(error)
+        });
+        this.#tools.delete(index);
+      }
+      return;
+    }
+    if (step2.thinking_delta) {
+      this.#thinking.set(index, (this.#thinking.get(index) ?? "") + step2.thinking_delta);
+      this.#record_({ kind: "thinking.delta", text: step2.thinking_delta, blockId: `${blockId}:t` });
+    }
+    if (step2.text_delta) {
+      this.#texts.set(index, (this.#texts.get(index) ?? "") + step2.text_delta);
+      this.#record_({ kind: "assistant.delta", text: step2.text_delta, blockId });
+    }
+    if (step2.usage && typeof step2.usage.input_tokens === "number") {
+      this.#contextTokens = step2.usage.input_tokens + (step2.usage.output_tokens ?? 0);
+    }
+    if (step2.state === "DONE" || step2.state === "ERROR") {
+      const thinking = this.#thinking.get(index);
+      if (thinking) {
+        this.#record_({ kind: "assistant.thinking", text: thinking, blockId: `${blockId}:t` });
+        this.#thinking.delete(index);
+      }
+      const text = this.#texts.get(index);
+      if (text) {
+        this.#record_({ kind: "assistant.text", text: text.replace(/\n+$/, ""), blockId });
+        this.#texts.delete(index);
+      }
+      if (step2.state === "ERROR") {
+        const message = typeof step2.error === "string" ? step2.error : step2.error?.message;
+        this.#record_({ kind: "error", message: message || `\u0428\u0430\u0433 ${step2.step_type ?? ""} \u0437\u0430\u0432\u0435\u0440\u0448\u0438\u043B\u0441\u044F \u043E\u0448\u0438\u0431\u043A\u043E\u0439` });
+      }
+    }
+  }
+  #handleResult(result) {
+    if (!result || this.#interrupting)
+      return;
+    this.#closeOpenSteps();
+    const ok = result.status === "SUCCESS";
+    const usage = result.usage ? {
+      inputTokens: result.usage.input_tokens ?? 0,
+      outputTokens: (result.usage.output_tokens ?? 0) + (result.usage.thinking_tokens ?? 0),
+      cacheReadTokens: result.usage.cache_read_tokens ?? 0,
+      cacheCreationTokens: 0
+    } : null;
+    const denied = (result.denied_actions ?? []).map((a) => a.display_name ?? a.action).filter((a) => Boolean(a));
+    if (denied.length > 0) {
+      this.#record_({
+        kind: "error",
+        message: `Antigravity \u043E\u0442\u043A\u043B\u043E\u043D\u0438\u043B \u0431\u0435\u0437 \u0432\u043E\u043F\u0440\u043E\u0441\u0430: ${[...new Set(denied)].join(", ")}. \u0412 headless-\u0440\u0435\u0436\u0438\u043C\u0435 agy \u043D\u0435 \u0443\u043C\u0435\u0435\u0442 \u0441\u043F\u0440\u0430\u0448\u0438\u0432\u0430\u0442\u044C \u0440\u0430\u0437\u0440\u0435\u0448\u0435\u043D\u0438\u0435: \u043F\u0440\u0430\u0432\u043A\u0438 \u0444\u0430\u0439\u043B\u043E\u0432 \u0440\u0430\u0437\u0440\u0435\u0448\u0430\u0435\u0442 \u0440\u0435\u0436\u0438\u043C acceptEdits, \u043A\u043E\u043C\u0430\u043D\u0434\u044B \u0438 \u0432\u0441\u0451 \u043E\u0441\u0442\u0430\u043B\u044C\u043D\u043E\u0435 \u2014 bypassPermissions. \u041E\u0442\u0434\u0435\u043B\u044C\u043D\u044B\u0435 \u043A\u043E\u043C\u0430\u043D\u0434\u044B \u043C\u043E\u0436\u043D\u043E \u0440\u0430\u0437\u0440\u0435\u0448\u0438\u0442\u044C \u043F\u0440\u0430\u0432\u0438\u043B\u043E\u043C \u0432 permissions.allow \u0444\u0430\u0439\u043B\u0430 ~/.gemini/antigravity-cli/settings.json, \u043D\u0430\u043F\u0440\u0438\u043C\u0435\u0440 command(npm test).`
+      });
     }
-  };
-  try {
-    writeFileSync(path5.join(dir, "usage-cache.json"), JSON.stringify(snapshot, null, 2));
-  } catch {
+    if (!ok && result.error)
+      this.#record_({ kind: "error", message: result.error });
+    this.#record_({
+      kind: "result",
+      subtype: ok ? "success" : "error",
+      isError: !ok,
+      durationMs: Math.round((result.duration_seconds ?? 0) * 1e3),
+      costUsd: null,
+      usage,
+      contextTokens: this.#contextTokens,
+      text: result.response ?? null
+    });
+    this.#emitContext();
+    void this.refreshUsage(true);
+    this.#lastTurn = ok ? "completed" : "failed";
+    this.#pendingTurns = Math.max(0, this.#pendingTurns - 1);
+    if (this.#pendingTurns > 0)
+      return;
+    if (this.#restartPending)
+      this.#restart();
+    this.#setState("idle");
+  }
+  /** Незакрытые шаги оборванного хода: текст — в ленту, инструменты — с ошибкой. */
+  #closeOpenSteps() {
+    const prefix = this.#record.conversationId ?? this.id;
+    for (const [index, text] of this.#texts) {
+      if (text)
+        this.#record_({ kind: "assistant.text", text, blockId: `${prefix}:${index}` });
+    }
+    for (const index of this.#tools) {
+      this.#record_({
+        kind: "tool.result",
+        toolUseId: `${prefix}:${index}`,
+        content: "\u041F\u0440\u0435\u0440\u0432\u0430\u043D\u043E",
+        isError: true
+      });
+    }
+    this.#texts.clear();
+    this.#thinking.clear();
+    this.#tools.clear();
+  }
+  // -------------------------------------------------------------------------
+  #record_(event) {
+    this.#updatedAt = Date.now();
+    const entry = this.journal.append(event);
+    this.emit("event", entry);
+    if (TRANSIENT.has(event.kind))
+      return;
+    this.#unsaved.push({ ts: entry.ts, event });
+    this.#scheduleFlush();
   }
+  #scheduleFlush() {
+    if (this.#flushTimer)
+      return;
+    this.#flushTimer = setTimeout(() => this.#flush(), 500);
+    this.#flushTimer.unref?.();
+  }
+  #flush() {
+    if (this.#flushTimer) {
+      clearTimeout(this.#flushTimer);
+      this.#flushTimer = null;
+    }
+    const batch = this.#unsaved;
+    this.#unsaved = [];
+    this.#record.updatedAt = this.#updatedAt;
+    void this.#store.appendEvents(this.id, batch);
+    void this.#store.save(this.#record);
+  }
+  #setState(state) {
+    if (this.#state === state)
+      return;
+    this.#state = state;
+    this.#record_({ kind: "state", state });
+    if (state === "idle" || state === "error" || state === "closed")
+      this.#flush();
+    this.emit("summary", this.summary());
+  }
+};
+function toolInput(parameters) {
+  const input = { ...parameters ?? {} };
+  const pick = (...keys) => keys.map((k) => input[k]).find((v) => typeof v === "string");
+  const file = pick("TargetFile", "AbsolutePath", "File", "FilePath", "Path");
+  if (file && input.file_path === void 0)
+    input.file_path = file;
+  const command = pick("CommandLine", "Command");
+  if (command && input.command === void 0)
+    input.command = command;
+  const pattern = pick("Query", "Pattern", "SearchPattern");
+  if (pattern && input.pattern === void 0)
+    input.pattern = pattern;
+  const dir = pick("DirectoryPath", "SearchPath", "SearchDirectory");
+  if (dir && input.path === void 0)
+    input.path = dir;
+  const url2 = pick("Url", "URL");
+  if (url2 && input.url === void 0)
+    input.url = url2;
+  return input;
+}
+function formatUsage(usage) {
+  const rows = (usage.buckets ?? []).map((b) => {
+    const left = Math.round(100 - b.window.utilization);
+    const reset = b.window.resetsAt ? new Date(b.window.resetsAt).toLocaleString("ru-RU") : "\u2014";
+    return `| ${b.title || b.label} | ${left}% | ${reset} |`;
+  });
+  if (rows.length === 0)
+    return "\u041A\u0432\u043E\u0442\u0430 Antigravity: \u0434\u0430\u043D\u043D\u044B\u0445 \u043D\u0435\u0442.";
+  return ["**\u041A\u0432\u043E\u0442\u0430 Antigravity**", "", "| \u0413\u0440\u0443\u043F\u043F\u0430 | \u041E\u0441\u0442\u0430\u043B\u043E\u0441\u044C | \u041E\u0431\u043D\u0443\u043B\u0438\u0442\u0441\u044F |", "|---|---|---|", ...rows].join("\n");
 }
-function toUsageWindow(raw) {
-  if (!raw || typeof raw.utilization !== "number")
+function formatCommandReply(name, response) {
+  const text = response.replace(/\s+$/, "");
+  if (!text)
+    return `/${name}: \u043F\u0443\u0441\u0442\u043E`;
+  const lines = text.split(/\r?\n/);
+  if (lines.every((l) => l.includes("	"))) {
+    return lines.map((l) => {
+      const [head, ...rest] = l.split("	");
+      return `- **${head}** \u2014 ${rest.join(" ")}`;
+    }).join("\n");
+  }
+  return text;
+}
+function agyEffort(effort) {
+  if (!effort)
     return null;
-  return {
-    // Доля окна и так приходит в 0–100, но полоса шире дорожки — это уже не
-    // «почти всё израсходовано», а сломанная вёрстка.
-    utilization: Math.min(100, Math.max(0, raw.utilization)),
-    resetsAt: typeof raw.resets_at === "string" ? raw.resets_at : ""
-  };
+  return effort === "xhigh" ? "high" : effort;
 }
-function contentToText2(content) {
-  if (typeof content === "string")
-    return content;
-  if (!Array.isArray(content))
-    return "";
-  return content.map((block) => {
-    if (typeof block === "string")
-      return block;
-    if (block && typeof block === "object" && "text" in block) {
-      return String(block.text);
+function describe2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// ../host/dist/antigravity-store.js
+import { appendFile, mkdir as mkdir3, readFile as readFile4, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import path8 from "node:path";
+var AntigravityStore = class {
+  #dir;
+  #file;
+  #records = /* @__PURE__ */ new Map();
+  #loaded = null;
+  #writing = Promise.resolve();
+  constructor(dataDir) {
+    this.#dir = path8.join(dataDir, "antigravity");
+    this.#file = path8.join(this.#dir, "sessions.json");
+  }
+  #load() {
+    this.#loaded ??= (async () => {
+      try {
+        const raw = JSON.parse(await readFile4(this.#file, "utf8"));
+        for (const record of Array.isArray(raw) ? raw : []) {
+          if (record && typeof record.id === "string")
+            this.#records.set(record.id, record);
+        }
+      } catch {
+      }
+    })();
+    return this.#loaded;
+  }
+  async find(id) {
+    await this.#load();
+    return this.#records.get(id) ?? null;
+  }
+  async list(workspaceId) {
+    await this.#load();
+    return [...this.#records.values()].filter((r) => r.workspaceId === workspaceId);
+  }
+  async save(record) {
+    await this.#load();
+    this.#records.set(record.id, { ...record });
+    await this.#persist();
+  }
+  async rename(id, title) {
+    await this.#load();
+    const record = this.#records.get(id);
+    if (!record)
+      return false;
+    record.title = title;
+    await this.#persist();
+    return true;
+  }
+  async remove(id) {
+    await this.#load();
+    if (!this.#records.delete(id))
+      return;
+    await this.#persist();
+    await rm2(this.#eventsFile(id), { force: true });
+  }
+  /** Дописать события в ленту сессии. Порядок записей сохраняется. */
+  appendEvents(id, events) {
+    if (events.length === 0)
+      return this.#writing;
+    const lines = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
+    return this.#enqueue(async () => {
+      await mkdir3(this.#dir, { recursive: true });
+      await appendFile(this.#eventsFile(id), lines, "utf8");
+    });
+  }
+  /** Лента сессии как история: `seq` — позиция, от 1 по порядку. */
+  async readEvents(id) {
+    await this.#writing;
+    let raw;
+    try {
+      raw = await readFile4(this.#eventsFile(id), "utf8");
+    } catch {
+      return [];
     }
-    if (block && typeof block === "object" && "type" in block) {
-      return `[${String(block.type)}]`;
+    const entries = [];
+    for (const line of raw.split("\n")) {
+      if (!line.trim())
+        continue;
+      try {
+        const parsed = JSON.parse(line);
+        entries.push({ seq: entries.length + 1, ts: parsed.ts, event: parsed.event });
+      } catch {
+      }
     }
-    return "";
-  }).join("");
-}
+    return entries;
+  }
+  #eventsFile(id) {
+    return path8.join(this.#dir, `${id.replace(/[^\w-]/g, "_")}.jsonl`);
+  }
+  #persist() {
+    const snapshot = JSON.stringify([...this.#records.values()], null, 2);
+    return this.#enqueue(async () => {
+      await mkdir3(this.#dir, { recursive: true });
+      await writeFile3(this.#file, snapshot, "utf8");
+    });
+  }
+  /** Записи на диск — строго по очереди: две параллельные испортили бы файл. */
+  #enqueue(task) {
+    const next = this.#writing.then(task, task);
+    this.#writing = next.catch((error) => {
+      console.error("[antigravity-store]", error instanceof Error ? error.message : error);
+    });
+    return this.#writing;
+  }
+};
 
 // ../host/dist/git.js
-import { execFile as execFile2 } from "node:child_process";
-import { mkdtemp, readFile as readFile4, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path6 from "node:path";
+import { execFile as execFile4 } from "node:child_process";
+import { mkdtemp, readFile as readFile5, rm as rm3, writeFile as writeFile4 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import path9 from "node:path";
 var TIMEOUT_MS = 2e4;
 var NET_TIMEOUT_MS = 5 * 6e4;
 var MAX_BUFFER = 32 * 1024 * 1024;
@@ -2526,7 +3714,7 @@ var GitRepo = class {
       await this.#run(["rev-parse", "--is-inside-work-tree"]);
     } catch (error) {
       const runnable2 = await this.#run(["--version"]).then(() => true, () => false);
-      return { ...blank, message: describe2(error), noRepo: runnable2 };
+      return { ...blank, message: describe3(error), noRepo: runnable2 };
     }
     const branchRaw = await this.#soft(["rev-parse", "--abbrev-ref", "HEAD"]);
     const detached = branchRaw === "HEAD" || branchRaw === "";
@@ -2796,12 +3984,12 @@ var GitRepo = class {
    * важнее всего (см. `checkIgnored`).
    */
   async #withoutRepo(args) {
-    const dir = await mkdtemp(path6.join(tmpdir(), "ccv-git-"));
+    const dir = await mkdtemp(path9.join(tmpdir2(), "ccv-git-"));
     try {
       await this.#run(["init", "--bare", "--quiet", dir]);
       return await this.#soft([`--git-dir=${dir}`, `--work-tree=${this.cwd}`, ...args]);
     } finally {
-      await rm2(dir, { recursive: true, force: true }).catch(() => void 0);
+      await rm3(dir, { recursive: true, force: true }).catch(() => void 0);
     }
   }
   /**
@@ -2842,14 +4030,14 @@ var GitRepo = class {
    * исключил. Повторы отсеиваются, чтобы файл не рос от каждой публикации.
    */
   async #appendGitignore(paths) {
-    const file = path6.join(this.cwd, ".gitignore");
-    const existing = await readFile4(file, "utf8").catch(() => "");
+    const file = path9.join(this.cwd, ".gitignore");
+    const existing = await readFile5(file, "utf8").catch(() => "");
     const known = new Set(existing.split(/\r?\n/).map((line) => line.trim()));
     const lines = paths.map(ignorePattern).filter((line) => !known.has(line));
     if (lines.length === 0)
       return;
     const prefix = existing === "" || existing.endsWith("\n") ? "" : "\n";
-    await writeFile2(file, `${existing}${prefix}${lines.join("\n")}
+    await writeFile4(file, `${existing}${prefix}${lines.join("\n")}
 `, "utf8");
   }
   /** Команда, чей провал — обычное дело (нет upstream, нет коммитов, detached). */
@@ -2867,7 +4055,7 @@ var GitRepo = class {
   #run(args, options2 = {}) {
     const token = options2.token ?? "";
     return new Promise((resolve, reject) => {
-      const child = execFile2(
+      const child = execFile4(
         "git",
         // core.quotepath=false — иначе кириллические пути приезжают в виде
         // «\320\277\321\200…» и в панели читаются как мусор.
@@ -2938,7 +4126,7 @@ function requirePath(value) {
 function ignorePattern(relPath) {
   return `/${relPath.replace(/[\\*?[\]]/g, (char) => `\\${char}`)}`;
 }
-function describe2(error) {
+function describe3(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function parseStatus(raw) {
@@ -3048,9 +4236,9 @@ function parsePatch(raw) {
       body = "";
     }
     total += body.length;
-    const path21 = status === "deleted" ? oldPath : newPath || oldPath;
+    const path25 = status === "deleted" ? oldPath : newPath || oldPath;
     files.push({
-      path: path21,
+      path: path25,
       oldPath: status === "renamed" ? oldPath : "",
       status,
       added: count(body, "+"),
@@ -3062,10 +4250,10 @@ function parsePatch(raw) {
   return { files, truncated };
 }
 function stripPrefix(value) {
-  const path21 = unquote(value.trim());
-  if (path21 === "/dev/null")
+  const path25 = unquote(value.trim());
+  if (path25 === "/dev/null")
     return "";
-  return path21.replace(/^[ab]\//, "");
+  return path25.replace(/^[ab]\//, "");
 }
 function count(body, mark) {
   let n = 0;
@@ -3077,9 +4265,9 @@ function count(body, mark) {
 }
 
 // ../host/dist/github.js
-import { execFile as execFile3 } from "node:child_process";
-import { mkdir as mkdir2, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
-import path7 from "node:path";
+import { execFile as execFile5 } from "node:child_process";
+import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile5 } from "node:fs/promises";
+import path10 from "node:path";
 var API = "https://api.github.com";
 var API_VERSION = "2022-11-28";
 var API_TIMEOUT_MS = 2e4;
@@ -3100,11 +4288,11 @@ var GitHubAccount = class {
    */
   #ghInstalled = null;
   constructor(dataDir) {
-    this.#storePath = path7.join(dataDir, "github.json");
+    this.#storePath = path10.join(dataDir, "github.json");
   }
   async load() {
     try {
-      const raw = JSON.parse(await readFile5(this.#storePath, "utf8"));
+      const raw = JSON.parse(await readFile6(this.#storePath, "utf8"));
       const token = raw.token;
       this.#token = typeof token === "string" ? token.trim() : "";
     } catch {
@@ -3114,8 +4302,8 @@ var GitHubAccount = class {
   /** Сохранить токен или стереть его пустой строкой. */
   async setToken(token) {
     this.#token = token.trim();
-    await mkdir2(path7.dirname(this.#storePath), { recursive: true });
-    await writeFile3(this.#storePath, JSON.stringify({ token: this.#token }, null, 2), {
+    await mkdir4(path10.dirname(this.#storePath), { recursive: true });
+    await writeFile5(this.#storePath, JSON.stringify({ token: this.#token }, null, 2), {
       encoding: "utf8",
       mode: 384
     });
@@ -3142,7 +4330,7 @@ var GitHubAccount = class {
       const credential = await this.credential();
       return { ...base, connected: true, source: credential.source, login: credential.login };
     } catch (error) {
-      return { ...base, message: describe3(error) };
+      return { ...base, message: describe4(error) };
     }
   }
   /**
@@ -3240,7 +4428,7 @@ var GitHubAccount = class {
         signal: AbortSignal.timeout(API_TIMEOUT_MS)
       });
     } catch (error) {
-      throw new Error(`GitHub \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D: ${describe3(error)}`);
+      throw new Error(`GitHub \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D: ${describe4(error)}`);
     }
     const text = await response.text();
     if (!response.ok)
@@ -3266,7 +4454,7 @@ var GitHubAccount = class {
 };
 function gh(args) {
   return new Promise((resolve, reject) => {
-    execFile3("gh", args, { timeout: GH_TIMEOUT_MS, windowsHide: true, encoding: "utf8" }, (error, stdout, stderr) => {
+    execFile5("gh", args, { timeout: GH_TIMEOUT_MS, windowsHide: true, encoding: "utf8" }, (error, stdout, stderr) => {
       if (error)
         return reject(new Error(stderr.trim() || error.message));
       resolve(stdout);
@@ -3302,7 +4490,7 @@ function apiError(status, body) {
 function str(value) {
   return typeof value === "string" ? value : "";
 }
-function describe3(error) {
+function describe4(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
@@ -3310,7 +4498,7 @@ function describe3(error) {
 import { existsSync as existsSync2, statSync } from "node:fs";
 import { readdir as readdir2 } from "node:fs/promises";
 import os2 from "node:os";
-import path8 from "node:path";
+import path11 from "node:path";
 import { listSessions } from "@anthropic-ai/claude-agent-sdk";
 var CACHE_TTL = 6e4;
 var FIND_LIMIT = 50;
@@ -3349,7 +4537,7 @@ var ProjectFinder = class {
     if (needles.length === 0)
       return { candidates: [], truncated: false };
     const open = new Map(this.registry.list().map((workspace) => [workspace.path.toLowerCase(), workspace]));
-    const byName = this.#dirs.filter((dir) => matches(path8.basename(dir.path), needles));
+    const byName = this.#dirs.filter((dir) => matches(path11.basename(dir.path), needles));
     const matched = byName.length > 0 ? byName : this.#dirs.filter((dir) => matches(dir.path, needles));
     const sorted = [...matched].sort((a, b) => {
       const aOpen = open.has(a.path.toLowerCase());
@@ -3360,7 +4548,7 @@ var ProjectFinder = class {
         return a.sessions > 0 ? -1 : 1;
       if (a.lastUsedAt !== b.lastUsedAt)
         return b.lastUsedAt - a.lastUsedAt;
-      return path8.basename(a.path).localeCompare(path8.basename(b.path), void 0, {
+      return path11.basename(a.path).localeCompare(path11.basename(b.path), void 0, {
         numeric: true,
         sensitivity: "base"
       });
@@ -3368,7 +4556,7 @@ var ProjectFinder = class {
     return {
       candidates: sorted.slice(0, FIND_LIMIT).map((dir) => ({
         path: dir.path,
-        name: path8.basename(dir.path) || dir.path,
+        name: path11.basename(dir.path) || dir.path,
         sessions: dir.sessions,
         lastUsedAt: dir.lastUsedAt || null,
         open: open.has(dir.path.toLowerCase()),
@@ -3392,7 +4580,7 @@ var ProjectFinder = class {
     const candidates = [];
     for (const entry of named) {
       const absolute = entry.path.trim();
-      if (!absolute || !path8.isAbsolute(absolute))
+      if (!absolute || !path11.isAbsolute(absolute))
         continue;
       const key = absolute.toLowerCase();
       if (seen.has(key))
@@ -3403,7 +4591,7 @@ var ProjectFinder = class {
       const record = known.get(key);
       candidates.push({
         path: record?.path ?? absolute,
-        name: path8.basename(absolute) || absolute,
+        name: path11.basename(absolute) || absolute,
         sessions: record?.sessions ?? 0,
         lastUsedAt: record?.lastUsedAt || null,
         open: open.has(key),
@@ -3460,7 +4648,7 @@ var ProjectFinder = class {
         if (!dirent.isDirectory() || SKIP_NAMES.has(dirent.name) || dirent.name.startsWith(".")) {
           continue;
         }
-        const full = path8.join(parent, dirent.name);
+        const full = path11.join(parent, dirent.name);
         const key = full.toLowerCase();
         if (dirs.has(key))
           continue;
@@ -3481,7 +4669,7 @@ var ProjectFinder = class {
   #parents(dirs) {
     const counted = /* @__PURE__ */ new Map();
     for (const dir of dirs) {
-      const parent = path8.dirname(dir.path);
+      const parent = path11.dirname(dir.path);
       if (parent === dir.path || !usable(parent))
         continue;
       const key = parent.toLowerCase();
@@ -3593,18 +4781,18 @@ function fromText(text) {
 
 // ../host/dist/workspaces.js
 import { existsSync as existsSync3, statSync as statSync2 } from "node:fs";
-import { mkdir as mkdir3, readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
-import path9 from "node:path";
+import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile6 } from "node:fs/promises";
+import path12 from "node:path";
 import { listSessions as listSessions2 } from "@anthropic-ai/claude-agent-sdk";
 var WorkspaceRegistry = class {
   #entries = [];
   #storePath;
   constructor(dataDir) {
-    this.#storePath = path9.join(dataDir, "workspaces.json");
+    this.#storePath = path12.join(dataDir, "workspaces.json");
   }
   async load() {
     try {
-      const raw = await readFile6(this.#storePath, "utf8");
+      const raw = await readFile7(this.#storePath, "utf8");
       const parsed = JSON.parse(raw);
       if (!Array.isArray(parsed)) {
         this.#entries = [];
@@ -3622,8 +4810,8 @@ var WorkspaceRegistry = class {
     }
   }
   async #persist() {
-    await mkdir3(path9.dirname(this.#storePath), { recursive: true });
-    await writeFile4(this.#storePath, JSON.stringify(this.#entries, null, 2), "utf8");
+    await mkdir5(path12.dirname(this.#storePath), { recursive: true });
+    await writeFile6(this.#storePath, JSON.stringify(this.#entries, null, 2), "utf8");
   }
   /** Активные проекты. */
   list() {
@@ -3638,7 +4826,7 @@ var WorkspaceRegistry = class {
     return entry ? toInfo(entry) : void 0;
   }
   async open(rawPath) {
-    const absolute = path9.resolve(rawPath);
+    const absolute = path12.resolve(rawPath);
     if (!existsSync3(absolute)) {
       throw new Error(`\u041A\u0430\u0442\u0430\u043B\u043E\u0433 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D: ${absolute}`);
     }
@@ -3705,24 +4893,24 @@ var WorkspaceRegistry = class {
   async create(parentRaw, nameRaw, init) {
     const name = nameRaw.trim();
     requireName(name);
-    const parent = path9.resolve(parentRaw.trim());
+    const parent = path12.resolve(parentRaw.trim());
     if (!existsSync3(parent)) {
       throw new Error(`\u041A\u0430\u0442\u0430\u043B\u043E\u0433 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D: ${parent}`);
     }
     if (!statSync2(parent).isDirectory()) {
       throw new Error(`\u042D\u0442\u043E \u043D\u0435 \u043A\u0430\u0442\u0430\u043B\u043E\u0433: ${parent}`);
     }
-    const target = path9.join(parent, name);
+    const target = path12.join(parent, name);
     if (existsSync3(target)) {
       throw new Error(`\u0423\u0436\u0435 \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u0435\u0442: ${target} \u2014 \u043E\u0442\u043A\u0440\u043E\u0439\u0442\u0435 \u0435\u0433\u043E \u043A\u0430\u043A \u043F\u0440\u043E\u0435\u043A\u0442`);
     }
-    await mkdir3(target);
+    await mkdir5(target);
     const warnings = [];
     if (init.claudeMd) {
-      await step(warnings, "CLAUDE.md", () => writeFile4(path9.join(target, "CLAUDE.md"), claudeMdStub(name), "utf8"));
+      await step(warnings, "CLAUDE.md", () => writeFile6(path12.join(target, "CLAUDE.md"), claudeMdStub(name), "utf8"));
     }
     if (init.readme) {
-      await step(warnings, "README.md", () => writeFile4(path9.join(target, "README.md"), readmeStub(name), "utf8"));
+      await step(warnings, "README.md", () => writeFile6(path12.join(target, "README.md"), readmeStub(name), "utf8"));
     }
     if (init.git) {
       await step(warnings, "git init", () => new GitRepo(target).init());
@@ -3794,8 +4982,8 @@ function toInfo(entry) {
   return {
     id: workspaceIdFromPath(absolute),
     path: absolute,
-    name: path9.basename(absolute) || absolute,
-    hasClaudeMd: existsSync3(path9.join(absolute, "CLAUDE.md")),
+    name: path12.basename(absolute) || absolute,
+    hasClaudeMd: existsSync3(path12.join(absolute, "CLAUDE.md")),
     ...archivedAt ? { archivedAt } : {}
   };
 }
@@ -3804,18 +4992,18 @@ function isEntry(value) {
 }
 
 // ../host/dist/archive.js
-import { mkdir as mkdir4, readFile as readFile7, writeFile as writeFile5 } from "node:fs/promises";
-import path10 from "node:path";
+import { mkdir as mkdir6, readFile as readFile8, writeFile as writeFile7 } from "node:fs/promises";
+import path13 from "node:path";
 var SessionArchive = class {
   #archived = /* @__PURE__ */ new Map();
   #restored = /* @__PURE__ */ new Map();
   #storePath;
   constructor(dataDir) {
-    this.#storePath = path10.join(dataDir, "session-archive.json");
+    this.#storePath = path13.join(dataDir, "session-archive.json");
   }
   async load() {
     try {
-      const raw = await readFile7(this.#storePath, "utf8");
+      const raw = await readFile8(this.#storePath, "utf8");
       const parsed = JSON.parse(raw);
       this.#archived = new Map(Object.entries(parsed.archived ?? {}).filter(([, r]) => isRecord(r)));
       this.#restored = new Map(Object.entries(parsed.restored ?? {}).filter((entry) => typeof entry[1] === "number"));
@@ -3904,8 +5092,8 @@ var SessionArchive = class {
       archived: Object.fromEntries(this.#archived),
       restored: Object.fromEntries(this.#restored)
     };
-    await mkdir4(path10.dirname(this.#storePath), { recursive: true });
-    await writeFile5(this.#storePath, JSON.stringify(file, null, 2), "utf8");
+    await mkdir6(path13.dirname(this.#storePath), { recursive: true });
+    await writeFile7(this.#storePath, JSON.stringify(file, null, 2), "utf8");
   }
 };
 function isRecord(value) {
@@ -3913,17 +5101,17 @@ function isRecord(value) {
 }
 
 // ../host/dist/pins.js
-import { mkdir as mkdir5, readFile as readFile8, writeFile as writeFile6 } from "node:fs/promises";
-import path11 from "node:path";
+import { mkdir as mkdir7, readFile as readFile9, writeFile as writeFile8 } from "node:fs/promises";
+import path14 from "node:path";
 var SessionPins = class {
   #pinned = /* @__PURE__ */ new Map();
   #storePath;
   constructor(dataDir) {
-    this.#storePath = path11.join(dataDir, "session-pins.json");
+    this.#storePath = path14.join(dataDir, "session-pins.json");
   }
   async load() {
     try {
-      const raw = await readFile8(this.#storePath, "utf8");
+      const raw = await readFile9(this.#storePath, "utf8");
       const parsed = JSON.parse(raw);
       this.#pinned = new Map(Object.entries(parsed.pinned ?? {}).filter(([, r]) => isRecord2(r)));
     } catch {
@@ -4003,8 +5191,8 @@ var SessionPins = class {
   }
   async #persist() {
     const file = { pinned: Object.fromEntries(this.#pinned) };
-    await mkdir5(path11.dirname(this.#storePath), { recursive: true });
-    await writeFile6(this.#storePath, JSON.stringify(file, null, 2), "utf8");
+    await mkdir7(path14.dirname(this.#storePath), { recursive: true });
+    await writeFile8(this.#storePath, JSON.stringify(file, null, 2), "utf8");
   }
 };
 function isRecord2(value) {
@@ -4012,17 +5200,17 @@ function isRecord2(value) {
 }
 
 // ../host/dist/order.js
-import { mkdir as mkdir6, readFile as readFile9, writeFile as writeFile7 } from "node:fs/promises";
-import path12 from "node:path";
+import { mkdir as mkdir8, readFile as readFile10, writeFile as writeFile9 } from "node:fs/promises";
+import path15 from "node:path";
 var ListOrderStore = class {
   #order = emptyOrder();
   #storePath;
   constructor(dataDir) {
-    this.#storePath = path12.join(dataDir, "list-order.json");
+    this.#storePath = path15.join(dataDir, "list-order.json");
   }
   async load() {
     try {
-      const raw = await readFile9(this.#storePath, "utf8");
+      const raw = await readFile10(this.#storePath, "utf8");
       this.#order = sanitize(JSON.parse(raw));
     } catch {
       this.#order = emptyOrder();
@@ -4052,8 +5240,8 @@ var ListOrderStore = class {
     } else {
       this.#order[scope] = clean ?? [];
     }
-    await mkdir6(path12.dirname(this.#storePath), { recursive: true });
-    await writeFile7(this.#storePath, JSON.stringify(this.#order, null, 2), "utf8");
+    await mkdir8(path15.dirname(this.#storePath), { recursive: true });
+    await writeFile9(this.#storePath, JSON.stringify(this.#order, null, 2), "utf8");
   }
 };
 function emptyOrder() {
@@ -4082,9 +5270,9 @@ function sanitize(value) {
 }
 
 // ../host/dist/folders.js
-import { mkdir as mkdir7, readFile as readFile10, writeFile as writeFile8 } from "node:fs/promises";
-import path13 from "node:path";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir as mkdir9, readFile as readFile11, writeFile as writeFile10 } from "node:fs/promises";
+import path16 from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
 var Folders = class {
   #workspaceFolders = /* @__PURE__ */ new Map();
   #sessionFolders = /* @__PURE__ */ new Map();
@@ -4094,11 +5282,11 @@ var Folders = class {
   #pinnedAssignments = /* @__PURE__ */ new Map();
   #storePath;
   constructor(dataDir) {
-    this.#storePath = path13.join(dataDir, "folders.json");
+    this.#storePath = path16.join(dataDir, "folders.json");
   }
   async load() {
     try {
-      const raw = await readFile10(this.#storePath, "utf8");
+      const raw = await readFile11(this.#storePath, "utf8");
       const parsed = JSON.parse(raw);
       this.#workspaceFolders = new Map(Object.entries(parsed.workspaceFolders ?? {}).filter(([, r]) => isWorkspaceFolder(r)));
       this.#sessionFolders = new Map(Object.entries(parsed.sessionFolders ?? {}).filter(([, r]) => isSessionFolder(r)));
@@ -4128,19 +5316,19 @@ var Folders = class {
     };
   }
   async createWorkspaceFolder(name) {
-    const id = randomUUID2();
+    const id = randomUUID3();
     this.#workspaceFolders.set(id, { name });
     await this.#persist();
     return id;
   }
   async createSessionFolder(workspaceId, name) {
-    const id = randomUUID2();
+    const id = randomUUID3();
     this.#sessionFolders.set(id, { name, workspaceId });
     await this.#persist();
     return id;
   }
   async createPinnedFolder(name) {
-    const id = randomUUID2();
+    const id = randomUUID3();
     this.#pinnedFolders.set(id, { name });
     await this.#persist();
     return id;
@@ -4281,8 +5469,8 @@ var Folders = class {
       sessionAssignments: Object.fromEntries(this.#sessionAssignments),
       pinnedAssignments: Object.fromEntries(this.#pinnedAssignments)
     };
-    await mkdir7(path13.dirname(this.#storePath), { recursive: true });
-    await writeFile8(this.#storePath, JSON.stringify(file, null, 2), "utf8");
+    await mkdir9(path16.dirname(this.#storePath), { recursive: true });
+    await writeFile10(this.#storePath, JSON.stringify(file, null, 2), "utf8");
   }
 };
 function isWorkspaceFolder(value) {
@@ -4296,9 +5484,9 @@ function isPinnedFolder(value) {
 }
 
 // ../host/dist/app-settings.js
-import { mkdir as mkdir8, readFile as readFile11, writeFile as writeFile9 } from "node:fs/promises";
+import { mkdir as mkdir10, readFile as readFile12, writeFile as writeFile11 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import path14 from "node:path";
+import path17 from "node:path";
 var DEFAULT_AUTO_ARCHIVE_AFTER_MS = 2 * 24 * 60 * 60 * 1e3;
 var MIN_AUTO_ARCHIVE_AFTER_MS = 60 * 60 * 1e3;
 var DEFAULT_AUTO_STOP_AFTER_MS = 10 * 60 * 1e3;
@@ -4332,17 +5520,22 @@ var DEFAULT_APP_SETTINGS = {
   // машине что угодно.
   terminalEnabled: false,
   // Выключено по умолчанию: списки идут в том порядке, в каком их расставили.
-  liveSessionsFirst: false
+  liveSessionsFirst: false,
+  // Пятичасовое окно останавливаем с запасом: хэндофф — это ещё один ход, и
+  // ему нужно место. Недельное — у самого края: до сброса там может быть
+  // несколько дней, и терять их из-за пары процентов жалко.
+  limitStopFiveHourPct: 95,
+  limitStopSevenDayPct: 99
 };
 var AppSettingsStore = class {
   #settings = { ...DEFAULT_APP_SETTINGS };
   #storePath;
   constructor(dataDir) {
-    this.#storePath = path14.join(dataDir, "app-settings.json");
+    this.#storePath = path17.join(dataDir, "app-settings.json");
   }
   async load() {
     try {
-      const raw = await readFile11(this.#storePath, "utf8");
+      const raw = await readFile12(this.#storePath, "utf8");
       this.#settings = sanitize2(JSON.parse(raw), DEFAULT_APP_SETTINGS);
     } catch {
       this.#settings = { ...DEFAULT_APP_SETTINGS };
@@ -4362,8 +5555,8 @@ var AppSettingsStore = class {
   async update(patch) {
     const next = sanitize2(patch, this.#settings);
     this.#settings = next;
-    await mkdir8(path14.dirname(this.#storePath), { recursive: true });
-    await writeFile9(this.#storePath, JSON.stringify(next, null, 2), "utf8");
+    await mkdir10(path17.dirname(this.#storePath), { recursive: true });
+    await writeFile11(this.#storePath, JSON.stringify(next, null, 2), "utf8");
     return this.current;
   }
 };
@@ -4405,10 +5598,16 @@ function sanitize2(value, fallback) {
   if (typeof record.liveSessionsFirst === "boolean") {
     result.liveSessionsFirst = record.liveSessionsFirst;
   }
+  for (const key of ["limitStopFiveHourPct", "limitStopSevenDayPct"]) {
+    const pct = record[key];
+    if (typeof pct === "number" && Number.isFinite(pct)) {
+      result[key] = pct <= 0 ? 0 : Math.min(Math.max(Math.round(pct), 1), 100);
+    }
+  }
   return result;
 }
 function claudeHome() {
-  return path14.join(homedir4(), ".claude");
+  return path17.join(homedir4(), ".claude");
 }
 function writableRoots(mode, cwd, workspacePaths) {
   if (mode === "all")
@@ -4418,17 +5617,189 @@ function writableRoots(mode, cwd, workspacePaths) {
     return [...roots];
   for (const workspace of [cwd, ...workspacePaths]) {
     roots.add(workspace);
-    const parent = path14.dirname(workspace);
+    const parent = path17.dirname(workspace);
     if (parent !== workspace)
       roots.add(parent);
   }
   return [...roots];
 }
 
+// ../host/dist/handoff-store.js
+import { mkdir as mkdir11, readFile as readFile13, readdir as readdir3, rm as rm4, writeFile as writeFile12 } from "node:fs/promises";
+import path18 from "node:path";
+var HandoffStore = class {
+  #dir;
+  constructor(dataDir) {
+    this.#dir = path18.join(dataDir, "handoffs");
+  }
+  async get(sessionId) {
+    const file = this.#file(sessionId);
+    if (!file)
+      return null;
+    try {
+      const parsed = JSON.parse(await readFile13(file, "utf8"));
+      return typeof parsed.text === "string" ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+  async save(handoff) {
+    const file = this.#file(handoff.sessionId);
+    if (!file)
+      return;
+    await mkdir11(this.#dir, { recursive: true });
+    await writeFile12(file, JSON.stringify(handoff, null, 2), "utf8");
+  }
+  async remove(sessionId) {
+    const file = this.#file(sessionId);
+    if (file)
+      await rm4(file, { force: true });
+  }
+  /** id всех сохранённых хэндоффов. */
+  async list() {
+    try {
+      return (await readdir3(this.#dir)).filter((name) => name.endsWith(".json")).map((name) => name.slice(0, -".json".length));
+    } catch {
+      return [];
+    }
+  }
+  /** Путь файла; `null` — id пришёл от клиента и на имя файла не годится. */
+  #file(sessionId) {
+    if (!/^[\w-]{1,128}$/.test(sessionId))
+      return null;
+    return path18.join(this.#dir, `${sessionId}.json`);
+  }
+};
+var LimitStopState = class {
+  #fired = {};
+  #storePath;
+  constructor(dataDir) {
+    this.#storePath = path18.join(dataDir, "limit-stop.json");
+  }
+  async load() {
+    try {
+      const parsed = JSON.parse(await readFile13(this.#storePath, "utf8"));
+      this.#fired = {};
+      for (const key of ["fiveHour", "sevenDay"]) {
+        const until = parsed[key];
+        if (typeof until === "number" && Number.isFinite(until))
+          this.#fired[key] = until;
+      }
+    } catch {
+      this.#fired = {};
+    }
+  }
+  /** Окно `limit` уже сработало и ещё не сбросилось. */
+  fired(limit, now = Date.now()) {
+    return (this.#fired[limit] ?? 0) > now;
+  }
+  /** Запомнить срабатывание до `until` (момент сброса окна). */
+  async mark(limit, until) {
+    this.#fired[limit] = until;
+    await mkdir11(path18.dirname(this.#storePath), { recursive: true });
+    await writeFile12(this.#storePath, JSON.stringify(this.#fired, null, 2), "utf8");
+  }
+};
+
+// ../host/dist/limit-guard.js
+var HANDOFF_TIMEOUT_MS = 3 * 6e4;
+var LIMIT_SWEEP_MS = 6e4;
+var WINDOW_SPAN_MS = {
+  fiveHour: 5 * 60 * 6e4,
+  sevenDay: 7 * 24 * 60 * 6e4
+};
+var LIMIT_LABEL = {
+  fiveHour: "5-\u0447\u0430\u0441\u043E\u0432\u043E\u0439 \u043B\u0438\u043C\u0438\u0442",
+  sevenDay: "\u043D\u0435\u0434\u0435\u043B\u044C\u043D\u044B\u0439 \u043B\u0438\u043C\u0438\u0442"
+};
+function crossedLimit(usage, settings, fired, now = Date.now()) {
+  if (!usage.available)
+    return null;
+  const checks = [
+    ["fiveHour", usage.fiveHour, settings.limitStopFiveHourPct],
+    ["sevenDay", usage.sevenDay, settings.limitStopSevenDayPct]
+  ];
+  for (const [limit, window, threshold] of checks) {
+    if (!window || threshold <= 0 || window.utilization < threshold)
+      continue;
+    if (fired(limit))
+      continue;
+    const resets = Date.parse(window.resetsAt);
+    const until = Number.isFinite(resets) && resets > now ? resets : now + WINDOW_SPAN_MS[limit];
+    return { limit, window, until };
+  }
+  return null;
+}
+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.`,
+    "\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),",
+    "\xAB## \u0422\u0440\u043E\u043D\u0443\u0442\u044B\u0435 \u0444\u0430\u0439\u043B\u044B\xBB, \xAB## \u041E\u0442\u043A\u0440\u044B\u0442\u044B\u0435 \u0432\u043E\u043F\u0440\u043E\u0441\u044B\xBB, \xAB## \u0421\u043B\u0435\u0434\u0443\u044E\u0449\u0438\u0439 \u0448\u0430\u0433\xBB.",
+    "\u041A\u043E\u043D\u043A\u0440\u0435\u0442\u043D\u043E: \u043F\u0443\u0442\u0438, \u043A\u043E\u043C\u0430\u043D\u0434\u044B, \u0440\u0435\u0448\u0435\u043D\u0438\u044F \u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044F. \u0411\u0435\u0437 \u0432\u0441\u0442\u0443\u043F\u043B\u0435\u043D\u0438\u0439."
+  ].join("\n");
+}
+var EDIT_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
+function journalHandoff(entries) {
+  const prompts = [];
+  let lastText = "";
+  let todos = null;
+  const files = /* @__PURE__ */ new Set();
+  for (const { event } of entries) {
+    if (event.kind === "user.message") {
+      if (!event.text.startsWith("[ccv]"))
+        prompts.push(event.text);
+    } else if (event.kind === "assistant.text") {
+      if (event.text.trim())
+        lastText = event.text;
+    } else if (event.kind === "tool.use") {
+      const input = event.input ?? {};
+      if (EDIT_TOOLS.has(event.name)) {
+        const target = input.file_path ?? input.notebook_path;
+        if (typeof target === "string")
+          files.add(target);
+      } else if (event.name === "TodoWrite" && Array.isArray(input.todos)) {
+        todos = input.todos.flatMap((todo) => {
+          const t = todo;
+          return typeof t.content === "string" ? [{ content: t.content, status: String(t.status ?? "") }] : [];
+        });
+      }
+    }
+  }
+  const sections = [
+    "_\u0425\u044D\u043D\u0434\u043E\u0444\u0444 \u0441\u043E\u0431\u0440\u0430\u043D \u0430\u0432\u0442\u043E\u043C\u0430\u0442\u0438\u0447\u0435\u0441\u043A\u0438 \u0438\u0437 \u0436\u0443\u0440\u043D\u0430\u043B\u0430 \u0441\u0435\u0441\u0441\u0438\u0438: \u0430\u0433\u0435\u043D\u0442 \u043D\u0435 \u0443\u0441\u043F\u0435\u043B \u043D\u0430\u043F\u0438\u0441\u0430\u0442\u044C \u0435\u0433\u043E \u0441\u0430\u043C._"
+  ];
+  if (prompts.length > 0) {
+    sections.push("## \u041F\u043E\u0441\u043B\u0435\u0434\u043D\u0438\u0435 \u0437\u0430\u043F\u0440\u043E\u0441\u044B\n\n" + prompts.slice(-3).map((text) => quote(clip2(text, 1500))).join("\n\n"));
+  }
+  if (todos && todos.length > 0) {
+    const mark = (status) => status === "completed" ? "[x]" : status === "in_progress" ? "[~]" : "[ ]";
+    sections.push("## \u0417\u0430\u0434\u0430\u0447\u0438\n\n" + todos.map((t) => `- ${mark(t.status)} ${t.content}`).join("\n"));
+  }
+  if (files.size > 0) {
+    sections.push("## \u0422\u0440\u043E\u043D\u0443\u0442\u044B\u0435 \u0444\u0430\u0439\u043B\u044B\n\n" + [...files].map((f) => `- \`${f}\``).join("\n"));
+  }
+  if (lastText)
+    sections.push("## \u041F\u043E\u0441\u043B\u0435\u0434\u043D\u0438\u0439 \u043E\u0442\u0432\u0435\u0442 \u0430\u0433\u0435\u043D\u0442\u0430\n\n" + clip2(lastText, 4e3));
+  if (sections.length === 1)
+    sections.push("\u0412 \u0436\u0443\u0440\u043D\u0430\u043B\u0435 \u044D\u0442\u043E\u0439 \u0441\u0435\u0441\u0441\u0438\u0438 \u043D\u0438\u0447\u0435\u0433\u043E \u043D\u0435 \u043D\u0430\u0448\u043B\u043E\u0441\u044C.");
+  return sections.join("\n\n");
+}
+function clip2(text, max) {
+  return text.length > max ? `${text.slice(0, max)}\u2026` : text;
+}
+function quote(text) {
+  return text.split("\n").map((line) => `> ${line}`).join("\n");
+}
+function capitalize(text) {
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+
 // ../host/dist/plugins.js
-import { readFile as readFile12 } from "node:fs/promises";
+import { readFile as readFile14 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
-import path15 from "node:path";
+import path19 from "node:path";
 var TIMEOUT_MS2 = 12e4;
 var SAFE_ARG = /^[A-Za-z0-9][A-Za-z0-9._@/-]*$/;
 var PluginCli = class {
@@ -4527,10 +5898,10 @@ async function readCatalog(markets, installed) {
   return lists.flat().sort((a, b) => a.name.localeCompare(b.name));
 }
 async function readMarketplace(market, installed) {
-  const root = market.installLocation || path15.join(homedir5(), ".claude", "plugins", "marketplaces", market.name);
+  const root = market.installLocation || path19.join(homedir5(), ".claude", "plugins", "marketplaces", market.name);
   let manifest;
   try {
-    const text = await readFile12(path15.join(root, ".claude-plugin", "marketplace.json"), "utf8");
+    const text = await readFile14(path19.join(root, ".claude-plugin", "marketplace.json"), "utf8");
     manifest = JSON.parse(text);
   } catch {
     return [];
@@ -4573,7 +5944,7 @@ function authorName(raw) {
 }
 
 // ../host/dist/auth.js
-import { EventEmitter as EventEmitter2 } from "node:events";
+import { EventEmitter as EventEmitter3 } from "node:events";
 var QUICK_TIMEOUT_MS = 3e4;
 var LOGIN_TIMEOUT_MS = 10 * 6e4;
 var URL_RE = /https:\/\/\S*\/oauth\/authorize\S*/;
@@ -4585,7 +5956,7 @@ var IDLE = {
   output: "",
   error: null
 };
-var AuthCli = class extends EventEmitter2 {
+var AuthCli = class extends EventEmitter3 {
   #child = null;
   #state = IDLE;
   #timer = null;
@@ -4617,7 +5988,7 @@ var AuthCli = class extends EventEmitter2 {
     if (this.#child)
       throw new Error("\u0412\u0445\u043E\u0434 \u0443\u0436\u0435 \u0438\u0434\u0451\u0442 \u2014 \u0434\u043E\u0436\u0434\u0438\u0442\u0435\u0441\u044C \u0438\u043B\u0438 \u043E\u0442\u043C\u0435\u043D\u0438\u0442\u0435 \u0435\u0433\u043E");
     if (switchAccount) {
-      const out = await run(["auth", "logout"], QUICK_TIMEOUT_MS).catch(describe4);
+      const out = await run(["auth", "logout"], QUICK_TIMEOUT_MS).catch(describe5);
       this.#push({ ...IDLE, active: true, output: `${out}
 ` });
       this.emit("changed");
@@ -4637,7 +6008,7 @@ var AuthCli = class extends EventEmitter2 {
     child.stdout?.on("data", (chunk) => this.#absorb(chunk.toString()));
     child.stderr?.on("data", (chunk) => this.#absorb(chunk.toString()));
     child.on("error", (error) => {
-      this.#fail(error.code === "ENOENT" ? "\u041D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D claude \u0432 PATH \u2014 \u0432\u0445\u043E\u0434 \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D" : describe4(error));
+      this.#fail(error.code === "ENOENT" ? "\u041D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D claude \u0432 PATH \u2014 \u0432\u0445\u043E\u0434 \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D" : describe5(error));
     });
     child.on("close", (code) => {
       if (this.#child !== child)
@@ -4765,14 +6136,14 @@ function parseStatus2(raw) {
 function str2(value) {
   return typeof value === "string" ? value : "";
 }
-function describe4(error) {
+function describe5(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
 // ../host/dist/relay-link.js
-import { EventEmitter as EventEmitter3 } from "node:events";
-import { readFile as readFile13, writeFile as writeFile10, rm as rm3, mkdir as mkdir9 } from "node:fs/promises";
-import path16 from "node:path";
+import { EventEmitter as EventEmitter4 } from "node:events";
+import { readFile as readFile15, writeFile as writeFile13, rm as rm5, mkdir as mkdir12 } from "node:fs/promises";
+import path20 from "node:path";
 import { hostname } from "node:os";
 import WebSocket from "ws";
 
@@ -4789,7 +6160,7 @@ var SILENCE_TIMEOUT_MS = 95e3;
 function jitter(delay) {
   return Math.round(delay * (0.8 + Math.random() * 0.4));
 }
-var RelayLink = class extends EventEmitter3 {
+var RelayLink = class extends EventEmitter4 {
   #credentials = null;
   #socket = null;
   #retry = RETRY_MIN_MS;
@@ -4827,7 +6198,7 @@ var RelayLink = class extends EventEmitter3 {
   #log;
   constructor(options2) {
     super();
-    this.#file = path16.join(options2.dataDir, "relay.json");
+    this.#file = path20.join(options2.dataDir, "relay.json");
     this.#defaultUrl = options2.defaultUrl.replace(/\/+$/, "");
     this.#log = options2.log ?? ((msg) => console.log(`[relay] ${msg}`));
   }
@@ -4908,7 +6279,7 @@ var RelayLink = class extends EventEmitter3 {
   }
   async #read() {
     try {
-      const raw = await readFile13(this.#file, "utf8");
+      const raw = await readFile15(this.#file, "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed !== "object" || parsed === null)
         return null;
@@ -4921,8 +6292,8 @@ var RelayLink = class extends EventEmitter3 {
     }
   }
   async #write(credentials) {
-    await mkdir9(path16.dirname(this.#file), { recursive: true });
-    await writeFile10(this.#file, `${JSON.stringify(credentials, null, 2)}
+    await mkdir12(path20.dirname(this.#file), { recursive: true });
+    await writeFile13(this.#file, `${JSON.stringify(credentials, null, 2)}
 `, {
       encoding: "utf8",
       mode: 384
@@ -4946,7 +6317,7 @@ var RelayLink = class extends EventEmitter3 {
         body: JSON.stringify({ code, name: machine, platform: process.platform })
       });
     } catch (error) {
-      throw new Error(`\u043D\u0435 \u0434\u043E\u0437\u0432\u043E\u043D\u0438\u043B\u0438\u0441\u044C \u0434\u043E ${url2}: ${describe5(error)}`);
+      throw new Error(`\u043D\u0435 \u0434\u043E\u0437\u0432\u043E\u043D\u0438\u043B\u0438\u0441\u044C \u0434\u043E ${url2}: ${describe6(error)}`);
     }
     const data = await response.json().catch(() => ({}));
     if (!response.ok || !data.token || !data.hostId) {
@@ -4974,7 +6345,7 @@ var RelayLink = class extends EventEmitter3 {
     this.#error = null;
     this.#clients.clear();
     this.#shell = { enabled: false, pending: false, email: null, confirmedAt: null };
-    await rm3(this.#file, { force: true });
+    await rm5(this.#file, { force: true });
     this.#changed();
     this.#log("\u0441\u043E\u043F\u0440\u044F\u0436\u0435\u043D\u0438\u0435 \u0441\u043D\u044F\u0442\u043E");
   }
@@ -5165,11 +6536,11 @@ var RelayLink = class extends EventEmitter3 {
     socket.send(JSON.stringify(frame));
   }
 };
-function describe5(error) {
+function describe6(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function humanize(error) {
-  const message = describe5(error);
+  const message = describe6(error);
   if (/handshake has timed out/i.test(message)) {
     return `relay \u043D\u0435 \u043E\u0442\u0432\u0435\u0442\u0438\u043B \u043D\u0430 \u0440\u0443\u043A\u043E\u043F\u043E\u0436\u0430\u0442\u0438\u0435 \u0437\u0430 ${Math.round(HANDSHAKE_TIMEOUT_MS / 1e3)} \u0441 \u2014 \u043F\u0440\u043E\u0431\u0443\u0435\u043C \u0441\u043D\u043E\u0432\u0430`;
   }
@@ -5177,14 +6548,14 @@ function humanize(error) {
 }
 
 // ../host/dist/terminal.js
-import { EventEmitter as EventEmitter4 } from "node:events";
+import { EventEmitter as EventEmitter5 } from "node:events";
 import { access as access2, constants as constants2 } from "node:fs/promises";
-import path17 from "node:path";
-import { randomUUID as randomUUID3 } from "node:crypto";
+import path21 from "node:path";
+import { randomUUID as randomUUID4 } from "node:crypto";
 var SCROLLBACK_BYTES = 256 * 1024;
 var FLUSH_MS = 12;
 var MAX_TERMINALS = 24;
-var TerminalHub = class extends EventEmitter4 {
+var TerminalHub = class extends EventEmitter5 {
   #terminals = /* @__PURE__ */ new Map();
   #module = null;
   list(workspaceId) {
@@ -5217,7 +6588,7 @@ var TerminalHub = class extends EventEmitter4 {
       env: environment()
     });
     const info = {
-      id: randomUUID3(),
+      id: randomUUID4(),
       workspaceId: options2.workspaceId,
       title: shell.title,
       shell: shell.file,
@@ -5349,22 +6720,22 @@ async function defaultShell() {
     if (pwsh)
       return { file: pwsh, args: [], title: "pwsh" };
     const system = process.env.SystemRoot ?? "C:\\Windows";
-    const powershell = path17.join(system, "System32/WindowsPowerShell/v1.0/powershell.exe");
+    const powershell = path21.join(system, "System32/WindowsPowerShell/v1.0/powershell.exe");
     if (await exists2(powershell))
       return { file: powershell, args: [], title: "powershell" };
     return { file: process.env.COMSPEC ?? "cmd.exe", args: [], title: "cmd" };
   }
   const shell = process.env.SHELL;
   if (shell && await exists2(shell))
-    return { file: shell, args: [], title: path17.basename(shell) };
+    return { file: shell, args: [], title: path21.basename(shell) };
   if (await exists2("/bin/bash"))
     return { file: "/bin/bash", args: [], title: "bash" };
   return { file: "/bin/sh", args: [], title: "sh" };
 }
 async function findOnPath(name) {
-  const dirs = (process.env.PATH ?? "").split(path17.delimiter).filter(Boolean);
+  const dirs = (process.env.PATH ?? "").split(path21.delimiter).filter(Boolean);
   for (const dir of dirs) {
-    const candidate = path17.join(dir, name);
+    const candidate = path21.join(dir, name);
     if (await exists2(candidate))
       return candidate;
   }
@@ -5375,10 +6746,10 @@ function exists2(file) {
 }
 
 // ../host/dist/mcp-config.js
-import { readFile as readFile14, writeFile as writeFile11, mkdir as mkdir10 } from "node:fs/promises";
-import path18 from "node:path";
+import { readFile as readFile16, writeFile as writeFile14, mkdir as mkdir13 } from "node:fs/promises";
+import path22 from "node:path";
 var MCP_FILE = ".mcp.json";
-var LOCAL_SETTINGS2 = path18.join(".claude", "settings.local.json");
+var LOCAL_SETTINGS2 = path22.join(".claude", "settings.local.json");
 var queues = /* @__PURE__ */ new Map();
 function serialize(cwd, work) {
   const previous = queues.get(cwd) ?? Promise.resolve();
@@ -5387,7 +6758,7 @@ function serialize(cwd, work) {
   return next;
 }
 async function readProjectServers(cwd) {
-  const file = await readJson(path18.join(cwd, MCP_FILE));
+  const file = await readJson(path22.join(cwd, MCP_FILE));
   const servers = file?.mcpServers;
   if (!servers || typeof servers !== "object")
     return {};
@@ -5395,23 +6766,23 @@ async function readProjectServers(cwd) {
 }
 function addProjectServer(cwd, name, config) {
   return serialize(cwd, async () => {
-    const file = await readJson(path18.join(cwd, MCP_FILE)) ?? {};
+    const file = await readJson(path22.join(cwd, MCP_FILE)) ?? {};
     const servers = file.mcpServers ?? {};
     servers[name] = config;
     file.mcpServers = servers;
-    await writeJson(path18.join(cwd, MCP_FILE), file);
+    await writeJson(path22.join(cwd, MCP_FILE), file);
     await approve(cwd, name);
   });
 }
 function removeProjectServer(cwd, name) {
   return serialize(cwd, async () => {
-    const file = await readJson(path18.join(cwd, MCP_FILE));
+    const file = await readJson(path22.join(cwd, MCP_FILE));
     const servers = file?.mcpServers;
     if (!servers || !(name in servers))
       return false;
     delete servers[name];
-    await writeJson(path18.join(cwd, MCP_FILE), file);
-    const settingsPath = path18.join(cwd, LOCAL_SETTINGS2);
+    await writeJson(path22.join(cwd, MCP_FILE), file);
+    const settingsPath = path22.join(cwd, LOCAL_SETTINGS2);
     const settings = await readJson(settingsPath);
     const enabled = settings?.enabledMcpjsonServers;
     if (settings && Array.isArray(enabled) && enabled.includes(name)) {
@@ -5422,7 +6793,7 @@ function removeProjectServer(cwd, name) {
   });
 }
 async function approve(cwd, name) {
-  const file = path18.join(cwd, LOCAL_SETTINGS2);
+  const file = path22.join(cwd, LOCAL_SETTINGS2);
   const settings = await readJson(file) ?? {};
   const enabled = Array.isArray(settings.enabledMcpjsonServers) ? settings.enabledMcpjsonServers : [];
   if (!enabled.includes(name))
@@ -5461,21 +6832,21 @@ function describeConfig(config) {
 }
 async function readJson(file) {
   try {
-    const raw = await readFile14(file, "utf8");
+    const raw = await readFile16(file, "utf8");
     const parsed = JSON.parse(raw);
     return parsed && typeof parsed === "object" ? parsed : null;
   } catch (error) {
     if (error.code === "ENOENT")
       return null;
     if (error instanceof SyntaxError) {
-      throw new Error(`\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0440\u0430\u0437\u043E\u0431\u0440\u0430\u0442\u044C ${path18.basename(file)}: ${error.message}`);
+      throw new Error(`\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0440\u0430\u0437\u043E\u0431\u0440\u0430\u0442\u044C ${path22.basename(file)}: ${error.message}`);
     }
     throw error;
   }
 }
 async function writeJson(file, data) {
-  await mkdir10(path18.dirname(file), { recursive: true });
-  await writeFile11(file, `${JSON.stringify(data, null, 2)}
+  await mkdir13(path22.dirname(file), { recursive: true });
+  await writeFile14(file, `${JSON.stringify(data, null, 2)}
 `, "utf8");
 }
 
@@ -5500,6 +6871,7 @@ var HostServer = class {
   #settings;
   #finder;
   #sessions = /* @__PURE__ */ new Map();
+  #antigravity;
   /** Боковые сессии («вопрос на полях») по id родителя — не больше одной на разговор. */
   #sides = /* @__PURE__ */ new Map();
   /**
@@ -5529,7 +6901,12 @@ var HostServer = class {
    */
   #draftTouchedAt = /* @__PURE__ */ new Map();
   #autoStopTimer = null;
-  #hostId = randomUUID4();
+  #handoffs;
+  #limitStop;
+  #limitTimer = null;
+  /** Идёт остановка у лимита — второй снимок лимитов её не запускает. */
+  #limitStopping = false;
+  #hostId = randomUUID5();
   #plugins = new PluginCli();
   #auth = new AuthCli();
   #relay;
@@ -5552,6 +6929,9 @@ var HostServer = class {
     this.#order = new ListOrderStore(options2.dataDir);
     this.#folders = new Folders(options2.dataDir);
     this.#settings = new AppSettingsStore(options2.dataDir);
+    this.#antigravity = new AntigravityStore(options2.dataDir);
+    this.#handoffs = new HandoffStore(options2.dataDir);
+    this.#limitStop = new LimitStopState(options2.dataDir);
     this.#finder = new ProjectFinder(this.#workspaces);
     this.#relay = new RelayLink({ dataDir: options2.dataDir, defaultUrl: options2.relayUrl });
     this.#github = new GitHubAccount(options2.dataDir);
@@ -5571,6 +6951,7 @@ var HostServer = class {
     await this.#order.load();
     await this.#folders.load();
     await this.#settings.load();
+    await this.#limitStop.load();
     await this.#github.load();
     await warmClaudeLauncher();
     void this.#finder.warm();
@@ -5595,11 +6976,16 @@ var HostServer = class {
     });
     this.#autoStopTimer = setInterval(() => void this.#stopIdleSessions(), AUTO_STOP_SWEEP_MS);
     this.#autoStopTimer.unref();
+    this.#limitTimer = setInterval(() => this.#sweepUsage(), LIMIT_SWEEP_MS);
+    this.#limitTimer.unref();
   }
   async shutdown() {
     if (this.#autoStopTimer)
       clearInterval(this.#autoStopTimer);
     this.#autoStopTimer = null;
+    if (this.#limitTimer)
+      clearInterval(this.#limitTimer);
+    this.#limitTimer = null;
     this.#auth.cancel();
     this.#terminals.closeAll();
     await this.#relay.close();
@@ -6338,6 +7724,17 @@ var HostServer = class {
       case "settings.get":
         this.#send(socket, { type: "settings.state", settings: this.#settings.current });
         return;
+      case "handoff.get":
+        this.#send(socket, {
+          type: "handoff.state",
+          sessionId: frame.sessionId,
+          handoff: await this.#handoffs.get(frame.sessionId)
+        });
+        return;
+      case "handoff.dismiss":
+        await this.#handoffs.remove(frame.sessionId);
+        this.#broadcast({ type: "handoff.state", sessionId: frame.sessionId, handoff: null });
+        return;
       case "settings.update": {
         const before = this.#settings.current;
         const settings = await this.#settings.update(frame.settings);
@@ -6600,6 +7997,88 @@ var HostServer = class {
       this.#draftTouchedAt.delete(session.id);
     }
   }
+  // -------------------------------------------------------------------------
+  // Остановка у лимита плана
+  // -------------------------------------------------------------------------
+  /** Пользовательские сессии Claude — те, что останавливаются у лимита. */
+  #claudeUserSessions() {
+    return [...this.#sessions.values()].filter((s) => s instanceof ClaudeSession && s !== this.#finderSession && Boolean(s.workspaceId) && !s.summary().parentSessionId);
+  }
+  #isBusy(session) {
+    const summary = session.summary();
+    return BUSY_STATES.has(summary.state) || summary.backgroundWork;
+  }
+  /**
+   * Перечитать лимиты, пока хоть одна сессия занята. Сама сессия делает это
+   * по результатам инструментов, а долгий шаг модели без инструментов иначе
+   * прошёл бы мимо порога. Лимиты общие на аккаунт — спросить одну хватит.
+   */
+  #sweepUsage() {
+    const busy = this.#claudeUserSessions().find((s) => this.#isBusy(s));
+    if (busy)
+      void busy.refreshUsage();
+  }
+  async #checkLimit(usage) {
+    if (this.#limitStopping)
+      return;
+    const hit = crossedLimit(usage, this.#settings.current, (limit) => this.#limitStop.fired(limit));
+    if (!hit)
+      return;
+    this.#limitStopping = true;
+    try {
+      await this.#limitStop.mark(hit.limit, hit.until);
+      await this.#stopAtLimit(hit);
+    } catch (error) {
+      console.error("[limit-stop]", error instanceof Error ? error.message : String(error));
+    } finally {
+      this.#limitStopping = false;
+    }
+  }
+  /**
+   * Остановить все живые сессии Claude: занятые — после хода хэндоффа (или с
+   * хэндоффом из журнала, если агент не ответил), простаивающие — сразу.
+   */
+  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));
+        }
+      }
+      await this.#dropSession(session.id, "limit").catch(() => false);
+      return saved;
+    }));
+    this.#broadcast({
+      type: "limit.stopped",
+      limit: hit.limit,
+      utilization: hit.window.utilization,
+      resetsAt: hit.window.resetsAt,
+      stopped: results.length,
+      handoffs: results.filter(Boolean).length
+    });
+  }
   /**
    * Живые сессии всех проектов — вкладке запущенных.
    *
@@ -6654,6 +8133,26 @@ var HostServer = class {
     const workspace = this.#workspaces.find(frame.workspaceId);
     if (!workspace)
       throw new Error(`\u0412\u043E\u0440\u043A\u0441\u043F\u0435\u0439\u0441 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D: ${frame.workspaceId}`);
+    const agyRecord = frame.resume ? await this.#antigravity.find(frame.resume) : null;
+    if (agyRecord || !frame.resume && frame.provider === "antigravity") {
+      if (agyRecord)
+        await this.#archive.unarchive([agyRecord.id]);
+      const session2 = new AntigravitySession({
+        workspaceId: workspace.id,
+        cwd: agyRecord?.cwd ?? workspace.path,
+        store: this.#antigravity,
+        ...agyRecord ? { record: agyRecord } : {},
+        ...frame.permissionMode ? { permissionMode: frame.permissionMode } : {},
+        ...frame.model ? { model: frame.model } : {},
+        defaultTitle: workspace.name
+      });
+      this.#wire(session2);
+      this.#sessions.set(session2.id, session2);
+      session2.start();
+      this.#sendLive();
+      this.#send(socket, { type: "session.summary", session: session2.summary() });
+      return;
+    }
     const resumed = frame.resume && !frame.fork ? (await this.#workspaces.sessionsOnDisk(workspace.id)).find((info) => info.sessionId === frame.resume) : void 0;
     const resumedTitle = resumed ? diskTitle(resumed) : null;
     if (frame.resume)
@@ -6710,12 +8209,15 @@ var HostServer = class {
     });
     session.on("usage", (usage) => {
       this.#broadcast({ type: "usage.state", sessionId: session.id, usage });
+      if (session instanceof ClaudeSession)
+        void this.#checkLimit(usage);
     });
     session.on("context", (context) => {
       this.#broadcast({ type: "context.state", sessionId: session.id, context });
     });
     session.on("stderr", (data) => {
-      process.stderr.write(`[claude ${session.id.slice(0, 8)}] ${data}`);
+      const tag = session instanceof AntigravitySession ? "agy" : "claude";
+      process.stderr.write(`[${tag} ${session.id.slice(0, 8)}] ${data}`);
     });
   }
   // -------------------------------------------------------------------------
@@ -6734,6 +8236,9 @@ var HostServer = class {
    * разговора пока и не было.
    */
   #ensureSide(parent) {
+    if (parent instanceof AntigravitySession) {
+      throw new Error("\u0412\u043E\u043F\u0440\u043E\u0441 \u043D\u0430 \u043F\u043E\u043B\u044F\u0445 \u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D \u0442\u043E\u043B\u044C\u043A\u043E \u0432 \u0441\u0435\u0441\u0441\u0438\u044F\u0445 Claude");
+    }
     const existing = this.#sides.get(parent.id);
     if (existing && existing.state !== "closed" && existing.state !== "error") {
       return existing;
@@ -7031,6 +8536,11 @@ var HostServer = class {
       live.setTitle(title);
       return;
     }
+    if (await this.#antigravity.rename(sessionId, title)) {
+      if (workspaceId)
+        await this.#sendSessionList(workspaceId);
+      return;
+    }
     const dir = workspaceId ? this.#workspaces.find(workspaceId)?.path : void 0;
     await renameSession2(sessionId, title, dir ? { dir } : void 0);
     if (!workspaceId)
@@ -7052,6 +8562,7 @@ var HostServer = class {
     const workspacePath = this.#workspaces.find(workspaceId)?.path ?? "";
     const historical = onDisk.filter((info) => !liveIds.has(info.sessionId) && info.customTitle !== SIDE_TITLE && info.customTitle !== FINDER_TITLE).map((info) => ({
       id: info.sessionId,
+      provider: "claude",
       claudeSessionId: info.sessionId,
       workspaceId,
       cwd: info.cwd ?? workspacePath,
@@ -7076,6 +8587,11 @@ var HostServer = class {
       lastSeq: 0,
       totalCostUsd: 0
     }));
+    for (const record of await this.#antigravity.list(workspaceId)) {
+      if (liveIds.has(record.id))
+        continue;
+      historical.push(antigravitySummary(record));
+    }
     const known = /* @__PURE__ */ new Set([...liveIds, ...historical.map((s) => s.id)]);
     await this.#archive.sweep(workspaceId, historical.filter((s) => !this.#pins.has(s.id)).map((s) => ({ id: s.id, updatedAt: s.updatedAt })), known, this.#settings.current.autoArchiveAfterMs);
     await this.#pins.sweep(workspaceId, known);
@@ -7128,8 +8644,8 @@ var HostServer = class {
       return;
     }
     const url2 = new URL(req.url ?? "/", "http://localhost");
-    const requested = path19.join(webRoot, path19.normalize(url2.pathname));
-    const target = requested.startsWith(webRoot) && existsSync4(requested) && statSync3(requested).isFile() ? requested : path19.join(webRoot, "index.html");
+    const requested = path23.join(webRoot, path23.normalize(url2.pathname));
+    const target = requested.startsWith(webRoot) && existsSync4(requested) && statSync3(requested).isFile() ? requested : path23.join(webRoot, "index.html");
     if (!existsSync4(target)) {
       res.writeHead(404).end("not found");
       return;
@@ -7155,12 +8671,36 @@ function contentType(file) {
     ".svg": "image/svg+xml",
     ".woff2": "font/woff2"
   };
-  return types[path19.extname(file)] ?? "application/octet-stream";
+  return types[path23.extname(file)] ?? "application/octet-stream";
+}
+function antigravitySummary(record) {
+  return {
+    id: record.id,
+    provider: "antigravity",
+    claudeSessionId: record.id,
+    workspaceId: record.workspaceId,
+    cwd: record.cwd,
+    parentSessionId: null,
+    title: record.title,
+    state: "closed",
+    lastTurn: null,
+    backgroundWork: false,
+    model: record.model,
+    permissionMode: record.permissionMode,
+    effort: record.effort,
+    ultracode: false,
+    thinking: true,
+    switchModelsOnFlag: true,
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt,
+    lastSeq: 0,
+    totalCostUsd: 0
+  };
 }
 
 // dist/ccv.js
-var HERE = path20.dirname(fileURLToPath(import.meta.url));
-var PACKAGE_ROOT = path20.resolve(HERE, "..");
+var HERE = path24.dirname(fileURLToPath(import.meta.url));
+var PACKAGE_ROOT = path24.resolve(HERE, "..");
 var USAGE = `ccv \u2014 Claude Code Visual: \u043B\u043E\u043A\u0430\u043B\u044C\u043D\u044B\u0439 \u0445\u043E\u0441\u0442 Claude Code \u0441 \u0438\u043D\u0442\u0435\u0440\u0444\u0435\u0439\u0441\u043E\u043C \u0432 \u0431\u0440\u0430\u0443\u0437\u0435\u0440\u0435.
 
 \u0418\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u043D\u0438\u0435:
@@ -7227,7 +8767,7 @@ var server = new HostServer({
   dataDir: defaults.dataDir,
   // UI лежит в пакете рядом с бандлом — это и есть разница между установленной
   // утилитой и запуском из репозитория, где сборка живёт в `apps/web/dist`.
-  webRoot: process.env.CCV_WEB_ROOT ?? path20.join(PACKAGE_ROOT, "web"),
+  webRoot: process.env.CCV_WEB_ROOT ?? path24.join(PACKAGE_ROOT, "web"),
   version,
   relayUrl: defaults.relayUrl
 });
@@ -7256,7 +8796,7 @@ for (const signal of ["SIGINT", "SIGTERM"]) {
 }
 async function packageVersion() {
   try {
-    const text = await readFile15(path20.join(PACKAGE_ROOT, "package.json"), "utf8");
+    const text = await readFile17(path24.join(PACKAGE_ROOT, "package.json"), "utf8");
     return JSON.parse(text).version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -7300,7 +8840,7 @@ function openBrowser(target) {
     return;
   }
   const command = process.platform === "win32" ? { file: "cmd", args: ["/c", "start", "", target] } : process.platform === "darwin" ? { file: "open", args: [target] } : { file: "xdg-open", args: [target] };
-  const child = spawn2(command.file, command.args, {
+  const child = spawn3(command.file, command.args, {
     stdio: "ignore",
     detached: true,
     windowsHide: true