@codexhost/cli-darwin-x64 0.11.0 → 0.12.0

package/app/plugins/codebuddy/plugin.mjs

@@ -5,6 +5,488 @@ 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 text2 = shim.replaceAll("\\", "/").toLowerCase();
+  return text2.includes(`%dp0%/${target}"`) || text2.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((text2) => JSON.parse(text2)).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((text2) => JSON.parse(text2)).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 });
+    }
+  };
+}
+
 // ../../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -771,10 +1253,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path9) {
-  if (!path9)
+function getElementAtPath(obj, path10) {
+  if (!path10)
     return obj;
-  return path9.reduce((acc, key) => acc?.[key], obj);
+  return path10.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1183,11 +1665,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path9, issues) {
+function prefixIssues(path10, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path9);
+    iss.path.unshift(path10);
     return iss;
   });
 }
@@ -1334,16 +1816,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path9 = []) => {
+  const processError = (error52, path10 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path9, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path10, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else {
-        const fullpath = [...path9, ...issue2.path];
+        const fullpath = [...path10, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1370,17 +1852,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path9 = []) => {
+  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 }, [...path9, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path10, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else {
-        const fullpath = [...path9, ...issue2.path];
+        const fullpath = [...path10, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1412,8 +1894,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path9 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path9) {
+  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")
@@ -14105,13 +14587,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path9 = ref.slice(1).split("/").filter(Boolean);
-  if (path9.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 (path9[0] === defsKey) {
-    const key = path9[1];
+  if (path10[0] === defsKey) {
+    const key = path10[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14605,6 +15087,7 @@ var CONSOLE_HOST_METHODS = Object.freeze([
   "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",
@@ -15251,14 +15734,17 @@ var harnessLaunchSettingsSchema = external_exports.object({
 // ../../shared-contracts/dist/harness-installation.js
 var harnessInstallationParamsSchema = external_exports.object({
   harnessId: harnessIdSchema,
-  action: external_exports.enum(["check", "update"])
+  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(),
-  message: external_exports.string().max(2048).optional()
+  // 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
@@ -15560,6 +16046,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);
 
@@ -15980,7 +16498,7 @@ function commandPrompt(command, catalog, profile = CODEBUDDY_RUNTIME_PROFILE) {
 }
 
 // dist/codebuddy-adapter.js
-import { stat as stat2 } from "node:fs/promises";
+import { stat as stat3 } from "node:fs/promises";
 
 // dist/acp-client.js
 import { execFile as execFile2, spawn } from "node:child_process";
@@ -19781,861 +20299,433 @@ var ClientSideConnection = class {
    * The request may include `additionalDirectories` to set the complete list of
    * additional workspace roots for the loaded session.
    *
-   * See protocol docs: [Loading Sessions](https://agentclientprotocol.com/protocol/session-setup#loading-sessions)
-   */
-  loadSession(params) {
-    return this.connection.sendRequest(AGENT_METHODS.session_load, params, emptyObjectResponse);
-  }
-  /**
-   * **UNSTABLE**
-   *
-   * This capability is not part of the spec yet, and may be removed or changed at any point.
-   *
-   * Forks an existing session to create a new independent session.
-   *
-   * Creates a new session based on the context of an existing one, allowing
-   * operations like generating summaries without affecting the original session's history.
-   *
-   * The request may include `additionalDirectories` to set the complete list of
-   * additional workspace roots for the forked session.
-   *
-   * This method is only available if the agent advertises the `session.fork` capability.
-   *
-   * @experimental
-   */
-  unstable_forkSession(params) {
-    return this.connection.sendRequest(AGENT_METHODS.session_fork, params);
-  }
-  /**
-   * Lists existing sessions from the agent.
-   *
-   * This method is only available if the agent advertises the `listSessions` capability.
-   *
-   * Returns a list of sessions with metadata like session ID, working directory,
-   * title, and last update time. Supports filtering by working directory,
-   * `additionalDirectories`, and cursor-based pagination.
-   */
-  listSessions(params) {
-    return this.connection.sendRequest(AGENT_METHODS.session_list, params);
-  }
-  /**
-   * Deletes an existing session returned by `session/list`.
-   *
-   * This method is only available if the agent advertises the `sessionCapabilities.delete` capability.
-   */
-  deleteSession(params) {
-    return this.connection.sendRequest(AGENT_METHODS.session_delete, params, emptyObjectResponse);
-  }
-  /**
-   * Resumes an existing session without returning previous messages.
-   *
-   * This method is only available if the agent advertises the `session.resume` capability.
-   *
-   * The agent should resume the session context, allowing the conversation to continue
-   * without replaying the message history (unlike `session/load`).
-   *
-   * The request may include `additionalDirectories` to set the complete list of
-   * additional workspace roots for the resumed session.
-   */
-  resumeSession(params) {
-    return this.connection.sendRequest(AGENT_METHODS.session_resume, params);
-  }
-  /**
-   * Closes an active session and frees up any resources associated with it.
-   *
-   * This method is only available if the agent advertises the `session.close` capability.
-   *
-   * The agent must cancel any ongoing work (as if `session/cancel` was called)
-   * and then free up any resources associated with the session.
-   */
-  closeSession(params) {
-    return this.connection.sendRequest(AGENT_METHODS.session_close, params, emptyObjectResponse);
-  }
-  /**
-   * Sets the operational mode for a session.
-   *
-   * Allows switching between different agent modes (e.g., "ask", "architect", "code")
-   * that affect system prompts, tool availability, and permission behaviors.
-   *
-   * The mode must be one of the modes advertised in `availableModes` during session
-   * creation or loading. Agents may also change modes autonomously and notify the
-   * client via `current_mode_update` notifications.
-   *
-   * This method can be called at any time during a session, whether the Agent is
-   * idle or actively generating a turn.
-   *
-   * See protocol docs: [Session Modes](https://agentclientprotocol.com/protocol/session-modes)
-   */
-  setSessionMode(params) {
-    return this.connection.sendRequest(AGENT_METHODS.session_set_mode, params, emptyObjectResponse);
-  }
-  /**
-   * Set a configuration option for a given session.
-   *
-   * The response contains the full set of configuration options and their current values,
-   * as changing one option may affect the available values or state of other options.
-   */
-  setSessionConfigOption(params) {
-    return this.connection.sendRequest(AGENT_METHODS.session_set_config_option, params);
-  }
-  /**
-   * Authenticates the client using the specified authentication method.
-   *
-   * Called when the agent requires authentication before allowing session creation.
-   * The client provides the authentication method ID that was advertised during initialization.
-   *
-   * After successful authentication, the client can proceed to create sessions with
-   * `newSession` without receiving an `auth_required` error.
-   *
-   * See protocol docs: [Initialization](https://agentclientprotocol.com/protocol/initialization)
-   */
-  authenticate(params) {
-    return this.connection.sendRequest(AGENT_METHODS.authenticate, params, emptyObjectResponse);
-  }
-  /**
-   * **UNSTABLE**
-   *
-   * This capability is not part of the spec yet, and may be removed or changed at any point.
-   *
-   * Lists providers that can be configured by the client.
-   *
-   * This method is only available if the agent advertises the `providers` capability.
-   *
-   * @experimental
-   */
-  unstable_listProviders(params) {
-    return this.connection.sendRequest(AGENT_METHODS.providers_list, params);
-  }
-  /**
-   * **UNSTABLE**
-   *
-   * This capability is not part of the spec yet, and may be removed or changed at any point.
-   *
-   * Replaces the configuration for a provider.
-   *
-   * This method is only available if the agent advertises the `providers` capability.
-   *
-   * @experimental
-   */
-  unstable_setProvider(params) {
-    return this.connection.sendRequest(AGENT_METHODS.providers_set, params, emptyObjectResponse);
-  }
-  /**
-   * **UNSTABLE**
-   *
-   * This capability is not part of the spec yet, and may be removed or changed at any point.
-   *
-   * Disables a provider.
-   *
-   * This method is only available if the agent advertises the `providers` capability.
-   *
-   * @experimental
-   */
-  unstable_disableProvider(params) {
-    return this.connection.sendRequest(AGENT_METHODS.providers_disable, params, emptyObjectResponse);
-  }
-  /**
-   * Logout of the current authentication method.
-   */
-  logout(params) {
-    return this.connection.sendRequest(AGENT_METHODS.logout, params, emptyObjectResponse);
-  }
-  /**
-   * Processes a user prompt within a session.
-   *
-   * This method handles the whole lifecycle of a prompt:
-   * - Receives user messages with optional context (files, images, etc.)
-   * - Processes the prompt using language models
-   * - Reports language model content and tool calls to the Clients
-   * - Requests permission to run tools
-   * - Executes any requested tool calls
-   * - Returns when the turn is complete with a stop reason
-   *
-   * See protocol docs: [Prompt Turn](https://agentclientprotocol.com/protocol/prompt-turn)
-   */
-  prompt(params) {
-    return this.connection.sendRequest(AGENT_METHODS.session_prompt, params);
-  }
-  /**
-   * Cancels ongoing operations for a session.
-   *
-   * This is a notification sent by the client to cancel an ongoing prompt turn.
-   *
-   * Upon receiving this notification, the Agent SHOULD:
-   * - Stop all language model requests as soon as possible
-   * - Abort all tool call invocations in progress
-   * - Send any pending `session/update` notifications
-   * - Respond to the original `session/prompt` request with `StopReason::Cancelled`
-   *
-   * See protocol docs: [Cancellation](https://agentclientprotocol.com/protocol/prompt-turn#cancellation)
-   */
-  cancel(params) {
-    return this.connection.sendNotification(AGENT_METHODS.session_cancel, params);
-  }
-  /**
-   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
-   *
-   * Starts a NES (Next Edit Suggestions) session.
-   *
-   * @experimental
-   */
-  unstable_startNes(params) {
-    return this.connection.sendRequest(AGENT_METHODS.nes_start, params);
-  }
-  /**
-   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
-   *
-   * Sends a NES suggestion request.
-   *
-   * @experimental
-   */
-  unstable_suggestNes(params) {
-    return this.connection.sendRequest(AGENT_METHODS.nes_suggest, params);
-  }
-  /**
-   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
-   *
-   * Closes a NES session.
-   *
-   * @experimental
+   * See protocol docs: [Loading Sessions](https://agentclientprotocol.com/protocol/session-setup#loading-sessions)
    */
-  unstable_closeNes(params) {
-    return this.connection.sendRequest(AGENT_METHODS.nes_close, params, emptyObjectResponse);
+  loadSession(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_load, params, emptyObjectResponse);
   }
   /**
-   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   * **UNSTABLE**
    *
-   * Notifies the agent that a document was opened.
+   * This capability is not part of the spec yet, and may be removed or changed at any point.
    *
-   * @experimental
-   */
-  unstable_didOpenDocument(params) {
-    return this.connection.sendNotification(AGENT_METHODS.document_did_open, params);
-  }
-  /**
-   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   * Forks an existing session to create a new independent session.
    *
-   * Notifies the agent that a document was changed.
+   * Creates a new session based on the context of an existing one, allowing
+   * operations like generating summaries without affecting the original session's history.
+   *
+   * The request may include `additionalDirectories` to set the complete list of
+   * additional workspace roots for the forked session.
+   *
+   * This method is only available if the agent advertises the `session.fork` capability.
    *
    * @experimental
    */
-  unstable_didChangeDocument(params) {
-    return this.connection.sendNotification(AGENT_METHODS.document_did_change, params);
+  unstable_forkSession(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_fork, params);
   }
   /**
-   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   * Lists existing sessions from the agent.
    *
-   * Notifies the agent that a document was closed.
+   * This method is only available if the agent advertises the `listSessions` capability.
    *
-   * @experimental
+   * Returns a list of sessions with metadata like session ID, working directory,
+   * title, and last update time. Supports filtering by working directory,
+   * `additionalDirectories`, and cursor-based pagination.
    */
-  unstable_didCloseDocument(params) {
-    return this.connection.sendNotification(AGENT_METHODS.document_did_close, params);
+  listSessions(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_list, params);
   }
   /**
-   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
-   *
-   * Notifies the agent that a document was saved.
+   * Deletes an existing session returned by `session/list`.
    *
-   * @experimental
+   * This method is only available if the agent advertises the `sessionCapabilities.delete` capability.
    */
-  unstable_didSaveDocument(params) {
-    return this.connection.sendNotification(AGENT_METHODS.document_did_save, params);
+  deleteSession(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_delete, params, emptyObjectResponse);
   }
   /**
-   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   * Resumes an existing session without returning previous messages.
    *
-   * Notifies the agent that a document received focus.
+   * This method is only available if the agent advertises the `session.resume` capability.
    *
-   * @experimental
+   * The agent should resume the session context, allowing the conversation to continue
+   * without replaying the message history (unlike `session/load`).
+   *
+   * The request may include `additionalDirectories` to set the complete list of
+   * additional workspace roots for the resumed session.
    */
-  unstable_didFocusDocument(params) {
-    return this.connection.sendNotification(AGENT_METHODS.document_did_focus, params);
+  resumeSession(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_resume, params);
   }
   /**
-   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   * Closes an active session and frees up any resources associated with it.
    *
-   * Notifies the agent that a NES suggestion was accepted.
+   * This method is only available if the agent advertises the `session.close` capability.
    *
-   * @experimental
+   * The agent must cancel any ongoing work (as if `session/cancel` was called)
+   * and then free up any resources associated with the session.
    */
-  unstable_acceptNes(params) {
-    return this.connection.sendNotification(AGENT_METHODS.nes_accept, params);
+  closeSession(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_close, params, emptyObjectResponse);
   }
   /**
-   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   * Sets the operational mode for a session.
    *
-   * Notifies the agent that a NES suggestion was rejected.
+   * Allows switching between different agent modes (e.g., "ask", "architect", "code")
+   * that affect system prompts, tool availability, and permission behaviors.
    *
-   * @experimental
+   * The mode must be one of the modes advertised in `availableModes` during session
+   * creation or loading. Agents may also change modes autonomously and notify the
+   * client via `current_mode_update` notifications.
+   *
+   * This method can be called at any time during a session, whether the Agent is
+   * idle or actively generating a turn.
+   *
+   * See protocol docs: [Session Modes](https://agentclientprotocol.com/protocol/session-modes)
    */
-  unstable_rejectNes(params) {
-    return this.connection.sendNotification(AGENT_METHODS.nes_reject, params);
-  }
-  request(method, params, options) {
-    const spec = agentRequestSpecsByMethod[method];
-    return this.connection.sendRequest(method, params, spec?.mapResponse, options);
-  }
-  notify(method, params) {
-    return this.connection.sendNotification(method, params);
+  setSessionMode(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_set_mode, params, emptyObjectResponse);
   }
   /**
-   * Extension method.
+   * Set a configuration option for a given session.
    *
-   * @deprecated Use {@link request}.
+   * The response contains the full set of configuration options and their current values,
+   * as changing one option may affect the available values or state of other options.
    */
-  extMethod(method, params) {
-    return this.request(method, params);
+  setSessionConfigOption(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_set_config_option, params);
   }
   /**
-   * Extension notification.
+   * Authenticates the client using the specified authentication method.
    *
-   * @deprecated Use {@link notify}.
+   * Called when the agent requires authentication before allowing session creation.
+   * The client provides the authentication method ID that was advertised during initialization.
+   *
+   * After successful authentication, the client can proceed to create sessions with
+   * `newSession` without receiving an `auth_required` error.
+   *
+   * See protocol docs: [Initialization](https://agentclientprotocol.com/protocol/initialization)
    */
-  extNotification(method, params) {
-    return this.notify(method, params);
+  authenticate(params) {
+    return this.connection.sendRequest(AGENT_METHODS.authenticate, params, emptyObjectResponse);
   }
   /**
-   * 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.
+   * **UNSTABLE**
    *
-   * @example
-   * ```typescript
-   * const connection = new ClientSideConnection(client, stream);
+   * This capability is not part of the spec yet, and may be removed or changed at any point.
    *
-   * // Listen for closure
-   * connection.signal.addEventListener('abort', () => {
-   *   console.log('Connection closed - performing cleanup');
-   * });
+   * Lists providers that can be configured by the client.
    *
-   * // Check status
-   * if (connection.signal.aborted) {
-   *   console.log('Connection is already closed');
-   * }
+   * This method is only available if the agent advertises the `providers` capability.
    *
-   * // Pass to other APIs
-   * fetch(url, { signal: connection.signal });
-   * ```
+   * @experimental
    */
-  get signal() {
-    return this.connection.signal;
+  unstable_listProviders(params) {
+    return this.connection.sendRequest(AGENT_METHODS.providers_list, params);
   }
   /**
-   * Promise that resolves when the connection closes.
+   * **UNSTABLE**
    *
-   * 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 capability is not part of the spec yet, and may be removed or changed at any point.
    *
-   * This is useful for async/await style cleanup:
+   * Replaces the configuration for a provider.
    *
-   * @example
-   * ```typescript
-   * const connection = new ClientSideConnection(client, stream);
-   * await connection.closed;
-   * console.log('Connection closed - performing cleanup');
-   * ```
+   * This method is only available if the agent advertises the `providers` capability.
+   *
+   * @experimental
    */
-  get closed() {
-    return this.connection.closed;
-  }
-};
-
-// dist/copy-cleanup.js
-import { randomBytes } from "node:crypto";
-import { createInterface } from "node:readline";
-import { stripVTControlCharacters } from "node:util";
-import { Readable } from "node:stream";
-var CodeBuddyCopyCleanup = class {
-  copyId;
-  cwd;
-  password = randomBytes(32).toString("base64url");
-  arguments = [
-    "--acp",
-    "--serve",
-    "--host",
-    "127.0.0.1",
-    "--port",
-    "0",
-    "--auth",
-    "password"
-  ];
-  #endpoint;
-  constructor(copyId, cwd) {
-    this.copyId = copyId;
-    this.cwd = cwd;
-  }
-  environment(environment) {
-    return {
-      ...environment,
-      CODEBUDDY_GATEWAY_AUTH: "password",
-      CODEBUDDY_GATEWAY_PASSWORD: this.password,
-      CODEBUDDY_GATEWAY_BASE_PATH: ""
-    };
-  }
-  /** Native --serve banners include its password; never pass them to the ACP parser/logs. */
-  protocolOutput(stdout) {
-    return Readable.from(this.#protocolLines(stdout));
-  }
-  async *#protocolLines(stdout) {
-    for await (const line of createInterface({ input: stdout })) {
-      const endpoint = /^\s*Endpoint\s+(http:\/\/127\.0\.0\.1:\d+)\s*$/u.exec(stripVTControlCharacters(line));
-      if (endpoint)
-        this.#endpoint = endpoint[1];
-      if (line.trimStart().startsWith("{"))
-        yield Buffer.from(`${line}
-`);
-    }
-  }
-  async remove() {
-    if (!this.#endpoint)
-      throw new CodeBuddyError("nativeFailure", `Native cleanup endpoint was not reported; temporary Session ${this.copyId} remains`);
-    const response = await fetch(`${this.#endpoint}/api/v1/sessions/${encodeURIComponent(this.copyId)}?cwd=${encodeURIComponent(this.cwd)}`, {
-      method: "DELETE",
-      headers: { Authorization: `Bearer ${this.password}`, "x-codebuddy-request": "true" },
-      signal: AbortSignal.timeout(5e3),
-      redirect: "error"
-    }).catch(() => {
-      throw new CodeBuddyError("nativeFailure", `Native cleanup request failed; temporary Session ${this.copyId} remains`);
-    });
-    await response.body?.cancel();
-    if (response.status !== 204)
-      throw new CodeBuddyError("nativeFailure", `Native cleanup failed (${response.status}); temporary Session ${this.copyId} remains`);
+  unstable_setProvider(params) {
+    return this.connection.sendRequest(AGENT_METHODS.providers_set, params, emptyObjectResponse);
   }
-};
-
-// ../../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;
+  /**
+   * **UNSTABLE**
+   *
+   * This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Disables a provider.
+   *
+   * This method is only available if the agent advertises the `providers` capability.
+   *
+   * @experimental
+   */
+  unstable_disableProvider(params) {
+    return this.connection.sendRequest(AGENT_METHODS.providers_disable, params, emptyObjectResponse);
   }
-  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;
+  /**
+   * Logout of the current authentication method.
+   */
+  logout(params) {
+    return this.connection.sendRequest(AGENT_METHODS.logout, params, emptyObjectResponse);
   }
-}
-function subdirectoryNames(directory) {
-  try {
-    return fs.readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-  } catch {
-    return [];
+  /**
+   * Processes a user prompt within a session.
+   *
+   * This method handles the whole lifecycle of a prompt:
+   * - Receives user messages with optional context (files, images, etc.)
+   * - Processes the prompt using language models
+   * - Reports language model content and tool calls to the Clients
+   * - Requests permission to run tools
+   * - Executes any requested tool calls
+   * - Returns when the turn is complete with a stop reason
+   *
+   * See protocol docs: [Prompt Turn](https://agentclientprotocol.com/protocol/prompt-turn)
+   */
+  prompt(params) {
+    return this.connection.sendRequest(AGENT_METHODS.session_prompt, params);
   }
-}
-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 };
+  /**
+   * Cancels ongoing operations for a session.
+   *
+   * This is a notification sent by the client to cancel an ongoing prompt turn.
+   *
+   * Upon receiving this notification, the Agent SHOULD:
+   * - Stop all language model requests as soon as possible
+   * - Abort all tool call invocations in progress
+   * - Send any pending `session/update` notifications
+   * - Respond to the original `session/prompt` request with `StopReason::Cancelled`
+   *
+   * See protocol docs: [Cancellation](https://agentclientprotocol.com/protocol/prompt-turn#cancellation)
+   */
+  cancel(params) {
+    return this.connection.sendNotification(AGENT_METHODS.session_cancel, params);
   }
-  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);
+  /**
+   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Starts a NES (Next Edit Suggestions) session.
+   *
+   * @experimental
+   */
+  unstable_startNes(params) {
+    return this.connection.sendRequest(AGENT_METHODS.nes_start, params);
   }
-  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;
+  /**
+   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Sends a NES suggestion request.
+   *
+   * @experimental
+   */
+  unstable_suggestNes(params) {
+    return this.connection.sendRequest(AGENT_METHODS.nes_suggest, params);
   }
-  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");
+  /**
+   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Closes a NES session.
+   *
+   * @experimental
+   */
+  unstable_closeNes(params) {
+    return this.connection.sendRequest(AGENT_METHODS.nes_close, params, emptyObjectResponse);
   }
-  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"));
-    }
+  /**
+   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Notifies the agent that a document was opened.
+   *
+   * @experimental
+   */
+  unstable_didOpenDocument(params) {
+    return this.connection.sendNotification(AGENT_METHODS.document_did_open, params);
   }
-  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);
+  /**
+   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Notifies the agent that a document was changed.
+   *
+   * @experimental
+   */
+  unstable_didChangeDocument(params) {
+    return this.connection.sendNotification(AGENT_METHODS.document_did_change, params);
   }
-  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" }];
+  /**
+   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Notifies the agent that a document was closed.
+   *
+   * @experimental
+   */
+  unstable_didCloseDocument(params) {
+    return this.connection.sendNotification(AGENT_METHODS.document_did_close, params);
   }
-  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"
-      });
-    }
+  /**
+   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Notifies the agent that a document was saved.
+   *
+   * @experimental
+   */
+  unstable_didSaveDocument(params) {
+    return this.connection.sendNotification(AGENT_METHODS.document_did_save, 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"
-      });
-    }
+  /**
+   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Notifies the agent that a document received focus.
+   *
+   * @experimental
+   */
+  unstable_didFocusDocument(params) {
+    return this.connection.sendNotification(AGENT_METHODS.document_did_focus, params);
   }
-  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 };
+  /**
+   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Notifies the agent that a NES suggestion was accepted.
+   *
+   * @experimental
+   */
+  unstable_acceptNes(params) {
+    return this.connection.sendNotification(AGENT_METHODS.nes_accept, params);
   }
-  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);
+  /**
+   * **UNSTABLE**: This capability is not part of the spec yet, and may be removed or changed at any point.
+   *
+   * Notifies the agent that a NES suggestion was rejected.
+   *
+   * @experimental
+   */
+  unstable_rejectNes(params) {
+    return this.connection.sendNotification(AGENT_METHODS.nes_reject, params);
   }
-  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;
+  request(method, params, options) {
+    const spec = agentRequestSpecsByMethod[method];
+    return this.connection.sendRequest(method, params, spec?.mapResponse, options);
   }
-  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();
+  notify(method, params) {
+    return this.connection.sendNotification(method, params);
+  }
+  /**
+   * Extension method.
+   *
+   * @deprecated Use {@link request}.
+   */
+  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;
   }
-}
+};
 
-// ../../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 text2 = shim.replaceAll("\\", "/").toLowerCase();
-  return text2.includes(`%dp0%/${target}"`) || text2.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((text2) => JSON.parse(text2)).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;
-      }
-    }
+// dist/copy-cleanup.js
+import { randomBytes } from "node:crypto";
+import { createInterface } from "node:readline";
+import { stripVTControlCharacters } from "node:util";
+import { Readable } from "node:stream";
+var CodeBuddyCopyCleanup = class {
+  copyId;
+  cwd;
+  password = randomBytes(32).toString("base64url");
+  arguments = [
+    "--acp",
+    "--serve",
+    "--host",
+    "127.0.0.1",
+    "--port",
+    "0",
+    "--auth",
+    "password"
+  ];
+  #endpoint;
+  constructor(copyId, cwd) {
+    this.copyId = copyId;
+    this.cwd = cwd;
   }
-  let directory = path4.dirname(selected);
-  for (let depth = 0; depth < 8; depth++) {
-    const metadata = await readFile(path4.join(directory, "package.json"), "utf8").then((text2) => JSON.parse(text2)).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);
-        }
-      };
+  environment(environment) {
+    return {
+      ...environment,
+      CODEBUDDY_GATEWAY_AUTH: "password",
+      CODEBUDDY_GATEWAY_PASSWORD: this.password,
+      CODEBUDDY_GATEWAY_BASE_PATH: ""
+    };
+  }
+  /** Native --serve banners include its password; never pass them to the ACP parser/logs. */
+  protocolOutput(stdout) {
+    return Readable.from(this.#protocolLines(stdout));
+  }
+  async *#protocolLines(stdout) {
+    for await (const line of createInterface({ input: stdout })) {
+      const endpoint = /^\s*Endpoint\s+(http:\/\/127\.0\.0\.1:\d+)\s*$/u.exec(stripVTControlCharacters(line));
+      if (endpoint)
+        this.#endpoint = endpoint[1];
+      if (line.trimStart().startsWith("{"))
+        yield Buffer.from(`${line}
+`);
     }
-    const parent = path4.dirname(directory);
-    if (parent === directory)
-      break;
-    directory = parent;
   }
-  return null;
-}
+  async remove() {
+    if (!this.#endpoint)
+      throw new CodeBuddyError("nativeFailure", `Native cleanup endpoint was not reported; temporary Session ${this.copyId} remains`);
+    const response = await fetch(`${this.#endpoint}/api/v1/sessions/${encodeURIComponent(this.copyId)}?cwd=${encodeURIComponent(this.cwd)}`, {
+      method: "DELETE",
+      headers: { Authorization: `Bearer ${this.password}`, "x-codebuddy-request": "true" },
+      signal: AbortSignal.timeout(5e3),
+      redirect: "error"
+    }).catch(() => {
+      throw new CodeBuddyError("nativeFailure", `Native cleanup request failed; temporary Session ${this.copyId} remains`);
+    });
+    await response.body?.cancel();
+    if (response.status !== 204)
+      throw new CodeBuddyError("nativeFailure", `Native cleanup failed (${response.status}); temporary Session ${this.copyId} remains`);
+  }
+};
 
 // dist/command.js
 var codeBuddyDiscoverySpec = {
@@ -20922,7 +21012,7 @@ function confirmedConfiguration(response, id, value, profile = CODEBUDDY_RUNTIME
 // dist/derivation.js
 import { randomUUID } from "node:crypto";
 import { execFile as execFile3, spawn as spawn2 } from "node:child_process";
-import { lstat, mkdir, readFile as readFile3, realpath as realpath5, unlink, writeFile } from "node:fs/promises";
+import { lstat, mkdir, readFile as readFile3, realpath as realpath5, unlink, writeFile as writeFile2 } from "node:fs/promises";
 import path6 from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual3 } from "node:util";
 
@@ -21034,16 +21124,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path9, added, removed, oldPosInc, options) {
-    const last = path9.lastComponent;
+  addToPath(path10, added, removed, oldPosInc, options) {
+    const last = path10.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path9.oldPos + oldPosInc,
+        oldPos: path10.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path9.oldPos + oldPosInc,
+        oldPos: path10.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -22424,7 +22514,7 @@ async function bridgeCopyToTarget(sourceCwd, targetCwd, ref, contents, environme
   if (!sameResolvedPath(realTargetDirectory, path6.join(realProjects, codeBuddyProjectSlug(targetCwd, profile))))
     throw new CodeBuddyError("invalidRequest", "Cross-directory history bridge target escaped the native projects root");
   const expected = Buffer.from(contents, "utf8");
-  await writeFile(targetFile, expected, { flag: "wx", mode: 384 });
+  await writeFile2(targetFile, expected, { flag: "wx", mode: 384 });
   const bridge = { file: targetFile, expected };
   try {
     const persisted = await readFile3(targetFile);
@@ -22554,7 +22644,7 @@ async function verifiedChildFile(file2, expected) {
 }
 async function persistChildCopy(file2, expected) {
   try {
-    await writeFile(file2, expected, { flag: "wx", mode: 384 });
+    await writeFile2(file2, expected, { flag: "wx", mode: 384 });
   } catch (error51) {
     if (record2(error51).code !== "EEXIST")
       throw error51;
@@ -22849,6 +22939,345 @@ async function deriveCodeBuddySession(options) {
   }
 }
 
+// dist/session-import.js
+import { createReadStream } from "node:fs";
+import { opendir, readFile as readFile4, stat as stat2 } from "node:fs/promises";
+import path7 from "node:path";
+import { createInterface as createInterface2 } from "node:readline";
+
+// ../../harness-adapter/dist/session-import.js
+import { lstat as lstat2 } 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 lstat2(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
+var SESSION_FILE = /^([A-Za-z0-9][A-Za-z0-9_-]{0,199})\.jsonl$/u;
+var MAX_HISTORY_BYTES = 64e6;
+var MAX_MARKER_BYTES = 64 * 1024;
+function processAlive(pid) {
+  if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error51) {
+    return record2(error51).code === "EPERM";
+  }
+}
+function userText(row) {
+  if (row.type !== "message" || row.role !== "user")
+    return null;
+  const { content } = row;
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.map((part) => record2(part)).filter((part) => typeof part.text === "string").map((part) => String(part.text)).join(" ");
+}
+async function readFacts(file2, signal) {
+  const stream = createReadStream(file2, { encoding: "utf8", signal });
+  const lines = createInterface2({ input: stream, crlfDelay: Infinity });
+  let cwd = null;
+  let customTitle = null;
+  let generatedTitle = null;
+  let firstPrompt = null;
+  let hasUser = false;
+  let updatedAt = null;
+  try {
+    for await (const line of lines) {
+      signal.throwIfAborted();
+      if (!line.trim())
+        continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        return null;
+      }
+      const row = record2(parsed);
+      if (typeof row.cwd === "string" && path7.isAbsolute(row.cwd))
+        cwd ??= row.cwd;
+      if (typeof row.timestamp === "number" && Number.isFinite(row.timestamp))
+        updatedAt = row.timestamp;
+      if (row.type === "custom-title")
+        customTitle = sessionImportTitle(row.customTitle);
+      else if (row.type === "ai-title")
+        generatedTitle = sessionImportTitle(row.aiTitle);
+      else {
+        const text2 = userText(row);
+        if (text2 !== null) {
+          hasUser = true;
+          firstPrompt ??= sessionImportTitle(text2);
+        }
+      }
+    }
+  } finally {
+    lines.close();
+    stream.destroy();
+  }
+  if (!hasUser || !cwd)
+    return null;
+  return { cwd, title: customTitle ?? generatedTitle ?? firstPrompt, updatedAt };
+}
+var CodeBuddySessionImport = class {
+  #environment;
+  #profile;
+  #scope;
+  constructor(environment, profile = CODEBUDDY_RUNTIME_PROFILE) {
+    this.#environment = { ...environment };
+    this.#profile = profile;
+    this.#scope = new SessionImportScope({
+      closedMessage: `${profile.displayName} Session import is closed`,
+      unavailableMessage: `${profile.displayName} sessions could not be read; close native clients, check storage access and retry`,
+      notFoundMessage: `${profile.displayName} Session is no longer importable`
+    });
+  }
+  listCandidates() {
+    return this.#scope.read(async (signal) => {
+      const active = await this.#activeSessions(signal);
+      const candidates = [];
+      for (const [nativeSessionId, files] of await this.#sessionFiles(signal)) {
+        if (files.length !== 1 || !files[0])
+          continue;
+        try {
+          const source = await this.#source(nativeSessionId, files[0], active, 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) => {
+      const files = (await this.#sessionFiles(signal)).get(nativeSessionId);
+      if (files?.length !== 1 || !files[0])
+        return null;
+      return this.#source(nativeSessionId, files[0], await this.#activeSessions(signal), signal);
+    });
+  }
+  close() {
+    return this.#scope.close();
+  }
+  #root() {
+    return codeBuddyConfigRoot(this.#environment, this.#profile);
+  }
+  /** IDs a live native process registered in `<config>/sessions/<pid>.json`. */
+  async #activeSessions(signal) {
+    const active = /* @__PURE__ */ new Set();
+    const directory = path7.join(this.#root(), "sessions");
+    const markers = await opendir(directory).catch((error51) => {
+      if (isMissingFileError(error51) || record2(error51).code === "ENOTDIR")
+        return null;
+      throw error51;
+    });
+    if (!markers)
+      return active;
+    for await (const marker of markers) {
+      signal.throwIfAborted();
+      if (!marker.isFile() || !marker.name.endsWith(".json"))
+        continue;
+      try {
+        const file2 = path7.join(directory, marker.name);
+        if ((await stat2(file2)).size > MAX_MARKER_BYTES)
+          continue;
+        const entry = record2(JSON.parse(await readFile4(file2, { encoding: "utf8", signal })));
+        if (typeof entry.sessionId === "string" && processAlive(entry.pid))
+          active.add(entry.sessionId);
+      } catch (error51) {
+        signal.throwIfAborted();
+        if (isStorageAccessError(error51))
+          throw error51;
+      }
+    }
+    return active;
+  }
+  /** Session ID to every project file claiming it. Enumerated links are not followed. */
+  async #sessionFiles(signal) {
+    const root = path7.join(this.#root(), "projects");
+    const found = /* @__PURE__ */ new Map();
+    const info = await optionalLstat(root);
+    if (!info)
+      return found;
+    if (!info.isDirectory())
+      throw new Error(`${this.#profile.displayName} Session store is not a directory`);
+    for await (const project of await opendir(root)) {
+      signal.throwIfAborted();
+      if (!project.isDirectory())
+        continue;
+      const projectDirectory = path7.join(root, project.name);
+      const entries = await opendir(projectDirectory).catch((error51) => {
+        if (isMissingFileError(error51))
+          return null;
+        throw error51;
+      });
+      if (!entries)
+        continue;
+      for await (const entry of entries) {
+        signal.throwIfAborted();
+        const nativeSessionId = entry.isFile() ? SESSION_FILE.exec(entry.name)?.[1] : void 0;
+        if (!nativeSessionId)
+          continue;
+        const files = found.get(nativeSessionId) ?? [];
+        files.push(path7.join(projectDirectory, entry.name));
+        found.set(nativeSessionId, files);
+      }
+    }
+    return found;
+  }
+  async #source(nativeSessionId, file2, active, signal) {
+    signal.throwIfAborted();
+    return readStableFiles([file2], async ([info]) => {
+      if (!info?.isFile() || info.size === 0 || info.size > MAX_HISTORY_BYTES)
+        return null;
+      try {
+        const facts = await readFacts(file2, signal);
+        if (!facts)
+          return null;
+        const cwd = path7.resolve(facts.cwd);
+        if (!(await stat2(cwd)).isDirectory())
+          return null;
+        const nativeRef = nativeSessionRefSchema.parse({
+          harnessId: this.#profile.harnessId,
+          nativeSessionId,
+          formatVersion: 1
+        });
+        signal.throwIfAborted();
+        const history = await codeBuddyNativeHistory(cwd, nativeRef, this.#environment, this.#profile);
+        if (path7.resolve(history.file) !== path7.resolve(file2))
+          return null;
+        const candidate = sessionImportCandidate({
+          nativeSessionId,
+          cwd,
+          title: facts.title,
+          updatedAt: facts.updatedAt ?? info.mtimeMs,
+          // A registered live process holds the Session. Absence is not proof of idleness.
+          running: active.has(nativeSessionId) ? true : null
+        });
+        return candidate ? { candidate, nativeRef } : null;
+      } catch (error51) {
+        signal.throwIfAborted();
+        if (isStorageAccessError(error51))
+          throw error51;
+        return null;
+      }
+    });
+  }
+};
+
 // dist/interactions.js
 var CodeBuddyInteractions = class {
   emit;
@@ -22992,7 +23421,7 @@ var CodeBuddyInteractions = class {
 
 // dist/subagent-history.js
 import { readdir as readdir2, realpath as realpath6 } from "node:fs/promises";
-import path7 from "node:path";
+import path8 from "node:path";
 var equalPath2 = (a, b) => process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
 var MAX_CACHED_CHILDREN = 16;
 var CodeBuddyChildObserver = class {
@@ -23056,8 +23485,8 @@ var CodeBuddyChildObserver = class {
   }
   async #directory() {
     const history = await this.#parentHistory();
-    const project = path7.dirname(await realpath6(history.file));
-    const expected = path7.join(project, this.parent.nativeSessionId, "subagents");
+    const project = path8.dirname(await realpath6(history.file));
+    const expected = path8.join(project, this.parent.nativeSessionId, "subagents");
     const actual = await realpath6(expected);
     this.#assertOpen();
     if (!equalPath2(actual, expected))
@@ -23067,7 +23496,7 @@ var CodeBuddyChildObserver = class {
   async #child(directory, childId) {
     if (!validCodeBuddyChildId(childId))
       throw new CodeBuddyError("invalidRequest", "Invalid native Subagent ID");
-    const file2 = path7.join(directory, `${childId}.jsonl`);
+    const file2 = path8.join(directory, `${childId}.jsonl`);
     const before = await codeBuddyFileVersion(file2);
     if (!equalPath2(before.realFile, file2))
       throw new CodeBuddyError("invalidRequest", "Redirected Subagent transcript");
@@ -23779,6 +24208,7 @@ var CodeBuddyAdapter = class {
   harnessId;
   commandCatalog;
   liveCommandCatalog = true;
+  sessionImport;
   subagents = {
     readSnapshot: async ({ parent, nativeSubagentId, cwd }) => {
       try {
@@ -23812,6 +24242,7 @@ var CodeBuddyAdapter = class {
         this.commandCatalog = commandCatalog2;
     }
     this.#environment = { ...options.environment ?? process.env };
+    this.sessionImport = new CodeBuddySessionImport(this.#environment, this.#profile);
     this.#invocation = options.invocationFactory ?? codeBuddyInvocation;
     this.#factory = options.clientFactory ?? ((clientOptions) => new CodeBuddyAcpClient(clientOptions, void 0, this.#invocation));
   }
@@ -23831,7 +24262,7 @@ var CodeBuddyAdapter = class {
     try {
       if (this.#closed)
         throw new CodeBuddyError("invalidState", "Adapter is closed");
-      if (!(await stat2(cwd)).isDirectory())
+      if (!(await stat3(cwd)).isDirectory())
         throw new CodeBuddyError("invalidRequest", "Working directory is not a directory");
       client2 = this.#factory({
         cwd,
@@ -23877,7 +24308,7 @@ var CodeBuddyAdapter = class {
       return failure("invalidRequest", "Unattended execution requires native fullAccess permissions", this.#profile);
     let session;
     try {
-      if (!(await stat2(input.cwd)).isDirectory())
+      if (!(await stat3(input.cwd)).isDirectory())
         throw new CodeBuddyError("invalidRequest", "Working directory is not a directory");
       if (this.#closed)
         throw new CodeBuddyError("invalidState", "Adapter closed while opening Session");
@@ -23940,7 +24371,7 @@ var CodeBuddyAdapter = class {
   async close() {
     this.#closed = true;
     this.#abort.abort();
-    await Promise.allSettled([...this.#derivations]);
+    await Promise.allSettled([this.sessionImport.close(), ...this.#derivations]);
     const results = await Promise.allSettled([...this.#sessions, ...this.#inspections].map((resource) => resource.close()));
     this.#sessions.clear();
     this.#inspections.clear();
@@ -23970,6 +24401,7 @@ function createCodeBuddyInstallation(environment) {
         updateAvailable: !!npm && newerInstallationVersion(currentVersion, latestVersion),
         canUpdate,
         ...!canUpdate ? {
+          messageCode: "codebuddy-npm-required",
           message: "Use CodeBuddy's native updater or original package manager for this installation. Latest-version checks here require an identified npm installation."
         } : {}
       };
@@ -23984,7 +24416,7 @@ function createCodeBuddyInstallation(environment) {
 
 // ../../harness-broker/dist/client.js
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { lstat as lstat2, readFile as readFile4 } from "node:fs/promises";
+import { lstat as lstat3, readFile as readFile5 } from "node:fs/promises";
 import net, {} from "node:net";
 
 // ../../harness-broker/dist/protocol.js
@@ -24099,18 +24531,18 @@ function consumeBrokerFrames(socket, onFrame, onError) {
 
 // ../../harness-broker/dist/paths.js
 import os2 from "node:os";
-import path8 from "node:path";
+import path9 from "node:path";
 var HARNESS_BROKER_DESCRIPTOR_ENV = "CODEXHOST_CLAUDE_BROKER_DESCRIPTOR";
 var HARNESS_BROKER_DESCRIPTOR_FILE = "claude-code-broker-v1.json";
 function defaultHarnessBrokerDirectory(environment = process.env) {
   const home = environment.HOME || os2.homedir();
-  return path8.join(home, ".codexhost", "harness-broker");
+  return path9.join(home, ".codexhost", "harness-broker");
 }
 function defaultHarnessBrokerDescriptorPath(environment = process.env, harnessId = "claude-code") {
   harnessPluginIdSchema.parse(harnessId);
   if (harnessId !== "claude-code")
-    return path8.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.json`);
-  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path8.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
+    return path9.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.json`);
+  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path9.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
 }
 
 // ../../harness-broker/dist/validation.js
@@ -24389,7 +24821,7 @@ function parseSessionMetadata(value) {
   };
 }
 async function readDescriptor(descriptorPath) {
-  const metadata = await lstat2(descriptorPath);
+  const metadata = await lstat3(descriptorPath);
   if (metadata.isSymbolicLink())
     throw new Error("Aqua Harness broker descriptor must not be a symlink");
   if (!metadata.isFile())
@@ -24401,12 +24833,12 @@ async function readDescriptor(descriptorPath) {
       throw new Error("Aqua Harness broker descriptor belongs to another user");
     }
   }
-  const descriptor = harnessBrokerDescriptorSchema.parse(JSON.parse(await readFile4(descriptorPath, "utf8")));
+  const descriptor = harnessBrokerDescriptorSchema.parse(JSON.parse(await readFile5(descriptorPath, "utf8")));
   if (process.platform === "darwin" && Buffer.byteLength(descriptor.socketPath) > 103) {
     throw new Error("Aqua Harness broker socket path is too long for macOS");
   }
   if (process.platform !== "win32") {
-    const socket = await lstat2(descriptor.socketPath);
+    const socket = await lstat3(descriptor.socketPath);
     if (socket.isSymbolicLink() || !socket.isSocket()) {
       throw new Error("Aqua Harness broker endpoint is not a Unix socket");
     }
@@ -24909,7 +25341,8 @@ function createHarnessAdapter(context) {
     });
   const environment = { ...context.environment };
   return Object.assign(new CodeBuddyAdapter({ environment }), {
-    installation: createCodeBuddyInstallation(environment)
+    installation: createCodeBuddyInstallation(environment),
+    install: createHarnessInstaller(environment, { npm: "@tencent-ai/codebuddy-code" })
   });
 }
 export {