@i14ks/ccv 0.1.0 → 0.3.0

package/bundle/ccv.mjs

@@ -2,8 +2,8 @@
 
 // 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 { readFile as readFile11 } from "node:fs/promises";
+import path16 from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 
@@ -146,9 +146,9 @@ function envDefaults() {
 // ../host/dist/server.js
 import { createServer } from "node:http";
 import { createReadStream, existsSync as existsSync3, statSync as statSync3 } from "node:fs";
-import path13 from "node:path";
+import path15 from "node:path";
 import { homedir as homedir5 } from "node:os";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { WebSocketServer } from "ws";
 import { renameSession as renameSession2 } from "@anthropic-ai/claude-agent-sdk";
 
@@ -628,6 +628,184 @@ async function readSettings(file) {
   }
 }
 
+// ../host/dist/transcript.js
+import { getSessionMessages } from "@anthropic-ai/claude-agent-sdk";
+var RESULT_LIMIT = 4e3;
+var INPUT_LIMIT = 2e4;
+var CUT = "\n\u2026 (\u043E\u0431\u0440\u0435\u0437\u0430\u043D\u043E)";
+async function readTranscript(sessionId, options2) {
+  let messages;
+  try {
+    messages = await getSessionMessages(sessionId, {
+      dir: options2.dir,
+      includeSystemMessages: true
+    });
+  } catch {
+    return [];
+  }
+  const entries = [];
+  const blockCounts = /* @__PURE__ */ new Map();
+  let seq = 0;
+  const record = (event, ts) => {
+    entries.push({ seq: ++seq, ts, event });
+  };
+  for (const message of messages) {
+    if (message.parent_tool_use_id !== null || message.parent_agent_id !== null)
+      continue;
+    const ts = timestampOf(message);
+    if (ts >= options2.until)
+      continue;
+    if (message.type === "system") {
+      if (subtypeOf(message) === "compact_boundary") {
+        record({ kind: "system", subtype: "compact_boundary", data: {} }, ts);
+      }
+      continue;
+    }
+    const content = contentOf(message);
+    if (message.type === "user") {
+      if (typeof content === "string") {
+        const text = humanText(content);
+        if (text)
+          record({ kind: "user.message", text }, ts);
+        continue;
+      }
+      for (const block of content) {
+        if (block.type === "text" && typeof block.text === "string") {
+          const text = humanText(block.text);
+          if (text)
+            record({ kind: "user.message", text }, ts);
+        } else if (block.type === "tool_result") {
+          record({
+            kind: "tool.result",
+            toolUseId: String(block.tool_use_id ?? ""),
+            content: clip(contentToText(block.content), RESULT_LIMIT),
+            isError: block.is_error === true
+          }, ts);
+        }
+      }
+      continue;
+    }
+    const messageId = messageIdOf(message);
+    if (typeof content === "string") {
+      if (content)
+        record({ kind: "assistant.text", text: content, blockId: `${messageId}:0` }, ts);
+      continue;
+    }
+    for (const block of content) {
+      const blockId = `${messageId}:${nextBlockIndex(blockCounts, messageId)}`;
+      if (block.type === "text" && typeof block.text === "string") {
+        if (!block.text)
+          continue;
+        if (synthetic(message)) {
+          record({ kind: "error", message: block.text }, ts);
+        } else {
+          record({ kind: "assistant.text", text: block.text, blockId }, ts);
+        }
+      } else if (block.type === "thinking") {
+        const text = typeof block.thinking === "string" ? block.thinking : "";
+        if (text)
+          record({ kind: "assistant.thinking", text, blockId }, ts);
+      } else if (block.type === "tool_use") {
+        record({
+          kind: "tool.use",
+          toolUseId: String(block.id ?? ""),
+          name: String(block.name ?? ""),
+          input: clipInput(block.input)
+        }, ts);
+      }
+    }
+  }
+  return entries;
+}
+function asObject(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+function contentOf(message) {
+  const content = asObject(message.message)?.content;
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return [];
+  return content.filter((block) => typeof block === "object" && block !== null);
+}
+function messageIdOf(message) {
+  const id = asObject(message.message)?.id;
+  return typeof id === "string" ? id : message.uuid;
+}
+function synthetic(message) {
+  return asObject(message.message)?.model === "<synthetic>";
+}
+function subtypeOf(message) {
+  const subtype = message.subtype;
+  return typeof subtype === "string" ? subtype : "";
+}
+function timestampOf(message) {
+  const raw = message.timestamp;
+  if (typeof raw !== "string")
+    return 0;
+  const ts = Date.parse(raw);
+  return Number.isNaN(ts) ? 0 : ts;
+}
+function nextBlockIndex(counts, messageId) {
+  const index = counts.get(messageId) ?? 0;
+  counts.set(messageId, index + 1);
+  return index;
+}
+var ENVELOPE = /^\s*<(local-command-caveat|local-command-stdout|system-reminder|task-notification|command-message|command-args)\b/;
+var SLASH_COMMAND = /^\s*<command-name>([^<]*)<\/command-name>/;
+var SLASH_ARGS = /<command-args>([^<]*)<\/command-args>/;
+function humanText(raw) {
+  const slash = SLASH_COMMAND.exec(raw);
+  if (slash) {
+    const name = (slash[1] ?? "").trim();
+    const args = (SLASH_ARGS.exec(raw)?.[1] ?? "").trim();
+    return args ? `${name} ${args}` : name;
+  }
+  if (ENVELOPE.test(raw))
+    return "";
+  const text = raw.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").trim();
+  if (/^\[Image: /.test(text))
+    return "";
+  return text;
+}
+function contentToText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.map((block) => {
+    if (typeof block === "string")
+      return block;
+    const item = asObject(block);
+    if (!item)
+      return "";
+    if (typeof item.text === "string")
+      return item.text;
+    if (typeof item.type === "string")
+      return `[${item.type}]`;
+    return "";
+  }).join("");
+}
+function clip(text, limit) {
+  return text.length > limit ? text.slice(0, limit) + CUT : text;
+}
+function clipInput(input) {
+  const object = asObject(input);
+  if (!object)
+    return input;
+  let changed = false;
+  const clipped = {};
+  for (const [key, value] of Object.entries(object)) {
+    if (typeof value === "string" && value.length > INPUT_LIMIT) {
+      clipped[key] = clip(value, INPUT_LIMIT);
+      changed = true;
+    } else {
+      clipped[key] = value;
+    }
+  }
+  return changed ? clipped : input;
+}
+
 // ../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.";
@@ -646,6 +824,80 @@ function writeTarget(input) {
   const target = record.file_path ?? record.notebook_path;
   return typeof target === "string" && target ? target : null;
 }
+var ASK_QUESTION_TOOL = "AskUserQuestion";
+var ABORTED_REASONS = /* @__PURE__ */ new Set(["aborted_streaming", "aborted_tools"]);
+var STOPPED_REASONS = /* @__PURE__ */ new Set([
+  "max_turns",
+  "budget_exhausted",
+  "stop_hook_prevented",
+  "hook_stopped",
+  "tool_deferred",
+  "tool_deferred_unavailable",
+  "background_requested"
+]);
+function turnOutcome(terminalReason, subtype, interruptRequested) {
+  if (terminalReason && ABORTED_REASONS.has(terminalReason))
+    return "interrupted";
+  if (terminalReason && STOPPED_REASONS.has(terminalReason))
+    return "stopped";
+  if (subtype === "success")
+    return "completed";
+  if (interruptRequested)
+    return "interrupted";
+  if (subtype === "error_max_turns" || subtype === "error_max_budget_usd")
+    return "stopped";
+  return "failed";
+}
+function parseQuestions(input) {
+  if (typeof input !== "object" || input === null)
+    return null;
+  const raw = input.questions;
+  if (!Array.isArray(raw) || raw.length === 0)
+    return null;
+  const questions = [];
+  for (const item of raw) {
+    if (typeof item !== "object" || item === null)
+      return null;
+    const { question, header, options: options2, multiSelect } = item;
+    if (typeof question !== "string" || !question)
+      return null;
+    if (!Array.isArray(options2) || options2.length === 0)
+      return null;
+    const parsed = [];
+    for (const option of options2) {
+      if (typeof option !== "object" || option === null)
+        return null;
+      const { label, description, preview } = option;
+      if (typeof label !== "string" || !label)
+        return null;
+      parsed.push({
+        label,
+        description: typeof description === "string" ? description : "",
+        ...typeof preview === "string" && preview ? { preview } : {}
+      });
+    }
+    questions.push({
+      question,
+      header: typeof header === "string" ? header : "",
+      options: parsed,
+      multiSelect: multiSelect === true
+    });
+  }
+  return questions;
+}
+function previewAnnotations(questions, answers) {
+  const annotations = {};
+  for (const question of questions) {
+    const answer = answers[question.question];
+    if (!answer)
+      continue;
+    const chosen = question.options.filter((option) => answer.split(", ").includes(option.label));
+    if (chosen.length !== 1 || !chosen[0]?.preview)
+      continue;
+    annotations[question.question] = { preview: chosen[0].preview };
+  }
+  return annotations;
+}
 var USAGE_MIN_INTERVAL_MS = 2e4;
 var ClaudeSession = class extends EventEmitter {
   id;
@@ -653,10 +905,47 @@ var ClaudeSession = class extends EventEmitter {
   cwd;
   journal = new Journal();
   #query = null;
+  /**
+   * Разговор, который был до нас, — прочитанный транскрипт продолженной сессии.
+   *
+   * Читается один раз, на старте, и больше не меняется: всё, что случится
+   * дальше, попадает в журнал. Промис, а не массив, потому что чтение
+   * асинхронное, а спросить историю могут раньше, чем оно закончится, — тогда
+   * запрос дождётся того же чтения вместо второго такого же. `null` — сессия
+   * начата с нуля, и продолжать нечего.
+   */
+  #history = null;
   /** Чем подняли эту сессию — нужно, чтобы объяснить провал старта. */
   #executable = { source: "bundled" };
   #inbox = new AsyncQueue();
+  /**
+   * Размер контекста на последнем запросе к API — то, что показывает полоса
+   * контекста в UI.
+   *
+   * Считается здесь, а не в UI из `result.usage`: SDK складывает в него все
+   * запросы хода разом, и разделить их обратно уже нечем. Usage
+   * `assistant`-сообщения, наоборот, всегда про один запрос — запоминаем
+   * последнее и отдаём его вместе с `result`.
+   */
+  #contextTokens = null;
   #state = "starting";
+  /**
+   * Чем кончился последний ход — см. `TurnOutcome` в протоколе.
+   *
+   * Обновляется на `result`, обнуляется новым промптом: свежий ход ещё ничем не
+   * кончился, и прошлый исход рядом с ним читался бы как исход этого.
+   */
+  #lastTurn = null;
+  /**
+   * Человек нажал «Стоп» — до того, как пришёл `result` этого хода.
+   *
+   * Запасной путь к «прервали»: обычно исход виден по `terminal_reason`
+   * (`aborted_streaming`/`aborted_tools`, проверено пробой), но поле
+   * необязательное, а версия CLI живёт отдельно от нашей. Тогда решает флаг:
+   * если мы сами только что просили прервать, оборвавшийся ход — прерванный, а
+   * не упавший.
+   */
+  #interruptRequested = false;
   #capabilities = null;
   #pendingPermissions = /* @__PURE__ */ new Map();
   #model = null;
@@ -755,6 +1044,16 @@ var ClaudeSession = class extends EventEmitter {
   get usage() {
     return this.#usage;
   }
+  /**
+   * Разговор, который был до старта этой сессии, — целиком и по порядку.
+   *
+   * Пустой массив у сессии, начатой с нуля. Ждёт чтения транскрипта, если оно
+   * ещё идёт: клиент спрашивает историю сразу после открытия сессии, и ответ
+   * «пока пусто» он принял бы за «истории нет».
+   */
+  async history() {
+    return await this.#history ?? [];
+  }
   summary() {
     return {
       id: this.id,
@@ -764,6 +1063,7 @@ var ClaudeSession = class extends EventEmitter {
       parentSessionId: this.parentSessionId,
       title: this.#title,
       state: this.#state,
+      lastTurn: this.#lastTurn,
       model: this.#model,
       permissionMode: this.#permissionMode,
       effort: this.#effort,
@@ -782,6 +1082,10 @@ var ClaudeSession = class extends EventEmitter {
   start() {
     if (this.#query)
       throw new Error("session already started");
+    if (this.#options.resume && !this.#options.fork) {
+      const until = Date.now();
+      this.#history = readTranscript(this.#options.resume, { dir: this.cwd, until });
+    }
     const options2 = {
       cwd: this.cwd,
       // Без этого SDK не читает с диска ничего: ни CLAUDE.md, ни кастомные
@@ -891,6 +1195,8 @@ var ClaudeSession = class extends EventEmitter {
       });
       return;
     }
+    this.#lastTurn = null;
+    this.#interruptRequested = false;
     this.#setState("running");
     this.#inbox.push({
       type: "user",
@@ -898,17 +1204,46 @@ var ClaudeSession = class extends EventEmitter {
       parent_tool_use_id: null
     });
   }
-  respondPermission(requestId, decision, reason) {
+  /**
+   * Ответ человека на запрос прав — он же ответ на вопрос агента.
+   *
+   * `answers` осмысленны только для `AskUserQuestion`: там разрешение и есть
+   * ответ, и выбранное надо вернуть инструменту в его же аргументах. Схема
+   * аргументов у него строгая (`strictObject`), поэтому дописываем ровно те
+   * поля, которые она знает, — лишнее уронило бы вызов ZodError'ом там, где
+   * человек только что нажал кнопку.
+   */
+  respondPermission(requestId, decision, reason, answers, annotations) {
     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 });
+    const answered = pending.questions && answers ? answers : null;
+    let input = pending.input;
+    if (answered) {
+      const withPreviews = {
+        ...previewAnnotations(pending.questions ?? [], answered),
+        ...annotations
+      };
+      input = {
+        ...pending.input,
+        answers: answered,
+        ...Object.keys(withPreviews).length > 0 ? { annotations: withPreviews } : {}
+      };
+    }
+    pending.resolve(decision === "allow" ? { behavior: "allow", updatedInput: 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,
+      ...answered ? { answers: answered } : {}
+    });
     if (this.#pendingPermissions.size === 0)
       this.#setState("running");
   }
   async interrupt() {
+    this.#interruptRequested = true;
     await this.#query?.interrupt();
   }
   /**
@@ -1115,7 +1450,7 @@ var ClaudeSession = class extends EventEmitter {
     const pass = { continue: true };
     if (!this.workspaceId)
       return pass;
-    const roots = this.#options.writableRoots?.() ?? [this.cwd];
+    const roots = this.#options.writableRoots ? this.#options.writableRoots() : [this.cwd];
     if (roots === null)
       return pass;
     const target = writeTarget(input.tool_input);
@@ -1135,7 +1470,23 @@ var ClaudeSession = class extends EventEmitter {
       }
     };
   };
-  #canUseTool = (toolName, input, { signal, decisionReason }) => {
+  /**
+   * Мост между `canUseTool` из SDK и решением человека в UI.
+   *
+   * Сюда же приходит и `AskUserQuestion` — вопрос агента с вариантами ответа.
+   * Отдельного канала для него в SDK нет и не нужно: CLI объявляет этот
+   * инструмент как `requiresUserInteraction`, а такой всегда попадает в
+   * `canUseTool`, в любом режиме прав, — даже в `bypassPermissions`, где всё
+   * остальное проходит молча. Проверка стоит раньше разбора режима, так что
+   * вопрос не потеряется ни в одном из них.
+   *
+   * Разрешение для него значит не «выполняй», а «вот ответ»: выбранное
+   * возвращается в `updatedInput.answers`, и уже с ним инструмент выполняется
+   * и складывает ответ в результат вызова. Пустой `answers` (то есть простое
+   * «Разрешить») инструмент понимает как «человек не стал отвечать» — ровно
+   * это и происходило, пока вопросы показывались обычной карточкой прав.
+   */
+  #canUseTool = (toolName, input, { signal, decisionReason, toolUseID }) => {
     if (this.#options.readOnly) {
       this.#record({
         kind: "error",
@@ -1147,8 +1498,9 @@ var ClaudeSession = class extends EventEmitter {
       });
     }
     const requestId = randomUUID();
+    const questions = toolName === ASK_QUESTION_TOOL ? parseQuestions(input) : null;
     return new Promise((resolve) => {
-      this.#pendingPermissions.set(requestId, { resolve, toolName, input });
+      this.#pendingPermissions.set(requestId, { resolve, toolName, input, questions });
       this.#setState("waiting_permission");
       this.#record({
         kind: "permission.request",
@@ -1157,8 +1509,11 @@ var ClaudeSession = class extends EventEmitter {
         input,
         // Причину даёт не всякий запрос: обычный вопрос в режиме `default`
         // объясняется самим режимом, а вот запрос, поднятый хуком поверх
-        // разрешающего режима, без неё выглядит сбоем.
-        ...decisionReason ? { reason: decisionReason } : {}
+        // разрешающего режима, без неё выглядит сбоем. Вопросу агента причина
+        // не нужна вовсе: CLI объясняет его технически («requiresUserInteraction»),
+        // а спрашивают тут не «почему», а «что выбрать».
+        ...decisionReason && !questions ? { reason: decisionReason } : {},
+        ...questions ? { questions, toolUseId: toolUseID } : {}
       });
       signal.addEventListener("abort", () => {
         if (!this.#pendingPermissions.delete(requestId))
@@ -1207,6 +1562,10 @@ var ClaudeSession = class extends EventEmitter {
         this.#handleSystem(message);
         break;
       case "assistant":
+        if (message.parent_tool_use_id === null && message.message.usage) {
+          const usage = message.message.usage;
+          this.#contextTokens = (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+        }
         for (const block of message.message.content) {
           const blockId = `${message.message.id}:${this.#nextBlockIndex(message.message.id)}`;
           if (block.type === "text") {
@@ -1250,6 +1609,7 @@ var ClaudeSession = class extends EventEmitter {
           durationMs: message.duration_ms,
           costUsd: message.total_cost_usd ?? null,
           usage,
+          contextTokens: this.#contextTokens,
           text: "result" in message ? message.result : null
         });
         if (this.#options.outputFormat) {
@@ -1258,7 +1618,12 @@ var ClaudeSession = class extends EventEmitter {
             text: "result" in message ? message.result : null
           });
         }
+        this.#lastTurn = turnOutcome("terminal_reason" in message ? message.terminal_reason : void 0, message.subtype, this.#interruptRequested);
+        this.#interruptRequested = false;
+        const alreadyIdle = this.#state === "idle";
         this.#setState("idle");
+        if (alreadyIdle)
+          this.emit("summary", this.summary());
         if (this.#unpersistedTitle)
           void this.#persistTitle();
         void this.refreshUsage();
@@ -1371,7 +1736,7 @@ var ClaudeSession = class extends EventEmitter {
       this.#record({
         kind: "tool.result",
         toolUseId: block.tool_use_id,
-        content: contentToText(block.content),
+        content: contentToText2(block.content),
         isError: block.is_error === true
       });
     }
@@ -1452,7 +1817,7 @@ function toUsageWindow(raw) {
     resetsAt: typeof raw.resets_at === "string" ? raw.resets_at : ""
   };
 }
-function contentToText(content) {
+function contentToText2(content) {
   if (typeof content === "string")
     return content;
   if (!Array.isArray(content))
@@ -1833,9 +2198,9 @@ function parsePatch(raw) {
       body = "";
     }
     total += body.length;
-    const path15 = status === "deleted" ? oldPath : newPath || oldPath;
+    const path17 = status === "deleted" ? oldPath : newPath || oldPath;
     files.push({
-      path: path15,
+      path: path17,
       oldPath: status === "renamed" ? oldPath : "",
       status,
       added: count(body, "+"),
@@ -1847,10 +2212,10 @@ function parsePatch(raw) {
   return { files, truncated };
 }
 function stripPrefix(value) {
-  const path15 = unquote(value.trim());
-  if (path15 === "/dev/null")
+  const path17 = unquote(value.trim());
+  if (path17 === "/dev/null")
     return "";
-  return path15.replace(/^[ab]\//, "");
+  return path17.replace(/^[ab]\//, "");
 }
 function count(body, mark) {
   let n = 0;
@@ -2423,28 +2788,166 @@ function isRecord(value) {
   return typeof value === "object" && value !== null && typeof value.workspaceId === "string" && typeof value.at === "number";
 }
 
-// ../host/dist/app-settings.js
+// ../host/dist/pins.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 SessionPins = class {
+  #pinned = /* @__PURE__ */ new Map();
+  #storePath;
+  constructor(dataDir) {
+    this.#storePath = path9.join(dataDir, "session-pins.json");
+  }
+  async load() {
+    try {
+      const raw = await readFile6(this.#storePath, "utf8");
+      const parsed = JSON.parse(raw);
+      this.#pinned = new Map(Object.entries(parsed.pinned ?? {}).filter(([, r]) => isRecord2(r)));
+    } catch {
+      this.#pinned = /* @__PURE__ */ new Map();
+    }
+  }
+  find(sessionId) {
+    return this.#pinned.get(sessionId);
+  }
+  has(sessionId) {
+    return this.#pinned.has(sessionId);
+  }
+  /** Проекты, в которых есть хоть что-то закреплённое, — по ним собирается панель. */
+  workspaceIds() {
+    return [...new Set([...this.#pinned.values()].map((r) => r.workspaceId))];
+  }
+  /** Закрепить или снять закрепление. Возвращает `true`, если что-то изменилось. */
+  async set(workspaceId, sessionIds, pinned) {
+    let changed = false;
+    const at = Date.now();
+    for (const id of sessionIds) {
+      if (pinned) {
+        if (this.#pinned.has(id))
+          continue;
+        this.#pinned.set(id, { workspaceId, at });
+      } else if (!this.#pinned.delete(id)) {
+        continue;
+      }
+      changed = true;
+    }
+    if (changed)
+      await this.#persist();
+    return changed;
+  }
+  /**
+   * Перенести закрепление с локального uuid на настоящий id Claude Code.
+   *
+   * Свежую сессию закрепляют до первого обмена — тогда её дискового id ещё не
+   * существует, и в реестр попадает временный uuid. Как только id появился,
+   * запись обязана переехать на него: под uuid сессию не найдёт ни список
+   * (`#listSessions` ищет закрепление по дисковому id), ни следующий запуск
+   * хоста — там этого uuid нет вовсе, и подметание стёрло бы закрепление
+   * молча.
+   *
+   * Время закрепления переносится как есть: порядок в панели задан им, и
+   * строка не должна прыгать в конец списка от того, что сессия наконец
+   * дошла до `system/init`.
+   */
+  async migrate(fromId, toId) {
+    const record = this.#pinned.get(fromId);
+    if (!record || fromId === toId)
+      return false;
+    this.#pinned.delete(fromId);
+    if (!this.#pinned.has(toId))
+      this.#pinned.set(toId, record);
+    await this.#persist();
+    return true;
+  }
+  /**
+   * Забыть записи о сессиях, которых больше нет на диске.
+   *
+   * Зовётся оттуда же, откуда подметается архив, и делает то же самое: реестр
+   * не должен копить ссылки на исчезнувшие транскрипты. `known` — все сессии
+   * проекта, живые и с диска.
+   */
+  async sweep(workspaceId, known) {
+    let changed = false;
+    for (const [id, record] of this.#pinned) {
+      if (record.workspaceId !== workspaceId || known.has(id))
+        continue;
+      this.#pinned.delete(id);
+      changed = true;
+    }
+    if (changed)
+      await this.#persist();
+    return changed;
+  }
+  /**
+   * Забыть всё закреплённое в проекте — при его закрытии.
+   *
+   * Закрытый проект не показывается нигде, и закреплённая сессия из него
+   * висела бы в панели строкой, по клику на которую открывать нечего.
+   */
+  async forgetWorkspace(workspaceId) {
+    let changed = false;
+    for (const [id, record] of this.#pinned) {
+      if (record.workspaceId !== workspaceId)
+        continue;
+      this.#pinned.delete(id);
+      changed = true;
+    }
+    if (changed)
+      await this.#persist();
+    return changed;
+  }
+  async #persist() {
+    const file = { pinned: Object.fromEntries(this.#pinned) };
+    await mkdir4(path9.dirname(this.#storePath), { recursive: true });
+    await writeFile4(this.#storePath, JSON.stringify(file, null, 2), "utf8");
+  }
+};
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && typeof value.workspaceId === "string" && typeof value.at === "number";
+}
+
+// ../host/dist/app-settings.js
+import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile5 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import path10 from "node:path";
 var DEFAULT_AUTO_ARCHIVE_AFTER_MS = 2 * 24 * 60 * 60 * 1e3;
 var MIN_AUTO_ARCHIVE_AFTER_MS = 60 * 60 * 1e3;
+var MIN_AUTO_SAVE_AFTER_PAUSE_MS = 500;
 var FOLDER_ACCESS = ["all", "projects", "project"];
+var PERMISSION_MODES = [
+  "default",
+  "acceptEdits",
+  "plan",
+  "dontAsk",
+  "bypassPermissions",
+  "auto"
+];
 var DEFAULT_APP_SETTINGS = {
   autoArchiveAfterMs: DEFAULT_AUTO_ARCHIVE_AFTER_MS,
   // Строгий режим по умолчанию: молча писать в чужой проект приложение начнёт
   // только после того, как об этом попросили явно.
-  folderAccess: "project"
+  folderAccess: "project",
+  // Выключено по умолчанию: сохранение — явное действие, пока человек сам не
+  // попросил иначе.
+  autoSaveAfterPauseMs: 0,
+  // Модель за пользователя не выбираем: пока он не сказал иначе, сессия
+  // поднимается ровно с той, с которой её поднял бы консольный Claude Code.
+  startModel: null,
+  // Тот же режим, с которым сессия стартовала до появления этой настройки.
+  startPermissionMode: "default",
+  // Терминал по умолчанию закрыт — его включают, а не выключают: приложение,
+  // открытое в браузере, не обязано с первого запуска уметь запускать на этой
+  // машине что угодно.
+  terminalEnabled: false
 };
 var AppSettingsStore = class {
   #settings = { ...DEFAULT_APP_SETTINGS };
   #storePath;
   constructor(dataDir) {
-    this.#storePath = path9.join(dataDir, "app-settings.json");
+    this.#storePath = path10.join(dataDir, "app-settings.json");
   }
   async load() {
     try {
-      const raw = await readFile6(this.#storePath, "utf8");
+      const raw = await readFile7(this.#storePath, "utf8");
       this.#settings = sanitize(JSON.parse(raw), DEFAULT_APP_SETTINGS);
     } catch {
       this.#settings = { ...DEFAULT_APP_SETTINGS };
@@ -2464,8 +2967,8 @@ var AppSettingsStore = class {
   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");
+    await mkdir5(path10.dirname(this.#storePath), { recursive: true });
+    await writeFile5(this.#storePath, JSON.stringify(next, null, 2), "utf8");
     return this.current;
   }
 };
@@ -2478,14 +2981,32 @@ function sanitize(value, fallback) {
   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;
+  const access3 = record.folderAccess;
+  if (typeof access3 === "string" && FOLDER_ACCESS.includes(access3)) {
+    result.folderAccess = access3;
+  }
+  const autoSave = record.autoSaveAfterPauseMs;
+  if (typeof autoSave === "number" && Number.isFinite(autoSave)) {
+    result.autoSaveAfterPauseMs = autoSave <= 0 ? 0 : Math.max(Math.round(autoSave), MIN_AUTO_SAVE_AFTER_PAUSE_MS);
+  }
+  if ("startModel" in record) {
+    const model = record.startModel;
+    if (model === null)
+      result.startModel = null;
+    else if (typeof model === "string")
+      result.startModel = model.trim() || null;
+  }
+  const mode = record.startPermissionMode;
+  if (typeof mode === "string" && PERMISSION_MODES.includes(mode)) {
+    result.startPermissionMode = mode;
+  }
+  if (typeof record.terminalEnabled === "boolean") {
+    result.terminalEnabled = record.terminalEnabled;
   }
   return result;
 }
 function claudeHome() {
-  return path9.join(homedir3(), ".claude");
+  return path10.join(homedir3(), ".claude");
 }
 function writableRoots(mode, cwd, workspacePaths) {
   if (mode === "all")
@@ -2495,7 +3016,7 @@ function writableRoots(mode, cwd, workspacePaths) {
     return [...roots];
   for (const workspace of [cwd, ...workspacePaths]) {
     roots.add(workspace);
-    const parent = path9.dirname(workspace);
+    const parent = path10.dirname(workspace);
     if (parent !== workspace)
       roots.add(parent);
   }
@@ -2503,9 +3024,9 @@ function writableRoots(mode, cwd, workspacePaths) {
 }
 
 // ../host/dist/plugins.js
-import { readFile as readFile7 } from "node:fs/promises";
+import { readFile as readFile8 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import path10 from "node:path";
+import path11 from "node:path";
 var TIMEOUT_MS2 = 12e4;
 var SAFE_ARG = /^[A-Za-z0-9][A-Za-z0-9._@/-]*$/;
 var PluginCli = class {
@@ -2604,10 +3125,10 @@ async function readCatalog(markets, installed) {
   return lists.flat().sort((a, b) => a.name.localeCompare(b.name));
 }
 async function readMarketplace(market, installed) {
-  const root = market.installLocation || path10.join(homedir4(), ".claude", "plugins", "marketplaces", market.name);
+  const root = market.installLocation || path11.join(homedir4(), ".claude", "plugins", "marketplaces", market.name);
   let manifest;
   try {
-    const text = await readFile7(path10.join(root, ".claude-plugin", "marketplace.json"), "utf8");
+    const text = await readFile8(path11.join(root, ".claude-plugin", "marketplace.json"), "utf8");
     manifest = JSON.parse(text);
   } catch {
     return [];
@@ -2818,8 +3339,8 @@ function describe3(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 { readFile as readFile9, writeFile as writeFile6, rm as rm2, mkdir as mkdir6 } from "node:fs/promises";
+import path12 from "node:path";
 import { hostname } from "node:os";
 import WebSocket from "ws";
 
@@ -2841,13 +3362,26 @@ var RelayLink = class extends EventEmitter3 {
   #clients = /* @__PURE__ */ new Set();
   #error = null;
   #closed = false;
+  /**
+   * Право удалённого терминала — то, что нам сказал relay, и ничего больше.
+   *
+   * На диск не пишется намеренно, в отличие от токена сопряжения: правда о
+   * праве живёт на relay, а кеш на диске означал бы, что хост, поднятый без
+   * связи, сам себе разрешает то, что мог отозвать другой человек час назад.
+   * Поэтому после каждого запуска право закрыто, пока relay не пришлёт
+   * `shell.state`, — и это ничего не стоит: удалённых вкладок до связи с relay
+   * всё равно нет. Обрыв связи состояние не гасит по обратной причине: гасить
+   * нечего (вкладок снова нет), а мигание «выключено» в настройках от каждого
+   * зевка сети означало бы звать человека чинить то, что чинится само.
+   */
+  #shell = { enabled: false, pending: false, email: null, confirmedAt: null };
   /** Куда сопрягаться, пока не сопряглись. */
   #defaultUrl;
   #file;
   #log;
   constructor(options2) {
     super();
-    this.#file = path11.join(options2.dataDir, "relay.json");
+    this.#file = path12.join(options2.dataDir, "relay.json");
     this.#defaultUrl = options2.defaultUrl.replace(/\/+$/, "");
     this.#log = options2.log ?? ((msg) => console.log(`[relay] ${msg}`));
   }
@@ -2862,9 +3396,57 @@ var RelayLink = class extends EventEmitter3 {
       name: this.#credentials?.name ?? null,
       hostId: this.#credentials?.hostId ?? null,
       clients: this.#clients.size,
+      shell: this.#shell,
       error: this.#error
     };
   }
+  /** Право удалённого терминала — им же гейтится каждый кадр `term.*` от удалённой вкладки. */
+  get shell() {
+    return this.#shell;
+  }
+  /**
+   * Включить удалённый терминал прямо сейчас — вызывается только для запроса,
+   * пришедшего с локального сокета.
+   *
+   * Решение «локально или удалённо» принимает `HostServer`, а не этот класс:
+   * здесь уже нечем отличить одно от другого, а там это ровно то поле
+   * `ClientChannel.local`, ради которого канал и заведён.
+   */
+  async enableShell() {
+    if (!this.#credentials)
+      throw new Error("\u041A\u043E\u043C\u043F\u044C\u044E\u0442\u0435\u0440 \u043D\u0435 \u0441\u0432\u044F\u0437\u0430\u043D \u0441 \u0430\u043A\u043A\u0430\u0443\u043D\u0442\u043E\u043C \u2014 \u0441\u043D\u0430\u0447\u0430\u043B\u0430 \u0441\u043E\u043F\u0440\u044F\u0436\u0435\u043D\u0438\u0435");
+    if (this.#socket?.readyState !== WebSocket.OPEN) {
+      throw new Error("\u041D\u0435\u0442 \u0441\u0432\u044F\u0437\u0438 \u0441 relay \u2014 \u0432\u043A\u043B\u044E\u0447\u0438\u0442\u044C \u0443\u0434\u0430\u043B\u0451\u043D\u043D\u044B\u0439 \u0442\u0435\u0440\u043C\u0438\u043D\u0430\u043B \u0441\u0435\u0439\u0447\u0430\u0441 \u043D\u0435 \u0432\u044B\u0439\u0434\u0435\u0442");
+    }
+    this.#push({ t: "shell.enable" });
+  }
+  /**
+   * Попросить relay выслать письмо, подтверждающее удалённый терминал.
+   *
+   * Само право этот вызов не даёт и дать не может: relay только отправляет
+   * письмо, а включает доступ переход по ссылке из него. Поэтому здесь нет ни
+   * ожидания ответа, ни оптимистичного `enabled = true` — состояние приедет
+   * кадром `shell.state`, когда будет чему приезжать.
+   */
+  async requestShell() {
+    if (!this.#credentials)
+      throw new Error("\u041A\u043E\u043C\u043F\u044C\u044E\u0442\u0435\u0440 \u043D\u0435 \u0441\u0432\u044F\u0437\u0430\u043D \u0441 \u0430\u043A\u043A\u0430\u0443\u043D\u0442\u043E\u043C \u2014 \u0441\u043D\u0430\u0447\u0430\u043B\u0430 \u0441\u043E\u043F\u0440\u044F\u0436\u0435\u043D\u0438\u0435");
+    if (this.#socket?.readyState !== WebSocket.OPEN) {
+      throw new Error("\u041D\u0435\u0442 \u0441\u0432\u044F\u0437\u0438 \u0441 relay \u2014 \u043F\u0438\u0441\u044C\u043C\u043E \u043E\u0442\u043F\u0440\u0430\u0432\u0438\u0442\u044C \u043D\u0435\u043A\u043E\u043C\u0443, \u043F\u043E\u043F\u0440\u043E\u0431\u0443\u0439\u0442\u0435 \u043F\u043E\u0437\u0436\u0435");
+    }
+    this.#push({ t: "shell.request" });
+  }
+  /** Снять право немедленно. Тоже через relay: там оно и хранится. */
+  async disableShell() {
+    if (!this.#credentials)
+      return;
+    if (this.#socket?.readyState !== WebSocket.OPEN) {
+      this.#shell = { ...this.#shell, enabled: false, pending: false };
+      this.#changed();
+      return;
+    }
+    this.#push({ t: "shell.disable" });
+  }
   #changed() {
     this.emit("state");
   }
@@ -2880,7 +3462,7 @@ var RelayLink = class extends EventEmitter3 {
   }
   async #read() {
     try {
-      const raw = await readFile8(this.#file, "utf8");
+      const raw = await readFile9(this.#file, "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed !== "object" || parsed === null)
         return null;
@@ -2893,8 +3475,8 @@ var RelayLink = class extends EventEmitter3 {
     }
   }
   async #write(credentials) {
-    await mkdir5(path11.dirname(this.#file), { recursive: true });
-    await writeFile5(this.#file, `${JSON.stringify(credentials, null, 2)}
+    await mkdir6(path12.dirname(this.#file), { recursive: true });
+    await writeFile6(this.#file, `${JSON.stringify(credentials, null, 2)}
 `, {
       encoding: "utf8",
       mode: 384
@@ -2945,6 +3527,7 @@ var RelayLink = class extends EventEmitter3 {
     this.#credentials = null;
     this.#error = null;
     this.#clients.clear();
+    this.#shell = { enabled: false, pending: false, email: null, confirmedAt: null };
     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");
@@ -3050,6 +3633,16 @@ var RelayLink = class extends EventEmitter3 {
       case "client.frame":
         this.emit("frame", frame.clientId, frame.body);
         return;
+      case "shell.state":
+        this.#shell = {
+          enabled: frame.enabled,
+          pending: frame.pending,
+          email: frame.email,
+          confirmedAt: frame.confirmedAt
+        };
+        this.#log(frame.enabled ? "\u0443\u0434\u0430\u043B\u0451\u043D\u043D\u044B\u0439 \u0442\u0435\u0440\u043C\u0438\u043D\u0430\u043B \u0440\u0430\u0437\u0440\u0435\u0448\u0451\u043D" : frame.pending ? `\u0443\u0434\u0430\u043B\u0451\u043D\u043D\u044B\u0439 \u0442\u0435\u0440\u043C\u0438\u043D\u0430\u043B: \u043F\u0438\u0441\u044C\u043C\u043E \u043E\u0442\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u043E \u043D\u0430 ${frame.email}` : "\u0443\u0434\u0430\u043B\u0451\u043D\u043D\u044B\u0439 \u0442\u0435\u0440\u043C\u0438\u043D\u0430\u043B \u0432\u044B\u043A\u043B\u044E\u0447\u0435\u043D");
+        this.#changed();
+        return;
       case "ping":
         socket.send(JSON.stringify({ t: "pong", nonce: frame.nonce }));
         return;
@@ -3090,11 +3683,196 @@ function describe4(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
+// ../host/dist/terminal.js
+import { EventEmitter as EventEmitter4 } from "node:events";
+import { access as access2, constants as constants2 } from "node:fs/promises";
+import path13 from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+var SCROLLBACK_BYTES = 256 * 1024;
+var FLUSH_MS = 12;
+var MAX_TERMINALS = 24;
+var TerminalHub = class extends EventEmitter4 {
+  #terminals = /* @__PURE__ */ new Map();
+  #module = null;
+  list(workspaceId) {
+    const all = [...this.#terminals.values()].map((entry) => entry.info);
+    return workspaceId ? all.filter((info) => info.workspaceId === workspaceId) : all;
+  }
+  has(id) {
+    return this.#terminals.has(id);
+  }
+  /** Накопленный вывод — то, что увидит подключившийся позже. */
+  buffer(id) {
+    const entry = this.#terminals.get(id);
+    if (!entry)
+      return "";
+    return entry.chunks.join("") + entry.pending;
+  }
+  async open(options2) {
+    if (this.#terminals.size >= MAX_TERMINALS) {
+      throw new Error(`\u041E\u0442\u043A\u0440\u044B\u0442\u043E \u0443\u0436\u0435 ${MAX_TERMINALS} \u0442\u0435\u0440\u043C\u0438\u043D\u0430\u043B\u043E\u0432 \u2014 \u0437\u0430\u043A\u0440\u043E\u0439\u0442\u0435 \u043B\u0438\u0448\u043D\u0438\u0435`);
+    }
+    const pty = await this.#pty();
+    const shell = await defaultShell();
+    const cols = clampSize(options2.cols, 20, 500, 80);
+    const rows = clampSize(options2.rows, 5, 200, 24);
+    const child = pty.spawn(shell.file, shell.args, {
+      name: "xterm-256color",
+      cols,
+      rows,
+      cwd: options2.cwd,
+      env: environment()
+    });
+    const info = {
+      id: randomUUID2(),
+      workspaceId: options2.workspaceId,
+      title: shell.title,
+      shell: shell.file,
+      cwd: options2.cwd,
+      cols,
+      rows,
+      exitCode: null
+    };
+    const entry = { info, pty: child, chunks: [], chunksLength: 0, pending: "", flush: null };
+    this.#terminals.set(info.id, entry);
+    child.onData((data) => this.#onData(entry, data));
+    child.onExit(({ exitCode, signal }) => {
+      this.#flush(entry);
+      entry.info.exitCode = exitCode;
+      this.emit("exit", info.id, exitCode, signal ?? null);
+    });
+    return info;
+  }
+  /**
+   * Ввод человека — как есть.
+   *
+   * Ни разбора, ни экранирования, ни проверки: перед нами не «команда», а поток
+   * нажатий, в котором Ctrl+C, Tab и вставка из буфера обмена неотличимы от
+   * обычных букв и должны такими остаться.
+   */
+  write(id, data) {
+    const entry = this.#terminals.get(id);
+    if (!entry)
+      throw new Error("\u0422\u0435\u0440\u043C\u0438\u043D\u0430\u043B \u0443\u0436\u0435 \u0437\u0430\u043A\u0440\u044B\u0442");
+    if (entry.info.exitCode !== null)
+      return;
+    entry.pty.write(data);
+  }
+  resize(id, cols, rows) {
+    const entry = this.#terminals.get(id);
+    if (!entry || entry.info.exitCode !== null)
+      return;
+    const next = { cols: clampSize(cols, 20, 500, 80), rows: clampSize(rows, 5, 200, 24) };
+    if (next.cols === entry.info.cols && next.rows === entry.info.rows)
+      return;
+    entry.info.cols = next.cols;
+    entry.info.rows = next.rows;
+    try {
+      entry.pty.resize(next.cols, next.rows);
+    } catch {
+    }
+  }
+  close(id) {
+    const entry = this.#terminals.get(id);
+    if (!entry)
+      return;
+    this.#terminals.delete(id);
+    if (entry.flush)
+      clearTimeout(entry.flush);
+    try {
+      entry.pty.kill();
+    } catch {
+    }
+  }
+  /** Погасить всё: незакрытые оболочки переживут хост и останутся висеть. */
+  closeAll() {
+    for (const id of [...this.#terminals.keys()])
+      this.close(id);
+  }
+  #onData(entry, data) {
+    entry.pending += data;
+    if (entry.flush)
+      return;
+    entry.flush = setTimeout(() => this.#flush(entry), FLUSH_MS);
+    entry.flush.unref?.();
+  }
+  #flush(entry) {
+    if (entry.flush) {
+      clearTimeout(entry.flush);
+      entry.flush = null;
+    }
+    const data = entry.pending;
+    if (!data)
+      return;
+    entry.pending = "";
+    entry.chunks.push(data);
+    entry.chunksLength += data.length;
+    while (entry.chunksLength > SCROLLBACK_BYTES && entry.chunks.length > 1) {
+      entry.chunksLength -= entry.chunks.shift().length;
+    }
+    this.emit("data", entry.info.id, data);
+  }
+  #pty() {
+    this.#module ??= import("@lydell/node-pty").then((module) => module).catch((error) => {
+      this.#module = null;
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new Error(`\u0422\u0435\u0440\u043C\u0438\u043D\u0430\u043B \u043D\u0435\u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D \u043D\u0430 \u044D\u0442\u043E\u0439 \u043C\u0430\u0448\u0438\u043D\u0435: ${reason}`);
+    });
+    return this.#module;
+  }
+};
+function clampSize(value, min, max, fallback) {
+  if (!Number.isFinite(value))
+    return fallback;
+  return Math.min(max, Math.max(min, Math.round(value)));
+}
+function environment() {
+  const env = {
+    ...process.env,
+    TERM: "xterm-256color",
+    COLORTERM: "truecolor"
+  };
+  for (const key of Object.keys(env))
+    if (key.startsWith("="))
+      delete env[key];
+  return env;
+}
+async function defaultShell() {
+  if (process.platform === "win32") {
+    const pwsh = await findOnPath("pwsh.exe");
+    if (pwsh)
+      return { file: pwsh, args: [], title: "pwsh" };
+    const system = process.env.SystemRoot ?? "C:\\Windows";
+    const powershell = path13.join(system, "System32/WindowsPowerShell/v1.0/powershell.exe");
+    if (await exists2(powershell))
+      return { file: powershell, args: [], title: "powershell" };
+    return { file: process.env.COMSPEC ?? "cmd.exe", args: [], title: "cmd" };
+  }
+  const shell = process.env.SHELL;
+  if (shell && await exists2(shell))
+    return { file: shell, args: [], title: path13.basename(shell) };
+  if (await exists2("/bin/bash"))
+    return { file: "/bin/bash", args: [], title: "bash" };
+  return { file: "/bin/sh", args: [], title: "sh" };
+}
+async function findOnPath(name) {
+  const dirs = (process.env.PATH ?? "").split(path13.delimiter).filter(Boolean);
+  for (const dir of dirs) {
+    const candidate = path13.join(dir, name);
+    if (await exists2(candidate))
+      return candidate;
+  }
+  return null;
+}
+function exists2(file) {
+  return access2(file, constants2.X_OK).then(() => true, () => false);
+}
+
 // ../host/dist/mcp-config.js
-import { readFile as readFile9, writeFile as writeFile6, mkdir as mkdir6 } from "node:fs/promises";
-import path12 from "node:path";
+import { readFile as readFile10, writeFile as writeFile7, mkdir as mkdir7 } from "node:fs/promises";
+import path14 from "node:path";
 var MCP_FILE = ".mcp.json";
-var LOCAL_SETTINGS2 = path12.join(".claude", "settings.local.json");
+var LOCAL_SETTINGS2 = path14.join(".claude", "settings.local.json");
 var queues = /* @__PURE__ */ new Map();
 function serialize(cwd, work) {
   const previous = queues.get(cwd) ?? Promise.resolve();
@@ -3103,7 +3881,7 @@ function serialize(cwd, work) {
   return next;
 }
 async function readProjectServers(cwd) {
-  const file = await readJson(path12.join(cwd, MCP_FILE));
+  const file = await readJson(path14.join(cwd, MCP_FILE));
   const servers = file?.mcpServers;
   if (!servers || typeof servers !== "object")
     return {};
@@ -3111,23 +3889,23 @@ async function readProjectServers(cwd) {
 }
 function addProjectServer(cwd, name, config) {
   return serialize(cwd, async () => {
-    const file = await readJson(path12.join(cwd, MCP_FILE)) ?? {};
+    const file = await readJson(path14.join(cwd, MCP_FILE)) ?? {};
     const servers = file.mcpServers ?? {};
     servers[name] = config;
     file.mcpServers = servers;
-    await writeJson(path12.join(cwd, MCP_FILE), file);
+    await writeJson(path14.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 file = await readJson(path14.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);
+    await writeJson(path14.join(cwd, MCP_FILE), file);
+    const settingsPath = path14.join(cwd, LOCAL_SETTINGS2);
     const settings = await readJson(settingsPath);
     const enabled = settings?.enabledMcpjsonServers;
     if (settings && Array.isArray(enabled) && enabled.includes(name)) {
@@ -3138,7 +3916,7 @@ function removeProjectServer(cwd, name) {
   });
 }
 async function approve(cwd, name) {
-  const file = path12.join(cwd, LOCAL_SETTINGS2);
+  const file = path14.join(cwd, LOCAL_SETTINGS2);
   const settings = await readJson(file) ?? {};
   const enabled = Array.isArray(settings.enabledMcpjsonServers) ? settings.enabledMcpjsonServers : [];
   if (!enabled.includes(name))
@@ -3177,31 +3955,34 @@ function describeConfig(config) {
 }
 async function readJson(file) {
   try {
-    const raw = await readFile9(file, "utf8");
+    const raw = await readFile10(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 new Error(`\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0440\u0430\u0437\u043E\u0431\u0440\u0430\u0442\u044C ${path14.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)}
+  await mkdir7(path14.dirname(file), { recursive: true });
+  await writeFile7(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 HISTORY_PAGE = 250;
+var HISTORY_PAGE_MAX = 500;
 var HostServer = class {
   #options;
   #workspaces;
   #archive;
+  #pins;
   #settings;
   #finder;
   #sessions = /* @__PURE__ */ new Map();
@@ -3219,18 +4000,21 @@ var HostServer = class {
   #clients = /* @__PURE__ */ new Set();
   /** Удалённые вкладки по их id в relay — чтобы адресовать ответ именно той. */
   #remotes = /* @__PURE__ */ new Map();
-  #hostId = randomUUID2();
+  #hostId = randomUUID3();
   #plugins = new PluginCli();
   #auth = new AuthCli();
   #relay;
+  #terminals = new TerminalHub();
   constructor(options2) {
     this.#options = options2;
     this.#workspaces = new WorkspaceRegistry(options2.dataDir);
     this.#archive = new SessionArchive(options2.dataDir);
+    this.#pins = new SessionPins(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.#wireTerminals();
     this.#auth.on("login", (state) => {
       this.#broadcast({ type: "auth.login", state });
     });
@@ -3241,6 +4025,7 @@ var HostServer = class {
   async start() {
     await this.#workspaces.load();
     await this.#archive.load();
+    await this.#pins.load();
     await this.#settings.load();
     await warmClaudeLauncher();
     void this.#finder.warm();
@@ -3266,6 +4051,7 @@ var HostServer = class {
   }
   async shutdown() {
     this.#auth.cancel();
+    this.#terminals.closeAll();
     await this.#relay.close();
     await Promise.all([...this.#sessions.values()].map((s) => s.close("host shutdown")));
     this.#sessions.clear();
@@ -3329,6 +4115,36 @@ var HostServer = class {
       this.#broadcast({ type: "relay.state", state: this.#relay.state });
     });
   }
+  // -------------------------------------------------------------------------
+  // Терминал
+  // -------------------------------------------------------------------------
+  #wireTerminals() {
+    this.#terminals.on("data", (id, data) => {
+      this.#broadcastTerminal({ type: "term.data", id, data });
+    });
+    this.#terminals.on("exit", (id, exitCode, signal) => {
+      this.#broadcastTerminal({ type: "term.exit", id, exitCode, signal });
+    });
+  }
+  /**
+   * Вывод терминала — всем локальным вкладкам, удалённым только по праву.
+   *
+   * Отдельно от `#broadcast` именно поэтому: обычный broadcast уходит и в
+   * relay, а вывод оболочки — то самое, что удалённой стороне видеть не
+   * положено, пока доступ не подтверждён письмом. Ошибиться здесь дороже, чем
+   * в проверке входящего кадра: вход можно не заметить и отклонить, а вывод,
+   * ушедший наружу, уже ушёл.
+   */
+  #broadcastTerminal(frame) {
+    if (this.#relay.shell.enabled) {
+      this.#broadcast(frame);
+      return;
+    }
+    for (const client of this.#clients) {
+      if (client.local)
+        client.send(frame);
+    }
+  }
   #adoptRemote(clientId) {
     const client = {
       local: false,
@@ -3402,10 +4218,17 @@ var HostServer = class {
             continue;
           await this.#dropSession(session.id, "workspace closed");
         }
+        let unpinned = false;
+        for (const id of gone) {
+          if (await this.#pins.forgetWorkspace(id))
+            unpinned = true;
+        }
         this.#broadcast({
           type: "workspace.list",
           workspaces: this.#workspaces.list()
         });
+        if (unpinned)
+          await this.#sendPinned();
         return;
       }
       case "workspace.find": {
@@ -3468,6 +4291,27 @@ var HostServer = class {
         await this.#archive.unarchive(frame.sessionIds);
         await this.#sendSessionList(frame.workspaceId);
         return;
+      case "session.pin": {
+        const ids = new Set(frame.sessionIds);
+        for (const session of [...this.#sessions.values()]) {
+          const diskId = session.claudeSessionId;
+          if (!diskId)
+            continue;
+          if (ids.has(session.id))
+            ids.add(diskId);
+          if (ids.has(diskId))
+            ids.add(session.id);
+        }
+        await this.#pins.set(frame.workspaceId, [...ids], frame.pinned);
+        const hadPins = this.#pins.workspaceIds().includes(frame.workspaceId);
+        await this.#sendSessionList(frame.workspaceId);
+        if (!hadPins)
+          await this.#sendPinned();
+        return;
+      }
+      case "session.pins":
+        await this.#sendPinned();
+        return;
       case "session.rename":
         await this.#renameSession(frame.sessionId, frame.title, frame.workspaceId);
         return;
@@ -3494,6 +4338,21 @@ var HostServer = class {
         }
         return;
       }
+      case "session.history": {
+        const session = this.#requireSession(frame.sessionId);
+        const all = await session.history();
+        const end = typeof frame.before === "number" ? Math.max(0, Math.min(all.length, frame.before - 1)) : all.length;
+        const limit = Math.min(Math.max(frame.limit ?? HISTORY_PAGE, 1), HISTORY_PAGE_MAX);
+        const start = Math.max(0, end - limit);
+        this.#send(socket, {
+          type: "session.history",
+          sessionId: session.id,
+          entries: all.slice(start, end),
+          from: start + 1,
+          total: all.length
+        });
+        return;
+      }
       case "usage.get": {
         const session = this.#requireSession(frame.sessionId);
         if (session.usage) {
@@ -3510,7 +4369,7 @@ var HostServer = class {
         this.#requireSession(frame.sessionId).sendPrompt(frame.text);
         return;
       case "permission.respond":
-        this.#requireSession(frame.sessionId).respondPermission(frame.requestId, frame.decision, frame.reason);
+        this.#requireSession(frame.sessionId).respondPermission(frame.requestId, frame.decision, frame.reason, frame.answers, frame.annotations);
         return;
       case "side.ask":
         this.#ensureSide(this.#requireSession(frame.sessionId)).sendPrompt(frame.text);
@@ -3715,6 +4574,54 @@ var HostServer = class {
         }
         return;
       }
+      // Терминал. Каждая ручка начинается с одной и той же проверки права: их
+      // пять, и «забыл в одной» здесь означает не потерянную кнопку, а чужую
+      // оболочку в руках у того, кому её не давали.
+      case "term.list":
+        this.#requireShellAccess(socket);
+        this.#send(socket, {
+          type: "term.list",
+          workspaceId: frame.workspaceId,
+          terminals: this.#terminals.list(frame.workspaceId)
+        });
+        return;
+      case "term.open": {
+        this.#requireShellAccess(socket);
+        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 terminal = await this.#terminals.open({
+          workspaceId: workspace.id,
+          cwd: workspace.path,
+          cols: frame.cols,
+          rows: frame.rows
+        });
+        this.#broadcastTerminal({ type: "term.opened", terminal });
+        return;
+      }
+      case "term.attach":
+        this.#requireShellAccess(socket);
+        if (!this.#terminals.has(frame.id))
+          throw new Error("\u0422\u0435\u0440\u043C\u0438\u043D\u0430\u043B \u0443\u0436\u0435 \u0437\u0430\u043A\u0440\u044B\u0442");
+        this.#send(socket, {
+          type: "term.buffer",
+          id: frame.id,
+          data: this.#terminals.buffer(frame.id)
+        });
+        return;
+      case "term.input":
+        this.#requireShellAccess(socket);
+        this.#terminals.write(frame.id, frame.data);
+        return;
+      case "term.resize":
+        this.#requireShellAccess(socket);
+        this.#terminals.resize(frame.id, frame.cols, frame.rows);
+        return;
+      case "term.close":
+        this.#requireShellAccess(socket);
+        this.#terminals.close(frame.id);
+        this.#broadcastTerminal({ type: "term.closed", id: frame.id });
+        return;
       case "settings.get":
         this.#send(socket, { type: "settings.state", settings: this.#settings.current });
         return;
@@ -3727,6 +4634,12 @@ var HostServer = class {
             await this.#sendSessionList(workspace.id);
           }
         }
+        if (before.terminalEnabled && !settings.terminalEnabled) {
+          for (const terminal of this.#terminals.list()) {
+            this.#terminals.close(terminal.id);
+            this.#broadcastTerminal({ type: "term.closed", id: terminal.id });
+          }
+        }
         return;
       }
       case "auth.status":
@@ -3756,7 +4669,40 @@ var HostServer = class {
         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;
+      case "relay.shell.enable":
+        if (!this.#settings.current.terminalEnabled) {
+          throw new Error("\u0421\u043D\u0430\u0447\u0430\u043B\u0430 \u0432\u043A\u043B\u044E\u0447\u0438\u0442\u0435 \u0442\u0435\u0440\u043C\u0438\u043D\u0430\u043B \u0432 \u043D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0430\u0445 \u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u044F \u2014 \u0443\u0434\u0430\u043B\u0451\u043D\u043D\u044B\u0439 \u0434\u043E\u0441\u0442\u0443\u043F \u0434\u0430\u0451\u0442\u0441\u044F \u043A \u043D\u0435\u043C\u0443, \u0430 \u0435\u0433\u043E \u0441\u0435\u0439\u0447\u0430\u0441 \u043D\u0435\u0442.");
+        }
+        if (socket.local)
+          await this.#relay.enableShell();
+        else
+          await this.#relay.requestShell();
+        return;
+      case "relay.shell.disable":
+        await this.#relay.disableShell();
+        return;
+    }
+  }
+  /**
+   * Терминал — по двум условиям сразу: включён ли он вообще и, для удалённой
+   * вкладки, подтверждено ли право.
+   *
+   * Первое — настройка самой машины (`AppSettings.terminalEnabled`), выключена
+   * по умолчанию: пока её не подняли, терминала нет ни у кого. Второе, поверх
+   * первого: локальному клиенту не отказываем никогда — он и так за этой
+   * машиной, где терминал открывается и без нас. Удалённому — по состоянию,
+   * которое ведёт
+   * relay: право включают либо на самой машине (сразу, физический доступ и
+   * есть подтверждение), либо из удалённой вкладки, и тогда его включает не
+   * нажатие кнопки, а переход по ссылке из письма на почту аккаунта.
+   */
+  #requireShellAccess(client) {
+    if (!this.#settings.current.terminalEnabled) {
+      throw new Error("\u0422\u0435\u0440\u043C\u0438\u043D\u0430\u043B \u0432\u044B\u043A\u043B\u044E\u0447\u0435\u043D. \u0412\u043A\u043B\u044E\u0447\u0438\u0442\u0435 \u0435\u0433\u043E \u0432 \u043D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0430\u0445 \u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u044F, \u0440\u0430\u0437\u0434\u0435\u043B \xAB\u0422\u0435\u0440\u043C\u0438\u043D\u0430\u043B\xBB.");
     }
+    if (client.local || this.#relay.shell.enabled)
+      return;
+    throw new Error("\u0422\u0435\u0440\u043C\u0438\u043D\u0430\u043B \u0441 \u0443\u0434\u0430\u043B\u0451\u043D\u043D\u044B\u0445 \u0443\u0441\u0442\u0440\u043E\u0439\u0441\u0442\u0432 \u0432\u044B\u043A\u043B\u044E\u0447\u0435\u043D. \u0412\u043A\u043B\u044E\u0447\u0438\u0442\u0435 \u0435\u0433\u043E \u0432 \u043D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0430\u0445 \u0443\u0434\u0430\u043B\u0451\u043D\u043D\u043E\u0433\u043E \u0434\u043E\u0441\u0442\u0443\u043F\u0430 \u2014 \u043D\u0430 \u0441\u0430\u043C\u043E\u043C \u043A\u043E\u043C\u043F\u044C\u044E\u0442\u0435\u0440\u0435 \u043E\u043D \u0432\u043A\u043B\u044E\u0447\u0430\u0435\u0442\u0441\u044F \u0441\u0440\u0430\u0437\u0443, \u043E\u0442\u0441\u044E\u0434\u0430 \u043F\u043E\u0442\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044F \u043F\u043E\u0434\u0442\u0432\u0435\u0440\u0436\u0434\u0435\u043D\u0438\u0435 \u0441\u0441\u044B\u043B\u043A\u043E\u0439 \u0438\u0437 \u043F\u0438\u0441\u044C\u043C\u0430.");
   }
   /**
    * Настройки удалённого доступа меняются только с самой машины.
@@ -3890,6 +4836,32 @@ var HostServer = class {
   async #sendSessionList(workspaceId) {
     const { sessions, archived } = await this.#listSessions(workspaceId);
     this.#broadcast({ type: "session.list", workspaceId, sessions, archived });
+    if (this.#pins.workspaceIds().includes(workspaceId))
+      await this.#sendPinned();
+  }
+  /**
+   * Разослать закреплённые сессии — по всем проектам сразу.
+   *
+   * Собирается из тех же списков, что и панель проекта (`#listSessions`), а не
+   * из одного реестра закреплений: в панели закреплённых у строки должны быть
+   * имя, состояние и время последнего события, а реестр знает только id. Обход
+   * идёт лишь по проектам, где вообще что-то закреплено, — их обычно единицы, и
+   * читать диск по всем открытым проектам ради этого незачем.
+   *
+   * Архивные сюда тоже попадают: закреплённое в архив само не уезжает, но
+   * убрать туда руками уже закреплённую сессию человеку никто не мешает, и
+   * терять её из панели после этого было бы странно.
+   */
+  async #sendPinned() {
+    const sessions = [];
+    for (const workspaceId of this.#pins.workspaceIds()) {
+      if (!this.#workspaces.find(workspaceId))
+        continue;
+      const { sessions: live, archived } = await this.#listSessions(workspaceId);
+      sessions.push(...[...live, ...archived].filter((s) => s.pinned));
+    }
+    sessions.sort((a, b) => (a.pinnedAt ?? 0) - (b.pinnedAt ?? 0));
+    this.#broadcast({ type: "session.pinned", sessions });
   }
   async #startSession(socket, frame) {
     const workspace = this.#workspaces.find(frame.workspaceId);
@@ -3899,13 +4871,14 @@ var HostServer = class {
     const resumedTitle = resumed ? diskTitle(resumed) : null;
     if (frame.resume)
       await this.#archive.unarchive([frame.resume]);
+    const startDefaults = this.#settings.current;
     const session = new ClaudeSession({
       workspaceId: workspace.id,
       cwd: workspace.path,
       resume: frame.resume,
       fork: frame.fork,
-      permissionMode: frame.permissionMode,
-      model: frame.model,
+      permissionMode: frame.permissionMode ?? startDefaults.startPermissionMode,
+      model: frame.model ?? startDefaults.startModel ?? void 0,
       ...resumedTitle ? { title: resumedTitle } : {},
       // Имя проекта вместо «Без названия»: свежую сессию в списке уже надо
       // как-то называть, а сказать о ней пока нечего, кроме того, где она.
@@ -3929,6 +4902,9 @@ var HostServer = class {
     });
     session.on("summary", (summary) => {
       this.#broadcast({ type: "session.summary", session: summary });
+      if (!summary.claudeSessionId || !this.#pins.has(summary.id))
+        return;
+      void this.#pins.migrate(summary.id, summary.claudeSessionId).then((moved) => moved ? this.#sendPinned() : void 0).catch(() => void 0);
     });
     session.on("capabilities", () => {
       if (!session.capabilities)
@@ -4191,6 +5167,9 @@ var HostServer = class {
       parentSessionId: null,
       title: diskTitle(info),
       state: "closed",
+      // Хода в этой жизни у неё не было: сессия не поднята, и чем кончился
+      // последний ход прошлой, знает только её JSONL.
+      lastTurn: null,
       model: null,
       permissionMode: "default",
       // Сессия с диска не поднята: чем она была настроена, знает только её
@@ -4204,10 +5183,14 @@ var HostServer = class {
       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 known = /* @__PURE__ */ new Set([...liveIds, ...historical.map((s) => s.id)]);
+    await this.#archive.sweep(workspaceId, historical.filter((s) => !this.#pins.has(s.id)).map((s) => ({ id: s.id, updatedAt: s.updatedAt })), known, this.#settings.current.autoArchiveAfterMs);
+    await this.#pins.sweep(workspaceId, known);
     const sessions = [];
     const archived = [];
-    for (const summary of [...live, ...historical].sort((a, b) => b.updatedAt - a.updatedAt)) {
+    for (const base of [...live, ...historical].sort((a, b) => b.updatedAt - a.updatedAt)) {
+      const pin = this.#pins.find(base.claudeSessionId ?? base.id);
+      const summary = pin ? { ...base, pinned: true, pinnedAt: pin.at } : base;
       const record = this.#archive.find(summary.claudeSessionId ?? summary.id);
       if (!record) {
         sessions.push(summary);
@@ -4245,8 +5228,8 @@ var HostServer = class {
       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");
+    const requested = path15.join(webRoot, path15.normalize(url2.pathname));
+    const target = requested.startsWith(webRoot) && existsSync3(requested) && statSync3(requested).isFile() ? requested : path15.join(webRoot, "index.html");
     if (!existsSync3(target)) {
       res.writeHead(404).end("not found");
       return;
@@ -4272,12 +5255,12 @@ function contentType(file) {
     ".svg": "image/svg+xml",
     ".woff2": "font/woff2"
   };
-  return types[path13.extname(file)] ?? "application/octet-stream";
+  return types[path15.extname(file)] ?? "application/octet-stream";
 }
 
 // dist/ccv.js
-var HERE = path14.dirname(fileURLToPath(import.meta.url));
-var PACKAGE_ROOT = path14.resolve(HERE, "..");
+var HERE = path16.dirname(fileURLToPath(import.meta.url));
+var PACKAGE_ROOT = path16.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:
@@ -4344,7 +5327,7 @@ var server = new HostServer({
   dataDir: defaults.dataDir,
   // UI лежит в пакете рядом с бандлом — это и есть разница между установленной
   // утилитой и запуском из репозитория, где сборка живёт в `apps/web/dist`.
-  webRoot: process.env.CCV_WEB_ROOT ?? path14.join(PACKAGE_ROOT, "web"),
+  webRoot: process.env.CCV_WEB_ROOT ?? path16.join(PACKAGE_ROOT, "web"),
   version,
   relayUrl: defaults.relayUrl
 });
@@ -4373,7 +5356,7 @@ for (const signal of ["SIGINT", "SIGTERM"]) {
 }
 async function packageVersion() {
   try {
-    const text = await readFile10(path14.join(PACKAGE_ROOT, "package.json"), "utf8");
+    const text = await readFile11(path16.join(PACKAGE_ROOT, "package.json"), "utf8");
     return JSON.parse(text).version ?? "0.0.0";
   } catch {
     return "0.0.0";