@i14ks/ccv 0.23.0 → 0.24.0

package/bundle/ccv.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // dist/ccv.js
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 import { readFile as readFile17 } from "node:fs/promises";
-import path24 from "node:path";
+import path25 from "node:path";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 
@@ -145,10 +145,10 @@ function envDefaults() {
 
 // ../host/dist/server.js
 import { createServer } from "node:http";
-import { createReadStream, existsSync as existsSync4, statSync as statSync3 } from "node:fs";
-import path23 from "node:path";
-import { homedir as homedir6 } from "node:os";
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { createReadStream, existsSync as existsSync5, statSync as statSync4 } from "node:fs";
+import path24 from "node:path";
+import { homedir as homedir7 } from "node:os";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { WebSocketServer } from "ws";
 import { renameSession as renameSession2 } from "@anthropic-ai/claude-agent-sdk";
 
@@ -187,12 +187,12 @@ function hashText(text) {
 // ../host/dist/workspace-ids.js
 function workspaceIdRemap(paths, sessionsOf) {
   const byLegacy = /* @__PURE__ */ new Map();
-  for (const path25 of paths) {
-    const id = workspaceIdFromPath(path25);
-    for (const legacy of formerWorkspaceIdsFromPath(path25)) {
+  for (const path26 of paths) {
+    const id = workspaceIdFromPath(path26);
+    for (const legacy of formerWorkspaceIdsFromPath(path26)) {
       const group = byLegacy.get(legacy) ?? [];
       if (!group.some((target) => target.id === id))
-        group.push({ id, path: path25 });
+        group.push({ id, path: path26 });
       byLegacy.set(legacy, group);
     }
   }
@@ -4217,18 +4217,865 @@ function describe2(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
+// ../host/dist/codex-session.js
+import { EventEmitter as EventEmitter5 } from "node:events";
+import { randomUUID as randomUUID3 } from "node:crypto";
+
+// ../host/dist/codex-cli.js
+import { accessSync, constants as constants2, existsSync as existsSync2, readFileSync, statSync } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import path8 from "node:path";
+var CODEX_MISSING_HINT = "Codex CLI \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D. \u0423\u0441\u0442\u0430\u043D\u043E\u0432\u0438\u0442\u0435: npm install -g @openai/codex, \u0437\u0430\u0442\u0435\u043C \u0432\u044B\u043F\u043E\u043B\u043D\u0438\u0442\u0435 codex login. \u0415\u0441\u043B\u0438 CLI \u0443\u0436\u0435 \u0443\u0441\u0442\u0430\u043D\u043E\u0432\u043B\u0435\u043D, \u0437\u0430\u0434\u0430\u0439\u0442\u0435 CCV_CODEX_PATH \u0438 \u043F\u0435\u0440\u0435\u0437\u0430\u043F\u0443\u0441\u0442\u0438\u0442\u0435 ccv.";
+function codexLauncher() {
+  const forced = process.env.CCV_CODEX_PATH;
+  if (forced)
+    return launcherFor(path8.resolve(forced));
+  const dirs = (process.env.PATH ?? "").split(path8.delimiter).filter(Boolean);
+  if (process.platform === "win32") {
+    const local = process.env.LOCALAPPDATA ?? path8.join(homedir4(), "AppData", "Local");
+    dirs.push(path8.join(local, "Programs", "OpenAI", "Codex", "bin"));
+    dirs.push(path8.join(process.env.APPDATA ?? path8.join(homedir4(), "AppData", "Roaming"), "npm"));
+  } else {
+    dirs.push(path8.join(homedir4(), ".local", "bin"), "/usr/local/bin", "/opt/homebrew/bin");
+  }
+  for (const dir of dirs) {
+    for (const name of process.platform === "win32" ? ["codex.exe", "codex.cmd", "codex"] : ["codex"]) {
+      const found = launcherFor(path8.join(dir.replace(/^"|"$/g, ""), name));
+      if (found)
+        return found;
+    }
+  }
+  return null;
+}
+function launcherFor(file) {
+  try {
+    if (!statSync(file).isFile())
+      return null;
+    if (/\.[cm]?js$/i.test(file))
+      return { file: process.execPath, prefix: [file] };
+    if (process.platform === "win32" && /\.(cmd|bat|ps1)$/i.test(file)) {
+      const root = path8.dirname(file);
+      const candidates = [path8.join(root, "node_modules", "@openai", "codex", "bin", "codex.js")];
+      const shim = readFileSync(file, "utf8");
+      for (const match of shim.matchAll(/(?:%dp0%|%~dp0|\$basedir)[\\/]([^"\r\n]+?\.[cm]?js)/gi)) {
+        candidates.push(path8.resolve(root, match[1]));
+      }
+      const script = candidates.find((candidate) => existsSync2(candidate));
+      return script ? { file: process.execPath, prefix: [script] } : null;
+    }
+    if (process.platform === "win32" && !/\.exe$/i.test(file))
+      return null;
+    accessSync(file, constants2.X_OK);
+    return { file, prefix: [] };
+  } catch {
+    return null;
+  }
+}
+
+// ../host/dist/codex-rpc.js
+import { EventEmitter as EventEmitter4 } from "node:events";
+import { execFile as execFile4, spawn as spawn3 } from "node:child_process";
+import { createInterface as createInterface2 } from "node:readline";
+var CodexRpc = class extends EventEmitter4 {
+  #child;
+  #pending = /* @__PURE__ */ new Map();
+  #nextId = 0;
+  #closed = false;
+  #stderr = "";
+  constructor(launcher, cwd) {
+    super();
+    this.#child = spawn3(launcher.file, [...launcher.prefix, "app-server", "--listen", "stdio://"], {
+      cwd,
+      windowsHide: true,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, NO_COLOR: "1" }
+    });
+    createInterface2({ input: this.#child.stdout }).on("line", (line) => {
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        return;
+      }
+      if (!message || typeof message !== "object")
+        return;
+      if (message.method) {
+        this.emit("message", message);
+        return;
+      }
+      const pending = typeof message.id === "number" ? this.#pending.get(message.id) : void 0;
+      if (!pending)
+        return;
+      this.#pending.delete(message.id);
+      clearTimeout(pending.timer);
+      if (message.error)
+        pending.reject(new Error(message.error.message));
+      else
+        pending.resolve(message.result);
+    });
+    this.#child.stderr.on("data", (chunk) => {
+      this.#stderr = (this.#stderr + chunk.toString()).slice(-4e3);
+      this.emit("stderr", chunk.toString());
+    });
+    this.#child.stdin.on("error", (error) => this.#finish(error));
+    this.#child.on("error", (error) => this.#finish(error));
+    this.#child.on("exit", (code) => this.#finish(new Error(`Codex \u0437\u0430\u0432\u0435\u0440\u0448\u0438\u043B\u0441\u044F (${code ?? "signal"}). ${this.#stderr.trim()}`)));
+  }
+  request(method, params = {}) {
+    if (this.#closed)
+      return Promise.reject(new Error("\u0421\u043E\u0435\u0434\u0438\u043D\u0435\u043D\u0438\u0435 \u0441 Codex \u0437\u0430\u043A\u0440\u044B\u0442\u043E"));
+    const id = ++this.#nextId;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.#pending.delete(id);
+        reject(new Error(`Codex \u043D\u0435 \u043E\u0442\u0432\u0435\u0442\u0438\u043B \u043D\u0430 ${method} \u0437\u0430 60 \u0441\u0435\u043A\u0443\u043D\u0434`));
+      }, 6e4);
+      this.#pending.set(id, { resolve: (value) => resolve(value), reject, timer });
+      this.write({ id, method, params });
+    });
+  }
+  write(message) {
+    if (!this.#closed)
+      this.#child.stdin.write(JSON.stringify(message) + "\n");
+  }
+  close() {
+    this.#finish(new Error("\u0421\u043E\u0435\u0434\u0438\u043D\u0435\u043D\u0438\u0435 \u0441 Codex \u0437\u0430\u043A\u0440\u044B\u0442\u043E"), false);
+    this.#child.stdin.end();
+    const child = this.#child;
+    if (child.exitCode !== null)
+      return;
+    if (process.platform === "win32" && child.pid) {
+      execFile4("taskkill", ["/pid", String(child.pid), "/T", "/F"], { windowsHide: true }, () => {
+        if (child.exitCode === null)
+          child.kill();
+      });
+    } else
+      child.kill("SIGTERM");
+  }
+  #finish(error, notify = true) {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    for (const pending of this.#pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.#pending.clear();
+    if (notify)
+      this.emit("exit", error);
+  }
+};
+
+// ../host/dist/codex-session.js
+function codexPolicy(mode) {
+  switch (mode) {
+    case "default":
+      return { approvalPolicy: "untrusted", sandbox: "workspace-write" };
+    case "acceptEdits":
+      return { approvalPolicy: "on-request", sandbox: "workspace-write" };
+    case "plan":
+      return { approvalPolicy: "untrusted", sandbox: "read-only" };
+    case "bypassPermissions":
+      return { approvalPolicy: "never", sandbox: "danger-full-access" };
+    default:
+      throw new Error(`Codex \u043D\u0435 \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442 \u0440\u0435\u0436\u0438\u043C \u043F\u0440\u0430\u0432 \xAB${mode}\xBB`);
+  }
+}
+function codexUsage(limits) {
+  const window = (value) => value ? {
+    utilization: Math.min(100, Math.max(0, value.usedPercent)),
+    resetsAt: value.resetsAt ? new Date(value.resetsAt * 1e3).toISOString() : ""
+  } : null;
+  return {
+    available: !!(limits.primary || limits.secondary),
+    plan: limits.planType ?? "",
+    fiveHour: window(limits.primary),
+    sevenDay: window(limits.secondary),
+    sevenDayOpus: null,
+    fetchedAt: Date.now()
+  };
+}
+var CodexSession = class extends EventEmitter5 {
+  provider = "codex";
+  id;
+  workspaceId;
+  cwd;
+  journal = new Journal();
+  #store;
+  #record;
+  #history = Promise.resolve([]);
+  #rpc = null;
+  #ready = Promise.resolve();
+  #state = "starting";
+  #lastTurn = null;
+  #capabilities = null;
+  #usage = null;
+  #context = null;
+  #turnId = null;
+  #turnStartedAt = 0;
+  #turnUsage = null;
+  #totalUsage = null;
+  #turnUsageBaseline = null;
+  #interruptRequested = false;
+  #busy = false;
+  #startingTurn = false;
+  #generation = 0;
+  #queue = [];
+  #pending = /* @__PURE__ */ new Map();
+  #texts = /* @__PURE__ */ new Map();
+  #tools = /* @__PURE__ */ new Set();
+  #items = /* @__PURE__ */ new Map();
+  #titleIsDefault;
+  #unsaved = [];
+  #flushTimer = null;
+  constructor(options2) {
+    super();
+    this.workspaceId = options2.workspaceId;
+    this.cwd = options2.cwd;
+    this.#store = options2.store;
+    this.#record = options2.record ? { ...options2.record } : {
+      id: randomUUID3(),
+      conversationId: null,
+      workspaceId: options2.workspaceId,
+      cwd: options2.cwd,
+      title: options2.defaultTitle ?? null,
+      model: options2.model ?? null,
+      permissionMode: options2.permissionMode ?? "default",
+      effort: null,
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    if (options2.permissionMode)
+      this.#record.permissionMode = options2.permissionMode;
+    if (options2.model)
+      this.#record.model = options2.model;
+    this.id = this.#record.id;
+    this.#context = this.#record.context ?? null;
+    if (!options2.record?.conversationId) {
+      this.#totalUsage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0 };
+    }
+    this.#titleIsDefault = !options2.record;
+  }
+  get state() {
+    return this.#state;
+  }
+  get capabilities() {
+    return this.#capabilities;
+  }
+  get claudeSessionId() {
+    return this.id;
+  }
+  get parentSessionId() {
+    return null;
+  }
+  get usage() {
+    return this.#usage;
+  }
+  get context() {
+    return this.#context;
+  }
+  history() {
+    return this.#history;
+  }
+  summary() {
+    return {
+      id: this.id,
+      provider: this.provider,
+      claudeSessionId: this.id,
+      workspaceId: this.workspaceId,
+      cwd: this.cwd,
+      parentSessionId: null,
+      title: this.#record.title,
+      state: this.#state,
+      lastTurn: this.#lastTurn,
+      backgroundWork: false,
+      tasks: [],
+      model: this.#record.model,
+      permissionMode: this.#record.permissionMode,
+      effort: this.#record.effort,
+      ultracode: false,
+      thinking: true,
+      switchModelsOnFlag: false,
+      createdAt: this.#record.createdAt,
+      updatedAt: this.#record.updatedAt,
+      lastSeq: this.journal.lastSeq,
+      totalCostUsd: 0
+    };
+  }
+  start() {
+    this.#history = this.#store.readEvents(this.id).then((entries) => {
+      const pending = /* @__PURE__ */ new Set();
+      for (const { event } of entries) {
+        if (event.kind === "permission.request")
+          pending.add(event.requestId);
+        if (event.kind === "permission.resolved")
+          pending.delete(event.requestId);
+      }
+      for (const requestId of pending)
+        entries.push({ seq: entries.length + 1, ts: Date.now(), event: {
+          kind: "permission.resolved",
+          requestId,
+          decision: "deny",
+          reason: "\u041F\u0440\u0435\u0434\u044B\u0434\u0443\u0449\u0438\u0439 \u043F\u0440\u043E\u0446\u0435\u0441\u0441 Codex \u0437\u0430\u0432\u0435\u0440\u0448\u0451\u043D"
+        } });
+      return entries;
+    });
+    this.#launch();
+  }
+  #launch() {
+    const generation = ++this.#generation;
+    this.#ready = this.#connect(generation);
+    void this.#ready.catch((error) => {
+      if (generation === this.#generation)
+        this.#fail(error);
+    });
+  }
+  async #connect(generation) {
+    await this.#history;
+    await this.#store.save(this.#record);
+    if (generation !== this.#generation)
+      return;
+    const reason = networkGuard.blockedReason();
+    if (reason)
+      throw new Error(reason);
+    const launcher = codexLauncher();
+    if (!launcher)
+      throw new Error(CODEX_MISSING_HINT);
+    const rpc = new CodexRpc(launcher, this.cwd);
+    this.#rpc = rpc;
+    rpc.on("message", (message) => {
+      if (this.#rpc === rpc)
+        this.#message(message);
+    });
+    rpc.on("stderr", (data) => this.emit("stderr", data));
+    rpc.on("exit", (error) => {
+      if (this.#rpc === rpc)
+        this.#fail(error);
+    });
+    await rpc.request("initialize", { clientInfo: { name: "ccv", title: "Claude Code Visual", version: "0.1.0" } });
+    if (this.#rpc !== rpc)
+      return;
+    rpc.write({ method: "initialized", params: {} });
+    const policy = codexPolicy(this.#record.permissionMode);
+    const result = await rpc.request(this.#record.conversationId ? "thread/resume" : "thread/start", {
+      ...this.#record.conversationId ? { threadId: this.#record.conversationId } : {},
+      cwd: this.cwd,
+      ...this.#record.model ? { model: this.#record.model } : {},
+      approvalPolicy: policy.approvalPolicy,
+      sandbox: policy.sandbox
+    });
+    if (this.#rpc !== rpc)
+      return;
+    this.#record.conversationId = result.thread.id;
+    this.#record.model = result.model;
+    if (!this.#record.effort && result.reasoningEffort)
+      this.#record.effort = result.reasoningEffort;
+    await this.#store.save(this.#record);
+    if (this.#rpc !== rpc)
+      return;
+    this.#capabilities = {
+      cwd: this.cwd,
+      model: result.model,
+      permissionMode: this.#record.permissionMode,
+      slashCommands: [],
+      commands: [],
+      models: [],
+      tools: ["Bash", "apply_patch", "web_search"],
+      agents: [],
+      mcpServers: [],
+      flags: []
+    };
+    this.emit("capabilities");
+    this.#setState("idle");
+    void this.#loadModels(rpc).catch((error) => {
+      if (this.#rpc === rpc)
+        this.#notice(error);
+    });
+    void this.refreshUsage();
+  }
+  async #loadModels(rpc) {
+    const models = [];
+    let cursor = null;
+    do {
+      const page = await rpc.request("model/list", { cursor, limit: 100 });
+      for (const model of page.data) {
+        const levels = (model.supportedReasoningEfforts ?? []).map((e) => e.reasoningEffort).filter((e) => ["low", "medium", "high", "xhigh", "max"].includes(e));
+        models.push({
+          value: model.model,
+          resolvedModel: model.model,
+          displayName: model.displayName,
+          description: model.description,
+          supportsEffort: levels.length > 0,
+          effortLevels: levels,
+          supportsThinking: false,
+          supportsAutoMode: false
+        });
+      }
+      cursor = page.nextCursor;
+    } while (cursor && this.#rpc === rpc);
+    if (this.#capabilities && this.#rpc === rpc) {
+      this.#capabilities.models = models;
+      this.emit("capabilities");
+    }
+  }
+  sendPrompt(text, images) {
+    const reason = networkGuard.blockedReason();
+    if (reason) {
+      this.#notice(new Error(reason));
+      return;
+    }
+    if (this.#state === "closed" || this.#state === "error") {
+      this.#notice(new Error("\u041F\u0435\u0440\u0435\u043F\u043E\u0434\u043A\u043B\u044E\u0447\u0438\u0442\u0435 \u0441\u0435\u0441\u0441\u0438\u044E Codex \u043F\u0435\u0440\u0435\u0434 \u043E\u0442\u043F\u0440\u0430\u0432\u043A\u043E\u0439"));
+      return;
+    }
+    if (!text.trim() && !images?.length)
+      return;
+    this.#append({ kind: "user.message", text, ...images?.length ? { images } : {} });
+    if (this.#titleIsDefault) {
+      this.#record.title = text.trim().split("\n")[0].slice(0, 100) || "Codex";
+      this.#titleIsDefault = false;
+      this.emit("summary", this.summary());
+    }
+    this.#queue.push({ text, images });
+    void this.#drain();
+  }
+  async #drain() {
+    if (this.#busy || this.#startingTurn || !this.#queue.length)
+      return;
+    const generation = this.#generation;
+    this.#busy = true;
+    this.#startingTurn = true;
+    try {
+      await this.#ready;
+      if (generation !== this.#generation)
+        return;
+      const prompt = this.#queue.shift();
+      if (!prompt || !this.#rpc || this.#state === "closed" || this.#state === "error") {
+        this.#busy = false;
+        return;
+      }
+      const reason = networkGuard.blockedReason();
+      if (reason)
+        throw new Error(reason);
+      this.#turnStartedAt = Date.now();
+      this.#turnUsage = null;
+      this.#turnUsageBaseline = this.#totalUsage;
+      this.#lastTurn = null;
+      this.#setState("running");
+      const policy = codexPolicy(this.#record.permissionMode);
+      const sandboxPolicy = this.#record.permissionMode === "bypassPermissions" ? { type: "dangerFullAccess" } : this.#record.permissionMode === "plan" ? { type: "readOnly", networkAccess: false } : {
+        type: "workspaceWrite",
+        writableRoots: [this.cwd],
+        networkAccess: false,
+        excludeTmpdirEnvVar: false,
+        excludeSlashTmp: false
+      };
+      const result = await this.#rpc.request("turn/start", {
+        threadId: this.#record.conversationId,
+        cwd: this.cwd,
+        input: [{ type: "text", text: prompt.text, text_elements: [] }, ...(prompt.images ?? []).map((image) => ({
+          type: "image",
+          url: `data:${image.mediaType};base64,${image.data}`
+        }))],
+        model: this.#record.model,
+        effort: this.#record.effort,
+        approvalPolicy: policy.approvalPolicy,
+        sandboxPolicy
+      });
+      if (this.#busy)
+        this.#turnId = result.turn.id;
+      if (this.#interruptRequested && this.#turnId)
+        await this.interrupt();
+    } catch (error) {
+      if (generation === this.#generation)
+        this.#fail(error);
+    } finally {
+      if (generation === this.#generation) {
+        this.#startingTurn = false;
+        if (!this.#busy)
+          void this.#drain();
+      }
+    }
+  }
+  #message(message) {
+    const p = message.params ?? {};
+    if (message.id !== void 0 && message.method) {
+      this.#request(message.id, message.method, p);
+      return;
+    }
+    if (p.threadId && p.threadId !== this.#record.conversationId)
+      return;
+    switch (message.method) {
+      case "turn/started": {
+        const turn = p.turn;
+        this.#turnId = turn.id;
+        break;
+      }
+      case "item/agentMessage/delta":
+      case "item/reasoning/summaryTextDelta": {
+        const id = String(p.itemId);
+        const thinking = message.method !== "item/agentMessage/delta";
+        const key = `${id}:${thinking ? "thinking" : "text"}`;
+        const delta = String(p.delta ?? "");
+        const block = this.#texts.get(key) ?? { text: "", thinking };
+        block.text += delta;
+        this.#texts.set(key, block);
+        this.#append({ kind: thinking ? "thinking.delta" : "assistant.delta", blockId: key, text: delta });
+        break;
+      }
+      case "item/started":
+        this.#item(p.item, false);
+        break;
+      case "item/completed":
+        this.#item(p.item, true);
+        break;
+      case "thread/tokenUsage/updated": {
+        const usage = p.tokenUsage;
+        if (usage?.last && usage.modelContextWindow) {
+          this.#context = { tokens: usage.last.totalTokens, maxTokens: usage.modelContextWindow, fetchedAt: Date.now() };
+          this.#record.context = this.#context;
+          this.emit("context", this.#context);
+        }
+        if (usage?.total) {
+          const total = {
+            inputTokens: usage.total.inputTokens,
+            outputTokens: usage.total.outputTokens,
+            cacheReadTokens: usage.total.cachedInputTokens ?? 0,
+            cacheCreationTokens: usage.total.cacheWriteInputTokens ?? 0
+          };
+          if (this.#busy && this.#turnUsageBaseline) {
+            const baseline = this.#turnUsageBaseline;
+            this.#turnUsage = {
+              inputTokens: Math.max(0, total.inputTokens - baseline.inputTokens),
+              outputTokens: Math.max(0, total.outputTokens - baseline.outputTokens),
+              cacheReadTokens: Math.max(0, total.cacheReadTokens - baseline.cacheReadTokens),
+              cacheCreationTokens: Math.max(0, total.cacheCreationTokens - baseline.cacheCreationTokens)
+            };
+          }
+          this.#totalUsage = total;
+        }
+        break;
+      }
+      case "account/rateLimits/updated":
+        if (p.rateLimits)
+          this.#setUsage(p.rateLimits);
+        break;
+      case "serverRequest/resolved": {
+        const requestId = String(p.requestId);
+        if (this.#pending.delete(requestId)) {
+          this.#append({ kind: "permission.resolved", requestId, decision: "deny", reason: "\u0417\u0430\u043F\u0440\u043E\u0441 \u0437\u0430\u043A\u0440\u044B\u0442 Codex" });
+          this.#setState(this.#pending.size ? "waiting_permission" : "running");
+        }
+        break;
+      }
+      case "turn/completed": {
+        const turn = p.turn;
+        this.#lastTurn = turn.status === "completed" ? "completed" : turn.status === "interrupted" ? "interrupted" : "failed";
+        if (turn.error?.message)
+          this.#notice(new Error(turn.error.message));
+        this.#finishTurn(turn.status, turn.durationMs);
+        void this.refreshUsage();
+        break;
+      }
+      case "error": {
+        const error = p.error;
+        this.#notice(new Error(error?.message ?? "\u041E\u0448\u0438\u0431\u043A\u0430 Codex"));
+        break;
+      }
+    }
+  }
+  #item(item, done) {
+    if (!item)
+      return;
+    this.#items.set(item.id, item);
+    if (item.type === "agentMessage" || item.type === "reasoning" || item.type === "plan") {
+      if (!done)
+        return;
+      const thinking = item.type === "reasoning";
+      const key = `${item.id}:${thinking ? "thinking" : "text"}`;
+      const text = item.text ?? item.summary?.join("\n") ?? this.#texts.get(key)?.text ?? "";
+      this.#texts.delete(key);
+      if (text)
+        this.#append({ kind: thinking ? "assistant.thinking" : "assistant.text", text, blockId: key });
+      return;
+    }
+    if (!["commandExecution", "fileChange", "mcpToolCall", "webSearch", "imageView", "collabAgentToolCall"].includes(item.type))
+      return;
+    if (!this.#tools.has(item.id)) {
+      this.#tools.add(item.id);
+      const name = item.type === "commandExecution" ? "Bash" : item.type === "fileChange" ? "apply_patch" : item.type === "mcpToolCall" ? `mcp__${item.server}__${item.tool}` : item.type;
+      const input = item.type === "commandExecution" ? { command: item.command, cwd: item.cwd } : item.type === "fileChange" ? { changes: item.changes, file_path: item.changes?.[0]?.path } : item.arguments ?? item.action ?? { query: item.query };
+      this.#append({ kind: "tool.use", toolUseId: item.id, name, input });
+    }
+    if (done) {
+      this.#tools.delete(item.id);
+      const output = item.aggregatedOutput ?? (item.changes ? item.changes.map((c) => `${c.path}
+${c.diff}`).join("\n") : typeof item.result === "string" ? item.result : JSON.stringify(item.error ?? item.result ?? item.action ?? "\u0413\u043E\u0442\u043E\u0432\u043E"));
+      this.#append({
+        kind: "tool.result",
+        toolUseId: item.id,
+        content: output,
+        isError: ["failed", "declined"].includes(item.status ?? "") || item.exitCode != null && item.exitCode !== 0 || !!item.error
+      });
+    }
+  }
+  #request(id, method, params) {
+    const requestId = String(id);
+    const questions = method === "item/tool/requestUserInput" ? params.questions.map((q) => ({ ...q, options: q.options ?? [], multiSelect: false })) : void 0;
+    const known = [
+      "item/commandExecution/requestApproval",
+      "item/fileChange/requestApproval",
+      "item/permissions/requestApproval",
+      "item/tool/requestUserInput"
+    ];
+    if (!known.includes(method)) {
+      this.#rpc?.write({ id, error: { code: -32601, message: `CCV does not support ${method}` } });
+      this.#notice(new Error(`Codex \u0437\u0430\u043F\u0440\u043E\u0441\u0438\u043B \u043D\u0435\u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u043C\u043E\u0435 \u0434\u0435\u0439\u0441\u0442\u0432\u0438\u0435: ${method}`));
+      return;
+    }
+    this.#pending.set(requestId, { id, method, params, questions });
+    this.#append({
+      kind: "permission.request",
+      requestId,
+      toolUseId: String(params.itemId ?? requestId),
+      toolName: questions ? "AskUserQuestion" : method.includes("commandExecution") ? "Bash" : method.includes("fileChange") ? "apply_patch" : "Codex permissions",
+      input: { ...params, ...this.#items.get(String(params.itemId))?.changes ? { changes: this.#items.get(String(params.itemId)).changes } : {} },
+      ...typeof params.reason === "string" ? { reason: params.reason } : {},
+      ...questions ? { questions } : {}
+    });
+    this.#setState("waiting_permission");
+  }
+  respondPermission(requestId, decision, reason, answers) {
+    const request2 = this.#pending.get(requestId);
+    if (!request2)
+      return;
+    let result = { decision: decision === "allow" ? "accept" : "decline" };
+    if (request2.questions) {
+      result = { answers: Object.fromEntries(request2.questions.map((q) => [q.id, {
+        answers: decision === "allow" ? [answers?.[q.question] ?? ""] : []
+      }])) };
+    } else if (request2.method === "item/permissions/requestApproval") {
+      result = { permissions: decision === "allow" ? request2.params.permissions : {}, scope: "turn" };
+    }
+    this.#rpc?.write({ id: request2.id, result });
+    this.#pending.delete(requestId);
+    this.#append({ kind: "permission.resolved", requestId, decision, reason, answers });
+    this.#setState(this.#pending.size ? "waiting_permission" : "running");
+  }
+  async interrupt() {
+    this.#queue = [];
+    if (!this.#busy)
+      return;
+    this.#interruptRequested = true;
+    if (this.#turnId && this.#rpc) {
+      await this.#rpc.request("turn/interrupt", { threadId: this.#record.conversationId, turnId: this.#turnId });
+    }
+  }
+  #finishTurn(subtype, durationMs) {
+    for (const [blockId, block] of this.#texts) {
+      this.#append({ kind: block.thinking ? "assistant.thinking" : "assistant.text", text: block.text, blockId });
+    }
+    this.#texts.clear();
+    for (const toolUseId of this.#tools) {
+      this.#append({ kind: "tool.result", toolUseId, content: "\u0414\u0435\u0439\u0441\u0442\u0432\u0438\u0435 \u043F\u0440\u0435\u0440\u0432\u0430\u043D\u043E", isError: true });
+    }
+    this.#tools.clear();
+    this.#items.clear();
+    this.#clearApprovals();
+    this.#append({
+      kind: "result",
+      subtype,
+      isError: this.#lastTurn === "failed",
+      durationMs: durationMs ?? Math.max(0, Date.now() - this.#turnStartedAt),
+      costUsd: null,
+      usage: this.#turnUsage,
+      contextTokens: this.#context?.tokens ?? null,
+      text: null
+    });
+    this.#busy = false;
+    this.#turnId = null;
+    this.#interruptRequested = false;
+    this.#setState("idle");
+    void this.#drain();
+  }
+  async setPermissionMode(mode) {
+    codexPolicy(mode);
+    this.#record.permissionMode = mode;
+    this.#settingsChanged();
+  }
+  async setModel(model) {
+    this.#record.model = model;
+    this.#record.effort = null;
+    this.#settingsChanged();
+  }
+  async setEffort(effort) {
+    const model = this.#capabilities?.models.find((m) => m.value === this.#record.model);
+    if (model && !model.effortLevels.includes(effort))
+      throw new Error("\u041C\u043E\u0434\u0435\u043B\u044C Codex \u043D\u0435 \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442 \u044D\u0442\u043E \u0443\u0441\u0438\u043B\u0438\u0435");
+    this.#record.effort = effort;
+    this.#settingsChanged();
+  }
+  #settingsChanged() {
+    if (this.#capabilities) {
+      this.#capabilities.model = this.#record.model ?? "";
+      this.#capabilities.permissionMode = this.#record.permissionMode;
+      this.emit("capabilities");
+    }
+    void this.#store.save(this.#record);
+    this.emit("summary", this.summary());
+  }
+  setTitle(title) {
+    this.#record.title = title;
+    this.#titleIsDefault = false;
+    this.#settingsChanged();
+  }
+  async refreshUsage(_force = false) {
+    if (!this.#rpc || networkGuard.blockedReason())
+      return;
+    try {
+      const reply = await this.#rpc.request("account/rateLimits/read");
+      this.#setUsage(reply.rateLimits);
+    } catch {
+    }
+  }
+  #setUsage(limits) {
+    this.#usage = codexUsage(limits);
+    this.emit("usage", this.#usage);
+  }
+  async refreshContext(_force = false) {
+    if (this.#context)
+      this.emit("context", this.#context);
+  }
+  reconnect(_reason) {
+    this.#disconnect();
+    this.#setState("starting");
+    this.#launch();
+  }
+  suspend(reason) {
+    this.#disconnect();
+    this.#notice(new Error(reason));
+    this.#setState("error");
+  }
+  async close(_reason = "closed by client") {
+    this.#disconnect();
+    this.#setState("closed");
+    await this.#flush();
+  }
+  #disconnect() {
+    this.#generation += 1;
+    this.#startingTurn = false;
+    const rpc = this.#rpc;
+    this.#rpc = null;
+    rpc?.close();
+    this.#queue = [];
+    if (this.#busy) {
+      this.#lastTurn = "interrupted";
+      this.#finishTurn("interrupted");
+    }
+    this.#clearApprovals();
+  }
+  #clearApprovals() {
+    for (const requestId of this.#pending.keys()) {
+      this.#append({ kind: "permission.resolved", requestId, decision: "deny", reason: "\u0425\u043E\u0434 \u0437\u0430\u0432\u0435\u0440\u0448\u0451\u043D" });
+    }
+    this.#pending.clear();
+  }
+  #notice(error) {
+    this.#append({ kind: "error", message: error instanceof Error ? error.message : String(error) });
+  }
+  #fail(error) {
+    if (this.#state === "closed")
+      return;
+    this.#queue = [];
+    if (this.#busy) {
+      this.#lastTurn = "failed";
+      this.#finishTurn("failed");
+    }
+    this.#notice(error);
+    const rpc = this.#rpc;
+    this.#rpc = null;
+    rpc?.close();
+    this.#setState("error");
+  }
+  #append(event) {
+    this.#record.updatedAt = Date.now();
+    const entry = this.journal.append(event);
+    this.emit("event", entry);
+    if (["assistant.delta", "thinking.delta", "state"].includes(event.kind))
+      return;
+    this.#unsaved.push({ ts: entry.ts, event });
+    if (!this.#flushTimer) {
+      this.#flushTimer = setTimeout(() => {
+        void this.#flush();
+      }, 500);
+      this.#flushTimer.unref?.();
+    }
+  }
+  async #flush() {
+    if (this.#flushTimer)
+      clearTimeout(this.#flushTimer);
+    this.#flushTimer = null;
+    const batch = this.#unsaved;
+    this.#unsaved = [];
+    await this.#store.appendEvents(this.id, batch);
+    await this.#store.save(this.#record);
+  }
+  #setState(state) {
+    this.#state = state;
+    this.#append({ kind: "state", state });
+    if (["idle", "error", "closed"].includes(state))
+      void this.#flush();
+    this.emit("summary", this.summary());
+  }
+  async editPrompt(_index, _text, _images) {
+    throw new Error("\u0412 \u0441\u0435\u0441\u0441\u0438\u0438 Codex \u043F\u0440\u0430\u0432\u043A\u0430 \u043F\u0440\u043E\u0448\u043B\u044B\u0445 \u0440\u0435\u043F\u043B\u0438\u043A \u043F\u043E\u043A\u0430 \u043D\u0435 \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442\u0441\u044F");
+  }
+  async setUltracode(_enabled) {
+  }
+  async setThinking(_enabled) {
+  }
+  async setSwitchModelsOnFlag(_enabled) {
+  }
+  async reloadPlugins() {
+  }
+  async mcpServerStatus() {
+    return [];
+  }
+  async addMcpServer(_name, _config) {
+    throw this.#mcpHint();
+  }
+  async removeMcpServer(_name) {
+    throw this.#mcpHint();
+  }
+  async reconnectMcpServer(_name) {
+    throw this.#mcpHint();
+  }
+  async toggleMcpServer(_name, _enabled) {
+    throw this.#mcpHint();
+  }
+  async authenticateMcpServer(_name) {
+    throw this.#mcpHint();
+  }
+  async submitMcpOAuthCallback(_name, _url) {
+    throw this.#mcpHint();
+  }
+  #mcpHint() {
+    return new Error("MCP Codex \u043D\u0430\u0441\u0442\u0440\u0430\u0438\u0432\u0430\u0435\u0442\u0441\u044F \u0447\u0435\u0440\u0435\u0437 codex mcp \u0438\u043B\u0438 ~/.codex/config.toml");
+  }
+};
+
 // ../host/dist/antigravity-store.js
 import { appendFile, mkdir as mkdir3, readFile as readFile4, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
-import path8 from "node:path";
+import path9 from "node:path";
 var AntigravityStore = class {
   #dir;
   #file;
   #records = /* @__PURE__ */ new Map();
   #loaded = null;
   #writing = Promise.resolve();
-  constructor(dataDir) {
-    this.#dir = path8.join(dataDir, "antigravity");
-    this.#file = path8.join(this.#dir, "sessions.json");
+  constructor(dataDir, provider = "antigravity") {
+    this.#dir = path9.join(dataDir, provider);
+    this.#file = path9.join(this.#dir, "sessions.json");
   }
   #load() {
     this.#loaded ??= (async () => {
@@ -4325,7 +5172,7 @@ var AntigravityStore = class {
     return entries;
   }
   #eventsFile(id) {
-    return path8.join(this.#dir, `${id.replace(/[^\w-]/g, "_")}.jsonl`);
+    return path9.join(this.#dir, `${id.replace(/[^\w-]/g, "_")}.jsonl`);
   }
   #persist() {
     const snapshot = JSON.stringify([...this.#records.values()], null, 2);
@@ -4345,10 +5192,10 @@ var AntigravityStore = class {
 };
 
 // ../host/dist/git.js
-import { execFile as execFile4 } from "node:child_process";
+import { execFile as execFile5 } from "node:child_process";
 import { mkdtemp, readFile as readFile5, rm as rm3, writeFile as writeFile4 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import path9 from "node:path";
+import path10 from "node:path";
 var TIMEOUT_MS = 2e4;
 var NET_TIMEOUT_MS = 5 * 6e4;
 var MAX_BUFFER = 32 * 1024 * 1024;
@@ -4664,7 +5511,7 @@ var GitRepo = class {
    * важнее всего (см. `checkIgnored`).
    */
   async #withoutRepo(args) {
-    const dir = await mkdtemp(path9.join(tmpdir2(), "ccv-git-"));
+    const dir = await mkdtemp(path10.join(tmpdir2(), "ccv-git-"));
     try {
       await this.#run(["init", "--bare", "--quiet", dir]);
       return await this.#soft([`--git-dir=${dir}`, `--work-tree=${this.cwd}`, ...args]);
@@ -4710,7 +5557,7 @@ var GitRepo = class {
    * исключил. Повторы отсеиваются, чтобы файл не рос от каждой публикации.
    */
   async #appendGitignore(paths) {
-    const file = path9.join(this.cwd, ".gitignore");
+    const file = path10.join(this.cwd, ".gitignore");
     const existing = await readFile5(file, "utf8").catch(() => "");
     const known = new Set(existing.split(/\r?\n/).map((line) => line.trim()));
     const lines = paths.map(ignorePattern).filter((line) => !known.has(line));
@@ -4735,7 +5582,7 @@ var GitRepo = class {
   #run(args, options2 = {}) {
     const token = options2.token ?? "";
     return new Promise((resolve, reject) => {
-      const child = execFile4(
+      const child = execFile5(
         "git",
         // core.quotepath=false — иначе кириллические пути приезжают в виде
         // «\320\277\321\200…» и в панели читаются как мусор.
@@ -4916,9 +5763,9 @@ function parsePatch(raw) {
       body = "";
     }
     total += body.length;
-    const path25 = status === "deleted" ? oldPath : newPath || oldPath;
+    const path26 = status === "deleted" ? oldPath : newPath || oldPath;
     files.push({
-      path: path25,
+      path: path26,
       oldPath: status === "renamed" ? oldPath : "",
       status,
       added: count(body, "+"),
@@ -4930,10 +5777,10 @@ function parsePatch(raw) {
   return { files, truncated };
 }
 function stripPrefix(value) {
-  const path25 = unquote(value.trim());
-  if (path25 === "/dev/null")
+  const path26 = unquote(value.trim());
+  if (path26 === "/dev/null")
     return "";
-  return path25.replace(/^[ab]\//, "");
+  return path26.replace(/^[ab]\//, "");
 }
 function count(body, mark) {
   let n = 0;
@@ -4945,9 +5792,9 @@ function count(body, mark) {
 }
 
 // ../host/dist/github.js
-import { execFile as execFile5 } from "node:child_process";
+import { execFile as execFile6 } from "node:child_process";
 import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile5 } from "node:fs/promises";
-import path10 from "node:path";
+import path11 from "node:path";
 var API = "https://api.github.com";
 var API_VERSION = "2022-11-28";
 var API_TIMEOUT_MS = 2e4;
@@ -4968,7 +5815,7 @@ var GitHubAccount = class {
    */
   #ghInstalled = null;
   constructor(dataDir) {
-    this.#storePath = path10.join(dataDir, "github.json");
+    this.#storePath = path11.join(dataDir, "github.json");
   }
   async load() {
     try {
@@ -4982,7 +5829,7 @@ var GitHubAccount = class {
   /** Сохранить токен или стереть его пустой строкой. */
   async setToken(token) {
     this.#token = token.trim();
-    await mkdir4(path10.dirname(this.#storePath), { recursive: true });
+    await mkdir4(path11.dirname(this.#storePath), { recursive: true });
     await writeFile5(this.#storePath, JSON.stringify({ token: this.#token }, null, 2), {
       encoding: "utf8",
       mode: 384
@@ -5134,7 +5981,7 @@ var GitHubAccount = class {
 };
 function gh(args) {
   return new Promise((resolve, reject) => {
-    execFile5("gh", args, { timeout: GH_TIMEOUT_MS, windowsHide: true, encoding: "utf8" }, (error, stdout, stderr) => {
+    execFile6("gh", args, { timeout: GH_TIMEOUT_MS, windowsHide: true, encoding: "utf8" }, (error, stdout, stderr) => {
       if (error)
         return reject(new Error(stderr.trim() || error.message));
       resolve(stdout);
@@ -5175,10 +6022,10 @@ function describe4(error) {
 }
 
 // ../host/dist/finder.js
-import { existsSync as existsSync2, statSync } from "node:fs";
+import { existsSync as existsSync3, statSync as statSync2 } from "node:fs";
 import { readdir as readdir2 } from "node:fs/promises";
 import os2 from "node:os";
-import path11 from "node:path";
+import path12 from "node:path";
 import { listSessions } from "@anthropic-ai/claude-agent-sdk";
 var CACHE_TTL = 6e4;
 var FIND_LIMIT = 50;
@@ -5217,7 +6064,7 @@ var ProjectFinder = class {
     if (needles.length === 0)
       return { candidates: [], truncated: false };
     const open = new Map(this.registry.list().map((workspace) => [workspace.path.toLowerCase(), workspace]));
-    const byName = this.#dirs.filter((dir) => matches(path11.basename(dir.path), needles));
+    const byName = this.#dirs.filter((dir) => matches(path12.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());
@@ -5228,7 +6075,7 @@ var ProjectFinder = class {
         return a.sessions > 0 ? -1 : 1;
       if (a.lastUsedAt !== b.lastUsedAt)
         return b.lastUsedAt - a.lastUsedAt;
-      return path11.basename(a.path).localeCompare(path11.basename(b.path), void 0, {
+      return path12.basename(a.path).localeCompare(path12.basename(b.path), void 0, {
         numeric: true,
         sensitivity: "base"
       });
@@ -5236,7 +6083,7 @@ var ProjectFinder = class {
     return {
       candidates: sorted.slice(0, FIND_LIMIT).map((dir) => ({
         path: dir.path,
-        name: path11.basename(dir.path) || dir.path,
+        name: path12.basename(dir.path) || dir.path,
         sessions: dir.sessions,
         lastUsedAt: dir.lastUsedAt || null,
         open: open.has(dir.path.toLowerCase()),
@@ -5260,7 +6107,7 @@ var ProjectFinder = class {
     const candidates = [];
     for (const entry of named) {
       const absolute = entry.path.trim();
-      if (!absolute || !path11.isAbsolute(absolute))
+      if (!absolute || !path12.isAbsolute(absolute))
         continue;
       const key = absolute.toLowerCase();
       if (seen.has(key))
@@ -5271,7 +6118,7 @@ var ProjectFinder = class {
       const record = known.get(key);
       candidates.push({
         path: record?.path ?? absolute,
-        name: path11.basename(absolute) || absolute,
+        name: path12.basename(absolute) || absolute,
         sessions: record?.sessions ?? 0,
         lastUsedAt: record?.lastUsedAt || null,
         open: open.has(key),
@@ -5328,7 +6175,7 @@ var ProjectFinder = class {
         if (!dirent.isDirectory() || SKIP_NAMES.has(dirent.name) || dirent.name.startsWith(".")) {
           continue;
         }
-        const full = path11.join(parent, dirent.name);
+        const full = path12.join(parent, dirent.name);
         const key = full.toLowerCase();
         if (dirs.has(key))
           continue;
@@ -5349,7 +6196,7 @@ var ProjectFinder = class {
   #parents(dirs) {
     const counted = /* @__PURE__ */ new Map();
     for (const dir of dirs) {
-      const parent = path11.dirname(dir.path);
+      const parent = path12.dirname(dir.path);
       if (parent === dir.path || !usable(parent))
         continue;
       const key = parent.toLowerCase();
@@ -5363,7 +6210,7 @@ var ProjectFinder = class {
   }
 };
 function usable(dir) {
-  return !contains(os2.tmpdir(), dir) && existsSync2(dir);
+  return !contains(os2.tmpdir(), dir) && existsSync3(dir);
 }
 function tokens(query2) {
   return query2.toLowerCase().split(/[^a-z0-9а-яё]+/i).filter(Boolean);
@@ -5374,7 +6221,7 @@ function matches(value, needles) {
 }
 function isDirectory(dir) {
   try {
-    return statSync(dir).isDirectory();
+    return statSync2(dir).isDirectory();
   } catch {
     return false;
   }
@@ -5460,15 +6307,15 @@ function fromText(text) {
 }
 
 // ../host/dist/workspaces.js
-import { existsSync as existsSync3, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync4, statSync as statSync3 } from "node:fs";
 import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile6 } from "node:fs/promises";
-import path12 from "node:path";
+import path13 from "node:path";
 import { listSessions as listSessions2 } from "@anthropic-ai/claude-agent-sdk";
 var WorkspaceRegistry = class {
   #entries = [];
   #storePath;
   constructor(dataDir) {
-    this.#storePath = path12.join(dataDir, "workspaces.json");
+    this.#storePath = path13.join(dataDir, "workspaces.json");
   }
   async load() {
     try {
@@ -5484,13 +6331,13 @@ var WorkspaceRegistry = class {
         if (isEntry(item))
           return item;
         return null;
-      }).filter((e) => e !== null && existsSync3(e.path));
+      }).filter((e) => e !== null && existsSync4(e.path));
     } catch {
       this.#entries = [];
     }
   }
   async #persist() {
-    await mkdir5(path12.dirname(this.#storePath), { recursive: true });
+    await mkdir5(path13.dirname(this.#storePath), { recursive: true });
     await writeFile6(this.#storePath, JSON.stringify(this.#entries, null, 2), "utf8");
   }
   /** Активные проекты. */
@@ -5510,8 +6357,8 @@ var WorkspaceRegistry = class {
     return entry ? toInfo(entry) : void 0;
   }
   async open(rawPath) {
-    const absolute = path12.resolve(rawPath);
-    if (!existsSync3(absolute)) {
+    const absolute = path13.resolve(rawPath);
+    if (!existsSync4(absolute)) {
       throw new Error(`\u041A\u0430\u0442\u0430\u043B\u043E\u0433 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D: ${absolute}`);
     }
     const existing = this.#entries.find((e) => e.path === absolute);
@@ -5577,24 +6424,24 @@ var WorkspaceRegistry = class {
   async create(parentRaw, nameRaw, init) {
     const name = nameRaw.trim();
     requireName(name);
-    const parent = path12.resolve(parentRaw.trim());
-    if (!existsSync3(parent)) {
+    const parent = path13.resolve(parentRaw.trim());
+    if (!existsSync4(parent)) {
       throw new Error(`\u041A\u0430\u0442\u0430\u043B\u043E\u0433 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D: ${parent}`);
     }
-    if (!statSync2(parent).isDirectory()) {
+    if (!statSync3(parent).isDirectory()) {
       throw new Error(`\u042D\u0442\u043E \u043D\u0435 \u043A\u0430\u0442\u0430\u043B\u043E\u0433: ${parent}`);
     }
-    const target = path12.join(parent, name);
-    if (existsSync3(target)) {
+    const target = path13.join(parent, name);
+    if (existsSync4(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 mkdir5(target);
     const warnings = [];
     if (init.claudeMd) {
-      await step(warnings, "CLAUDE.md", () => writeFile6(path12.join(target, "CLAUDE.md"), claudeMdStub(name), "utf8"));
+      await step(warnings, "CLAUDE.md", () => writeFile6(path13.join(target, "CLAUDE.md"), claudeMdStub(name), "utf8"));
     }
     if (init.readme) {
-      await step(warnings, "README.md", () => writeFile6(path12.join(target, "README.md"), readmeStub(name), "utf8"));
+      await step(warnings, "README.md", () => writeFile6(path13.join(target, "README.md"), readmeStub(name), "utf8"));
     }
     if (init.git) {
       await step(warnings, "git init", () => new GitRepo(target).init());
@@ -5666,8 +6513,8 @@ function toInfo(entry) {
   return {
     id: workspaceIdFromPath(absolute),
     path: absolute,
-    name: path12.basename(absolute) || absolute,
-    hasClaudeMd: existsSync3(path12.join(absolute, "CLAUDE.md")),
+    name: path13.basename(absolute) || absolute,
+    hasClaudeMd: existsSync4(path13.join(absolute, "CLAUDE.md")),
     ...archivedAt ? { archivedAt } : {}
   };
 }
@@ -5677,13 +6524,13 @@ function isEntry(value) {
 
 // ../host/dist/archive.js
 import { mkdir as mkdir6, readFile as readFile8, writeFile as writeFile7 } from "node:fs/promises";
-import path13 from "node:path";
+import path14 from "node:path";
 var SessionArchive = class {
   #archived = /* @__PURE__ */ new Map();
   #restored = /* @__PURE__ */ new Map();
   #storePath;
   constructor(dataDir) {
-    this.#storePath = path13.join(dataDir, "session-archive.json");
+    this.#storePath = path14.join(dataDir, "session-archive.json");
   }
   async load() {
     try {
@@ -5795,7 +6642,7 @@ var SessionArchive = class {
       archived: Object.fromEntries(this.#archived),
       restored: Object.fromEntries(this.#restored)
     };
-    await mkdir6(path13.dirname(this.#storePath), { recursive: true });
+    await mkdir6(path14.dirname(this.#storePath), { recursive: true });
     await writeFile7(this.#storePath, JSON.stringify(file, null, 2), "utf8");
   }
 };
@@ -5805,7 +6652,7 @@ function isRecord(value) {
 
 // ../host/dist/pins.js
 import { mkdir as mkdir7, readFile as readFile9, writeFile as writeFile8 } from "node:fs/promises";
-import path14 from "node:path";
+import path15 from "node:path";
 var SessionPins = class {
   #pinned = /* @__PURE__ */ new Map();
   /**
@@ -5820,7 +6667,7 @@ var SessionPins = class {
   #moved = /* @__PURE__ */ new Map();
   #storePath;
   constructor(dataDir) {
-    this.#storePath = path14.join(dataDir, "session-pins.json");
+    this.#storePath = path15.join(dataDir, "session-pins.json");
   }
   async load() {
     try {
@@ -5977,7 +6824,7 @@ var SessionPins = class {
       pinned: Object.fromEntries(this.#pinned),
       ...this.#moved.size > 0 ? { moved: Object.fromEntries(this.#moved) } : {}
     };
-    await mkdir7(path14.dirname(this.#storePath), { recursive: true });
+    await mkdir7(path15.dirname(this.#storePath), { recursive: true });
     await writeFile8(this.#storePath, JSON.stringify(file, null, 2), "utf8");
   }
 };
@@ -5987,12 +6834,12 @@ function isRecord2(value) {
 
 // ../host/dist/order.js
 import { mkdir as mkdir8, readFile as readFile10, writeFile as writeFile9 } from "node:fs/promises";
-import path15 from "node:path";
+import path16 from "node:path";
 var ListOrderStore = class {
   #order = emptyOrder();
   #storePath;
   constructor(dataDir) {
-    this.#storePath = path15.join(dataDir, "list-order.json");
+    this.#storePath = path16.join(dataDir, "list-order.json");
   }
   async load() {
     try {
@@ -6068,7 +6915,7 @@ var ListOrderStore = class {
     return changed;
   }
   async #persist() {
-    await mkdir8(path15.dirname(this.#storePath), { recursive: true });
+    await mkdir8(path16.dirname(this.#storePath), { recursive: true });
     await writeFile9(this.#storePath, JSON.stringify(this.#order, null, 2), "utf8");
   }
 };
@@ -6099,8 +6946,8 @@ function sanitize(value) {
 
 // ../host/dist/folders.js
 import { mkdir as mkdir9, readFile as readFile11, writeFile as writeFile10 } from "node:fs/promises";
-import path16 from "node:path";
-import { randomUUID as randomUUID3 } from "node:crypto";
+import path17 from "node:path";
+import { randomUUID as randomUUID4 } from "node:crypto";
 var COLOR_PATTERN = /^#[0-9a-f]{6}$/i;
 var Folders = class {
   #workspaceFolders = /* @__PURE__ */ new Map();
@@ -6111,7 +6958,7 @@ var Folders = class {
   #pinnedAssignments = /* @__PURE__ */ new Map();
   #storePath;
   constructor(dataDir) {
-    this.#storePath = path16.join(dataDir, "folders.json");
+    this.#storePath = path17.join(dataDir, "folders.json");
   }
   async load() {
     try {
@@ -6200,19 +7047,19 @@ var Folders = class {
     };
   }
   async createWorkspaceFolder(name) {
-    const id = randomUUID3();
+    const id = randomUUID4();
     this.#workspaceFolders.set(id, { name });
     await this.#persist();
     return id;
   }
   async createSessionFolder(workspaceId, name) {
-    const id = randomUUID3();
+    const id = randomUUID4();
     this.#sessionFolders.set(id, { name, workspaceId });
     await this.#persist();
     return id;
   }
   async createPinnedFolder(name) {
-    const id = randomUUID3();
+    const id = randomUUID4();
     this.#pinnedFolders.set(id, { name });
     await this.#persist();
     return id;
@@ -6392,7 +7239,7 @@ var Folders = class {
       sessionAssignments: Object.fromEntries(this.#sessionAssignments),
       pinnedAssignments: Object.fromEntries(this.#pinnedAssignments)
     };
-    await mkdir9(path16.dirname(this.#storePath), { recursive: true });
+    await mkdir9(path17.dirname(this.#storePath), { recursive: true });
     await writeFile10(this.#storePath, JSON.stringify(file, null, 2), "utf8");
   }
 };
@@ -6415,8 +7262,8 @@ function isPinnedFolder(value) {
 
 // ../host/dist/app-settings.js
 import { mkdir as mkdir10, readFile as readFile12, writeFile as writeFile11 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import path17 from "node:path";
+import { homedir as homedir5 } from "node:os";
+import path18 from "node:path";
 var DEFAULT_AUTO_ARCHIVE_AFTER_MS = 2 * 24 * 60 * 60 * 1e3;
 var MIN_AUTO_ARCHIVE_AFTER_MS = 60 * 60 * 1e3;
 var DEFAULT_AUTO_STOP_AFTER_MS = 10 * 60 * 1e3;
@@ -6424,7 +7271,7 @@ var MIN_AUTO_STOP_AFTER_MS = 60 * 1e3;
 var MIN_AUTO_SAVE_AFTER_PAUSE_MS = 500;
 var DEFAULT_BLOCKED_COUNTRIES = ["RU", "BY", "CN", "IR", "KP", "SY", "CU"];
 var FOLDER_ACCESS = ["all", "projects", "project"];
-var PROVIDERS = ["claude", "antigravity"];
+var PROVIDERS = ["claude", "antigravity", "codex"];
 var PERMISSION_MODES = [
   "default",
   "acceptEdits",
@@ -6459,7 +7306,7 @@ var DEFAULT_APP_SETTINGS = {
   limitStopFiveHourPct: 95,
   limitStopSevenDayPct: 99,
   // Оба: до появления настройки приложение предлагало обоих агентов.
-  enabledProviders: ["claude", "antigravity"],
+  enabledProviders: ["claude", "antigravity", "codex"],
   // Включено: запрос без VPN может стоить аккаунта, а тому, у кого маршрут и
   // так из разрешённой страны, защита ничем не мешает.
   networkGuardEnabled: true,
@@ -6469,7 +7316,7 @@ var AppSettingsStore = class {
   #settings = { ...DEFAULT_APP_SETTINGS };
   #storePath;
   constructor(dataDir) {
-    this.#storePath = path17.join(dataDir, "app-settings.json");
+    this.#storePath = path18.join(dataDir, "app-settings.json");
   }
   async load() {
     try {
@@ -6493,7 +7340,7 @@ var AppSettingsStore = class {
   async update(patch) {
     const next = sanitize2(patch, this.#settings);
     this.#settings = next;
-    await mkdir10(path17.dirname(this.#storePath), { recursive: true });
+    await mkdir10(path18.dirname(this.#storePath), { recursive: true });
     await writeFile11(this.#storePath, JSON.stringify(next, null, 2), "utf8");
     return this.current;
   }
@@ -6560,7 +7407,7 @@ function sanitize2(value, fallback) {
   return result;
 }
 function claudeHome() {
-  return path17.join(homedir4(), ".claude");
+  return path18.join(homedir5(), ".claude");
 }
 function writableRoots(mode, cwd, workspacePaths) {
   if (mode === "all")
@@ -6570,7 +7417,7 @@ function writableRoots(mode, cwd, workspacePaths) {
     return [...roots];
   for (const workspace of [cwd, ...workspacePaths]) {
     roots.add(workspace);
-    const parent = path17.dirname(workspace);
+    const parent = path18.dirname(workspace);
     if (parent !== workspace)
       roots.add(parent);
   }
@@ -6579,11 +7426,11 @@ function writableRoots(mode, cwd, workspacePaths) {
 
 // ../host/dist/handoff-store.js
 import { mkdir as mkdir11, readFile as readFile13, readdir as readdir3, rm as rm4, writeFile as writeFile12 } from "node:fs/promises";
-import path18 from "node:path";
+import path19 from "node:path";
 var HandoffStore = class {
   #dir;
   constructor(dataDir) {
-    this.#dir = path18.join(dataDir, "handoffs");
+    this.#dir = path19.join(dataDir, "handoffs");
   }
   async get(sessionId) {
     const file = this.#file(sessionId);
@@ -6620,7 +7467,7 @@ var HandoffStore = class {
   #file(sessionId) {
     if (!/^[\w-]{1,128}$/.test(sessionId))
       return null;
-    return path18.join(this.#dir, `${sessionId}.json`);
+    return path19.join(this.#dir, `${sessionId}.json`);
   }
 };
 var SAME_WINDOW_MS = 5 * 6e4;
@@ -6628,7 +7475,7 @@ var LimitStopState = class {
   #fired = {};
   #storePath;
   constructor(dataDir) {
-    this.#storePath = path18.join(dataDir, "limit-stop.json");
+    this.#storePath = path19.join(dataDir, "limit-stop.json");
   }
   async load() {
     try {
@@ -6664,7 +7511,7 @@ var LimitStopState = class {
   /** Запомнить срабатывание до `until` (момент сброса окна). */
   async mark(limit, until) {
     this.#fired[limit] = until;
-    await mkdir11(path18.dirname(this.#storePath), { recursive: true });
+    await mkdir11(path19.dirname(this.#storePath), { recursive: true });
     await writeFile12(this.#storePath, JSON.stringify(this.#fired, null, 2), "utf8");
   }
 };
@@ -6770,8 +7617,8 @@ function capitalize(text) {
 
 // ../host/dist/plugins.js
 import { readFile as readFile14 } from "node:fs/promises";
-import { homedir as homedir5 } from "node:os";
-import path19 from "node:path";
+import { homedir as homedir6 } from "node:os";
+import path20 from "node:path";
 var TIMEOUT_MS2 = 12e4;
 var SAFE_ARG = /^[A-Za-z0-9][A-Za-z0-9._@/-]*$/;
 var PluginCli = class {
@@ -6870,10 +7717,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 || path19.join(homedir5(), ".claude", "plugins", "marketplaces", market.name);
+  const root = market.installLocation || path20.join(homedir6(), ".claude", "plugins", "marketplaces", market.name);
   let manifest;
   try {
-    const text = await readFile14(path19.join(root, ".claude-plugin", "marketplace.json"), "utf8");
+    const text = await readFile14(path20.join(root, ".claude-plugin", "marketplace.json"), "utf8");
     manifest = JSON.parse(text);
   } catch {
     return [];
@@ -6916,7 +7763,7 @@ function authorName(raw) {
 }
 
 // ../host/dist/auth.js
-import { EventEmitter as EventEmitter4 } from "node:events";
+import { EventEmitter as EventEmitter6 } from "node:events";
 var QUICK_TIMEOUT_MS = 3e4;
 var LOGIN_TIMEOUT_MS = 10 * 6e4;
 var URL_RE = /https:\/\/\S*\/oauth\/authorize\S*/;
@@ -6928,7 +7775,7 @@ var IDLE = {
   output: "",
   error: null
 };
-var AuthCli = class extends EventEmitter4 {
+var AuthCli = class extends EventEmitter6 {
   #child = null;
   #state = IDLE;
   #timer = null;
@@ -7113,9 +7960,9 @@ function describe5(error) {
 }
 
 // ../host/dist/relay-link.js
-import { EventEmitter as EventEmitter5 } from "node:events";
+import { EventEmitter as EventEmitter7 } from "node:events";
 import { readFile as readFile15, writeFile as writeFile13, rm as rm5, mkdir as mkdir12 } from "node:fs/promises";
-import path20 from "node:path";
+import path21 from "node:path";
 import { hostname } from "node:os";
 import WebSocket from "ws";
 
@@ -7132,7 +7979,7 @@ var SILENCE_TIMEOUT_MS = 95e3;
 function jitter(delay2) {
   return Math.round(delay2 * (0.8 + Math.random() * 0.4));
 }
-var RelayLink = class extends EventEmitter5 {
+var RelayLink = class extends EventEmitter7 {
   #credentials = null;
   #socket = null;
   #retry = RETRY_MIN_MS;
@@ -7170,7 +8017,7 @@ var RelayLink = class extends EventEmitter5 {
   #log;
   constructor(options2) {
     super();
-    this.#file = path20.join(options2.dataDir, "relay.json");
+    this.#file = path21.join(options2.dataDir, "relay.json");
     this.#defaultUrl = options2.defaultUrl.replace(/\/+$/, "");
     this.#log = options2.log ?? ((msg) => console.log(`[relay] ${msg}`));
   }
@@ -7264,7 +8111,7 @@ var RelayLink = class extends EventEmitter5 {
     }
   }
   async #write(credentials) {
-    await mkdir12(path20.dirname(this.#file), { recursive: true });
+    await mkdir12(path21.dirname(this.#file), { recursive: true });
     await writeFile13(this.#file, `${JSON.stringify(credentials, null, 2)}
 `, {
       encoding: "utf8",
@@ -7520,14 +8367,14 @@ function humanize(error) {
 }
 
 // ../host/dist/terminal.js
-import { EventEmitter as EventEmitter6 } from "node:events";
-import { access as access2, constants as constants2 } from "node:fs/promises";
-import path21 from "node:path";
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { EventEmitter as EventEmitter8 } from "node:events";
+import { access as access2, constants as constants3 } from "node:fs/promises";
+import path22 from "node:path";
+import { randomUUID as randomUUID5 } from "node:crypto";
 var SCROLLBACK_BYTES = 256 * 1024;
 var FLUSH_MS = 12;
 var MAX_TERMINALS = 24;
-var TerminalHub = class extends EventEmitter6 {
+var TerminalHub = class extends EventEmitter8 {
   #terminals = /* @__PURE__ */ new Map();
   #module = null;
   list(workspaceId) {
@@ -7560,7 +8407,7 @@ var TerminalHub = class extends EventEmitter6 {
       env: environment()
     });
     const info = {
-      id: randomUUID4(),
+      id: randomUUID5(),
       workspaceId: options2.workspaceId,
       title: shell.title,
       shell: shell.file,
@@ -7692,36 +8539,36 @@ async function defaultShell() {
     if (pwsh)
       return { file: pwsh, args: [], title: "pwsh" };
     const system = process.env.SystemRoot ?? "C:\\Windows";
-    const powershell = path21.join(system, "System32/WindowsPowerShell/v1.0/powershell.exe");
+    const powershell = path22.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: path21.basename(shell) };
+    return { file: shell, args: [], title: path22.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(path21.delimiter).filter(Boolean);
+  const dirs = (process.env.PATH ?? "").split(path22.delimiter).filter(Boolean);
   for (const dir of dirs) {
-    const candidate = path21.join(dir, name);
+    const candidate = path22.join(dir, name);
     if (await exists2(candidate))
       return candidate;
   }
   return null;
 }
 function exists2(file) {
-  return access2(file, constants2.X_OK).then(() => true, () => false);
+  return access2(file, constants3.X_OK).then(() => true, () => false);
 }
 
 // ../host/dist/mcp-config.js
 import { readFile as readFile16, writeFile as writeFile14, mkdir as mkdir13 } from "node:fs/promises";
-import path22 from "node:path";
+import path23 from "node:path";
 var MCP_FILE = ".mcp.json";
-var LOCAL_SETTINGS2 = path22.join(".claude", "settings.local.json");
+var LOCAL_SETTINGS2 = path23.join(".claude", "settings.local.json");
 var queues = /* @__PURE__ */ new Map();
 function serialize(cwd, work) {
   const previous = queues.get(cwd) ?? Promise.resolve();
@@ -7730,7 +8577,7 @@ function serialize(cwd, work) {
   return next;
 }
 async function readProjectServers(cwd) {
-  const file = await readJson(path22.join(cwd, MCP_FILE));
+  const file = await readJson(path23.join(cwd, MCP_FILE));
   const servers = file?.mcpServers;
   if (!servers || typeof servers !== "object")
     return {};
@@ -7738,23 +8585,23 @@ async function readProjectServers(cwd) {
 }
 function addProjectServer(cwd, name, config) {
   return serialize(cwd, async () => {
-    const file = await readJson(path22.join(cwd, MCP_FILE)) ?? {};
+    const file = await readJson(path23.join(cwd, MCP_FILE)) ?? {};
     const servers = file.mcpServers ?? {};
     servers[name] = config;
     file.mcpServers = servers;
-    await writeJson(path22.join(cwd, MCP_FILE), file);
+    await writeJson(path23.join(cwd, MCP_FILE), file);
     await approve(cwd, name);
   });
 }
 function removeProjectServer(cwd, name) {
   return serialize(cwd, async () => {
-    const file = await readJson(path22.join(cwd, MCP_FILE));
+    const file = await readJson(path23.join(cwd, MCP_FILE));
     const servers = file?.mcpServers;
     if (!servers || !(name in servers))
       return false;
     delete servers[name];
-    await writeJson(path22.join(cwd, MCP_FILE), file);
-    const settingsPath = path22.join(cwd, LOCAL_SETTINGS2);
+    await writeJson(path23.join(cwd, MCP_FILE), file);
+    const settingsPath = path23.join(cwd, LOCAL_SETTINGS2);
     const settings = await readJson(settingsPath);
     const enabled = settings?.enabledMcpjsonServers;
     if (settings && Array.isArray(enabled) && enabled.includes(name)) {
@@ -7765,7 +8612,7 @@ function removeProjectServer(cwd, name) {
   });
 }
 async function approve(cwd, name) {
-  const file = path22.join(cwd, LOCAL_SETTINGS2);
+  const file = path23.join(cwd, LOCAL_SETTINGS2);
   const settings = await readJson(file) ?? {};
   const enabled = Array.isArray(settings.enabledMcpjsonServers) ? settings.enabledMcpjsonServers : [];
   if (!enabled.includes(name))
@@ -7811,13 +8658,13 @@ async function readJson(file) {
     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 ${path22.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 ${path23.basename(file)}: ${error.message}`);
     }
     throw error;
   }
 }
 async function writeJson(file, data) {
-  await mkdir13(path22.dirname(file), { recursive: true });
+  await mkdir13(path23.dirname(file), { recursive: true });
   await writeFile14(file, `${JSON.stringify(data, null, 2)}
 `, "utf8");
 }
@@ -7836,6 +8683,8 @@ var BUSY_STATES2 = /* @__PURE__ */ new Set([
   "reconnecting"
 ]);
 var HostServer = class {
+  #httpServer = null;
+  #webSockets = null;
   #options;
   #workspaces;
   #archive;
@@ -7848,6 +8697,7 @@ var HostServer = class {
   /** Опросы статуса для идущих OAuth-входов MCP, ключ — сессия и сервер. */
   #mcpAuthWatch = /* @__PURE__ */ new Map();
   #antigravity;
+  #codex;
   /** Боковые сессии («вопрос на полях») по id родителя — не больше одной на разговор. */
   #sides = /* @__PURE__ */ new Map();
   /**
@@ -7895,7 +8745,7 @@ var HostServer = class {
   #limitHandoffBusy = /* @__PURE__ */ new Set();
   /** Живые id сессий, у которых сейчас пишется ручной хэндофф. */
   #handoffBusy = /* @__PURE__ */ new Set();
-  #hostId = randomUUID5();
+  #hostId = randomUUID6();
   #plugins = new PluginCli();
   #auth = new AuthCli();
   #relay;
@@ -7919,6 +8769,7 @@ var HostServer = class {
     this.#folders = new Folders(options2.dataDir);
     this.#settings = new AppSettingsStore(options2.dataDir);
     this.#antigravity = new AntigravityStore(options2.dataDir);
+    this.#codex = new AntigravityStore(options2.dataDir, "codex");
     this.#handoffs = new HandoffStore(options2.dataDir);
     this.#limitStop = new LimitStopState(options2.dataDir);
     this.#finder = new ProjectFinder(this.#workspaces);
@@ -7945,9 +8796,11 @@ var HostServer = class {
       const id = workspaceIdFromPath(dir);
       const onDisk = await this.#workspaces.sessionsOnDisk(id);
       const antigravity = await this.#antigravity.list(id);
-      return [...onDisk.map((s) => s.sessionId), ...antigravity.map((r) => r.id)];
+      const codex = await this.#codex.list(id);
+      return [...onDisk.map((s) => s.sessionId), ...antigravity.map((r) => r.id), ...codex.map((r) => r.id)];
     });
     await this.#antigravity.remapWorkspaceIds(remap);
+    await this.#codex.remapWorkspaceIds(remap);
     await this.#archive.remapWorkspaceIds(remap);
     await this.#pins.remapWorkspaceIds(remap);
     await this.#order.remapWorkspaceIds(remap);
@@ -7982,6 +8835,8 @@ var HostServer = class {
         resolve();
       });
     });
+    this.#httpServer = httpServer;
+    this.#webSockets = wss;
     await this.#relay.start().catch((error) => {
       console.error("[relay]", error instanceof Error ? error.message : String(error));
     });
@@ -8020,6 +8875,16 @@ var HostServer = class {
     await this.#relay.close();
     await Promise.all([...this.#sessions.values()].map((s) => s.close("host shutdown")));
     this.#sessions.clear();
+    const wss = this.#webSockets;
+    const http = this.#httpServer;
+    this.#webSockets = null;
+    this.#httpServer = null;
+    for (const socket of wss?.clients ?? [])
+      socket.terminate();
+    await Promise.all([
+      ...wss ? [new Promise((resolve) => wss.close(() => resolve()))] : [],
+      ...http ? [new Promise((resolve) => http.close(() => resolve()))] : []
+    ]);
   }
   // -------------------------------------------------------------------------
   // WebSocket
@@ -9419,7 +10284,31 @@ var HostServer = class {
       throw new Error(`\u0412\u043E\u0440\u043A\u0441\u043F\u0435\u0439\u0441 \u043D\u0435 \u043D\u0430\u0439\u0434\u0435\u043D: ${frame.workspaceId}`);
     const provider = frame.provider ?? "claude";
     if (!frame.resume && !this.#settings.current.enabledProviders.includes(provider)) {
-      throw new Error(`${provider === "antigravity" ? "Antigravity" : "Claude"} \u0432\u044B\u043A\u043B\u044E\u0447\u0435\u043D \u0432 \u043D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0430\u0445`);
+      throw new Error(`${provider === "antigravity" ? "Antigravity" : provider === "codex" ? "Codex" : "Claude"} \u0432\u044B\u043A\u043B\u044E\u0447\u0435\u043D \u0432 \u043D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0430\u0445`);
+    }
+    const codexRecord = frame.resume ? await this.#codex.find(frame.resume) : null;
+    if (codexRecord || !frame.resume && provider === "codex") {
+      if (frame.fork)
+        throw new Error("\u0412\u0435\u0442\u0432\u043B\u0435\u043D\u0438\u0435 \u0441\u0435\u0441\u0441\u0438\u0439 Codex \u043F\u043E\u043A\u0430 \u043D\u0435 \u043F\u043E\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u0442\u0441\u044F");
+      if (codexRecord && codexRecord.workspaceId !== workspace.id)
+        throw new Error("\u0421\u0435\u0441\u0441\u0438\u044F Codex \u043F\u0440\u0438\u043D\u0430\u0434\u043B\u0435\u0436\u0438\u0442 \u0434\u0440\u0443\u0433\u043E\u043C\u0443 \u043F\u0440\u043E\u0435\u043A\u0442\u0443");
+      if (codexRecord)
+        await this.#archive.unarchive([codexRecord.id]);
+      const session2 = new CodexSession({
+        workspaceId: workspace.id,
+        cwd: codexRecord?.cwd ?? workspace.path,
+        store: this.#codex,
+        ...codexRecord ? { record: codexRecord } : {},
+        ...frame.permissionMode ? { permissionMode: frame.permissionMode } : {},
+        ...frame.model ? { model: frame.model } : {},
+        defaultTitle: workspace.name
+      });
+      this.#wire(session2);
+      this.#sessions.set(session2.id, session2);
+      session2.start();
+      this.#sendLive();
+      this.#send(socket, { type: "session.summary", session: session2.summary() });
+      return;
     }
     const agyRecord = frame.resume ? await this.#antigravity.find(frame.resume) : null;
     if (agyRecord || !frame.resume && frame.provider === "antigravity") {
@@ -9583,7 +10472,7 @@ var HostServer = class {
       this.#broadcast({ type: "context.state", sessionId: session.id, context });
     });
     session.on("stderr", (data) => {
-      const tag = session instanceof AntigravitySession ? "agy" : "claude";
+      const tag = session instanceof AntigravitySession ? "agy" : session instanceof CodexSession ? "codex" : "claude";
       process.stderr.write(`[${tag} ${session.id.slice(0, 8)}] ${data}`);
     });
   }
@@ -9603,7 +10492,7 @@ var HostServer = class {
    * разговора пока и не было.
    */
   #ensureSide(parent) {
-    if (parent instanceof AntigravitySession) {
+    if (!(parent instanceof ClaudeSession)) {
       throw new Error("\u0412\u043E\u043F\u0440\u043E\u0441 \u043D\u0430 \u043F\u043E\u043B\u044F\u0445 \u0434\u043E\u0441\u0442\u0443\u043F\u0435\u043D \u0442\u043E\u043B\u044C\u043A\u043E \u0432 \u0441\u0435\u0441\u0441\u0438\u044F\u0445 Claude");
     }
     const existing = this.#sides.get(parent.id);
@@ -9661,7 +10550,7 @@ var HostServer = class {
    */
   #roots() {
     const roots = this.#finder.roots();
-    return roots.length > 0 ? roots : [homedir6()];
+    return roots.length > 0 ? roots : [homedir7()];
   }
   /**
    * Где сессии этого каталога разрешено писать без вопроса.
@@ -9903,7 +10792,7 @@ var HostServer = class {
       live.setTitle(title);
       return;
     }
-    if (await this.#antigravity.rename(sessionId, title)) {
+    if (await this.#antigravity.rename(sessionId, title) || await this.#codex.rename(sessionId, title)) {
       if (workspaceId)
         await this.#sendSessionList(workspaceId);
       return;
@@ -9960,6 +10849,11 @@ var HostServer = class {
         continue;
       historical.push(antigravitySummary(record));
     }
+    for (const record of await this.#codex.list(workspaceId)) {
+      if (liveIds.has(record.id))
+        continue;
+      historical.push({ ...antigravitySummary(record), provider: "codex", switchModelsOnFlag: false });
+    }
     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);
@@ -10006,15 +10900,15 @@ var HostServer = class {
   }
   #serveStatic(req, res) {
     const webRoot = this.#options.webRoot;
-    if (!webRoot || !existsSync4(webRoot)) {
+    if (!webRoot || !existsSync5(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 = path23.join(webRoot, path23.normalize(url2.pathname));
-    const target = requested.startsWith(webRoot) && existsSync4(requested) && statSync3(requested).isFile() ? requested : path23.join(webRoot, "index.html");
-    if (!existsSync4(target)) {
+    const requested = path24.join(webRoot, path24.normalize(url2.pathname));
+    const target = requested.startsWith(webRoot) && existsSync5(requested) && statSync4(requested).isFile() ? requested : path24.join(webRoot, "index.html");
+    if (!existsSync5(target)) {
       res.writeHead(404).end("not found");
       return;
     }
@@ -10039,7 +10933,7 @@ function contentType(file) {
     ".svg": "image/svg+xml",
     ".woff2": "font/woff2"
   };
-  return types[path23.extname(file)] ?? "application/octet-stream";
+  return types[path24.extname(file)] ?? "application/octet-stream";
 }
 function antigravitySummary(record) {
   return {
@@ -10068,9 +10962,9 @@ function antigravitySummary(record) {
 }
 
 // dist/ccv.js
-var HERE = path24.dirname(fileURLToPath(import.meta.url));
-var PACKAGE_ROOT = path24.resolve(HERE, "..");
-var USAGE = `ccv \u2014 Claude Code Visual: \u043B\u043E\u043A\u0430\u043B\u044C\u043D\u044B\u0439 \u0445\u043E\u0441\u0442 Claude Code \u0441 \u0438\u043D\u0442\u0435\u0440\u0444\u0435\u0439\u0441\u043E\u043C \u0432 \u0431\u0440\u0430\u0443\u0437\u0435\u0440\u0435.
+var HERE = path25.dirname(fileURLToPath(import.meta.url));
+var PACKAGE_ROOT = path25.resolve(HERE, "..");
+var USAGE = `ccv \u2014 Claude Code Visual: \u0438\u043D\u0442\u0435\u0440\u0444\u0435\u0439\u0441 \u043A Claude Code, Codex \u0438 Antigravity \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]
@@ -10079,12 +10973,12 @@ var USAGE = `ccv \u2014 Claude Code Visual: \u043B\u043E\u043A\u0430\u043B\u044C
   -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
+      --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 Claude, \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.
+CCV_CLAUDE_PATH, CCV_BUNDLED_CLAUDE, CCV_CODEX_PATH, CCV_AGY_PATH.
 \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" },
@@ -10136,7 +11030,7 @@ var server = new HostServer({
   dataDir: defaults.dataDir,
   // UI лежит в пакете рядом с бандлом — это и есть разница между установленной
   // утилитой и запуском из репозитория, где сборка живёт в `apps/web/dist`.
-  webRoot: process.env.CCV_WEB_ROOT ?? path24.join(PACKAGE_ROOT, "web"),
+  webRoot: process.env.CCV_WEB_ROOT ?? path25.join(PACKAGE_ROOT, "web"),
   version,
   relayUrl: defaults.relayUrl
 });
@@ -10165,7 +11059,7 @@ for (const signal of ["SIGINT", "SIGTERM"]) {
 }
 async function packageVersion() {
   try {
-    const text = await readFile17(path24.join(PACKAGE_ROOT, "package.json"), "utf8");
+    const text = await readFile17(path25.join(PACKAGE_ROOT, "package.json"), "utf8");
     return JSON.parse(text).version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -10209,7 +11103,7 @@ function openBrowser(target) {
     return;
   }
   const command = process.platform === "win32" ? { file: "cmd", args: ["/c", "start", "", target] } : process.platform === "darwin" ? { file: "open", args: [target] } : { file: "xdg-open", args: [target] };
-  const child = spawn3(command.file, command.args, {
+  const child = spawn4(command.file, command.args, {
     stdio: "ignore",
     detached: true,
     windowsHide: true