@codexhost/cli-linux-arm64 0.10.2 → 0.12.0

package/app/plugins/kimi-code/plugin.mjs

@@ -5,9 +5,491 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// ../../harness-discovery/dist/environment.js
+import fs from "node:fs";
+import path from "node:path";
+function targetPath(platform) {
+  return platform === "win32" ? path.win32 : path.posix;
+}
+function environmentValue(environment, name) {
+  const lowered = name.toLowerCase();
+  for (const [key, value] of Object.entries(environment)) {
+    if (key.toLowerCase() === lowered)
+      return value;
+  }
+  return void 0;
+}
+function pathDelimiter(platform) {
+  return platform === "win32" ? ";" : ":";
+}
+function pathDirectories(environment, platform) {
+  return (environmentValue(environment, "PATH") ?? "").split(pathDelimiter(platform)).map((directory) => directory.trim().replace(/^"|"$/gu, "")).filter(Boolean);
+}
+function executableExtensions(command, platform, environment) {
+  if (platform !== "win32")
+    return [""];
+  if (targetPath(platform).extname(command) !== "")
+    return [""];
+  return (environmentValue(environment, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD").split(";").map((extension) => extension.trim()).filter(Boolean);
+}
+function isExecutableFile(filePath, platform) {
+  try {
+    fs.accessSync(filePath, platform === "win32" ? fs.constants.F_OK : fs.constants.X_OK);
+    return fs.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+function subdirectoryNames(directory) {
+  try {
+    return fs.readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+function newestFirst(names) {
+  return [...names].sort((left, right) => right.localeCompare(left, void 0, { numeric: true }));
+}
+
+// ../../harness-discovery/dist/invocation.js
+import path2 from "node:path";
+function commandInvocation(command, arguments_, environment, platform = process.platform) {
+  const extension = path2.win32.extname(command).toLowerCase();
+  if (platform !== "win32" || ![".cmd", ".bat"].includes(extension)) {
+    return { command, arguments: [...arguments_], windowsVerbatimArguments: false };
+  }
+  const quote = (value) => `"${value.replaceAll("%", "%%").replaceAll('"', '""')}"`;
+  const commandLine = [command, ...arguments_].map(quote).join(" ");
+  return {
+    command: environmentValue(environment, "ComSpec") ?? "cmd.exe",
+    arguments: ["/d", "/v:off", "/s", "/c", `"${commandLine}"`],
+    windowsVerbatimArguments: true
+  };
+}
+
+// ../../harness-discovery/dist/node-runtime.js
+import path3 from "node:path";
+function withNodeRuntimeOnPath(environment, runtimeExecutable = process.execPath, platform = process.platform) {
+  const pathKey = Object.keys(environment).find((name) => name.toLowerCase() === "path") ?? "PATH";
+  const delimiter = platform === "win32" ? ";" : ":";
+  const runtimeDirectory = path3.dirname(runtimeExecutable);
+  const directories = (environment[pathKey] ?? "").split(delimiter).filter(Boolean);
+  const equal = platform === "win32" ? (value) => value.toLowerCase() : (value) => value;
+  if (!directories.some((directory) => equal(directory) === equal(runtimeDirectory))) {
+    directories.push(runtimeDirectory);
+  }
+  return { ...environment, [pathKey]: directories.join(delimiter) };
+}
+
+// ../../harness-discovery/dist/resolve.js
+import os from "node:os";
+
+// ../../harness-discovery/dist/version-managers.js
+function versionManagerBinaryDirectories(context) {
+  const { platform, environment, home } = context;
+  const list = context.subdirectories ?? subdirectoryNames;
+  const pathFlavor = targetPath(platform);
+  const value = (name) => environmentValue(environment, name);
+  const directories = [];
+  const versioned = (root, ...tail) => {
+    for (const version2 of newestFirst(list(root))) {
+      directories.push(pathFlavor.join(root, version2, ...tail));
+    }
+  };
+  if (platform === "win32") {
+    const appData = value("APPDATA") ?? pathFlavor.join(home, "AppData", "Roaming");
+    const localAppData = value("LOCALAPPDATA") ?? pathFlavor.join(home, "AppData", "Local");
+    versioned(pathFlavor.join(appData, "nvm"));
+    versioned(value("FNM_DIR") ?? pathFlavor.join(appData, "fnm", "node-versions"), "installation");
+    directories.push(pathFlavor.join(localAppData, "Volta", "bin"));
+    directories.push(pathFlavor.join(home, ".bun", "bin"));
+    const pnpmHome2 = value("PNPM_HOME");
+    if (pnpmHome2)
+      directories.push(pnpmHome2);
+    directories.push(pathFlavor.join(localAppData, "pnpm"));
+    return directories;
+  }
+  versioned(pathFlavor.join(value("NVM_DIR") ?? pathFlavor.join(home, ".nvm"), "versions", "node"), "bin");
+  const fnmRoots = [
+    value("FNM_DIR"),
+    pathFlavor.join(home, ".local", "share", "fnm"),
+    pathFlavor.join(home, "Library", "Application Support", "fnm")
+  ].filter((root) => root !== void 0);
+  for (const root of fnmRoots) {
+    versioned(pathFlavor.join(root, "node-versions"), "installation", "bin");
+  }
+  const voltaHome = value("VOLTA_HOME") ?? pathFlavor.join(home, ".volta");
+  versioned(pathFlavor.join(voltaHome, "tools", "image", "node"), "bin");
+  directories.push(pathFlavor.join(voltaHome, "bin"));
+  const asdfHome = value("ASDF_DATA_DIR") ?? pathFlavor.join(home, ".asdf");
+  versioned(pathFlavor.join(asdfHome, "installs", "nodejs"), "bin");
+  directories.push(pathFlavor.join(asdfHome, "shims"));
+  const nodenvHome = value("NODENV_ROOT") ?? pathFlavor.join(home, ".nodenv");
+  versioned(pathFlavor.join(nodenvHome, "versions"), "bin");
+  directories.push(pathFlavor.join(nodenvHome, "shims"));
+  versioned(pathFlavor.join(value("N_PREFIX") ?? "/usr/local", "n", "versions", "node"), "bin");
+  directories.push(pathFlavor.join(home, ".bun", "bin"));
+  const pnpmHome = value("PNPM_HOME");
+  if (pnpmHome)
+    directories.push(pnpmHome);
+  directories.push(pathFlavor.join(home, "Library", "pnpm"));
+  directories.push(pathFlavor.join(home, ".local", "share", "pnpm"));
+  for (const prefix of ["/opt/homebrew/opt", "/usr/local/opt"]) {
+    for (const formula of newestFirst(list(prefix).filter((name) => name.startsWith("node@")))) {
+      directories.push(pathFlavor.join(prefix, formula, "bin"));
+    }
+  }
+  return directories;
+}
+
+// ../../harness-discovery/dist/resolve.js
+var VERSION_MANAGER_ROOTS = "<version-managers>";
+function installRootExtensions(platform) {
+  return platform === "win32" ? [".exe", ".cmd"] : [""];
+}
+function resolveHomeDirectory(input) {
+  return input.homeDirectory ?? environmentValue(input.environment, "HOME") ?? environmentValue(input.environment, "USERPROFILE") ?? os.homedir();
+}
+function templateVariables(environment, platform, home) {
+  const pathFlavor = targetPath(platform);
+  return {
+    HOME: home,
+    USERPROFILE: home,
+    APPDATA: environmentValue(environment, "APPDATA") ?? pathFlavor.join(home, "AppData", "Roaming"),
+    LOCALAPPDATA: environmentValue(environment, "LOCALAPPDATA") ?? pathFlavor.join(home, "AppData", "Local")
+  };
+}
+function joinTemplate(platform, value) {
+  const pathFlavor = targetPath(platform);
+  const segments = value.split("/");
+  const head = segments[0] ?? "";
+  const tail = segments.slice(1);
+  if (head === "")
+    return pathFlavor.join(pathFlavor.sep, ...tail);
+  return tail.length === 0 ? head : pathFlavor.join(head, ...tail);
+}
+function expandInstallRoot(template, environment, platform, home) {
+  const variables = templateVariables(environment, platform, home);
+  let unresolved = false;
+  const substituted = template.replace(/^~(?=\/|$)/u, home).replace(/\$\{(\w+)\}/gu, (_match, name) => {
+    const value = variables[name] ?? environmentValue(environment, name);
+    if (value === void 0 || value === "") {
+      unresolved = true;
+      return "";
+    }
+    return value;
+  });
+  return unresolved ? void 0 : joinTemplate(platform, substituted);
+}
+function installRootDirectories(spec, input, dependencies, platform, home) {
+  const templates = (platform === "win32" ? spec.installRoots?.windows : spec.installRoots?.posix) ?? [];
+  const directories = [];
+  for (const template of templates) {
+    if (template === VERSION_MANAGER_ROOTS) {
+      directories.push(...versionManagerBinaryDirectories({
+        platform,
+        environment: input.environment,
+        home,
+        ...dependencies.subdirectories ? { subdirectories: dependencies.subdirectories } : {}
+      }));
+      continue;
+    }
+    const directory = expandInstallRoot(template, input.environment, platform, home);
+    if (directory !== void 0)
+      directories.push(directory);
+  }
+  return directories;
+}
+function harnessCandidates(spec, input, dependencies = {}) {
+  const platform = input.platform ?? process.platform;
+  const pathFlavor = targetPath(platform);
+  const configured = input.command ?? (spec.commandEnvironmentVariable ? environmentValue(input.environment, spec.commandEnvironmentVariable) : void 0);
+  const command = configured ?? spec.command;
+  if (pathFlavor.isAbsolute(command) || command.includes("/") || command.includes("\\")) {
+    return [{ candidate: command, source: "configured" }];
+  }
+  const candidates = [];
+  const extensions = executableExtensions(command, platform, input.environment);
+  for (const directory of pathDirectories(input.environment, platform)) {
+    for (const extension of extensions) {
+      candidates.push({
+        candidate: pathFlavor.join(directory, command + extension),
+        source: "path"
+      });
+    }
+  }
+  if (configured !== void 0)
+    return candidates;
+  const home = resolveHomeDirectory(input);
+  for (const directory of installRootDirectories(spec, input, dependencies, platform, home)) {
+    for (const extension of installRootExtensions(platform)) {
+      candidates.push({
+        candidate: pathFlavor.join(directory, spec.command + extension),
+        source: "install-root"
+      });
+    }
+  }
+  return candidates;
+}
+function resolveHarnessExecutable(spec, input, dependencies = {}) {
+  const platform = input.platform ?? process.platform;
+  const isExecutable = dependencies.isExecutable ?? ((candidate) => isExecutableFile(candidate, platform));
+  const runnable = spec.runnableCandidate ?? ((candidate) => candidate);
+  const context = { platform, isExecutable };
+  for (const { candidate, source } of harnessCandidates(spec, input, dependencies)) {
+    const executable = runnable(candidate, context);
+    if (executable !== void 0 && isExecutable(executable))
+      return { executable, source };
+  }
+  return void 0;
+}
+
+// ../../harness-discovery/dist/installation.js
+import { execFile } from "node:child_process";
+import { homedir } from "node:os";
+function runInstallationCommand(command, args, environment, timeout = 3e4) {
+  const env = withNodeRuntimeOnPath(environment);
+  const invocation = /\.[cm]?js$/i.test(command) ? commandInvocation(process.execPath, [command, ...args], env) : commandInvocation(command, args, env);
+  return new Promise((resolve, reject) => {
+    const child = execFile(invocation.command, invocation.arguments, {
+      env,
+      cwd: env.HOME ?? env.USERPROFILE ?? homedir(),
+      encoding: "utf8",
+      timeout,
+      killSignal: "SIGKILL",
+      maxBuffer: 1024 * 1024,
+      windowsHide: true,
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments
+    }, (error51, stdout, stderr) => {
+      if (error51)
+        reject(new Error(error51.killed ? "Harness command timed out" : "Harness command failed; check the native installation and retry"));
+      else
+        resolve((stdout || stderr).trim());
+    });
+    child.stdin?.end();
+  });
+}
+function installationVersion(value) {
+  if (typeof value !== "string" || !/^v?\d+(?:\.\d+){1,3}(?:-[\w.-]+)?(?:\+[\w.-]+)?$/.test(value.trim()))
+    throw new Error("Harness returned an invalid version");
+  return value.trim().replace(/^v/, "");
+}
+function versionFromOutput(output) {
+  return installationVersion(output.match(/\b\d+(?:\.\d+){1,3}(?:-[\w.-]+)?(?:\+[\w.-]+)?\b/)?.[0]);
+}
+function newerInstallationVersion(current, latest) {
+  const a = installationVersion(current).replace(/\+.*/, "");
+  const b = installationVersion(latest).replace(/\+.*/, "");
+  const coreA = a.replace(/-.*/, "").split(".").map(BigInt);
+  const coreB = b.replace(/-.*/, "").split(".").map(BigInt);
+  for (let i = 0; i < Math.max(coreA.length, coreB.length); i++) {
+    if ((coreA[i] ?? 0n) !== (coreB[i] ?? 0n))
+      return (coreB[i] ?? 0n) > (coreA[i] ?? 0n);
+  }
+  const preA = a.includes("-") ? a.slice(a.indexOf("-") + 1).split(".") : [];
+  const preB = b.includes("-") ? b.slice(b.indexOf("-") + 1).split(".") : [];
+  if (!preA.length || !preB.length)
+    return !!preA.length && !preB.length;
+  for (let i = 0; i < Math.max(preA.length, preB.length); i++) {
+    const x = preA[i];
+    const y = preB[i];
+    if (x === y)
+      continue;
+    if (x === void 0 || y === void 0)
+      return x === void 0;
+    const numericX = /^\d+$/.test(x);
+    const numericY = /^\d+$/.test(y);
+    if (numericX && numericY) {
+      if (BigInt(x) === BigInt(y))
+        continue;
+      return BigInt(y) > BigInt(x);
+    }
+    if (numericX !== numericY)
+      return numericX;
+    return y > x;
+  }
+  return false;
+}
+function createInstallationManager(options) {
+  let checking;
+  let updating;
+  const check2 = () => checking ??= options.check().finally(() => {
+    checking = void 0;
+  });
+  return (action) => {
+    if (updating)
+      return updating;
+    if (action === "check")
+      return check2();
+    updating = (async () => {
+      const before = await check2();
+      if (!before.updateAvailable)
+        return before;
+      if (!before.canUpdate)
+        throw new Error(before.message ?? "This installation cannot be updated automatically");
+      await options.update(before);
+      const after = await check2();
+      if (after.currentVersion === before.currentVersion)
+        throw new Error("The Harness version did not change; check the native updater and retry");
+      return after;
+    })().finally(() => {
+      updating = void 0;
+    });
+    return updating;
+  };
+}
+async function fetchInstallationText(url2) {
+  const request = async () => {
+    const response = await fetch(url2, { signal: AbortSignal.timeout(15e3) });
+    if (!response.ok)
+      throw new Error("Could not check the latest Harness version");
+    return response.text();
+  };
+  try {
+    return await request();
+  } catch (error51) {
+    if (error51 instanceof DOMException && (error51.name === "AbortError" || error51.name === "TimeoutError"))
+      throw error51;
+    return request();
+  }
+}
+
+// ../../harness-discovery/dist/npm-installation.js
+import { readFile, realpath } from "node:fs/promises";
+import path4 from "node:path";
+function referencesNpmBin(shim, name, bin) {
+  if (bin.includes(".."))
+    return false;
+  const target = `node_modules/${name}/${bin.replace(/^\.\//, "")}`.toLowerCase();
+  const text = shim.replaceAll("\\", "/").toLowerCase();
+  return text.includes(`%dp0%/${target}"`) || text.includes(`%~dp0/${target}"`);
+}
+async function npmInstallation(command, packages, environment) {
+  let selected = await realpath(command);
+  if (process.platform === "win32" && /\.(cmd|bat)$/i.test(selected)) {
+    const shim = (await readFile(selected, "utf8")).replaceAll("\\", "/");
+    const root = path4.dirname(selected);
+    for (const name of packages) {
+      const directory2 = path4.join(root, "node_modules", ...name.split("/"));
+      const metadata = await readFile(path4.join(directory2, "package.json"), "utf8").then((text) => JSON.parse(text)).catch(() => null);
+      const bins = typeof metadata?.bin === "string" ? [metadata.bin] : Object.values(metadata?.bin ?? {});
+      const bin = bins.find((entry) => referencesNpmBin(shim, name, entry));
+      if (bin) {
+        selected = await realpath(path4.join(directory2, bin));
+        break;
+      }
+    }
+  }
+  let directory = path4.dirname(selected);
+  for (let depth = 0; depth < 8; depth++) {
+    const metadata = await readFile(path4.join(directory, "package.json"), "utf8").then((text) => JSON.parse(text)).catch(() => null);
+    if (metadata?.name && packages.includes(metadata.name)) {
+      const name = metadata.name;
+      const currentVersion = installationVersion(metadata.version);
+      const segments = name.split("/");
+      let modules = directory;
+      for (let index = 0; index < segments.length; index++)
+        modules = path4.dirname(modules);
+      const prefix = process.platform === "win32" ? path4.dirname(modules) : path4.dirname(path4.dirname(modules));
+      const globalRoot = process.platform === "win32" ? path4.join(prefix, "node_modules") : path4.join(prefix, "lib", "node_modules");
+      const env = withNodeRuntimeOnPath(environment);
+      const npm = resolveHarnessExecutable({ id: "npm", command: "npm", installRoots: { posix: [], windows: [] } }, { environment: env });
+      let globalInstall = modules === globalRoot;
+      if (process.platform === "win32") {
+        const project = (await Promise.all(["package.json", "package-lock.json", "npm-shrinkwrap.json"].map((file2) => readFile(path4.join(prefix, file2), "utf8").then(() => true, (error51) => error51.code !== "ENOENT")))).some(Boolean);
+        const bins = typeof metadata.bin === "string" ? { [name.split("/").at(-1) ?? name]: metadata.bin } : metadata.bin ?? {};
+        const launchers = await Promise.all(Object.entries(bins).map(async ([bin, entry]) => {
+          if (path4.basename(bin) !== bin || entry.includes(".."))
+            return false;
+          const target = await realpath(path4.join(directory, entry)).catch(() => "");
+          if (target.toLowerCase() !== selected.toLowerCase())
+            return false;
+          const shim = await readFile(path4.join(prefix, `${bin}.cmd`), "utf8").catch(() => "");
+          return referencesNpmBin(shim, name, entry);
+        }));
+        globalInstall = globalInstall && !project && launchers.some(Boolean);
+      }
+      const canUpdate = globalInstall && !!npm;
+      return {
+        prefix,
+        currentVersion,
+        canUpdate,
+        latest: async () => {
+          const data = JSON.parse(await fetchInstallationText(`https://registry.npmjs.org/${encodeURIComponent(name)}/latest`));
+          return installationVersion(data.version);
+        },
+        update: async (version2) => {
+          if (!canUpdate || !npm)
+            throw new Error("Use the original package manager to update this installation");
+          await runInstallationCommand(npm.executable, ["install", "--global", "--prefix", prefix, `${name}@${installationVersion(version2)}`], env, 3e5);
+        }
+      };
+    }
+    const parent = path4.dirname(directory);
+    if (parent === directory)
+      break;
+    directory = parent;
+  }
+  return null;
+}
+
+// ../../harness-discovery/dist/installer.js
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+function createHarnessInstaller(environment, source) {
+  return async () => {
+    if (!["darwin", "linux", "win32"].includes(process.platform))
+      throw new Error("Unsupported installation platform");
+    const env = withNodeRuntimeOnPath(environment);
+    if ("npm" in source) {
+      const npm = resolveHarnessExecutable({
+        id: "npm",
+        command: "npm",
+        installRoots: {
+          posix: [
+            "~/.npm-global/bin",
+            "~/.local/bin",
+            VERSION_MANAGER_ROOTS,
+            "/opt/homebrew/bin",
+            "/usr/local/bin",
+            "/usr/bin"
+          ],
+          windows: [
+            "${APPDATA}/npm",
+            VERSION_MANAGER_ROOTS,
+            "${ProgramFiles}/nodejs",
+            "${LOCALAPPDATA}/Programs/nodejs"
+          ]
+        }
+      }, { environment: env });
+      if (!npm)
+        throw new Error("Install Node.js and npm first");
+      await runInstallationCommand(npm.executable, ["install", "--global", source.npm], {
+        ...env,
+        ...source.allowScripts ? { npm_config_allow_scripts: source.allowScripts } : {}
+      }, 6e5);
+      return;
+    }
+    const windows = process.platform === "win32";
+    const url2 = windows ? source.windows : source.posix;
+    if (new URL(url2).protocol !== "https:")
+      throw new Error("Installer requires HTTPS");
+    const script = await fetchInstallationText(url2);
+    const directory = await mkdtemp(join(tmpdir(), "codexhost-installer-"));
+    try {
+      const file2 = join(directory, windows ? "install.ps1" : "install.sh");
+      await writeFile(file2, script, { mode: 384 });
+      await runInstallationCommand(windows ? "powershell.exe" : source.shell ?? "bash", windows ? ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File", file2] : [file2], env, 6e5);
+    } finally {
+      await rm(directory, { recursive: true, force: true });
+    }
+  };
+}
+
 // dist/kimi-adapter.js
-import { readFile as readFile3 } from "node:fs/promises";
-import path6 from "node:path";
+import { readFile as readFile6 } from "node:fs/promises";
+import path9 from "node:path";
 import { isDeepStrictEqual } from "node:util";
 
 // ../../../node_modules/zod/v4/classic/external.js
@@ -776,10 +1258,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path7) {
-  if (!path7)
+function getElementAtPath(obj, path10) {
+  if (!path10)
     return obj;
-  return path7.reduce((acc, key) => acc?.[key], obj);
+  return path10.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1188,11 +1670,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path7, issues) {
+function prefixIssues(path10, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path7);
+    iss.path.unshift(path10);
     return iss;
   });
 }
@@ -1339,16 +1821,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path7 = []) => {
+  const processError = (error52, path10 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path10, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else {
-        const fullpath = [...path7, ...issue2.path];
+        const fullpath = [...path10, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1375,17 +1857,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path7 = []) => {
+  const processError = (error52, path10 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path10, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else {
-        const fullpath = [...path7, ...issue2.path];
+        const fullpath = [...path10, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1417,8 +1899,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path7 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path7) {
+  const path10 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path10) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14110,13 +14592,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path7 = ref.slice(1).split("/").filter(Boolean);
-  if (path7.length === 0) {
+  const path10 = ref.slice(1).split("/").filter(Boolean);
+  if (path10.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path7[0] === defsKey) {
-    const key = path7[1];
+  if (path10[0] === defsKey) {
+    const key = path10[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14579,6 +15061,56 @@ var credentialImportsParamsSchema = external_exports.object({
   request: credentialImportsRequestSchema
 }).strict();
 
+// ../../shared-contracts/dist/harness-display-settings.js
+var harnessDisplayEntriesSchema = external_exports.array(external_exports.strictObject({
+  agent: external_exports.string().min(1).max(128),
+  section: external_exports.enum(["main", "more", "auto"])
+})).max(256).refine((entries) => new Set(entries.map((entry) => entry.agent)).size === entries.length, "Duplicate Harness IDs");
+var harnessDisplaySettingsSchema = external_exports.strictObject({
+  entries: harnessDisplayEntriesSchema.nullable()
+});
+var harnessDisplayGetSchema = external_exports.strictObject({});
+var harnessDisplaySetSchema = external_exports.strictObject({
+  entries: harnessDisplayEntriesSchema,
+  /** Import legacy Desktop preferences only if no shared settings exist yet. */
+  initializeOnly: external_exports.boolean().optional()
+});
+
+// ../../shared-contracts/dist/console.js
+var consoleAnnouncementSchema = external_exports.strictObject({
+  title: external_exports.string().trim().min(1).max(200),
+  type: external_exports.enum(["info", "warning", "danger"]),
+  body: external_exports.string().trim().min(1).max(16 * 1024)
+});
+var consoleOpenParamsSchema = external_exports.strictObject({});
+var consoleOpenResultSchema = external_exports.strictObject({
+  /** The console address. */
+  url: external_exports.string().max(2048).regex(/^http:\/\/(?:127\.0\.0\.1|localhost):\d{1,5}\/(?:\?.*)?$/u)
+});
+var CONSOLE_HOST_METHODS = Object.freeze([
+  "codexhost/harness/plugins/list",
+  "codexhost/harness/display-settings/get",
+  "codexhost/harness/display-settings/set",
+  "codexhost/harness/inspect",
+  "codexhost/harness/installation",
+  "codexhost/harness/launch-settings/get",
+  "codexhost/harness/launch-settings/set",
+  "codexhost/harness/web-ui/open",
+  "codexhost/harness/accounts/sources",
+  "codexhost/harness/accounts/list",
+  "codexhost/harness/accounts/inspect",
+  "codexhost/harness/credential-imports",
+  "codexhost/harness/session-import/sources",
+  "codexhost/harness/session-import/list",
+  "codexhost/harness/session-import/import",
+  "codexhost/account/list",
+  "codexhost/account/refresh",
+  "codexhost/account/usage/inspect",
+  "codexhost/update/check",
+  "codexhost/update/start",
+  "codexhost/update/status"
+]);
+
 // ../../shared-contracts/dist/version.js
 var WORKSPACE_CONTRACT_VERSION = 1;
 
@@ -14632,6 +15164,12 @@ var hostTurnIdSchema = opaqueIdSchema.brand();
 var hostItemIdSchema = opaqueIdSchema.brand();
 var hostInteractionIdSchema = opaqueIdSchema.brand();
 
+// ../../shared-contracts/dist/manual-compaction.js
+var threadManualCompactionStartedSchema = external_exports.strictObject({
+  threadId: hostThreadIdSchema,
+  turnId: hostTurnIdSchema
+});
+
 // ../../shared-contracts/dist/thread-usage.js
 var nonNegativeSafeIntegerSchema = external_exports.number().int().safe().nonnegative();
 var finiteNonNegativeNumberSchema = external_exports.number().finite().nonnegative();
@@ -14692,6 +15230,10 @@ var threadUsageSnapshotSchema = external_exports.object({
 var usagePercentSchema = external_exports.number().finite().min(0).max(100);
 var accountCreditsProductUsageSchema = external_exports.object({
   product: external_exports.string().min(1),
+  used: external_exports.number().finite().nonnegative().optional(),
+  // Zero is a real empty cap, not an absent field.
+  limit: external_exports.number().finite().nonnegative().optional(),
+  unit: external_exports.string().min(1).max(32).optional(),
   usagePercent: usagePercentSchema,
   resetsAt: external_exports.string().min(1).optional()
 }).strict();
@@ -14701,6 +15243,10 @@ var accountResetCreditsSchema = external_exports.object({
   expiresAt: external_exports.array(external_exports.string().min(1)).min(1).max(32).optional()
 }).strict();
 var accountCreditsSnapshotSchema = external_exports.object({
+  used: external_exports.number().finite().nonnegative().optional(),
+  // Zero is a real empty cap, not an absent field.
+  limit: external_exports.number().finite().nonnegative().optional(),
+  unit: external_exports.string().min(1).max(32).optional(),
   /** Native label when the primary limit is scoped to a model or product group. */
   label: external_exports.string().min(1).optional(),
   usedPercent: usagePercentSchema,
@@ -14720,12 +15266,27 @@ var threadUsageInspectionSchema = external_exports.object({
 }).strict();
 
 // ../../shared-contracts/dist/harness-accounts.js
-var harnessAccountSnapshotSchema = external_exports.object({
+var accountBalanceSnapshotSchema = external_exports.object({
+  amount: external_exports.number().finite().nonnegative(),
+  /** ISO 4217 code as reported by the Provider, for example `CNY`. */
+  currency: external_exports.string().trim().min(1).max(8),
+  /** Native label when the Harness exposes several Billing Sources. */
+  label: external_exports.string().trim().min(1).max(128).optional()
+}).strict();
+var harnessAccountSnapshotObject = external_exports.object({
   email: external_exports.string().trim().min(1).max(320).optional(),
   label: external_exports.string().trim().min(1).max(256).optional(),
   plan: external_exports.string().trim().min(1).max(128).optional(),
-  credits: accountCreditsSnapshotSchema
+  credits: accountCreditsSnapshotSchema.optional(),
+  balance: accountBalanceSnapshotSchema.optional()
 }).strict();
+function requireReportedQuota(schema) {
+  return schema.refine((value) => {
+    const reported = value;
+    return reported.credits !== void 0 || reported.balance !== void 0;
+  }, { message: "Account must report either credits or a balance" });
+}
+var harnessAccountSnapshotSchema = requireReportedQuota(harnessAccountSnapshotObject);
 var harnessAccountIdentityShape = {
   harnessId: harnessIdSchema,
   harnessName: external_exports.string().trim().min(1).max(128)
@@ -14736,11 +15297,13 @@ var harnessAccountSourceListResultSchema = external_exports.object({ sources: ex
 var harnessAccountInspectParamsSchema = external_exports.object({ harnessId: harnessIdSchema, refresh: external_exports.boolean().optional() }).strict();
 var harnessAccountInspectResultSchema = external_exports.object({
   ...harnessAccountIdentityShape,
-  account: harnessAccountSnapshotSchema.nullable()
+  account: harnessAccountSnapshotSchema.nullable(),
+  /** Every Billing Source from one Harness; `account` remains the first for older clients. */
+  accounts: external_exports.array(harnessAccountSnapshotSchema).max(8).optional()
 }).strict();
 var harnessAccountListParamsSchema = external_exports.object({ refresh: external_exports.boolean().optional() }).strict();
 var harnessAccountListResultSchema = external_exports.object({
-  accounts: external_exports.array(harnessAccountSnapshotSchema.extend(harnessAccountIdentityShape)).max(128)
+  accounts: external_exports.array(requireReportedQuota(harnessAccountSnapshotObject.extend(harnessAccountIdentityShape))).max(128)
 }).strict();
 
 // ../../shared-contracts/dist/json-value.js
@@ -14878,6 +15441,8 @@ var harnessModelSchema = external_exports.object({
   ref: harnessModelRefSchema,
   label: nonBlankTextSchema2.max(HARNESS_MODEL_LABEL_MAX_LENGTH),
   resolvedModelLabel: harnessResolvedModelLabelSchema.optional(),
+  /** Optional opaque selection for this same Model with priority processing enabled. */
+  fastModel: harnessModelRefSchema.optional(),
   supportedThinkingOptionIds: external_exports.array(harnessThinkingOptionIdSchema).optional()
 }).strict();
 var harnessThinkingOptionsSchema = external_exports.array(harnessThinkingOptionSchema).superRefine((options, context) => {
@@ -14910,6 +15475,16 @@ var harnessModelCatalogSchema = external_exports.object({
       });
     }
     refs.add(model.ref.id);
+    if (model.fastModel) {
+      if (refs.has(model.fastModel.id) || catalog.models.some((entry) => entry.ref.id === model.fastModel?.id)) {
+        context.addIssue({
+          code: "custom",
+          message: "Fast Model refs must be distinct and unique",
+          path: ["models", index, "fastModel"]
+        });
+      }
+      refs.add(model.fastModel.id);
+    }
     const supportedThinkingIds = /* @__PURE__ */ new Set();
     for (const [optionIndex, optionId] of (model.supportedThinkingOptionIds ?? []).entries()) {
       if (supportedThinkingIds.has(optionId)) {
@@ -15029,11 +15604,13 @@ var threadThinkingSelectParamsSchema = external_exports.object({
   thinkingOptionId: harnessThinkingOptionIdSchema
 }).strict();
 var threadInspectionParamsSchema = external_exports.object({
-  threadId: hostThreadIdSchema
+  threadId: hostThreadIdSchema,
+  includeReferenceCapability: external_exports.boolean().optional()
 }).strict();
 var codexThreadInspectionSchema = external_exports.object({
   owner: external_exports.literal("codex"),
-  locked: external_exports.literal(true)
+  locked: external_exports.literal(true),
+  supportsThreadReferences: external_exports.literal(true).optional()
 }).strict();
 var externalThreadInspectionSchema = external_exports.object({
   owner: external_exports.literal("external"),
@@ -15159,6 +15736,22 @@ var harnessLaunchSettingsSchema = external_exports.object({
   restartRequired: external_exports.boolean()
 }).strict();
 
+// ../../shared-contracts/dist/harness-installation.js
+var harnessInstallationParamsSchema = external_exports.object({
+  harnessId: harnessIdSchema,
+  action: external_exports.enum(["check", "update", "install"])
+}).strict();
+var harnessInstallationStateSchema = external_exports.object({
+  currentVersion: external_exports.string().min(1).max(128),
+  latestVersion: external_exports.string().min(1).max(128),
+  updateAvailable: external_exports.boolean(),
+  canUpdate: external_exports.boolean(),
+  // Adapter-owned diagnostic text; UI uses messageCode rather than displaying it verbatim.
+  message: external_exports.string().max(2048).optional(),
+  messageCode: external_exports.string().min(1).max(128).optional(),
+  latestVersionKind: external_exports.enum(["unknown", "tracking-branch"]).optional()
+}).strict();
+
 // ../../shared-contracts/dist/codex-accounts.js
 var accountIdSchema = external_exports.string().min(1).max(256).regex(/^[A-Za-z0-9._~-]+$/u);
 var nonBlankTextSchema3 = external_exports.string().trim().min(1);
@@ -15458,6 +16051,38 @@ var updateStatusResultSchema = external_exports.strictObject({
   status: updateStatusSchema.nullable()
 });
 
+// ../../shared-contracts/dist/remote-runtime.js
+var remoteUpdatePhaseSchema = external_exports.enum([
+  "idle",
+  "installing",
+  "restarting",
+  "succeeded",
+  "failed"
+]);
+var runtimeStatusSchema = external_exports.object({
+  runningVersion: external_exports.string().nullable(),
+  installedVersion: external_exports.string().nullable(),
+  restartRequired: external_exports.boolean(),
+  remote: external_exports.boolean(),
+  updateSupported: external_exports.boolean(),
+  update: external_exports.object({
+    phase: remoteUpdatePhaseSchema,
+    targetVersion: external_exports.string().nullable(),
+    error: external_exports.string().nullable()
+  })
+});
+var remoteUpdateParamsSchema = external_exports.object({
+  version: external_exports.string().regex(/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/u)
+}).strict();
+var remoteSshSetupParamsSchema = external_exports.object({
+  hostname: external_exports.string().min(1).max(1024).refine((value) => !value.startsWith("-") && !/\s/u.test(value)),
+  port: external_exports.number().int().min(1).max(65535).nullable(),
+  identity: external_exports.string().max(4096).nullable(),
+  action: external_exports.enum(["inspect", "install", "update", "repair"]),
+  version: external_exports.string().regex(/^\d+\.\d+\.\d+$/u).nullable()
+}).strict();
+var remoteSshSetupResultSchema = external_exports.object({ state: external_exports.enum(["installed", "not-installed"]) }).strict();
+
 // ../../shared-contracts/dist/index.js
 var workspaceContractVersionSchema = external_exports.literal(WORKSPACE_CONTRACT_VERSION);
 
@@ -19758,294 +20383,67 @@ var ClientSideConnection = class {
   extMethod(method, params) {
     return this.request(method, params);
   }
-  /**
-   * Extension notification.
-   *
-   * @deprecated Use {@link notify}.
-   */
-  extNotification(method, params) {
-    return this.notify(method, params);
-  }
-  /**
-   * AbortSignal that aborts when the connection closes.
-   *
-   * This signal can be used to:
-   * - Listen for connection closure: `connection.signal.addEventListener('abort', () => {...})`
-   * - Check connection status synchronously: `if (connection.signal.aborted) {...}`
-   * - Pass to other APIs (fetch, setTimeout) for automatic cancellation
-   *
-   * The connection closes when the underlying stream ends, either normally or due to an error.
-   *
-   * @example
-   * ```typescript
-   * const connection = new ClientSideConnection(client, stream);
-   *
-   * // Listen for closure
-   * connection.signal.addEventListener('abort', () => {
-   *   console.log('Connection closed - performing cleanup');
-   * });
-   *
-   * // Check status
-   * if (connection.signal.aborted) {
-   *   console.log('Connection is already closed');
-   * }
-   *
-   * // Pass to other APIs
-   * fetch(url, { signal: connection.signal });
-   * ```
-   */
-  get signal() {
-    return this.connection.signal;
-  }
-  /**
-   * Promise that resolves when the connection closes.
-   *
-   * The connection closes when the underlying stream ends, either normally or due to an error.
-   * Once closed, the connection cannot send or receive any more messages.
-   *
-   * This is useful for async/await style cleanup:
-   *
-   * @example
-   * ```typescript
-   * const connection = new ClientSideConnection(client, stream);
-   * await connection.closed;
-   * console.log('Connection closed - performing cleanup');
-   * ```
-   */
-  get closed() {
-    return this.connection.closed;
-  }
-};
-
-// dist/command.js
-import path3 from "node:path";
-
-// ../../harness-discovery/dist/environment.js
-import fs from "node:fs";
-import path from "node:path";
-function targetPath(platform) {
-  return platform === "win32" ? path.win32 : path.posix;
-}
-function environmentValue(environment, name) {
-  const lowered = name.toLowerCase();
-  for (const [key, value] of Object.entries(environment)) {
-    if (key.toLowerCase() === lowered)
-      return value;
-  }
-  return void 0;
-}
-function pathDelimiter(platform) {
-  return platform === "win32" ? ";" : ":";
-}
-function pathDirectories(environment, platform) {
-  return (environmentValue(environment, "PATH") ?? "").split(pathDelimiter(platform)).map((directory) => directory.trim().replace(/^"|"$/gu, "")).filter(Boolean);
-}
-function executableExtensions(command, platform, environment) {
-  if (platform !== "win32")
-    return [""];
-  if (targetPath(platform).extname(command) !== "")
-    return [""];
-  return (environmentValue(environment, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD").split(";").map((extension) => extension.trim()).filter(Boolean);
-}
-function isExecutableFile(filePath, platform) {
-  try {
-    fs.accessSync(filePath, platform === "win32" ? fs.constants.F_OK : fs.constants.X_OK);
-    return fs.statSync(filePath).isFile();
-  } catch {
-    return false;
-  }
-}
-function subdirectoryNames(directory) {
-  try {
-    return fs.readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-  } catch {
-    return [];
-  }
-}
-function newestFirst(names) {
-  return [...names].sort((left, right) => right.localeCompare(left, void 0, { numeric: true }));
-}
-
-// ../../harness-discovery/dist/invocation.js
-import path2 from "node:path";
-function commandInvocation(command, arguments_, environment, platform = process.platform) {
-  const extension = path2.win32.extname(command).toLowerCase();
-  if (platform !== "win32" || ![".cmd", ".bat"].includes(extension)) {
-    return { command, arguments: [...arguments_], windowsVerbatimArguments: false };
-  }
-  const quote = (value) => `"${value.replaceAll("%", "%%").replaceAll('"', '""')}"`;
-  const commandLine = [command, ...arguments_].map(quote).join(" ");
-  return {
-    command: environmentValue(environment, "ComSpec") ?? "cmd.exe",
-    arguments: ["/d", "/v:off", "/s", "/c", `"${commandLine}"`],
-    windowsVerbatimArguments: true
-  };
-}
-
-// ../../harness-discovery/dist/resolve.js
-import os from "node:os";
-
-// ../../harness-discovery/dist/version-managers.js
-function versionManagerBinaryDirectories(context) {
-  const { platform, environment, home } = context;
-  const list = context.subdirectories ?? subdirectoryNames;
-  const pathFlavor = targetPath(platform);
-  const value = (name) => environmentValue(environment, name);
-  const directories = [];
-  const versioned = (root, ...tail) => {
-    for (const version2 of newestFirst(list(root))) {
-      directories.push(pathFlavor.join(root, version2, ...tail));
-    }
-  };
-  if (platform === "win32") {
-    const appData = value("APPDATA") ?? pathFlavor.join(home, "AppData", "Roaming");
-    const localAppData = value("LOCALAPPDATA") ?? pathFlavor.join(home, "AppData", "Local");
-    versioned(pathFlavor.join(appData, "nvm"));
-    versioned(value("FNM_DIR") ?? pathFlavor.join(appData, "fnm", "node-versions"), "installation");
-    directories.push(pathFlavor.join(localAppData, "Volta", "bin"));
-    directories.push(pathFlavor.join(home, ".bun", "bin"));
-    const pnpmHome2 = value("PNPM_HOME");
-    if (pnpmHome2)
-      directories.push(pnpmHome2);
-    directories.push(pathFlavor.join(localAppData, "pnpm"));
-    return directories;
-  }
-  versioned(pathFlavor.join(value("NVM_DIR") ?? pathFlavor.join(home, ".nvm"), "versions", "node"), "bin");
-  const fnmRoots = [
-    value("FNM_DIR"),
-    pathFlavor.join(home, ".local", "share", "fnm"),
-    pathFlavor.join(home, "Library", "Application Support", "fnm")
-  ].filter((root) => root !== void 0);
-  for (const root of fnmRoots) {
-    versioned(pathFlavor.join(root, "node-versions"), "installation", "bin");
-  }
-  const voltaHome = value("VOLTA_HOME") ?? pathFlavor.join(home, ".volta");
-  versioned(pathFlavor.join(voltaHome, "tools", "image", "node"), "bin");
-  directories.push(pathFlavor.join(voltaHome, "bin"));
-  const asdfHome = value("ASDF_DATA_DIR") ?? pathFlavor.join(home, ".asdf");
-  versioned(pathFlavor.join(asdfHome, "installs", "nodejs"), "bin");
-  directories.push(pathFlavor.join(asdfHome, "shims"));
-  const nodenvHome = value("NODENV_ROOT") ?? pathFlavor.join(home, ".nodenv");
-  versioned(pathFlavor.join(nodenvHome, "versions"), "bin");
-  directories.push(pathFlavor.join(nodenvHome, "shims"));
-  versioned(pathFlavor.join(value("N_PREFIX") ?? "/usr/local", "n", "versions", "node"), "bin");
-  directories.push(pathFlavor.join(home, ".bun", "bin"));
-  const pnpmHome = value("PNPM_HOME");
-  if (pnpmHome)
-    directories.push(pnpmHome);
-  directories.push(pathFlavor.join(home, "Library", "pnpm"));
-  directories.push(pathFlavor.join(home, ".local", "share", "pnpm"));
-  for (const prefix of ["/opt/homebrew/opt", "/usr/local/opt"]) {
-    for (const formula of newestFirst(list(prefix).filter((name) => name.startsWith("node@")))) {
-      directories.push(pathFlavor.join(prefix, formula, "bin"));
-    }
-  }
-  return directories;
-}
-
-// ../../harness-discovery/dist/resolve.js
-var VERSION_MANAGER_ROOTS = "<version-managers>";
-function installRootExtensions(platform) {
-  return platform === "win32" ? [".exe", ".cmd"] : [""];
-}
-function resolveHomeDirectory(input) {
-  return input.homeDirectory ?? environmentValue(input.environment, "HOME") ?? environmentValue(input.environment, "USERPROFILE") ?? os.homedir();
-}
-function templateVariables(environment, platform, home) {
-  const pathFlavor = targetPath(platform);
-  return {
-    HOME: home,
-    USERPROFILE: home,
-    APPDATA: environmentValue(environment, "APPDATA") ?? pathFlavor.join(home, "AppData", "Roaming"),
-    LOCALAPPDATA: environmentValue(environment, "LOCALAPPDATA") ?? pathFlavor.join(home, "AppData", "Local")
-  };
-}
-function joinTemplate(platform, value) {
-  const pathFlavor = targetPath(platform);
-  const segments = value.split("/");
-  const head = segments[0] ?? "";
-  const tail = segments.slice(1);
-  if (head === "")
-    return pathFlavor.join(pathFlavor.sep, ...tail);
-  return tail.length === 0 ? head : pathFlavor.join(head, ...tail);
-}
-function expandInstallRoot(template, environment, platform, home) {
-  const variables = templateVariables(environment, platform, home);
-  let unresolved = false;
-  const substituted = template.replace(/^~(?=\/|$)/u, home).replace(/\$\{(\w+)\}/gu, (_match, name) => {
-    const value = variables[name] ?? environmentValue(environment, name);
-    if (value === void 0 || value === "") {
-      unresolved = true;
-      return "";
-    }
-    return value;
-  });
-  return unresolved ? void 0 : joinTemplate(platform, substituted);
-}
-function installRootDirectories(spec, input, dependencies, platform, home) {
-  const templates = (platform === "win32" ? spec.installRoots?.windows : spec.installRoots?.posix) ?? [];
-  const directories = [];
-  for (const template of templates) {
-    if (template === VERSION_MANAGER_ROOTS) {
-      directories.push(...versionManagerBinaryDirectories({
-        platform,
-        environment: input.environment,
-        home,
-        ...dependencies.subdirectories ? { subdirectories: dependencies.subdirectories } : {}
-      }));
-      continue;
-    }
-    const directory = expandInstallRoot(template, input.environment, platform, home);
-    if (directory !== void 0)
-      directories.push(directory);
-  }
-  return directories;
-}
-function harnessCandidates(spec, input, dependencies = {}) {
-  const platform = input.platform ?? process.platform;
-  const pathFlavor = targetPath(platform);
-  const configured = input.command ?? (spec.commandEnvironmentVariable ? environmentValue(input.environment, spec.commandEnvironmentVariable) : void 0);
-  const command = configured ?? spec.command;
-  if (pathFlavor.isAbsolute(command) || command.includes("/") || command.includes("\\")) {
-    return [{ candidate: command, source: "configured" }];
-  }
-  const candidates = [];
-  const extensions = executableExtensions(command, platform, input.environment);
-  for (const directory of pathDirectories(input.environment, platform)) {
-    for (const extension of extensions) {
-      candidates.push({
-        candidate: pathFlavor.join(directory, command + extension),
-        source: "path"
-      });
-    }
+  /**
+   * Extension notification.
+   *
+   * @deprecated Use {@link notify}.
+   */
+  extNotification(method, params) {
+    return this.notify(method, params);
   }
-  if (configured !== void 0)
-    return candidates;
-  const home = resolveHomeDirectory(input);
-  for (const directory of installRootDirectories(spec, input, dependencies, platform, home)) {
-    for (const extension of installRootExtensions(platform)) {
-      candidates.push({
-        candidate: pathFlavor.join(directory, spec.command + extension),
-        source: "install-root"
-      });
-    }
+  /**
+   * AbortSignal that aborts when the connection closes.
+   *
+   * This signal can be used to:
+   * - Listen for connection closure: `connection.signal.addEventListener('abort', () => {...})`
+   * - Check connection status synchronously: `if (connection.signal.aborted) {...}`
+   * - Pass to other APIs (fetch, setTimeout) for automatic cancellation
+   *
+   * The connection closes when the underlying stream ends, either normally or due to an error.
+   *
+   * @example
+   * ```typescript
+   * const connection = new ClientSideConnection(client, stream);
+   *
+   * // Listen for closure
+   * connection.signal.addEventListener('abort', () => {
+   *   console.log('Connection closed - performing cleanup');
+   * });
+   *
+   * // Check status
+   * if (connection.signal.aborted) {
+   *   console.log('Connection is already closed');
+   * }
+   *
+   * // Pass to other APIs
+   * fetch(url, { signal: connection.signal });
+   * ```
+   */
+  get signal() {
+    return this.connection.signal;
   }
-  return candidates;
-}
-function resolveHarnessExecutable(spec, input, dependencies = {}) {
-  const platform = input.platform ?? process.platform;
-  const isExecutable = dependencies.isExecutable ?? ((candidate) => isExecutableFile(candidate, platform));
-  const runnable = spec.runnableCandidate ?? ((candidate) => candidate);
-  const context = { platform, isExecutable };
-  for (const { candidate, source } of harnessCandidates(spec, input, dependencies)) {
-    const executable = runnable(candidate, context);
-    if (executable !== void 0 && isExecutable(executable))
-      return { executable, source };
+  /**
+   * Promise that resolves when the connection closes.
+   *
+   * The connection closes when the underlying stream ends, either normally or due to an error.
+   * Once closed, the connection cannot send or receive any more messages.
+   *
+   * This is useful for async/await style cleanup:
+   *
+   * @example
+   * ```typescript
+   * const connection = new ClientSideConnection(client, stream);
+   * await connection.closed;
+   * console.log('Connection closed - performing cleanup');
+   * ```
+   */
+  get closed() {
+    return this.connection.closed;
   }
-  return void 0;
-}
+};
 
 // dist/command.js
+import path5 from "node:path";
 var KimiExecutableError = class extends Error {
   code = "KIMI_NOT_FOUND";
 };
@@ -20069,7 +20467,7 @@ function resolveKimiExecutable(input = {}) {
   });
   if (!resolution)
     throw new KimiExecutableError("Kimi Code CLI is not installed");
-  return targetPath(platform).isAbsolute(resolution.executable) ? resolution.executable : path3.resolve(resolution.executable);
+  return targetPath(platform).isAbsolute(resolution.executable) ? resolution.executable : path5.resolve(resolution.executable);
 }
 function kimiInvocation(command, environment = process.env, platform = process.platform) {
   return commandInvocation(command, ["acp"], environment, platform);
@@ -20513,10 +20911,229 @@ var KimiAcpTransport = class {
   }
 };
 
+// dist/account-identity.js
+import { randomUUID } from "node:crypto";
+import { readFile as readFile2, rename, unlink, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+var KIMI_USAGES_ENDPOINT = "https://api.kimi.com/coding/v1/usages";
+var KIMI_OAUTH_TOKEN_ENDPOINT = "https://auth.kimi.com/api/oauth/token";
+var KIMI_CODE_CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098";
+var REQUEST_TIMEOUT_MS = 8e3;
+var REFRESH_SKEW_MS = 6e4;
+var credentialSchema = external_exports.object({
+  access_token: external_exports.string().min(1),
+  refresh_token: external_exports.string().min(1).optional(),
+  expires_at: external_exports.number().optional(),
+  expires_in: external_exports.number().optional(),
+  scope: external_exports.string().optional(),
+  token_type: external_exports.string().optional()
+});
+var refreshResponseSchema = external_exports.object({
+  access_token: external_exports.string().min(1),
+  refresh_token: external_exports.string().min(1).optional(),
+  expires_in: external_exports.number().positive().optional(),
+  scope: external_exports.string().optional(),
+  token_type: external_exports.string().optional()
+});
+function kimiHome(environment) {
+  return environment.KIMI_CODE_HOME ?? join2(environment.HOME ?? homedir2(), ".kimi-code");
+}
+function credentialPath(environment) {
+  return join2(kimiHome(environment), "credentials", "kimi-code.json");
+}
+function oauthTokenUrl(environment) {
+  const host = environment.KIMI_CODE_OAUTH_HOST ?? environment.KIMI_OAUTH_HOST;
+  return host ? `${host.replace(/\/$/u, "")}/api/oauth/token` : KIMI_OAUTH_TOKEN_ENDPOINT;
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function quantity(value) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return void 0;
+}
+function isFiveHourWindow(window) {
+  if (!isRecord3(window))
+    return false;
+  const duration3 = quantity(window.duration);
+  const unit = String(window.timeUnit ?? "").toLowerCase();
+  return duration3 === 300 && unit.includes("minute");
+}
+function usageShare(detail) {
+  if (!isRecord3(detail))
+    return void 0;
+  const limit = quantity(detail.limit);
+  const remaining = quantity(detail.remaining);
+  const used = quantity(detail.used) ?? (limit !== void 0 && remaining !== void 0 ? Math.max(0, limit - remaining) : void 0);
+  if (limit === void 0 || limit <= 0 || used === void 0 || used < 0)
+    return void 0;
+  const resetsAt = typeof detail.resetTime === "string" && detail.resetTime ? detail.resetTime : void 0;
+  return { usedPercent: Math.min(100, used / limit * 100), ...resetsAt ? { resetsAt } : {} };
+}
+function membershipPlan(user) {
+  if (!isRecord3(user) || !isRecord3(user.membership) || typeof user.membership.level !== "string")
+    return void 0;
+  return user.membership.level.replace(/^LEVEL_/u, "").trim() || void 0;
+}
+function nickname(user) {
+  if (!isRecord3(user) || typeof user.nickname !== "string")
+    return void 0;
+  return user.nickname.trim() || void 0;
+}
+function expiresAtMs(expiresAt) {
+  if (expiresAt === void 0 || !Number.isFinite(expiresAt))
+    return void 0;
+  return expiresAt < 1e12 ? expiresAt * 1e3 : expiresAt;
+}
+function accessTokenFresh(credentials, now) {
+  const expires = expiresAtMs(credentials.expires_at);
+  return expires === void 0 || expires - REFRESH_SKEW_MS > now;
+}
+function projectKimiUsages(payload) {
+  if (!isRecord3(payload))
+    return null;
+  const weekly = usageShare(payload.usage);
+  if (!weekly)
+    return null;
+  const productUsage = (Array.isArray(payload.limits) ? payload.limits : []).flatMap((entry) => {
+    if (!isRecord3(entry))
+      return [];
+    const share = usageShare(entry.detail);
+    if (!share || !isFiveHourWindow(entry.window))
+      return [];
+    return [
+      {
+        product: "Kimi Code · 5-hour window",
+        usagePercent: share.usedPercent,
+        ...share.resetsAt ? { resetsAt: share.resetsAt } : {}
+      }
+    ];
+  });
+  const credits = {
+    usedPercent: weekly.usedPercent,
+    periodType: "weekly",
+    ...weekly.resetsAt ? { resetsAt: weekly.resetsAt } : {},
+    ...productUsage.length ? { productUsage } : {}
+  };
+  const plan = membershipPlan(payload.user);
+  const label = nickname(payload.user);
+  const parsed = harnessAccountSnapshotSchema.safeParse({
+    label: label || "Kimi Code",
+    ...plan ? { plan } : {},
+    credits
+  });
+  return parsed.success ? parsed.data : null;
+}
+async function readNativeCredentials(filePath, readAuthFile) {
+  try {
+    const raw = JSON.parse(await readAuthFile(filePath));
+    if (!isRecord3(raw))
+      return void 0;
+    const parsed = credentialSchema.safeParse(raw);
+    return parsed.success ? { raw, credentials: parsed.data } : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function defaultWriteAuthFile(filePath, contents) {
+  const temporary = `${filePath}.${randomUUID()}.tmp`;
+  try {
+    await writeFile2(temporary, contents, { encoding: "utf8", mode: 384, flag: "wx" });
+    await rename(temporary, filePath);
+  } finally {
+    await unlink(temporary).catch(() => void 0);
+  }
+}
+async function refreshNativeCredentials(environment, stored, filePath, fetchImpl, writeAuthFile, signal, now) {
+  const refreshToken = stored.credentials.refresh_token;
+  if (!refreshToken)
+    return void 0;
+  const response = await fetchImpl(oauthTokenUrl(environment), {
+    method: "POST",
+    headers: { Accept: "application/json", "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: KIMI_CODE_CLIENT_ID,
+      grant_type: "refresh_token",
+      refresh_token: refreshToken
+    }),
+    signal
+  });
+  if (!response.ok)
+    return void 0;
+  const parsed = refreshResponseSchema.safeParse(await response.json());
+  if (!parsed.success)
+    return void 0;
+  const expiresIn = parsed.data.expires_in ?? stored.credentials.expires_in ?? 900;
+  const next = {
+    ...stored.raw,
+    access_token: parsed.data.access_token,
+    refresh_token: parsed.data.refresh_token ?? refreshToken,
+    expires_in: expiresIn,
+    expires_at: now / 1e3 + expiresIn,
+    ...parsed.data.scope ? { scope: parsed.data.scope } : {},
+    ...parsed.data.token_type ? { token_type: parsed.data.token_type } : {}
+  };
+  await writeAuthFile(filePath, `${JSON.stringify(next, void 0, 2)}
+`).catch(() => void 0);
+  stored.raw = next;
+  stored.credentials = {
+    ...stored.credentials,
+    access_token: parsed.data.access_token,
+    refresh_token: parsed.data.refresh_token ?? refreshToken,
+    expires_in: expiresIn,
+    expires_at: now / 1e3 + expiresIn
+  };
+  return parsed.data.access_token;
+}
+async function fetchKimiAccount(input = {}) {
+  try {
+    const environment = input.environment ?? process.env;
+    const fromEnv = environment.KIMI_CODE_API_KEY?.trim() || environment.KIMI_API_KEY?.trim();
+    const readAuthFile = input.readAuthFile ?? ((filePath2) => readFile2(filePath2, "utf8"));
+    const writeAuthFile = input.writeAuthFile ?? defaultWriteAuthFile;
+    const fetchImpl = input.fetch ?? fetch;
+    const requestSignal = () => input.signal ? AbortSignal.any([input.signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)]) : AbortSignal.timeout(REQUEST_TIMEOUT_MS);
+    const now = input.now ?? Date.now();
+    const filePath = credentialPath(environment);
+    const stored = fromEnv ? void 0 : await readNativeCredentials(filePath, readAuthFile);
+    let token = fromEnv ?? stored?.credentials.access_token;
+    if (!token)
+      return null;
+    if (stored && !accessTokenFresh(stored.credentials, now)) {
+      token = await refreshNativeCredentials(environment, stored, filePath, fetchImpl, writeAuthFile, requestSignal(), now) ?? token;
+    }
+    const requestUsages = (accessToken) => fetchImpl(KIMI_USAGES_ENDPOINT, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${accessToken}`, Accept: "application/json" },
+      signal: requestSignal()
+    });
+    let response = await requestUsages(token);
+    if (response.status === 401 && stored?.credentials.refresh_token) {
+      const refreshed = await refreshNativeCredentials(environment, stored, filePath, fetchImpl, writeAuthFile, requestSignal(), now);
+      if (!refreshed)
+        return null;
+      token = refreshed;
+      response = await requestUsages(token);
+    }
+    if (!response.ok)
+      return null;
+    return projectKimiUsages(await response.json());
+  } catch {
+    return null;
+  }
+}
+
 // dist/history.js
-import { readFile } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
 import os2 from "node:os";
-import path4 from "node:path";
+import path6 from "node:path";
 
 // ../../../node_modules/diff/libesm/diff/base.js
 var Diff = class {
@@ -20618,16 +21235,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path7, added, removed, oldPosInc, options) {
-    const last = path7.lastComponent;
+  addToPath(path10, added, removed, oldPosInc, options) {
+    const last = path10.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path7.oldPos + oldPosInc,
+        oldPos: path10.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path7.oldPos + oldPosInc,
+        oldPos: path10.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -21759,9 +22376,9 @@ function readKimiThinkingOptions(configOptions) {
 }
 
 // dist/projection.js
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 function projectKimiApprovalRequest(turnId, request) {
-  const interactionId = hostInteractionIdSchema.parse(randomUUID());
+  const interactionId = hostInteractionIdSchema.parse(randomUUID2());
   const optionIdByActionId = /* @__PURE__ */ new Map();
   const actions = [];
   const description = readAcpToolContentText(request.toolCall.content);
@@ -21805,7 +22422,7 @@ function projectKimiApprovalRequest(turnId, request) {
   return { interaction, optionIdByActionId };
 }
 function projectKimiElicitationRequest(turnId, request) {
-  const interactionId = hostInteractionIdSchema.parse(randomUUID());
+  const interactionId = hostInteractionIdSchema.parse(randomUUID2());
   const questions = [];
   const schemaProperties = {};
   const req = request;
@@ -21875,18 +22492,18 @@ function formatElicitationResponse(response, schemaProperties) {
   }
   return { action: "accept", content };
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function canonicalizeKimiToolName(name, kind, rawInput) {
   const trimmed = name?.trim();
   const lower = trimmed?.toLowerCase() ?? "";
   if (lower.startsWith("write") || lower.startsWith("writ")) {
-    const isEdit = isRecord3(rawInput) && ("old_string" in rawInput || "oldText" in rawInput || "old" in rawInput);
+    const isEdit = isRecord4(rawInput) && ("old_string" in rawInput || "oldText" in rawInput || "old" in rawInput);
     return isEdit ? "Edit" : "Write";
   }
   if (kind === "edit" || lower.startsWith("edit")) {
-    const isWrite = isRecord3(rawInput) && ("content" in rawInput || "text" in rawInput) && !("old_string" in rawInput || "oldText" in rawInput || "old" in rawInput);
+    const isWrite = isRecord4(rawInput) && ("content" in rawInput || "text" in rawInput) && !("old_string" in rawInput || "oldText" in rawInput || "old" in rawInput);
     return isWrite ? "Write" : "Edit";
   }
   if (kind === "execute" || lower.startsWith("bash") || lower.startsWith("shell") || lower.startsWith("run")) {
@@ -22095,14 +22712,14 @@ function createKimiNativeCheckpointRef(sessionId, turnId) {
   });
 }
 function getKimiCodeHome(homeDirectory, environment = process.env) {
-  return environment.KIMI_CODE_HOME || (homeDirectory ? path4.join(homeDirectory, ".kimi-code") : path4.join(os2.homedir(), ".kimi-code"));
+  return environment.KIMI_CODE_HOME || (homeDirectory ? path6.join(homeDirectory, ".kimi-code") : path6.join(os2.homedir(), ".kimi-code"));
 }
 async function locateKimiSession(sessionId, options = {}) {
-  const kimiHome = options.kimiCodeHome || getKimiCodeHome(options.homeDirectory);
-  const indexFile = path4.join(kimiHome, "session_index.jsonl");
+  const kimiHome2 = options.kimiCodeHome || getKimiCodeHome(options.homeDirectory);
+  const indexFile = path6.join(kimiHome2, "session_index.jsonl");
   let content;
   try {
-    content = await readFile(indexFile, "utf8");
+    content = await readFile3(indexFile, "utf8");
   } catch {
     return null;
   }
@@ -22123,15 +22740,15 @@ async function locateKimiSession(sessionId, options = {}) {
   if (!targetEntry || targetEntry.deleted || !targetEntry.sessionDir) {
     return null;
   }
-  const sessionDir = path4.resolve(targetEntry.sessionDir);
-  const normalizedKimiHome = path4.resolve(kimiHome);
-  const relativeToHome = path4.relative(normalizedKimiHome, sessionDir);
-  if (relativeToHome.startsWith("..") || path4.isAbsolute(relativeToHome)) {
+  const sessionDir = path6.resolve(targetEntry.sessionDir);
+  const normalizedKimiHome = path6.resolve(kimiHome2);
+  const relativeToHome = path6.relative(normalizedKimiHome, sessionDir);
+  if (relativeToHome.startsWith("..") || path6.isAbsolute(relativeToHome)) {
     throw new Error(`Session directory ${sessionDir} is outside KIMI_CODE_HOME`);
   }
   let state;
   try {
-    const stateContent = await readFile(path4.join(sessionDir, "state.json"), "utf8");
+    const stateContent = await readFile3(path6.join(sessionDir, "state.json"), "utf8");
     state = JSON.parse(stateContent);
   } catch {
     return null;
@@ -22139,7 +22756,7 @@ async function locateKimiSession(sessionId, options = {}) {
   if (state.id !== sessionId) {
     throw new Error(`State JSON session ID mismatch: expected ${sessionId}, found ${state.id}`);
   }
-  const mainHomeDir = state.agents?.main?.homedir ? path4.resolve(state.agents.main.homedir) : path4.join(sessionDir, "agents", "main");
+  const mainHomeDir = state.agents?.main?.homedir ? path6.resolve(state.agents.main.homedir) : path6.join(sessionDir, "agents", "main");
   return { sessionDir, mainHomeDir, state };
 }
 async function parseKimiWireLog(wireContent, sessionId, mainHomeDir) {
@@ -22432,14 +23049,14 @@ async function parseKimiWireLog(wireContent, sessionId, mainHomeDir) {
         let newContent = "";
         if (tracked?.key) {
           try {
-            oldContent = await readFile(path4.join(mainHomeDir, tracked.key), "utf8");
+            oldContent = await readFile3(path6.join(mainHomeDir, tracked.key), "utf8");
           } catch {
             oldContent = "";
           }
         }
         if (checkpoint?.key) {
           try {
-            newContent = await readFile(path4.join(mainHomeDir, checkpoint.key), "utf8");
+            newContent = await readFile3(path6.join(mainHomeDir, checkpoint.key), "utf8");
           } catch {
             newContent = "";
           }
@@ -22512,10 +23129,10 @@ async function readKimiSessionSnapshot(sessionId, options = {}) {
   if (!located) {
     throw new Error(`Kimi native session not found: ${sessionId}`);
   }
-  const wirePath = path4.join(located.mainHomeDir, "wire.jsonl");
+  const wirePath = path6.join(located.mainHomeDir, "wire.jsonl");
   let wireContent = "";
   try {
-    wireContent = await readFile(wirePath, "utf8");
+    wireContent = await readFile3(wirePath, "utf8");
   } catch (error51) {
     throw new Error(`Failed to read Kimi native history ${wirePath}: ${error51 instanceof Error ? error51.message : String(error51)}`, { cause: error51 });
   }
@@ -22572,28 +23189,268 @@ async function readKimiSessionUsage(sessionId, options = {}) {
   const located = await locateKimiSession(sessionId, options);
   if (!located)
     return null;
-  const wirePath = path4.join(located.mainHomeDir, "wire.jsonl");
+  const wirePath = path6.join(located.mainHomeDir, "wire.jsonl");
   try {
-    const wireContent = await readFile(wirePath, "utf8");
+    const wireContent = await readFile3(wirePath, "utf8");
     return extractKimiUsageFromWireLog(wireContent, options.contextWindowTokens);
   } catch {
     return null;
   }
 }
 
+// dist/session-import.js
+import { readFile as readFile4, stat } from "node:fs/promises";
+import path7 from "node:path";
+
+// ../../harness-adapter/dist/session-import.js
+import { lstat } from "node:fs/promises";
+var SessionImportChangedError = class extends Error {
+  constructor(message = "Native Session changed during discovery; refresh and retry") {
+    super(message);
+    this.name = "SessionImportChangedError";
+  }
+};
+function isMissingFileError(error51) {
+  return typeof error51 === "object" && error51 !== null && "code" in error51 && error51.code === "ENOENT";
+}
+function sameFileFingerprint(left, right) {
+  return left === null || right === null ? left === right : left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
+}
+var STORAGE_ACCESS_ERRORS = /* @__PURE__ */ new Set(["EACCES", "EPERM", "EIO", "EMFILE", "ENFILE"]);
+function isStorageAccessError(error51) {
+  return typeof error51 === "object" && error51 !== null && "code" in error51 && typeof error51.code === "string" && STORAGE_ACCESS_ERRORS.has(error51.code);
+}
+async function optionalLstat(file2) {
+  try {
+    return await lstat(file2);
+  } catch (error51) {
+    if (isMissingFileError(error51))
+      return null;
+    throw error51;
+  }
+}
+async function readStableFiles(files, read) {
+  const before = await Promise.all(files.map(optionalLstat));
+  const value = await read(before);
+  const after = await Promise.all(files.map(optionalLstat));
+  if (before.some((info, index) => !sameFileFingerprint(info, after[index] ?? null)))
+    throw new SessionImportChangedError();
+  return value;
+}
+function sessionImportTitle(value, maxLength = HARNESS_SESSION_IMPORT_TITLE_MAX_LENGTH) {
+  if (typeof value !== "string")
+    return null;
+  const normalized = value.replaceAll("\0", "").replaceAll(/\s+/gu, " ").trim();
+  if (!normalized)
+    return null;
+  if (normalized.length <= maxLength)
+    return normalized;
+  const characters = [...normalized];
+  if (characters.length <= maxLength)
+    return normalized;
+  return `${characters.slice(0, maxLength - 1).join("").trimEnd()}…`;
+}
+function sessionImportCandidate(input) {
+  const time3 = typeof input.updatedAt === "number" ? input.updatedAt : typeof input.updatedAt === "string" ? Date.parse(input.updatedAt) : Number.NaN;
+  const parsed = harnessSessionImportCandidateSchema.safeParse({
+    nativeSessionId: input.nativeSessionId,
+    cwd: input.cwd,
+    title: typeof input.title === "string" && input.title.trim().length > 0 ? input.title : null,
+    updatedAt: Math.floor(time3),
+    // Unknown must stay unknown; only an explicit boolean is a native statement.
+    running: typeof input.running === "boolean" ? input.running : null
+  });
+  return parsed.success ? parsed.data : null;
+}
+var SessionImportScope = class {
+  #abort = new AbortController();
+  #options;
+  #pending = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.#options = options;
+  }
+  #closed() {
+    return {
+      ok: false,
+      error: { code: "invalidState", message: this.#options.closedMessage, retryable: false }
+    };
+  }
+  read(operation) {
+    const signal = this.#abort.signal;
+    if (signal.aborted)
+      return Promise.resolve(this.#closed());
+    let started;
+    try {
+      started = operation(signal);
+    } catch (error51) {
+      started = Promise.reject(error51 instanceof Error ? error51 : new Error("Session read failed"));
+    }
+    const request = started.then((value) => signal.aborted ? this.#closed() : { ok: true, value }).catch(() => signal.aborted ? this.#closed() : {
+      ok: false,
+      error: {
+        code: "unavailable",
+        message: this.#options.unavailableMessage,
+        retryable: true
+      }
+    }).finally(() => this.#pending.delete(request));
+    this.#pending.add(request);
+    return request;
+  }
+  /** `read` for `resolveCandidate`: a null source is the selected Session having disappeared. */
+  async resolve(operation) {
+    const result = await this.read(operation);
+    if (!result.ok)
+      return result;
+    return result.value ? { ok: true, value: result.value } : {
+      ok: false,
+      error: {
+        code: "sessionNotFound",
+        message: this.#options.notFoundMessage,
+        retryable: false
+      }
+    };
+  }
+  /** Idempotent. Resolves after every started read has settled. */
+  async close() {
+    this.#abort.abort();
+    await Promise.allSettled(this.#pending);
+  }
+};
+
+// dist/session-import.js
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var KimiSessionImport = class {
+  #home;
+  #scope = new SessionImportScope({
+    closedMessage: "Kimi Session import is closed",
+    unavailableMessage: "Kimi sessions could not be read; close native clients, check storage access and retry",
+    notFoundMessage: "Kimi Session is no longer importable"
+  });
+  constructor(options) {
+    this.#home = getKimiCodeHome(options.homeDirectory, options.environment);
+  }
+  listCandidates() {
+    return this.#scope.read(async (signal) => {
+      const candidates = [];
+      for (const nativeSessionId of await this.#indexedSessions(signal)) {
+        try {
+          const source = await this.#source(nativeSessionId, signal);
+          if (source)
+            candidates.push(source.candidate);
+        } catch (error51) {
+          if (!(error51 instanceof SessionImportChangedError))
+            throw error51;
+        }
+      }
+      return candidates;
+    });
+  }
+  resolveCandidate(nativeSessionId) {
+    return this.#scope.resolve(async (signal) => (await this.#indexedSessions(signal)).has(nativeSessionId) ? this.#source(nativeSessionId, signal) : null);
+  }
+  close() {
+    return this.#scope.close();
+  }
+  /** Live identities in Kimi's index. The last record of an identity decides, as in resume. */
+  async #indexedSessions(signal) {
+    const live = /* @__PURE__ */ new Set();
+    let content;
+    try {
+      content = await readFile4(path7.join(this.#home, "session_index.jsonl"), {
+        encoding: "utf8",
+        signal
+      });
+    } catch (error51) {
+      signal.throwIfAborted();
+      if (isMissingFileError(error51))
+        return live;
+      throw error51;
+    }
+    for (const line of content.split("\n")) {
+      if (!line.trim())
+        continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!isRecord5(entry) || typeof entry.sessionId !== "string" || !entry.sessionId)
+        continue;
+      if (entry.deleted || typeof entry.sessionDir !== "string")
+        live.delete(entry.sessionId);
+      else
+        live.add(entry.sessionId);
+    }
+    return live;
+  }
+  async #source(nativeSessionId, signal) {
+    signal.throwIfAborted();
+    const options = { kimiCodeHome: this.#home };
+    let located;
+    try {
+      located = await locateKimiSession(nativeSessionId, options);
+    } catch (error51) {
+      if (isStorageAccessError(error51))
+        throw error51;
+      return null;
+    }
+    if (!located)
+      return null;
+    const { state } = located;
+    const files = [
+      path7.join(located.sessionDir, "state.json"),
+      path7.join(located.mainHomeDir, "wire.jsonl")
+    ];
+    return readStableFiles(files, async ([stateInfo, wire]) => {
+      if (!stateInfo?.isFile() || !wire?.isFile())
+        return null;
+      try {
+        if (typeof state.cwd !== "string" || !path7.isAbsolute(state.cwd))
+          return null;
+        const cwd = path7.resolve(state.cwd);
+        if (!(await stat(cwd)).isDirectory())
+          return null;
+        signal.throwIfAborted();
+        const { turns } = await readKimiSessionSnapshot(nativeSessionId, options);
+        const prompt = turns.flatMap((turn) => turn.input).find((input) => input.type === "text" && input.text.trim().length > 0);
+        if (!prompt)
+          return null;
+        const activity = turns.flatMap((turn) => [turn.completedAtMs, turn.startedAtMs]).filter((time3) => typeof time3 === "number" && Number.isFinite(time3));
+        const candidate = sessionImportCandidate({
+          nativeSessionId,
+          cwd,
+          title: sessionImportTitle(state.title) ?? sessionImportTitle(prompt.text),
+          // Wire record times are milliseconds; the state file's unit is not documented.
+          updatedAt: activity.length > 0 ? Math.max(...activity) : wire.mtimeMs
+          // Kimi has no cross-process activity marker: idleness cannot be established.
+        });
+        return candidate ? { candidate, nativeRef: createKimiNativeSessionRef(nativeSessionId, cwd) } : null;
+      } catch (error51) {
+        signal.throwIfAborted();
+        if (isStorageAccessError(error51))
+          throw error51;
+        return null;
+      }
+    });
+  }
+};
+
 // dist/kimi-session.js
 import { setTimeout as delay } from "node:timers/promises";
 
 // dist/command-history.js
-import { appendFile, readFile as readFile2, writeFile } from "node:fs/promises";
-import path5 from "node:path";
+import { appendFile, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
+import path8 from "node:path";
 async function readKimiCommandHistory(sessionId, options) {
   const located = await locateKimiSession(sessionId, options);
   if (!located)
     return [];
   let content;
   try {
-    content = await readFile2(path5.join(located.sessionDir, "codexhost-commands.jsonl"), "utf8");
+    content = await readFile5(path8.join(located.sessionDir, "codexhost-commands.jsonl"), "utf8");
   } catch (error51) {
     if (error51.code === "ENOENT")
       return [];
@@ -22623,7 +23480,7 @@ async function appendKimiCommandHistory(turn, options) {
   const located = await locateKimiSession(turn.nativeTurnRef.nativeSessionId, options);
   if (!located)
     throw new Error("Cannot persist Kimi command: native session is missing");
-  await appendFile(path5.join(located.sessionDir, "codexhost-commands.jsonl"), `${JSON.stringify(turn)}
+  await appendFile(path8.join(located.sessionDir, "codexhost-commands.jsonl"), `${JSON.stringify(turn)}
 `, "utf8");
 }
 async function copyKimiCommandHistory(turns, sessionId, options) {
@@ -22637,7 +23494,7 @@ async function copyKimiCommandHistory(turns, sessionId, options) {
     nativeTurnRef: { ...turn.nativeTurnRef, nativeSessionId: sessionId },
     ...turn.checkpoint ? { checkpoint: { ...turn.checkpoint, nativeSessionId: sessionId } } : {}
   }));
-  await writeFile(path5.join(located.sessionDir, "codexhost-commands.jsonl"), copied.map((turn) => `${JSON.stringify(turn)}
+  await writeFile3(path8.join(located.sessionDir, "codexhost-commands.jsonl"), copied.map((turn) => `${JSON.stringify(turn)}
 `).join(""), "utf8");
 }
 
@@ -23806,6 +24663,7 @@ function stateFromConfig(sessionId, cwd, configOptions) {
 }
 var KimiAdapter = class {
   harnessId = kimiHarnessId3;
+  sessionImport;
   #options;
   #deps;
   #sessions = /* @__PURE__ */ new Set();
@@ -23818,6 +24676,15 @@ var KimiAdapter = class {
   constructor(options = {}, dependencies = {}) {
     this.#options = options;
     this.#deps = dependencies;
+    this.sessionImport = new KimiSessionImport({
+      environment: { ...process.env, ...options.environment },
+      homeDirectory: options.homeDirectory
+    });
+  }
+  async inspectAccount() {
+    if (this.#closed)
+      return null;
+    return fetchKimiAccount({ environment: { ...process.env, ...this.#options.environment } });
   }
   #createTransport(options) {
     return this.#deps.createTransport ? this.#deps.createTransport(options) : new KimiAcpTransport(options);
@@ -23850,11 +24717,11 @@ var KimiAdapter = class {
       this.#inspectionCache = result;
       return result;
     }
-    const kimiHome = getKimiCodeHome(this.#options.homeDirectory, environment);
-    const configPath = path6.join(kimiHome, "config.toml");
+    const kimiHome2 = getKimiCodeHome(this.#options.homeDirectory, environment);
+    const configPath = path9.join(kimiHome2, "config.toml");
     let nativeConfig = null;
     try {
-      const configContent = await readFile3(configPath, "utf8");
+      const configContent = await readFile6(configPath, "utf8");
       nativeConfig = parseKimiConfigToml(configContent);
     } catch {
       nativeConfig = null;
@@ -23964,11 +24831,11 @@ var KimiAdapter = class {
       ...this.#options.closeTimeoutMs ? { closeTimeoutMs: this.#options.closeTimeoutMs } : {},
       onFault: (error51) => session?.handleTransportFault(error51)
     });
-    const kimiHome = getKimiCodeHome(this.#options.homeDirectory, environment);
-    const configPath = path6.join(kimiHome, "config.toml");
+    const kimiHome2 = getKimiCodeHome(this.#options.homeDirectory, environment);
+    const configPath = path9.join(kimiHome2, "config.toml");
     let nativeConfig = null;
     try {
-      const configContent = await readFile3(configPath, "utf8");
+      const configContent = await readFile6(configPath, "utf8");
       nativeConfig = parseKimiConfigToml(configContent);
     } catch {
       nativeConfig = null;
@@ -24025,7 +24892,7 @@ var KimiAdapter = class {
         await transport.close().catch(() => void 0);
         return err2("checkpointNotFound", "Kimi Checkpoint does not belong to the source Native Session");
       }
-      if (path6.resolve(cwd) !== path6.resolve(located.state.cwd)) {
+      if (path9.resolve(cwd) !== path9.resolve(located.state.cwd)) {
         await transport.close().catch(() => void 0);
         return err2("unsupported", "Kimi Code cannot fork across different working directories");
       }
@@ -24148,7 +25015,7 @@ var KimiAdapter = class {
       const located = await locateKimiSession(sourceId, historyOptions);
       if (!located)
         return err2("sessionNotFound", "Kimi source session was not found");
-      if (path6.resolve(input.cwd) !== path6.resolve(located.state.cwd))
+      if (path9.resolve(input.cwd) !== path9.resolve(located.state.cwd))
         return err2("unsupported", "Kimi cannot roll back into another working directory");
       const source = [...this.#sessions].find((candidate) => candidate.initialState.nativeRef?.nativeSessionId === sourceId);
       if (source) {
@@ -24206,6 +25073,7 @@ var KimiAdapter = class {
       return;
     this.#closed = true;
     this.#commandCatalog = KIMI_DEFAULT_COMMAND_CATALOG;
+    await this.sessionImport.close();
     for (const session of this.#sessions) {
       await session.close().catch(() => void 0);
     }
@@ -24213,12 +25081,72 @@ var KimiAdapter = class {
   }
 };
 
+// dist/installation.js
+import { open, readFile as readFile7 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
+function createKimiInstallation(environment) {
+  const executable = () => resolveKimiExecutable({ environment });
+  const run = (args, timeout) => runInstallationCommand(executable(), args, { ...environment, KIMI_CODE_NO_AUTO_UPDATE: "1" }, timeout);
+  const nativeUpdaterAvailable = async () => {
+    const file2 = await open(executable(), "r");
+    try {
+      const header = Buffer.alloc(4);
+      await file2.read(header, 0, 4, 0);
+      const magic = header.toString("hex");
+      if (!["cffaedfe", "cefaedfe", "cafebabe", "7f454c46"].includes(magic) && !magic.startsWith("4d5a"))
+        return false;
+    } finally {
+      await file2.close();
+    }
+    return /--manual/.test(await run(["__update_download", "--help"]));
+  };
+  return createInstallationManager({
+    async check() {
+      const currentVersion = versionFromOutput(await run(["--version"]));
+      const home = environment.KIMI_CODE_HOME ?? join3(environment.HOME ?? homedir3(), ".kimi-code");
+      const region = await readFile7(join3(home, "region"), "utf8").catch(() => "");
+      const base = region.trim() === "global" ? "https://code.kimi.ai/kimi-code" : "https://code.kimi.com/kimi-code";
+      const latestVersion = installationVersion(await fetchInstallationText(`${base}/latest`));
+      const npm = await npmInstallation(executable(), ["@moonshot-ai/kimi-code"], environment);
+      const canUpdate = npm ? npm.canUpdate : await nativeUpdaterAvailable();
+      return {
+        currentVersion,
+        latestVersion,
+        updateAvailable: newerInstallationVersion(currentVersion, latestVersion),
+        canUpdate,
+        ...!canUpdate ? {
+          messageCode: "original-installer",
+          message: "Use the original installer to update this Kimi installation"
+        } : {}
+      };
+    },
+    async update(state) {
+      const npm = await npmInstallation(executable(), ["@moonshot-ai/kimi-code"], environment);
+      if (npm)
+        await npm.update(state.latestVersion);
+      else {
+        if (!await nativeUpdaterAvailable())
+          throw new Error("Kimi native updater is unavailable");
+        await run(["__update_download", state.latestVersion, "--manual"], 3e5);
+        await run(["--version"]);
+      }
+    }
+  });
+}
+
 // dist/plugin.js
 function createHarnessAdapter(context) {
   const environment = { ...context.environment };
-  return new KimiAdapter({
+  return Object.assign(new KimiAdapter({
     ...environment[KIMI_COMMAND_ENV] ? { command: environment[KIMI_COMMAND_ENV] } : {},
     environment
+  }), {
+    installation: createKimiInstallation(environment),
+    install: createHarnessInstaller(environment, {
+      posix: "https://code.kimi.com/kimi-code/install.sh",
+      windows: "https://code.kimi.com/kimi-code/install.ps1"
+    })
   });
 }
 export {