@codexhost/cli-linux-arm64 0.10.2 → 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, path8) {
-  if (!path8)
+function getElementAtPath(obj, path10) {
+  if (!path10)
     return obj;
-  return path8.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(path8, issues) {
+function prefixIssues(path10, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path8);
+    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, path8 = []) => {
+  const processError = (error52, path10 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path8, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path10, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else {
-        const fullpath = [...path8, ...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, path8 = []) => {
+  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 }, [...path8, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path10, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else {
-        const fullpath = [...path8, ...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 path8 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path8) {
+  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 path8 = ref.slice(1).split("/").filter(Boolean);
-  if (path8.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 (path8[0] === defsKey) {
-    const key = path8[1];
+  if (path10[0] === defsKey) {
+    const key = path10[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14574,6 +15056,56 @@ var credentialImportsParamsSchema = external_exports.object({
   request: credentialImportsRequestSchema
 }).strict();
 
+// ../../shared-contracts/dist/harness-display-settings.js
+var harnessDisplayEntriesSchema = external_exports.array(external_exports.strictObject({
+  agent: external_exports.string().min(1).max(128),
+  section: external_exports.enum(["main", "more", "auto"])
+})).max(256).refine((entries) => new Set(entries.map((entry) => entry.agent)).size === entries.length, "Duplicate Harness IDs");
+var harnessDisplaySettingsSchema = external_exports.strictObject({
+  entries: harnessDisplayEntriesSchema.nullable()
+});
+var harnessDisplayGetSchema = external_exports.strictObject({});
+var harnessDisplaySetSchema = external_exports.strictObject({
+  entries: harnessDisplayEntriesSchema,
+  /** Import legacy Desktop preferences only if no shared settings exist yet. */
+  initializeOnly: external_exports.boolean().optional()
+});
+
+// ../../shared-contracts/dist/console.js
+var consoleAnnouncementSchema = external_exports.strictObject({
+  title: external_exports.string().trim().min(1).max(200),
+  type: external_exports.enum(["info", "warning", "danger"]),
+  body: external_exports.string().trim().min(1).max(16 * 1024)
+});
+var consoleOpenParamsSchema = external_exports.strictObject({});
+var consoleOpenResultSchema = external_exports.strictObject({
+  /** The console address. */
+  url: external_exports.string().max(2048).regex(/^http:\/\/(?:127\.0\.0\.1|localhost):\d{1,5}\/(?:\?.*)?$/u)
+});
+var CONSOLE_HOST_METHODS = Object.freeze([
+  "codexhost/harness/plugins/list",
+  "codexhost/harness/display-settings/get",
+  "codexhost/harness/display-settings/set",
+  "codexhost/harness/inspect",
+  "codexhost/harness/installation",
+  "codexhost/harness/launch-settings/get",
+  "codexhost/harness/launch-settings/set",
+  "codexhost/harness/web-ui/open",
+  "codexhost/harness/accounts/sources",
+  "codexhost/harness/accounts/list",
+  "codexhost/harness/accounts/inspect",
+  "codexhost/harness/credential-imports",
+  "codexhost/harness/session-import/sources",
+  "codexhost/harness/session-import/list",
+  "codexhost/harness/session-import/import",
+  "codexhost/account/list",
+  "codexhost/account/refresh",
+  "codexhost/account/usage/inspect",
+  "codexhost/update/check",
+  "codexhost/update/start",
+  "codexhost/update/status"
+]);
+
 // ../../shared-contracts/dist/version.js
 var WORKSPACE_CONTRACT_VERSION = 1;
 
@@ -14627,6 +15159,12 @@ var hostTurnIdSchema = opaqueIdSchema.brand();
 var hostItemIdSchema = opaqueIdSchema.brand();
 var hostInteractionIdSchema = opaqueIdSchema.brand();
 
+// ../../shared-contracts/dist/manual-compaction.js
+var threadManualCompactionStartedSchema = external_exports.strictObject({
+  threadId: hostThreadIdSchema,
+  turnId: hostTurnIdSchema
+});
+
 // ../../shared-contracts/dist/thread-usage.js
 var nonNegativeSafeIntegerSchema = external_exports.number().int().safe().nonnegative();
 var finiteNonNegativeNumberSchema = external_exports.number().finite().nonnegative();
@@ -14687,6 +15225,10 @@ var threadUsageSnapshotSchema = external_exports.object({
 var usagePercentSchema = external_exports.number().finite().min(0).max(100);
 var accountCreditsProductUsageSchema = external_exports.object({
   product: external_exports.string().min(1),
+  used: external_exports.number().finite().nonnegative().optional(),
+  // Zero is a real empty cap, not an absent field.
+  limit: external_exports.number().finite().nonnegative().optional(),
+  unit: external_exports.string().min(1).max(32).optional(),
   usagePercent: usagePercentSchema,
   resetsAt: external_exports.string().min(1).optional()
 }).strict();
@@ -14696,6 +15238,10 @@ var accountResetCreditsSchema = external_exports.object({
   expiresAt: external_exports.array(external_exports.string().min(1)).min(1).max(32).optional()
 }).strict();
 var accountCreditsSnapshotSchema = external_exports.object({
+  used: external_exports.number().finite().nonnegative().optional(),
+  // Zero is a real empty cap, not an absent field.
+  limit: external_exports.number().finite().nonnegative().optional(),
+  unit: external_exports.string().min(1).max(32).optional(),
   /** Native label when the primary limit is scoped to a model or product group. */
   label: external_exports.string().min(1).optional(),
   usedPercent: usagePercentSchema,
@@ -14715,12 +15261,27 @@ var threadUsageInspectionSchema = external_exports.object({
 }).strict();
 
 // ../../shared-contracts/dist/harness-accounts.js
-var harnessAccountSnapshotSchema = external_exports.object({
+var accountBalanceSnapshotSchema = external_exports.object({
+  amount: external_exports.number().finite().nonnegative(),
+  /** ISO 4217 code as reported by the Provider, for example `CNY`. */
+  currency: external_exports.string().trim().min(1).max(8),
+  /** Native label when the Harness exposes several Billing Sources. */
+  label: external_exports.string().trim().min(1).max(128).optional()
+}).strict();
+var harnessAccountSnapshotObject = external_exports.object({
   email: external_exports.string().trim().min(1).max(320).optional(),
   label: external_exports.string().trim().min(1).max(256).optional(),
   plan: external_exports.string().trim().min(1).max(128).optional(),
-  credits: accountCreditsSnapshotSchema
+  credits: accountCreditsSnapshotSchema.optional(),
+  balance: accountBalanceSnapshotSchema.optional()
 }).strict();
+function requireReportedQuota(schema) {
+  return schema.refine((value) => {
+    const reported = value;
+    return reported.credits !== void 0 || reported.balance !== void 0;
+  }, { message: "Account must report either credits or a balance" });
+}
+var harnessAccountSnapshotSchema = requireReportedQuota(harnessAccountSnapshotObject);
 var harnessAccountIdentityShape = {
   harnessId: harnessIdSchema,
   harnessName: external_exports.string().trim().min(1).max(128)
@@ -14731,11 +15292,13 @@ var harnessAccountSourceListResultSchema = external_exports.object({ sources: ex
 var harnessAccountInspectParamsSchema = external_exports.object({ harnessId: harnessIdSchema, refresh: external_exports.boolean().optional() }).strict();
 var harnessAccountInspectResultSchema = external_exports.object({
   ...harnessAccountIdentityShape,
-  account: harnessAccountSnapshotSchema.nullable()
+  account: harnessAccountSnapshotSchema.nullable(),
+  /** Every Billing Source from one Harness; `account` remains the first for older clients. */
+  accounts: external_exports.array(harnessAccountSnapshotSchema).max(8).optional()
 }).strict();
 var harnessAccountListParamsSchema = external_exports.object({ refresh: external_exports.boolean().optional() }).strict();
 var harnessAccountListResultSchema = external_exports.object({
-  accounts: external_exports.array(harnessAccountSnapshotSchema.extend(harnessAccountIdentityShape)).max(128)
+  accounts: external_exports.array(requireReportedQuota(harnessAccountSnapshotObject.extend(harnessAccountIdentityShape))).max(128)
 }).strict();
 
 // ../../shared-contracts/dist/json-value.js
@@ -14873,6 +15436,8 @@ var harnessModelSchema = external_exports.object({
   ref: harnessModelRefSchema,
   label: nonBlankTextSchema2.max(HARNESS_MODEL_LABEL_MAX_LENGTH),
   resolvedModelLabel: harnessResolvedModelLabelSchema.optional(),
+  /** Optional opaque selection for this same Model with priority processing enabled. */
+  fastModel: harnessModelRefSchema.optional(),
   supportedThinkingOptionIds: external_exports.array(harnessThinkingOptionIdSchema).optional()
 }).strict();
 var harnessThinkingOptionsSchema = external_exports.array(harnessThinkingOptionSchema).superRefine((options, context) => {
@@ -14905,6 +15470,16 @@ var harnessModelCatalogSchema = external_exports.object({
       });
     }
     refs.add(model.ref.id);
+    if (model.fastModel) {
+      if (refs.has(model.fastModel.id) || catalog.models.some((entry) => entry.ref.id === model.fastModel?.id)) {
+        context.addIssue({
+          code: "custom",
+          message: "Fast Model refs must be distinct and unique",
+          path: ["models", index, "fastModel"]
+        });
+      }
+      refs.add(model.fastModel.id);
+    }
     const supportedThinkingIds = /* @__PURE__ */ new Set();
     for (const [optionIndex, optionId] of (model.supportedThinkingOptionIds ?? []).entries()) {
       if (supportedThinkingIds.has(optionId)) {
@@ -15024,11 +15599,13 @@ var threadThinkingSelectParamsSchema = external_exports.object({
   thinkingOptionId: harnessThinkingOptionIdSchema
 }).strict();
 var threadInspectionParamsSchema = external_exports.object({
-  threadId: hostThreadIdSchema
+  threadId: hostThreadIdSchema,
+  includeReferenceCapability: external_exports.boolean().optional()
 }).strict();
 var codexThreadInspectionSchema = external_exports.object({
   owner: external_exports.literal("codex"),
-  locked: external_exports.literal(true)
+  locked: external_exports.literal(true),
+  supportsThreadReferences: external_exports.literal(true).optional()
 }).strict();
 var externalThreadInspectionSchema = external_exports.object({
   owner: external_exports.literal("external"),
@@ -15154,6 +15731,22 @@ var harnessLaunchSettingsSchema = external_exports.object({
   restartRequired: external_exports.boolean()
 }).strict();
 
+// ../../shared-contracts/dist/harness-installation.js
+var harnessInstallationParamsSchema = external_exports.object({
+  harnessId: harnessIdSchema,
+  action: external_exports.enum(["check", "update", "install"])
+}).strict();
+var harnessInstallationStateSchema = external_exports.object({
+  currentVersion: external_exports.string().min(1).max(128),
+  latestVersion: external_exports.string().min(1).max(128),
+  updateAvailable: external_exports.boolean(),
+  canUpdate: external_exports.boolean(),
+  // Adapter-owned diagnostic text; UI uses messageCode rather than displaying it verbatim.
+  message: external_exports.string().max(2048).optional(),
+  messageCode: external_exports.string().min(1).max(128).optional(),
+  latestVersionKind: external_exports.enum(["unknown", "tracking-branch"]).optional()
+}).strict();
+
 // ../../shared-contracts/dist/codex-accounts.js
 var accountIdSchema = external_exports.string().min(1).max(256).regex(/^[A-Za-z0-9._~-]+$/u);
 var nonBlankTextSchema3 = external_exports.string().trim().min(1);
@@ -15453,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);
 
@@ -15873,10 +16498,10 @@ 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, spawn } from "node:child_process";
+import { execFile as execFile2, spawn } from "node:child_process";
 import { Readable as Readable2, Writable } from "node:stream";
 
 // ../../../node_modules/@agentclientprotocol/sdk/dist/schema/index.js
@@ -19920,426 +20545,187 @@ var ClientSideConnection = class {
    *
    * Notifies the agent that a document was closed.
    *
-   * @experimental
-   */
-  unstable_didCloseDocument(params) {
-    return this.connection.sendNotification(AGENT_METHODS.document_did_close, 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.
-   *
-   * @experimental
-   */
-  unstable_didSaveDocument(params) {
-    return this.connection.sendNotification(AGENT_METHODS.document_did_save, 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 received focus.
-   *
-   * @experimental
-   */
-  unstable_didFocusDocument(params) {
-    return this.connection.sendNotification(AGENT_METHODS.document_did_focus, 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 NES suggestion was accepted.
-   *
-   * @experimental
-   */
-  unstable_acceptNes(params) {
-    return this.connection.sendNotification(AGENT_METHODS.nes_accept, 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 NES suggestion was rejected.
-   *
-   * @experimental
-   */
-  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);
-  }
-  /**
-   * 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;
-  }
-};
-
-// 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`);
+   * @experimental
+   */
+  unstable_didCloseDocument(params) {
+    return this.connection.sendNotification(AGENT_METHODS.document_did_close, params);
   }
-};
-
-// ../../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.
+   *
+   * Notifies the agent that a document was saved.
+   *
+   * @experimental
+   */
+  unstable_didSaveDocument(params) {
+    return this.connection.sendNotification(AGENT_METHODS.document_did_save, params);
   }
-  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;
+  /**
+   * **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);
   }
-}
-function subdirectoryNames(directory) {
-  try {
-    return fs.readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-  } catch {
-    return [];
+  /**
+   * **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);
   }
-}
-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 };
+  /**
+   * **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 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);
+  request(method, params, options) {
+    const spec = agentRequestSpecsByMethod[method];
+    return this.connection.sendRequest(method, params, spec?.mapResponse, options);
   }
-  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;
+  notify(method, params) {
+    return this.connection.sendNotification(method, 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");
+  /**
+   * Extension method.
+   *
+   * @deprecated Use {@link request}.
+   */
+  extMethod(method, params) {
+    return this.request(method, params);
   }
-  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"));
-    }
+  /**
+   * Extension notification.
+   *
+   * @deprecated Use {@link notify}.
+   */
+  extNotification(method, params) {
+    return this.notify(method, 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);
+  /**
+   * AbortSignal that aborts when the connection closes.
+   *
+   * This signal can be used to:
+   * - Listen for connection closure: `connection.signal.addEventListener('abort', () => {...})`
+   * - Check connection status synchronously: `if (connection.signal.aborted) {...}`
+   * - Pass to other APIs (fetch, setTimeout) for automatic cancellation
+   *
+   * The connection closes when the underlying stream ends, either normally or due to an error.
+   *
+   * @example
+   * ```typescript
+   * const connection = new ClientSideConnection(client, stream);
+   *
+   * // Listen for closure
+   * connection.signal.addEventListener('abort', () => {
+   *   console.log('Connection closed - performing cleanup');
+   * });
+   *
+   * // Check status
+   * if (connection.signal.aborted) {
+   *   console.log('Connection is already closed');
+   * }
+   *
+   * // Pass to other APIs
+   * fetch(url, { signal: connection.signal });
+   * ```
+   */
+  get signal() {
+    return this.connection.signal;
   }
-  return 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" }];
+  /**
+   * 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;
   }
-  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"
-      });
-    }
+};
+
+// 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;
   }
-  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"
-      });
+  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}
+`);
     }
   }
-  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 };
+  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`);
   }
-  return void 0;
-}
+};
 
 // dist/command.js
 var codeBuddyDiscoverySpec = {
@@ -20533,7 +20919,7 @@ var CodeBuddyAcpClient = class {
     }
     const pid = this.#child.pid;
     if (pid && process.platform === "win32") {
-      await new Promise((resolve) => execFile("taskkill", ["/PID", String(pid), "/T", "/F"], { windowsHide: true, timeout: 3e3 }, () => resolve()));
+      await new Promise((resolve) => execFile2("taskkill", ["/PID", String(pid), "/T", "/F"], { windowsHide: true, timeout: 3e3 }, () => resolve()));
     } else if (pid) {
       try {
         process.kill(-pid, "SIGKILL");
@@ -20625,17 +21011,17 @@ function confirmedConfiguration(response, id, value, profile = CODEBUDDY_RUNTIME
 
 // dist/derivation.js
 import { randomUUID } from "node:crypto";
-import { execFile as execFile2, spawn as spawn2 } from "node:child_process";
-import { lstat, mkdir, readFile as readFile2, realpath as realpath4, unlink, writeFile } from "node:fs/promises";
-import path5 from "node:path";
+import { execFile as execFile3, spawn as spawn2 } from "node:child_process";
+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";
 
 // dist/history.js
 import { createHash } from "node:crypto";
 import { realpathSync } from "node:fs";
-import { access, readdir, realpath as realpath2 } from "node:fs/promises";
-import { homedir } from "node:os";
-import path4 from "node:path";
+import { access, readdir, realpath as realpath3 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import path5 from "node:path";
 import { isDeepStrictEqual } from "node:util";
 
 // ../../../node_modules/diff/libesm/diff/base.js
@@ -20738,16 +21124,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path8, added, removed, oldPosInc, options) {
-    const last = path8.lastComponent;
+  addToPath(path10, added, removed, oldPosInc, options) {
+    const last = path10.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path8.oldPos + oldPosInc,
+        oldPos: path10.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path8.oldPos + oldPosInc,
+        oldPos: path10.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -21299,9 +21685,9 @@ function codeBuddyDelegation(callId, input, status, childId, displayName = "Code
 }
 
 // dist/file-observation.js
-import { readFile, realpath, stat } from "node:fs/promises";
+import { readFile as readFile2, realpath as realpath2, stat } from "node:fs/promises";
 async function codeBuddyFileVersion(file2) {
-  const [realFile, value] = await Promise.all([realpath(file2), stat(file2, { bigint: true })]);
+  const [realFile, value] = await Promise.all([realpath2(file2), stat(file2, { bigint: true })]);
   return {
     realFile,
     fingerprint: `${value.dev}:${value.ino}:${value.size}:${value.mtimeNs}:${value.ctimeNs}`,
@@ -21315,7 +21701,7 @@ async function readCodeBuddyVersionedText(file2, maximumBytes, tooLargeMessage,
   const observedBefore = before ?? await codeBuddyFileVersion(file2);
   if (observedBefore.size > maximumBytes)
     throw new CodeBuddyError("unsupported", tooLargeMessage);
-  const contents = await readFile(file2, "utf8"), after = await codeBuddyFileVersion(file2), bytesRead = Buffer.byteLength(contents), reusableVersion = sameCodeBuddyFileVersion(observedBefore, after) && bytesRead === after.size ? after : void 0;
+  const contents = await readFile2(file2, "utf8"), after = await codeBuddyFileVersion(file2), bytesRead = Buffer.byteLength(contents), reusableVersion = sameCodeBuddyFileVersion(observedBefore, after) && bytesRead === after.size ? after : void 0;
   if (bytesRead > maximumBytes || after.size > maximumBytes)
     throw new CodeBuddyError("unsupported", tooLargeMessage);
   return { contents, reusableVersion };
@@ -21332,15 +21718,15 @@ function codeBuddyCanonicalCwd(cwd) {
   try {
     return realpathSync.native(cwd);
   } catch {
-    return path4.resolve(cwd);
+    return path5.resolve(cwd);
   }
 }
 function codeBuddyConfigRoot(environment, profile) {
   const configuredRoot = profile.configDirectoryEnvironmentVariables.map((name) => environment[name]).find((value) => typeof value === "string" && value.trim().length > 0);
-  return configuredRoot || path4.join(environment.HOME || environment.USERPROFILE || homedir(), profile.defaultConfigDirectoryName);
+  return configuredRoot || path5.join(environment.HOME || environment.USERPROFILE || homedir2(), profile.defaultConfigDirectoryName);
 }
 function codeBuddyPrimaryHistoryPath(cwd, ref, environment, profile = CODEBUDDY_RUNTIME_PROFILE) {
-  return path4.join(codeBuddyConfigRoot(environment, profile), "projects", codeBuddyProjectSlug(cwd, profile), `${ref.nativeSessionId}.jsonl`);
+  return path5.join(codeBuddyConfigRoot(environment, profile), "projects", codeBuddyProjectSlug(cwd, profile), `${ref.nativeSessionId}.jsonl`);
 }
 function derivedLocator(ref) {
   const locator = record2(ref.locator);
@@ -21374,8 +21760,8 @@ function validateNativeRef(ref, profile = CODEBUDDY_RUNTIME_PROFILE) {
   }
 }
 async function sameCwd(left, right) {
-  const b = await realpath2(right);
-  const a = await realpath2(left).catch((error51) => {
+  const b = await realpath3(right);
+  const a = await realpath3(left).catch((error51) => {
     if (["ENOENT", "ENOTDIR"].includes(String(record2(error51).code)))
       throw new CodeBuddyError("invalidRequest", "Native Session historical working directory is unavailable; ownership cannot be verified");
     throw error51;
@@ -21383,9 +21769,9 @@ async function sameCwd(left, right) {
   return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
 }
 async function matchesAnyHistoricalCwd(value, candidates) {
-  const resolved = path4.resolve(value);
+  const resolved = path5.resolve(value);
   for (const candidate of candidates) {
-    const other = path4.resolve(candidate);
+    const other = path5.resolve(candidate);
     if (process.platform === "win32" ? resolved.toLowerCase() === other.toLowerCase() : resolved === other)
       return true;
     try {
@@ -21409,9 +21795,9 @@ async function codeBuddyLiveNativeHistory(cwd, ref, environment, profile = CODEB
 async function codeBuddyHistory(cwd, ref, environment, tolerateIncompleteTail, profile, transaction) {
   validateNativeRef(ref, profile);
   const configRoot = codeBuddyConfigRoot(environment, profile);
-  const root = path4.join(configRoot, "projects");
+  const root = path5.join(configRoot, "projects");
   const slug = codeBuddyProjectSlug(cwd, profile);
-  const primary = path4.join(root, slug, `${ref.nativeSessionId}.jsonl`);
+  const primary = path5.join(root, slug, `${ref.nativeSessionId}.jsonl`);
   const provenance = derivedLocator(ref);
   let candidates = [];
   try {
@@ -21430,7 +21816,7 @@ async function codeBuddyHistory(cwd, ref, environment, tolerateIncompleteTail, p
     for (const directory of directories) {
       if (!directory.isDirectory())
         continue;
-      const file3 = path4.join(root, directory.name, `${ref.nativeSessionId}.jsonl`);
+      const file3 = path5.join(root, directory.name, `${ref.nativeSessionId}.jsonl`);
       try {
         await access(file3);
         candidates.push(file3);
@@ -21445,7 +21831,7 @@ async function codeBuddyHistory(cwd, ref, environment, tolerateIncompleteTail, p
   const file2 = candidates[0];
   if (!file2)
     throw new CodeBuddyError("sessionNotFound", "Native Session history was not found");
-  if (profile.historyCapabilities?.fork && !transaction && path4.resolve(file2) !== path4.resolve(primary))
+  if (profile.historyCapabilities?.fork && !transaction && path5.resolve(file2) !== path5.resolve(primary))
     throw new CodeBuddyError("invalidRequest", "Native Session is not stored in the requested working directory");
   const source = await readCodeBuddyVersionedText(file2, 64e6, "Native history exceeds the supported 64 MB snapshot size"), parsed = parseJsonl(source.contents, tolerateIncompleteTail);
   const checkedDirectories = /* @__PURE__ */ new Set();
@@ -21474,7 +21860,7 @@ async function codeBuddyHistory(cwd, ref, environment, tolerateIncompleteTail, p
       }
     }
   } else if (provenance) {
-    if (!await sameCwd(provenance.boundCwd, cwd) || provenance.targetProjectSlug !== slug || path4.resolve(file2) !== path4.resolve(primary))
+    if (!await sameCwd(provenance.boundCwd, cwd) || provenance.targetProjectSlug !== slug || path5.resolve(file2) !== path5.resolve(primary))
       throw new CodeBuddyError("invalidRequest", "Derived Native Session target binding changed");
     const active = nativeHistoryRows(parsed.contents);
     if (provenance.inheritedPrefixRows > active.length || nativeRowsDigest(active.slice(0, provenance.inheritedPrefixRows)) !== provenance.inheritedPrefixSha256)
@@ -21768,7 +22154,7 @@ function historyUsage(contents) {
 
 // dist/child-provenance.js
 import { createHash as createHash2 } from "node:crypto";
-import { realpath as realpath3 } from "node:fs/promises";
+import { realpath as realpath4 } from "node:fs/promises";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
 var CODEBUDDY_CHILD_MAX_BYTES = 8e6;
 var equalPath = (left, right) => process.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right;
@@ -21836,7 +22222,7 @@ function codeBuddyInheritedChild(parent, childId) {
 async function canonicalCwds(cwds) {
   const result = /* @__PURE__ */ new Map();
   for (const cwd of new Set(cwds)) {
-    const canonical = await realpath3(cwd).catch((error51) => {
+    const canonical = await realpath4(cwd).catch((error51) => {
       if (["ENOENT", "ENOTDIR"].includes(String(record2(error51).code)))
         throw new CodeBuddyError("invalidRequest", "Subagent historical working directory is unavailable; ownership cannot be verified");
       throw error51;
@@ -21875,7 +22261,7 @@ async function validateCodeBuddyChildContents(contents, parent, childId, cwd, to
       throw new CodeBuddyError("protocolError", "Inherited Subagent identity changed");
     inheritedEntries = prefixParsed.entries;
   }
-  const target = await realpath3(cwd);
+  const target = await realpath4(cwd);
   const inheritedCwds = inheritedEntries.flatMap((row) => typeof row.cwd === "string" ? [row.cwd] : []);
   const suffixCwds = parsed.entries.slice(inheritedEntries.length).flatMap((row) => typeof row.cwd === "string" ? [row.cwd] : []);
   const canonical = await canonicalCwds(suffixCwds);
@@ -22011,7 +22397,7 @@ async function copyCodeBuddySession(cwd, sourceId, targetId, environment, signal
         child.stderr.destroy();
       } else if (process.platform === "win32" && child.pid) {
         termination = new Promise((done) => {
-          execFile2("taskkill", ["/PID", String(child.pid), "/T", "/F"], { windowsHide: true, timeout: 3e3 }, () => {
+          execFile3("taskkill", ["/PID", String(child.pid), "/T", "/F"], { windowsHide: true, timeout: 3e3 }, () => {
             child.kill();
             done();
           });
@@ -22118,20 +22504,20 @@ async function bridgeCopyToTarget(sourceCwd, targetCwd, ref, contents, environme
   const targetFile = codeBuddyPrimaryHistoryPath(targetCwd, ref, environment, profile);
   if (sameResolvedPath(sourceFile, targetFile))
     return void 0;
-  const targetDirectory = path5.dirname(targetFile);
-  const projectsDirectory = path5.dirname(targetDirectory);
+  const targetDirectory = path6.dirname(targetFile);
+  const projectsDirectory = path6.dirname(targetDirectory);
   await mkdir(targetDirectory, { recursive: true });
   const [realProjects, realTargetDirectory] = await Promise.all([
-    realpath4(projectsDirectory),
-    realpath4(targetDirectory)
+    realpath5(projectsDirectory),
+    realpath5(targetDirectory)
   ]);
-  if (!sameResolvedPath(realTargetDirectory, path5.join(realProjects, codeBuddyProjectSlug(targetCwd, profile))))
+  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 readFile2(targetFile);
+    const persisted = await readFile3(targetFile);
     if (!isDeepStrictEqual3(persisted, expected))
       throw new CodeBuddyError("nativeFailure", "Cross-directory history bridge changed native bytes");
     return bridge;
@@ -22146,7 +22532,7 @@ async function cleanupBridge(bridge) {
     const info = await lstat(bridge.file);
     if (!info.isFile() || process.platform !== "win32" && (info.mode & 63) !== 0)
       return;
-    if (!isDeepStrictEqual3(await readFile2(bridge.file), bridge.expected))
+    if (!isDeepStrictEqual3(await readFile3(bridge.file), bridge.expected))
       return;
     await unlink(bridge.file);
   } catch (error51) {
@@ -22232,7 +22618,7 @@ function assertChildRanges(rows2, child) {
   }
 }
 async function plainDirectory(parent, name) {
-  const directory = path5.join(parent, name);
+  const directory = path6.join(parent, name);
   await mkdir(directory, { mode: 448 }).catch((error51) => {
     if (record2(error51).code !== "EEXIST")
       throw error51;
@@ -22240,7 +22626,7 @@ async function plainDirectory(parent, name) {
   const info = await lstat(directory);
   if (!info.isDirectory() || info.isSymbolicLink() || process.platform !== "win32" && (info.mode & 18) !== 0)
     throw new CodeBuddyError("invalidRequest", "Redirected native Subagent directory");
-  const actual = await realpath4(directory);
+  const actual = await realpath5(directory);
   if (!sameResolvedPath(actual, directory))
     throw new CodeBuddyError("invalidRequest", "Redirected native Subagent directory");
   return directory;
@@ -22249,7 +22635,7 @@ async function verifiedChildFile(file2, expected) {
   const info = await lstat(file2);
   if (!info.isFile() || info.isSymbolicLink() || process.platform !== "win32" && (info.mode & 63) !== 0)
     throw new CodeBuddyError("invalidRequest", "Unsafe derived Subagent transcript");
-  if (!sameResolvedPath(await realpath4(file2), file2))
+  if (!sameResolvedPath(await realpath5(file2), file2))
     throw new CodeBuddyError("invalidRequest", "Redirected derived Subagent transcript");
   const before = await codeBuddyFileVersion(file2);
   const actual = await readCodeBuddyVersionedText(file2, CODEBUDDY_CHILD_MAX_BYTES, "Subagent transcript exceeds 8 MB", before);
@@ -22258,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;
@@ -22277,19 +22663,19 @@ async function copyInheritedChildren(options) {
   const { references } = options;
   if (!references.length)
     return { descriptors: [], created: [] };
-  const sourceHistoryFile = await realpath4(options.sourceHistoryFile);
-  const sourceProject = path5.dirname(sourceHistoryFile);
-  if (!sameResolvedPath(sourceHistoryFile, path5.join(sourceProject, `${options.sourceRef.nativeSessionId}.jsonl`)))
+  const sourceHistoryFile = await realpath5(options.sourceHistoryFile);
+  const sourceProject = path6.dirname(sourceHistoryFile);
+  if (!sameResolvedPath(sourceHistoryFile, path6.join(sourceProject, `${options.sourceRef.nativeSessionId}.jsonl`)))
     throw new CodeBuddyError("invalidRequest", "Unexpected source history location");
-  const sourceDirectory = path5.join(sourceProject, options.sourceRef.nativeSessionId, "subagents");
+  const sourceDirectory = path6.join(sourceProject, options.sourceRef.nativeSessionId, "subagents");
   const sourceDirectoryInfo = await lstat(sourceDirectory);
   if (!sourceDirectoryInfo.isDirectory() || sourceDirectoryInfo.isSymbolicLink())
     throw new CodeBuddyError("invalidRequest", "Redirected source Subagent directory");
-  if (!sameResolvedPath(await realpath4(sourceDirectory), sourceDirectory))
+  if (!sameResolvedPath(await realpath5(sourceDirectory), sourceDirectory))
     throw new CodeBuddyError("invalidRequest", "Redirected source Subagent directory");
-  const targetHistoryFile = await realpath4(options.targetHistoryFile);
-  const targetProject = path5.dirname(targetHistoryFile);
-  if (!sameResolvedPath(targetHistoryFile, path5.join(targetProject, `${options.targetRef.nativeSessionId}.jsonl`)))
+  const targetHistoryFile = await realpath5(options.targetHistoryFile);
+  const targetProject = path6.dirname(targetHistoryFile);
+  if (!sameResolvedPath(targetHistoryFile, path6.join(targetProject, `${options.targetRef.nativeSessionId}.jsonl`)))
     throw new CodeBuddyError("invalidRequest", "Unexpected target history location");
   const targetSessionDirectory = await plainDirectory(targetProject, options.targetRef.nativeSessionId);
   const targetDirectory = await plainDirectory(targetSessionDirectory, "subagents");
@@ -22297,7 +22683,7 @@ async function copyInheritedChildren(options) {
   const created = [];
   try {
     for (const reference of references) {
-      const sourceFile = path5.join(sourceDirectory, `${reference.childId}.jsonl`);
+      const sourceFile = path6.join(sourceDirectory, `${reference.childId}.jsonl`);
       const sourceInfo = await lstat(sourceFile);
       if (!sourceInfo.isFile() || sourceInfo.isSymbolicLink())
         throw new CodeBuddyError("invalidRequest", "Redirected source Subagent transcript");
@@ -22316,7 +22702,7 @@ async function copyInheritedChildren(options) {
         throw new CodeBuddyError("protocolError", "Missing Agent result child range");
       const prefix = await codeBuddyChildPrefixThrough(source.contents, last, validated);
       const expected = Buffer.from(prefix.contents, "utf8");
-      const targetFile = path5.join(targetDirectory, `${reference.childId}.jsonl`);
+      const targetFile = path6.join(targetDirectory, `${reference.childId}.jsonl`);
       const copy = await persistChildCopy(targetFile, expected);
       if (copy)
         created.push(copy);
@@ -22553,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;
@@ -22695,8 +23420,8 @@ var CodeBuddyInteractions = class {
 };
 
 // dist/subagent-history.js
-import { readdir as readdir2, realpath as realpath5 } from "node:fs/promises";
-import path6 from "node:path";
+import { readdir as readdir2, realpath as realpath6 } from "node:fs/promises";
+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 {
@@ -22723,9 +23448,9 @@ var CodeBuddyChildObserver = class {
       throw new CodeBuddyError("invalidRequest", "Subagent observer is closed");
   }
   async #validateWorkspaces(cwds) {
-    const expected = await realpath5(this.cwd);
+    const expected = await realpath6(this.cwd);
     for (const cwd of new Set(cwds)) {
-      const actual = await realpath5(cwd).catch((error51) => {
+      const actual = await realpath6(cwd).catch((error51) => {
         if (["ENOENT", "ENOTDIR"].includes(String(record2(error51).code)))
           throw new CodeBuddyError("invalidRequest", "Native Session historical working directory is unavailable; ownership cannot be verified");
         throw error51;
@@ -22760,9 +23485,9 @@ var CodeBuddyChildObserver = class {
   }
   async #directory() {
     const history = await this.#parentHistory();
-    const project = path6.dirname(await realpath5(history.file));
-    const expected = path6.join(project, this.parent.nativeSessionId, "subagents");
-    const actual = await realpath5(expected);
+    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))
       throw new CodeBuddyError("invalidRequest", `Redirected ${this.profile.displayName} Subagent directory`);
@@ -22771,7 +23496,7 @@ var CodeBuddyChildObserver = class {
   async #child(directory, childId) {
     if (!validCodeBuddyChildId(childId))
       throw new CodeBuddyError("invalidRequest", "Invalid native Subagent ID");
-    const file2 = path6.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");
@@ -23483,6 +24208,7 @@ var CodeBuddyAdapter = class {
   harnessId;
   commandCatalog;
   liveCommandCatalog = true;
+  sessionImport;
   subagents = {
     readSnapshot: async ({ parent, nativeSubagentId, cwd }) => {
       try {
@@ -23516,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));
   }
@@ -23535,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,
@@ -23581,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");
@@ -23644,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();
@@ -23655,9 +24382,41 @@ var CodeBuddyAdapter = class {
   }
 };
 
+// dist/installation.js
+function createCodeBuddyInstallation(environment) {
+  let update;
+  return createInstallationManager({
+    async check() {
+      const resolved = resolveHarnessExecutable(codeBuddyDiscoverySpec, { environment });
+      if (!resolved)
+        throw new Error("CodeBuddy is not installed");
+      const currentVersion = versionFromOutput(await runInstallationCommand(resolved.executable, ["--version"], environment));
+      const npm = await npmInstallation(resolved.executable, ["@tencent-ai/codebuddy-code"], environment);
+      update = npm?.update;
+      const latestVersion = npm ? await npm.latest() : "Unknown";
+      const canUpdate = npm?.canUpdate ?? false;
+      return {
+        currentVersion,
+        latestVersion,
+        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."
+        } : {}
+      };
+    },
+    async update(state) {
+      if (!update)
+        throw new Error("This CodeBuddy installation requires a manual update");
+      await update(state.latestVersion);
+    }
+  });
+}
+
 // ../../harness-broker/dist/client.js
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { lstat as lstat2, readFile as readFile3 } 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
@@ -23772,24 +24531,25 @@ function consumeBrokerFrames(socket, onFrame, onError) {
 
 // ../../harness-broker/dist/paths.js
 import os2 from "node:os";
-import path7 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 path7.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 path7.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.json`);
-  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path7.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
 var cwdSchema = external_exports.string().min(1).max(16384);
 var brokerEnvironmentSchema = external_exports.object({
   CODEXHOST_CLI_PATH: external_exports.string().max(16384).optional(),
+  CODEXHOST_CLI_NODE_PATH: external_exports.string().max(16384).optional(),
   CODEXHOST_RUNTIME_ENDPOINT: external_exports.string().max(16384).optional(),
   CODEXHOST_RUNTIME_TOKEN: external_exports.string().max(16384).optional(),
   CODEXHOST_THREAD_ID: external_exports.string().max(256).optional()
@@ -23944,6 +24704,7 @@ var eventKeys = /* @__PURE__ */ new Map([
   ["item.started", /* @__PURE__ */ new Set(["type", "turnId", "item"])],
   ["item.updated", /* @__PURE__ */ new Set(["type", "turnId", "itemId", "update"])],
   ["item.completed", /* @__PURE__ */ new Set(["type", "turnId", "snapshot"])],
+  ["item.detached", /* @__PURE__ */ new Set(["type", "turnId", "itemId"])],
   ["interaction.closed", /* @__PURE__ */ new Set(["type", "interactionId", "turnId", "reason"])],
   ["turn.completed", /* @__PURE__ */ new Set(["type", "turnId", "nativeTurnRef", "outcome"])],
   ["session.faulted", /* @__PURE__ */ new Set(["type", "error"])]
@@ -24060,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())
@@ -24072,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 readFile3(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");
     }
@@ -24512,6 +25273,7 @@ var BrokeredHarnessAdapter = class {
       if (this.#forwardEnvironment && input.environment) {
         const allowed = [
           "CODEXHOST_CLI_PATH",
+          "CODEXHOST_CLI_NODE_PATH",
           "CODEXHOST_RUNTIME_ENDPOINT",
           "CODEXHOST_RUNTIME_TOKEN",
           "CODEXHOST_THREAD_ID"
@@ -24577,7 +25339,11 @@ function createHarnessAdapter(context) {
       liveCommandCatalog: true,
       environment: { ...context.environment }
     });
-  return new CodeBuddyAdapter({ environment: { ...context.environment } });
+  const environment = { ...context.environment };
+  return Object.assign(new CodeBuddyAdapter({ environment }), {
+    installation: createCodeBuddyInstallation(environment),
+    install: createHarnessInstaller(environment, { npm: "@tencent-ai/codebuddy-code" })
+  });
 }
 export {
   createHarnessAdapter