@codexhost/cli-linux-arm64 0.10.2 → 0.12.0

package/app/plugins/grok/plugin.mjs

@@ -5,20 +5,387 @@ 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
+    }, (error53, stdout, stderr) => {
+      if (error53)
+        reject(new Error(error53.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 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 (error53) {
+    if (error53 instanceof DOMException && (error53.name === "AbortError" || error53.name === "TimeoutError"))
+      throw error53;
+    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/grok-adapter.js
 import { randomUUID } from "node:crypto";
 
 // dist/grok-credential-export.js
 import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
+import os2 from "node:os";
+import path4 from "node:path";
 async function readGrokCredentials(environment) {
   if ([environment.XAI_API_KEY, environment.GROK_API_KEY, environment.GROK_TOKEN].some((v) => v?.trim()))
     return [];
   try {
-    const home = environment.GROK_HOME ?? path.join(environment.HOME ?? os.homedir(), ".grok");
-    const auth = JSON.parse(await readFile(path.join(home, "auth.json"), "utf8"));
+    const home = environment.GROK_HOME ?? path4.join(environment.HOME ?? os2.homedir(), ".grok");
+    const auth = JSON.parse(await readFile(path4.join(home, "auth.json"), "utf8"));
     const client2 = "b1a00492-073a-47ea-816f-4c329264a828";
     const entry = auth[`https://auth.x.ai::${client2}`] ?? auth["https://auth.x.ai"];
     if (!entry || entry.oidc_issuer !== "https://auth.x.ai" || entry.oidc_client_id !== client2)
@@ -45,7 +412,7 @@ async function readGrokCredentials(environment) {
 }
 
 // dist/grok-adapter.js
-import path11 from "node:path";
+import path13 from "node:path";
 
 // ../../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -813,10 +1180,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path12) {
-  if (!path12)
+function getElementAtPath(obj, path14) {
+  if (!path14)
     return obj;
-  return path12.reduce((acc, key) => acc?.[key], obj);
+  return path14.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1225,11 +1592,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path12, issues) {
+function prefixIssues(path14, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path12);
+    iss.path.unshift(path14);
     return iss;
   });
 }
@@ -1376,16 +1743,16 @@ function flattenError(error53, mapper = (issue2) => issue2.message) {
 }
 function formatError(error53, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error54, path12 = []) => {
+  const processError = (error54, path14 = []) => {
     for (const issue2 of error54.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path12, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path14, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
       } else {
-        const fullpath = [...path12, ...issue2.path];
+        const fullpath = [...path14, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1412,17 +1779,17 @@ function formatError(error53, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error53, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error54, path12 = []) => {
+  const processError = (error54, path14 = []) => {
     var _a3, _b;
     for (const issue2 of error54.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path12, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path14, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
       } else {
-        const fullpath = [...path12, ...issue2.path];
+        const fullpath = [...path14, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1454,8 +1821,8 @@ function treeifyError(error53, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path12 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path12) {
+  const path14 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path14) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14147,13 +14514,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path12 = ref.slice(1).split("/").filter(Boolean);
-  if (path12.length === 0) {
+  const path14 = ref.slice(1).split("/").filter(Boolean);
+  if (path14.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path12[0] === defsKey) {
-    const key = path12[1];
+  if (path14[0] === defsKey) {
+    const key = path14[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14616,6 +14983,56 @@ var credentialImportsParamsSchema = external_exports.object({
   request: credentialImportsRequestSchema
 }).strict();
 
+// ../../shared-contracts/dist/harness-display-settings.js
+var harnessDisplayEntriesSchema = external_exports.array(external_exports.strictObject({
+  agent: external_exports.string().min(1).max(128),
+  section: external_exports.enum(["main", "more", "auto"])
+})).max(256).refine((entries) => new Set(entries.map((entry) => entry.agent)).size === entries.length, "Duplicate Harness IDs");
+var harnessDisplaySettingsSchema = external_exports.strictObject({
+  entries: harnessDisplayEntriesSchema.nullable()
+});
+var harnessDisplayGetSchema = external_exports.strictObject({});
+var harnessDisplaySetSchema = external_exports.strictObject({
+  entries: harnessDisplayEntriesSchema,
+  /** Import legacy Desktop preferences only if no shared settings exist yet. */
+  initializeOnly: external_exports.boolean().optional()
+});
+
+// ../../shared-contracts/dist/console.js
+var consoleAnnouncementSchema = external_exports.strictObject({
+  title: external_exports.string().trim().min(1).max(200),
+  type: external_exports.enum(["info", "warning", "danger"]),
+  body: external_exports.string().trim().min(1).max(16 * 1024)
+});
+var consoleOpenParamsSchema = external_exports.strictObject({});
+var consoleOpenResultSchema = external_exports.strictObject({
+  /** The console address. */
+  url: external_exports.string().max(2048).regex(/^http:\/\/(?:127\.0\.0\.1|localhost):\d{1,5}\/(?:\?.*)?$/u)
+});
+var CONSOLE_HOST_METHODS = Object.freeze([
+  "codexhost/harness/plugins/list",
+  "codexhost/harness/display-settings/get",
+  "codexhost/harness/display-settings/set",
+  "codexhost/harness/inspect",
+  "codexhost/harness/installation",
+  "codexhost/harness/launch-settings/get",
+  "codexhost/harness/launch-settings/set",
+  "codexhost/harness/web-ui/open",
+  "codexhost/harness/accounts/sources",
+  "codexhost/harness/accounts/list",
+  "codexhost/harness/accounts/inspect",
+  "codexhost/harness/credential-imports",
+  "codexhost/harness/session-import/sources",
+  "codexhost/harness/session-import/list",
+  "codexhost/harness/session-import/import",
+  "codexhost/account/list",
+  "codexhost/account/refresh",
+  "codexhost/account/usage/inspect",
+  "codexhost/update/check",
+  "codexhost/update/start",
+  "codexhost/update/status"
+]);
+
 // ../../shared-contracts/dist/version.js
 var WORKSPACE_CONTRACT_VERSION = 1;
 
@@ -14669,6 +15086,12 @@ var hostTurnIdSchema = opaqueIdSchema.brand();
 var hostItemIdSchema = opaqueIdSchema.brand();
 var hostInteractionIdSchema = opaqueIdSchema.brand();
 
+// ../../shared-contracts/dist/manual-compaction.js
+var threadManualCompactionStartedSchema = external_exports.strictObject({
+  threadId: hostThreadIdSchema,
+  turnId: hostTurnIdSchema
+});
+
 // ../../shared-contracts/dist/thread-usage.js
 var nonNegativeSafeIntegerSchema = external_exports.number().int().safe().nonnegative();
 var finiteNonNegativeNumberSchema = external_exports.number().finite().nonnegative();
@@ -14729,6 +15152,10 @@ var threadUsageSnapshotSchema = external_exports.object({
 var usagePercentSchema = external_exports.number().finite().min(0).max(100);
 var accountCreditsProductUsageSchema = external_exports.object({
   product: external_exports.string().min(1),
+  used: external_exports.number().finite().nonnegative().optional(),
+  // Zero is a real empty cap, not an absent field.
+  limit: external_exports.number().finite().nonnegative().optional(),
+  unit: external_exports.string().min(1).max(32).optional(),
   usagePercent: usagePercentSchema,
   resetsAt: external_exports.string().min(1).optional()
 }).strict();
@@ -14738,6 +15165,10 @@ var accountResetCreditsSchema = external_exports.object({
   expiresAt: external_exports.array(external_exports.string().min(1)).min(1).max(32).optional()
 }).strict();
 var accountCreditsSnapshotSchema = external_exports.object({
+  used: external_exports.number().finite().nonnegative().optional(),
+  // Zero is a real empty cap, not an absent field.
+  limit: external_exports.number().finite().nonnegative().optional(),
+  unit: external_exports.string().min(1).max(32).optional(),
   /** Native label when the primary limit is scoped to a model or product group. */
   label: external_exports.string().min(1).optional(),
   usedPercent: usagePercentSchema,
@@ -14757,12 +15188,27 @@ var threadUsageInspectionSchema = external_exports.object({
 }).strict();
 
 // ../../shared-contracts/dist/harness-accounts.js
-var harnessAccountSnapshotSchema = external_exports.object({
+var accountBalanceSnapshotSchema = external_exports.object({
+  amount: external_exports.number().finite().nonnegative(),
+  /** ISO 4217 code as reported by the Provider, for example `CNY`. */
+  currency: external_exports.string().trim().min(1).max(8),
+  /** Native label when the Harness exposes several Billing Sources. */
+  label: external_exports.string().trim().min(1).max(128).optional()
+}).strict();
+var harnessAccountSnapshotObject = external_exports.object({
   email: external_exports.string().trim().min(1).max(320).optional(),
   label: external_exports.string().trim().min(1).max(256).optional(),
   plan: external_exports.string().trim().min(1).max(128).optional(),
-  credits: accountCreditsSnapshotSchema
+  credits: accountCreditsSnapshotSchema.optional(),
+  balance: accountBalanceSnapshotSchema.optional()
 }).strict();
+function requireReportedQuota(schema) {
+  return schema.refine((value) => {
+    const reported = value;
+    return reported.credits !== void 0 || reported.balance !== void 0;
+  }, { message: "Account must report either credits or a balance" });
+}
+var harnessAccountSnapshotSchema = requireReportedQuota(harnessAccountSnapshotObject);
 var harnessAccountIdentityShape = {
   harnessId: harnessIdSchema,
   harnessName: external_exports.string().trim().min(1).max(128)
@@ -14773,11 +15219,13 @@ var harnessAccountSourceListResultSchema = external_exports.object({ sources: ex
 var harnessAccountInspectParamsSchema = external_exports.object({ harnessId: harnessIdSchema, refresh: external_exports.boolean().optional() }).strict();
 var harnessAccountInspectResultSchema = external_exports.object({
   ...harnessAccountIdentityShape,
-  account: harnessAccountSnapshotSchema.nullable()
+  account: harnessAccountSnapshotSchema.nullable(),
+  /** Every Billing Source from one Harness; `account` remains the first for older clients. */
+  accounts: external_exports.array(harnessAccountSnapshotSchema).max(8).optional()
 }).strict();
 var harnessAccountListParamsSchema = external_exports.object({ refresh: external_exports.boolean().optional() }).strict();
 var harnessAccountListResultSchema = external_exports.object({
-  accounts: external_exports.array(harnessAccountSnapshotSchema.extend(harnessAccountIdentityShape)).max(128)
+  accounts: external_exports.array(requireReportedQuota(harnessAccountSnapshotObject.extend(harnessAccountIdentityShape))).max(128)
 }).strict();
 
 // ../../shared-contracts/dist/json-value.js
@@ -14915,6 +15363,8 @@ var harnessModelSchema = external_exports.object({
   ref: harnessModelRefSchema,
   label: nonBlankTextSchema2.max(HARNESS_MODEL_LABEL_MAX_LENGTH),
   resolvedModelLabel: harnessResolvedModelLabelSchema.optional(),
+  /** Optional opaque selection for this same Model with priority processing enabled. */
+  fastModel: harnessModelRefSchema.optional(),
   supportedThinkingOptionIds: external_exports.array(harnessThinkingOptionIdSchema).optional()
 }).strict();
 var harnessThinkingOptionsSchema = external_exports.array(harnessThinkingOptionSchema).superRefine((options, context) => {
@@ -14947,6 +15397,16 @@ var harnessModelCatalogSchema = external_exports.object({
       });
     }
     refs.add(model.ref.id);
+    if (model.fastModel) {
+      if (refs.has(model.fastModel.id) || catalog.models.some((entry) => entry.ref.id === model.fastModel?.id)) {
+        context.addIssue({
+          code: "custom",
+          message: "Fast Model refs must be distinct and unique",
+          path: ["models", index, "fastModel"]
+        });
+      }
+      refs.add(model.fastModel.id);
+    }
     const supportedThinkingIds = /* @__PURE__ */ new Set();
     for (const [optionIndex, optionId] of (model.supportedThinkingOptionIds ?? []).entries()) {
       if (supportedThinkingIds.has(optionId)) {
@@ -15066,11 +15526,13 @@ var threadThinkingSelectParamsSchema = external_exports.object({
   thinkingOptionId: harnessThinkingOptionIdSchema
 }).strict();
 var threadInspectionParamsSchema = external_exports.object({
-  threadId: hostThreadIdSchema
+  threadId: hostThreadIdSchema,
+  includeReferenceCapability: external_exports.boolean().optional()
 }).strict();
 var codexThreadInspectionSchema = external_exports.object({
   owner: external_exports.literal("codex"),
-  locked: external_exports.literal(true)
+  locked: external_exports.literal(true),
+  supportsThreadReferences: external_exports.literal(true).optional()
 }).strict();
 var externalThreadInspectionSchema = external_exports.object({
   owner: external_exports.literal("external"),
@@ -15196,6 +15658,22 @@ var harnessLaunchSettingsSchema = external_exports.object({
   restartRequired: external_exports.boolean()
 }).strict();
 
+// ../../shared-contracts/dist/harness-installation.js
+var harnessInstallationParamsSchema = external_exports.object({
+  harnessId: harnessIdSchema,
+  action: external_exports.enum(["check", "update", "install"])
+}).strict();
+var harnessInstallationStateSchema = external_exports.object({
+  currentVersion: external_exports.string().min(1).max(128),
+  latestVersion: external_exports.string().min(1).max(128),
+  updateAvailable: external_exports.boolean(),
+  canUpdate: external_exports.boolean(),
+  // Adapter-owned diagnostic text; UI uses messageCode rather than displaying it verbatim.
+  message: external_exports.string().max(2048).optional(),
+  messageCode: external_exports.string().min(1).max(128).optional(),
+  latestVersionKind: external_exports.enum(["unknown", "tracking-branch"]).optional()
+}).strict();
+
 // ../../shared-contracts/dist/codex-accounts.js
 var accountIdSchema = external_exports.string().min(1).max(256).regex(/^[A-Za-z0-9._~-]+$/u);
 var nonBlankTextSchema3 = external_exports.string().trim().min(1);
@@ -15495,6 +15973,38 @@ var updateStatusResultSchema = external_exports.strictObject({
   status: updateStatusSchema.nullable()
 });
 
+// ../../shared-contracts/dist/remote-runtime.js
+var remoteUpdatePhaseSchema = external_exports.enum([
+  "idle",
+  "installing",
+  "restarting",
+  "succeeded",
+  "failed"
+]);
+var runtimeStatusSchema = external_exports.object({
+  runningVersion: external_exports.string().nullable(),
+  installedVersion: external_exports.string().nullable(),
+  restartRequired: external_exports.boolean(),
+  remote: external_exports.boolean(),
+  updateSupported: external_exports.boolean(),
+  update: external_exports.object({
+    phase: remoteUpdatePhaseSchema,
+    targetVersion: external_exports.string().nullable(),
+    error: external_exports.string().nullable()
+  })
+});
+var remoteUpdateParamsSchema = external_exports.object({
+  version: external_exports.string().regex(/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/u)
+}).strict();
+var remoteSshSetupParamsSchema = external_exports.object({
+  hostname: external_exports.string().min(1).max(1024).refine((value) => !value.startsWith("-") && !/\s/u.test(value)),
+  port: external_exports.number().int().min(1).max(65535).nullable(),
+  identity: external_exports.string().max(4096).nullable(),
+  action: external_exports.enum(["inspect", "install", "update", "repair"]),
+  version: external_exports.string().regex(/^\d+\.\d+\.\d+$/u).nullable()
+}).strict();
+var remoteSshSetupResultSchema = external_exports.object({ state: external_exports.enum(["installed", "not-installed"]) }).strict();
+
 // ../../shared-contracts/dist/index.js
 var workspaceContractVersionSchema = external_exports.literal(WORKSPACE_CONTRACT_VERSION);
 
@@ -15776,7 +16286,7 @@ function mergeLiveHarnessCommands(builtIns, idPrefix, live, exclusions = {}) {
 import { spawn, spawnSync } from "node:child_process";
 import { readdir, readFile as readFile2 } from "node:fs/promises";
 import os4 from "node:os";
-import path9 from "node:path";
+import path10 from "node:path";
 import { Readable, Writable } from "node:stream";
 
 // ../../../node_modules/@agentclientprotocol/sdk/dist/schema/index.js
@@ -19929,281 +20439,54 @@ var ClientSideConnection = class {
    * This is useful for async/await style cleanup:
    *
    * @example
-   * ```typescript
-   * const connection = new ClientSideConnection(client, stream);
-   * await connection.closed;
-   * console.log('Connection closed - performing cleanup');
-   * ```
-   */
-  get closed() {
-    return this.connection.closed;
-  }
-};
-
-// dist/grok-slash-commands.js
-var GROK_LIVE_COMMAND_ID_PREFIX = "grok.slash.";
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function parseGrokAvailableCommands(value) {
-  if (!Array.isArray(value))
-    return [];
-  return value.flatMap((entry) => {
-    if (!isRecord3(entry))
-      return [];
-    const name = typeof entry.name === "string" ? entry.name.trim().replace(/^\//u, "") : "";
-    if (!name)
-      return [];
-    return [
-      {
-        name,
-        description: typeof entry.description === "string" ? entry.description : "",
-        meta: isRecord3(entry._meta) ? entry._meta : null
-      }
-    ];
-  });
-}
-function isGrokSkill(command) {
-  const path12 = command.meta?.path;
-  return typeof path12 === "string" && /(^|[\\/])SKILL\.md$/u.test(path12) || typeof command.meta?.qualifiedName === "string";
-}
-function grokLiveCommands(native) {
-  return native.map((command) => ({
-    name: command.name,
-    description: command.description,
-    kind: isGrokSkill(command) ? "skill" : "command"
-  }));
-}
-
-// dist/command.js
-import path4 from "node:path";
-
-// ../../harness-discovery/dist/environment.js
-import fs from "node:fs";
-import path2 from "node:path";
-function targetPath(platform) {
-  return platform === "win32" ? path2.win32 : path2.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 path3 from "node:path";
-function commandInvocation(command, arguments_, environment, platform = process.platform) {
-  const extension = path3.win32.extname(command).toLowerCase();
-  if (platform !== "win32" || ![".cmd", ".bat"].includes(extension)) {
-    return { command, arguments: [...arguments_], windowsVerbatimArguments: false };
-  }
-  const quote = (value) => `"${value.replaceAll("%", "%%").replaceAll('"', '""')}"`;
-  const commandLine = [command, ...arguments_].map(quote).join(" ");
-  return {
-    command: environmentValue(environment, "ComSpec") ?? "cmd.exe",
-    arguments: ["/d", "/v:off", "/s", "/c", `"${commandLine}"`],
-    windowsVerbatimArguments: true
-  };
-}
-
-// ../../harness-discovery/dist/resolve.js
-import os2 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") ?? os2.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);
+   * ```typescript
+   * const connection = new ClientSideConnection(client, stream);
+   * await connection.closed;
+   * console.log('Connection closed - performing cleanup');
+   * ```
+   */
+  get closed() {
+    return this.connection.closed;
+  }
+};
+
+// dist/grok-slash-commands.js
+var GROK_LIVE_COMMAND_ID_PREFIX = "grok.slash.";
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-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;
+function parseGrokAvailableCommands(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((entry) => {
+    if (!isRecord3(entry))
+      return [];
+    const name = typeof entry.name === "string" ? entry.name.trim().replace(/^\//u, "") : "";
+    if (!name)
+      return [];
+    return [
+      {
+        name,
+        description: typeof entry.description === "string" ? entry.description : "",
+        meta: isRecord3(entry._meta) ? entry._meta : null
+      }
+    ];
   });
-  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 isGrokSkill(command) {
+  const path14 = command.meta?.path;
+  return typeof path14 === "string" && /(^|[\\/])SKILL\.md$/u.test(path14) || typeof command.meta?.qualifiedName === "string";
 }
-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;
+function grokLiveCommands(native) {
+  return native.map((command) => ({
+    name: command.name,
+    description: command.description,
+    kind: isGrokSkill(command) ? "skill" : "command"
+  }));
 }
 
 // dist/command.js
+import path5 from "node:path";
 var GrokExecutableError = class extends Error {
   code = "GROK_NOT_FOUND";
 };
@@ -20232,7 +20515,7 @@ function resolveGrokExecutable(input = {}) {
   });
   if (!resolution)
     throw new GrokExecutableError("Grok CLI is not installed");
-  return targetPath(platform).isAbsolute(resolution.executable) ? resolution.executable : path4.resolve(resolution.executable);
+  return targetPath(platform).isAbsolute(resolution.executable) ? resolution.executable : path5.resolve(resolution.executable);
 }
 function grokInvocation(command, platform = process.platform, modelId) {
   const arguments_ = ["agent", "--no-leader"];
@@ -20245,11 +20528,11 @@ function grokInvocation(command, platform = process.platform, modelId) {
 
 // dist/grok-fork.js
 import { isDeepStrictEqual } from "node:util";
-import path7 from "node:path";
+import path8 from "node:path";
 
 // dist/grok-file-change.js
 import { Buffer as Buffer2 } from "node:buffer";
-import path5 from "node:path";
+import path6 from "node:path";
 
 // ../../../node_modules/diff/libesm/diff/base.js
 var Diff = class {
@@ -20351,16 +20634,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path12, added, removed, oldPosInc, options) {
-    const last = path12.lastComponent;
+  addToPath(path14, added, removed, oldPosInc, options) {
+    const last = path14.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path12.oldPos + oldPosInc,
+        oldPos: path14.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path12.oldPos + oldPosInc,
+        oldPos: path14.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -20673,13 +20956,13 @@ function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function validAbsolutePath(value) {
-  return typeof value === "string" && path5.isAbsolute(value) && value.trim().length > 0 && !value.includes("\0") && !value.includes("\n") && !value.includes("\r");
+  return typeof value === "string" && path6.isAbsolute(value) && value.trim().length > 0 && !value.includes("\0") && !value.includes("\n") && !value.includes("\r");
 }
 function displayPath(nativePath, cwd) {
-  const resolvedCwd = path5.resolve(cwd);
-  const resolvedPath = path5.resolve(nativePath);
-  const relative = path5.relative(resolvedCwd, resolvedPath);
-  const inside = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path5.sep}`);
+  const resolvedCwd = path6.resolve(cwd);
+  const resolvedPath = path6.resolve(nativePath);
+  const relative = path6.relative(resolvedCwd, resolvedPath);
+  const inside = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path6.sep}`);
   const selected = inside ? relative : resolvedPath;
   const normalized = selected.replaceAll("\\", "/");
   if (normalized.length === 0 || normalized === ".")
@@ -20742,7 +21025,7 @@ function projectGrokFileChanges(content, cwd, textLimit = DEFAULT_GROK_FILE_CHAN
 // dist/local-media-markdown.js
 import { existsSync, statSync } from "node:fs";
 import os3 from "node:os";
-import path6 from "node:path";
+import path7 from "node:path";
 var MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
   ".aac",
   ".gif",
@@ -20761,14 +21044,14 @@ var MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
   ".webp"
 ]);
 function grokMediaResolveRoots(cwd, sessionDirectory) {
-  const roots = [path6.resolve(cwd)];
+  const roots = [path7.resolve(cwd)];
   if (sessionDirectory) {
-    const session = path6.resolve(sessionDirectory);
-    roots.push(session, path6.join(session, "videos"), path6.join(session, "images"));
+    const session = path7.resolve(sessionDirectory);
+    roots.push(session, path7.join(session, "videos"), path7.join(session, "images"));
   }
   const home = process.env.HOME ?? process.env.USERPROFILE ?? os3.homedir();
   if (home)
-    roots.push(path6.join(home, "Downloads"));
+    roots.push(path7.join(home, "Downloads"));
   return roots;
 }
 function rewriteLocalMediaMarkdown(text, roots, options = {}) {
@@ -20869,7 +21152,7 @@ function parseInlineCode(text, start) {
   return { closed: false, content: text.slice(start + 1), end: text.length };
 }
 function mediaMarkdownImage(absolutePath) {
-  const name = path6.basename(absolutePath).replaceAll("]", "\\]");
+  const name = path7.basename(absolutePath).replaceAll("]", "\\]");
   return `![${name}](${formatMarkdownDestination(absolutePath, false)})`;
 }
 function parseMarkdownImage(text, start) {
@@ -20994,11 +21277,11 @@ function resolveLocalMediaPath(raw, roots, exists = mediaFileExists) {
   if (!hasMediaExtension(stripped))
     return null;
   if (isAbsoluteMediaPath(stripped)) {
-    const absolute = path6.resolve(stripped);
+    const absolute = path7.resolve(stripped);
     return exists(absolute) ? absolute : null;
   }
   for (const root of roots) {
-    const absolute = path6.resolve(root, stripped);
+    const absolute = path7.resolve(root, stripped);
     if (exists(absolute))
       return absolute;
   }
@@ -21020,11 +21303,11 @@ function stripFileUrl(value) {
   }
 }
 function isAbsoluteMediaPath(value) {
-  return path6.isAbsolute(value) || /^[a-zA-Z]:[\\/]/.test(value);
+  return path7.isAbsolute(value) || /^[a-zA-Z]:[\\/]/.test(value);
 }
 function hasMediaExtension(value) {
   const pathname = value.split(/[?#]/, 1)[0] ?? value;
-  return MEDIA_EXTENSIONS.has(path6.extname(pathname).toLowerCase());
+  return MEDIA_EXTENSIONS.has(path7.extname(pathname).toLowerCase());
 }
 function mediaFileExists(absolutePath) {
   try {
@@ -22033,11 +22316,11 @@ function parseGrokForkResponse(value) {
 }
 function projectRelativePath(value, cwds) {
   const normalized = value.replaceAll("\\", "/");
-  if (!path7.isAbsolute(value))
+  if (!path8.isAbsolute(value))
     return normalized;
   for (const cwd of cwds) {
-    const relative = path7.relative(path7.resolve(cwd), path7.resolve(value));
-    if (relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path7.sep}`)) {
+    const relative = path8.relative(path8.resolve(cwd), path8.resolve(value));
+    if (relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path8.sep}`)) {
       return relative.replaceAll("\\", "/");
     }
   }
@@ -22102,8 +22385,8 @@ async function forkGrokSession(input) {
       error: error51("sessionNotFound", "Grok Native Session is unavailable")
     };
   }
-  const sourceCwd = path7.resolve(located.cwd);
-  const targetCwd = path7.resolve(input.cwd);
+  const sourceCwd = path8.resolve(located.cwd);
+  const targetCwd = path8.resolve(input.cwd);
   const source = await readSnapshot({ ...input, cwd: sourceCwd }, sourceRef.data.nativeSessionId);
   if (!source.ok)
     return source;
@@ -22285,7 +22568,7 @@ function parseGrokCompactResult(value, cancelled = false) {
 }
 
 // dist/grok-rewind.js
-import path8 from "node:path";
+import path9 from "node:path";
 var GROK_REWIND_EXECUTE_METHOD = "_x.ai/rewind/execute";
 function error52(code, message, retryable = false) {
   return { code, message, retryable };
@@ -22358,8 +22641,8 @@ async function rewindGrokLastTurn(input) {
       error: error52("sessionNotFound", "Grok Native Session is unavailable")
     };
   }
-  const sourceCwd = path8.resolve(located.cwd);
-  const targetCwd = path8.resolve(input.cwd);
+  const sourceCwd = path9.resolve(located.cwd);
+  const targetCwd = path9.resolve(input.cwd);
   if (sourceCwd !== targetCwd) {
     return {
       ok: false,
@@ -22603,13 +22886,13 @@ function transportEvent(update, metadata) {
 function grokHomeDir(options) {
   const environment = { ...process.env, ...options.environment };
   const home = environment.HOME ?? environment.USERPROFILE ?? os4.homedir();
-  return environment.GROK_HOME ?? path9.join(home, ".grok");
+  return environment.GROK_HOME ?? path10.join(home, ".grok");
 }
 function grokNativeSessionDirectory(options, sessionId) {
-  return path9.join(grokHomeDir(options), "sessions", encodeURIComponent(path9.resolve(options.cwd)), sessionId);
+  return path10.join(grokHomeDir(options), "sessions", encodeURIComponent(path10.resolve(options.cwd)), sessionId);
 }
 function nativeSessionFile(options, sessionId, fileName) {
-  return path9.join(grokNativeSessionDirectory(options, sessionId), fileName);
+  return path10.join(grokNativeSessionDirectory(options, sessionId), fileName);
 }
 function nativeHistoryPath(options, sessionId) {
   return nativeSessionFile(options, sessionId, "updates.jsonl");
@@ -22629,7 +22912,7 @@ async function locateGrokNativeSession(options, sessionId) {
     return null;
   let entries;
   try {
-    entries = await readdir(path9.join(grokHomeDir(options), "sessions"), { withFileTypes: true });
+    entries = await readdir(path10.join(grokHomeDir(options), "sessions"), { withFileTypes: true });
   } catch (error53) {
     if (isMissingFile(error53))
       return null;
@@ -22643,7 +22926,7 @@ async function locateGrokNativeSession(options, sessionId) {
       continue;
     let summaryRaw;
     try {
-      summaryRaw = await readFile2(path9.join(grokHomeDir(options), "sessions", entry.name, sessionId, "summary.json"), "utf8");
+      summaryRaw = await readFile2(path10.join(grokHomeDir(options), "sessions", entry.name, sessionId, "summary.json"), "utf8");
     } catch (error53) {
       if (isMissingFile(error53) || isRecord11(error53) && error53.code === "ENOTDIR")
         continue;
@@ -22660,8 +22943,8 @@ async function locateGrokNativeSession(options, sessionId) {
     if (!isRecord11(parsed))
       continue;
     const info = parsed.info;
-    const cwd = isRecord11(info) && typeof info.cwd === "string" && info.cwd.length > 0 ? path9.resolve(info.cwd) : path9.resolve(decodeURIComponent(entry.name));
-    const sourceWorkspaceDir = typeof parsed.source_workspace_dir === "string" && parsed.source_workspace_dir.length > 0 ? path9.resolve(parsed.source_workspace_dir) : void 0;
+    const cwd = isRecord11(info) && typeof info.cwd === "string" && info.cwd.length > 0 ? path10.resolve(info.cwd) : path10.resolve(decodeURIComponent(entry.name));
+    const sourceWorkspaceDir = typeof parsed.source_workspace_dir === "string" && parsed.source_workspace_dir.length > 0 ? path10.resolve(parsed.source_workspace_dir) : void 0;
     matches.push({
       cwd,
       ...sourceWorkspaceDir ? { sourceWorkspaceDir } : {}
@@ -22671,7 +22954,7 @@ async function locateGrokNativeSession(options, sessionId) {
 }
 async function readGrokNativeHistory(options, sessionId) {
   try {
-    return parseNativeHistory(await readFile2(nativeHistoryPath({ ...options, cwd: path9.resolve(options.cwd) }, sessionId), "utf8"), sessionId);
+    return parseNativeHistory(await readFile2(nativeHistoryPath({ ...options, cwd: path10.resolve(options.cwd) }, sessionId), "utf8"), sessionId);
   } catch (error53) {
     if (isMissingFile(error53))
       return [];
@@ -23088,6 +23371,323 @@ var GrokAcpTransport = class {
   }
 };
 
+// dist/session-import.js
+import { createReadStream } from "node:fs";
+import { opendir, readFile as readFile3, stat } from "node:fs/promises";
+import path11 from "node:path";
+import { createInterface } from "node:readline";
+
+// ../../harness-adapter/dist/session-import.js
+import { lstat } from "node:fs/promises";
+var SessionImportChangedError = class extends Error {
+  constructor(message = "Native Session changed during discovery; refresh and retry") {
+    super(message);
+    this.name = "SessionImportChangedError";
+  }
+};
+function isMissingFileError(error53) {
+  return typeof error53 === "object" && error53 !== null && "code" in error53 && error53.code === "ENOENT";
+}
+function sameFileFingerprint(left, right) {
+  return left === null || right === null ? left === right : left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
+}
+var STORAGE_ACCESS_ERRORS = /* @__PURE__ */ new Set(["EACCES", "EPERM", "EIO", "EMFILE", "ENFILE"]);
+function isStorageAccessError(error53) {
+  return typeof error53 === "object" && error53 !== null && "code" in error53 && typeof error53.code === "string" && STORAGE_ACCESS_ERRORS.has(error53.code);
+}
+async function optionalLstat(file2) {
+  try {
+    return await lstat(file2);
+  } catch (error53) {
+    if (isMissingFileError(error53))
+      return null;
+    throw error53;
+  }
+}
+async function readStableFiles(files, read) {
+  const before = await Promise.all(files.map(optionalLstat));
+  const value = await read(before);
+  const after = await Promise.all(files.map(optionalLstat));
+  if (before.some((info, index) => !sameFileFingerprint(info, after[index] ?? null)))
+    throw new SessionImportChangedError();
+  return value;
+}
+function sessionImportTitle(value, maxLength = HARNESS_SESSION_IMPORT_TITLE_MAX_LENGTH) {
+  if (typeof value !== "string")
+    return null;
+  const normalized = value.replaceAll("\0", "").replaceAll(/\s+/gu, " ").trim();
+  if (!normalized)
+    return null;
+  if (normalized.length <= maxLength)
+    return normalized;
+  const characters = [...normalized];
+  if (characters.length <= maxLength)
+    return normalized;
+  return `${characters.slice(0, maxLength - 1).join("").trimEnd()}…`;
+}
+function sessionImportCandidate(input) {
+  const time3 = typeof input.updatedAt === "number" ? input.updatedAt : typeof input.updatedAt === "string" ? Date.parse(input.updatedAt) : Number.NaN;
+  const parsed = harnessSessionImportCandidateSchema.safeParse({
+    nativeSessionId: input.nativeSessionId,
+    cwd: input.cwd,
+    title: typeof input.title === "string" && input.title.trim().length > 0 ? input.title : null,
+    updatedAt: Math.floor(time3),
+    // Unknown must stay unknown; only an explicit boolean is a native statement.
+    running: typeof input.running === "boolean" ? input.running : null
+  });
+  return parsed.success ? parsed.data : null;
+}
+var SessionImportScope = class {
+  #abort = new AbortController();
+  #options;
+  #pending = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.#options = options;
+  }
+  #closed() {
+    return {
+      ok: false,
+      error: { code: "invalidState", message: this.#options.closedMessage, retryable: false }
+    };
+  }
+  read(operation) {
+    const signal = this.#abort.signal;
+    if (signal.aborted)
+      return Promise.resolve(this.#closed());
+    let started;
+    try {
+      started = operation(signal);
+    } catch (error53) {
+      started = Promise.reject(error53 instanceof Error ? error53 : new Error("Session read failed"));
+    }
+    const request = started.then((value) => signal.aborted ? this.#closed() : { ok: true, value }).catch(() => signal.aborted ? this.#closed() : {
+      ok: false,
+      error: {
+        code: "unavailable",
+        message: this.#options.unavailableMessage,
+        retryable: true
+      }
+    }).finally(() => this.#pending.delete(request));
+    this.#pending.add(request);
+    return request;
+  }
+  /** `read` for `resolveCandidate`: a null source is the selected Session having disappeared. */
+  async resolve(operation) {
+    const result = await this.read(operation);
+    if (!result.ok)
+      return result;
+    return result.value ? { ok: true, value: result.value } : {
+      ok: false,
+      error: {
+        code: "sessionNotFound",
+        message: this.#options.notFoundMessage,
+        retryable: false
+      }
+    };
+  }
+  /** Idempotent. Resolves after every started read has settled. */
+  async close() {
+    this.#abort.abort();
+    await Promise.allSettled(this.#pending);
+  }
+};
+
+// dist/session-import.js
+var MAX_METADATA_BYTES = 4 * 1024 * 1024;
+var SUBAGENT_SESSION_KINDS = /* @__PURE__ */ new Set(["subagent", "subagent_resume"]);
+function isRecord12(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function readJson(file2, signal) {
+  return JSON.parse(await readFile3(file2, { encoding: "utf8", signal }));
+}
+function processAlive(pid) {
+  if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error53) {
+    return isRecord12(error53) && error53.code === "EPERM";
+  }
+}
+async function firstUserText(file2, signal) {
+  const stream = createReadStream(file2, { encoding: "utf8", signal });
+  const lines = createInterface({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of lines) {
+      signal.throwIfAborted();
+      if (!line.includes("user_message_chunk"))
+        continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const update = isRecord12(entry) && isRecord12(entry.params) ? entry.params.update : null;
+      if (!isRecord12(update) || update.sessionUpdate !== "user_message_chunk")
+        continue;
+      const text = isRecord12(update.content) ? update.content.text : null;
+      return typeof text === "string" ? text : "";
+    }
+    return null;
+  } finally {
+    lines.close();
+    stream.destroy();
+  }
+}
+var GrokSessionImport = class {
+  #environment;
+  #scope = new SessionImportScope({
+    closedMessage: "Grok Session import is closed",
+    unavailableMessage: "Grok sessions could not be read; close native clients, check storage access and retry",
+    notFoundMessage: "Grok Session is no longer importable"
+  });
+  constructor(environment) {
+    this.#environment = environment ? { ...environment } : void 0;
+  }
+  listCandidates() {
+    return this.#scope.read(async (signal) => {
+      const active = await this.#activeSessions(signal);
+      const candidates = [];
+      for (const [, directories] of await this.#sessionDirectories(signal)) {
+        if (directories.length !== 1 || !directories[0])
+          continue;
+        try {
+          const candidate = await this.#candidate(directories[0], active, signal);
+          if (candidate)
+            candidates.push(candidate);
+        } catch (error53) {
+          if (!(error53 instanceof SessionImportChangedError))
+            throw error53;
+        }
+      }
+      return candidates;
+    });
+  }
+  resolveCandidate(nativeSessionId) {
+    return this.#scope.resolve(async (signal) => {
+      const directories = (await this.#sessionDirectories(signal)).get(nativeSessionId);
+      if (directories?.length !== 1 || !directories[0])
+        return null;
+      const candidate = await this.#candidate(directories[0], await this.#activeSessions(signal), signal);
+      if (!candidate)
+        return null;
+      return {
+        candidate,
+        nativeRef: nativeSessionRefSchema.parse({
+          harnessId: "grok",
+          nativeSessionId,
+          formatVersion: 1
+        })
+      };
+    });
+  }
+  close() {
+    return this.#scope.close();
+  }
+  #home() {
+    return grokHomeDir(this.#environment ? { environment: this.#environment } : {});
+  }
+  /** IDs a live Grok process currently holds open, from Grok's own registry. */
+  async #activeSessions(signal) {
+    const active = /* @__PURE__ */ new Set();
+    let entries;
+    try {
+      entries = await readJson(path11.join(this.#home(), "active_sessions.json"), signal);
+    } catch (error53) {
+      signal.throwIfAborted();
+      if (isStorageAccessError(error53))
+        throw error53;
+      return active;
+    }
+    if (!Array.isArray(entries))
+      return active;
+    for (const entry of entries) {
+      if (isRecord12(entry) && typeof entry.session_id === "string" && processAlive(entry.pid))
+        active.add(entry.session_id);
+    }
+    return active;
+  }
+  /** Session ID to every directory claiming it. Enumerated links are not followed. */
+  async #sessionDirectories(signal) {
+    const root = path11.join(this.#home(), "sessions");
+    const found = /* @__PURE__ */ new Map();
+    const info = await optionalLstat(root);
+    if (!info)
+      return found;
+    if (!info.isDirectory())
+      throw new Error("Grok Session store is not a directory");
+    for await (const workspace of await opendir(root)) {
+      signal.throwIfAborted();
+      if (!workspace.isDirectory())
+        continue;
+      const workspaceDirectory = path11.join(root, workspace.name);
+      const sessions = await opendir(workspaceDirectory).catch((error53) => {
+        if (isMissingFileError(error53))
+          return null;
+        throw error53;
+      });
+      if (!sessions)
+        continue;
+      for await (const session of sessions) {
+        signal.throwIfAborted();
+        if (!session.isDirectory())
+          continue;
+        const directories = found.get(session.name) ?? [];
+        directories.push(path11.join(workspaceDirectory, session.name));
+        found.set(session.name, directories);
+      }
+    }
+    return found;
+  }
+  async #candidate(sessionDirectory, active, signal) {
+    signal.throwIfAborted();
+    const nativeSessionId = path11.basename(sessionDirectory);
+    const files = [
+      path11.join(sessionDirectory, "summary.json"),
+      path11.join(sessionDirectory, "updates.jsonl")
+    ];
+    return readStableFiles(files, async ([summaryInfo, updates]) => {
+      if (!summaryInfo?.isFile() || !updates?.isFile() || summaryInfo.size > MAX_METADATA_BYTES)
+        return null;
+      try {
+        const summary = await readJson(files[0], signal);
+        if (!isRecord12(summary) || !isRecord12(summary.info) || summary.info.id !== nativeSessionId)
+          return null;
+        if (typeof summary.session_kind === "string" && SUBAGENT_SESSION_KINDS.has(summary.session_kind))
+          return null;
+        const nativeCwd = summary.info.cwd;
+        if (typeof nativeCwd !== "string" || !path11.isAbsolute(nativeCwd) || nativeCwd.includes("\0"))
+          return null;
+        const cwd = path11.resolve(nativeCwd);
+        if (encodeURIComponent(cwd) !== path11.basename(path11.dirname(sessionDirectory)))
+          return null;
+        if (!(await stat(cwd)).isDirectory())
+          return null;
+        const prompt = await firstUserText(files[1], signal);
+        if (prompt === null)
+          return null;
+        const updatedAt = [summary.last_active_at, summary.updated_at].map((value) => typeof value === "string" ? Date.parse(value) : Number.NaN).find((value) => Number.isFinite(value) && value >= 0);
+        return sessionImportCandidate({
+          nativeSessionId,
+          cwd,
+          title: sessionImportTitle(summary.generated_title) ?? sessionImportTitle(summary.session_summary) ?? sessionImportTitle(prompt),
+          updatedAt: updatedAt ?? updates.mtimeMs,
+          // Grok registers open Sessions with their process. Absence is not proof of idleness.
+          running: active.has(nativeSessionId) ? true : null
+        });
+      } catch (error53) {
+        signal.throwIfAborted();
+        if (isStorageAccessError(error53))
+          throw error53;
+        return null;
+      }
+    });
+  }
+};
+
 // dist/grok-subagent-lifecycle.js
 function subagentFailure() {
   return {
@@ -23281,7 +23881,7 @@ var GrokSubagentLifecycle = class {
 };
 
 // dist/grok-models.js
-function isRecord12(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonBlank(value) {
@@ -23293,7 +23893,7 @@ function thinkingOptions(value) {
   const seen = /* @__PURE__ */ new Set();
   const options = [];
   for (const candidate of value) {
-    if (!isRecord12(candidate) || !nonBlank(candidate.label))
+    if (!isRecord13(candidate) || !nonBlank(candidate.label))
       continue;
     const id = harnessThinkingOptionIdSchema.safeParse(candidate.id ?? candidate.value);
     if (!id.success || seen.has(id.data))
@@ -23304,7 +23904,7 @@ function thinkingOptions(value) {
   return options;
 }
 function parseGrokModelState(value) {
-  if (!isRecord12(value) || !nonBlank(value.currentModelId) || !Array.isArray(value.availableModels)) {
+  if (!isRecord13(value) || !nonBlank(value.currentModelId) || !Array.isArray(value.availableModels)) {
     return null;
   }
   const currentModel = harnessModelRefSchema.safeParse({ id: value.currentModelId });
@@ -23315,12 +23915,12 @@ function parseGrokModelState(value) {
   const models = [];
   let currentThinkingOptionId;
   for (const candidate of value.availableModels) {
-    if (!isRecord12(candidate) || !nonBlank(candidate.modelId) || !nonBlank(candidate.name))
+    if (!isRecord13(candidate) || !nonBlank(candidate.modelId) || !nonBlank(candidate.name))
       continue;
     const ref = harnessModelRefSchema.safeParse({ id: candidate.modelId });
     if (!ref.success)
       continue;
-    const metadata = isRecord12(candidate._meta) ? candidate._meta : {};
+    const metadata = isRecord13(candidate._meta) ? candidate._meta : {};
     const options2 = thinkingOptions(metadata.reasoningEfforts);
     if (typeof metadata.totalContextTokens === "number" && Number.isSafeInteger(metadata.totalContextTokens) && metadata.totalContextTokens > 0) {
       contextWindowTokensByModel.set(ref.data.id, metadata.totalContextTokens);
@@ -23355,10 +23955,10 @@ function parseGrokModelState(value) {
   };
 }
 function modelStateFromInitialize(response) {
-  return parseGrokModelState(isRecord12(response._meta) ? response._meta.modelState : void 0);
+  return parseGrokModelState(isRecord13(response._meta) ? response._meta.modelState : void 0);
 }
 function modelStateFromSessionResponse(response) {
-  return parseGrokModelState(isRecord12(response) ? response.models : void 0);
+  return parseGrokModelState(isRecord13(response) ? response.models : void 0);
 }
 function stateForGrokModel(modelState, nativeState, model = modelState.currentModel, thinkingOptionId = modelState.currentThinkingOptionId, permissionModeId) {
   const selectedModel = model;
@@ -23377,12 +23977,12 @@ function stateForGrokModel(modelState, nativeState, model = modelState.currentMo
 }
 
 // dist/grok-credits.js
-import { readFile as readFile3 } from "node:fs/promises";
+import { readFile as readFile4 } from "node:fs/promises";
 import os5 from "node:os";
-import path10 from "node:path";
+import path12 from "node:path";
 var GROK_CREDITS_ENDPOINT = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
 var REQUEST_TIMEOUT_MS = 15e3;
-function isRecord13(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function finitePercent(value) {
@@ -23391,7 +23991,7 @@ function finitePercent(value) {
   return Math.min(100, Math.max(0, value));
 }
 function nonNegativeCentValue(value) {
-  if (!isRecord13(value))
+  if (!isRecord14(value))
     return void 0;
   const amount = value.val === void 0 ? 0 : value.val;
   if (typeof amount !== "number" || !Number.isFinite(amount) || amount < 0)
@@ -23399,7 +23999,7 @@ function nonNegativeCentValue(value) {
   return amount;
 }
 function grokHome(environment) {
-  return environment.GROK_HOME ?? path10.join(environment.HOME ?? environment.USERPROFILE ?? os5.homedir(), ".grok");
+  return environment.GROK_HOME ?? path12.join(environment.HOME ?? environment.USERPROFILE ?? os5.homedir(), ".grok");
 }
 function periodTypeFrom(value) {
   if (typeof value !== "string")
@@ -23415,7 +24015,7 @@ function productUsageFrom(value) {
   if (!Array.isArray(value))
     return void 0;
   const products = value.flatMap((entry) => {
-    if (!isRecord13(entry) || typeof entry.product !== "string")
+    if (!isRecord14(entry) || typeof entry.product !== "string")
       return [];
     const usagePercent = finitePercent(entry.usagePercent);
     return usagePercent === void 0 ? [] : [{ product: entry.product, usagePercent }];
@@ -23423,10 +24023,10 @@ function productUsageFrom(value) {
   return products.length > 0 ? products : void 0;
 }
 function parseGrokCreditsResponse(value, fetchedAt = (/* @__PURE__ */ new Date()).toISOString()) {
-  if (!isRecord13(value) || !isRecord13(value.config))
+  if (!isRecord14(value) || !isRecord14(value.config))
     return null;
   const config2 = value.config;
-  const period = isRecord13(config2.currentPeriod) ? config2.currentPeriod : void 0;
+  const period = isRecord14(config2.currentPeriod) ? config2.currentPeriod : void 0;
   const periodType = periodTypeFrom(period?.type);
   const resetsAt = (typeof period?.end === "string" && period.end.length > 0 ? period.end : void 0) ?? (typeof config2.billingPeriodEnd === "string" && config2.billingPeriodEnd.length > 0 ? config2.billingPeriodEnd : void 0);
   let usedPercent = finitePercent(config2.creditUsagePercent);
@@ -23453,11 +24053,11 @@ function parseGrokCreditsResponse(value, fetchedAt = (/* @__PURE__ */ new Date()
   };
 }
 function selectAccessToken(auth, now) {
-  if (!isRecord13(auth))
+  if (!isRecord14(auth))
     return null;
-  const entries = Object.entries(auth).filter(([issuer, value]) => (issuer === "https://auth.x.ai" || issuer.startsWith("https://auth.x.ai::")) && isRecord13(value) && typeof value.key === "string" && value.key.length > 0).sort(([left], [right]) => Number(right.startsWith("https://auth.x.ai")) - Number(left.startsWith("https://auth.x.ai")));
+  const entries = Object.entries(auth).filter(([issuer, value]) => (issuer === "https://auth.x.ai" || issuer.startsWith("https://auth.x.ai::")) && isRecord14(value) && typeof value.key === "string" && value.key.length > 0).sort(([left], [right]) => Number(right.startsWith("https://auth.x.ai")) - Number(left.startsWith("https://auth.x.ai")));
   for (const [, value] of entries) {
-    if (!isRecord13(value) || typeof value.key !== "string")
+    if (!isRecord14(value) || typeof value.key !== "string")
       continue;
     if (typeof value.expires_at === "string") {
       const expiresAt = Date.parse(value.expires_at);
@@ -23478,8 +24078,8 @@ async function fetchGrokAccount(input = {}) {
     if ([environment.XAI_API_KEY, environment.GROK_API_KEY, environment.GROK_TOKEN].some((value) => value?.trim()))
       return null;
     const now = input.now ?? /* @__PURE__ */ new Date();
-    const authPath = path10.join(grokHome(environment), "auth.json");
-    const raw = input.readAuthFile ? await input.readAuthFile(authPath) : await readFile3(authPath, "utf8");
+    const authPath = path12.join(grokHome(environment), "auth.json");
+    const raw = input.readAuthFile ? await input.readAuthFile(authPath) : await readFile4(authPath, "utf8");
     const token = selectAccessToken(JSON.parse(raw), now);
     if (!token)
       return null;
@@ -23514,7 +24114,7 @@ async function fetchGrokAccount(input = {}) {
 }
 async function fetchGrokCredits(input = {}) {
   const account = await fetchGrokAccount(input);
-  if (!account)
+  if (!account?.credits)
     return null;
   const { credits } = account;
   return {
@@ -23528,7 +24128,7 @@ async function fetchGrokCredits(input = {}) {
 
 // dist/grok-usage.js
 var USD_TICKS_PER_DOLLAR = 1e10;
-function isRecord14(value) {
+function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalToken(value) {
@@ -23545,7 +24145,7 @@ function combineUsage(base, next) {
   return base === null ? next : parseHostUsage({ ...base, ...next });
 }
 function usageFromNative(value) {
-  if (!isRecord14(value))
+  if (!isRecord15(value))
     return null;
   const inputTokens = optionalToken(value.inputTokens);
   const cachedRead = optionalToken(value.cachedReadTokens);
@@ -23572,7 +24172,7 @@ function usageFromPrompt(response) {
   return response.usage ? usageFromNative(response.usage) : null;
 }
 function usageFromSignals(value) {
-  if (!isRecord14(value))
+  if (!isRecord15(value))
     return null;
   try {
     return parseHostUsage({
@@ -23592,7 +24192,7 @@ var summedUsageFields = [
   "totalTokens"
 ];
 function nativeCostTicks(value) {
-  if (!isRecord14(value))
+  if (!isRecord15(value))
     return void 0;
   const ticks = value.costUsdTicks;
   if (typeof ticks !== "number" || !Number.isSafeInteger(ticks) || ticks < 0)
@@ -23669,7 +24269,7 @@ function usageFromCompact(tokensAfter, contextWindowTokens) {
 function usageFromUpdate(update, metadata, contextWindowTokens) {
   try {
     if (update?.sessionUpdate === "usage_update") {
-      const cost = isRecord14(update.cost) ? update.cost : null;
+      const cost = isRecord15(update.cost) ? update.cost : null;
       return parseHostUsage({
         contextUsedTokens: update.used,
         contextWindowTokens: update.size,
@@ -24681,6 +25281,7 @@ var GrokAdapter = class {
   commandCatalog = grokCommandCatalog;
   liveCommandCatalog = true;
   harnessId = grokHarnessId;
+  sessionImport;
   subagents = {
     readSnapshot: async (input) => {
       if (input.parent.harnessId !== this.harnessId || input.nativeSubagentId.trim().length === 0) {
@@ -24728,6 +25329,7 @@ var GrokAdapter = class {
   constructor(options = {}, dependencies) {
     this.#closeTimeoutMs = options.closeTimeoutMs ?? DEFAULT_CLOSE_TIMEOUT_MS;
     this.#environment = options.environment;
+    this.sessionImport = new GrokSessionImport(options.environment);
     this.#toolOutputLimit = options.toolOutputLimit ?? DEFAULT_GROK_TOOL_OUTPUT_LIMIT;
     this.#dependencies = dependencies ?? {
       randomUUID,
@@ -24771,7 +25373,7 @@ var GrokAdapter = class {
   async inspect(input = {}) {
     if (this.#closePromise)
       return { status: "unavailable", error: invalidState("Grok Adapter is closed") };
-    const cwd = path11.resolve(input.cwd ?? process.cwd());
+    const cwd = path13.resolve(input.cwd ?? process.cwd());
     if (!input.refresh) {
       const cached2 = this.#inspectionCache.get(cwd);
       if (cached2)
@@ -24833,7 +25435,7 @@ var GrokAdapter = class {
         }
       };
     }
-    const cwd = path11.resolve(input.cwd);
+    const cwd = path13.resolve(input.cwd);
     const parsedRef = input.kind === "resume" ? nativeSessionRefSchema.safeParse(input.nativeRef) : null;
     if (parsedRef && (!parsedRef.success || parsedRef.data.harnessId !== this.harnessId)) {
       return {
@@ -25004,7 +25606,10 @@ var GrokAdapter = class {
     if (!this.#closePromise) {
       this.#accountAbort.abort();
       this.#inspectionCache.clear();
-      this.#closePromise = Promise.all([...this.#sessions].map((session) => session.close())).then(() => void 0);
+      this.#closePromise = Promise.all([
+        this.sessionImport.close(),
+        ...[...this.#sessions].map((session) => session.close())
+      ]).then(() => void 0);
     }
     return this.#closePromise;
   }
@@ -25017,13 +25622,51 @@ var GrokAdapter = class {
   }
 };
 
+// dist/installation.js
+var GROK_NPM_PACKAGE = "@xai-official/grok";
+function createGrokInstallation(environment, command) {
+  const run = (args, timeout, extra) => runInstallationCommand(resolveGrokExecutable({ environment, ...command ? { command } : {} }), args, extra ? { ...environment, ...extra } : environment, timeout);
+  let installer = "";
+  return createInstallationManager({
+    async check() {
+      const state = JSON.parse(await run(["update", "--check", "--json"]));
+      if (state.error || typeof state.updateAvailable !== "boolean")
+        throw new Error("Grok update check failed");
+      installer = typeof state.installer === "string" ? state.installer : "";
+      return {
+        currentVersion: installationVersion(state.currentVersion),
+        latestVersion: installationVersion(state.latestVersion),
+        updateAvailable: state.updateAvailable,
+        canUpdate: true
+      };
+    },
+    async update() {
+      if (installer !== "npm") {
+        await run(["update"], 3e5);
+        return;
+      }
+      const existing = environment.npm_config_allow_scripts?.trim();
+      const allowed = existing ? `${existing},${GROK_NPM_PACKAGE}` : GROK_NPM_PACKAGE;
+      await run(["update", "--force-reinstall"], 3e5, {
+        npm_config_allow_scripts: allowed
+      });
+    }
+  });
+}
+
 // dist/plugin.js
 var GROK_COMMAND_ENV = "CODEXHOST_GROK_COMMAND";
 function createHarnessAdapter(context) {
   const environment = { ...context.environment };
-  return new GrokAdapter({
+  return Object.assign(new GrokAdapter({
     ...environment[GROK_COMMAND_ENV] ? { command: environment[GROK_COMMAND_ENV] } : {},
     environment
+  }), {
+    installation: createGrokInstallation(environment, environment[GROK_COMMAND_ENV]),
+    install: createHarnessInstaller(environment, {
+      npm: "@xai-official/grok",
+      allowScripts: "@xai-official/grok"
+    })
   });
 }
 export {