@i14ks/ccv 0.1.0

package/bundle/ccv.mjs

@@ -0,0 +1,4428 @@
+#!/usr/bin/env node
+
+// dist/ccv.js
+import { spawn as spawn2 } from "node:child_process";
+import { readFile as readFile10 } from "node:fs/promises";
+import path14 from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+
+// ../host/dist/claude-cli.js
+import { execFile, spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { access, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+var SDK_SCRIPT_EXT = [".js", ".mjs", ".ts", ".tsx", ".jsx"];
+var BARE = { file: "claude", prefix: [] };
+var DIRECT_EXT = /* @__PURE__ */ new Set([".exe", ".com"]);
+var SHIM_RELATIVE = /(?:%~?dp0%|\$basedir)[\\/]*([^"'\r\n]+?\.[cm]?js)/i;
+var SHIM_ABSOLUTE = /(["'])([A-Za-z]:[\\/][^"'\r\n]+?\.[cm]?js)\1/;
+var resolved = null;
+var inFlight = null;
+var searched = false;
+async function claudeLauncher() {
+  if (resolved)
+    return resolved;
+  inFlight ??= locate();
+  const found = await inFlight;
+  inFlight = null;
+  searched = true;
+  if (found)
+    resolved = found;
+  return found ?? BARE;
+}
+async function warmClaudeLauncher() {
+  await claudeLauncher();
+}
+function claudeExecutable() {
+  if (process.env.CCV_BUNDLED_CLAUDE)
+    return { source: "forced" };
+  const override = process.env.CCV_CLAUDE_PATH?.trim();
+  if (override)
+    return { source: "env", ...runnable(override) };
+  if (!searched || !resolved)
+    return { source: "bundled" };
+  const { file, prefix } = resolved;
+  if (prefix.length === 0)
+    return { source: "found", path: file };
+  const script = prefix[0];
+  if (!script || !isSdkScript(script))
+    return { source: "bundled" };
+  return { source: "found", path: script, executable: "node" };
+}
+function runnable(file) {
+  return isSdkScript(file) ? { path: file, executable: "node" } : { path: file };
+}
+function isSdkScript(file) {
+  return SDK_SCRIPT_EXT.includes(path.extname(file).toLowerCase());
+}
+async function runClaude(args, options2) {
+  const { file, prefix } = await claudeLauncher();
+  return new Promise((resolve, reject) => {
+    execFile(file, [...prefix, ...args], {
+      timeout: options2.timeout,
+      maxBuffer: options2.maxBuffer ?? 1024 * 1024,
+      windowsHide: true
+    }, (error, stdout, stderr) => {
+      if (!error)
+        return resolve(stdout.trim());
+      if (error.code === "ENOENT") {
+        return reject(new Error(`\u041D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D claude \u0432 PATH \u2014 ${options2.missing}`));
+      }
+      const detail = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
+      reject(new Error(detail || error.message));
+    });
+  });
+}
+async function spawnClaude(args) {
+  const { file, prefix } = await claudeLauncher();
+  return spawn(file, [...prefix, ...args], { windowsHide: true });
+}
+async function locate() {
+  for (const dir of searchDirs()) {
+    for (const name of names()) {
+      const found = await inspect(path.join(dir, name));
+      if (found)
+        return found;
+    }
+  }
+  return null;
+}
+function searchDirs() {
+  const fromPath = (process.env.PATH ?? "").split(path.delimiter).map((dir) => dir.replace(/^"|"$/g, "").trim()).filter(Boolean);
+  const home = homedir();
+  const known = process.platform === "win32" ? [path.join(home, ".local", "bin")] : [path.join(home, ".local", "bin"), "/usr/local/bin", "/opt/homebrew/bin"];
+  return [.../* @__PURE__ */ new Set([...fromPath, ...known])];
+}
+function names() {
+  if (process.platform !== "win32")
+    return ["claude"];
+  const exts = (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").map((ext) => ext.trim().toLowerCase()).filter((ext) => ext.startsWith("."));
+  return [...new Set(exts)].map((ext) => `claude${ext}`);
+}
+async function inspect(candidate) {
+  const mode = process.platform === "win32" ? constants.F_OK : constants.X_OK;
+  if (!await reachable(candidate, mode))
+    return null;
+  if (process.platform !== "win32")
+    return { file: candidate, prefix: [] };
+  if (DIRECT_EXT.has(path.extname(candidate).toLowerCase())) {
+    return { file: candidate, prefix: [] };
+  }
+  const script = await shimScript(candidate);
+  return script ? { file: process.execPath, prefix: [script] } : null;
+}
+async function shimScript(shim) {
+  const text = await readFile(shim, "utf8").catch(() => "");
+  if (!text)
+    return null;
+  const absolute = SHIM_ABSOLUTE.exec(text)?.[2];
+  const relative = SHIM_RELATIVE.exec(text)?.[1];
+  const script = absolute ?? (relative ? path.resolve(path.dirname(shim), relative) : null);
+  if (!script)
+    return null;
+  return await reachable(script, constants.F_OK) ? script : null;
+}
+function reachable(file, mode) {
+  return access(file, mode).then(() => true, () => false);
+}
+
+// ../host/dist/config.js
+import os from "node:os";
+import path2 from "node:path";
+function envDefaults() {
+  return {
+    port: Number(process.env.CCV_PORT ?? 8787),
+    // Только loopback. Наружу этот порт не выставляется — снаружи будет relay.
+    host: process.env.CCV_HOST ?? "127.0.0.1",
+    dataDir: process.env.CCV_DATA_DIR ?? path2.join(os.homedir(), ".claude-code-visual"),
+    // Куда сопрягаться за удалённым доступом. Переопределяется ради своего
+    // relay — и ради прогона всей связки на одной машине.
+    relayUrl: process.env.CCV_RELAY_URL ?? "https://claudevisual.com"
+  };
+}
+
+// ../host/dist/server.js
+import { createServer } from "node:http";
+import { createReadStream, existsSync as existsSync3, statSync as statSync3 } from "node:fs";
+import path13 from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { WebSocketServer } from "ws";
+import { renameSession as renameSession2 } from "@anthropic-ai/claude-agent-sdk";
+
+// ../protocol/dist/index.js
+var PROTOCOL_VERSION = 1;
+function isClientFrame(value) {
+  return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function workspaceIdFromPath(absolutePath) {
+  return absolutePath.replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-").toLowerCase();
+}
+
+// ../host/dist/session.js
+import { EventEmitter } from "node:events";
+import { randomUUID } from "node:crypto";
+import path5 from "node:path";
+import { query, renameSession } from "@anthropic-ai/claude-agent-sdk";
+
+// ../host/dist/async-queue.js
+var AsyncQueue = class {
+  #items = [];
+  #resolvers = [];
+  #closed = false;
+  push(item) {
+    if (this.#closed)
+      return;
+    const resolve = this.#resolvers.shift();
+    if (resolve) {
+      resolve({ value: item, done: false });
+    } else {
+      this.#items.push(item);
+    }
+  }
+  close() {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    for (const resolve of this.#resolvers) {
+      resolve({ value: void 0, done: true });
+    }
+    this.#resolvers = [];
+  }
+  get closed() {
+    return this.#closed;
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        const item = this.#items.shift();
+        if (item !== void 0) {
+          return Promise.resolve({ value: item, done: false });
+        }
+        if (this.#closed) {
+          return Promise.resolve({ value: void 0, done: true });
+        }
+        return new Promise((resolve) => this.#resolvers.push(resolve));
+      },
+      return: () => {
+        this.close();
+        return Promise.resolve({ value: void 0, done: true });
+      }
+    };
+  }
+};
+
+// ../host/dist/files.js
+import { lstat, mkdir, readFile as readFile2, readdir, realpath, rename as renamePath, rm, stat, writeFile } from "node:fs/promises";
+import path3 from "node:path";
+var MAX_FILE = 4 * 1024 * 1024;
+var SNIFF = 8192;
+var HIDDEN = /* @__PURE__ */ new Set([".git"]);
+var SEARCH_SKIP = /* @__PURE__ */ new Set([...HIDDEN, "node_modules"]);
+var SEARCH_LIMIT = 200;
+var GREP_LIMIT = 500;
+var GREP_LINE_PREVIEW = 300;
+var ProjectFiles = class {
+  cwd;
+  /** Корень, разрешённый от ссылок: с ним сравниваются все пути. */
+  #root = null;
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  async list(relative) {
+    const dir = await this.#resolve(relative);
+    const names2 = await readdir(dir, { withFileTypes: true });
+    const entries = [];
+    for (const dirent of names2) {
+      if (HIDDEN.has(dirent.name))
+        continue;
+      const full = path3.join(dir, dirent.name);
+      const link = dirent.isSymbolicLink();
+      const info = await stat(full).catch(() => null);
+      if (!info)
+        continue;
+      entries.push({
+        name: dirent.name,
+        path: join(relative, dirent.name),
+        kind: info.isDirectory() ? "dir" : "file",
+        size: info.isDirectory() ? 0 : info.size,
+        mtime: Math.round(info.mtimeMs),
+        link,
+        // Кто игнорируется, знает git, а не файловая система: отметку ставит
+        // сервер поверх готового списка (см. `markIgnored`).
+        ignored: false
+      });
+    }
+    return entries.sort((a, b) => {
+      if (a.kind !== b.kind)
+        return a.kind === "dir" ? -1 : 1;
+      return a.name.localeCompare(b.name, void 0, { numeric: true, sensitivity: "base" });
+    });
+  }
+  /**
+   * Поиск по подстроке в имени — рекурсивно по всему дереву проекта.
+   *
+   * В отличие от `list`, здесь нет ленивой подгрузки: искать в раскрытых
+   * каталогах бессмысленно, пользователь ищет как раз то, чего не видит.
+   * Поэтому обход идёт по диску напрямую, минуя `#resolve` на каждый шаг —
+   * он один раз проверяет корень, а дальше обход и так не выходит за
+   * найденные внутри него каталоги.
+   */
+  async search(query2) {
+    const needle = query2.trim().toLowerCase();
+    if (!needle)
+      return { entries: [], truncated: false };
+    const root = await this.#resolve("");
+    const entries = [];
+    let truncated = false;
+    const walk = async (dir, relative) => {
+      if (truncated)
+        return;
+      const names2 = await readdir(dir, { withFileTypes: true }).catch(() => []);
+      for (const dirent of names2) {
+        if (truncated)
+          return;
+        if (SEARCH_SKIP.has(dirent.name))
+          continue;
+        const full = path3.join(dir, dirent.name);
+        const rel = join(relative, dirent.name);
+        const info = await stat(full).catch(() => null);
+        if (!info)
+          continue;
+        const isDir = info.isDirectory();
+        if (dirent.name.toLowerCase().includes(needle)) {
+          if (entries.length >= SEARCH_LIMIT) {
+            truncated = true;
+            return;
+          }
+          entries.push({
+            name: dirent.name,
+            path: rel,
+            kind: isDir ? "dir" : "file",
+            size: isDir ? 0 : info.size,
+            mtime: Math.round(info.mtimeMs),
+            link: dirent.isSymbolicLink(),
+            ignored: false
+          });
+        }
+        if (isDir && !dirent.isSymbolicLink())
+          await walk(full, rel);
+      }
+    };
+    await walk(root, "");
+    entries.sort((a, b) => a.path.localeCompare(b.path, void 0, { numeric: true, sensitivity: "base" }));
+    return { entries, truncated };
+  }
+  /**
+   * Полнотекстовый поиск — подстрока в содержимом файлов, по всему дереву проекта.
+   *
+   * Как и `search`, обходит диск напрямую, минуя ленивую подгрузку дерева, и
+   * пропускает те же каталоги (`SEARCH_SKIP`). Дополнительно пропускает то, что
+   * не текст для чтения: бинарные файлы (по тому же признаку, что и `read`) и
+   * файлы больше `MAX_FILE` — совпадение внутри них всё равно нельзя было бы
+   * открыть в редакторе. Симлинки не разворачиваются вовсе: их цель — уже файл
+   * где-то в дереве, и он будет прочитан по своему собственному пути.
+   */
+  async grep(query2) {
+    const needle = query2.trim().toLowerCase();
+    if (!needle)
+      return { matches: [], truncated: false };
+    const root = await this.#resolve("");
+    const matches2 = [];
+    let truncated = false;
+    const walk = async (dir, relative) => {
+      if (truncated)
+        return;
+      const names2 = await readdir(dir, { withFileTypes: true }).catch(() => []);
+      for (const dirent of names2) {
+        if (truncated)
+          return;
+        if (SEARCH_SKIP.has(dirent.name) || dirent.isSymbolicLink())
+          continue;
+        const full = path3.join(dir, dirent.name);
+        const rel = join(relative, dirent.name);
+        if (dirent.isDirectory()) {
+          await walk(full, rel);
+          continue;
+        }
+        if (!dirent.isFile())
+          continue;
+        const info = await stat(full).catch(() => null);
+        if (!info || info.size > MAX_FILE)
+          continue;
+        const buffer = await readFile2(full).catch(() => null);
+        if (!buffer || isBinary(buffer))
+          continue;
+        const lines = buffer.toString("utf8").split(/\r\n|\n/);
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          const lower = line.toLowerCase();
+          let from = 0;
+          for (; ; ) {
+            const at = lower.indexOf(needle, from);
+            if (at === -1)
+              break;
+            if (matches2.length >= GREP_LIMIT) {
+              truncated = true;
+              break;
+            }
+            matches2.push({
+              path: rel,
+              line: i + 1,
+              column: at + 1,
+              lineText: line.length > GREP_LINE_PREVIEW ? line.slice(0, GREP_LINE_PREVIEW) : line,
+              matchLength: needle.length
+            });
+            from = at + needle.length;
+          }
+          if (truncated)
+            break;
+        }
+      }
+    };
+    await walk(root, "");
+    matches2.sort((a, b) => {
+      const byPath = a.path.localeCompare(b.path, void 0, { numeric: true, sensitivity: "base" });
+      if (byPath !== 0)
+        return byPath;
+      return a.line - b.line || a.column - b.column;
+    });
+    return { matches: matches2, truncated };
+  }
+  async read(relative) {
+    const file = await this.#resolve(relative);
+    const info = await stat(file);
+    if (info.isDirectory())
+      throw new Error("\u042D\u0442\u043E \u043A\u0430\u0442\u0430\u043B\u043E\u0433, \u0430 \u043D\u0435 \u0444\u0430\u0439\u043B");
+    const blank = {
+      path: normalize(relative),
+      content: "",
+      eol: "lf",
+      mtime: Math.round(info.mtimeMs),
+      size: info.size,
+      binary: false,
+      tooLarge: false
+    };
+    if (info.size > MAX_FILE)
+      return { ...blank, tooLarge: true };
+    const buffer = await readFile2(file);
+    if (isBinary(buffer))
+      return { ...blank, binary: true };
+    const text = buffer.toString("utf8");
+    const crlf = text.includes("\r\n");
+    return {
+      ...blank,
+      content: crlf ? text.replace(/\r\n/g, "\n") : text,
+      eol: crlf ? "crlf" : "lf"
+    };
+  }
+  /**
+   * Записать файл, если его на диске не подменили.
+   *
+   * `baseMtime` — версия, которую редактировали (0 для нового файла). Не
+   * совпало — значит, файл изменил кто-то ещё (почти наверняка агент), и
+   * молчаливая перезапись стёрла бы его работу. `force` снимает проверку —
+   * это сознательное решение пользователя, принятое после отказа.
+   */
+  async write(relative, content, eol, baseMtime, force = false) {
+    const file = await this.#resolve(relative);
+    const info = await stat(file).catch(() => null);
+    if (info?.isDirectory())
+      throw new Error("\u042D\u0442\u043E \u043A\u0430\u0442\u0430\u043B\u043E\u0433, \u0430 \u043D\u0435 \u0444\u0430\u0439\u043B");
+    if (!force) {
+      const onDisk = info ? Math.round(info.mtimeMs) : 0;
+      if (Math.abs(onDisk - baseMtime) > 1e3) {
+        throw new ConflictError(info ? "\u0424\u0430\u0439\u043B \u043D\u0430 \u0434\u0438\u0441\u043A\u0435 \u0438\u0437\u043C\u0435\u043D\u0438\u043B\u0441\u044F \u043F\u043E\u0441\u043B\u0435 \u0442\u043E\u0433\u043E, \u043A\u0430\u043A \u0435\u0433\u043E \u043E\u0442\u043A\u0440\u044B\u043B\u0438 \u0432 \u0440\u0435\u0434\u0430\u043A\u0442\u043E\u0440\u0435" : "\u0424\u0430\u0439\u043B \u043D\u0430 \u0434\u0438\u0441\u043A\u0435 \u0438\u0441\u0447\u0435\u0437 \u043F\u043E\u0441\u043B\u0435 \u0442\u043E\u0433\u043E, \u043A\u0430\u043A \u0435\u0433\u043E \u043E\u0442\u043A\u0440\u044B\u043B\u0438 \u0432 \u0440\u0435\u0434\u0430\u043A\u0442\u043E\u0440\u0435");
+      }
+    }
+    await writeFile(file, eol === "crlf" ? content.replace(/\n/g, "\r\n") : content, "utf8");
+    const saved = await stat(file);
+    return { mtime: Math.round(saved.mtimeMs), size: saved.size };
+  }
+  async create(relative, kind) {
+    const target = await this.#resolve(relative);
+    if (await exists(target))
+      throw new Error("\u0422\u0430\u043A\u043E\u0439 \u0444\u0430\u0439\u043B \u0438\u043B\u0438 \u043A\u0430\u0442\u0430\u043B\u043E\u0433 \u0443\u0436\u0435 \u0435\u0441\u0442\u044C");
+    if (kind === "dir") {
+      await mkdir(target, { recursive: true });
+      return;
+    }
+    await mkdir(path3.dirname(target), { recursive: true });
+    await writeFile(target, "", { encoding: "utf8", flag: "wx" });
+  }
+  async rename(relative, to) {
+    const from = await this.#resolve(relative);
+    const target = await this.#resolve(to);
+    if (from === target)
+      return;
+    if (await exists(target))
+      throw new Error("\u041F\u043E \u043D\u043E\u0432\u043E\u043C\u0443 \u043F\u0443\u0442\u0438 \u0443\u0436\u0435 \u0447\u0442\u043E-\u0442\u043E \u0435\u0441\u0442\u044C");
+    await mkdir(path3.dirname(target), { recursive: true });
+    await renamePath(from, target);
+  }
+  async remove(relative) {
+    const target = await this.#resolve(relative);
+    if (!normalize(relative))
+      throw new Error("\u0423\u0434\u0430\u043B\u0438\u0442\u044C \u043A\u043E\u0440\u0435\u043D\u044C \u043F\u0440\u043E\u0435\u043A\u0442\u0430 \u043D\u0435\u043B\u044C\u0437\u044F");
+    await rm(target, { recursive: true, force: false });
+  }
+  /**
+   * Относительный путь -> абсолютный, внутри проекта и нигде больше.
+   *
+   * Одной склейки мало: `..` в пути и символическая ссылка наружу — разные
+   * способы выйти из корня, и второй не ловится сравнением строк. Поэтому
+   * корень и существующая часть цели разрешаются через `realpath`, а
+   * несуществующая (её создают) проверяется по разрешённому родителю.
+   */
+  async #resolve(relative) {
+    const clean = normalize(relative);
+    if (path3.isAbsolute(clean) || /^[A-Za-z]:/.test(clean)) {
+      throw new Error("\u041F\u0443\u0442\u044C \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u043E\u0442\u043D\u043E\u0441\u0438\u0442\u0435\u043B\u044C\u043D\u044B\u043C \u043E\u0442 \u043A\u043E\u0440\u043D\u044F \u043F\u0440\u043E\u0435\u043A\u0442\u0430");
+    }
+    if (clean.split("/").includes("..")) {
+      throw new Error("\u0412\u044B\u0445\u043E\u0434 \u0437\u0430 \u043F\u0440\u0435\u0434\u0435\u043B\u044B \u043A\u0430\u0442\u0430\u043B\u043E\u0433\u0430 \u043F\u0440\u043E\u0435\u043A\u0442\u0430 \u0437\u0430\u043F\u0440\u0435\u0449\u0451\u043D");
+    }
+    const root = this.#root ??= await realpath(this.cwd);
+    const target = path3.resolve(root, clean);
+    const probe = await exists(target) ? target : path3.dirname(target);
+    const real = await realpath(probe).catch(() => probe);
+    if (!contains(root, real)) {
+      throw new Error("\u0412\u044B\u0445\u043E\u0434 \u0437\u0430 \u043F\u0440\u0435\u0434\u0435\u043B\u044B \u043A\u0430\u0442\u0430\u043B\u043E\u0433\u0430 \u043F\u0440\u043E\u0435\u043A\u0442\u0430 \u0437\u0430\u043F\u0440\u0435\u0449\u0451\u043D");
+    }
+    return target;
+  }
+};
+var ConflictError = class extends Error {
+  conflict = true;
+};
+function normalize(relative) {
+  return relative.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+}
+function join(dir, name) {
+  const base = normalize(dir);
+  return base ? `${base}/${name}` : name;
+}
+function contains(root, target) {
+  if (target === root)
+    return true;
+  const prefix = root.endsWith(path3.sep) ? root : root + path3.sep;
+  return process.platform === "win32" ? target.toLowerCase().startsWith(prefix.toLowerCase()) : target.startsWith(prefix);
+}
+async function exists(file) {
+  return lstat(file).then(() => true, () => false);
+}
+function isBinary(buffer) {
+  const head = buffer.subarray(0, SNIFF);
+  return head.includes(0);
+}
+
+// ../host/dist/journal.js
+var Journal = class {
+  #entries = [];
+  #nextSeq = 1;
+  #maxEntries;
+  constructor(maxEntries = 5e3) {
+    this.#maxEntries = maxEntries;
+  }
+  get lastSeq() {
+    return this.#nextSeq - 1;
+  }
+  append(event) {
+    const entry = { seq: this.#nextSeq++, ts: Date.now(), event };
+    this.#entries.push(entry);
+    if (this.#entries.length > this.#maxEntries) {
+      this.#entries.splice(0, this.#entries.length - this.#maxEntries);
+    }
+    return entry;
+  }
+  /** Всё, что появилось после `sinceSeq`. Пустой массив = клиент уже в курсе. */
+  since(sinceSeq) {
+    if (sinceSeq >= this.lastSeq)
+      return [];
+    const idx = this.#entries.findIndex((e) => e.seq > sinceSeq);
+    return idx === -1 ? [] : this.#entries.slice(idx);
+  }
+  /**
+   * Самый ранний seq, который мы ещё можем отдать. Если клиент отстал сильнее,
+   * догон невозможен — ему нужно перечитать транскрипт целиком.
+   */
+  get oldestSeq() {
+    return this.#entries[0]?.seq ?? this.#nextSeq;
+  }
+};
+
+// ../host/dist/settings.js
+import { readFile as readFile3 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import path4 from "node:path";
+var USER_SETTINGS = path4.join(homedir2(), ".claude", "settings.json");
+var PROJECT_SETTINGS = path4.join(".claude", "settings.json");
+var LOCAL_SETTINGS = path4.join(".claude", "settings.local.json");
+function managedSettingsPath() {
+  switch (process.platform) {
+    case "win32":
+      return path4.join(process.env.PROGRAMDATA ?? "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
+    case "darwin":
+      return "/Library/Application Support/ClaudeCode/managed-settings.json";
+    default:
+      return "/etc/claude-code/managed-settings.json";
+  }
+}
+var EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
+async function readConfiguredDefaults(cwd) {
+  const files = [
+    USER_SETTINGS,
+    path4.join(cwd, PROJECT_SETTINGS),
+    path4.join(cwd, LOCAL_SETTINGS),
+    managedSettingsPath()
+  ];
+  const result = {
+    model: null,
+    effort: null,
+    ultracode: false,
+    thinking: true,
+    switchModelsOnFlag: true
+  };
+  for (const file of files) {
+    const settings = await readSettings(file);
+    if (!settings)
+      continue;
+    const value = settings.model;
+    if (typeof value === "string" && value.trim())
+      result.model = value.trim();
+    const env = settings.env;
+    if (env && typeof env === "object") {
+      const fromEnv = env.ANTHROPIC_MODEL;
+      if (typeof fromEnv === "string" && fromEnv.trim())
+        result.model = fromEnv.trim();
+    }
+    const effort = settings.effortLevel;
+    if (typeof effort === "string" && EFFORT_LEVELS.includes(effort)) {
+      result.effort = effort;
+    }
+    if (typeof settings.ultracode === "boolean") {
+      result.ultracode = settings.ultracode;
+      if (settings.ultracode)
+        result.effort = "xhigh";
+    }
+    if (typeof settings.alwaysThinkingEnabled === "boolean") {
+      result.thinking = settings.alwaysThinkingEnabled;
+    }
+    if (typeof settings.switchModelsOnFlag === "boolean") {
+      result.switchModelsOnFlag = settings.switchModelsOnFlag;
+    }
+  }
+  const fromProcess = process.env.ANTHROPIC_MODEL?.trim();
+  if (fromProcess)
+    result.model = fromProcess;
+  return result;
+}
+async function readSettings(file) {
+  try {
+    const parsed = JSON.parse(await readFile3(file, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+// ../host/dist/session.js
+function uiSystemPromptAppend(cwd) {
+  const markdown = "You are running inside Claude Code Visual, a GUI for Claude Code. When the user opens a .md file in this app, it is rendered as formatted, human-readable text (headings, lists, code blocks, tables) by default \u2014 not shown as raw markdown source. A toggle lets them switch to the raw source view if they want to edit it. So when producing a report, plan, summary, or any other document meant for the user to read, prefer writing it to a .md file rather than only in chat \u2014 the user will see it rendered, not as plain marked-up text.";
+  if (!cwd)
+    return markdown;
+  return markdown + `
+
+The user has a project open in this app: ${cwd}. Its file explorer shows that directory and nothing else \u2014 a file written anywhere outside it is invisible to the user, no matter how the path was described to them. So every file you create or edit belongs inside the project directory unless the user explicitly named a location outside it. This takes precedence over the scratchpad instruction above: use the scratchpad only for throwaway intermediates the user will never open, never for a file the user asked for. When asked for a file without being told where, put it in the project directory.`;
+}
+var READ_ONLY_TOOLS = ["Read", "Grep", "Glob"];
+var WRITE_TOOLS = "Write|Edit|NotebookEdit";
+function writeTarget(input) {
+  if (typeof input !== "object" || input === null)
+    return null;
+  const record = input;
+  const target = record.file_path ?? record.notebook_path;
+  return typeof target === "string" && target ? target : null;
+}
+var USAGE_MIN_INTERVAL_MS = 2e4;
+var ClaudeSession = class extends EventEmitter {
+  id;
+  workspaceId;
+  cwd;
+  journal = new Journal();
+  #query = null;
+  /** Чем подняли эту сессию — нужно, чтобы объяснить провал старта. */
+  #executable = { source: "bundled" };
+  #inbox = new AsyncQueue();
+  #state = "starting";
+  #capabilities = null;
+  #pendingPermissions = /* @__PURE__ */ new Map();
+  #model = null;
+  #permissionMode;
+  /**
+   * Усилие, размышления и подмена модели по флагу.
+   *
+   * Живут рядом с моделью и режимом прав, потому что меняются так же — на лету,
+   * через `applyFlagSettings`. Начальные значения читаются с диска (см.
+   * `#resolveDefaults`): спросить о них SDK, как и о текущей модели, нельзя.
+   */
+  #effort = null;
+  #ultracode = false;
+  #thinking = true;
+  #switchModelsOnFlag = true;
+  #title = null;
+  /**
+   * Имя сессии — всё ещё подставленное имя проекта, а не сказанное о деле.
+   *
+   * Первый промпт заменяет только такое имя: переименованную вручную сессию
+   * он трогать не должен, а у продолженной имя пришло с диска и тоже настоящее.
+   */
+  #titleIsDefault = false;
+  /** Настоящий id сессии Claude Code — известен только после system/init. */
+  #claudeSessionId = null;
+  /**
+   * Имя, которое пользователь задал, но записать на диск ещё не удалось.
+   *
+   * JSONL сессии появляется только после первого обмена, поэтому
+   * переименование пустой сессии писать некуда — повторяем после result.
+   */
+  #unpersistedTitle = null;
+  /**
+   * id текущего ассистентского сообщения (msg_…).
+   *
+   * Нужен как общий ключ для дельт: у каждого `stream_event` собственный
+   * uuid, поэтому склеивать поток по нему нельзя — получаются обрывки. А
+   * `message_start.message.id` совпадает с `id` финального assistant-блока,
+   * так что UI заменяет накопленный стрим целиком.
+   */
+  #streamMessageId = null;
+  /**
+   * Сколько блоков сообщения `msg_…` уже пришло финальными.
+   *
+   * SDK отдаёт assistant-сообщения по одному блоку за раз, и в каждом таком
+   * сообщении блок лежит в `content[0]`. Индекс же у дельт растёт по всем
+   * блокам сообщения подряд, поэтому позиция в массиве ключом быть не может:
+   * текст после `thinking` или `tool_use` получал бы финальный `:0` против
+   * стримового `:1` и рисовался бы в ленте дважды. Считаем блоки сами.
+   */
+  #blockCounts = /* @__PURE__ */ new Map();
+  /**
+   * MCP-серверы, добавленные в эту сессию на лету.
+   *
+   * Помним их, потому что `setMcpServers` принимает полный набор: отправив
+   * только что добавленный сервер, мы отключили бы все предыдущие.
+   */
+  #dynamicMcp = /* @__PURE__ */ new Map();
+  #totalCostUsd = 0;
+  /** Последний снимок расхода лимитов плана; null — ещё не спрашивали. */
+  #usage = null;
+  /** Когда была последняя попытка его получить — удачная или нет. */
+  #usageAt = 0;
+  #usageInFlight = false;
+  #createdAt = Date.now();
+  #updatedAt = Date.now();
+  #options;
+  constructor(options2) {
+    super();
+    this.#options = options2;
+    this.id = options2.resume && !options2.fork ? options2.resume : randomUUID();
+    this.workspaceId = options2.workspaceId;
+    this.cwd = options2.cwd;
+    this.#permissionMode = options2.permissionMode ?? "default";
+    this.#model = options2.model ?? null;
+    this.#title = options2.title ?? options2.defaultTitle ?? null;
+    this.#titleIsDefault = !options2.title && options2.defaultTitle !== void 0;
+  }
+  // -------------------------------------------------------------------------
+  // Публичное состояние
+  // -------------------------------------------------------------------------
+  get state() {
+    return this.#state;
+  }
+  get capabilities() {
+    return this.#capabilities;
+  }
+  get claudeSessionId() {
+    return this.#claudeSessionId;
+  }
+  /** Боковая сессия («вопрос на полях») — у неё есть родитель и нет прав на запись. */
+  get parentSessionId() {
+    return this.#options.parentSessionId ?? null;
+  }
+  /** Расход лимитов плана. null — ещё ни разу не спросили или спросить не вышло. */
+  get usage() {
+    return this.#usage;
+  }
+  summary() {
+    return {
+      id: this.id,
+      claudeSessionId: this.#claudeSessionId,
+      workspaceId: this.workspaceId,
+      cwd: this.cwd,
+      parentSessionId: this.parentSessionId,
+      title: this.#title,
+      state: this.#state,
+      model: this.#model,
+      permissionMode: this.#permissionMode,
+      effort: this.#effort,
+      ultracode: this.#ultracode,
+      thinking: this.#thinking,
+      switchModelsOnFlag: this.#switchModelsOnFlag,
+      createdAt: this.#createdAt,
+      updatedAt: this.#updatedAt,
+      lastSeq: this.journal.lastSeq,
+      totalCostUsd: this.#totalCostUsd
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Жизненный цикл
+  // -------------------------------------------------------------------------
+  start() {
+    if (this.#query)
+      throw new Error("session already started");
+    const options2 = {
+      cwd: this.cwd,
+      // Без этого SDK не читает с диска ничего: ни CLAUDE.md, ни кастомные
+      // слэш-команды, ни сабагентов из .claude/agents, ни MCP из settings.json.
+      // Именно эта строка отвечает за «сохранить весь функционал Claude Code».
+      settingSources: ["user", "project", "local"],
+      systemPrompt: {
+        type: "preset",
+        preset: "claude_code",
+        // Каталог называем только когда это правда каталог проекта. У сессии
+        // поиска воркспейса нет, а `cwd` у неё — корень, где ищут: назвать его
+        // «открытым проектом» значило бы соврать.
+        append: uiSystemPromptAppend(this.workspaceId ? this.cwd : null)
+      },
+      permissionMode: this.#permissionMode,
+      // Не включает `bypassPermissions`, а лишь разрешает его выбрать. Без
+      // флага CLI отказывает в переходе на лету («session was not launched
+      // with --dangerously-skip-permissions»), и пункт в выпадающем списке
+      // шапки просто не работал: режим молча оставался прежним. Раз пункт
+      // предложен человеку, выбор должен исполняться — а решает он.
+      allowDangerouslySkipPermissions: true,
+      // Даёт посимвольный стрим ответа, а не «тишина, потом стена текста».
+      includePartialMessages: true,
+      canUseTool: this.#canUseTool,
+      hooks: {
+        PreToolUse: [
+          {
+            matcher: WRITE_TOOLS,
+            hooks: [(input) => this.#guardWrite(input)]
+          }
+        ]
+      },
+      stderr: (data) => this.emit("stderr", data)
+    };
+    this.#executable = claudeExecutable();
+    if (this.#executable.path) {
+      options2.pathToClaudeCodeExecutable = this.#executable.path;
+      if (this.#executable.executable)
+        options2.executable = this.#executable.executable;
+    }
+    if (this.#model)
+      options2.model = this.#model;
+    if (this.#options.resume)
+      options2.resume = this.#options.resume;
+    if (this.#options.fork)
+      options2.forkSession = true;
+    if (this.#options.outputFormat)
+      options2.outputFormat = this.#options.outputFormat;
+    if (this.#options.readOnly) {
+      options2.tools = READ_ONLY_TOOLS;
+      options2.allowedTools = READ_ONLY_TOOLS;
+      options2.strictMcpConfig = true;
+    }
+    this.#query = query({ prompt: this.#inbox, options: options2 });
+    void this.#consume(this.#query);
+    void this.#loadCatalog();
+  }
+  /**
+   * Что известно о сессии до system/init.
+   *
+   * Каталог и режим прав мы задали сами, поэтому UI может показать их сразу.
+   * Модель здесь — алиас из опций сессии или из settings.json (см.
+   * `#resolveModel`), а не канонический id: до init канонического взять
+   * неоткуда, а показывать пустоту вместо выбранной в консоли модели хуже.
+   */
+  #baseCapabilities() {
+    return {
+      cwd: this.cwd,
+      model: this.#model ?? "",
+      permissionMode: this.#permissionMode,
+      slashCommands: [],
+      commands: [],
+      models: [],
+      tools: [],
+      agents: [],
+      mcpServers: [],
+      flags: []
+    };
+  }
+  async close(reason = "closed by client") {
+    this.#inbox.close();
+    for (const [requestId, pending] of this.#pendingPermissions) {
+      pending.resolve({ behavior: "deny", message: reason });
+      this.#pendingPermissions.delete(requestId);
+    }
+    try {
+      this.#query?.close();
+    } catch {
+    }
+    this.#setState("closed");
+  }
+  // -------------------------------------------------------------------------
+  // Ввод от пользователя
+  // -------------------------------------------------------------------------
+  sendPrompt(text) {
+    if (this.#inbox.closed)
+      throw new Error("session is closed");
+    this.#record({ kind: "user.message", text });
+    if (!this.#title || this.#titleIsDefault) {
+      this.#title = text.slice(0, 80);
+      this.#titleIsDefault = false;
+    }
+    if (this.#state === "error") {
+      this.#record({
+        kind: "error",
+        message: "\u0421\u0435\u0441\u0441\u0438\u044F \u043D\u0435 \u0437\u0430\u043F\u0443\u0449\u0435\u043D\u0430, \u043E\u0442\u043F\u0440\u0430\u0432\u043B\u044F\u0442\u044C \u043F\u0440\u043E\u043C\u043F\u0442 \u043D\u0435\u043A\u0443\u0434\u0430 \u2014 \u0441\u043C. \u043E\u0448\u0438\u0431\u043A\u0443 \u0432\u044B\u0448\u0435."
+      });
+      return;
+    }
+    this.#setState("running");
+    this.#inbox.push({
+      type: "user",
+      message: { role: "user", content: [{ type: "text", text }] },
+      parent_tool_use_id: null
+    });
+  }
+  respondPermission(requestId, decision, reason) {
+    const pending = this.#pendingPermissions.get(requestId);
+    if (!pending)
+      return;
+    this.#pendingPermissions.delete(requestId);
+    pending.resolve(decision === "allow" ? { behavior: "allow", updatedInput: pending.input } : { behavior: "deny", message: reason ?? "\u041E\u0442\u043A\u043B\u043E\u043D\u0435\u043D\u043E \u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u0435\u043C" });
+    this.#record({ kind: "permission.resolved", requestId, decision, reason });
+    if (this.#pendingPermissions.size === 0)
+      this.#setState("running");
+  }
+  async interrupt() {
+    await this.#query?.interrupt();
+  }
+  /**
+   * Смена режима прав на лету.
+   *
+   * Отказ CLI гасим в ленту сессии, а не наружу исключением: кадр `error`
+   * клиент пишет в консоль браузера, и несменившийся режим выглядел бы
+   * молчаливым отказом кнопки. Здесь же рассылаем summary с прежним режимом —
+   * выпадающий список должен показывать то, что есть, а не то, что выбрали.
+   */
+  async setPermissionMode(mode) {
+    try {
+      await this.#query?.setPermissionMode(mode);
+    } catch (error) {
+      this.#record({
+        kind: "error",
+        message: `\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043F\u0435\u0440\u0435\u0439\u0442\u0438 \u0432 \u0440\u0435\u0436\u0438\u043C ${mode}: ${error instanceof Error ? error.message : String(error)}`
+      });
+      this.emit("summary", this.summary());
+      return;
+    }
+    this.#permissionMode = mode;
+    this.emit("summary", this.summary());
+  }
+  async setModel(model) {
+    await this.#query?.setModel(model);
+    this.#model = model;
+    this.emit("summary", this.summary());
+  }
+  /**
+   * Усилие, размышления и подмена модели по флагу — всё это слой «флаговых»
+   * настроек SDK.
+   *
+   * `applyFlagSettings` кладёт значение над пользовательскими и проектными
+   * настройками, но под корпоративной политикой — то же место, куда пишет
+   * консоль, когда меняют то же самое на лету. Поэтому выбор действует до
+   * конца сессии и не переписывает settings.json пользователя.
+   *
+   * Локальное поле обновляем только после успеха: иначе шапка показывала бы
+   * уровень, до CLI не доехавший.
+   */
+  async setEffort(effort) {
+    await this.#query?.applyFlagSettings(this.#ultracode ? { effortLevel: effort, ultracode: false } : { effortLevel: effort });
+    this.#effort = effort;
+    this.#ultracode = false;
+    this.emit("summary", this.summary());
+  }
+  /**
+   * Ultracode: `xhigh` плюс постоянная оркестрация динамическими воркфлоу.
+   *
+   * Уровень выставляем сами, потому что CLI о нём отдельно не отчитывается, а
+   * в шапке уровень виден рядом с моделью. Выключение уровень не возвращает:
+   * `xhigh` остаётся ровно тем, что и был выбран, — понижать его за
+   * пользователя мы не вправе.
+   */
+  async setUltracode(enabled) {
+    await this.#query?.applyFlagSettings(enabled ? { ultracode: true, effortLevel: "xhigh" } : { ultracode: false });
+    this.#ultracode = enabled;
+    if (enabled)
+      this.#effort = "xhigh";
+    this.emit("summary", this.summary());
+  }
+  async setThinking(enabled) {
+    await this.#query?.applyFlagSettings({ alwaysThinkingEnabled: enabled });
+    this.#thinking = enabled;
+    this.emit("summary", this.summary());
+  }
+  async setSwitchModelsOnFlag(enabled) {
+    await this.#query?.applyFlagSettings({ switchModelsOnFlag: enabled });
+    this.#switchModelsOnFlag = enabled;
+    this.emit("summary", this.summary());
+  }
+  // -------------------------------------------------------------------------
+  // Лимиты плана
+  // -------------------------------------------------------------------------
+  /**
+   * Перечитать расход лимитов подписки.
+   *
+   * `force` — по прямой просьбе клиента (открыли сессию, CLI сам сказал, что
+   * лимит сдвинулся): тогда пауза между запросами не действует.
+   *
+   * Неудача здесь ничего не ломает и в ленту не пишется. Метод SDK помечен как
+   * экспериментальный и на старом CLI может отсутствовать вовсе — сессия от
+   * этого работать не перестаёт, просто полосы в шапке не будет.
+   */
+  async refreshUsage(force = false) {
+    const q = this.#query;
+    if (!q || this.#usageInFlight)
+      return;
+    if (!force && Date.now() - this.#usageAt < USAGE_MIN_INTERVAL_MS)
+      return;
+    this.#usageInFlight = true;
+    try {
+      const raw = await q.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET();
+      this.#usage = toUsageState(raw);
+      this.emit("usage", this.#usage);
+    } catch {
+    } finally {
+      this.#usageAt = Date.now();
+      this.#usageInFlight = false;
+    }
+  }
+  // -------------------------------------------------------------------------
+  // MCP и плагины
+  // -------------------------------------------------------------------------
+  /** Живые статусы серверов: подключён, упал, ждёт авторизации. */
+  async mcpServerStatus() {
+    return await this.#query?.mcpServerStatus() ?? [];
+  }
+  /**
+   * Поднять сервер в уже работающей сессии.
+   *
+   * `setMcpServers` заменяет весь набор динамических серверов целиком, а не
+   * добавляет один, — поэтому добавленное за сессию приходится помнить и
+   * отправлять каждый раз списком. Серверы из файлов настроек этот вызов не
+   * трогает, так что своё накопленное ими не затрёт.
+   */
+  async addMcpServer(name, config) {
+    this.#dynamicMcp.set(name, config);
+    await this.#query?.setMcpServers(Object.fromEntries(this.#dynamicMcp));
+  }
+  /** Убрать сервер из живой сессии. Возвращает false, если он не наш. */
+  async removeMcpServer(name) {
+    if (!this.#dynamicMcp.delete(name))
+      return false;
+    await this.#query?.setMcpServers(Object.fromEntries(this.#dynamicMcp));
+    return true;
+  }
+  /** Перечитать плагины с диска — после установки через внешний CLI. */
+  async reloadPlugins() {
+    const result = await this.#query?.reloadPlugins();
+    if (!result)
+      return;
+    this.#capabilities = {
+      ...this.#capabilities ?? this.#baseCapabilities(),
+      commands: result.commands.map(toSlashCommand),
+      agents: result.agents.map((a) => a.name),
+      mcpServers: result.mcpServers.map((s) => ({ name: s.name, status: s.status }))
+    };
+    this.emit("capabilities", this.#capabilities);
+  }
+  /**
+   * Переименовать сессию.
+   *
+   * В памяти — сразу, чтобы UI не ждал диска. На диск — тем же способом, что
+   * `/rename` в CLI: запись в JSONL, так что имя переживает перезапуск хоста и
+   * видно из самого Claude Code.
+   */
+  setTitle(title) {
+    this.#title = title;
+    this.#titleIsDefault = false;
+    this.#updatedAt = Date.now();
+    this.emit("summary", this.summary());
+    void this.#persistTitle();
+  }
+  async #persistTitle() {
+    const title = this.#title;
+    if (!title || !this.#claudeSessionId) {
+      this.#unpersistedTitle = title;
+      return;
+    }
+    try {
+      await renameSession(this.#claudeSessionId, title, { dir: this.cwd });
+      this.#unpersistedTitle = null;
+    } catch (error) {
+      this.#unpersistedTitle = title;
+      this.emit("stderr", `rename \u043D\u0435 \u0437\u0430\u043F\u0438\u0441\u0430\u043D: ${describe(error)}
+`);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Права: мост между колбэком SDK и асинхронным ответом из UI
+  // -------------------------------------------------------------------------
+  /**
+   * SDK ждёт промис — мы его паркуем и разрешаем, когда придёт кадр
+   * `permission.respond`. Промис переживает разрыв соединения с UI: агент
+   * просто стоит на паузе, пока клиент не вернётся и не ответит.
+   */
+  /**
+   * Запись за пределы проекта — только с разрешения человека.
+   *
+   * Промптом это не чинится: `cwd` задаёт каталог процессу, но не выбирает
+   * место за модель, а системный промпт CLI отдельно и настойчиво зовёт писать
+   * «временное» в scratchpad внутри `%TEMP%`. Однажды туда уехал файл, который
+   * просили создать в проекте, — и в UI его было не найти: проводник показывает
+   * только каталог проекта. Назвать каталог в промпте (`uiSystemPromptAppend`)
+   * помогает, но остаётся уговором, а этот хук — проверкой.
+   *
+   * Именно `PreToolUse`, а не `canUseTool`: до `canUseTool` дело не доходит в
+   * `acceptEdits`, `dontAsk` и `bypassPermissions` — там запись разрешена
+   * заранее. Решение хука эти режимы перебивает, поэтому правило работает во
+   * всех.
+   *
+   * Решение — `ask`, а не `deny`: писать вне проекта иногда надо по делу
+   * (настройки в `~/.claude`, временный скрипт). Запрет ломал бы это, а вопрос
+   * лишь возвращает выбор человеку — нажатое «Разрешить» и есть то самое явное
+   * согласие на «иное место».
+   *
+   * Где именно проходит граница, решает настройка «Доступ к папкам»
+   * (`writableRoots`): её самый широкий вариант убирает вопрос совсем, самый
+   * строгий оставляет ровно каталог проекта.
+   */
+  #guardWrite = async (input) => {
+    const pass = { continue: true };
+    if (!this.workspaceId)
+      return pass;
+    const roots = this.#options.writableRoots?.() ?? [this.cwd];
+    if (roots === null)
+      return pass;
+    const target = writeTarget(input.tool_input);
+    if (!target)
+      return pass;
+    const absolute = path5.resolve(this.cwd, target);
+    if (roots.some((root) => contains(root, absolute)))
+      return pass;
+    return {
+      continue: true,
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "ask",
+        // Каталог проекта в `roots` есть всегда, поэтому сюда попадает только
+        // то, что лежит вне его, — про проводник можно говорить без оговорок.
+        permissionDecisionReason: `\u0424\u0430\u0439\u043B \u0432\u043D\u0435 \u0440\u0430\u0437\u0440\u0435\u0448\u0451\u043D\u043D\u044B\u0445 \u043A\u0430\u0442\u0430\u043B\u043E\u0433\u043E\u0432 (${roots.join(", ")}): ${absolute}. \u0412 \u043F\u0440\u043E\u0432\u043E\u0434\u043D\u0438\u043A\u0435 \u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u044F \u043E\u043D \u0432\u0438\u0434\u0435\u043D \u043D\u0435 \u0431\u0443\u0434\u0435\u0442. \u0413\u0440\u0430\u043D\u0438\u0446\u0443 \u0437\u0430\u0434\u0430\u0451\u0442 \u043D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0430 \xAB\u0414\u043E\u0441\u0442\u0443\u043F \u043A \u043F\u0430\u043F\u043A\u0430\u043C\xBB.`
+      }
+    };
+  };
+  #canUseTool = (toolName, input, { signal, decisionReason }) => {
+    if (this.#options.readOnly) {
+      this.#record({
+        kind: "error",
+        message: `\u0411\u043E\u043A\u043E\u0432\u043E\u0439 \u0432\u043E\u043F\u0440\u043E\u0441 \u043D\u0435 \u0432\u044B\u043F\u043E\u043B\u043D\u044F\u0435\u0442 \u0434\u0435\u0439\u0441\u0442\u0432\u0438\u0439: ${toolName} \u043E\u0442\u043A\u043B\u043E\u043D\u0451\u043D`
+      });
+      return Promise.resolve({
+        behavior: "deny",
+        message: "\u0411\u043E\u043A\u043E\u0432\u0430\u044F \u0441\u0435\u0441\u0441\u0438\u044F \u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442 \u0442\u043E\u043B\u044C\u043A\u043E \u043D\u0430 \u0447\u0442\u0435\u043D\u0438\u0435"
+      });
+    }
+    const requestId = randomUUID();
+    return new Promise((resolve) => {
+      this.#pendingPermissions.set(requestId, { resolve, toolName, input });
+      this.#setState("waiting_permission");
+      this.#record({
+        kind: "permission.request",
+        requestId,
+        toolName,
+        input,
+        // Причину даёт не всякий запрос: обычный вопрос в режиме `default`
+        // объясняется самим режимом, а вот запрос, поднятый хуком поверх
+        // разрешающего режима, без неё выглядит сбоем.
+        ...decisionReason ? { reason: decisionReason } : {}
+      });
+      signal.addEventListener("abort", () => {
+        if (!this.#pendingPermissions.delete(requestId))
+          return;
+        resolve({ behavior: "deny", message: "\u041F\u0440\u0435\u0440\u0432\u0430\u043D\u043E" });
+      }, { once: true });
+    });
+  };
+  // -------------------------------------------------------------------------
+  // Поток сообщений из SDK -> события журнала
+  // -------------------------------------------------------------------------
+  async #consume(q) {
+    try {
+      for await (const message of q) {
+        this.#handleMessage(message);
+      }
+      this.#setState("closed");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.#record({ kind: "error", message: message + this.#executableHint() });
+      this.#setState("error");
+    }
+  }
+  /**
+   * Приписка про CLI, которым поднимали сессию.
+   *
+   * Надёжной проверки совместимости версий нет: у внешнего CLI и у SDK свои
+   * ряды версий, и сказать заранее, поймёт ли этот CLI то, что пошлёт этот SDK,
+   * нечем — их согласие проверяется только запуском. Поэтому мы не выдумываем
+   * проверку, а объясняем провал: если сессия умерла, не дойдя до `system/init`,
+   * рукопожатия с CLI не было вовсе, и первый подозреваемый — он.
+   *
+   * После init приписки нет: тогда CLI заведомо понят, а ошибка — про дело.
+   */
+  #executableHint() {
+    if (this.#capabilities || !this.#executable.path)
+      return "";
+    const whence = this.#executable.source === "env" ? "\u0443\u043A\u0430\u0437\u0430\u043D\u043D\u044B\u0439 \u0432 CCV_CLAUDE_PATH" : "\u043D\u0430\u0439\u0434\u0435\u043D\u043D\u044B\u0439 \u0432 \u0441\u0438\u0441\u0442\u0435\u043C\u0435";
+    return `
+
+\u0421\u0435\u0441\u0441\u0438\u044E \u043F\u043E\u0434\u043D\u0438\u043C\u0430\u043B Claude Code, ${whence}: ${this.#executable.path}. \u0415\u0441\u043B\u0438 \u0434\u0435\u043B\u043E \u0432 \u043D\u0451\u043C, CCV_CLAUDE_PATH \u0443\u043A\u0430\u0436\u0435\u0442 \u0434\u0440\u0443\u0433\u043E\u0439, \u0430 CCV_BUNDLED_CLAUDE=1 \u0432\u0435\u0440\u043D\u0451\u0442 ccv \u043D\u0430 \u0431\u0438\u043D\u0430\u0440\u043D\u0438\u043A \u0438\u0437 Agent SDK.`;
+  }
+  #handleMessage(message) {
+    switch (message.type) {
+      case "system":
+        this.#handleSystem(message);
+        break;
+      case "assistant":
+        for (const block of message.message.content) {
+          const blockId = `${message.message.id}:${this.#nextBlockIndex(message.message.id)}`;
+          if (block.type === "text") {
+            this.#record({ kind: "assistant.text", text: block.text, blockId });
+          } else if (block.type === "thinking") {
+            this.#record({
+              kind: "assistant.thinking",
+              text: block.thinking,
+              blockId
+            });
+          } else if (block.type === "tool_use") {
+            this.#record({
+              kind: "tool.use",
+              toolUseId: block.id,
+              name: block.name,
+              input: block.input
+            });
+          }
+        }
+        break;
+      case "user":
+        this.#handleToolResults(message);
+        break;
+      case "stream_event":
+        this.#handleStreamEvent(message);
+        break;
+      case "result": {
+        const usage = message.usage ? {
+          inputTokens: message.usage.input_tokens ?? 0,
+          outputTokens: message.usage.output_tokens ?? 0,
+          cacheReadTokens: message.usage.cache_read_input_tokens ?? 0,
+          cacheCreationTokens: message.usage.cache_creation_input_tokens ?? 0
+        } : null;
+        if (typeof message.total_cost_usd === "number") {
+          this.#totalCostUsd += message.total_cost_usd;
+        }
+        this.#record({
+          kind: "result",
+          subtype: message.subtype,
+          isError: message.is_error,
+          durationMs: message.duration_ms,
+          costUsd: message.total_cost_usd ?? null,
+          usage,
+          text: "result" in message ? message.result : null
+        });
+        if (this.#options.outputFormat) {
+          this.emit("structured", {
+            data: "structured_output" in message ? message.structured_output : void 0,
+            text: "result" in message ? message.result : null
+          });
+        }
+        this.#setState("idle");
+        if (this.#unpersistedTitle)
+          void this.#persistTitle();
+        void this.refreshUsage();
+        break;
+      }
+      // CLI сам сообщил, что лимит сдвинулся (обычно — подошёл к порогу).
+      // Проценты в этом сообщении относятся к одному окну, а в шапке их два,
+      // поэтому берём не их, а свежий снимок целиком.
+      case "rate_limit_event":
+        void this.refreshUsage(true);
+        break;
+      default:
+        break;
+    }
+  }
+  #handleSystem(message) {
+    if (message.subtype === "init") {
+      this.#model = message.model;
+      this.#permissionMode = message.permissionMode;
+      this.#claudeSessionId = message.session_id;
+      const catalog = this.#capabilities ?? this.#baseCapabilities();
+      this.#capabilities = {
+        ...catalog,
+        cwd: message.cwd,
+        model: message.model,
+        permissionMode: message.permissionMode,
+        slashCommands: message.slash_commands ?? [],
+        tools: message.tools ?? [],
+        agents: message.agents ?? [],
+        mcpServers: message.mcp_servers ?? [],
+        flags: message.capabilities ?? []
+      };
+      this.emit("capabilities", this.#capabilities);
+      this.emit("summary", this.summary());
+      if (catalog.commands.length === 0)
+        void this.#loadCatalog();
+      if (this.#unpersistedTitle)
+        void this.#persistTitle();
+      if (this.#state === "starting")
+        this.#setState("idle");
+      void this.refreshUsage(true);
+      return;
+    }
+    const { type: _type, subtype, ...rest } = message;
+    this.#record({ kind: "system", subtype, data: rest });
+  }
+  /**
+   * Слэш-команды и модели — то, из чего UI строит меню «/» и выбор модели.
+   *
+   * Это control-запрос к CLI, которого на старой версии может не быть вовсе:
+   * падение гасим молча. Без каталога UI останется без меню команд, но сессия
+   * работать не перестанет — ради подсказок ломать её нельзя.
+   */
+  async #loadCatalog() {
+    const q = this.#query;
+    if (!q)
+      return;
+    await this.#resolveDefaults();
+    const init = await q.initializationResult().catch(() => null);
+    if (!init)
+      return;
+    this.#capabilities = {
+      ...this.#capabilities ?? this.#baseCapabilities(),
+      commands: init.commands.map(toSlashCommand),
+      models: init.models.map((m) => ({
+        value: m.value,
+        resolvedModel: m.resolvedModel ?? null,
+        displayName: m.displayName,
+        description: m.description,
+        supportsEffort: m.supportsEffort === true,
+        effortLevels: m.supportedEffortLevels ?? [],
+        supportsThinking: m.supportsAdaptiveThinking === true,
+        supportsAutoMode: m.supportsAutoMode === true
+      }))
+    };
+    this.emit("capabilities", this.#capabilities);
+  }
+  /**
+   * Что выбрано в сессии — до того, как об этом скажет `system/init`.
+   *
+   * Спросить об этом SDK нельзя: списком моделей он делится, а тем, какая из
+   * них текущая, — нет; про усилие и размышления не говорит и `init`. Поэтому
+   * читаем те же settings.json, что и консоль ([`settings.ts`](./settings.ts)).
+   * Иначе дропдаун до первого хода показывал бы «ничего не выбрано» на сессии,
+   * которая уже работает на opus с высоким усилием.
+   *
+   * Ответ здесь — предположение о том, что прочитает CLI из тех же файлов, а
+   * не факт: `system/init` затем приходит с канонической моделью и заменяет
+   * его. Явно заданную при старте модель не трогаем — она сильнее файлов.
+   */
+  async #resolveDefaults() {
+    const configured = await readConfiguredDefaults(this.cwd).catch(() => null);
+    if (!configured)
+      return;
+    this.#effort = configured.effort;
+    this.#ultracode = configured.ultracode;
+    this.#thinking = configured.thinking;
+    this.#switchModelsOnFlag = configured.switchModelsOnFlag;
+    if (configured.model && !this.#model)
+      this.#model = configured.model;
+    this.emit("summary", this.summary());
+  }
+  #handleToolResults(message) {
+    const content = message.message.content;
+    if (typeof content === "string")
+      return;
+    for (const block of content) {
+      if (block.type !== "tool_result")
+        continue;
+      this.#record({
+        kind: "tool.result",
+        toolUseId: block.tool_use_id,
+        content: contentToText(block.content),
+        isError: block.is_error === true
+      });
+    }
+  }
+  /** Индекс очередного блока сообщения — в той же нумерации, что у дельт. */
+  #nextBlockIndex(messageId) {
+    const index = this.#blockCounts.get(messageId) ?? 0;
+    this.#blockCounts.set(messageId, index + 1);
+    if (this.#blockCounts.size > 64) {
+      const oldest = this.#blockCounts.keys().next().value;
+      if (oldest !== void 0 && oldest !== messageId) {
+        this.#blockCounts.delete(oldest);
+      }
+    }
+    return index;
+  }
+  #handleStreamEvent(message) {
+    const event = message.event;
+    if (event.type === "message_start") {
+      this.#streamMessageId = event.message.id;
+      return;
+    }
+    if (event.type !== "content_block_delta")
+      return;
+    if (!this.#streamMessageId)
+      return;
+    const delta = event.delta;
+    const blockId = `${this.#streamMessageId}:${event.index}`;
+    if (delta.type === "text_delta") {
+      this.#record({ kind: "assistant.delta", text: delta.text, blockId });
+    } else if (delta.type === "thinking_delta") {
+      this.#record({ kind: "thinking.delta", text: delta.thinking, blockId });
+    }
+  }
+  // -------------------------------------------------------------------------
+  #record(event) {
+    this.#updatedAt = Date.now();
+    const entry = this.journal.append(event);
+    this.emit("event", entry);
+  }
+  #setState(state) {
+    if (this.#state === state)
+      return;
+    this.#state = state;
+    this.#record({ kind: "state", state });
+    this.emit("summary", this.summary());
+  }
+};
+function describe(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function toSlashCommand(command) {
+  return {
+    name: command.name,
+    description: command.description,
+    argumentHint: command.argumentHint ?? "",
+    aliases: command.aliases ?? []
+  };
+}
+function toUsageState(raw) {
+  const limits = raw.rate_limits ?? {};
+  return {
+    available: raw.rate_limits_available === true,
+    plan: raw.subscription_type ?? "",
+    fiveHour: toUsageWindow(limits.five_hour),
+    sevenDay: toUsageWindow(limits.seven_day),
+    sevenDayOpus: toUsageWindow(limits.seven_day_opus),
+    fetchedAt: Date.now()
+  };
+}
+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 contentToText(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/git.js
+import { execFile as execFile2 } from "node:child_process";
+var TIMEOUT_MS = 2e4;
+var MAX_BUFFER = 32 * 1024 * 1024;
+var LOG_LIMIT = 150;
+var UNPUSHED_LIMIT = 2e3;
+var MAX_PATCH = 4e5;
+var MAX_FILE_PATCH = 8e4;
+var UNIT = "";
+var RECORD = "";
+var SAFE_REF = /^[A-Za-z0-9][A-Za-z0-9._/@^~-]*$/;
+var GitRepo = class {
+  cwd;
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  /**
+   * Снимок репозитория целиком: статус, ветки и лента коммитов.
+   *
+   * Собирается одним проходом, потому что панель показывает это вместе.
+   * Отдельные части опрашиваются терпимо к ошибкам: в репозитории без единого
+   * коммита `rev-parse HEAD` падает, и это не повод не показать вообще ничего.
+   */
+  async state() {
+    const blank = {
+      available: false,
+      message: "",
+      branch: "",
+      head: "",
+      detached: false,
+      upstream: "",
+      hasRemote: false,
+      ahead: 0,
+      behind: 0,
+      changed: [],
+      commits: [],
+      branches: []
+    };
+    try {
+      await this.#run(["rev-parse", "--is-inside-work-tree"]);
+    } catch (error) {
+      return { ...blank, message: describe2(error) };
+    }
+    const branchRaw = await this.#soft(["rev-parse", "--abbrev-ref", "HEAD"]);
+    const detached = branchRaw === "HEAD" || branchRaw === "";
+    const upstream = await this.#soft([
+      "rev-parse",
+      "--abbrev-ref",
+      "--symbolic-full-name",
+      "@{upstream}"
+    ]);
+    const counts = upstream ? await this.#soft(["rev-list", "--left-right", "--count", `${upstream}...HEAD`]) : "";
+    const [behind = "0", ahead = "0"] = counts.split(/\s+/);
+    const hasRemote = await this.#soft(["remote"]) !== "";
+    return {
+      available: true,
+      message: "",
+      branch: detached ? "" : branchRaw,
+      head: await this.#soft(["rev-parse", "HEAD"]),
+      detached,
+      upstream,
+      hasRemote,
+      ahead: Number(ahead) || 0,
+      behind: Number(behind) || 0,
+      changed: parseStatus(await this.#soft(["status", "--porcelain=v1"])),
+      commits: parseLog(await this.#soft([
+        "log",
+        "--all",
+        "--topo-order",
+        `--max-count=${LOG_LIMIT}`,
+        `--format=%H${UNIT}%P${UNIT}%an${UNIT}%aI${UNIT}%D${UNIT}%s${RECORD}`
+      ]), hasRemote ? await this.#unpushed() : /* @__PURE__ */ new Set()),
+      branches: parseBranches(await this.#soft(["branch", "--format=%(objectname):%(refname:short)"]), detached ? "" : branchRaw)
+    };
+  }
+  /**
+   * Хеши коммитов, которых нет ни в одной удалённой ветке.
+   *
+   * Спрашиваем «чего нет на remote», а не «что на нём есть»: неотправленного
+   * почти всегда горстка, а отправленного — вся история, и второй список был
+   * бы во столько же раз длиннее. `--all --not --remotes` — ровно эта разница:
+   * всё, что видно локально, минус всё, что достижимо из `refs/remotes`.
+   *
+   * Достижимость, а не совпадение с вершиной ветки: коммит в глубине уже
+   * отправленной истории отправлен так же, как её последний коммит.
+   */
+  async #unpushed() {
+    const raw = await this.#soft([
+      "rev-list",
+      "--all",
+      "--not",
+      "--remotes",
+      `--max-count=${UNPUSHED_LIMIT}`
+    ]);
+    return new Set(raw.split("\n").filter(Boolean));
+  }
+  /**
+   * Коммит целиком: заголовок, сообщение и патчи файлов.
+   *
+   * Пустой `ref` — незакоммиченные изменения рабочего дерева. Это тот же
+   * запрос по смыслу («покажи, что здесь поменялось»), и разводить его в
+   * отдельный кадр протокола значило бы дублировать разбор патча.
+   */
+  async show(ref) {
+    if (ref === "")
+      return this.#worktree();
+    const hash = requireRef(ref);
+    const raw = await this.#run([
+      "show",
+      "--no-color",
+      "--no-patch",
+      `--format=%H${UNIT}%h${UNIT}%P${UNIT}%an${UNIT}%ae${UNIT}%aI${UNIT}%s${UNIT}%b`,
+      hash
+    ]);
+    const parts = raw.split(UNIT);
+    const patch = await this.#run([
+      "show",
+      "--no-color",
+      "--patch",
+      "--find-renames",
+      "--format=",
+      hash
+    ]);
+    const { files, truncated } = parsePatch(patch);
+    return {
+      hash: parts[0] ?? hash,
+      shortHash: parts[1] ?? hash.slice(0, 8),
+      parents: (parts[2] ?? "").split(" ").filter(Boolean),
+      author: parts[3] ?? "",
+      email: parts[4] ?? "",
+      date: parts[5] ?? "",
+      subject: parts[6] ?? "",
+      body: parts.slice(7).join(UNIT).trim(),
+      files,
+      truncated
+    };
+  }
+  /**
+   * Незакоммиченные изменения.
+   *
+   * `git diff HEAD` показывает и индекс, и рабочее дерево, но не знает про
+   * файлы, которых в репозитории ещё нет вовсе. Их дописываем из статуса
+   * отдельными строками без содержимого: показать «новый файл» честнее, чем
+   * промолчать о нём.
+   */
+  async #worktree() {
+    const patch = await this.#soft(["diff", "HEAD", "--no-color", "--find-renames"]);
+    const { files, truncated } = parsePatch(patch);
+    const untracked = parseStatus(await this.#soft(["status", "--porcelain=v1"])).filter((change) => change.status === "??").map((change) => ({
+      path: change.path,
+      oldPath: "",
+      status: "added",
+      added: 0,
+      removed: 0,
+      binary: false,
+      patch: ""
+    }));
+    return {
+      hash: "",
+      shortHash: "",
+      parents: [],
+      author: "",
+      email: "",
+      date: (/* @__PURE__ */ new Date()).toISOString(),
+      subject: "\u041D\u0435\u0437\u0430\u043A\u043E\u043C\u043C\u0438\u0447\u0435\u043D\u043D\u044B\u0435 \u0438\u0437\u043C\u0435\u043D\u0435\u043D\u0438\u044F",
+      body: "",
+      files: [...files, ...untracked],
+      truncated
+    };
+  }
+  /**
+   * Какие из путей игнорируются по `.gitignore` — одним вызовом на весь список.
+   *
+   * Спрашиваем сам git, а не разбираем `.gitignore` руками: правил там больше,
+   * чем кажется (вложенные файлы в каждом каталоге, `.git/info/exclude`,
+   * глобальный `core.excludesFile`, отрицания `!`), и своя реализация врала бы
+   * ровно в тех случаях, ради которых на неё и смотрят.
+   *
+   * Пути уходят через stdin, а не аргументами: каталог с тысячей записей не
+   * влез бы в командную строку Windows. Отслеживаемый файл под правилом
+   * игнорирования git ответом не назовёт — индекс он учитывает сам.
+   *
+   * Провал здесь — обычное дело (каталог не репозиторий, git не установлен), и
+   * значит он ровно «ничего не игнорируется»: дерево файлов работает и без git.
+   */
+  async checkIgnored(paths) {
+    if (paths.length === 0)
+      return /* @__PURE__ */ new Set();
+    const raw = await this.#run(
+      ["check-ignore", "--stdin", "-z"],
+      // `-z` переводит на NUL и вход тоже — иначе путь с переводом строки в
+      // имени разъехался бы на две записи.
+      paths.join("\0")
+    ).catch(() => "");
+    return new Set(raw.split("\0").filter(Boolean));
+  }
+  /**
+   * Завести репозиторий в каталоге — шаг создания нового проекта.
+   *
+   * Имя начальной ветки не задаём: его выбирает `init.defaultBranch` из
+   * настроек пользователя, и навязывать здесь своё значило бы разойтись с тем,
+   * что тот же человек получает от `git init` в терминале.
+   */
+  async init() {
+    return await this.#run(["init"]);
+  }
+  /** Переключиться на ветку или коммит. Возвращает то, что сказал сам git. */
+  async checkout(target) {
+    const out = await this.#run(["checkout", requireRef(target), "--"]);
+    return out || `\u041F\u0435\u0440\u0435\u043A\u043B\u044E\u0447\u0435\u043D\u043E \u043D\u0430 ${target}`;
+  }
+  /** Команда, чей провал — обычное дело (нет upstream, нет коммитов, detached). */
+  async #soft(args) {
+    return this.#run(args).catch(() => "");
+  }
+  /** `input` — то, что команда читает со stdin; без него stdin сразу закрывается. */
+  #run(args, input) {
+    return new Promise((resolve, reject) => {
+      const child = execFile2(
+        "git",
+        // core.quotepath=false — иначе кириллические пути приезжают в виде
+        // «\320\277\321\200…» и в панели читаются как мусор.
+        ["-c", "core.quotepath=false", ...args],
+        {
+          cwd: this.cwd,
+          timeout: TIMEOUT_MS,
+          maxBuffer: MAX_BUFFER,
+          windowsHide: true,
+          encoding: "utf8"
+        },
+        (error, stdout, stderr) => {
+          if (!error)
+            return resolve(stdout.trimEnd());
+          if (error.code === "ENOENT") {
+            return reject(new Error(`\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0437\u0430\u043F\u0443\u0441\u0442\u0438\u0442\u044C git \u0432 ${this.cwd} \u2014 \u043D\u0435\u0442 git \u0432 PATH \u0438\u043B\u0438 \u043A\u0430\u0442\u0430\u043B\u043E\u0433\u0430`));
+          }
+          const detail = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
+          reject(new Error(detail || error.message));
+        }
+      );
+      child.stdin?.on("error", () => {
+      });
+      child.stdin?.end(input ?? "");
+    });
+  }
+};
+function requireRef(value) {
+  const trimmed = value.trim();
+  if (!SAFE_REF.test(trimmed) || trimmed.includes("..")) {
+    throw new Error(`\u041D\u0435\u0434\u043E\u043F\u0443\u0441\u0442\u0438\u043C\u0430\u044F \u0441\u0441\u044B\u043B\u043A\u0430 git: \xAB${value}\xBB`);
+  }
+  return trimmed;
+}
+function describe2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function parseStatus(raw) {
+  const out = [];
+  for (const line of raw.split("\n")) {
+    if (line.length < 4)
+      continue;
+    const status = line.slice(0, 2);
+    const rest = line.slice(3);
+    const arrow = rest.indexOf(" -> ");
+    out.push({
+      status,
+      staged: status[0] !== " " && status[0] !== "?",
+      path: arrow === -1 ? unquote(rest) : unquote(rest.slice(arrow + 4)),
+      oldPath: arrow === -1 ? "" : unquote(rest.slice(0, arrow))
+    });
+  }
+  return out;
+}
+function unquote(value) {
+  if (!value.startsWith('"') || !value.endsWith('"'))
+    return value;
+  return value.slice(1, -1).replace(/\\(.)/g, "$1");
+}
+function parseLog(raw, unpushed) {
+  const out = [];
+  for (const record of raw.split(RECORD)) {
+    const line = record.replace(/^\n/, "");
+    if (line.trim() === "")
+      continue;
+    const [hash = "", parents = "", author = "", date = "", refs = "", subject = ""] = line.split(UNIT);
+    out.push({
+      hash,
+      shortHash: hash.slice(0, 8),
+      parents: parents.split(" ").filter(Boolean),
+      author,
+      date,
+      subject,
+      refs: refs.split(", ").map((ref) => ref.trim()).filter(Boolean),
+      // Пустое множество приходит и от репозитория без remote — там pushed
+      // читать нельзя, и UI его не читает.
+      pushed: !unpushed.has(hash)
+    });
+  }
+  return out;
+}
+function parseBranches(raw, current) {
+  const out = [];
+  for (const line of raw.split("\n")) {
+    const at = line.indexOf(":");
+    if (at === -1)
+      continue;
+    const name = line.slice(at + 1).trim();
+    if (!name)
+      continue;
+    out.push({ name, hash: line.slice(0, at).trim(), current: name === current });
+  }
+  return out;
+}
+function parsePatch(raw) {
+  const files = [];
+  let truncated = false;
+  let total = 0;
+  for (const chunk of raw.split(/^diff --git /m).slice(1)) {
+    const lines = chunk.split("\n");
+    let oldPath = "";
+    let newPath = "";
+    let status = "modified";
+    let binary = false;
+    let bodyStart = -1;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i] ?? "";
+      if (line.startsWith("@@")) {
+        bodyStart = i;
+        break;
+      }
+      if (line.startsWith("--- "))
+        oldPath = stripPrefix(line.slice(4));
+      else if (line.startsWith("+++ "))
+        newPath = stripPrefix(line.slice(4));
+      else if (line.startsWith("new file mode"))
+        status = "added";
+      else if (line.startsWith("deleted file mode"))
+        status = "deleted";
+      else if (line.startsWith("rename from ")) {
+        status = "renamed";
+        oldPath = line.slice(12).trim();
+      } else if (line.startsWith("rename to "))
+        newPath = line.slice(10).trim();
+      else if (line.startsWith("Binary files") || line.startsWith("GIT binary patch")) {
+        binary = true;
+      }
+    }
+    if (!newPath && !oldPath) {
+      const header = lines[0] ?? "";
+      const half = Math.floor(header.length / 2);
+      newPath = stripPrefix(header.slice(half).trim());
+      oldPath = newPath;
+    }
+    let body = bodyStart === -1 ? "" : lines.slice(bodyStart).join("\n").trimEnd();
+    if (body.length > MAX_FILE_PATCH) {
+      body = body.slice(0, MAX_FILE_PATCH);
+      truncated = true;
+    }
+    if (total + body.length > MAX_PATCH) {
+      truncated = true;
+      body = "";
+    }
+    total += body.length;
+    const path15 = status === "deleted" ? oldPath : newPath || oldPath;
+    files.push({
+      path: path15,
+      oldPath: status === "renamed" ? oldPath : "",
+      status,
+      added: count(body, "+"),
+      removed: count(body, "-"),
+      binary,
+      patch: binary ? "" : body
+    });
+  }
+  return { files, truncated };
+}
+function stripPrefix(value) {
+  const path15 = unquote(value.trim());
+  if (path15 === "/dev/null")
+    return "";
+  return path15.replace(/^[ab]\//, "");
+}
+function count(body, mark) {
+  let n = 0;
+  for (const line of body.split("\n")) {
+    if (line.startsWith(mark))
+      n++;
+  }
+  return n;
+}
+
+// ../host/dist/finder.js
+import { existsSync, statSync } from "node:fs";
+import { readdir as readdir2 } from "node:fs/promises";
+import os2 from "node:os";
+import path6 from "node:path";
+import { listSessions } from "@anthropic-ai/claude-agent-sdk";
+var CACHE_TTL = 6e4;
+var FIND_LIMIT = 50;
+var ROOT_LIMIT = 5;
+var SKIP_NAMES = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "venv"]);
+var ProjectFinder = class {
+  registry;
+  #dirs = [];
+  #loadedAt = 0;
+  /** Обновление уже идёт: второй `listSessions()` параллельно первому не нужен. */
+  #refreshing = null;
+  constructor(registry) {
+    this.registry = registry;
+  }
+  /**
+   * Прогреть кэш при старте хоста.
+   *
+   * Иначе первый же поиск пришёлся бы на непрогретый кэш и ответил пустотой,
+   * пока журнал читается, — ровно в тот момент, когда пользователь открыл
+   * диалог и ждёт подсказку.
+   */
+  async warm() {
+    await this.#refresh();
+  }
+  /**
+   * Каталоги, подходящие под запрос.
+   *
+   * Работает синхронно по памяти; устаревший кэш обновляется в фоне и попадёт
+   * в следующий ответ. Ждать его здесь нельзя: это две секунды на нажатие
+   * клавиши.
+   */
+  find(query2) {
+    if (Date.now() - this.#loadedAt > CACHE_TTL)
+      void this.#refresh();
+    const needles = tokens(query2);
+    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(path6.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());
+      const bOpen = open.has(b.path.toLowerCase());
+      if (aOpen !== bOpen)
+        return aOpen ? -1 : 1;
+      if (a.sessions > 0 !== b.sessions > 0)
+        return a.sessions > 0 ? -1 : 1;
+      if (a.lastUsedAt !== b.lastUsedAt)
+        return b.lastUsedAt - a.lastUsedAt;
+      return path6.basename(a.path).localeCompare(path6.basename(b.path), void 0, {
+        numeric: true,
+        sensitivity: "base"
+      });
+    });
+    return {
+      candidates: sorted.slice(0, FIND_LIMIT).map((dir) => ({
+        path: dir.path,
+        name: path6.basename(dir.path) || dir.path,
+        sessions: dir.sessions,
+        lastUsedAt: dir.lastUsedAt || null,
+        open: open.has(dir.path.toLowerCase()),
+        why: null
+      })),
+      truncated: sorted.length > FIND_LIMIT
+    };
+  }
+  /**
+   * Превратить названные агентом пути в кандидатов.
+   *
+   * Проверяем каждый: модель может назвать каталог, которого нет, — открывать
+   * его вслепую нельзя. Заодно дополняем тем, что знает журнал: сколько там
+   * сессий и когда работали в последний раз. Агент этого не видит, а в списке
+   * это самое полезное.
+   */
+  validate(named) {
+    const known = new Map(this.#dirs.map((dir) => [dir.path.toLowerCase(), dir]));
+    const open = new Map(this.registry.list().map((workspace) => [workspace.path.toLowerCase(), workspace]));
+    const seen = /* @__PURE__ */ new Set();
+    const candidates = [];
+    for (const entry of named) {
+      const absolute = entry.path.trim();
+      if (!absolute || !path6.isAbsolute(absolute))
+        continue;
+      const key = absolute.toLowerCase();
+      if (seen.has(key))
+        continue;
+      if (!isDirectory(absolute))
+        continue;
+      seen.add(key);
+      const record = known.get(key);
+      candidates.push({
+        path: record?.path ?? absolute,
+        name: path6.basename(absolute) || absolute,
+        sessions: record?.sessions ?? 0,
+        lastUsedAt: record?.lastUsedAt || null,
+        open: open.has(key),
+        why: entry.why
+      });
+      if (candidates.length >= FIND_LIMIT)
+        break;
+    }
+    return candidates;
+  }
+  /**
+   * Где искать агенту: родительские каталоги известных проектов.
+   *
+   * Первым идёт тот, под которым известных каталогов больше всего, — он же
+   * станет `cwd` сессии поиска. Остальные достаются агенту списком в промпте:
+   * `Glob` и `Grep` принимают абсолютный путь, так что одним `cwd` он не заперт.
+   */
+  roots() {
+    return this.#parents(this.#dirs).slice(0, ROOT_LIMIT);
+  }
+  #refresh() {
+    return this.#refreshing ??= this.#load().finally(() => {
+      this.#refreshing = null;
+    });
+  }
+  async #load() {
+    const dirs = /* @__PURE__ */ new Map();
+    for (const workspace of this.registry.list()) {
+      dirs.set(workspace.path.toLowerCase(), {
+        path: workspace.path,
+        sessions: 0,
+        lastUsedAt: 0
+      });
+    }
+    for (const info of await allSessions()) {
+      const cwd = info.cwd;
+      if (!cwd || !usable(cwd))
+        continue;
+      const key = cwd.toLowerCase();
+      const seen = dirs.get(key);
+      if (seen) {
+        seen.sessions += 1;
+        if (info.lastModified > seen.lastUsedAt) {
+          seen.lastUsedAt = info.lastModified;
+          seen.path = cwd;
+        }
+        continue;
+      }
+      dirs.set(key, { path: cwd, sessions: 1, lastUsedAt: info.lastModified });
+    }
+    for (const parent of this.#parents(dirs.values())) {
+      const names2 = await readdir2(parent, { withFileTypes: true }).catch(() => []);
+      for (const dirent of names2) {
+        if (!dirent.isDirectory() || SKIP_NAMES.has(dirent.name) || dirent.name.startsWith(".")) {
+          continue;
+        }
+        const full = path6.join(parent, dirent.name);
+        const key = full.toLowerCase();
+        if (dirs.has(key))
+          continue;
+        dirs.set(key, { path: full, sessions: 0, lastUsedAt: 0 });
+      }
+    }
+    this.#dirs = [...dirs.values()];
+    this.#loadedAt = Date.now();
+  }
+  /**
+   * Каталоги, в которых проекты действительно лежат.
+   *
+   * «Родитель известного каталога» само по себе не признак: у `C:\Users\corfi`
+   * родитель `C:\Users`, а у проекта в корне диска — `C:\`. Признаком считаем
+   * то, что в каталоге известных проектов больше одного: тогда это рабочая
+   * папка, а не случайное место на пути.
+   */
+  #parents(dirs) {
+    const counted = /* @__PURE__ */ new Map();
+    for (const dir of dirs) {
+      const parent = path6.dirname(dir.path);
+      if (parent === dir.path || !usable(parent))
+        continue;
+      const key = parent.toLowerCase();
+      const seen = counted.get(key);
+      if (seen)
+        seen.count += 1;
+      else
+        counted.set(key, { path: parent, count: 1 });
+    }
+    return [...counted.values()].filter((entry) => entry.count >= 2).sort((a, b) => b.count - a.count).map((entry) => entry.path);
+  }
+};
+function usable(dir) {
+  return !contains(os2.tmpdir(), dir) && existsSync(dir);
+}
+function tokens(query2) {
+  return query2.toLowerCase().split(/[^a-z0-9а-яё]+/i).filter(Boolean);
+}
+function matches(value, needles) {
+  const flat = value.toLowerCase().replace(/[^a-z0-9а-яё]+/gi, "");
+  return needles.every((needle) => flat.includes(needle));
+}
+function isDirectory(dir) {
+  try {
+    return statSync(dir).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function allSessions() {
+  try {
+    return await listSessions();
+  } catch {
+    return [];
+  }
+}
+var FINDER_SCHEMA = {
+  type: "object",
+  properties: {
+    candidates: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "\u0410\u0431\u0441\u043E\u043B\u044E\u0442\u043D\u044B\u0439 \u043F\u0443\u0442\u044C \u043A \u043A\u0430\u0442\u0430\u043B\u043E\u0433\u0443 \u043F\u0440\u043E\u0435\u043A\u0442\u0430" },
+          why: { type: "string", description: "\u041E\u0434\u043D\u0430 \u043A\u043E\u0440\u043E\u0442\u043A\u0430\u044F \u0444\u0440\u0430\u0437\u0430, \u043F\u043E\u0447\u0435\u043C\u0443 \u044D\u0442\u043E\u0442 \u043F\u0440\u043E\u0435\u043A\u0442 \u043F\u043E\u0434\u0445\u043E\u0434\u0438\u0442" }
+        },
+        required: ["path", "why"],
+        additionalProperties: false
+      }
+    }
+  },
+  required: ["candidates"],
+  additionalProperties: false
+};
+var AGENT_LIMIT = 5;
+function finderPrompt(query2, roots) {
+  return [
+    "\u041D\u0430\u0439\u0434\u0438 \u043A\u0430\u0442\u0430\u043B\u043E\u0433 \u043F\u0440\u043E\u0435\u043A\u0442\u0430 \u043D\u0430 \u044D\u0442\u043E\u043C \u043A\u043E\u043C\u043F\u044C\u044E\u0442\u0435\u0440\u0435 \u043F\u043E \u043E\u043F\u0438\u0441\u0430\u043D\u0438\u044E \u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044F.",
+    "",
+    `\u041E\u043F\u0438\u0441\u0430\u043D\u0438\u0435: ${query2}`,
+    "",
+    "\u0418\u0441\u043A\u0430\u0442\u044C \u0442\u043E\u043B\u044C\u043A\u043E \u0432\u043D\u0443\u0442\u0440\u0438 \u044D\u0442\u0438\u0445 \u043A\u0430\u0442\u0430\u043B\u043E\u0433\u043E\u0432:",
+    ...roots.map((root) => `- ${root}`),
+    "",
+    "\u041F\u0440\u043E\u0435\u043A\u0442 \u2014 \u044D\u0442\u043E \u043A\u0430\u0442\u0430\u043B\u043E\u0433 \u0441 \u0438\u0441\u0445\u043E\u0434\u043D\u0438\u043A\u0430\u043C\u0438 (package.json, .git, pyproject.toml,",
+    "Cargo.toml, *.csproj \u0438 \u043F\u043E\u0434\u043E\u0431\u043D\u043E\u0435), \u0430 \u043D\u0435 \u043E\u0442\u0434\u0435\u043B\u044C\u043D\u044B\u0439 \u0444\u0430\u0439\u043B \u0438 \u043D\u0435 \u043F\u043E\u0434\u043A\u0430\u0442\u0430\u043B\u043E\u0433",
+    "\u0432\u043D\u0443\u0442\u0440\u0438 \u043F\u0440\u043E\u0435\u043A\u0442\u0430. \u041D\u0435 \u0437\u0430\u0445\u043E\u0434\u0438 \u0432 node_modules, dist, build \u0438 .git.",
+    "\u0418\u043C\u044F \u043A\u0430\u0442\u0430\u043B\u043E\u0433\u0430, README \u0438 package.json \u043E\u0431\u044B\u0447\u043D\u043E \u043E\u0442\u0432\u0435\u0447\u0430\u044E\u0442 \u043D\u0430 \u0432\u043E\u043F\u0440\u043E\u0441 \u0431\u044B\u0441\u0442\u0440\u0435\u0435",
+    "\u0432\u0441\u0435\u0433\u043E \u2014 \u043D\u0430\u0447\u0438\u043D\u0430\u0439 \u0441 \u043D\u0438\u0445, \u0430 \u043D\u0435 \u0441 \u043E\u0431\u0445\u043E\u0434\u0430 \u0432\u0441\u0435\u0433\u043E \u0434\u0435\u0440\u0435\u0432\u0430.",
+    "",
+    `\u0412\u0435\u0440\u043D\u0438 \u043D\u0435 \u0431\u043E\u043B\u044C\u0448\u0435 ${AGENT_LIMIT} \u043A\u0430\u043D\u0434\u0438\u0434\u0430\u0442\u043E\u0432, \u0441\u0430\u043C\u044B\u0439 \u043F\u043E\u0434\u0445\u043E\u0434\u044F\u0449\u0438\u0439 \u043F\u0435\u0440\u0432\u044B\u043C.`,
+    "\u0415\u0441\u043B\u0438 \u043D\u0438\u0447\u0435\u0433\u043E \u043D\u0435 \u043F\u043E\u0434\u043E\u0448\u043B\u043E, \u0432\u0435\u0440\u043D\u0438 \u043F\u0443\u0441\u0442\u043E\u0439 \u0441\u043F\u0438\u0441\u043E\u043A \u2014 \u044D\u0442\u043E \u043D\u043E\u0440\u043C\u0430\u043B\u044C\u043D\u044B\u0439 \u043E\u0442\u0432\u0435\u0442."
+  ].join("\n");
+}
+function readNamedPaths(data, text) {
+  const structured = fromSchema(data);
+  if (structured.length > 0)
+    return structured;
+  return fromText(text);
+}
+function fromSchema(data) {
+  if (typeof data !== "object" || data === null)
+    return [];
+  const list = data.candidates;
+  if (!Array.isArray(list))
+    return [];
+  const named = [];
+  for (const item of list) {
+    if (typeof item !== "object" || item === null)
+      continue;
+    const { path: value, why } = item;
+    if (typeof value !== "string")
+      continue;
+    named.push({ path: value, why: typeof why === "string" ? why : null });
+  }
+  return named;
+}
+function fromText(text) {
+  if (!text)
+    return [];
+  const matches2 = text.match(/(?:[A-Za-z]:[\\/]|\/)[^\s`'"*)>\]]+/g) ?? [];
+  return matches2.map((value) => ({
+    // Точка или скобка в конце — это пунктуация фразы, а не имя каталога.
+    path: value.replace(/[.,;:]+$/, ""),
+    why: null
+  }));
+}
+
+// ../host/dist/workspaces.js
+import { existsSync as existsSync2, statSync as statSync2 } from "node:fs";
+import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
+import path7 from "node:path";
+import { listSessions as listSessions2 } from "@anthropic-ai/claude-agent-sdk";
+var WorkspaceRegistry = class {
+  #paths = [];
+  #storePath;
+  constructor(dataDir) {
+    this.#storePath = path7.join(dataDir, "workspaces.json");
+  }
+  async load() {
+    try {
+      const raw = await readFile4(this.#storePath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) {
+        this.#paths = parsed.filter((p) => typeof p === "string" && existsSync2(p));
+      }
+    } catch {
+      this.#paths = [];
+    }
+  }
+  async #persist() {
+    await mkdir2(path7.dirname(this.#storePath), { recursive: true });
+    await writeFile2(this.#storePath, JSON.stringify(this.#paths, null, 2), "utf8");
+  }
+  list() {
+    return this.#paths.map(toInfo);
+  }
+  find(id) {
+    return this.list().find((w) => w.id === id);
+  }
+  async open(rawPath) {
+    const absolute = path7.resolve(rawPath);
+    if (!existsSync2(absolute)) {
+      throw new Error(`\u041A\u0430\u0442\u0430\u043B\u043E\u0433 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D: ${absolute}`);
+    }
+    if (!this.#paths.includes(absolute)) {
+      this.#paths.unshift(absolute);
+      await this.#persist();
+    }
+    return toInfo(absolute);
+  }
+  /**
+   * Убрать проекты из списка открытых.
+   *
+   * Только реестр: каталог, его файлы и транскрипты сессий остаются на месте —
+   * закрытый проект открывается обратно тем же путём и с той же историей.
+   * Пачкой, а не по одному, потому что список чистят разом и переписывать файл
+   * на каждый проект незачем.
+   */
+  async close(ids) {
+    const doomed = new Set(ids);
+    const closed = this.list().filter((w) => doomed.has(w.id));
+    if (closed.length === 0)
+      return [];
+    const gone = new Set(closed.map((w) => w.path));
+    this.#paths = this.#paths.filter((p) => !gone.has(p));
+    await this.#persist();
+    return closed;
+  }
+  /**
+   * Создать каталог проекта и открыть его.
+   *
+   * Единственное место в хосте, которое делает каталог, а не читает его. Порядок
+   * шагов задан тем, что можно откатить: сам каталог обязателен — без него
+   * проекта нет, и любая ошибка здесь отменяет всю операцию целиком. Заготовки
+   * файлов и `git init` — уже нет: провал `git init` (нет git в PATH — обычное
+   * дело, см. [`git.ts`](./git.ts)) не повод стирать только что созданный
+   * каталог, поэтому такой шаг возвращается предупреждением, а проект всё равно
+   * открывается.
+   */
+  async create(parentRaw, nameRaw, init) {
+    const name = nameRaw.trim();
+    requireName(name);
+    const parent = path7.resolve(parentRaw.trim());
+    if (!existsSync2(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 = path7.join(parent, name);
+    if (existsSync2(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 mkdir2(target);
+    const warnings = [];
+    if (init.claudeMd) {
+      await step(warnings, "CLAUDE.md", () => writeFile2(path7.join(target, "CLAUDE.md"), claudeMdStub(name), "utf8"));
+    }
+    if (init.readme) {
+      await step(warnings, "README.md", () => writeFile2(path7.join(target, "README.md"), readmeStub(name), "utf8"));
+    }
+    if (init.git) {
+      await step(warnings, "git init", () => new GitRepo(target).init());
+    }
+    return { workspace: await this.open(target), warnings };
+  }
+  /** Сессии Claude Code, уже лежащие на диске для этого каталога. */
+  async sessionsOnDisk(workspaceId) {
+    const workspace = this.find(workspaceId);
+    if (!workspace)
+      return [];
+    try {
+      return await listSessions2({ dir: workspace.path });
+    } catch {
+      return [];
+    }
+  }
+};
+var RESERVED = /^(con|prn|aux|nul|com[0-9]|lpt[0-9])(\.|$)/i;
+var FORBIDDEN = /[\\/:*?"<>|]/;
+function requireName(name) {
+  if (name === "") {
+    throw new Error("\u0418\u043C\u044F \u043F\u0440\u043E\u0435\u043A\u0442\u0430 \u043D\u0435 \u043C\u043E\u0436\u0435\u0442 \u0431\u044B\u0442\u044C \u043F\u0443\u0441\u0442\u044B\u043C");
+  }
+  if (FORBIDDEN.test(name)) {
+    throw new Error('\u0412 \u0438\u043C\u0435\u043D\u0438 \u043D\u0435\u043B\u044C\u0437\u044F \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u044C \\ / : * ? " < > |');
+  }
+  if (name === "." || name === "..") {
+    throw new Error(`\xAB${name}\xBB \u2014 \u044D\u0442\u043E \u043D\u0435 \u0438\u043C\u044F \u043A\u0430\u0442\u0430\u043B\u043E\u0433\u0430, \u0430 \u0441\u0441\u044B\u043B\u043A\u0430 \u043D\u0430 \u0434\u0440\u0443\u0433\u043E\u0439`);
+  }
+  if (name.startsWith(".")) {
+    throw new Error("\u0418\u043C\u044F \u043D\u0435 \u0434\u043E\u043B\u0436\u043D\u043E \u043D\u0430\u0447\u0438\u043D\u0430\u0442\u044C\u0441\u044F \u0441 \u0442\u043E\u0447\u043A\u0438 \u2014 \u0442\u0430\u043A\u043E\u0439 \u043A\u0430\u0442\u0430\u043B\u043E\u0433 \u0441\u043A\u0440\u044B\u0442");
+  }
+  if (/[. ]$/.test(name)) {
+    throw new Error("\u0418\u043C\u044F \u043D\u0435 \u0434\u043E\u043B\u0436\u043D\u043E \u0437\u0430\u043A\u0430\u043D\u0447\u0438\u0432\u0430\u0442\u044C\u0441\u044F \u0442\u043E\u0447\u043A\u043E\u0439 \u0438\u043B\u0438 \u043F\u0440\u043E\u0431\u0435\u043B\u043E\u043C");
+  }
+  if (RESERVED.test(name)) {
+    throw new Error(`\xAB${name}\xBB \u2014 \u0437\u0430\u0440\u0435\u0437\u0435\u0440\u0432\u0438\u0440\u043E\u0432\u0430\u043D\u043D\u043E\u0435 \u0438\u043C\u044F \u0443\u0441\u0442\u0440\u043E\u0439\u0441\u0442\u0432\u0430 Windows`);
+  }
+}
+async function step(warnings, what, run2) {
+  try {
+    await run2();
+  } catch (error) {
+    warnings.push(`${what}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function claudeMdStub(name) {
+  return [
+    `# ${name}`,
+    "",
+    "\u0418\u043D\u0441\u0442\u0440\u0443\u043A\u0446\u0438\u0438 \u0434\u043B\u044F Claude Code \u0432 \u044D\u0442\u043E\u043C \u043F\u0440\u043E\u0435\u043A\u0442\u0435.",
+    "",
+    "## \u041E \u043F\u0440\u043E\u0435\u043A\u0442\u0435",
+    "",
+    "<!-- \u0427\u0435\u043C \u0437\u0430\u043D\u044F\u0442 \u043F\u0440\u043E\u0435\u043A\u0442 \u0438 \u0447\u0442\u043E \u0432 \u043D\u0451\u043C \u0433\u043B\u0430\u0432\u043D\u043E\u0435. -->",
+    "",
+    "## \u041A\u0430\u043A \u0437\u0434\u0435\u0441\u044C \u0440\u0430\u0431\u043E\u0442\u0430\u0442\u044C",
+    "",
+    "<!-- \u041A\u043E\u043C\u0430\u043D\u0434\u044B \u0441\u0431\u043E\u0440\u043A\u0438 \u0438 \u0442\u0435\u0441\u0442\u043E\u0432, \u0441\u043E\u0433\u043B\u0430\u0448\u0435\u043D\u0438\u044F \u043A\u043E\u0434\u0430, \u0447\u0435\u0433\u043E \u0434\u0435\u043B\u0430\u0442\u044C \u043D\u0435 \u043D\u0430\u0434\u043E. -->",
+    ""
+  ].join("\n");
+}
+function readmeStub(name) {
+  return [`# ${name}`, "", "<!-- \u041E\u0434\u043D\u0430-\u0434\u0432\u0435 \u0444\u0440\u0430\u0437\u044B: \u0447\u0442\u043E \u044D\u0442\u043E \u0438 \u0437\u0430\u0447\u0435\u043C. -->", ""].join("\n");
+}
+function toInfo(absolute) {
+  return {
+    id: workspaceIdFromPath(absolute),
+    path: absolute,
+    name: path7.basename(absolute) || absolute,
+    hasClaudeMd: existsSync2(path7.join(absolute, "CLAUDE.md"))
+  };
+}
+
+// ../host/dist/archive.js
+import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
+import path8 from "node:path";
+var SessionArchive = class {
+  #archived = /* @__PURE__ */ new Map();
+  #restored = /* @__PURE__ */ new Map();
+  #storePath;
+  constructor(dataDir) {
+    this.#storePath = path8.join(dataDir, "session-archive.json");
+  }
+  async load() {
+    try {
+      const raw = await readFile5(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"));
+    } catch {
+      this.#archived = /* @__PURE__ */ new Map();
+      this.#restored = /* @__PURE__ */ new Map();
+    }
+  }
+  find(sessionId) {
+    return this.#archived.get(sessionId);
+  }
+  /** Убрать в архив. Возвращает `true`, если что-то изменилось. */
+  async archive(workspaceId, sessionIds, auto = false) {
+    let changed = false;
+    const at = Date.now();
+    for (const id of sessionIds) {
+      if (this.#archived.has(id))
+        continue;
+      this.#archived.set(id, { workspaceId, at, auto });
+      this.#restored.delete(id);
+      changed = true;
+    }
+    if (changed)
+      await this.#persist();
+    return changed;
+  }
+  /**
+   * Достать из архива.
+   *
+   * Заодно отмечает момент возврата: без него сессия, которая молчит дольше
+   * срока, уехала бы обратно в архив тем же списком, которым её только что
+   * вернули, — и достать её было бы нельзя вообще никак.
+   */
+  async unarchive(sessionIds) {
+    let changed = false;
+    const now = Date.now();
+    for (const id of sessionIds) {
+      if (!this.#archived.delete(id))
+        continue;
+      this.#restored.set(id, now);
+      changed = true;
+    }
+    if (changed)
+      await this.#persist();
+    return changed;
+  }
+  /**
+   * Отправить в архив всё, что молчит дольше срока, и забыть исчезнувшее.
+   *
+   * `candidates` — только те сессии, что сейчас не подняты: архивация живой
+   * сессии её останавливает, и делать это молча, по таймеру, за спиной у
+   * работающего агента нельзя. `known` — все сессии проекта, включая живые:
+   * по ним вычищаются записи о транскриптах, которых больше нет на диске.
+   *
+   * `afterMs` приходит из настроек приложения, а не задан здесь константой:
+   * срок молчания — вопрос того, как человек работает, и `0` («не архивировать
+   * никогда») тоже законный ответ. Чистка исчезнувших записей от него не
+   * зависит и идёт всегда: она не про архивацию, а про мусор в реестре.
+   */
+  async sweep(workspaceId, candidates, known, afterMs) {
+    const now = Date.now();
+    let changed = false;
+    for (const session of afterMs > 0 ? candidates : []) {
+      if (this.#archived.has(session.id))
+        continue;
+      const since = Math.max(session.updatedAt, this.#restored.get(session.id) ?? 0);
+      if (now - since < afterMs)
+        continue;
+      this.#archived.set(session.id, { workspaceId, at: now, auto: true });
+      this.#restored.delete(session.id);
+      changed = true;
+    }
+    for (const [id, record] of this.#archived) {
+      if (record.workspaceId !== workspaceId || known.has(id))
+        continue;
+      this.#archived.delete(id);
+      this.#restored.delete(id);
+      changed = true;
+    }
+    if (changed)
+      await this.#persist();
+    return changed;
+  }
+  async #persist() {
+    const file = {
+      archived: Object.fromEntries(this.#archived),
+      restored: Object.fromEntries(this.#restored)
+    };
+    await mkdir3(path8.dirname(this.#storePath), { recursive: true });
+    await writeFile3(this.#storePath, JSON.stringify(file, null, 2), "utf8");
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && typeof value.workspaceId === "string" && typeof value.at === "number";
+}
+
+// ../host/dist/app-settings.js
+import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import path9 from "node:path";
+var DEFAULT_AUTO_ARCHIVE_AFTER_MS = 2 * 24 * 60 * 60 * 1e3;
+var MIN_AUTO_ARCHIVE_AFTER_MS = 60 * 60 * 1e3;
+var FOLDER_ACCESS = ["all", "projects", "project"];
+var DEFAULT_APP_SETTINGS = {
+  autoArchiveAfterMs: DEFAULT_AUTO_ARCHIVE_AFTER_MS,
+  // Строгий режим по умолчанию: молча писать в чужой проект приложение начнёт
+  // только после того, как об этом попросили явно.
+  folderAccess: "project"
+};
+var AppSettingsStore = class {
+  #settings = { ...DEFAULT_APP_SETTINGS };
+  #storePath;
+  constructor(dataDir) {
+    this.#storePath = path9.join(dataDir, "app-settings.json");
+  }
+  async load() {
+    try {
+      const raw = await readFile6(this.#storePath, "utf8");
+      this.#settings = sanitize(JSON.parse(raw), DEFAULT_APP_SETTINGS);
+    } catch {
+      this.#settings = { ...DEFAULT_APP_SETTINGS };
+    }
+  }
+  get current() {
+    return { ...this.#settings };
+  }
+  /**
+   * Применить присланное окном.
+   *
+   * Частичным набором: клиент шлёт только то, что человек тронул, — иначе две
+   * открытые вкладки затирали бы правки друг друга полем, которого не касались.
+   * Непонятное значение не отвергается с ошибкой, а заменяется прежним: окно
+   * всё равно получит в ответ то, что реально записано, и покажет именно это.
+   */
+  async update(patch) {
+    const next = sanitize(patch, this.#settings);
+    this.#settings = next;
+    await mkdir4(path9.dirname(this.#storePath), { recursive: true });
+    await writeFile4(this.#storePath, JSON.stringify(next, null, 2), "utf8");
+    return this.current;
+  }
+};
+function sanitize(value, fallback) {
+  const result = { ...fallback };
+  if (typeof value !== "object" || value === null)
+    return result;
+  const record = value;
+  const after = record.autoArchiveAfterMs;
+  if (typeof after === "number" && Number.isFinite(after)) {
+    result.autoArchiveAfterMs = after <= 0 ? 0 : Math.max(Math.round(after), MIN_AUTO_ARCHIVE_AFTER_MS);
+  }
+  const access2 = record.folderAccess;
+  if (typeof access2 === "string" && FOLDER_ACCESS.includes(access2)) {
+    result.folderAccess = access2;
+  }
+  return result;
+}
+function claudeHome() {
+  return path9.join(homedir3(), ".claude");
+}
+function writableRoots(mode, cwd, workspacePaths) {
+  if (mode === "all")
+    return null;
+  const roots = /* @__PURE__ */ new Set([cwd, claudeHome()]);
+  if (mode === "project")
+    return [...roots];
+  for (const workspace of [cwd, ...workspacePaths]) {
+    roots.add(workspace);
+    const parent = path9.dirname(workspace);
+    if (parent !== workspace)
+      roots.add(parent);
+  }
+  return [...roots];
+}
+
+// ../host/dist/plugins.js
+import { readFile as readFile7 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import path10 from "node:path";
+var TIMEOUT_MS2 = 12e4;
+var SAFE_ARG = /^[A-Za-z0-9][A-Za-z0-9._@/-]*$/;
+var PluginCli = class {
+  /** Установленные плагины, подключённые маркетплейсы и их каталог. */
+  async list() {
+    const [rawPlugins, rawMarkets] = await Promise.all([
+      this.#json(["plugin", "list", "--json"]),
+      this.#json(["plugin", "marketplace", "list", "--json"])
+    ]);
+    const plugins = Array.isArray(rawPlugins) ? rawPlugins.map(toPlugin) : [];
+    const entries = Array.isArray(rawMarkets) ? rawMarkets.map(toMarketplace) : [];
+    const installed = new Set(plugins.map((p) => p.id));
+    return {
+      plugins,
+      marketplaces: entries.map(({ name, source }) => ({ name, source })),
+      catalog: await readCatalog(entries, installed)
+    };
+  }
+  async install(spec) {
+    return this.#run(["plugin", "install", requireSafe(spec, "\u043F\u043B\u0430\u0433\u0438\u043D\u0430")]);
+  }
+  async uninstall(id) {
+    return this.#run(["plugin", "uninstall", requireSafe(id, "\u043F\u043B\u0430\u0433\u0438\u043D\u0430"), "-y"]);
+  }
+  async setEnabled(id, enabled) {
+    return this.#run(["plugin", enabled ? "enable" : "disable", requireSafe(id, "\u043F\u043B\u0430\u0433\u0438\u043D\u0430")]);
+  }
+  async addMarketplace(source) {
+    if (source.trim() === "" || source.trim().startsWith("-")) {
+      throw new Error("\u0418\u0441\u0442\u043E\u0447\u043D\u0438\u043A \u043C\u0430\u0440\u043A\u0435\u0442\u043F\u043B\u0435\u0439\u0441\u0430 \u043D\u0435 \u043C\u043E\u0436\u0435\u0442 \u0431\u044B\u0442\u044C \u043F\u0443\u0441\u0442\u044B\u043C \u0438\u043B\u0438 \u043D\u0430\u0447\u0438\u043D\u0430\u0442\u044C\u0441\u044F \u0441 \xAB-\xBB");
+    }
+    return this.#run(["plugin", "marketplace", "add", source.trim()]);
+  }
+  async removeMarketplace(name) {
+    return this.#run(["plugin", "marketplace", "remove", requireSafe(name, "\u043C\u0430\u0440\u043A\u0435\u0442\u043F\u043B\u0435\u0439\u0441\u0430")]);
+  }
+  async #json(args) {
+    const out = await this.#run(args);
+    try {
+      return JSON.parse(out);
+    } catch {
+      const start = out.indexOf("[");
+      const end = out.lastIndexOf("]");
+      if (start === -1 || end <= start)
+        return null;
+      try {
+        return JSON.parse(out.slice(start, end + 1));
+      } catch {
+        return null;
+      }
+    }
+  }
+  #run(args) {
+    return runClaude(args, {
+      timeout: TIMEOUT_MS2,
+      // install печатает лог клонирования репозитория — куску в мегабайт тесно.
+      maxBuffer: 8 * 1024 * 1024,
+      missing: "\u0443\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u0438\u0435 \u043F\u043B\u0430\u0433\u0438\u043D\u0430\u043C\u0438 \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u043D\u043E"
+    });
+  }
+};
+function requireSafe(value, what) {
+  const trimmed = value.trim();
+  if (!SAFE_ARG.test(trimmed))
+    throw new Error(`\u041D\u0435\u0434\u043E\u043F\u0443\u0441\u0442\u0438\u043C\u043E\u0435 \u0438\u043C\u044F ${what}: \xAB${value}\xBB`);
+  return trimmed;
+}
+function toPlugin(raw) {
+  const r = raw ?? {};
+  const id = typeof r.id === "string" ? r.id : "";
+  const at = id.indexOf("@");
+  const servers = r.mcpServers;
+  return {
+    id,
+    name: at === -1 ? id : id.slice(0, at),
+    marketplace: at === -1 ? "" : id.slice(at + 1),
+    version: typeof r.version === "string" ? r.version : "",
+    scope: typeof r.scope === "string" ? r.scope : "",
+    // Поле новое: на старом CLI его нет, и молча считать плагин выключенным
+    // хуже, чем показать включённым — установленный плагин по умолчанию работает.
+    enabled: r.enabled !== false,
+    mcpServers: servers && typeof servers === "object" ? Object.keys(servers) : []
+  };
+}
+function toMarketplace(raw) {
+  const r = raw ?? {};
+  return {
+    name: typeof r.name === "string" ? r.name : "",
+    // `repo` информативнее, чем 'github' в `source`, — показываем его, если есть.
+    source: typeof r.repo === "string" ? r.repo : String(r.source ?? ""),
+    installLocation: typeof r.installLocation === "string" ? r.installLocation : ""
+  };
+}
+async function readCatalog(markets, installed) {
+  const lists = await Promise.all(markets.map((market) => readMarketplace(market, installed)));
+  return lists.flat().sort((a, b) => a.name.localeCompare(b.name));
+}
+async function readMarketplace(market, installed) {
+  const root = market.installLocation || path10.join(homedir4(), ".claude", "plugins", "marketplaces", market.name);
+  let manifest;
+  try {
+    const text = await readFile7(path10.join(root, ".claude-plugin", "marketplace.json"), "utf8");
+    manifest = JSON.parse(text);
+  } catch {
+    return [];
+  }
+  const raw = manifest?.plugins;
+  if (!Array.isArray(raw))
+    return [];
+  return raw.map((entry) => toCatalogPlugin(entry, market.name, installed)).filter((plugin) => plugin !== null);
+}
+function toCatalogPlugin(raw, marketplace, installed) {
+  const r = raw ?? {};
+  const name = typeof r.name === "string" ? r.name.trim() : "";
+  if (!name)
+    return null;
+  const id = `${name}@${marketplace}`;
+  return {
+    id,
+    name,
+    displayName: typeof r.displayName === "string" ? r.displayName : "",
+    marketplace,
+    description: typeof r.description === "string" ? r.description : "",
+    // `author` бывает строкой и объектом `{ name, email }` — в манифесте
+    // допустимы оба вида, и второй встречается чаще.
+    author: authorName(r.author),
+    category: typeof r.category === "string" ? r.category : "",
+    homepage: typeof r.homepage === "string" ? r.homepage : "",
+    version: typeof r.version === "string" ? r.version : "",
+    installed: installed.has(id)
+  };
+}
+function authorName(raw) {
+  if (typeof raw === "string")
+    return raw;
+  if (raw && typeof raw === "object") {
+    const name = raw.name;
+    if (typeof name === "string")
+      return name;
+  }
+  return "";
+}
+
+// ../host/dist/auth.js
+import { EventEmitter as EventEmitter2 } from "node:events";
+var QUICK_TIMEOUT_MS = 3e4;
+var LOGIN_TIMEOUT_MS = 10 * 6e4;
+var URL_RE = /https:\/\/\S*\/oauth\/authorize\S*/;
+var CODE_PROMPT_RE = /paste code|введите код|code here/i;
+var IDLE = {
+  active: false,
+  url: "",
+  awaitingCode: false,
+  output: "",
+  error: null
+};
+var AuthCli = class extends EventEmitter2 {
+  #child = null;
+  #state = IDLE;
+  #timer = null;
+  constructor() {
+    super();
+    void warmClaudeLauncher();
+  }
+  get loginState() {
+    return this.#state;
+  }
+  /** Кто вошёл. Незалогиненный CLI — не ошибка, а обычный ответ. */
+  async status() {
+    const raw = await run(["auth", "status", "--json"], QUICK_TIMEOUT_MS).catch(
+      // Старый CLI мог не знать `auth status`. Показать «не вошёл» честнее,
+      // чем уронить окно: сессии всё равно расскажут, работает ли ключ.
+      () => ""
+    );
+    return parseStatus2(raw);
+  }
+  /**
+   * Начать вход.
+   *
+   * `switchAccount` — это выход и вход подряд: отдельной команды «сменить
+   * аккаунт» у CLI нет, а войти вторым, не выйдя первым, нельзя — новый токен
+   * просто затрёт старый лишь после успеха, и до тех пор `auth status`
+   * показывал бы предыдущего пользователя.
+   */
+  async login(mode, switchAccount = false) {
+    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(describe3);
+      this.#push({ ...IDLE, active: true, output: `${out}
+` });
+      this.emit("changed");
+    } else {
+      this.#push({ ...IDLE, active: true });
+    }
+    const args = ["auth", "login", mode === "console" ? "--console" : "--claudeai"];
+    const child = await spawnClaude(args);
+    if (!this.#state.active) {
+      child.kill();
+      return;
+    }
+    this.#child = child;
+    this.#timer = setTimeout(() => {
+      this.#fail("\u0412\u0445\u043E\u0434 \u043D\u0435 \u0437\u0430\u0432\u0435\u0440\u0448\u0451\u043D \u0437\u0430 10 \u043C\u0438\u043D\u0443\u0442 \u2014 \u043F\u043E\u043F\u0440\u043E\u0431\u0443\u0439\u0442\u0435 \u0435\u0449\u0451 \u0440\u0430\u0437");
+    }, LOGIN_TIMEOUT_MS);
+    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" : describe3(error));
+    });
+    child.on("close", (code) => {
+      if (this.#child !== child)
+        return;
+      this.#clear();
+      this.#push({
+        ...this.#state,
+        active: false,
+        awaitingCode: false,
+        error: code === 0 ? null : this.#state.error ?? `claude auth login \u0437\u0430\u0432\u0435\u0440\u0448\u0438\u043B\u0441\u044F \u0441 \u043A\u043E\u0434\u043E\u043C ${code}`
+      });
+      this.emit("changed");
+    });
+  }
+  /** Отдать процессу код, принесённый из браузера. */
+  submitCode(code) {
+    const child = this.#child;
+    if (!child?.stdin?.writable)
+      throw new Error("\u0412\u0445\u043E\u0434 \u043D\u0435 \u0438\u0434\u0451\u0442 \u2014 \u0432\u0432\u043E\u0434\u0438\u0442\u044C \u043A\u043E\u0434 \u043D\u0435\u043A\u0443\u0434\u0430");
+    child.stdin.write(`${code.trim()}
+`);
+    this.#push({ ...this.#state, awaitingCode: false });
+  }
+  /** Прервать вход. Учётные данные при этом остаются прежними. */
+  cancel() {
+    if (!this.#child && !this.#state.active)
+      return;
+    this.#child?.kill();
+    this.#clear();
+    this.#push({ ...this.#state, active: false, awaitingCode: false, error: "\u0412\u0445\u043E\u0434 \u043E\u0442\u043C\u0435\u043D\u0451\u043D" });
+  }
+  async logout() {
+    this.cancel();
+    const output = await run(["auth", "logout"], QUICK_TIMEOUT_MS);
+    this.#push({ ...IDLE, output });
+    this.emit("changed");
+  }
+  // -------------------------------------------------------------------------
+  #absorb(text) {
+    const output = this.#state.output + text;
+    this.#push({
+      ...this.#state,
+      output,
+      url: this.#state.url || URL_RE.exec(output)?.[0] || "",
+      // Приглашение ищем в хвосте: раньше в выводе оно встретиться не может, а
+      // так мы не примем за него упоминание кода в старом сообщении.
+      awaitingCode: CODE_PROMPT_RE.test(output.slice(-200))
+    });
+  }
+  #fail(message) {
+    this.#child?.kill();
+    this.#clear();
+    this.#push({ ...this.#state, active: false, awaitingCode: false, error: message });
+  }
+  #clear() {
+    this.#child = null;
+    if (this.#timer)
+      clearTimeout(this.#timer);
+    this.#timer = null;
+  }
+  #push(state) {
+    this.#state = state;
+    this.emit("login", state);
+  }
+};
+function run(args, timeout) {
+  return runClaude(args, { timeout, missing: "\u0443\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u0438\u0435 \u0430\u043A\u043A\u0430\u0443\u043D\u0442\u043E\u043C \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u043D\u043E" });
+}
+function parseStatus2(raw) {
+  const empty = {
+    loggedIn: false,
+    method: "none",
+    email: "",
+    organization: "",
+    plan: ""
+  };
+  const start = raw.indexOf("{");
+  const end = raw.lastIndexOf("}");
+  if (start === -1 || end <= start)
+    return empty;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw.slice(start, end + 1));
+  } catch {
+    return empty;
+  }
+  return {
+    loggedIn: parsed.loggedIn === true,
+    method: str(parsed.authMethod) || "none",
+    email: str(parsed.email),
+    organization: str(parsed.orgName),
+    plan: str(parsed.subscriptionType)
+  };
+}
+function str(value) {
+  return typeof value === "string" ? value : "";
+}
+function describe3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// ../host/dist/relay-link.js
+import { EventEmitter as EventEmitter3 } from "node:events";
+import { readFile as readFile8, writeFile as writeFile5, rm as rm2, mkdir as mkdir5 } from "node:fs/promises";
+import path11 from "node:path";
+import { hostname } from "node:os";
+import WebSocket from "ws";
+
+// ../protocol/dist/relay.js
+var RELAY_PROTOCOL_VERSION = 1;
+var RELAY_BROADCAST = "*";
+
+// ../host/dist/relay-link.js
+var RETRY_MIN_MS = 1e3;
+var RETRY_MAX_MS = 6e4;
+function jitter(delay) {
+  return Math.round(delay * (0.8 + Math.random() * 0.4));
+}
+var RelayLink = class extends EventEmitter3 {
+  #credentials = null;
+  #socket = null;
+  #retry = RETRY_MIN_MS;
+  #retryTimer = null;
+  #clients = /* @__PURE__ */ new Set();
+  #error = null;
+  #closed = false;
+  /** Куда сопрягаться, пока не сопряглись. */
+  #defaultUrl;
+  #file;
+  #log;
+  constructor(options2) {
+    super();
+    this.#file = path11.join(options2.dataDir, "relay.json");
+    this.#defaultUrl = options2.defaultUrl.replace(/\/+$/, "");
+    this.#log = options2.log ?? ((msg) => console.log(`[relay] ${msg}`));
+  }
+  // -------------------------------------------------------------------------
+  // Состояние
+  // -------------------------------------------------------------------------
+  get state() {
+    return {
+      paired: this.#credentials !== null,
+      connected: this.#socket?.readyState === WebSocket.OPEN,
+      url: this.#credentials?.url ?? this.#defaultUrl,
+      name: this.#credentials?.name ?? null,
+      hostId: this.#credentials?.hostId ?? null,
+      clients: this.#clients.size,
+      error: this.#error
+    };
+  }
+  #changed() {
+    this.emit("state");
+  }
+  // -------------------------------------------------------------------------
+  // Жизненный цикл
+  // -------------------------------------------------------------------------
+  /** Поднять связь, если хост уже сопрягали раньше. */
+  async start() {
+    this.#credentials = await this.#read();
+    if (this.#credentials)
+      this.#connect();
+    this.#changed();
+  }
+  async #read() {
+    try {
+      const raw = await readFile8(this.#file, "utf8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed !== "object" || parsed === null)
+        return null;
+      const { url: url2, hostId, name, token } = parsed;
+      if (!url2 || !hostId || !token)
+        return null;
+      return { url: url2, hostId, name: name ?? hostname(), token };
+    } catch {
+      return null;
+    }
+  }
+  async #write(credentials) {
+    await mkdir5(path11.dirname(this.#file), { recursive: true });
+    await writeFile5(this.#file, `${JSON.stringify(credentials, null, 2)}
+`, {
+      encoding: "utf8",
+      mode: 384
+    });
+  }
+  /**
+   * Обменять код сопряжения на токен хоста.
+   *
+   * Единственное место, где хост сам ходит в relay по HTTP. Токен приходит в
+   * ответе один раз и сразу ложится на диск: показывать его человеку незачем —
+   * весь смысл кода в том, чтобы длинную строку никто не переносил руками.
+   */
+  async pair(code, name) {
+    const url2 = this.#credentials?.url ?? this.#defaultUrl;
+    const machine = (name ?? "").trim() || hostname();
+    let response;
+    try {
+      response = await fetch(`${url2}/api/pair/claim`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        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}: ${describe4(error)}`);
+    }
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok || !data.token || !data.hostId) {
+      throw new Error(data.error ?? `relay \u043E\u0442\u0432\u0435\u0442\u0438\u043B ${response.status}`);
+    }
+    this.#disconnect();
+    const credentials = {
+      url: url2,
+      hostId: data.hostId,
+      name: data.name ?? machine,
+      token: data.token
+    };
+    await this.#write(credentials);
+    this.#credentials = credentials;
+    this.#error = null;
+    this.#retry = RETRY_MIN_MS;
+    this.#connect();
+    this.#changed();
+    this.#log(`\u0441\u043E\u043F\u0440\u044F\u0436\u0435\u043D\u043E: ${credentials.name} (${credentials.hostId}) \u043D\u0430 ${credentials.url}`);
+  }
+  /** Отвязать машину: связь рвём, токен стираем с диска. */
+  async unpair() {
+    this.#disconnect();
+    this.#credentials = null;
+    this.#error = null;
+    this.#clients.clear();
+    await rm2(this.#file, { force: true });
+    this.#changed();
+    this.#log("\u0441\u043E\u043F\u0440\u044F\u0436\u0435\u043D\u0438\u0435 \u0441\u043D\u044F\u0442\u043E");
+  }
+  async close() {
+    this.#closed = true;
+    this.#disconnect();
+  }
+  // -------------------------------------------------------------------------
+  // Соединение
+  // -------------------------------------------------------------------------
+  #disconnect() {
+    if (this.#retryTimer) {
+      clearTimeout(this.#retryTimer);
+      this.#retryTimer = null;
+    }
+    const socket = this.#socket;
+    this.#socket = null;
+    if (socket) {
+      socket.removeAllListeners();
+      socket.close();
+    }
+    for (const clientId of this.#clients)
+      this.emit("detached", clientId);
+    this.#clients.clear();
+  }
+  #connect() {
+    const credentials = this.#credentials;
+    if (!credentials || this.#closed || this.#socket)
+      return;
+    const wsUrl = `${credentials.url.replace(/^http/, "ws")}/relay/host`;
+    const socket = new WebSocket(wsUrl);
+    this.#socket = socket;
+    socket.on("open", () => {
+      const hello = {
+        t: "host.hello",
+        protocol: RELAY_PROTOCOL_VERSION,
+        token: credentials.token,
+        name: credentials.name,
+        platform: process.platform
+      };
+      socket.send(JSON.stringify(hello));
+    });
+    socket.on("message", (raw) => this.#onMessage(socket, String(raw)));
+    socket.on("error", (error) => {
+      this.#error = describe4(error);
+    });
+    socket.on("close", (code, reason) => {
+      if (this.#socket !== socket)
+        return;
+      this.#socket = null;
+      for (const clientId of this.#clients)
+        this.emit("detached", clientId);
+      this.#clients.clear();
+      const rejected = code === 4001;
+      if (rejected) {
+        this.#error = reason.toString() || "relay \u043D\u0435 \u043F\u0440\u0438\u0437\u043D\u0430\u043B \u0442\u043E\u043A\u0435\u043D \u0445\u043E\u0441\u0442\u0430";
+        this.#log(`\u043E\u0442\u043A\u0430\u0437 relay: ${this.#error}`);
+      }
+      this.#changed();
+      this.#scheduleRetry(rejected);
+    });
+  }
+  #scheduleRetry(rejected) {
+    if (this.#closed || !this.#credentials || this.#retryTimer)
+      return;
+    const delay = rejected ? RETRY_MAX_MS : this.#retry;
+    this.#retry = Math.min(this.#retry * 2, RETRY_MAX_MS);
+    this.#retryTimer = setTimeout(() => {
+      this.#retryTimer = null;
+      this.#connect();
+    }, jitter(delay));
+    this.#retryTimer.unref();
+  }
+  #onMessage(socket, raw) {
+    let frame;
+    try {
+      frame = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    switch (frame.t) {
+      case "host.ok":
+        this.#retry = RETRY_MIN_MS;
+        this.#error = null;
+        for (const clientId of frame.clients) {
+          this.#clients.add(clientId);
+          this.emit("attached", clientId);
+        }
+        this.#log(`\u043D\u0430 \u0441\u0432\u044F\u0437\u0438 \u043A\u0430\u043A ${frame.name} (${frame.hostId}), \u0436\u0434\u0443\u0442 ${frame.clients.length}`);
+        this.#changed();
+        return;
+      case "client.attached":
+        this.#clients.add(frame.clientId);
+        this.emit("attached", frame.clientId);
+        this.#changed();
+        return;
+      case "client.detached":
+        this.#clients.delete(frame.clientId);
+        this.emit("detached", frame.clientId);
+        this.#changed();
+        return;
+      case "client.frame":
+        this.emit("frame", frame.clientId, frame.body);
+        return;
+      case "ping":
+        socket.send(JSON.stringify({ t: "pong", nonce: frame.nonce }));
+        return;
+      case "error":
+        this.#error = frame.message;
+        this.#log(`\u043E\u0448\u0438\u0431\u043A\u0430 relay (${frame.code}): ${frame.message}`);
+        this.#changed();
+        return;
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Отправка
+  // -------------------------------------------------------------------------
+  /** Кадр одному удалённому клиенту. */
+  send(clientId, frame) {
+    this.#push({ t: "host.frame", to: clientId, body: frame });
+  }
+  /**
+   * Кадр всем удалённым клиентам разом.
+   *
+   * Не то же самое, что рассылка по одному: broadcast попадает в кольцевой
+   * буфер relay и переживёт кратковременный обрыв у клиента, а адресный кадр —
+   * нет, потому что повторять ответ ушедшей вкладке некому.
+   */
+  broadcast(frame) {
+    if (this.#clients.size === 0)
+      return;
+    this.#push({ t: "host.frame", to: RELAY_BROADCAST, body: frame });
+  }
+  #push(frame) {
+    const socket = this.#socket;
+    if (socket?.readyState !== WebSocket.OPEN)
+      return;
+    socket.send(JSON.stringify(frame));
+  }
+};
+function describe4(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// ../host/dist/mcp-config.js
+import { readFile as readFile9, writeFile as writeFile6, mkdir as mkdir6 } from "node:fs/promises";
+import path12 from "node:path";
+var MCP_FILE = ".mcp.json";
+var LOCAL_SETTINGS2 = path12.join(".claude", "settings.local.json");
+var queues = /* @__PURE__ */ new Map();
+function serialize(cwd, work) {
+  const previous = queues.get(cwd) ?? Promise.resolve();
+  const next = previous.then(work, work);
+  queues.set(cwd, next.catch(() => void 0));
+  return next;
+}
+async function readProjectServers(cwd) {
+  const file = await readJson(path12.join(cwd, MCP_FILE));
+  const servers = file?.mcpServers;
+  if (!servers || typeof servers !== "object")
+    return {};
+  return servers;
+}
+function addProjectServer(cwd, name, config) {
+  return serialize(cwd, async () => {
+    const file = await readJson(path12.join(cwd, MCP_FILE)) ?? {};
+    const servers = file.mcpServers ?? {};
+    servers[name] = config;
+    file.mcpServers = servers;
+    await writeJson(path12.join(cwd, MCP_FILE), file);
+    await approve(cwd, name);
+  });
+}
+function removeProjectServer(cwd, name) {
+  return serialize(cwd, async () => {
+    const file = await readJson(path12.join(cwd, MCP_FILE));
+    const servers = file?.mcpServers;
+    if (!servers || !(name in servers))
+      return false;
+    delete servers[name];
+    await writeJson(path12.join(cwd, MCP_FILE), file);
+    const settingsPath = path12.join(cwd, LOCAL_SETTINGS2);
+    const settings = await readJson(settingsPath);
+    const enabled = settings?.enabledMcpjsonServers;
+    if (settings && Array.isArray(enabled) && enabled.includes(name)) {
+      settings.enabledMcpjsonServers = enabled.filter((s) => s !== name);
+      await writeJson(settingsPath, settings);
+    }
+    return true;
+  });
+}
+async function approve(cwd, name) {
+  const file = path12.join(cwd, LOCAL_SETTINGS2);
+  const settings = await readJson(file) ?? {};
+  const enabled = Array.isArray(settings.enabledMcpjsonServers) ? settings.enabledMcpjsonServers : [];
+  if (!enabled.includes(name))
+    enabled.push(name);
+  settings.enabledMcpjsonServers = enabled;
+  const disabled = settings.disabledMcpjsonServers;
+  if (Array.isArray(disabled)) {
+    settings.disabledMcpjsonServers = disabled.filter((s) => s !== name);
+  }
+  await writeJson(file, settings);
+}
+function draftToConfig(draft) {
+  if (draft.transport === "stdio") {
+    const config2 = { type: "stdio", command: draft.command };
+    if (draft.args.length > 0)
+      config2.args = draft.args;
+    if (Object.keys(draft.env).length > 0)
+      config2.env = draft.env;
+    return config2;
+  }
+  const config = { type: draft.transport, url: draft.url };
+  if (Object.keys(draft.headers).length > 0)
+    config.headers = draft.headers;
+  return config;
+}
+function describeConfig(config) {
+  if (!config || typeof config !== "object")
+    return { transport: "", target: "" };
+  const c = config;
+  const url2 = typeof c.url === "string" ? c.url : null;
+  if (url2)
+    return { transport: typeof c.type === "string" ? c.type : "http", target: url2 };
+  const command = typeof c.command === "string" ? c.command : "";
+  const args = Array.isArray(c.args) ? c.args.filter((a) => typeof a === "string") : [];
+  return { transport: "stdio", target: [command, ...args].join(" ").trim() };
+}
+async function readJson(file) {
+  try {
+    const raw = await readFile9(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 ${path12.basename(file)}: ${error.message}`);
+    }
+    throw error;
+  }
+}
+async function writeJson(file, data) {
+  await mkdir6(path12.dirname(file), { recursive: true });
+  await writeFile6(file, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+}
+
+// ../host/dist/server.js
+var SIDE_TITLE = "\xB7 \u0432\u043E\u043F\u0440\u043E\u0441 \u043D\u0430 \u043F\u043E\u043B\u044F\u0445";
+var FINDER_TITLE = "\xB7 \u043F\u043E\u0438\u0441\u043A \u043F\u0440\u043E\u0435\u043A\u0442\u0430";
+var HostServer = class {
+  #options;
+  #workspaces;
+  #archive;
+  #settings;
+  #finder;
+  #sessions = /* @__PURE__ */ new Map();
+  /** Боковые сессии («вопрос на полях») по id родителя — не больше одной на разговор. */
+  #sides = /* @__PURE__ */ new Map();
+  /**
+   * Сессия поиска проекта — не больше одной на хост.
+   *
+   * Она ничья: у неё нет ни проекта, ни родительского разговора, поэтому и
+   * ключа для неё нет — в отличие от боковой, которая живёт при своём.
+   */
+  #finderSession = null;
+  /** Последний запрос к ней — им подписывается ответ, когда тот придёт. */
+  #finderQuery = "";
+  #clients = /* @__PURE__ */ new Set();
+  /** Удалённые вкладки по их id в relay — чтобы адресовать ответ именно той. */
+  #remotes = /* @__PURE__ */ new Map();
+  #hostId = randomUUID2();
+  #plugins = new PluginCli();
+  #auth = new AuthCli();
+  #relay;
+  constructor(options2) {
+    this.#options = options2;
+    this.#workspaces = new WorkspaceRegistry(options2.dataDir);
+    this.#archive = new SessionArchive(options2.dataDir);
+    this.#settings = new AppSettingsStore(options2.dataDir);
+    this.#finder = new ProjectFinder(this.#workspaces);
+    this.#relay = new RelayLink({ dataDir: options2.dataDir, defaultUrl: options2.relayUrl });
+    this.#wireRelay();
+    this.#auth.on("login", (state) => {
+      this.#broadcast({ type: "auth.login", state });
+    });
+    this.#auth.on("changed", () => {
+      void this.#sendAuthStatus();
+    });
+  }
+  async start() {
+    await this.#workspaces.load();
+    await this.#archive.load();
+    await this.#settings.load();
+    await warmClaudeLauncher();
+    void this.#finder.warm();
+    const httpServer = createServer((req, res) => this.#serveHttp(req, res));
+    const wss = new WebSocketServer({ server: httpServer, path: "/ws" });
+    wss.on("connection", (socket) => this.#onConnection(socket));
+    let listening = false;
+    wss.on("error", (error) => {
+      if (listening)
+        console.error("[ws]", error instanceof Error ? error.message : String(error));
+    });
+    await new Promise((resolve, reject) => {
+      httpServer.once("error", reject);
+      httpServer.listen(this.#options.port, this.#options.host, () => {
+        httpServer.off("error", reject);
+        listening = true;
+        resolve();
+      });
+    });
+    await this.#relay.start().catch((error) => {
+      console.error("[relay]", error instanceof Error ? error.message : String(error));
+    });
+  }
+  async shutdown() {
+    this.#auth.cancel();
+    await this.#relay.close();
+    await Promise.all([...this.#sessions.values()].map((s) => s.close("host shutdown")));
+    this.#sessions.clear();
+  }
+  // -------------------------------------------------------------------------
+  // WebSocket
+  // -------------------------------------------------------------------------
+  #onConnection(socket) {
+    const client = {
+      local: true,
+      send: (frame) => {
+        if (socket.readyState !== socket.OPEN)
+          return;
+        socket.send(JSON.stringify(frame));
+      }
+    };
+    this.#clients.add(client);
+    socket.on("close", () => this.#clients.delete(client));
+    socket.on("message", (raw) => {
+      let parsed;
+      try {
+        parsed = JSON.parse(raw.toString());
+      } catch {
+        return client.send({ type: "error", message: "\u041D\u0435\u043A\u043E\u0440\u0440\u0435\u043A\u0442\u043D\u044B\u0439 JSON \u0432\u043E \u0432\u0445\u043E\u0434\u044F\u0449\u0435\u043C \u043A\u0430\u0434\u0440\u0435" });
+      }
+      if (!isClientFrame(parsed)) {
+        return client.send({ type: "error", message: "\u041D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u044B\u0439 \u0444\u043E\u0440\u043C\u0430\u0442 \u043A\u0430\u0434\u0440\u0430" });
+      }
+      this.#dispatch(client, parsed);
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Relay: те же кадры, только пришедшие снаружи
+  // -------------------------------------------------------------------------
+  #wireRelay() {
+    this.#relay.on("attached", (clientId) => {
+      const client = {
+        local: false,
+        send: (frame) => this.#relay.send(clientId, frame)
+      };
+      this.#remotes.set(clientId, client);
+      this.#clients.add(client);
+    });
+    this.#relay.on("detached", (clientId) => {
+      const client = this.#remotes.get(clientId);
+      if (!client)
+        return;
+      this.#remotes.delete(clientId);
+      this.#clients.delete(client);
+    });
+    this.#relay.on("frame", (clientId, body) => {
+      const client = this.#remotes.get(clientId);
+      const channel = client ?? this.#adoptRemote(clientId);
+      if (!isClientFrame(body)) {
+        channel.send({ type: "error", message: "\u041D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u044B\u0439 \u0444\u043E\u0440\u043C\u0430\u0442 \u043A\u0430\u0434\u0440\u0430" });
+        return;
+      }
+      this.#dispatch(channel, body);
+    });
+    this.#relay.on("state", () => {
+      this.#broadcast({ type: "relay.state", state: this.#relay.state });
+    });
+  }
+  #adoptRemote(clientId) {
+    const client = {
+      local: false,
+      send: (frame) => this.#relay.send(clientId, frame)
+    };
+    this.#remotes.set(clientId, client);
+    this.#clients.add(client);
+    return client;
+  }
+  /** Общий вход для кадра любой вкладки: своё исключение — свой `error`. */
+  #dispatch(client, frame) {
+    void this.#handleFrame(client, frame).catch((error) => {
+      client.send({
+        type: "error",
+        message: error instanceof Error ? error.message : String(error),
+        context: frame.type
+      });
+    });
+  }
+  #send(client, frame) {
+    client.send(frame);
+  }
+  #broadcast(frame) {
+    this.#relay.broadcast(frame);
+    for (const client of this.#clients) {
+      if (client.local)
+        client.send(frame);
+    }
+  }
+  async #handleFrame(socket, frame) {
+    switch (frame.type) {
+      case "hello":
+        this.#send(socket, {
+          type: "hello.ok",
+          protocol: PROTOCOL_VERSION,
+          hostId: this.#hostId,
+          hostVersion: this.#options.version,
+          platform: process.platform
+        });
+        this.#send(socket, {
+          type: "workspace.list",
+          workspaces: this.#workspaces.list()
+        });
+        this.#auth.status().then((status) => this.#send(socket, { type: "auth.status", status })).catch(() => void 0);
+        this.#send(socket, { type: "relay.state", state: this.#relay.state });
+        return;
+      case "ping":
+        this.#send(socket, { type: "pong", nonce: frame.nonce });
+        return;
+      case "workspace.list":
+        this.#send(socket, {
+          type: "workspace.list",
+          workspaces: this.#workspaces.list()
+        });
+        return;
+      case "workspace.open":
+        await this.#workspaces.open(frame.path);
+        this.#broadcast({
+          type: "workspace.list",
+          workspaces: this.#workspaces.list()
+        });
+        await this.#closeFinder();
+        return;
+      case "workspace.close": {
+        const closed = await this.#workspaces.close(frame.workspaceIds);
+        if (closed.length === 0)
+          return;
+        const gone = new Set(closed.map((w) => w.id));
+        for (const session of [...this.#sessions.values()]) {
+          if (!gone.has(session.workspaceId))
+            continue;
+          await this.#dropSession(session.id, "workspace closed");
+        }
+        this.#broadcast({
+          type: "workspace.list",
+          workspaces: this.#workspaces.list()
+        });
+        return;
+      }
+      case "workspace.find": {
+        const { candidates, truncated } = this.#finder.find(frame.query);
+        this.#send(socket, {
+          type: "workspace.candidates",
+          query: frame.query,
+          source: "host",
+          candidates,
+          truncated
+        });
+        return;
+      }
+      case "workspace.find.agent":
+        this.#findWithAgent(frame.query);
+        return;
+      case "workspace.roots":
+        this.#send(socket, { type: "workspace.roots", roots: this.#roots() });
+        return;
+      case "workspace.create": {
+        const { workspace, warnings } = await this.#workspaces.create(frame.parent, frame.name, frame.init);
+        this.#broadcast({
+          type: "workspace.list",
+          workspaces: this.#workspaces.list()
+        });
+        this.#send(socket, { type: "workspace.created", workspace, warnings });
+        await this.#closeFinder();
+        return;
+      }
+      case "session.list": {
+        const { sessions, archived } = await this.#listSessions(frame.workspaceId);
+        this.#send(socket, {
+          type: "session.list",
+          workspaceId: frame.workspaceId,
+          sessions,
+          archived
+        });
+        return;
+      }
+      case "session.start":
+        await this.#startSession(socket, frame);
+        return;
+      case "session.close":
+        await this.#dropSession(frame.sessionId, "closed by client");
+        return;
+      case "session.archive": {
+        const ids = new Set(frame.sessionIds);
+        for (const session of [...this.#sessions.values()]) {
+          const diskId = session.claudeSessionId ?? session.id;
+          if (!ids.has(session.id) && !ids.has(diskId))
+            continue;
+          ids.add(diskId);
+          await this.#dropSession(session.id, "archived");
+        }
+        await this.#archive.archive(frame.workspaceId, [...ids]);
+        await this.#sendSessionList(frame.workspaceId);
+        return;
+      }
+      case "session.unarchive":
+        await this.#archive.unarchive(frame.sessionIds);
+        await this.#sendSessionList(frame.workspaceId);
+        return;
+      case "session.rename":
+        await this.#renameSession(frame.sessionId, frame.title, frame.workspaceId);
+        return;
+      case "session.sync": {
+        const session = this.#requireSession(frame.sessionId);
+        const entries = session.journal.since(frame.sinceSeq);
+        if (session.capabilities) {
+          this.#send(socket, {
+            type: "session.capabilities",
+            sessionId: session.id,
+            capabilities: session.capabilities
+          });
+        }
+        this.#send(socket, { type: "session.summary", session: session.summary() });
+        if (session.usage) {
+          this.#send(socket, {
+            type: "usage.state",
+            sessionId: session.id,
+            usage: session.usage
+          });
+        }
+        if (entries.length > 0) {
+          this.#send(socket, { type: "session.events", sessionId: session.id, entries });
+        }
+        return;
+      }
+      case "usage.get": {
+        const session = this.#requireSession(frame.sessionId);
+        if (session.usage) {
+          this.#send(socket, {
+            type: "usage.state",
+            sessionId: session.id,
+            usage: session.usage
+          });
+        }
+        await session.refreshUsage(true);
+        return;
+      }
+      case "prompt.send":
+        this.#requireSession(frame.sessionId).sendPrompt(frame.text);
+        return;
+      case "permission.respond":
+        this.#requireSession(frame.sessionId).respondPermission(frame.requestId, frame.decision, frame.reason);
+        return;
+      case "side.ask":
+        this.#ensureSide(this.#requireSession(frame.sessionId)).sendPrompt(frame.text);
+        return;
+      // Поднять форк, ничего не спрашивая: клиенту нужен его id, чтобы
+      // адресовать `control.*` — модель бокового вопроса выбирают до вопроса.
+      case "side.open": {
+        const side = this.#ensureSide(this.#requireSession(frame.sessionId));
+        this.#send(socket, {
+          type: "side.opened",
+          parentSessionId: frame.sessionId,
+          sessionId: side.id
+        });
+        return;
+      }
+      case "side.reset":
+        await this.#closeSide(frame.sessionId);
+        return;
+      case "control.interrupt":
+        await this.#requireSession(frame.sessionId).interrupt();
+        return;
+      case "control.set_mode":
+        await this.#requireSession(frame.sessionId).setPermissionMode(frame.mode);
+        return;
+      case "control.set_model":
+        await this.#requireSession(frame.sessionId).setModel(frame.model);
+        return;
+      case "control.set_effort":
+        await this.#requireSession(frame.sessionId).setEffort(frame.effort);
+        return;
+      case "control.set_ultracode":
+        await this.#requireSession(frame.sessionId).setUltracode(frame.enabled);
+        return;
+      case "control.set_thinking":
+        await this.#requireSession(frame.sessionId).setThinking(frame.enabled);
+        return;
+      case "control.set_flag_switch":
+        await this.#requireSession(frame.sessionId).setSwitchModelsOnFlag(frame.enabled);
+        return;
+      case "mcp.list":
+        await this.#sendMcpList(frame.sessionId);
+        return;
+      case "mcp.add": {
+        const session = this.#requireSession(frame.sessionId);
+        const config = draftToConfig(frame.draft);
+        const name = frame.name.trim();
+        if (!name)
+          throw new Error("\u0418\u043C\u044F \u0441\u0435\u0440\u0432\u0435\u0440\u0430 \u043D\u0435 \u043C\u043E\u0436\u0435\u0442 \u0431\u044B\u0442\u044C \u043F\u0443\u0441\u0442\u044B\u043C");
+        await addProjectServer(session.cwd, name, config);
+        await session.addMcpServer(name, config);
+        this.#reportOperation(frame.sessionId, "mcp", true, `\u0421\u0435\u0440\u0432\u0435\u0440 \xAB${name}\xBB \u043F\u043E\u0434\u043A\u043B\u044E\u0447\u0451\u043D`);
+        await this.#sendMcpList(frame.sessionId);
+        return;
+      }
+      case "mcp.remove": {
+        const session = this.#requireSession(frame.sessionId);
+        const inFile = await removeProjectServer(session.cwd, frame.name);
+        const live = await session.removeMcpServer(frame.name);
+        this.#reportOperation(frame.sessionId, "mcp", inFile || live, inFile || live ? `\u0421\u0435\u0440\u0432\u0435\u0440 \xAB${frame.name}\xBB \u0443\u0434\u0430\u043B\u0451\u043D` : `\u0421\u0435\u0440\u0432\u0435\u0440 \xAB${frame.name}\xBB \u043E\u043F\u0438\u0441\u0430\u043D \u043D\u0435 \u0432 \u044D\u0442\u043E\u043C \u043F\u0440\u043E\u0435\u043A\u0442\u0435 \u2014 \u0443\u0434\u0430\u043B\u0438\u0442\u044C \u043E\u0442\u0441\u044E\u0434\u0430 \u043D\u0435\u043B\u044C\u0437\u044F`);
+        await this.#sendMcpList(frame.sessionId);
+        return;
+      }
+      case "mcp.action": {
+        this.#requireSession(frame.sessionId).sendPrompt(`/mcp ${frame.action} ${frame.name}`);
+        return;
+      }
+      case "plugin.list":
+        await this.#sendPluginList(frame.sessionId);
+        return;
+      case "plugin.install":
+        await this.#pluginOperation(frame.sessionId, () => this.#plugins.install(frame.spec));
+        return;
+      case "plugin.uninstall":
+        await this.#pluginOperation(frame.sessionId, () => this.#plugins.uninstall(frame.id));
+        return;
+      case "plugin.toggle":
+        await this.#pluginOperation(frame.sessionId, () => this.#plugins.setEnabled(frame.id, frame.enabled));
+        return;
+      case "marketplace.add":
+        await this.#pluginOperation(frame.sessionId, () => this.#plugins.addMarketplace(frame.source));
+        return;
+      case "marketplace.remove":
+        await this.#pluginOperation(frame.sessionId, () => this.#plugins.removeMarketplace(frame.name));
+        return;
+      case "git.state":
+        this.#send(socket, {
+          type: "git.state",
+          workspaceId: frame.workspaceId,
+          state: await this.#git(frame.workspaceId).state()
+        });
+        return;
+      case "git.show":
+        this.#send(socket, {
+          type: "git.commit",
+          workspaceId: frame.workspaceId,
+          detail: await this.#git(frame.workspaceId).show(frame.ref)
+        });
+        return;
+      case "git.checkout": {
+        const repo = this.#git(frame.workspaceId);
+        let ok = true;
+        let message;
+        try {
+          message = await repo.checkout(frame.target);
+        } catch (error) {
+          ok = false;
+          message = error instanceof Error ? error.message : String(error);
+        }
+        this.#broadcast({ type: "git.result", workspaceId: frame.workspaceId, ok, message });
+        this.#broadcast({
+          type: "git.state",
+          workspaceId: frame.workspaceId,
+          state: await repo.state()
+        });
+        return;
+      }
+      case "fs.list":
+        this.#send(socket, {
+          type: "fs.dir",
+          workspaceId: frame.workspaceId,
+          path: normalize(frame.path),
+          entries: await this.#markIgnored(frame.workspaceId, await this.#files(frame.workspaceId).list(frame.path))
+        });
+        return;
+      case "fs.search": {
+        const { entries, truncated } = await this.#files(frame.workspaceId).search(frame.query);
+        this.#send(socket, {
+          type: "fs.search",
+          workspaceId: frame.workspaceId,
+          query: frame.query,
+          scope: frame.scope ?? "tree",
+          entries: await this.#markIgnored(frame.workspaceId, entries),
+          truncated
+        });
+        return;
+      }
+      case "fs.grep": {
+        const { matches: matches2, truncated } = await this.#files(frame.workspaceId).grep(frame.query);
+        this.#send(socket, {
+          type: "fs.grep",
+          workspaceId: frame.workspaceId,
+          query: frame.query,
+          matches: matches2,
+          truncated
+        });
+        return;
+      }
+      case "fs.read":
+        this.#send(socket, {
+          type: "fs.file",
+          workspaceId: frame.workspaceId,
+          file: await this.#files(frame.workspaceId).read(frame.path)
+        });
+        return;
+      case "fs.write": {
+        const files = this.#files(frame.workspaceId);
+        let saved;
+        try {
+          saved = await files.write(frame.path, frame.content, frame.eol, frame.baseMtime, frame.force === true);
+        } catch (error) {
+          this.#fsFailed(frame.workspaceId, frame.path, error);
+          return;
+        }
+        this.#broadcast({
+          type: "fs.saved",
+          workspaceId: frame.workspaceId,
+          path: normalize(frame.path),
+          mtime: saved.mtime,
+          size: saved.size
+        });
+        await this.#sendDir(frame.workspaceId, parentOf(frame.path));
+        return;
+      }
+      case "fs.create":
+      case "fs.delete":
+      case "fs.rename": {
+        const files = this.#files(frame.workspaceId);
+        const done = frame.type === "fs.create" ? `\u0421\u043E\u0437\u0434\u0430\u043D${frame.kind === "dir" ? " \u043A\u0430\u0442\u0430\u043B\u043E\u0433" : " \u0444\u0430\u0439\u043B"} ${normalize(frame.path)}` : frame.type === "fs.delete" ? `\u0423\u0434\u0430\u043B\u0435\u043D\u043E: ${normalize(frame.path)}` : `\u041F\u0435\u0440\u0435\u0438\u043C\u0435\u043D\u043E\u0432\u0430\u043D\u043E \u0432 ${normalize(frame.to)}`;
+        try {
+          if (frame.type === "fs.create")
+            await files.create(frame.path, frame.kind);
+          else if (frame.type === "fs.delete")
+            await files.remove(frame.path);
+          else
+            await files.rename(frame.path, frame.to);
+        } catch (error) {
+          this.#fsFailed(frame.workspaceId, frame.path, error);
+          return;
+        }
+        this.#broadcast({
+          type: "fs.result",
+          workspaceId: frame.workspaceId,
+          ok: true,
+          message: done,
+          path: normalize(frame.type === "fs.rename" ? frame.to : frame.path)
+        });
+        await this.#sendDir(frame.workspaceId, parentOf(frame.path));
+        if (frame.type === "fs.rename") {
+          const to = parentOf(frame.to);
+          if (to !== parentOf(frame.path))
+            await this.#sendDir(frame.workspaceId, to);
+        }
+        return;
+      }
+      case "settings.get":
+        this.#send(socket, { type: "settings.state", settings: this.#settings.current });
+        return;
+      case "settings.update": {
+        const before = this.#settings.current;
+        const settings = await this.#settings.update(frame.settings);
+        this.#broadcast({ type: "settings.state", settings });
+        if (settings.autoArchiveAfterMs !== before.autoArchiveAfterMs) {
+          for (const workspace of this.#workspaces.list()) {
+            await this.#sendSessionList(workspace.id);
+          }
+        }
+        return;
+      }
+      case "auth.status":
+        this.#send(socket, { type: "auth.status", status: await this.#auth.status() });
+        this.#send(socket, { type: "auth.login", state: this.#auth.loginState });
+        return;
+      case "auth.login":
+        await this.#auth.login(frame.mode, frame.switchAccount === true);
+        return;
+      case "auth.code":
+        this.#auth.submitCode(frame.code);
+        return;
+      case "auth.cancel":
+        this.#auth.cancel();
+        return;
+      case "auth.logout":
+        await this.#auth.logout();
+        return;
+      case "relay.status":
+        this.#send(socket, { type: "relay.state", state: this.#relay.state });
+        return;
+      case "relay.pair":
+        this.#requireLocal(socket, "\u0421\u0432\u044F\u0437\u0430\u0442\u044C \u043A\u043E\u043C\u043F\u044C\u044E\u0442\u0435\u0440");
+        await this.#relay.pair(frame.code, frame.name);
+        return;
+      case "relay.unpair":
+        this.#requireLocal(socket, "\u041E\u0442\u0432\u044F\u0437\u0430\u0442\u044C \u043A\u043E\u043C\u043F\u044C\u044E\u0442\u0435\u0440");
+        await this.#relay.unpair();
+        return;
+    }
+  }
+  /**
+   * Настройки удалённого доступа меняются только с самой машины.
+   *
+   * Иначе достаточно один раз попасть внутрь через relay, чтобы перепривязать
+   * хост к чужому аккаунту и остаться в нём навсегда. Смотреть на состояние
+   * (`relay.status`) при этом можно откуда угодно — это не право, а справка.
+   */
+  #requireLocal(client, action) {
+    if (client.local)
+      return;
+    throw new Error(`${action} \u043C\u043E\u0436\u043D\u043E \u0442\u043E\u043B\u044C\u043A\u043E \u043D\u0430 \u043D\u0451\u043C \u0441\u0430\u043C\u043E\u043C, \u043D\u0435 \u0443\u0434\u0430\u043B\u0451\u043D\u043D\u043E`);
+  }
+  async #sendAuthStatus() {
+    this.#broadcast({ type: "auth.status", status: await this.#auth.status() });
+  }
+  // -------------------------------------------------------------------------
+  // MCP и плагины
+  // -------------------------------------------------------------------------
+  /**
+   * Список серверов для панели: живые статусы из SDK, дополненные конфигами
+   * из `.mcp.json`.
+   *
+   * Одного источника мало. SDK знает только то, что уже поднято, и не скажет
+   * про сервер, который записан в проект, но в этой сессии не стартовал.
+   * Файл, наоборот, не знает ни статуса, ни ошибки подключения.
+   */
+  async #sendMcpList(sessionId) {
+    const session = this.#requireSession(sessionId);
+    const statuses = await session.mcpServerStatus();
+    const fromFile = await readProjectServers(session.cwd);
+    const servers = /* @__PURE__ */ new Map();
+    for (const status of statuses) {
+      const shape = describeConfig(status.config);
+      servers.set(status.name, {
+        name: status.name,
+        status: status.status,
+        transport: shape.transport,
+        target: shape.target,
+        scope: status.scope ?? "",
+        error: status.error ?? null,
+        tools: (status.tools ?? []).map((tool) => tool.name),
+        editable: status.name in fromFile
+      });
+    }
+    for (const [name, config] of Object.entries(fromFile)) {
+      if (servers.has(name))
+        continue;
+      const shape = describeConfig(config);
+      servers.set(name, {
+        name,
+        // Записан в проект, но SDK о нём не отчитался — значит, поднимется
+        // только со следующей сессии.
+        status: "pending",
+        transport: shape.transport,
+        target: shape.target,
+        scope: "project",
+        error: null,
+        tools: [],
+        editable: true
+      });
+    }
+    this.#broadcast({
+      type: "mcp.list",
+      sessionId,
+      servers: [...servers.values()].sort((a, b) => a.name.localeCompare(b.name))
+    });
+  }
+  async #sendPluginList(sessionId) {
+    const { plugins, marketplaces, catalog } = await this.#plugins.list();
+    this.#broadcast({ type: "plugin.list", sessionId, plugins, marketplaces, catalog });
+  }
+  /**
+   * Общий хвост для всех команд `claude plugin`.
+   *
+   * После любой из них сессии нужно перечитать плагины с диска, иначе меню «/»
+   * и список сабагентов останутся со старым составом до перезапуска. Ошибку
+   * CLI показываем как результат операции, а не роняем кадр: пользователь
+   * должен увидеть текст «маркетплейс не найден», а не молчание.
+   */
+  async #pluginOperation(sessionId, run2) {
+    let ok = true;
+    let message;
+    try {
+      message = await run2() || "\u0413\u043E\u0442\u043E\u0432\u043E";
+    } catch (error) {
+      ok = false;
+      message = error instanceof Error ? error.message : String(error);
+    }
+    if (ok) {
+      await this.#sessions.get(sessionId)?.reloadPlugins().catch(() => void 0);
+    }
+    this.#reportOperation(sessionId, "plugin", ok, message);
+    await this.#sendPluginList(sessionId);
+  }
+  #reportOperation(sessionId, scope, ok, message) {
+    this.#broadcast({ type: "operation.result", sessionId, result: { scope, ok, message } });
+  }
+  // -------------------------------------------------------------------------
+  // Сессии
+  // -------------------------------------------------------------------------
+  #requireSession(sessionId) {
+    const session = this.#sessions.get(sessionId);
+    if (!session)
+      throw new Error(`\u0421\u0435\u0441\u0441\u0438\u044F \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D\u0430: ${sessionId}`);
+    return session;
+  }
+  /**
+   * Остановить живую сессию и сказать об этом всем окнам.
+   *
+   * Одно место на все причины остановки (закрыли сессию, закрыли проект, убрали
+   * в архив): забыть про боковой вопрос или про рассылку в каждой из них по
+   * отдельности — вопрос времени, а цена — висящий процесс.
+   */
+  async #dropSession(sessionId, reason) {
+    const session = this.#sessions.get(sessionId);
+    if (!session)
+      return false;
+    await this.#closeSide(sessionId);
+    await session.close(reason);
+    this.#sessions.delete(sessionId);
+    this.#broadcast({ type: "session.closed", sessionId, reason });
+    return true;
+  }
+  /**
+   * Разослать список сессий проекта всем окнам.
+   *
+   * Broadcast, а не ответ спросившему: архив и список меняются от действий,
+   * которые видны всем, — во втором окне открыт тот же проект.
+   */
+  async #sendSessionList(workspaceId) {
+    const { sessions, archived } = await this.#listSessions(workspaceId);
+    this.#broadcast({ type: "session.list", workspaceId, sessions, archived });
+  }
+  async #startSession(socket, frame) {
+    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 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)
+      await this.#archive.unarchive([frame.resume]);
+    const session = new ClaudeSession({
+      workspaceId: workspace.id,
+      cwd: workspace.path,
+      resume: frame.resume,
+      fork: frame.fork,
+      permissionMode: frame.permissionMode,
+      model: frame.model,
+      ...resumedTitle ? { title: resumedTitle } : {},
+      // Имя проекта вместо «Без названия»: свежую сессию в списке уже надо
+      // как-то называть, а сказать о ней пока нечего, кроме того, где она.
+      defaultTitle: workspace.name,
+      writableRoots: () => this.#writableRoots(workspace.path)
+    });
+    this.#wire(session);
+    this.#sessions.set(session.id, session);
+    session.start();
+    this.#send(socket, { type: "session.summary", session: session.summary() });
+  }
+  /**
+   * Подписка на события сессии.
+   *
+   * Все клиенты видят одну и ту же сессию — это нужно уже сейчас (два окна
+   * на одном ПК) и тем более потом, когда добавится телефон.
+   */
+  #wire(session) {
+    session.on("event", (entry) => {
+      this.#broadcast({ type: "session.events", sessionId: session.id, entries: [entry] });
+    });
+    session.on("summary", (summary) => {
+      this.#broadcast({ type: "session.summary", session: summary });
+    });
+    session.on("capabilities", () => {
+      if (!session.capabilities)
+        return;
+      this.#broadcast({
+        type: "session.capabilities",
+        sessionId: session.id,
+        capabilities: session.capabilities
+      });
+    });
+    session.on("usage", (usage) => {
+      this.#broadcast({ type: "usage.state", sessionId: session.id, usage });
+    });
+    session.on("stderr", (data) => {
+      process.stderr.write(`[claude ${session.id.slice(0, 8)}] ${data}`);
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Боковой вопрос
+  // -------------------------------------------------------------------------
+  /**
+   * Боковая сессия родителя, при надобности поднятая.
+   *
+   * Форк, а не новая сессия: смысл вопроса на полях в том, что спрашивают про
+   * происходящее («зачем ты правишь этот файл?»), и без разговора ответить на
+   * это нечем. Форк видит транскрипт родителя, но пишет в свой — основная
+   * сессия о вопросе не узнает, и контекст ей вопрос не засоряет.
+   *
+   * Пока родитель не сделал ни одного обмена, транскрипта на диске ещё нет —
+   * тогда поднимаем обычную сессию в том же каталоге: проект она видит, а
+   * разговора пока и не было.
+   */
+  #ensureSide(parent) {
+    const existing = this.#sides.get(parent.id);
+    if (existing && existing.state !== "closed" && existing.state !== "error") {
+      return existing;
+    }
+    const claudeId = parent.claudeSessionId;
+    const side = new ClaudeSession({
+      workspaceId: parent.workspaceId,
+      cwd: parent.cwd,
+      parentSessionId: parent.id,
+      readOnly: true,
+      ...claudeId ? { resume: claudeId, fork: true } : {}
+    });
+    this.#wire(side);
+    this.#sessions.set(side.id, side);
+    this.#sides.set(parent.id, side);
+    side.start();
+    side.setTitle(SIDE_TITLE);
+    this.#broadcast({
+      type: "side.opened",
+      parentSessionId: parent.id,
+      sessionId: side.id
+    });
+    return side;
+  }
+  async #closeSide(parentSessionId) {
+    const side = this.#sides.get(parentSessionId);
+    if (!side)
+      return;
+    this.#sides.delete(parentSessionId);
+    this.#sessions.delete(side.id);
+    await side.close("\u0431\u043E\u043A\u043E\u0432\u043E\u0439 \u0432\u043E\u043F\u0440\u043E\u0441 \u0437\u0430\u043A\u0440\u044B\u0442");
+    this.#broadcast({ type: "side.closed", parentSessionId });
+  }
+  // -------------------------------------------------------------------------
+  // Поиск проекта агентом
+  // -------------------------------------------------------------------------
+  /**
+   * Спросить агента, где лежит проект.
+   *
+   * Сессия поднимается только на чтение и переиспользуется между запросами:
+   * второй вопрос в том же диалоге — это почти всегда уточнение первого
+   * («нет, не тот»), и разговор ему помогает. Закрывается она в
+   * `workspace.open` — момент, когда проект нашли и диалог больше не нужен.
+   */
+  /**
+   * Куда предлагать положить новый проект.
+   *
+   * То же, что знает агентный поиск, — каталоги, в которых проекты уже лежат.
+   * Домашний каталог дописывается запасным вариантом, а не подмешивается всегда:
+   * на обжитой машине он в этом списке лишний, а на свежей (проектов ещё нет, и
+   * `roots()` пуст) — единственное осмысленное место, которое хост может
+   * назвать, не спрашивая ОС о папке «Документы».
+   */
+  #roots() {
+    const roots = this.#finder.roots();
+    return roots.length > 0 ? roots : [homedir5()];
+  }
+  /**
+   * Где сессии этого каталога разрешено писать без вопроса.
+   *
+   * Считается на каждый вызов хука, а не запоминается при старте сессии: и
+   * настройку, и список открытых проектов меняют в работающем окне, а «дал
+   * доступ ко всем папкам» обязано действовать сразу, а не со следующей сессии.
+   */
+  #writableRoots(cwd) {
+    return writableRoots(this.#settings.current.folderAccess, cwd, this.#workspaces.list().map((workspace) => workspace.path));
+  }
+  #findWithAgent(query2) {
+    const roots = this.#finder.roots();
+    if (roots.length === 0) {
+      this.#broadcast({
+        type: "workspace.candidates",
+        query: query2,
+        source: "agent",
+        candidates: [],
+        truncated: false
+      });
+      return;
+    }
+    this.#finderQuery = query2;
+    const session = this.#ensureFinder(roots);
+    this.#broadcast({ type: "finder.opened", sessionId: session.id });
+    session.sendPrompt(finderPrompt(query2, roots));
+  }
+  #ensureFinder(roots) {
+    const existing = this.#finderSession;
+    if (existing && existing.state !== "closed" && existing.state !== "error")
+      return existing;
+    const finder = new ClaudeSession({
+      // Воркспейса у поиска нет: он ищет как раз то, что воркспейсом ещё не
+      // стало. Пустой id никакому проекту не принадлежит — и в список сессий
+      // ни одного из них такая сессия не попадёт.
+      workspaceId: "",
+      // `cwd` у сессии один, а корней несколько. Берём самый населённый, а
+      // остальные перечисляем в промпте: `Glob` и `Grep` принимают абсолютный
+      // путь, так что одним каталогом поиск не заперт.
+      cwd: roots[0],
+      readOnly: true,
+      outputFormat: { type: "json_schema", schema: FINDER_SCHEMA }
+    });
+    this.#wire(finder);
+    finder.on("structured", (payload) => {
+      this.#broadcast({
+        type: "workspace.candidates",
+        query: this.#finderQuery,
+        source: "agent",
+        candidates: this.#finder.validate(readNamedPaths(payload.data, payload.text)),
+        truncated: false
+      });
+    });
+    this.#sessions.set(finder.id, finder);
+    this.#finderSession = finder;
+    finder.start();
+    finder.setTitle(FINDER_TITLE);
+    return finder;
+  }
+  async #closeFinder() {
+    const finder = this.#finderSession;
+    if (!finder)
+      return;
+    this.#finderSession = null;
+    this.#sessions.delete(finder.id);
+    await finder.close("\u043F\u0440\u043E\u0435\u043A\u0442 \u043D\u0430\u0439\u0434\u0435\u043D");
+  }
+  // -------------------------------------------------------------------------
+  // Git
+  // -------------------------------------------------------------------------
+  #git(workspaceId) {
+    const workspace = this.#workspaces.find(workspaceId);
+    if (!workspace)
+      throw new Error(`\u0412\u043E\u0440\u043A\u0441\u043F\u0435\u0439\u0441 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D: ${workspaceId}`);
+    return new GitRepo(workspace.path);
+  }
+  // -------------------------------------------------------------------------
+  // Файлы проекта
+  // -------------------------------------------------------------------------
+  #files(workspaceId) {
+    const workspace = this.#workspaces.find(workspaceId);
+    if (!workspace)
+      throw new Error(`\u0412\u043E\u0440\u043A\u0441\u043F\u0435\u0439\u0441 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D: ${workspaceId}`);
+    return new ProjectFiles(workspace.path);
+  }
+  /**
+   * Разослать содержимое каталога после правки в нём.
+   *
+   * Broadcast, а не ответ спросившему: каталог проекта общий, и второе окно
+   * должно увидеть созданный файл само. Ошибку чтения гасим — каталог мог
+   * только что исчезнуть вместе с тем, что в нём удалили.
+   */
+  async #sendDir(workspaceId, dir) {
+    const entries = await this.#files(workspaceId).list(dir).catch(() => null);
+    if (!entries)
+      return;
+    this.#broadcast({
+      type: "fs.dir",
+      workspaceId,
+      path: normalize(dir),
+      entries: await this.#markIgnored(workspaceId, entries)
+    });
+  }
+  /**
+   * Проставить записям отметку «под .gitignore».
+   *
+   * Поверх готового списка, а не внутри `ProjectFiles`: файловая система про
+   * git не знает ничего, а один `git check-ignore` на весь каталог дешевле,
+   * чем вызов на запись. Каталог раскрывают по одному, поэтому и вызов уходит
+   * по одному — на весь обход дерева его не бывает.
+   */
+  async #markIgnored(workspaceId, entries) {
+    if (entries.length === 0)
+      return entries;
+    const ignored = await this.#git(workspaceId).checkIgnored(entries.map((e) => e.path));
+    if (ignored.size === 0)
+      return entries;
+    return entries.map((entry) => ignored.has(entry.path) ? { ...entry, ignored: true } : entry);
+  }
+  #fsFailed(workspaceId, filePath, error) {
+    const conflict = error instanceof Error && "conflict" in error;
+    this.#broadcast({
+      type: "fs.result",
+      workspaceId,
+      ok: false,
+      message: error instanceof Error ? error.message : String(error),
+      path: normalize(filePath),
+      ...conflict ? { conflict: true } : {}
+    });
+  }
+  /**
+   * Переименование живой сессии и сессии с диска — разные пути.
+   *
+   * Живая сама разошлёт новое имя и запишет его в JSONL. Для дисковой поднимать
+   * процесс ради имени незачем: пишем в JSONL напрямую и пересобираем список.
+   */
+  async #renameSession(sessionId, rawTitle, workspaceId) {
+    const title = rawTitle.trim().slice(0, 200);
+    if (!title)
+      throw new Error("\u041D\u0430\u0437\u0432\u0430\u043D\u0438\u0435 \u0441\u0435\u0441\u0441\u0438\u0438 \u043D\u0435 \u043C\u043E\u0436\u0435\u0442 \u0431\u044B\u0442\u044C \u043F\u0443\u0441\u0442\u044B\u043C");
+    const live = this.#sessions.get(sessionId);
+    if (live) {
+      live.setTitle(title);
+      return;
+    }
+    const dir = workspaceId ? this.#workspaces.find(workspaceId)?.path : void 0;
+    await renameSession2(sessionId, title, dir ? { dir } : void 0);
+    if (!workspaceId)
+      return;
+    await this.#sendSessionList(workspaceId);
+  }
+  /**
+   * Сессии проекта — двумя списками: обычные и убранные в архив.
+   *
+   * Здесь же срабатывает авто-архивация: список пересобирается на каждое
+   * открытие проекта и на каждое изменение, и другого регулярного момента,
+   * когда о сроке молчания вообще есть кому вспомнить, у хоста нет — таймер
+   * ради этого был бы вторым источником тех же событий.
+   */
+  async #listSessions(workspaceId) {
+    const live = [...this.#sessions.values()].filter((s) => s.workspaceId === workspaceId && !s.parentSessionId).map((s) => s.summary());
+    const liveIds = new Set(live.flatMap((s) => s.claudeSessionId ? [s.id, s.claudeSessionId] : [s.id]));
+    const onDisk = await this.#workspaces.sessionsOnDisk(workspaceId);
+    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,
+      claudeSessionId: info.sessionId,
+      workspaceId,
+      cwd: info.cwd ?? workspacePath,
+      parentSessionId: null,
+      title: diskTitle(info),
+      state: "closed",
+      model: null,
+      permissionMode: "default",
+      // Сессия с диска не поднята: чем она была настроена, знает только её
+      // JSONL, а разбирать его ради выключенной строки в списке незачем.
+      effort: null,
+      ultracode: false,
+      thinking: true,
+      switchModelsOnFlag: true,
+      createdAt: info.lastModified,
+      updatedAt: info.lastModified,
+      lastSeq: 0,
+      totalCostUsd: 0
+    }));
+    await this.#archive.sweep(workspaceId, historical.map((s) => ({ id: s.id, updatedAt: s.updatedAt })), /* @__PURE__ */ new Set([...liveIds, ...historical.map((s) => s.id)]), this.#settings.current.autoArchiveAfterMs);
+    const sessions = [];
+    const archived = [];
+    for (const summary of [...live, ...historical].sort((a, b) => b.updatedAt - a.updatedAt)) {
+      const record = this.#archive.find(summary.claudeSessionId ?? summary.id);
+      if (!record) {
+        sessions.push(summary);
+        continue;
+      }
+      archived.push({ ...summary, archivedAt: record.at, archivedAuto: record.auto });
+    }
+    archived.sort((a, b) => (b.archivedAt ?? 0) - (a.archivedAt ?? 0));
+    return { sessions, archived };
+  }
+  // -------------------------------------------------------------------------
+  // Статика (собранный веб-UI)
+  // -------------------------------------------------------------------------
+  /**
+   * Один ответ, который не про статику: «здесь живёт ccv, версия такая-то».
+   *
+   * Нужен запуску из консоли. Занятый порт сам по себе не говорит ничего —
+   * слушать 8787 может что угодно, и открывать в браузере чужой сервер, приняв
+   * его за себя, хуже, чем честно сказать, что порт занят.
+   */
+  #serveHttp(req, res) {
+    const pathname = new URL(req.url ?? "/", "http://localhost").pathname;
+    if (pathname === "/api/health") {
+      res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
+      res.end(JSON.stringify({ app: "claude-code-visual", version: this.#options.version }));
+      return;
+    }
+    this.#serveStatic(req, res);
+  }
+  #serveStatic(req, res) {
+    const webRoot = this.#options.webRoot;
+    if (!webRoot || !existsSync3(webRoot)) {
+      res.writeHead(200, { "content-type": "text/plain; charset=utf-8" });
+      res.end("CCV host is running. UI is served by the Vite dev server.\n");
+      return;
+    }
+    const url2 = new URL(req.url ?? "/", "http://localhost");
+    const requested = path13.join(webRoot, path13.normalize(url2.pathname));
+    const target = requested.startsWith(webRoot) && existsSync3(requested) && statSync3(requested).isFile() ? requested : path13.join(webRoot, "index.html");
+    if (!existsSync3(target)) {
+      res.writeHead(404).end("not found");
+      return;
+    }
+    res.writeHead(200, { "content-type": contentType(target) });
+    createReadStream(target).pipe(res);
+  }
+};
+function diskTitle(info) {
+  return info.customTitle ?? info.summary ?? info.firstPrompt ?? null;
+}
+function parentOf(relative) {
+  const clean = normalize(relative);
+  const cut = clean.lastIndexOf("/");
+  return cut === -1 ? "" : clean.slice(0, cut);
+}
+function contentType(file) {
+  const types = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".woff2": "font/woff2"
+  };
+  return types[path13.extname(file)] ?? "application/octet-stream";
+}
+
+// dist/ccv.js
+var HERE = path14.dirname(fileURLToPath(import.meta.url));
+var PACKAGE_ROOT = path14.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:
+  ccv [\u043E\u043F\u0446\u0438\u0438]
+
+\u041E\u043F\u0446\u0438\u0438:
+  -p, --port <\u043F\u043E\u0440\u0442>    \u043F\u043E\u0440\u0442 \u0445\u043E\u0441\u0442\u0430 (\u043F\u043E \u0443\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E 8787)
+      --host <\u0430\u0434\u0440\u0435\u0441>   \u0430\u0434\u0440\u0435\u0441 \u043F\u0440\u043E\u0441\u043B\u0443\u0448\u0438\u0432\u0430\u043D\u0438\u044F (\u043F\u043E \u0443\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E 127.0.0.1)
+      --no-open        \u043D\u0435 \u043E\u0442\u043A\u0440\u044B\u0432\u0430\u0442\u044C \u0431\u0440\u0430\u0443\u0437\u0435\u0440
+      --claude         \u0447\u0435\u043C \u0431\u0443\u0434\u0443\u0442 \u043F\u043E\u0434\u043D\u0438\u043C\u0430\u0442\u044C\u0441\u044F \u0441\u0435\u0441\u0441\u0438\u0438, \u0438 \u0432\u044B\u0439\u0442\u0438
+  -v, --version        \u0432\u0435\u0440\u0441\u0438\u044F
+  -h, --help           \u044D\u0442\u0430 \u0441\u043F\u0440\u0430\u0432\u043A\u0430
+
+\u041E\u043A\u0440\u0443\u0436\u0435\u043D\u0438\u0435: CCV_PORT, CCV_HOST, CCV_DATA_DIR, CCV_WEB_ROOT, CCV_RELAY_URL,
+CCV_CLAUDE_PATH, CCV_BUNDLED_CLAUDE.
+\u0424\u043B\u0430\u0433 \u0432\u0430\u0436\u043D\u0435\u0435 \u043F\u0435\u0440\u0435\u043C\u0435\u043D\u043D\u043E\u0439 \u043E\u043A\u0440\u0443\u0436\u0435\u043D\u0438\u044F, \u043F\u0435\u0440\u0435\u043C\u0435\u043D\u043D\u0430\u044F \u0432\u0430\u0436\u043D\u0435\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u044F \u043F\u043E \u0443\u043C\u043E\u043B\u0447\u0430\u043D\u0438\u044E.`;
+var options = {
+  port: { type: "string", short: "p" },
+  host: { type: "string" },
+  open: { type: "boolean", default: true },
+  claude: { type: "boolean" },
+  version: { type: "boolean", short: "v" },
+  help: { type: "boolean", short: "h" }
+};
+var values;
+try {
+  ({ values } = parseArgs({ options, allowPositionals: false, allowNegative: true }));
+} catch (error) {
+  console.error(`[ccv] ${error instanceof Error ? error.message : String(error)}
+`);
+  console.error(USAGE);
+  process.exit(2);
+}
+var version = await packageVersion();
+if (values.help) {
+  console.log(USAGE);
+  process.exit(0);
+}
+if (values.version) {
+  console.log(version);
+  process.exit(0);
+}
+if (values.claude)
+  process.exit(await reportClaude());
+var defaults = envDefaults();
+var port = values.port === void 0 ? defaults.port : Number(values.port);
+if (!Number.isInteger(port) || port < 1 || port > 65535) {
+  console.error(`[ccv] \u043F\u043E\u0440\u0442 \u0434\u043E\u043B\u0436\u0435\u043D \u0431\u044B\u0442\u044C \u0447\u0438\u0441\u043B\u043E\u043C \u043E\u0442 1 \u0434\u043E 65535, \u0430 \u043D\u0435 \xAB${values.port}\xBB`);
+  process.exit(2);
+}
+var host = values.host ?? defaults.host;
+var reachable2 = host === "0.0.0.0" || host === "::" || host === "" ? "127.0.0.1" : host;
+var url = `http://${authority(reachable2)}:${port}`;
+var running = await health(url);
+if (running) {
+  console.log(`[ccv] \u0445\u043E\u0441\u0442 \u0443\u0436\u0435 \u0437\u0430\u043F\u0443\u0449\u0435\u043D: ${url}  (\u0432\u0435\u0440\u0441\u0438\u044F ${running})`);
+  if (values.open)
+    openBrowser(url);
+  process.exit(0);
+}
+var server = new HostServer({
+  port,
+  host,
+  dataDir: defaults.dataDir,
+  // UI лежит в пакете рядом с бандлом — это и есть разница между установленной
+  // утилитой и запуском из репозитория, где сборка живёт в `apps/web/dist`.
+  webRoot: process.env.CCV_WEB_ROOT ?? path14.join(PACKAGE_ROOT, "web"),
+  version,
+  relayUrl: defaults.relayUrl
+});
+try {
+  await server.start();
+} catch (error) {
+  const code = error.code;
+  if (code === "EADDRINUSE") {
+    console.error(`[ccv] \u043F\u043E\u0440\u0442 ${port} \u0437\u0430\u043D\u044F\u0442 \u0434\u0440\u0443\u0433\u043E\u0439 \u043F\u0440\u043E\u0433\u0440\u0430\u043C\u043C\u043E\u0439 \u2014 \u0432\u044B\u0431\u0435\u0440\u0438\u0442\u0435 \u0434\u0440\u0443\u0433\u043E\u0439: ccv --port 8788`);
+  } else if (code === "EACCES") {
+    console.error(`[ccv] \u043D\u0435\u0442 \u043F\u0440\u0430\u0432 \u0441\u043B\u0443\u0448\u0430\u0442\u044C ${host}:${port}`);
+  } else {
+    console.error(`[ccv] \u043D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0437\u0430\u043F\u0443\u0441\u0442\u0438\u0442\u044C \u0445\u043E\u0441\u0442: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  process.exit(1);
+}
+console.log(`[ccv] \u0445\u043E\u0441\u0442 \u0441\u043B\u0443\u0448\u0430\u0435\u0442 ${url}  (ws: /ws)`);
+console.log(`[ccv] \u0434\u0430\u043D\u043D\u044B\u0435: ${defaults.dataDir}`);
+console.log("[ccv] \u043E\u0441\u0442\u0430\u043D\u043E\u0432\u0438\u0442\u044C \u2014 Ctrl+C");
+if (values.open)
+  openBrowser(url);
+for (const signal of ["SIGINT", "SIGTERM"]) {
+  process.on(signal, () => {
+    void server.shutdown().finally(() => process.exit(0));
+  });
+}
+async function packageVersion() {
+  try {
+    const text = await readFile10(path14.join(PACKAGE_ROOT, "package.json"), "utf8");
+    return JSON.parse(text).version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+async function reportClaude() {
+  await warmClaudeLauncher();
+  const found = claudeExecutable();
+  if (found.source === "forced") {
+    console.log("[ccv] CCV_BUNDLED_CLAUDE \u0437\u0430\u0434\u0430\u043D \u2014 \u0441\u0435\u0441\u0441\u0438\u0438 \u043F\u043E\u0434\u043D\u0438\u043C\u0435\u0442 \u0431\u0438\u043D\u0430\u0440\u043D\u0438\u043A \u0438\u0437 Agent SDK");
+    return 0;
+  }
+  if (found.source === "bundled") {
+    console.log("[ccv] Claude Code \u0432 \u0441\u0438\u0441\u0442\u0435\u043C\u0435 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D \u2014 \u0441\u0435\u0441\u0441\u0438\u0438 \u043F\u043E\u0434\u043D\u0438\u043C\u0435\u0442 \u0431\u0438\u043D\u0430\u0440\u043D\u0438\u043A \u0438\u0437 Agent SDK");
+    console.log("[ccv] \u0441\u0430\u043C Claude Code: https://claude.com/claude-code");
+    return 1;
+  }
+  const via = found.executable ? `${found.executable} ${found.path}` : found.path;
+  const how = found.source === "env" ? "\u0443\u043A\u0430\u0437\u0430\u043D \u0432 CCV_CLAUDE_PATH" : "\u043D\u0430\u0439\u0434\u0435\u043D \u0432 \u0441\u0438\u0441\u0442\u0435\u043C\u0435";
+  console.log(`[ccv] \u0441\u0435\u0441\u0441\u0438\u0438 \u043F\u043E\u0434\u043D\u0438\u043C\u0430\u0435\u0442 Claude Code, ${how}: ${via}`);
+  return 0;
+}
+function authority(address) {
+  const bare = address.replace(/^\[|\]$/g, "");
+  return bare.includes(":") ? `[${bare}]` : bare;
+}
+async function health(base) {
+  try {
+    const response = await fetch(`${base}/api/health`, { signal: AbortSignal.timeout(1500) });
+    if (!response.ok)
+      return null;
+    const body = await response.json();
+    return body.app === "claude-code-visual" ? body.version ?? "\u043D\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043D\u0430" : null;
+  } catch {
+    return null;
+  }
+}
+function openBrowser(target) {
+  if (!/^http:\/\/[A-Za-z0-9.\-[\]]+:\d+$/.test(target)) {
+    console.log(`[ccv] \u043E\u0442\u043A\u0440\u043E\u0439\u0442\u0435 \u0432 \u0431\u0440\u0430\u0443\u0437\u0435\u0440\u0435: ${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, {
+    stdio: "ignore",
+    detached: true,
+    windowsHide: true
+  });
+  child.on("error", () => {
+  });
+  child.unref();
+}