@codexhost/cli-win32-arm64 0.11.0 → 0.12.1

package/app/plugins/antigravity/plugin.mjs

@@ -5,6 +5,409 @@ 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/installer.js
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+function createHarnessInstaller(environment, source) {
+  return async () => {
+    if (!["darwin", "linux", "win32"].includes(process.platform))
+      throw new Error("Unsupported installation platform");
+    const env = withNodeRuntimeOnPath(environment);
+    if ("npm" in source) {
+      const npm = resolveHarnessExecutable({
+        id: "npm",
+        command: "npm",
+        installRoots: {
+          posix: [
+            "~/.npm-global/bin",
+            "~/.local/bin",
+            VERSION_MANAGER_ROOTS,
+            "/opt/homebrew/bin",
+            "/usr/local/bin",
+            "/usr/bin"
+          ],
+          windows: [
+            "${APPDATA}/npm",
+            VERSION_MANAGER_ROOTS,
+            "${ProgramFiles}/nodejs",
+            "${LOCALAPPDATA}/Programs/nodejs"
+          ]
+        }
+      }, { environment: env });
+      if (!npm)
+        throw new Error("Install Node.js and npm first");
+      await runInstallationCommand(npm.executable, ["install", "--global", source.npm], {
+        ...env,
+        ...source.allowScripts ? { npm_config_allow_scripts: source.allowScripts } : {}
+      }, 6e5);
+      return;
+    }
+    const windows = process.platform === "win32";
+    const url2 = windows ? source.windows : source.posix;
+    if (new URL(url2).protocol !== "https:")
+      throw new Error("Installer requires HTTPS");
+    const script = await fetchInstallationText(url2);
+    const directory = await mkdtemp(join(tmpdir(), "codexhost-installer-"));
+    try {
+      const file2 = join(directory, windows ? "install.ps1" : "install.sh");
+      await writeFile(file2, script, { mode: 384 });
+      await runInstallationCommand(windows ? "powershell.exe" : source.shell ?? "bash", windows ? ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File", file2] : [file2], env, 6e5);
+    } finally {
+      await rm(directory, { recursive: true, force: true });
+    }
+  };
+}
+
 // dist/antigravity-adapter.js
 import { spawn } from "node:child_process";
 import { randomUUID as randomUUID6 } from "node:crypto";
@@ -14598,6 +15001,20 @@ var harnessDisplaySetSchema = external_exports.strictObject({
   initializeOnly: external_exports.boolean().optional()
 });
 
+// ../../shared-contracts/dist/ids.js
+var opaqueIdSchema = external_exports.string().refine((value) => value.trim().length > 0, {
+  message: "Identifier must not be empty or whitespace"
+});
+var harnessIdSchema = opaqueIdSchema.brand();
+var hostThreadIdSchema = opaqueIdSchema.brand();
+var hostTurnIdSchema = opaqueIdSchema.brand();
+var hostItemIdSchema = opaqueIdSchema.brand();
+var hostInteractionIdSchema = opaqueIdSchema.brand();
+
+// ../../shared-contracts/dist/thread-prewarm.js
+var threadPrewarmDiscardParamsSchema = external_exports.object({ threadId: hostThreadIdSchema });
+var threadPrewarmDiscardResultSchema = external_exports.object({ discarded: external_exports.boolean() });
+
 // ../../shared-contracts/dist/console.js
 var consoleAnnouncementSchema = external_exports.strictObject({
   title: external_exports.string().trim().min(1).max(200),
@@ -14610,10 +15027,14 @@ var consoleOpenResultSchema = external_exports.strictObject({
   url: external_exports.string().max(2048).regex(/^http:\/\/(?:127\.0\.0\.1|localhost):\d{1,5}\/(?:\?.*)?$/u)
 });
 var CONSOLE_HOST_METHODS = Object.freeze([
+  "codexhost/console/remote-connections",
+  "codexhost/runtime/status",
+  "codexhost/remote/ssh-setup",
   "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",
@@ -14675,16 +15096,6 @@ var loadedSessionsSchema = external_exports.array(external_exports.strictObject(
   inactiveMs: external_exports.number().nonnegative()
 }));
 
-// ../../shared-contracts/dist/ids.js
-var opaqueIdSchema = external_exports.string().refine((value) => value.trim().length > 0, {
-  message: "Identifier must not be empty or whitespace"
-});
-var harnessIdSchema = opaqueIdSchema.brand();
-var hostThreadIdSchema = opaqueIdSchema.brand();
-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,
@@ -14968,1083 +15379,811 @@ var harnessModelSchema = external_exports.object({
 }).strict();
 var harnessThinkingOptionsSchema = external_exports.array(harnessThinkingOptionSchema).superRefine((options, context) => {
   const ids = /* @__PURE__ */ new Set();
-  for (const [index, option] of options.entries()) {
-    if (ids.has(option.id)) {
-      context.addIssue({
-        code: "custom",
-        message: "Thinking option IDs must be unique",
-        path: [index, "id"]
-      });
-    }
-    ids.add(option.id);
-  }
-});
-var harnessModelCatalogSchema = external_exports.object({
-  models: external_exports.array(harnessModelSchema),
-  defaultModel: harnessModelRefSchema.optional(),
-  thinkingOptions: harnessThinkingOptionsSchema,
-  defaultThinkingOptionId: harnessThinkingOptionIdSchema.optional()
-}).strict().superRefine((catalog, context) => {
-  const refs = /* @__PURE__ */ new Set();
-  const thinkingIds = new Set(catalog.thinkingOptions.map(({ id }) => id));
-  for (const [index, model] of catalog.models.entries()) {
-    if (refs.has(model.ref.id)) {
-      context.addIssue({
-        code: "custom",
-        message: "Model Catalog refs must be unique",
-        path: ["models", index, "ref", "id"]
-      });
-    }
-    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)) {
-        context.addIssue({
-          code: "custom",
-          message: "Supported Thinking option IDs must be unique per Model",
-          path: ["models", index, "supportedThinkingOptionIds", optionIndex]
-        });
-      }
-      supportedThinkingIds.add(optionId);
-      if (!thinkingIds.has(optionId)) {
-        context.addIssue({
-          code: "custom",
-          message: "Supported Thinking option must exist in the catalog",
-          path: ["models", index, "supportedThinkingOptionIds", optionIndex]
-        });
-      }
-    }
-  }
-  if (catalog.defaultModel && !refs.has(catalog.defaultModel.id)) {
-    context.addIssue({
-      code: "custom",
-      message: "Default Model must exist in the Model Catalog",
-      path: ["defaultModel", "id"]
-    });
-  }
-  if (catalog.defaultThinkingOptionId && !thinkingIds.has(catalog.defaultThinkingOptionId)) {
-    context.addIssue({
-      code: "custom",
-      message: "Default Thinking option must exist in the catalog",
-      path: ["defaultThinkingOptionId"]
-    });
-  }
-});
-var harnessHistoryCapabilitiesSchema = external_exports.object({
-  fork: external_exports.boolean(),
-  forkAcrossCwd: external_exports.boolean(),
-  rollbackLastTurn: external_exports.boolean()
-}).strict().refine((history) => history.fork || !history.forkAcrossCwd, {
-  path: ["forkAcrossCwd"],
-  message: "Cross-cwd Fork requires exact history Fork support"
-});
-var harnessPermissionModeScopeSchema = external_exports.enum(["live", "atCreate"]);
-var harnessSessionCapabilitiesSchema = external_exports.object({
-  configuration: external_exports.object({
-    selectModel: external_exports.boolean(),
-    selectThinkingOption: external_exports.boolean(),
-    selectPermissionMode: external_exports.boolean(),
-    permissionModeScope: harnessPermissionModeScopeSchema.default("live")
-  }).strict(),
-  history: harnessHistoryCapabilitiesSchema,
-  subagents: external_exports.object({
-    observe: external_exports.boolean(),
-    readTranscript: external_exports.boolean()
-  }).strict().optional(),
-  autonomousTurns: external_exports.object({
-    observe: external_exports.boolean()
-  }).strict().optional()
-}).strict();
-var harnessConfigurationStateSchema = external_exports.object({
-  effectiveModel: harnessModelRefSchema.optional(),
-  resolvedModelLabel: harnessResolvedModelLabelSchema.optional(),
-  effectiveThinkingOptionId: harnessThinkingOptionIdSchema.optional(),
-  availableThinkingOptions: harnessThinkingOptionsSchema.optional(),
-  effectivePermissionModeId: harnessPermissionModeIdSchema.optional()
-}).strict().superRefine((state, context) => {
-  if (state.effectiveThinkingOptionId && state.availableThinkingOptions && !state.availableThinkingOptions.some(({ id }) => id === state.effectiveThinkingOptionId)) {
-    context.addIssue({
-      code: "custom",
-      message: "Effective Thinking option must be currently available",
-      path: ["effectiveThinkingOptionId"]
-    });
-  }
-});
-var harnessWebUiCapabilitySchema = external_exports.object({
-  open: external_exports.literal(true)
-}).strict();
-var readyHarnessInspectionSchema = external_exports.object({
-  status: external_exports.literal("ready"),
-  catalog: harnessModelCatalogSchema,
-  permissionModes: harnessPermissionModeCatalogSchema.optional(),
-  capabilities: harnessSessionCapabilitiesSchema,
-  webUi: harnessWebUiCapabilitySchema.optional()
-}).strict().superRefine((inspection, context) => {
-  const selectable = inspection.capabilities.configuration.selectPermissionMode;
-  if (selectable !== Boolean(inspection.permissionModes)) {
-    context.addIssue({
-      code: "custom",
-      message: "Permission Mode catalog and capability must agree",
-      path: selectable ? ["permissionModes"] : ["capabilities", "configuration", "selectPermissionMode"]
-    });
-  }
-});
-var failedHarnessInspectionSchema = external_exports.object({
-  status: external_exports.enum(["notInstalled", "unavailable", "error"]),
-  error: codexhostErrorSchema
-}).strict();
-var harnessInspectionSchema = external_exports.union([
-  readyHarnessInspectionSchema,
-  failedHarnessInspectionSchema
-]);
-var harnessInspectParamsSchema = external_exports.object({
-  harnessId: harnessIdSchema,
-  cwd: nonBlankTextSchema2.max(16384).optional(),
-  refresh: external_exports.boolean().optional()
-}).strict();
-var harnessWebUiOpenParamsSchema = external_exports.object({
-  harnessId: harnessIdSchema
-}).strict();
-var harnessWebUiOpenResultSchema = external_exports.object({}).strict();
-var threadModelSelectParamsSchema = external_exports.object({
-  threadId: hostThreadIdSchema,
-  model: harnessModelRefSchema
-}).strict();
-var threadThinkingSelectParamsSchema = external_exports.object({
-  threadId: hostThreadIdSchema,
-  thinkingOptionId: harnessThinkingOptionIdSchema
-}).strict();
-var threadInspectionParamsSchema = external_exports.object({
-  threadId: hostThreadIdSchema,
-  includeReferenceCapability: external_exports.boolean().optional()
-}).strict();
-var codexThreadInspectionSchema = external_exports.object({
-  owner: external_exports.literal("codex"),
-  locked: external_exports.literal(true),
-  supportsThreadReferences: external_exports.literal(true).optional()
-}).strict();
-var externalThreadInspectionSchema = external_exports.object({
-  owner: external_exports.literal("external"),
-  harnessId: nonBlankTextSchema2.max(256),
-  transportModelId: nonBlankTextSchema2.max(1024),
-  effectiveModel: harnessModelRefSchema.optional(),
-  resolvedModelLabel: harnessResolvedModelLabelSchema.optional(),
-  effectiveThinkingOptionId: harnessThinkingOptionIdSchema.optional(),
-  availableThinkingOptions: harnessThinkingOptionsSchema.optional(),
-  effectivePermissionModeId: harnessPermissionModeIdSchema.optional(),
-  history: harnessHistoryCapabilitiesSchema,
-  usage: threadUsageSnapshotSchema.optional(),
-  locked: external_exports.literal(true)
-}).strict();
-var threadInspectionSchema = external_exports.discriminatedUnion("owner", [
-  codexThreadInspectionSchema,
-  externalThreadInspectionSchema
-]);
-var threadOwnershipListParamsSchema = external_exports.object({
-  threadIds: external_exports.array(hostThreadIdSchema).min(1).max(THREAD_OWNERSHIP_LIST_MAX_LENGTH)
-}).strict().superRefine(({ threadIds }, context) => {
-  const seen = /* @__PURE__ */ new Set();
-  for (const [index, threadId] of threadIds.entries()) {
-    if (seen.has(threadId)) {
+  for (const [index, option] of options.entries()) {
+    if (ids.has(option.id)) {
       context.addIssue({
         code: "custom",
-        message: "Thread ownership-list IDs must be unique",
-        path: ["threadIds", index]
+        message: "Thinking option IDs must be unique",
+        path: [index, "id"]
       });
     }
-    seen.add(threadId);
+    ids.add(option.id);
   }
 });
-var codexThreadOwnershipSchema = external_exports.object({
-  threadId: hostThreadIdSchema,
-  owner: external_exports.literal("codex")
-}).strict();
-var externalThreadOwnershipSchema = external_exports.object({
-  threadId: hostThreadIdSchema,
-  owner: external_exports.literal("external"),
-  harnessId: external_exports.string().max(256).pipe(harnessIdSchema)
-}).strict();
-var threadOwnershipSchema = external_exports.discriminatedUnion("owner", [
-  codexThreadOwnershipSchema,
-  externalThreadOwnershipSchema
-]);
-var threadOwnershipListResultSchema = external_exports.object({
-  threads: external_exports.array(threadOwnershipSchema).min(1).max(THREAD_OWNERSHIP_LIST_MAX_LENGTH)
-}).strict().superRefine(({ threads }, context) => {
-  const seen = /* @__PURE__ */ new Set();
-  for (const [index, thread] of threads.entries()) {
-    if (seen.has(thread.threadId)) {
+var harnessModelCatalogSchema = external_exports.object({
+  models: external_exports.array(harnessModelSchema),
+  defaultModel: harnessModelRefSchema.optional(),
+  thinkingOptions: harnessThinkingOptionsSchema,
+  defaultThinkingOptionId: harnessThinkingOptionIdSchema.optional()
+}).strict().superRefine((catalog, context) => {
+  const refs = /* @__PURE__ */ new Set();
+  const thinkingIds = new Set(catalog.thinkingOptions.map(({ id }) => id));
+  for (const [index, model] of catalog.models.entries()) {
+    if (refs.has(model.ref.id)) {
       context.addIssue({
         code: "custom",
-        message: "Thread ownership-list results must be unique",
-        path: ["threads", index, "threadId"]
+        message: "Model Catalog refs must be unique",
+        path: ["models", index, "ref", "id"]
       });
     }
-    seen.add(thread.threadId);
+    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)) {
+        context.addIssue({
+          code: "custom",
+          message: "Supported Thinking option IDs must be unique per Model",
+          path: ["models", index, "supportedThinkingOptionIds", optionIndex]
+        });
+      }
+      supportedThinkingIds.add(optionId);
+      if (!thinkingIds.has(optionId)) {
+        context.addIssue({
+          code: "custom",
+          message: "Supported Thinking option must exist in the catalog",
+          path: ["models", index, "supportedThinkingOptionIds", optionIndex]
+        });
+      }
+    }
+  }
+  if (catalog.defaultModel && !refs.has(catalog.defaultModel.id)) {
+    context.addIssue({
+      code: "custom",
+      message: "Default Model must exist in the Model Catalog",
+      path: ["defaultModel", "id"]
+    });
+  }
+  if (catalog.defaultThinkingOptionId && !thinkingIds.has(catalog.defaultThinkingOptionId)) {
+    context.addIssue({
+      code: "custom",
+      message: "Default Thinking option must exist in the catalog",
+      path: ["defaultThinkingOptionId"]
+    });
   }
 });
-
-// ../../shared-contracts/dist/harness-plugins.js
-var HARNESS_PLUGIN_MANIFEST_MAX_BYTES = 32 * 1024;
-var HARNESS_PLUGIN_ICON_MAX_BYTES = 128 * 1024;
-var HARNESS_PLUGIN_LIMIT = 128;
-var harnessPluginIdSchema = external_exports.string().min(1).max(128).regex(/^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/u).refine((id) => id !== "codex", "The official Codex identity is reserved").pipe(harnessIdSchema);
-var relativeResourceSchema = external_exports.string().min(1).max(512).refine((value) => !/[\\\u0000:#?]/u.test(value) && !value.startsWith("/") && !value.split("/").some((part) => part === ".." || part === ""), "Plugin resources must be relative paths inside the plugin");
-var documentationUrlSchema = external_exports.url().refine((value) => /^https:\/\/[^/?#@]+(?:[/?#]|$)/iu.test(value), "Plugin documentation links must be credential-free HTTPS URLs");
-var pluginPresentationShape = {
-  id: harnessPluginIdSchema,
-  name: external_exports.string().trim().min(1).max(128),
-  version: external_exports.string().min(1).max(128),
-  /** The factory accepts a persisted local entrypoint through its construction context. */
-  launchCommand: external_exports.literal(true).optional(),
-  links: external_exports.object({
-    documentation: documentationUrlSchema.optional(),
-    installation: documentationUrlSchema.optional()
-  }).strict().optional()
-};
-var harnessPluginManifestSchema = external_exports.object({
-  manifestVersion: external_exports.literal(1),
-  ...pluginPresentationShape,
-  adapterApiVersion: external_exports.number().int().positive(),
-  entry: relativeResourceSchema,
-  icon: relativeResourceSchema.optional()
-}).strict();
-var harnessPluginIconSchema = external_exports.string().max(Math.ceil(HARNESS_PLUGIN_ICON_MAX_BYTES / 3) * 4 + 64).regex(/^data:image\/(?:png|jpeg|webp|svg\+xml);base64,[A-Za-z0-9+/]+={0,2}$/u);
-var harnessPluginDescriptorSchema = external_exports.object({
-  ...pluginPresentationShape,
-  icon: harnessPluginIconSchema.optional()
-}).strict();
-var harnessPluginListParamsSchema = external_exports.object({}).strict();
-var harnessPluginListResultSchema = external_exports.object({
-  plugins: external_exports.array(harnessPluginDescriptorSchema).max(HARNESS_PLUGIN_LIMIT)
-}).strict();
-var harnessPluginConfigurationSchema = external_exports.object({
-  version: external_exports.literal(1),
-  enabled: external_exports.array(harnessPluginIdSchema).max(HARNESS_PLUGIN_LIMIT)
-}).strict().refine((value) => new Set(value.enabled).size === value.enabled.length, {
-  message: "Enabled plugin IDs must be unique",
-  path: ["enabled"]
-});
-
-// ../../shared-contracts/dist/harness-route.js
-var harnessPluginRouteSchema = external_exports.object({
-  harnessId: harnessPluginIdSchema,
-  model: harnessModelRefSchema.optional(),
-  thinkingOptionId: harnessThinkingOptionIdSchema.optional(),
-  permissionModeId: harnessPermissionModeIdSchema.optional()
-}).strict();
-
-// ../../shared-contracts/dist/harness-launch-settings.js
-var harnessLaunchPathSchema = external_exports.string().trim().min(1).max(4096).refine((value) => !/[\u0000\r\n]/u.test(value), "Invalid entrypoint path");
-var harnessLaunchSettingsGetSchema = external_exports.object({
-  harnessId: harnessPluginIdSchema
-}).strict();
-var harnessLaunchSettingsSetSchema = harnessLaunchSettingsGetSchema.extend({
-  path: harnessLaunchPathSchema.nullable()
+var harnessHistoryCapabilitiesSchema = external_exports.object({
+  fork: external_exports.boolean(),
+  forkAcrossCwd: external_exports.boolean(),
+  rollbackLastTurn: external_exports.boolean()
+}).strict().refine((history) => history.fork || !history.forkAcrossCwd, {
+  path: ["forkAcrossCwd"],
+  message: "Cross-cwd Fork requires exact history Fork support"
 });
-var harnessLaunchSettingsSchema = external_exports.object({
-  path: harnessLaunchPathSchema.nullable(),
-  restartRequired: external_exports.boolean()
-}).strict();
-
-// ../../shared-contracts/dist/harness-installation.js
-var harnessInstallationParamsSchema = external_exports.object({
-  harnessId: harnessIdSchema,
-  action: external_exports.enum(["check", "update"])
-}).strict();
-var harnessInstallationStateSchema = external_exports.object({
-  currentVersion: external_exports.string().min(1).max(128),
-  latestVersion: external_exports.string().min(1).max(128),
-  updateAvailable: external_exports.boolean(),
-  canUpdate: external_exports.boolean(),
-  message: external_exports.string().max(2048).optional()
-}).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);
-var codexAccountPlanTypeSchema = external_exports.enum([
-  "free",
-  "go",
-  "plus",
-  "pro",
-  "prolite",
-  "team",
-  "self_serve_business_prolite",
-  "self_serve_business_usage_based",
-  "business",
-  "ent26",
-  "enterprise_cbp_automation",
-  "enterprise_cbp_usage_based",
-  "enterprise",
-  "edu",
-  "edu_plus",
-  "edu_pro",
-  "unknown"
-]);
-var codexAccountSchema = external_exports.object({
-  accountId: accountIdSchema,
-  label: nonBlankTextSchema3.max(256),
-  email: external_exports.string().email().max(320).optional(),
-  planType: codexAccountPlanTypeSchema.optional()
-}).strict();
-var codexAccountPhaseSchema = external_exports.enum(["ready", "unavailable"]);
-var codexAccountListResultSchema = external_exports.object({
-  version: external_exports.literal(2),
-  currentAccountId: accountIdSchema.nullable(),
-  phase: codexAccountPhaseSchema,
-  revision: external_exports.number().int().nonnegative(),
-  instanceId: nonBlankTextSchema3.max(1024).optional(),
-  accounts: external_exports.array(codexAccountSchema).max(1)
-}).strict();
-var codexAccountUsageParamsSchema = external_exports.object({ accountId: accountIdSchema, refresh: external_exports.boolean().optional() }).strict();
-var codexAccountUsageResultSchema = external_exports.object({
-  accountId: accountIdSchema,
-  usage: threadUsageSnapshotSchema.nullable(),
-  accountCredits: accountCreditsSnapshotSchema.optional(),
-  freshness: external_exports.enum(["live", "cached"]),
-  observedAt: external_exports.string().datetime().nullable()
-}).strict();
-
-// ../../shared-contracts/dist/harness-session-import.js
-var HARNESS_SESSION_IMPORT_ID_MAX_LENGTH = 1024;
-var HARNESS_SESSION_IMPORT_CWD_MAX_LENGTH = 16384;
-var HARNESS_SESSION_IMPORT_TITLE_MAX_LENGTH = 4096;
-var HARNESS_SESSION_IMPORT_LIST_MAX_LENGTH = 1e3;
-var HARNESS_SESSION_IMPORT_UPDATED_AT_MAX = 864e13;
-var nonBlankTextSchema4 = external_exports.string().refine((value) => value.trim().length > 0, "Value must not be empty or whitespace").refine((value) => !value.includes("\0"), "Value must not contain NUL");
-var harnessSessionImportIdSchema = nonBlankTextSchema4.max(HARNESS_SESSION_IMPORT_ID_MAX_LENGTH);
-var harnessSessionImportCandidateSchema = external_exports.object({
-  nativeSessionId: harnessSessionImportIdSchema,
-  title: nonBlankTextSchema4.max(HARNESS_SESSION_IMPORT_TITLE_MAX_LENGTH).nullable(),
-  updatedAt: external_exports.number().int().nonnegative().max(HARNESS_SESSION_IMPORT_UPDATED_AT_MAX),
-  cwd: nonBlankTextSchema4.max(HARNESS_SESSION_IMPORT_CWD_MAX_LENGTH),
-  // Native file discovery cannot reliably observe another process's activity.
-  running: external_exports.boolean().nullable()
-}).strict();
-var harnessSessionImportSourcesParamsSchema = external_exports.object({}).strict();
-var harnessSessionImportSourcesResultSchema = external_exports.object({
-  harnesses: external_exports.array(external_exports.object({
-    harnessId: harnessPluginIdSchema,
-    name: nonBlankTextSchema4.max(128)
-  }).strict()).max(128)
-}).strict();
-var harnessSessionListParamsSchema = external_exports.object({
-  harnessId: harnessPluginIdSchema,
-  query: external_exports.string().trim().max(4096).refine((value) => !value.includes("\0")).optional(),
-  offset: external_exports.number().int().nonnegative().safe().optional(),
-  limit: external_exports.number().int().min(1).max(HARNESS_SESSION_IMPORT_LIST_MAX_LENGTH).optional()
-}).strict();
-var harnessSessionListResultSchema = external_exports.object({
-  candidates: external_exports.array(harnessSessionImportCandidateSchema).max(HARNESS_SESSION_IMPORT_LIST_MAX_LENGTH),
-  total: external_exports.number().int().nonnegative().safe()
-}).strict();
-var harnessSessionImportParamsSchema = external_exports.object({
-  harnessId: harnessPluginIdSchema,
-  nativeSessionId: harnessSessionImportIdSchema
+var harnessPermissionModeScopeSchema = external_exports.enum(["live", "atCreate"]);
+var harnessSessionCapabilitiesSchema = external_exports.object({
+  configuration: external_exports.object({
+    selectModel: external_exports.boolean(),
+    selectThinkingOption: external_exports.boolean(),
+    selectPermissionMode: external_exports.boolean(),
+    permissionModeScope: harnessPermissionModeScopeSchema.default("live")
+  }).strict(),
+  history: harnessHistoryCapabilitiesSchema,
+  subagents: external_exports.object({
+    observe: external_exports.boolean(),
+    readTranscript: external_exports.boolean()
+  }).strict().optional(),
+  autonomousTurns: external_exports.object({
+    observe: external_exports.boolean()
+  }).strict().optional()
 }).strict();
-var harnessSessionImportResultSchema = external_exports.object({
-  threadId: nonBlankTextSchema4.max(1024).pipe(hostThreadIdSchema)
+var harnessConfigurationStateSchema = external_exports.object({
+  effectiveModel: harnessModelRefSchema.optional(),
+  resolvedModelLabel: harnessResolvedModelLabelSchema.optional(),
+  effectiveThinkingOptionId: harnessThinkingOptionIdSchema.optional(),
+  availableThinkingOptions: harnessThinkingOptionsSchema.optional(),
+  effectivePermissionModeId: harnessPermissionModeIdSchema.optional()
+}).strict().superRefine((state, context) => {
+  if (state.effectiveThinkingOptionId && state.availableThinkingOptions && !state.availableThinkingOptions.some(({ id }) => id === state.effectiveThinkingOptionId)) {
+    context.addIssue({
+      code: "custom",
+      message: "Effective Thinking option must be currently available",
+      path: ["effectiveThinkingOptionId"]
+    });
+  }
+});
+var harnessWebUiCapabilitySchema = external_exports.object({
+  open: external_exports.literal(true)
 }).strict();
-
-// ../../shared-contracts/dist/deepseek-modern-sessions.js
-var DEEPSEEK_MODERN_SESSION_LIST_MAX_LENGTH = HARNESS_SESSION_IMPORT_LIST_MAX_LENGTH;
-var DEEPSEEK_MODERN_HOST_THREAD_ID_MAX_LENGTH = 1024;
-var nonBlankTextSchema5 = external_exports.string().refine((value) => value.trim().length > 0, "Value must not be empty or whitespace").refine((value) => !value.includes("\0"), "Value must not contain NUL");
-var deepSeekModernSessionIdSchema = harnessSessionImportIdSchema;
-var deepSeekModernSessionCandidateSchema = harnessSessionImportCandidateSchema;
-var deepSeekModernSessionListParamsSchema = external_exports.object({}).strict();
-var deepSeekModernSessionListResultSchema = external_exports.object({
-  candidates: external_exports.array(deepSeekModernSessionCandidateSchema).max(DEEPSEEK_MODERN_SESSION_LIST_MAX_LENGTH)
+var readyHarnessInspectionSchema = external_exports.object({
+  status: external_exports.literal("ready"),
+  catalog: harnessModelCatalogSchema,
+  permissionModes: harnessPermissionModeCatalogSchema.optional(),
+  capabilities: harnessSessionCapabilitiesSchema,
+  webUi: harnessWebUiCapabilitySchema.optional()
+}).strict().superRefine((inspection, context) => {
+  const selectable = inspection.capabilities.configuration.selectPermissionMode;
+  if (selectable !== Boolean(inspection.permissionModes)) {
+    context.addIssue({
+      code: "custom",
+      message: "Permission Mode catalog and capability must agree",
+      path: selectable ? ["permissionModes"] : ["capabilities", "configuration", "selectPermissionMode"]
+    });
+  }
+});
+var failedHarnessInspectionSchema = external_exports.object({
+  status: external_exports.enum(["notInstalled", "unavailable", "error"]),
+  error: codexhostErrorSchema
 }).strict();
-var deepSeekModernSessionImportParamsSchema = external_exports.object({
-  nativeSessionId: deepSeekModernSessionIdSchema
+var harnessInspectionSchema = external_exports.union([
+  readyHarnessInspectionSchema,
+  failedHarnessInspectionSchema
+]);
+var harnessInspectParamsSchema = external_exports.object({
+  harnessId: harnessIdSchema,
+  cwd: nonBlankTextSchema2.max(16384).optional(),
+  refresh: external_exports.boolean().optional()
 }).strict();
-var deepSeekModernSessionImportResultSchema = external_exports.object({
-  threadId: nonBlankTextSchema5.max(DEEPSEEK_MODERN_HOST_THREAD_ID_MAX_LENGTH).pipe(hostThreadIdSchema)
+var harnessWebUiOpenParamsSchema = external_exports.object({
+  harnessId: harnessIdSchema
 }).strict();
-
-// ../../shared-contracts/dist/external-thread-fork.js
-var externalThreadForkParamsSchema = external_exports.object({
+var harnessWebUiOpenResultSchema = external_exports.object({}).strict();
+var threadModelSelectParamsSchema = external_exports.object({
   threadId: hostThreadIdSchema,
-  lastTurnId: hostTurnIdSchema
-}).strict();
-var externalThreadForkResultSchema = external_exports.object({
-  threadId: hostThreadIdSchema
-}).strict();
-
-// ../../shared-contracts/dist/harness-commands.js
-var commandIdSchema = external_exports.string().trim().min(1).max(128).regex(/^[A-Za-z0-9._:-]+$/u).brand();
-var commandInvocationSchema = external_exports.string().min(1).max(128);
-var commandLabelSchema = external_exports.string().trim().min(1).max(128);
-var commandDescriptionSchema = external_exports.string().trim().min(1).max(512);
-var harnessCommandDescriptorSchema = external_exports.object({
-  id: commandIdSchema,
-  invocation: commandInvocationSchema,
-  label: commandLabelSchema,
-  description: commandDescriptionSchema.optional(),
-  argumentMode: external_exports.enum(["none", "text"]),
-  /**
-   * Native distinction reported by the Harness. Omitted when the Harness does
-   * not tell skills and commands apart; consumers treat that as "command".
-   */
-  kind: external_exports.enum(["command", "skill"]).optional()
-}).strict();
-var harnessCommandCatalogSchema = external_exports.object({
-  commands: external_exports.array(harnessCommandDescriptorSchema),
-  /**
-   * `live` when the catalog includes what a native Session reports for its
-   * workspace (custom commands, skills); `static` for Adapter built-ins only.
-   * Omitted by Adapters; set by the Host on inspection results.
-   */
-  source: external_exports.enum(["live", "static"]).optional()
-}).strict().superRefine((catalog, context) => {
-  const ids = /* @__PURE__ */ new Set();
-  for (const [index, command] of catalog.commands.entries()) {
-    if (ids.has(command.id)) {
-      context.addIssue({
-        code: "custom",
-        message: "Harness command IDs must be unique",
-        path: ["commands", index, "id"]
-      });
-    }
-    ids.add(command.id);
-  }
-});
-var harnessCommandsInspectParamsSchema = external_exports.object({
-  harnessId: harnessIdSchema,
-  /** Workspace of a draft without a Thread, for its live catalog when known. */
-  cwd: external_exports.string().min(1).optional()
+  model: harnessModelRefSchema
 }).strict();
-var threadCommandsInspectParamsSchema = external_exports.object({
-  threadId: hostThreadIdSchema
+var threadThinkingSelectParamsSchema = external_exports.object({
+  threadId: hostThreadIdSchema,
+  thinkingOptionId: harnessThinkingOptionIdSchema
 }).strict();
-var threadCommandExecuteParamsSchema = external_exports.object({
+var threadInspectionParamsSchema = external_exports.object({
   threadId: hostThreadIdSchema,
-  commandId: commandIdSchema,
-  turnId: hostTurnIdSchema.optional(),
-  arguments: jsonObjectSchema.optional()
+  includeReferenceCapability: external_exports.boolean().optional()
 }).strict();
-var threadCommandExecuteResultSchema = external_exports.object({
-  accepted: external_exports.literal(true),
-  turnId: hostTurnIdSchema
+var codexThreadInspectionSchema = external_exports.object({
+  owner: external_exports.literal("codex"),
+  locked: external_exports.literal(true),
+  supportsThreadReferences: external_exports.literal(true).optional()
 }).strict();
-
-// ../../shared-contracts/dist/json-rpc.js
-var jsonRpcVersionSchema = external_exports.literal("2.0").optional();
-var absentSchema = external_exports.never().optional();
-var methodSchema = external_exports.string().min(1);
-var jsonRpcIdSchema = external_exports.union([external_exports.string(), external_exports.number().int()]);
-var jsonRpcErrorSchema = external_exports.object({
-  code: external_exports.number().int(),
-  message: external_exports.string(),
-  data: jsonValueSchema.optional()
-}).catchall(jsonValueSchema).superRefine(rejectExplicitUndefined(["data"]));
-var jsonRpcRequestSchema = external_exports.object({
-  jsonrpc: jsonRpcVersionSchema,
-  id: jsonRpcIdSchema,
-  method: methodSchema,
-  params: jsonValueSchema.optional(),
-  result: absentSchema,
-  error: absentSchema
-}).catchall(jsonValueSchema).superRefine(rejectExplicitUndefined(["jsonrpc", "params", "result", "error"]));
-var jsonRpcNotificationSchema = external_exports.object({
-  jsonrpc: jsonRpcVersionSchema,
-  id: absentSchema,
-  method: methodSchema,
-  params: jsonValueSchema.optional(),
-  result: absentSchema,
-  error: absentSchema
-}).catchall(jsonValueSchema).superRefine(rejectExplicitUndefined(["jsonrpc", "id", "params", "result", "error"]));
-var jsonRpcSuccessResponseSchema = external_exports.object({
-  jsonrpc: jsonRpcVersionSchema,
-  id: jsonRpcIdSchema,
-  method: absentSchema,
-  params: absentSchema,
-  result: jsonValueSchema,
-  error: absentSchema
-}).catchall(jsonValueSchema).superRefine(rejectExplicitUndefined(["jsonrpc", "method", "params", "error"]));
-var jsonRpcErrorResponseSchema = external_exports.object({
-  jsonrpc: jsonRpcVersionSchema,
-  id: jsonRpcIdSchema,
-  method: absentSchema,
-  params: absentSchema,
-  result: absentSchema,
-  error: jsonRpcErrorSchema
-}).catchall(jsonValueSchema).superRefine(rejectExplicitUndefined(["jsonrpc", "method", "params", "result"]));
-var jsonRpcEnvelopeSchema = external_exports.union([
-  jsonRpcRequestSchema,
-  jsonRpcNotificationSchema,
-  jsonRpcSuccessResponseSchema,
-  jsonRpcErrorResponseSchema
-]);
-
-// ../../shared-contracts/dist/native-refs.js
-var nativeIdSchema = external_exports.string().refine((value) => value.trim().length > 0, {
-  message: "Native identifier must not be empty or whitespace"
-});
-var nativeSessionRefV1RuntimeSchema = external_exports.strictObject({
-  harnessId: harnessIdSchema,
-  nativeSessionId: nativeIdSchema,
-  locator: jsonValueSchema.optional(),
-  formatVersion: external_exports.literal(1)
-}).superRefine(rejectExplicitUndefined(["locator"]));
-var nativeSessionRefV1Schema = nativeSessionRefV1RuntimeSchema;
-var nativeSessionRefSchema = nativeSessionRefV1Schema;
-var nativeTurnRefV1Schema = external_exports.strictObject({
-  harnessId: harnessIdSchema,
-  nativeSessionId: nativeIdSchema,
-  nativeTurnKey: nativeIdSchema,
-  formatVersion: external_exports.literal(1)
-});
-var nativeTurnRefSchema = nativeTurnRefV1Schema;
-var nativeCheckpointRefV1RuntimeSchema = external_exports.strictObject({
-  harnessId: harnessIdSchema,
-  nativeSessionId: nativeIdSchema,
-  checkpointId: nativeIdSchema,
-  locator: jsonValueSchema.optional(),
-  formatVersion: external_exports.literal(1)
-}).superRefine(rejectExplicitUndefined(["locator"]));
-var nativeCheckpointRefV1Schema = nativeCheckpointRefV1RuntimeSchema;
-var nativeCheckpointRefSchema = nativeCheckpointRefV1Schema;
-
-// ../../shared-contracts/dist/updates.js
-var UPDATE_ERROR_MAX_LENGTH = 500;
-var UPDATE_SEMVER_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u;
-var updateSemanticVersionSchema = external_exports.string().regex(UPDATE_SEMVER_PATTERN);
-var updateInstallationSchema = external_exports.enum(["npm", "windows-installer", "macos-dmg"]);
-var updatePhaseSchema = external_exports.enum([
-  "prepared",
-  "downloading",
-  "waiting-for-exit",
-  "installing",
-  "restarting",
-  "succeeded",
-  "failed"
-]);
-var updateStatusSchema = external_exports.strictObject({
-  version: updateSemanticVersionSchema,
-  installation: updateInstallationSchema,
-  phase: updatePhaseSchema,
-  updatedAt: external_exports.number().int().nonnegative(),
-  downloadedBytes: external_exports.number().int().nonnegative().optional(),
-  totalBytes: external_exports.number().int().positive().optional(),
-  error: external_exports.string().min(1).max(UPDATE_ERROR_MAX_LENGTH).nullable()
-}).superRefine((status, context) => {
-  if (status.downloadedBytes !== void 0 && status.totalBytes !== void 0 && status.downloadedBytes > status.totalBytes) {
-    context.addIssue({
-      code: "custom",
-      path: ["downloadedBytes"],
-      message: "downloadedBytes must not exceed totalBytes"
-    });
+var externalThreadInspectionSchema = external_exports.object({
+  owner: external_exports.literal("external"),
+  harnessId: nonBlankTextSchema2.max(256),
+  transportModelId: nonBlankTextSchema2.max(1024),
+  effectiveModel: harnessModelRefSchema.optional(),
+  resolvedModelLabel: harnessResolvedModelLabelSchema.optional(),
+  effectiveThinkingOptionId: harnessThinkingOptionIdSchema.optional(),
+  availableThinkingOptions: harnessThinkingOptionsSchema.optional(),
+  effectivePermissionModeId: harnessPermissionModeIdSchema.optional(),
+  history: harnessHistoryCapabilitiesSchema,
+  usage: threadUsageSnapshotSchema.optional(),
+  locked: external_exports.literal(true)
+}).strict();
+var threadInspectionSchema = external_exports.discriminatedUnion("owner", [
+  codexThreadInspectionSchema,
+  externalThreadInspectionSchema
+]);
+var threadOwnershipListParamsSchema = external_exports.object({
+  threadIds: external_exports.array(hostThreadIdSchema).min(1).max(THREAD_OWNERSHIP_LIST_MAX_LENGTH)
+}).strict().superRefine(({ threadIds }, context) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, threadId] of threadIds.entries()) {
+    if (seen.has(threadId)) {
+      context.addIssue({
+        code: "custom",
+        message: "Thread ownership-list IDs must be unique",
+        path: ["threadIds", index]
+      });
+    }
+    seen.add(threadId);
   }
 });
-var updateEmptyParamsSchema = external_exports.strictObject({});
-var githubReleaseNotesUrlSchema = external_exports.string().max(300).regex(/^https:\/\/github\.com\/BytePioneer-AI\/codex-host\/releases\/tag\/v[0-9A-Za-z.+-]+$/u, "release notes URL must identify a codexhost GitHub Release");
-var updateCheckResultSchema = external_exports.strictObject({
-  currentVersion: updateSemanticVersionSchema,
-  installation: updateInstallationSchema.nullable(),
-  latestVersion: updateSemanticVersionSchema.nullable(),
-  updateAvailable: external_exports.boolean(),
-  installationAvailable: external_exports.boolean(),
-  releaseNotes: external_exports.string().min(1).max(2e4).nullable(),
-  releaseNotesUrl: githubReleaseNotesUrlSchema.nullable(),
-  status: updateStatusSchema.nullable(),
-  error: external_exports.string().min(1).max(UPDATE_ERROR_MAX_LENGTH).nullable()
-});
-var updateStartResultSchema = external_exports.strictObject({
-  status: updateStatusSchema
+var codexThreadOwnershipSchema = external_exports.object({
+  threadId: hostThreadIdSchema,
+  owner: external_exports.literal("codex")
+}).strict();
+var externalThreadOwnershipSchema = external_exports.object({
+  threadId: hostThreadIdSchema,
+  owner: external_exports.literal("external"),
+  harnessId: external_exports.string().max(256).pipe(harnessIdSchema)
+}).strict();
+var threadOwnershipSchema = external_exports.discriminatedUnion("owner", [
+  codexThreadOwnershipSchema,
+  externalThreadOwnershipSchema
+]);
+var threadOwnershipListResultSchema = external_exports.object({
+  threads: external_exports.array(threadOwnershipSchema).min(1).max(THREAD_OWNERSHIP_LIST_MAX_LENGTH)
+}).strict().superRefine(({ threads }, context) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, thread] of threads.entries()) {
+    if (seen.has(thread.threadId)) {
+      context.addIssue({
+        code: "custom",
+        message: "Thread ownership-list results must be unique",
+        path: ["threads", index, "threadId"]
+      });
+    }
+    seen.add(thread.threadId);
+  }
 });
-var updateStatusResultSchema = external_exports.strictObject({
-  status: updateStatusSchema.nullable()
+
+// ../../shared-contracts/dist/harness-plugins.js
+var HARNESS_PLUGIN_MANIFEST_MAX_BYTES = 32 * 1024;
+var HARNESS_PLUGIN_ICON_MAX_BYTES = 128 * 1024;
+var HARNESS_PLUGIN_LIMIT = 128;
+var harnessPluginIdSchema = external_exports.string().min(1).max(128).regex(/^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/u).refine((id) => id !== "codex", "The official Codex identity is reserved").pipe(harnessIdSchema);
+var relativeResourceSchema = external_exports.string().min(1).max(512).refine((value) => !/[\\\u0000:#?]/u.test(value) && !value.startsWith("/") && !value.split("/").some((part) => part === ".." || part === ""), "Plugin resources must be relative paths inside the plugin");
+var documentationUrlSchema = external_exports.url().refine((value) => /^https:\/\/[^/?#@]+(?:[/?#]|$)/iu.test(value), "Plugin documentation links must be credential-free HTTPS URLs");
+var pluginPresentationShape = {
+  id: harnessPluginIdSchema,
+  name: external_exports.string().trim().min(1).max(128),
+  version: external_exports.string().min(1).max(128),
+  /** The factory accepts a persisted local entrypoint through its construction context. */
+  launchCommand: external_exports.literal(true).optional(),
+  links: external_exports.object({
+    documentation: documentationUrlSchema.optional(),
+    installation: documentationUrlSchema.optional()
+  }).strict().optional()
+};
+var harnessPluginManifestSchema = external_exports.object({
+  manifestVersion: external_exports.literal(1),
+  ...pluginPresentationShape,
+  adapterApiVersion: external_exports.number().int().positive(),
+  entry: relativeResourceSchema,
+  icon: relativeResourceSchema.optional()
+}).strict();
+var harnessPluginIconSchema = external_exports.string().max(Math.ceil(HARNESS_PLUGIN_ICON_MAX_BYTES / 3) * 4 + 64).regex(/^data:image\/(?:png|jpeg|webp|svg\+xml);base64,[A-Za-z0-9+/]+={0,2}$/u);
+var harnessPluginDescriptorSchema = external_exports.object({
+  ...pluginPresentationShape,
+  icon: harnessPluginIconSchema.optional()
+}).strict();
+var harnessPluginListParamsSchema = external_exports.object({}).strict();
+var harnessPluginListResultSchema = external_exports.object({
+  plugins: external_exports.array(harnessPluginDescriptorSchema).max(HARNESS_PLUGIN_LIMIT)
+}).strict();
+var harnessPluginConfigurationSchema = external_exports.object({
+  version: external_exports.literal(1),
+  enabled: external_exports.array(harnessPluginIdSchema).max(HARNESS_PLUGIN_LIMIT)
+}).strict().refine((value) => new Set(value.enabled).size === value.enabled.length, {
+  message: "Enabled plugin IDs must be unique",
+  path: ["enabled"]
 });
 
-// ../../shared-contracts/dist/index.js
-var workspaceContractVersionSchema = external_exports.literal(WORKSPACE_CONTRACT_VERSION);
+// ../../shared-contracts/dist/harness-route.js
+var harnessPluginRouteSchema = external_exports.object({
+  harnessId: harnessPluginIdSchema,
+  model: harnessModelRefSchema.optional(),
+  thinkingOptionId: harnessThinkingOptionIdSchema.optional(),
+  permissionModeId: harnessPermissionModeIdSchema.optional()
+}).strict();
 
-// ../../harness-adapter/dist/question.js
-function invalidRequest(message) {
-  return { code: "invalidRequest", message, retryable: false };
-}
-function validateHostQuestionResponse(interaction, response) {
-  const questionIds = new Set(interaction.questions.map(({ id }) => id));
-  if (response.cancelled) {
-    return Object.keys(response.answers).length === 0 ? null : invalidRequest("Cancelled Question Response must not contain answers");
-  }
-  for (const answerId of Object.keys(response.answers)) {
-    if (!questionIds.has(answerId)) {
-      return invalidRequest("Question Response contains an unknown Question ID");
-    }
-  }
-  for (const question of interaction.questions) {
-    const answers = response.answers[question.id] ?? [];
-    if (!question.optional && answers.length === 0) {
-      return invalidRequest("Question Response omits a required answer");
-    }
-    if (question.type === "text") {
-      if (answers.length > 1) {
-        return invalidRequest("Text Question accepts at most one answer");
-      }
-      continue;
-    }
-    if (!question.multiple && answers.length > 1) {
-      return invalidRequest("Single-choice Question accepts at most one answer");
-    }
-    const declared = new Set(question.options.map(({ value }) => value));
-    if (!question.allowOther && answers.some((answer) => !declared.has(answer))) {
-      return invalidRequest("Question Response contains an undeclared choice");
-    }
-  }
-  return null;
-}
+// ../../shared-contracts/dist/harness-launch-settings.js
+var harnessLaunchPathSchema = external_exports.string().trim().min(1).max(4096).refine((value) => !/[\u0000\r\n]/u.test(value), "Invalid entrypoint path");
+var harnessLaunchSettingsGetSchema = external_exports.object({
+  harnessId: harnessPluginIdSchema
+}).strict();
+var harnessLaunchSettingsSetSchema = harnessLaunchSettingsGetSchema.extend({
+  path: harnessLaunchPathSchema.nullable()
+});
+var harnessLaunchSettingsSchema = external_exports.object({
+  path: harnessLaunchPathSchema.nullable(),
+  restartRequired: external_exports.boolean()
+}).strict();
 
-// ../../harness-adapter/dist/output-channel.js
-var HarnessOutputChannel = class {
-  outputs;
-  #consumerCreated = false;
-  #ended = false;
-  #pending = [];
-  #values = [];
-  constructor() {
-    this.outputs = {
-      [Symbol.asyncIterator]: () => {
-        if (this.#consumerCreated) {
-          throw new Error("Harness outputs allow only one consumer");
-        }
-        this.#consumerCreated = true;
-        return {
-          next: () => this.#next()
-        };
-      }
-    };
-  }
-  emit(value) {
-    if (this.#ended)
-      return false;
-    const resolve = this.#pending.shift();
-    if (resolve)
-      resolve({ done: false, value });
-    else
-      this.#values.push(value);
-    return true;
-  }
-  end() {
-    if (this.#ended)
-      return;
-    this.#ended = true;
-    if (this.#values.length !== 0)
-      return;
-    for (const resolve of this.#pending.splice(0))
-      resolve({ done: true, value: void 0 });
-  }
-  #next() {
-    const value = this.#values.shift();
-    if (value !== void 0)
-      return Promise.resolve({ done: false, value });
-    if (this.#ended)
-      return Promise.resolve({ done: true, value: void 0 });
-    return new Promise((resolve) => this.#pending.push(resolve));
-  }
-};
+// ../../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);
+var codexAccountPlanTypeSchema = external_exports.enum([
+  "free",
+  "go",
+  "plus",
+  "pro",
+  "prolite",
+  "team",
+  "self_serve_business_prolite",
+  "self_serve_business_usage_based",
+  "business",
+  "ent26",
+  "enterprise_cbp_automation",
+  "enterprise_cbp_usage_based",
+  "enterprise",
+  "edu",
+  "edu_plus",
+  "edu_pro",
+  "unknown"
+]);
+var codexAccountSchema = external_exports.object({
+  accountId: accountIdSchema,
+  label: nonBlankTextSchema3.max(256),
+  email: external_exports.string().email().max(320).optional(),
+  planType: codexAccountPlanTypeSchema.optional()
+}).strict();
+var codexAccountPhaseSchema = external_exports.enum(["ready", "unavailable"]);
+var codexAccountListResultSchema = external_exports.object({
+  version: external_exports.literal(2),
+  currentAccountId: accountIdSchema.nullable(),
+  phase: codexAccountPhaseSchema,
+  revision: external_exports.number().int().nonnegative(),
+  instanceId: nonBlankTextSchema3.max(1024).optional(),
+  accounts: external_exports.array(codexAccountSchema).max(1)
+}).strict();
+var codexAccountUsageParamsSchema = external_exports.object({ accountId: accountIdSchema, refresh: external_exports.boolean().optional() }).strict();
+var codexAccountUsageResultSchema = external_exports.object({
+  accountId: accountIdSchema,
+  usage: threadUsageSnapshotSchema.nullable(),
+  accountCredits: accountCreditsSnapshotSchema.optional(),
+  freshness: external_exports.enum(["live", "cached"]),
+  observedAt: external_exports.string().datetime().nullable()
+}).strict();
 
-// ../../harness-adapter/dist/diagnostics.js
-var DIAGNOSTIC_TAIL_MAX_LENGTH = 8e3;
-var SENSITIVE_VALUE_PATTERN = /(api[_-]?key|access[_-]?token|auth(?:orization)?|password|secret)(\s*[:=]\s*)([^\s,;]+)/giu;
-var BEARER_PATTERN = /\bBearer\s+[A-Za-z0-9._~+/=-]+/giu;
-function sanitizeDiagnosticTail(value) {
-  const redacted = value.replace(BEARER_PATTERN, "Bearer [redacted]").replace(SENSITIVE_VALUE_PATTERN, "$1$2[redacted]");
-  return redacted.length <= DIAGNOSTIC_TAIL_MAX_LENGTH ? redacted : redacted.slice(-DIAGNOSTIC_TAIL_MAX_LENGTH);
-}
+// ../../shared-contracts/dist/harness-session-import.js
+var HARNESS_SESSION_IMPORT_ID_MAX_LENGTH = 1024;
+var HARNESS_SESSION_IMPORT_CWD_MAX_LENGTH = 16384;
+var HARNESS_SESSION_IMPORT_TITLE_MAX_LENGTH = 4096;
+var HARNESS_SESSION_IMPORT_LIST_MAX_LENGTH = 1e3;
+var HARNESS_SESSION_IMPORT_UPDATED_AT_MAX = 864e13;
+var nonBlankTextSchema4 = external_exports.string().refine((value) => value.trim().length > 0, "Value must not be empty or whitespace").refine((value) => !value.includes("\0"), "Value must not contain NUL");
+var harnessSessionImportIdSchema = nonBlankTextSchema4.max(HARNESS_SESSION_IMPORT_ID_MAX_LENGTH);
+var harnessSessionImportCandidateSchema = external_exports.object({
+  nativeSessionId: harnessSessionImportIdSchema,
+  title: nonBlankTextSchema4.max(HARNESS_SESSION_IMPORT_TITLE_MAX_LENGTH).nullable(),
+  updatedAt: external_exports.number().int().nonnegative().max(HARNESS_SESSION_IMPORT_UPDATED_AT_MAX),
+  cwd: nonBlankTextSchema4.max(HARNESS_SESSION_IMPORT_CWD_MAX_LENGTH),
+  // Native file discovery cannot reliably observe another process's activity.
+  running: external_exports.boolean().nullable()
+}).strict();
+var harnessSessionImportSourcesParamsSchema = external_exports.object({}).strict();
+var harnessSessionImportSourcesResultSchema = external_exports.object({
+  harnesses: external_exports.array(external_exports.object({
+    harnessId: harnessPluginIdSchema,
+    name: nonBlankTextSchema4.max(128)
+  }).strict()).max(128)
+}).strict();
+var harnessSessionListParamsSchema = external_exports.object({
+  harnessId: harnessPluginIdSchema,
+  query: external_exports.string().trim().max(4096).refine((value) => !value.includes("\0")).optional(),
+  offset: external_exports.number().int().nonnegative().safe().optional(),
+  limit: external_exports.number().int().min(1).max(HARNESS_SESSION_IMPORT_LIST_MAX_LENGTH).optional()
+}).strict();
+var harnessSessionListResultSchema = external_exports.object({
+  candidates: external_exports.array(harnessSessionImportCandidateSchema).max(HARNESS_SESSION_IMPORT_LIST_MAX_LENGTH),
+  total: external_exports.number().int().nonnegative().safe()
+}).strict();
+var harnessSessionImportParamsSchema = external_exports.object({
+  harnessId: harnessPluginIdSchema,
+  nativeSessionId: harnessSessionImportIdSchema
+}).strict();
+var harnessSessionImportResultSchema = external_exports.object({
+  threadId: nonBlankTextSchema4.max(1024).pipe(hostThreadIdSchema)
+}).strict();
 
-// ../../harness-adapter/dist/usage.js
-var tokenFields = [
-  "inputTokens",
-  "cachedInputTokens",
-  "cacheWriteInputTokens",
-  "outputTokens",
-  "outputTokensPerSecond",
-  "reasoningOutputTokens",
-  "totalTokens",
-  "contextWindowTokens",
-  "contextUsedTokens"
-];
-var safeIntegerFields = [
-  "planFiveHourResetsAtUnix",
-  "planSevenDayResetsAtUnix"
-];
-var percentFields = [
-  "cacheHitRatePercent",
-  "planFiveHourUsedPercent",
-  "planSevenDayUsedPercent"
-];
-var usageFields = /* @__PURE__ */ new Set([
-  ...tokenFields,
-  ...safeIntegerFields,
-  ...percentFields,
-  "totalCostUsd",
-  "totalCredits",
-  "contextUsagePercent"
-]);
+// ../../shared-contracts/dist/deepseek-modern-sessions.js
+var DEEPSEEK_MODERN_SESSION_LIST_MAX_LENGTH = HARNESS_SESSION_IMPORT_LIST_MAX_LENGTH;
+var DEEPSEEK_MODERN_HOST_THREAD_ID_MAX_LENGTH = 1024;
+var nonBlankTextSchema5 = external_exports.string().refine((value) => value.trim().length > 0, "Value must not be empty or whitespace").refine((value) => !value.includes("\0"), "Value must not contain NUL");
+var deepSeekModernSessionIdSchema = harnessSessionImportIdSchema;
+var deepSeekModernSessionCandidateSchema = harnessSessionImportCandidateSchema;
+var deepSeekModernSessionListParamsSchema = external_exports.object({}).strict();
+var deepSeekModernSessionListResultSchema = external_exports.object({
+  candidates: external_exports.array(deepSeekModernSessionCandidateSchema).max(DEEPSEEK_MODERN_SESSION_LIST_MAX_LENGTH)
+}).strict();
+var deepSeekModernSessionImportParamsSchema = external_exports.object({
+  nativeSessionId: deepSeekModernSessionIdSchema
+}).strict();
+var deepSeekModernSessionImportResultSchema = external_exports.object({
+  threadId: nonBlankTextSchema5.max(DEEPSEEK_MODERN_HOST_THREAD_ID_MAX_LENGTH).pipe(hostThreadIdSchema)
+}).strict();
 
-// ../../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 [];
+// ../../shared-contracts/dist/external-thread-fork.js
+var externalThreadForkParamsSchema = external_exports.object({
+  threadId: hostThreadIdSchema,
+  lastTurnId: hostTurnIdSchema
+}).strict();
+var externalThreadForkResultSchema = external_exports.object({
+  threadId: hostThreadIdSchema
+}).strict();
+
+// ../../shared-contracts/dist/harness-commands.js
+var commandIdSchema = external_exports.string().trim().min(1).max(128).regex(/^[A-Za-z0-9._:-]+$/u).brand();
+var commandInvocationSchema = external_exports.string().min(1).max(128);
+var commandLabelSchema = external_exports.string().trim().min(1).max(128);
+var commandDescriptionSchema = external_exports.string().trim().min(1).max(512);
+var harnessCommandDescriptorSchema = external_exports.object({
+  id: commandIdSchema,
+  invocation: commandInvocationSchema,
+  label: commandLabelSchema,
+  description: commandDescriptionSchema.optional(),
+  argumentMode: external_exports.enum(["none", "text"]),
+  /**
+   * Native distinction reported by the Harness. Omitted when the Harness does
+   * not tell skills and commands apart; consumers treat that as "command".
+   */
+  kind: external_exports.enum(["command", "skill"]).optional()
+}).strict();
+var harnessCommandCatalogSchema = external_exports.object({
+  commands: external_exports.array(harnessCommandDescriptorSchema),
+  /**
+   * `live` when the catalog includes what a native Session reports for its
+   * workspace (custom commands, skills); `static` for Adapter built-ins only.
+   * Omitted by Adapters; set by the Host on inspection results.
+   */
+  source: external_exports.enum(["live", "static"]).optional()
+}).strict().superRefine((catalog, context) => {
+  const ids = /* @__PURE__ */ new Set();
+  for (const [index, command] of catalog.commands.entries()) {
+    if (ids.has(command.id)) {
+      context.addIssue({
+        code: "custom",
+        message: "Harness command IDs must be unique",
+        path: ["commands", index, "id"]
+      });
+    }
+    ids.add(command.id);
   }
-}
-function newestFirst(names) {
-  return [...names].sort((left, right) => right.localeCompare(left, void 0, { numeric: true }));
-}
+});
+var harnessCommandsInspectParamsSchema = external_exports.object({
+  harnessId: harnessIdSchema,
+  /** Workspace of a draft without a Thread, for its live catalog when known. */
+  cwd: external_exports.string().min(1).optional()
+}).strict();
+var threadCommandsInspectParamsSchema = external_exports.object({
+  threadId: hostThreadIdSchema
+}).strict();
+var threadCommandExecuteParamsSchema = external_exports.object({
+  threadId: hostThreadIdSchema,
+  commandId: commandIdSchema,
+  turnId: hostTurnIdSchema.optional(),
+  arguments: jsonObjectSchema.optional()
+}).strict();
+var threadCommandExecuteResultSchema = external_exports.object({
+  accepted: external_exports.literal(true),
+  turnId: hostTurnIdSchema
+}).strict();
+
+// ../../shared-contracts/dist/json-rpc.js
+var jsonRpcVersionSchema = external_exports.literal("2.0").optional();
+var absentSchema = external_exports.never().optional();
+var methodSchema = external_exports.string().min(1);
+var jsonRpcIdSchema = external_exports.union([external_exports.string(), external_exports.number().int()]);
+var jsonRpcErrorSchema = external_exports.object({
+  code: external_exports.number().int(),
+  message: external_exports.string(),
+  data: jsonValueSchema.optional()
+}).catchall(jsonValueSchema).superRefine(rejectExplicitUndefined(["data"]));
+var jsonRpcRequestSchema = external_exports.object({
+  jsonrpc: jsonRpcVersionSchema,
+  id: jsonRpcIdSchema,
+  method: methodSchema,
+  params: jsonValueSchema.optional(),
+  result: absentSchema,
+  error: absentSchema
+}).catchall(jsonValueSchema).superRefine(rejectExplicitUndefined(["jsonrpc", "params", "result", "error"]));
+var jsonRpcNotificationSchema = external_exports.object({
+  jsonrpc: jsonRpcVersionSchema,
+  id: absentSchema,
+  method: methodSchema,
+  params: jsonValueSchema.optional(),
+  result: absentSchema,
+  error: absentSchema
+}).catchall(jsonValueSchema).superRefine(rejectExplicitUndefined(["jsonrpc", "id", "params", "result", "error"]));
+var jsonRpcSuccessResponseSchema = external_exports.object({
+  jsonrpc: jsonRpcVersionSchema,
+  id: jsonRpcIdSchema,
+  method: absentSchema,
+  params: absentSchema,
+  result: jsonValueSchema,
+  error: absentSchema
+}).catchall(jsonValueSchema).superRefine(rejectExplicitUndefined(["jsonrpc", "method", "params", "error"]));
+var jsonRpcErrorResponseSchema = external_exports.object({
+  jsonrpc: jsonRpcVersionSchema,
+  id: jsonRpcIdSchema,
+  method: absentSchema,
+  params: absentSchema,
+  result: absentSchema,
+  error: jsonRpcErrorSchema
+}).catchall(jsonValueSchema).superRefine(rejectExplicitUndefined(["jsonrpc", "method", "params", "result"]));
+var jsonRpcEnvelopeSchema = external_exports.union([
+  jsonRpcRequestSchema,
+  jsonRpcNotificationSchema,
+  jsonRpcSuccessResponseSchema,
+  jsonRpcErrorResponseSchema
+]);
 
-// ../../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
-  };
-}
+// ../../shared-contracts/dist/native-refs.js
+var nativeIdSchema = external_exports.string().refine((value) => value.trim().length > 0, {
+  message: "Native identifier must not be empty or whitespace"
+});
+var nativeSessionRefV1RuntimeSchema = external_exports.strictObject({
+  harnessId: harnessIdSchema,
+  nativeSessionId: nativeIdSchema,
+  locator: jsonValueSchema.optional(),
+  formatVersion: external_exports.literal(1)
+}).superRefine(rejectExplicitUndefined(["locator"]));
+var nativeSessionRefV1Schema = nativeSessionRefV1RuntimeSchema;
+var nativeSessionRefSchema = nativeSessionRefV1Schema;
+var nativeTurnRefV1Schema = external_exports.strictObject({
+  harnessId: harnessIdSchema,
+  nativeSessionId: nativeIdSchema,
+  nativeTurnKey: nativeIdSchema,
+  formatVersion: external_exports.literal(1)
+});
+var nativeTurnRefSchema = nativeTurnRefV1Schema;
+var nativeCheckpointRefV1RuntimeSchema = external_exports.strictObject({
+  harnessId: harnessIdSchema,
+  nativeSessionId: nativeIdSchema,
+  checkpointId: nativeIdSchema,
+  locator: jsonValueSchema.optional(),
+  formatVersion: external_exports.literal(1)
+}).superRefine(rejectExplicitUndefined(["locator"]));
+var nativeCheckpointRefV1Schema = nativeCheckpointRefV1RuntimeSchema;
+var nativeCheckpointRefSchema = nativeCheckpointRefV1Schema;
 
-// ../../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);
+// ../../shared-contracts/dist/updates.js
+var UPDATE_ERROR_MAX_LENGTH = 500;
+var UPDATE_SEMVER_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u;
+var updateSemanticVersionSchema = external_exports.string().regex(UPDATE_SEMVER_PATTERN);
+var updateInstallationSchema = external_exports.enum(["npm", "windows-installer", "macos-dmg"]);
+var updatePhaseSchema = external_exports.enum([
+  "prepared",
+  "downloading",
+  "waiting-for-exit",
+  "installing",
+  "restarting",
+  "succeeded",
+  "failed"
+]);
+var updateStatusSchema = external_exports.strictObject({
+  version: updateSemanticVersionSchema,
+  installation: updateInstallationSchema,
+  phase: updatePhaseSchema,
+  updatedAt: external_exports.number().int().nonnegative(),
+  downloadedBytes: external_exports.number().int().nonnegative().optional(),
+  totalBytes: external_exports.number().int().positive().optional(),
+  error: external_exports.string().min(1).max(UPDATE_ERROR_MAX_LENGTH).nullable()
+}).superRefine((status, context) => {
+  if (status.downloadedBytes !== void 0 && status.totalBytes !== void 0 && status.downloadedBytes > status.totalBytes) {
+    context.addIssue({
+      code: "custom",
+      path: ["downloadedBytes"],
+      message: "downloadedBytes must not exceed totalBytes"
+    });
   }
-  return { ...environment, [pathKey]: directories.join(delimiter) };
-}
+});
+var updateEmptyParamsSchema = external_exports.strictObject({});
+var githubReleaseNotesUrlSchema = external_exports.string().max(300).regex(/^https:\/\/github\.com\/BytePioneer-AI\/codex-host\/releases\/tag\/v[0-9A-Za-z.+-]+$/u, "release notes URL must identify a codexhost GitHub Release");
+var updateCheckResultSchema = external_exports.strictObject({
+  currentVersion: updateSemanticVersionSchema,
+  installation: updateInstallationSchema.nullable(),
+  latestVersion: updateSemanticVersionSchema.nullable(),
+  updateAvailable: external_exports.boolean(),
+  installationAvailable: external_exports.boolean(),
+  releaseNotes: external_exports.string().min(1).max(2e4).nullable(),
+  releaseNotesUrl: githubReleaseNotesUrlSchema.nullable(),
+  status: updateStatusSchema.nullable(),
+  error: external_exports.string().min(1).max(UPDATE_ERROR_MAX_LENGTH).nullable()
+});
+var updateStartResultSchema = external_exports.strictObject({
+  status: updateStatusSchema
+});
+var updateStatusResultSchema = external_exports.strictObject({
+  status: updateStatusSchema.nullable()
+});
 
-// ../../harness-discovery/dist/resolve.js
-import os from "node:os";
+// ../../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", "uninstall"]),
+  uninstallPackage: external_exports.boolean().optional(),
+  version: external_exports.string().regex(/^\d+\.\d+\.\d+$/u).nullable()
+}).strict();
+var remoteSshSetupResultSchema = external_exports.object({ state: external_exports.enum(["installed", "not-installed"]) }).strict();
 
-// ../../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;
-}
+// ../../shared-contracts/dist/remote-connections.js
+var hostId = external_exports.string().min(1).max(1024);
+var codexSshConnectionSchema = external_exports.object({
+  hostId,
+  displayName: external_exports.string().min(1).max(1024),
+  source: external_exports.enum(["codex-managed", "discovered"]),
+  sshAlias: external_exports.string().max(1024).nullable(),
+  sshHost: external_exports.string().min(1).max(1024),
+  sshPort: external_exports.number().int().min(1).max(65535).nullable(),
+  identity: external_exports.string().max(4096).nullable(),
+  autoConnect: external_exports.boolean(),
+  connectionAnalyticsId: external_exports.string().max(1024).optional()
+});
+var codexSshDraftSchema = external_exports.strictObject({
+  displayName: external_exports.string().min(1).max(1024),
+  hostname: external_exports.string().min(1).max(1024),
+  sshPort: external_exports.number().int().min(1).max(65535).nullable(),
+  identity: external_exports.string().max(4096).nullable()
+});
+var remoteConnectionsRequestSchema = external_exports.discriminatedUnion("action", [
+  external_exports.strictObject({ action: external_exports.literal("list") }),
+  external_exports.strictObject({
+    action: external_exports.literal("save"),
+    draft: codexSshDraftSchema,
+    previous: codexSshConnectionSchema.nullable()
+  }),
+  external_exports.strictObject({ action: external_exports.literal("remove"), previous: codexSshConnectionSchema }),
+  external_exports.strictObject({ action: external_exports.literal("connect"), hostId, enabled: external_exports.boolean() }),
+  external_exports.strictObject({ action: external_exports.literal("state"), hostId }),
+  external_exports.strictObject({ action: external_exports.literal("runtime"), hostId }),
+  external_exports.strictObject({
+    action: external_exports.literal("update"),
+    hostId: hostId.refine((id) => id !== "local"),
+    version: remoteUpdateParamsSchema.shape.version
+  })
+]);
+var remoteConnectionsReplySchema = external_exports.union([
+  external_exports.strictObject({ result: jsonValueSchema }),
+  external_exports.strictObject({ error: external_exports.strictObject({ code: external_exports.number().int(), message: external_exports.string() }) })
+]);
 
-// ../../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" }];
+// ../../shared-contracts/dist/index.js
+var workspaceContractVersionSchema = external_exports.literal(WORKSPACE_CONTRACT_VERSION);
+
+// ../../harness-adapter/dist/question.js
+function invalidRequest(message) {
+  return { code: "invalidRequest", message, retryable: false };
+}
+function validateHostQuestionResponse(interaction, response) {
+  const questionIds = new Set(interaction.questions.map(({ id }) => id));
+  if (response.cancelled) {
+    return Object.keys(response.answers).length === 0 ? null : invalidRequest("Cancelled Question Response must not contain answers");
   }
-  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"
-      });
+  for (const answerId of Object.keys(response.answers)) {
+    if (!questionIds.has(answerId)) {
+      return invalidRequest("Question Response contains an unknown Question ID");
     }
   }
-  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"
-      });
+  for (const question of interaction.questions) {
+    const answers = response.answers[question.id] ?? [];
+    if (!question.optional && answers.length === 0) {
+      return invalidRequest("Question Response omits a required answer");
+    }
+    if (question.type === "text") {
+      if (answers.length > 1) {
+        return invalidRequest("Text Question accepts at most one answer");
+      }
+      continue;
+    }
+    if (!question.multiple && answers.length > 1) {
+      return invalidRequest("Single-choice Question accepts at most one answer");
+    }
+    const declared = new Set(question.options.map(({ value }) => value));
+    if (!question.allowOther && answers.some((answer) => !declared.has(answer))) {
+      return invalidRequest("Question Response contains an undeclared choice");
     }
   }
-  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;
+  return null;
 }
 
-// ../../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);
+// ../../harness-adapter/dist/output-channel.js
+var HarnessOutputChannel = class {
+  outputs;
+  #consumerCreated = false;
+  #ended = false;
+  #pending = [];
+  #values = [];
+  constructor() {
+    this.outputs = {
+      [Symbol.asyncIterator]: () => {
+        if (this.#consumerCreated) {
+          throw new Error("Harness outputs allow only one consumer");
+        }
+        this.#consumerCreated = true;
+        return {
+          next: () => this.#next()
+        };
+      }
+    };
   }
-  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;
+  emit(value) {
+    if (this.#ended)
+      return false;
+    const resolve = this.#pending.shift();
+    if (resolve)
+      resolve({ done: false, value });
+    else
+      this.#values.push(value);
+    return true;
   }
-  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();
+  end() {
+    if (this.#ended)
+      return;
+    this.#ended = true;
+    if (this.#values.length !== 0)
+      return;
+    for (const resolve of this.#pending.splice(0))
+      resolve({ done: true, value: void 0 });
+  }
+  #next() {
+    const value = this.#values.shift();
+    if (value !== void 0)
+      return Promise.resolve({ done: false, value });
+    if (this.#ended)
+      return Promise.resolve({ done: true, value: void 0 });
+    return new Promise((resolve) => this.#pending.push(resolve));
   }
+};
+
+// ../../harness-adapter/dist/diagnostics.js
+var DIAGNOSTIC_TAIL_MAX_LENGTH = 8e3;
+var SENSITIVE_VALUE_PATTERN = /(api[_-]?key|access[_-]?token|auth(?:orization)?|password|secret)(\s*[:=]\s*)([^\s,;]+)/giu;
+var BEARER_PATTERN = /\bBearer\s+[A-Za-z0-9._~+/=-]+/giu;
+function sanitizeDiagnosticTail(value) {
+  const redacted = value.replace(BEARER_PATTERN, "Bearer [redacted]").replace(SENSITIVE_VALUE_PATTERN, "$1$2[redacted]");
+  return redacted.length <= DIAGNOSTIC_TAIL_MAX_LENGTH ? redacted : redacted.slice(-DIAGNOSTIC_TAIL_MAX_LENGTH);
 }
 
+// ../../harness-adapter/dist/usage.js
+var tokenFields = [
+  "inputTokens",
+  "cachedInputTokens",
+  "cacheWriteInputTokens",
+  "outputTokens",
+  "outputTokensPerSecond",
+  "reasoningOutputTokens",
+  "totalTokens",
+  "contextWindowTokens",
+  "contextUsedTokens"
+];
+var safeIntegerFields = [
+  "planFiveHourResetsAtUnix",
+  "planSevenDayResetsAtUnix"
+];
+var percentFields = [
+  "cacheHitRatePercent",
+  "planFiveHourUsedPercent",
+  "planSevenDayUsedPercent"
+];
+var usageFields = /* @__PURE__ */ new Set([
+  ...tokenFields,
+  ...safeIntegerFields,
+  ...percentFields,
+  "totalCostUsd",
+  "totalCredits",
+  "contextUsagePercent"
+]);
+
 // dist/command.js
 import path4 from "node:path";
 var antigravityDiscoverySpec = {
@@ -16077,7 +16216,7 @@ import path6 from "node:path";
 
 // dist/history.js
 import { randomUUID } from "node:crypto";
-import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, rename, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
 import os2 from "node:os";
 import path5 from "node:path";
 var HISTORY_VERSION = 1;
@@ -16354,7 +16493,7 @@ var AntigravityHistory = class _AntigravityHistory {
       await mkdir(directory, { recursive: true, mode: 448 });
       const temporary = path5.join(directory, `.${path5.basename(file2)}.${randomUUID()}.tmp`);
       try {
-        await writeFile(temporary, `${JSON.stringify({
+        await writeFile2(temporary, `${JSON.stringify({
           formatVersion: HISTORY_VERSION,
           nativeSessionId,
           turns,
@@ -16364,7 +16503,7 @@ var AntigravityHistory = class _AntigravityHistory {
 `, { mode: 384 });
         await rename(temporary, file2);
       } finally {
-        await rm(temporary, { force: true }).catch(() => void 0);
+        await rm2(temporary, { force: true }).catch(() => void 0);
       }
     });
   }
@@ -17489,7 +17628,7 @@ async function fetchAntigravityQuota(run, now = /* @__PURE__ */ new Date()) {
 
 // dist/question-bridge.js
 import { randomBytes, randomUUID as randomUUID4, timingSafeEqual } from "node:crypto";
-import { mkdir as mkdir3, mkdtemp, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir3, mkdtemp as mkdtemp2, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
 import { createServer } from "node:http";
 import os4 from "node:os";
 import path8 from "node:path";
@@ -17617,7 +17756,7 @@ var AntigravityQuestionBridge = class _AntigravityQuestionBridge {
     this.#server.on("request", (request, response) => this.#receive(request, response));
   }
   static async create(options) {
-    const directory = await mkdtemp(path8.join(os4.tmpdir(), "codexhost-agy-question-"));
+    const directory = await mkdtemp2(path8.join(os4.tmpdir(), "codexhost-agy-question-"));
     const bridge = new _AntigravityQuestionBridge(directory, options);
     try {
       await new Promise((resolve, reject) => {
@@ -17634,12 +17773,12 @@ var AntigravityQuestionBridge = class _AntigravityQuestionBridge {
       bridge.environment.CODEXHOST_AGY_QUESTION_URL = `http://127.0.0.1:${address.port}/question`;
       const client = path8.join(directory, "question-hook.cjs");
       await mkdir3(path8.join(directory, ".agents"));
-      await writeFile2(client, ANTIGRAVITY_QUESTION_HOOK_CLIENT, "utf8");
+      await writeFile3(client, ANTIGRAVITY_QUESTION_HOOK_CLIENT, "utf8");
       const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
       bridge.environment.CODEXHOST_AGY_QUESTION_NODE = `"${process.execPath.replaceAll("\\", "/")}"`;
       bridge.environment.CODEXHOST_AGY_QUESTION_CLIENT = `"${client.replaceAll("\\", "/")}"`;
       const command = process.platform === "win32" ? "%CODEXHOST_AGY_QUESTION_NODE% %CODEXHOST_AGY_QUESTION_CLIENT%" : `${quote(process.execPath)} ${quote(client)}`;
-      await writeFile2(path8.join(directory, ".agents", "hooks.json"), JSON.stringify({
+      await writeFile3(path8.join(directory, ".agents", "hooks.json"), JSON.stringify({
         "codexhost-question-bridge": {
           PreToolUse: [
             {
@@ -17862,7 +18001,7 @@ var AntigravityQuestionBridge = class _AntigravityQuestionBridge {
         this.#server.close(() => resolve());
         this.#server.closeAllConnections();
       });
-      await rm2(this.directory, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
+      await rm3(this.directory, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
     })();
     return this.#disposal;
   }
@@ -18558,7 +18697,9 @@ function normalizedProcessError(detail, fallback, exposeDetail = false) {
   return {
     code: "nativeFailure",
     message: exposeDetail && nativeDetail ? `${fallback}: ${nativeDetail}` : fallback,
-    retryable: true,
+    // These native rejections need a changed precondition or a quota reset;
+    // immediately replaying a Turn (and its tools) cannot resolve them.
+    retryable: !/User location is not supported for the API use|Individual quota reached/iu.test(nativeDetail),
     ...diagnostic ? { stderrTail: diagnostic.slice(-4e3) } : {}
   };
 }
@@ -18969,6 +19110,18 @@ ${line}`).slice(-8e3);
   async #handleResult(active, event) {
     if (this.#active !== active)
       return;
+    const resultConversationId = event.result.conversation_id.trim();
+    if (resultConversationId && this.#nativeRef && resultConversationId !== this.#nativeRef.nativeSessionId) {
+      this.#completeTurn(active, {
+        status: "failed",
+        error: {
+          code: "protocolError",
+          message: "Antigravity returned a result for a different Conversation",
+          retryable: false
+        }
+      });
+      return;
+    }
     const usage = hostUsage(event.result.usage, active.model?.id);
     if (usage)
       this.#publishUsage(active, usage);
@@ -18981,7 +19134,7 @@ ${line}`).slice(-8e3);
     await active.subagents.refresh();
     if (this.#active !== active)
       return;
-    const convId = event.result.conversation_id && event.result.conversation_id.trim().length > 0 ? event.result.conversation_id.trim() : this.#nativeRef?.nativeSessionId ?? "";
+    const convId = resultConversationId || this.#nativeRef?.nativeSessionId || "";
     if (!this.#nativeRef && convId) {
       this.#nativeRef = nativeSessionRefSchema.parse({
         harnessId: this.harnessId,
@@ -19765,6 +19918,10 @@ function createHarnessAdapter(context) {
     ...environment[ANTIGRAVITY_COMMAND_ENV] ? { command: environment[ANTIGRAVITY_COMMAND_ENV] } : {},
     environment
   }), {
+    install: createHarnessInstaller(environment, {
+      posix: "https://antigravity.google/cli/install.sh",
+      windows: "https://antigravity.google/cli/install.ps1"
+    }),
     installation: createAntigravityInstallation(environment, environment[ANTIGRAVITY_COMMAND_ENV])
   });
 }