@codexhost/cli-darwin-x64 0.10.2 → 0.12.0

package/app/plugins/pi/plugin.mjs

@@ -5,15 +5,413 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// dist/pi-credential-imports.js
-import { randomUUID } from "node:crypto";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync, readdirSync, lstatSync, renameSync, rmdirSync } from "node:fs";
-import { realpath } from "node:fs/promises";
-import os2 from "node:os";
+// ../../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";
-import { pathToFileURL } from "node:url";
+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/account-balance.js
+import { readFile } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import path4 from "node:path";
 
 // ../../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -781,10 +1179,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path10) {
-  if (!path10)
+function getElementAtPath(obj, path14) {
+  if (!path14)
     return obj;
-  return path10.reduce((acc, key) => acc?.[key], obj);
+  return path14.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1193,11 +1591,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path10, issues) {
+function prefixIssues(path14, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path10);
+    iss.path.unshift(path14);
     return iss;
   });
 }
@@ -1344,16 +1742,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path10 = []) => {
+  const processError = (error52, path14 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path10, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path14, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
       } else {
-        const fullpath = [...path10, ...issue2.path];
+        const fullpath = [...path14, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1380,17 +1778,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path10 = []) => {
+  const processError = (error52, path14 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path10, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path14, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
       } else {
-        const fullpath = [...path10, ...issue2.path];
+        const fullpath = [...path14, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1422,8 +1820,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path10 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path10) {
+  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")
@@ -14115,13 +14513,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path10 = ref.slice(1).split("/").filter(Boolean);
-  if (path10.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 (path10[0] === defsKey) {
-    const key = path10[1];
+  if (path14[0] === defsKey) {
+    const key = path14[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14584,6 +14982,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;
 
@@ -14637,6 +15085,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();
@@ -14697,6 +15151,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();
@@ -14706,6 +15164,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,
@@ -14725,12 +15187,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)
@@ -14741,11 +15218,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
@@ -14883,6 +15362,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) => {
@@ -14915,6 +15396,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)) {
@@ -15034,11 +15525,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"),
@@ -15164,6 +15657,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);
@@ -15463,233 +15972,198 @@ 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);
 
-// ../../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/node-runtime.js
-import path2 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 = path2.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();
+// dist/account-balance.js
+var DEEPSEEK_BALANCE_ENDPOINT = "https://api.deepseek.com/user/balance";
+var SUB2API_USAGE_PATH = "/v1/usage";
+var REQUEST_TIMEOUT_MS = 1e4;
+var MAX_PI_ACCOUNTS = 8;
+function agentDirectory(environment) {
+  const configured = environment.PI_CODING_AGENT_DIR?.trim();
+  if (configured)
+    return configured;
+  return path4.join(environment.HOME ?? environment.USERPROFILE ?? homedir2(), ".pi", "agent");
+}
+var record2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+async function deepSeekApiKey(environment) {
+  const auth = record2(JSON.parse(await readFile(path4.join(agentDirectory(environment), "auth.json"), "utf8")));
+  const deepseek = record2(auth.deepseek);
+  if (deepseek.type !== "api_key")
+    return void 0;
+  return typeof deepseek.key === "string" && deepseek.key.trim() ? deepseek.key : void 0;
 }
-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 projectSub2ApiUsage(payload, providerId) {
+  const data = record2(payload);
+  if (data.isValid === false)
+    return null;
+  if (data.mode !== "unrestricted" && data.mode !== "quota_limited")
+    return null;
+  const currency = typeof data.unit === "string" ? data.unit.trim() : "";
+  if (!/^[A-Z]{3}$/u.test(currency))
+    return null;
+  const wallet = finiteAmount(data.balance);
+  const remaining = finiteAmount(data.remaining);
+  const quotaRemaining = finiteAmount(record2(data.quota).remaining);
+  const amount = wallet ?? remaining ?? quotaRemaining;
+  if (amount === null)
+    return null;
+  const planName = typeof data.planName === "string" ? data.planName.trim() : "";
+  const label = providerId.trim();
+  if (!label || label.length > 128)
+    return null;
+  const parsed = harnessAccountSnapshotSchema.safeParse({
+    label,
+    ...planName ? { plan: planName.slice(0, 128) } : {},
+    balance: { amount, currency, label: planName || label }
+  });
+  return parsed.success ? parsed.data : null;
 }
-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 finiteAmount(value) {
+  const amount = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : Number.NaN;
+  return Number.isFinite(amount) && amount >= 0 ? amount : null;
 }
-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 projectDeepSeekBalance(payload) {
+  const data = record2(payload);
+  if (!Array.isArray(data.balance_infos))
+    return null;
+  const first = record2(data.balance_infos[0]);
+  const amount = finiteAmount(first.total_balance);
+  const currency = typeof first.currency === "string" ? first.currency.trim() : "";
+  if (amount === null || !currency)
+    return null;
+  const parsed = harnessAccountSnapshotSchema.safeParse({
+    label: "DeepSeek",
+    balance: { amount, currency, label: "DeepSeek API" }
   });
-  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;
+  return parsed.success ? parsed.data : null;
 }
-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" }];
+function usageEndpoint(baseUrl) {
+  let url2;
+  try {
+    url2 = new URL(baseUrl);
+  } catch {
+    return null;
   }
-  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 (url2.protocol !== "https:" && url2.protocol !== "http:" || !url2.hostname)
+    return null;
+  url2.username = "";
+  url2.password = "";
+  url2.pathname = SUB2API_USAGE_PATH;
+  url2.search = "";
+  url2.hash = "";
+  return url2.toString();
+}
+async function configuredSub2ApiProviders(environment) {
+  try {
+    const models = record2(JSON.parse(await readFile(path4.join(agentDirectory(environment), "models.json"), "utf8")));
+    const providers = record2(models.providers);
+    const found = [];
+    for (const [id, definition] of Object.entries(providers)) {
+      const provider = record2(definition);
+      const apiKey = typeof provider.apiKey === "string" ? provider.apiKey.trim() : "";
+      const baseUrl = typeof provider.baseUrl === "string" ? provider.baseUrl.trim() : "";
+      if (!id.trim() || id.length > 128 || !apiKey || !usageEndpoint(baseUrl))
+        continue;
+      found.push({ id, apiKey, baseUrl });
     }
+    return found.sort((left, right) => left.id.localeCompare(right.id));
+  } catch {
+    return [];
   }
-  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"
-      });
-    }
+}
+async function fetchSub2ApiBalance(provider, fetchImpl, signal) {
+  const endpoint = usageEndpoint(provider.baseUrl);
+  if (!endpoint)
+    return null;
+  const response = await fetchImpl(endpoint, {
+    headers: { Authorization: `Bearer ${provider.apiKey}`, Accept: "application/json" },
+    redirect: "error",
+    signal
+  });
+  if (!response.ok)
+    return null;
+  return projectSub2ApiUsage(await response.json(), provider.id);
+}
+async function fetchPiAccounts(input = {}) {
+  try {
+    const environment = input.environment ?? process.env;
+    const fetchImpl = input.fetch ?? fetch;
+    const signal = input.signal ? AbortSignal.any([input.signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)]) : AbortSignal.timeout(REQUEST_TIMEOUT_MS);
+    const [providers, deepseek] = await Promise.all([
+      input.readProviders ? input.readProviders() : configuredSub2ApiProviders(environment),
+      fetchPiAccountBalance({ ...input, environment, fetch: fetchImpl, signal })
+    ]);
+    const wallets = await Promise.all(providers.filter((provider) => provider.apiKey.trim() && usageEndpoint(provider.baseUrl)).map((provider) => fetchSub2ApiBalance(provider, fetchImpl, signal).catch(() => null)));
+    return [...wallets, deepseek].filter((account) => account !== null).slice(0, MAX_PI_ACCOUNTS);
+  } catch {
+    return [];
   }
-  return candidates;
 }
-function resolveHarnessExecutable(spec, input, dependencies = {}) {
-  const platform = input.platform ?? process.platform;
-  const isExecutable = dependencies.isExecutable ?? ((candidate) => isExecutableFile(candidate, platform));
-  const runnable = spec.runnableCandidate ?? ((candidate) => candidate);
-  const context = { platform, isExecutable };
-  for (const { candidate, source } of harnessCandidates(spec, input, dependencies)) {
-    const executable = runnable(candidate, context);
-    if (executable !== void 0 && isExecutable(executable))
-      return { executable, source };
+async function fetchPiAccountBalance(input) {
+  try {
+    const key = await (input.readApiKey ? input.readApiKey() : deepSeekApiKey(input.environment));
+    if (!key)
+      return null;
+    const response = await input.fetch(DEEPSEEK_BALANCE_ENDPOINT, {
+      headers: { Authorization: `Bearer ${key}`, Accept: "application/json" },
+      signal: input.signal
+    });
+    if (!response.ok)
+      return null;
+    return projectDeepSeekBalance(await response.json());
+  } catch {
+    return null;
   }
-  return void 0;
 }
 
+// dist/pi-credential-imports.js
+import { randomUUID } from "node:crypto";
+import { execFile as execFile2 } from "node:child_process";
+import { promisify } from "node:util";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync, readdirSync, lstatSync, renameSync, rmdirSync } from "node:fs";
+import { realpath } from "node:fs/promises";
+import os2 from "node:os";
+import path6 from "node:path";
+import { pathToFileURL } from "node:url";
+
 // dist/command.js
+import fs2 from "node:fs";
+import { homedir as homedir3, tmpdir as tmpdir2 } from "node:os";
+import path5 from "node:path";
 var piDiscoverySpec = {
   id: "pi",
   command: "pi",
@@ -15714,6 +16188,34 @@ function resolvePiExecutable(input, dependencies = {}) {
   }, { ...dependencies.isExecutable ? { isExecutable: dependencies.isExecutable } : {} });
   return resolution?.executable ?? input.command ?? input.environment.PI_COMMAND ?? "pi";
 }
+function isFilesystemRoot(cwd) {
+  const resolved = path5.resolve(cwd);
+  return resolved === path5.parse(resolved).root;
+}
+function writableDirectory(candidate) {
+  if (!candidate || !path5.isAbsolute(candidate) || isFilesystemRoot(candidate))
+    return void 0;
+  try {
+    if (!fs2.statSync(candidate).isDirectory())
+      return void 0;
+    fs2.accessSync(candidate, fs2.constants.R_OK | fs2.constants.W_OK);
+    return candidate;
+  } catch {
+    return void 0;
+  }
+}
+function resolvePiInspectCwd(inputCwd, environment = process.env) {
+  if (typeof inputCwd === "string" && inputCwd.length > 0 && !isFilesystemRoot(inputCwd)) {
+    return path5.resolve(inputCwd);
+  }
+  const candidates = [environment.USERPROFILE, environment.HOME, homedir3(), tmpdir2()];
+  for (const candidate of candidates) {
+    const usable = writableDirectory(candidate);
+    if (usable)
+      return usable;
+  }
+  return inputCwd && inputCwd.length > 0 ? path5.resolve(inputCwd) : process.cwd();
+}
 
 // dist/pi-credential-imports.js
 var PREFIX = "codexhost-account-";
@@ -15756,6 +16258,15 @@ function describeOauth(credential) {
     ...match ? { vendor: match.vendor } : {}
   };
 }
+function readPiCodexProviderNames(environment) {
+  const agentDir = environment.PI_CODING_AGENT_DIR ?? path6.join(environment.HOME ?? environment.USERPROFILE ?? os2.homedir(), ".pi/agent");
+  try {
+    const auth = parseAuth(readFileSync(path6.join(agentDir, "auth.json"), "utf8"));
+    return Object.entries(auth).filter(([, credential]) => describeOauth(credential).vendor === "openai-codex").map(([provider]) => provider);
+  } catch {
+    return [];
+  }
+}
 function writeAuth(filename, content) {
   const temporary = `${filename}.${randomUUID()}.tmp`;
   try {
@@ -15766,8 +16277,8 @@ function writeAuth(filename, content) {
   }
 }
 function removeOwnedFiles(dir) {
-  rmSync(path3.join(dir, "index.ts"), { force: true });
-  rmSync(path3.join(dir, "import.json"), { force: true });
+  rmSync(path6.join(dir, "index.ts"), { force: true });
+  rmSync(path6.join(dir, "import.json"), { force: true });
   try {
     rmdirSync(dir);
   } catch {
@@ -15775,26 +16286,26 @@ function removeOwnedFiles(dir) {
 }
 async function installation(command, environment, authPath) {
   const executable = await realpath(resolvePiExecutable({ ...command ? { command } : {}, environment }));
-  let directory = path3.dirname(executable);
+  let directory = path6.dirname(executable);
   while (true) {
-    const manifest = path3.join(directory, "package.json");
+    const manifest = path6.join(directory, "package.json");
     if (existsSync(manifest)) {
       const pkg = JSON.parse(readFileSync(manifest, "utf8"));
       if (pkg.name === "@earendil-works/pi-coding-agent")
         break;
     }
-    const parent = path3.dirname(directory);
+    const parent = path6.dirname(directory);
     if (parent === directory)
       throw new Error("Pi credential import requires a supported npm Pi installation");
     directory = parent;
   }
-  const storage = await import(pathToFileURL(path3.join(directory, "dist/core/auth-storage.js")).href);
-  const ai = path3.join(directory, "node_modules/@earendil-works/pi-ai/dist");
-  const all = await import(pathToFileURL(path3.join(ai, "providers/all.js")).href);
+  const storage = await import(pathToFileURL(path6.join(directory, "dist/core/auth-storage.js")).href);
+  const ai = path6.join(directory, "node_modules/@earendil-works/pi-ai/dist");
+  const all = await import(pathToFileURL(path6.join(ai, "providers/all.js")).href);
   const providers = all.getBuiltinProviders();
   const providerModules = {
-    "openai-codex": pathToFileURL(path3.join(ai, "providers/openai-codex.js")).href,
-    xai: pathToFileURL(path3.join(ai, "providers/xai.js")).href
+    "openai-codex": pathToFileURL(path6.join(ai, "providers/openai-codex.js")).href,
+    xai: pathToFileURL(path6.join(ai, "providers/xai.js")).href
   };
   for (const [id, url2] of Object.entries(providerModules)) {
     const module = await import(url2);
@@ -15807,9 +16318,9 @@ async function installation(command, environment, authPath) {
     providerModules,
     reservedNames: providers.map((p) => typeof p === "string" ? p : p.id),
     async configuredProviderNames() {
-      const { stdout } = await promisify(execFile)(process.execPath, [executable, "--offline", "--no-approve", "--list-models"], {
-        cwd: existsSync(path3.dirname(authPath)) ? path3.dirname(authPath) : os2.homedir(),
-        env: { ...environment, PI_CODING_AGENT_DIR: path3.dirname(authPath), PI_OFFLINE: "1" },
+      const { stdout } = await promisify(execFile2)(process.execPath, [executable, "--offline", "--no-approve", "--list-models"], {
+        cwd: existsSync(path6.dirname(authPath)) ? path6.dirname(authPath) : os2.homedir(),
+        env: { ...environment, PI_CODING_AGENT_DIR: path6.dirname(authPath), PI_OFFLINE: "1" },
         timeout: 15e3,
         maxBuffer: 4 * 1024 * 1024
       });
@@ -15839,26 +16350,26 @@ export default async function (pi) {
 }
 function createPiCredentialImports(options = {}) {
   const env = { ...process.env, ...options.environment };
-  const agentDir = env.PI_CODING_AGENT_DIR ?? path3.join(env.HOME ?? os2.homedir(), ".pi/agent");
-  const authPath = path3.join(agentDir, "auth.json");
-  const extensionsDir = path3.join(agentDir, "extensions");
+  const agentDir = env.PI_CODING_AGENT_DIR ?? path6.join(env.HOME ?? os2.homedir(), ".pi/agent");
+  const authPath = path6.join(agentDir, "auth.json");
+  const extensionsDir = path6.join(agentDir, "extensions");
   const saveAuth = (auth) => (options.writeAuth ?? writeAuth)(authPath, JSON.stringify(auth, null, 2) + "\n");
   const resolve = () => options.resolveInstallation?.(authPath) ?? installation(options.command, env, authPath);
-  const location = (name) => path3.join(extensionsDir, `${PREFIX}${credentialImportNameSchema.parse(name)}`);
+  const location = (name) => path6.join(extensionsDir, `${PREFIX}${credentialImportNameSchema.parse(name)}`);
   const readRecord = (name) => {
     const dir = location(name);
     if (lstatSync(dir).isSymbolicLink())
       throw new Error("Imported configuration was changed; manage it in Pi");
-    const value = JSON.parse(readFileSync(path3.join(dir, "import.json"), "utf8"));
+    const value = JSON.parse(readFileSync(path6.join(dir, "import.json"), "utf8"));
     if (value.version !== 1 || typeof value.owner !== "string" || typeof value.extension !== "string")
       throw new Error("Invalid import metadata");
-    const record6 = value.record;
-    if (!object2(record6))
+    const record7 = value.record;
+    if (!object2(record7))
       throw new Error("Invalid import metadata");
     value.record = credentialImportRecordSchema.parse({
-      name: record6.name,
-      source: record6.source,
-      importedAt: record6.importedAt
+      name: record7.name,
+      source: record7.source,
+      importedAt: record7.importedAt
     });
     if (value.record.name !== name)
       throw new Error("Import identity mismatch");
@@ -15866,7 +16377,7 @@ function createPiCredentialImports(options = {}) {
   };
   const owned = (meta3, auth) => {
     const credential = auth[meta3.record.name];
-    const file2 = path3.join(location(meta3.record.name), "index.ts");
+    const file2 = path6.join(location(meta3.record.name), "index.ts");
     return existsSync(file2) && !lstatSync(file2).isSymbolicLink() && readFileSync(file2, "utf8") === meta3.extension && object2(credential) && credential.type === "oauth" && credential.codexhostImportId === meta3.owner;
   };
   const readAuth = () => existsSync(authPath) ? parseAuth(readFileSync(authPath, "utf8")) : {};
@@ -15880,7 +16391,7 @@ function createPiCredentialImports(options = {}) {
       const name = entry.slice(PREFIX.length);
       if (!credentialImportNameSchema.safeParse(name).success)
         continue;
-      if (!existsSync(path3.join(location(name), "import.json")))
+      if (!existsSync(path6.join(location(name), "import.json")))
         continue;
       try {
         const meta3 = readRecord(name);
@@ -15901,7 +16412,7 @@ function createPiCredentialImports(options = {}) {
     },
     async listOthers() {
       const auth = readAuth();
-      const ours = new Set(ownedRecords(auth).map((record6) => record6.name));
+      const ours = new Set(ownedRecords(auth).map((record7) => record7.name));
       const result = /* @__PURE__ */ new Map();
       const usable = (provider) => Boolean(provider) && provider.length <= 128 && !ours.has(provider) && !result.has(provider);
       for (const [provider, credential] of Object.entries(auth)) {
@@ -15914,7 +16425,7 @@ function createPiCredentialImports(options = {}) {
           ...describeOauth(credential)
         });
       }
-      const modelsPath = path3.join(agentDir, "models.json");
+      const modelsPath = path6.join(agentDir, "models.json");
       if (existsSync(modelsPath)) {
         const models = JSON.parse(readFileSync(modelsPath, "utf8"));
         const providers = object2(models) && object2(models.providers) ? models.providers : {};
@@ -15936,7 +16447,7 @@ function createPiCredentialImports(options = {}) {
       if (sdk.reservedNames.includes(name) || (await sdk.configuredProviderNames?.())?.includes(name))
         throw new Error("Provider name already exists; choose another name");
       const owner = randomUUID();
-      const record6 = credentialImportRecordSchema.parse({
+      const record7 = credentialImportRecordSchema.parse({
         name,
         source: transfer.source,
         importedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -15948,15 +16459,15 @@ function createPiCredentialImports(options = {}) {
       try {
         sdk.backend.withLock((current) => {
           const auth = parseAuth(current);
-          const modelsPath = path3.join(agentDir, "models.json");
+          const modelsPath = path6.join(agentDir, "models.json");
           const models = existsSync(modelsPath) ? JSON.parse(readFileSync(modelsPath, "utf8")) : {};
-          if (Object.hasOwn(auth, name) || Object.hasOwn(models.providers ?? {}, name) || existsSync(dir) || existsSync(path3.join(extensionsDir, `${name}-provider.ts`)))
+          if (Object.hasOwn(auth, name) || Object.hasOwn(models.providers ?? {}, name) || existsSync(dir) || existsSync(path6.join(extensionsDir, `${name}-provider.ts`)))
             throw new Error("Provider name already exists; choose another name");
           mkdirSync(extensionsDir, { recursive: true, mode: 448 });
           mkdirSync(dir, { mode: 448 });
           created = true;
-          writeFileSync(path3.join(dir, "import.json"), JSON.stringify({ version: 1, owner, record: record6, extension }), { flag: "wx", mode: 384 });
-          writeFileSync(path3.join(dir, "index.ts"), extension, { flag: "wx", mode: 384 });
+          writeFileSync(path6.join(dir, "import.json"), JSON.stringify({ version: 1, owner, record: record7, extension }), { flag: "wx", mode: 384 });
+          writeFileSync(path6.join(dir, "index.ts"), extension, { flag: "wx", mode: 384 });
           auth[name] = { type: "oauth", ...transfer.oauth, codexhostImportId: owner };
           saveAuth(auth);
           committed = true;
@@ -15975,7 +16486,7 @@ function createPiCredentialImports(options = {}) {
         const auth = parseAuth(current);
         if (!owned(meta3, auth) || meta3.record.source.id !== transfer.source.id || meta3.record.source.provider !== transfer.source.provider)
           throw new Error("Import ownership or source account changed; refusing replacement");
-        const metadataPath = path3.join(location(name), "import.json");
+        const metadataPath = path6.join(location(name), "import.json");
         const previous = readFileSync(metadataPath, "utf8");
         const updated = {
           ...meta3,
@@ -16009,15 +16520,229 @@ function createPiCredentialImports(options = {}) {
   };
 }
 
+// dist/pi-fast-mode.js
+import { createHash, randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir, readFile as readFile2, rename, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import path7 from "node:path";
+
+// dist/pi-model-catalog.js
+var PI_MODEL_REF_PREFIX = "pi-model-v1.";
+var PI_DRAFT_THINKING_OPTION_IDS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+].map((id) => harnessThinkingOptionIdSchema.parse(id));
+var PI_THINKING_LABELS = {
+  off: "Off",
+  minimal: "Minimal",
+  low: "Low",
+  medium: "Medium",
+  high: "High",
+  xhigh: "Extra High",
+  max: "Max"
+};
+function compareText(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function assertNativePart(value, name) {
+  if (value.trim().length === 0)
+    throw new Error(`Pi ${name} must not be empty`);
+}
+function encodePiModelRef(model) {
+  assertNativePart(model.provider, "Model provider");
+  assertNativePart(model.id, "Model id");
+  const encoded = Buffer.from(JSON.stringify(model.fast ? [model.provider, model.id, true] : [model.provider, model.id]), "utf8").toString("base64url");
+  return harnessModelRefSchema.parse({ id: `${PI_MODEL_REF_PREFIX}${encoded}` });
+}
+function decodePiModelRef(ref) {
+  const parsedRef = harnessModelRefSchema.parse(ref);
+  if (!parsedRef.id.startsWith(PI_MODEL_REF_PREFIX)) {
+    throw new Error("Model Ref does not belong to PiAdapter");
+  }
+  const encoded = parsedRef.id.slice(PI_MODEL_REF_PREFIX.length);
+  let decoded;
+  try {
+    decoded = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+  } catch {
+    throw new Error("Pi Model Ref is malformed");
+  }
+  if (!Array.isArray(decoded) || decoded.length !== 2 && !(decoded.length === 3 && decoded[2] === true) || typeof decoded[0] !== "string" || typeof decoded[1] !== "string") {
+    throw new Error("Pi Model Ref has an invalid native identity");
+  }
+  const native = {
+    provider: decoded[0],
+    id: decoded[1],
+    ...decoded[2] === true ? { fast: true } : {}
+  };
+  assertNativePart(native.provider, "Model provider");
+  assertNativePart(native.id, "Model id");
+  if (encodePiModelRef(native).id !== parsedRef.id) {
+    throw new Error("Pi Model Ref is not canonical");
+  }
+  return native;
+}
+function samePiModel(left, right) {
+  return left === null ? right === null : right !== null && left.provider === right.provider && left.id === right.id;
+}
+function fallbackThinkingLabel(id) {
+  const label = id.split(/[._~-]+/u).filter((part) => part.length > 0).map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join(" ");
+  return label || id;
+}
+function normalizePiThinkingOptions(levels) {
+  return levels.map((id) => harnessThinkingOptionSchema.parse({
+    id,
+    label: PI_THINKING_LABELS[id] ?? fallbackThinkingLabel(id)
+  }));
+}
+function normalizePiModelCatalog(nativeModels, effectiveModel, thinkingLevels, effectiveThinkingOptionId) {
+  const byRef = /* @__PURE__ */ new Map();
+  for (const native of nativeModels) {
+    const ref = encodePiModelRef(native);
+    const existing = byRef.get(ref.id);
+    if (existing) {
+      if (existing.reasoning !== native.reasoning) {
+        throw new Error("Pi duplicate Model entries disagree on reasoning capability");
+      }
+      continue;
+    }
+    byRef.set(ref.id, {
+      model: {
+        ref,
+        label: `${native.provider} / ${native.id}`
+      },
+      reasoning: native.reasoning
+    });
+  }
+  const defaultModel = effectiveModel ? encodePiModelRef(effectiveModel) : void 0;
+  if (defaultModel && !byRef.has(defaultModel.id)) {
+    throw new Error("Pi effective Model is absent from the available Model catalog");
+  }
+  if (thinkingLevels && effectiveThinkingOptionId && !thinkingLevels.includes(effectiveThinkingOptionId)) {
+    throw new Error("Pi effective Thinking option is absent from the available option catalog");
+  }
+  if (thinkingLevels && !effectiveThinkingOptionId) {
+    throw new Error("Pi did not report an effective Thinking option");
+  }
+  const thinkingOptions = thinkingLevels ? normalizePiThinkingOptions(PI_DRAFT_THINKING_OPTION_IDS) : [];
+  const allThinkingOptionIds = thinkingOptions.map(({ id }) => id);
+  const offThinkingOptionId = thinkingOptions.find(({ id }) => id === "off")?.id;
+  const models = [...byRef.values()].map(({ model, reasoning }) => ({
+    ...model,
+    supportedThinkingOptionIds: reasoning ? allThinkingOptionIds : offThinkingOptionId ? [offThinkingOptionId] : []
+  })).sort((left, right) => compareText(left.label, right.label) || compareText(left.ref.id, right.ref.id));
+  const defaultThinkingOptionId = thinkingOptions.find(({ id }) => id === effectiveThinkingOptionId)?.id;
+  return harnessModelCatalogSchema.parse({
+    models,
+    ...defaultModel ? { defaultModel } : {},
+    thinkingOptions,
+    ...defaultThinkingOptionId ? { defaultThinkingOptionId } : {}
+  });
+}
+
+// dist/pi-fast-mode.js
+var PI_FAST_COMMAND = "codexhost-fast-mode";
+var PI_FAST_ACK = "codexhost-fast-mode:";
+var PI_FAST_EXTENSION = `export default function(pi) {
+  let target;
+  const wrapped = new Set();
+  pi.on("model_select", (_event, ctx) => {
+    if (target && (target.provider !== ctx.model?.provider || target.id !== ctx.model?.id || ctx.model?.api !== "openai-codex-responses")) target = undefined;
+  });
+  pi.on("session_start", (_event, ctx) => {
+    if (typeof ctx.modelRegistry.getProvider !== "function") return;
+    pi.registerCommand("${PI_FAST_COMMAND}", {
+      description: "Codex Host Fast mode",
+      handler: async (args, ctx) => {
+        const [mode, nonce] = args.split(" ");
+        if (!nonce || (mode !== "on" && mode !== "off")) throw new Error("Invalid Fast selection");
+        if (mode === "on") {
+          const model = ctx.model;
+          if (!model || model.api !== "openai-codex-responses") throw new Error("Fast requires the Codex API");
+          const original = ctx.modelRegistry.getProvider(model.provider);
+          if (!original) throw new Error("Codex Provider is unavailable");
+          if (!wrapped.has(model.provider)) {
+            const options = (model, value) => target && model.api === "openai-codex-responses" && target.provider === model.provider && target.id === model.id
+              ? {
+                  ...value,
+                  serviceTier: "priority",
+                  // Pi streamSimple drops serviceTier but preserves onPayload.
+                  onPayload: async (payload, requestModel) => {
+                    const request = { ...payload, service_tier: "priority" };
+                    const replacement = await value?.onPayload?.(request, requestModel);
+                    return { ...(replacement === undefined ? request : replacement), service_tier: "priority" };
+                  },
+                } : value;
+            pi.registerProvider({
+              ...original,
+              stream: (model, context, value) => original.stream(model, context, options(model, value)),
+              streamSimple: (model, context, value) => original.streamSimple(model, context, options(model, value)),
+            });
+            wrapped.add(model.provider);
+          }
+          target = { provider: model.provider, id: model.id };
+        } else target = undefined;
+        ctx.ui.notify("${PI_FAST_ACK}" + nonce + ":" + mode, "info");
+      },
+    });
+  });
+}
+`;
+async function ensurePiFastExtension(environment) {
+  const digest = createHash("sha256").update(PI_FAST_EXTENSION).digest("hex").slice(0, 16);
+  const dataDirectory = environment.CODEXHOST_DATA_DIR ?? path7.join(environment.HOME ?? environment.USERPROFILE ?? homedir4(), ".codexhost");
+  const directory = path7.resolve(dataDirectory, "extensions", "pi-codex-fast");
+  const file2 = path7.join(directory, `${digest}.mjs`);
+  if (await readFile2(file2, "utf8").catch(() => "") === PI_FAST_EXTENSION)
+    return file2;
+  await mkdir(directory, { recursive: true });
+  const temporary = `${file2}.${randomUUID2()}.tmp`;
+  try {
+    await writeFile2(temporary, PI_FAST_EXTENSION, { mode: 384 });
+    try {
+      await rename(temporary, file2);
+    } catch (error51) {
+      if (await readFile2(file2, "utf8").catch(() => "") !== PI_FAST_EXTENSION)
+        throw error51;
+    }
+  } finally {
+    await rm2(temporary, { force: true });
+  }
+  return file2;
+}
+async function piFastModelKeys(models, environment) {
+  try {
+    const codexHome = environment.CODEX_HOME ?? path7.join(environment.HOME ?? environment.USERPROFILE ?? homedir4(), ".codex");
+    const cache = JSON.parse(await readFile2(path7.join(codexHome, "models_cache.json"), "utf8"));
+    if (!cache || typeof cache !== "object" || !("models" in cache) || !Array.isArray(cache.models))
+      return /* @__PURE__ */ new Set();
+    const priority = new Set(cache.models.filter((model) => typeof model?.slug === "string" && Array.isArray(model.service_tiers) && model.service_tiers.some((tier) => tier?.id === "priority")).map((model) => model.slug));
+    const codexProviders = new Set(readPiCodexProviderNames(environment));
+    return new Set(models.filter((model) => model.api === "openai-codex-responses" && codexProviders.has(model.provider) && priority.has(model.id)).map((model) => encodePiModelRef(model).id));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function withPiFast(catalog, supported) {
+  return {
+    ...catalog,
+    models: catalog.models.map((model) => supported.has(model.ref.id) ? { ...model, fastModel: encodePiModelRef({ ...decodePiModelRef(model.ref), fast: true }) } : model)
+  };
+}
+
 // dist/pi-empty-session.js
 import { createReadStream } from "node:fs";
 import { createInterface } from "node:readline";
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { link, open as open2, rm } from "node:fs/promises";
-import path4 from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { link, open as open2, rm as rm3 } from "node:fs/promises";
+import path8 from "node:path";
 
 // dist/pi-subagents.js
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 
 // dist/pi-subagent-workflow.js
 var PREFIX2 = "pi-subagents-workflow-v1:";
@@ -16031,23 +16756,23 @@ var STATES = {
   rejected: "failed",
   detached: "running"
 };
-function record2(value) {
+function record3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function text(value, limit = 256) {
   return typeof value === "string" && value.length > 0 && value.length <= limit;
 }
 function piWorkflowSummary(result) {
-  if (!record2(result) || !record2(result.details) || result.details.mode !== "workflow" || result.details.asyncId !== void 0)
+  if (!record3(result) || !record3(result.details) || result.details.mode !== "workflow" || result.details.asyncId !== void 0)
     return null;
   const details = result.details;
   const summary = details.workflowChildren;
-  if (!record2(summary) || summary.version !== 1 || !text(summary.workflowRunId) || summary.workflowRunId !== details.runId || !text(summary.parentToolCallId) || typeof summary.inventoryComplete !== "boolean" || !Array.isArray(summary.children) || summary.children.length > 256)
+  if (!record3(summary) || summary.version !== 1 || !text(summary.workflowRunId) || summary.workflowRunId !== details.runId || !text(summary.parentToolCallId) || typeof summary.inventoryComplete !== "boolean" || !Array.isArray(summary.children) || summary.children.length > 256)
     return null;
   const children = [];
   const seen = /* @__PURE__ */ new Set();
   for (const child of summary.children) {
-    if (!record2(child) || !text(child.childId) || seen.has(child.childId) || typeof child.state !== "string" || !Object.hasOwn(STATES, child.state))
+    if (!record3(child) || !text(child.childId) || seen.has(child.childId) || typeof child.state !== "string" || !Object.hasOwn(STATES, child.state))
       return null;
     for (const key of ["agent", "sessionName", "model", "thinking"]) {
       if (child[key] !== void 0 && !text(child[key], 2048))
@@ -16120,7 +16845,7 @@ var STATUS_PREFIX = "PI_SUBAGENT_ASYNC_JSON:";
 var INSPECT_PREFIX = "PI_SUBAGENT_INSPECT_JSON:";
 var ID_PREFIX = "pi-subagents-v1:";
 var MAX_BYTES = 64 * 1024;
-function record3(value) {
+function record4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function token(value) {
@@ -16137,7 +16862,7 @@ var statuses = {
   rejected: "failed"
 };
 function node(value, depth, budget) {
-  if (!record3(value) || depth > 8 || ++budget.count > 256 || !token(value.id) || !["subagent", "workflow", "step", "host-step"].includes(String(value.kind)) || typeof value.label !== "string" || value.label.length > 2048 || typeof value.state !== "string" || !Object.hasOwn(statuses, value.state))
+  if (!record4(value) || depth > 8 || ++budget.count > 256 || !token(value.id) || !["subagent", "workflow", "step", "host-step"].includes(String(value.kind)) || typeof value.label !== "string" || value.label.length > 2048 || typeof value.state !== "string" || !Object.hasOwn(statuses, value.state))
     return null;
   const children = [];
   if (value.children !== void 0) {
@@ -16159,14 +16884,14 @@ function node(value, depth, budget) {
   };
 }
 function widget(value, key, prefix) {
-  if (!record3(value) || value.type !== "extension_ui_request" || value.method !== "setWidget" || value.widgetKey !== key || !Array.isArray(value.widgetLines))
+  if (!record4(value) || value.type !== "extension_ui_request" || value.method !== "setWidget" || value.widgetKey !== key || !Array.isArray(value.widgetLines))
     return null;
   const line = value.widgetLines.find((part) => typeof part === "string" && part.startsWith(prefix));
   if (!line || Buffer.byteLength(line) > MAX_BYTES + prefix.length)
     return null;
   try {
     const parsed = JSON.parse(line.slice(prefix.length));
-    return record3(parsed) && parsed.version === 1 ? parsed : null;
+    return record4(parsed) && parsed.version === 1 ? parsed : null;
   } catch {
     return null;
   }
@@ -16230,7 +16955,7 @@ function states(run) {
   return result;
 }
 function asyncRunId(toolName, result) {
-  if (toolName !== "subagent" || !record3(result) || !record3(result.details))
+  if (toolName !== "subagent" || !record4(result) || !record4(result.details))
     return null;
   const details = result.details;
   return ["single", "parallel", "chain", "workflow"].includes(String(details.mode)) && token(details.asyncId) && typeof details.asyncDir === "string" ? details.asyncId : null;
@@ -16370,15 +17095,15 @@ function parsePiSubagentInspection(value) {
   const parsed = widget(value, "subagent-inspect", INSPECT_PREFIX);
   if (!parsed || parsed.kind !== "pi-subagents.inspect-reply" || !token(parsed.requestId))
     return null;
-  if (parsed.error !== void 0 && (!record3(parsed.error) || typeof parsed.error.code !== "string" || typeof parsed.error.message !== "string"))
+  if (parsed.error !== void 0 && (!record4(parsed.error) || typeof parsed.error.code !== "string" || typeof parsed.error.message !== "string"))
     return null;
   for (const field of ["asyncId", "childId", "status", "task", "finalOutput"]) {
     if (parsed[field] !== void 0 && typeof parsed[field] !== "string")
       return null;
   }
-  if (parsed.messages !== void 0 && (!Array.isArray(parsed.messages) || parsed.messages.length > 200 || parsed.messages.some((entry) => !record3(entry) || typeof entry.role !== "string" || typeof entry.text !== "string" || !["text", "toolCall", "toolResult"].includes(String(entry.kind)) || entry.name !== void 0 && typeof entry.name !== "string")))
+  if (parsed.messages !== void 0 && (!Array.isArray(parsed.messages) || parsed.messages.length > 200 || parsed.messages.some((entry) => !record4(entry) || typeof entry.role !== "string" || typeof entry.text !== "string" || !["text", "toolCall", "toolResult"].includes(String(entry.kind)) || entry.name !== void 0 && typeof entry.name !== "string")))
     return null;
-  if (parsed.truncated !== void 0 && (!record3(parsed.truncated) || typeof parsed.truncated.task !== "boolean" || typeof parsed.truncated.finalOutput !== "boolean" || !Number.isSafeInteger(parsed.truncated.messages) || Number(parsed.truncated.messages) < 0))
+  if (parsed.truncated !== void 0 && (!record4(parsed.truncated) || typeof parsed.truncated.task !== "boolean" || typeof parsed.truncated.finalOutput !== "boolean" || !Number.isSafeInteger(parsed.truncated.messages) || Number(parsed.truncated.messages) < 0))
     return null;
   return parsed;
 }
@@ -16397,7 +17122,7 @@ ${entry.text}`);
         nativeTurnRef: nativeTurnRefSchema.parse({
           harnessId: "pi",
           nativeSessionId: parentSessionId,
-          nativeTurnKey: `pi-subagent-${createHash("sha256").update(id).digest("hex")}`,
+          nativeTurnKey: `pi-subagent-${createHash2("sha256").update(id).digest("hex")}`,
           formatVersion: 1
         }),
         input: reply.task ? [{ type: "text", text: reply.task }] : [],
@@ -16405,7 +17130,7 @@ ${entry.text}`);
           item: {
             type: "agentMessage",
             text: text2,
-            itemId: hostItemIdSchema.parse(`pi-subagent-${createHash("sha256").update(`${id}:${index}:${text2}`).digest("hex")}`)
+            itemId: hostItemIdSchema.parse(`pi-subagent-${createHash2("sha256").update(`${id}:${index}:${text2}`).digest("hex")}`)
           },
           outcome: { status: "succeeded" }
         })),
@@ -16425,120 +17150,6 @@ ${entry.text}`);
   };
 }
 
-// dist/pi-model-catalog.js
-var PI_MODEL_REF_PREFIX = "pi-model-v1.";
-var PI_DRAFT_THINKING_OPTION_IDS = [
-  "off",
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-  "max"
-].map((id) => harnessThinkingOptionIdSchema.parse(id));
-var PI_THINKING_LABELS = {
-  off: "Off",
-  minimal: "Minimal",
-  low: "Low",
-  medium: "Medium",
-  high: "High",
-  xhigh: "Extra High",
-  max: "Max"
-};
-function compareText(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
-function assertNativePart(value, name) {
-  if (value.trim().length === 0)
-    throw new Error(`Pi ${name} must not be empty`);
-}
-function encodePiModelRef(model) {
-  assertNativePart(model.provider, "Model provider");
-  assertNativePart(model.id, "Model id");
-  const encoded = Buffer.from(JSON.stringify([model.provider, model.id]), "utf8").toString("base64url");
-  return harnessModelRefSchema.parse({ id: `${PI_MODEL_REF_PREFIX}${encoded}` });
-}
-function decodePiModelRef(ref) {
-  const parsedRef = harnessModelRefSchema.parse(ref);
-  if (!parsedRef.id.startsWith(PI_MODEL_REF_PREFIX)) {
-    throw new Error("Model Ref does not belong to PiAdapter");
-  }
-  const encoded = parsedRef.id.slice(PI_MODEL_REF_PREFIX.length);
-  let decoded;
-  try {
-    decoded = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
-  } catch {
-    throw new Error("Pi Model Ref is malformed");
-  }
-  if (!Array.isArray(decoded) || decoded.length !== 2 || typeof decoded[0] !== "string" || typeof decoded[1] !== "string") {
-    throw new Error("Pi Model Ref has an invalid native identity");
-  }
-  const native = { provider: decoded[0], id: decoded[1] };
-  assertNativePart(native.provider, "Model provider");
-  assertNativePart(native.id, "Model id");
-  if (encodePiModelRef(native).id !== parsedRef.id) {
-    throw new Error("Pi Model Ref is not canonical");
-  }
-  return native;
-}
-function samePiModel(left, right) {
-  return left === null ? right === null : right !== null && left.provider === right.provider && left.id === right.id;
-}
-function fallbackThinkingLabel(id) {
-  const label = id.split(/[._~-]+/u).filter((part) => part.length > 0).map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join(" ");
-  return label || id;
-}
-function normalizePiThinkingOptions(levels) {
-  return levels.map((id) => harnessThinkingOptionSchema.parse({
-    id,
-    label: PI_THINKING_LABELS[id] ?? fallbackThinkingLabel(id)
-  }));
-}
-function normalizePiModelCatalog(nativeModels, effectiveModel, thinkingLevels, effectiveThinkingOptionId) {
-  const byRef = /* @__PURE__ */ new Map();
-  for (const native of nativeModels) {
-    const ref = encodePiModelRef(native);
-    const existing = byRef.get(ref.id);
-    if (existing) {
-      if (existing.reasoning !== native.reasoning) {
-        throw new Error("Pi duplicate Model entries disagree on reasoning capability");
-      }
-      continue;
-    }
-    byRef.set(ref.id, {
-      model: {
-        ref,
-        label: `${native.provider} / ${native.id}`
-      },
-      reasoning: native.reasoning
-    });
-  }
-  const defaultModel = effectiveModel ? encodePiModelRef(effectiveModel) : void 0;
-  if (defaultModel && !byRef.has(defaultModel.id)) {
-    throw new Error("Pi effective Model is absent from the available Model catalog");
-  }
-  if (thinkingLevels && effectiveThinkingOptionId && !thinkingLevels.includes(effectiveThinkingOptionId)) {
-    throw new Error("Pi effective Thinking option is absent from the available option catalog");
-  }
-  if (thinkingLevels && !effectiveThinkingOptionId) {
-    throw new Error("Pi did not report an effective Thinking option");
-  }
-  const thinkingOptions = thinkingLevels ? normalizePiThinkingOptions(PI_DRAFT_THINKING_OPTION_IDS) : [];
-  const allThinkingOptionIds = thinkingOptions.map(({ id }) => id);
-  const offThinkingOptionId = thinkingOptions.find(({ id }) => id === "off")?.id;
-  const models = [...byRef.values()].map(({ model, reasoning }) => ({
-    ...model,
-    supportedThinkingOptionIds: reasoning ? allThinkingOptionIds : offThinkingOptionId ? [offThinkingOptionId] : []
-  })).sort((left, right) => compareText(left.label, right.label) || compareText(left.ref.id, right.ref.id));
-  const defaultThinkingOptionId = thinkingOptions.find(({ id }) => id === effectiveThinkingOptionId)?.id;
-  return harnessModelCatalogSchema.parse({
-    models,
-    ...defaultModel ? { defaultModel } : {},
-    thinkingOptions,
-    ...defaultThinkingOptionId ? { defaultThinkingOptionId } : {}
-  });
-}
-
 // dist/pi-history.js
 var piHarnessId = harnessIdSchema.parse("pi");
 function isRecord(value) {
@@ -16844,7 +17455,7 @@ async function verifyPiSessionCwd(input) {
 async function persistEmptyPiSession(input) {
   const { state: state2, history, sourceSessionFile, sourceSessionId, cwd } = input;
   const destination = state2.sessionFile;
-  if (!destination || !path4.isAbsolute(destination) || path4.resolve(destination) === path4.resolve(sourceSessionFile) || state2.sessionId === sourceSessionId || mapPiSnapshot(history, { sessionId: state2.sessionId, model: null }).turns.length !== 0)
+  if (!destination || !path8.isAbsolute(destination) || path8.resolve(destination) === path8.resolve(sourceSessionFile) || state2.sessionId === sourceSessionId || mapPiSnapshot(history, { sessionId: state2.sessionId, model: null }).turns.length !== 0)
     throw new Error("Pi empty Session is not an independent empty native fork");
   await verifyPiSessionCwd({
     sessionFile: sourceSessionFile,
@@ -16868,7 +17479,7 @@ async function persistEmptyPiSession(input) {
     cwd,
     parentSession: sourceSessionFile
   };
-  const temporary = path4.join(path4.dirname(destination), `.codexhost-${randomUUID2()}.tmp`);
+  const temporary = path8.join(path8.dirname(destination), `.codexhost-${randomUUID3()}.tmp`);
   try {
     const file2 = await open2(temporary, "wx", 384);
     try {
@@ -16879,7 +17490,7 @@ async function persistEmptyPiSession(input) {
     }
     await link(temporary, destination);
     if (process.platform !== "win32") {
-      const directory = await open2(path4.dirname(destination), "r");
+      const directory = await open2(path8.dirname(destination), "r");
       try {
         await directory.sync();
       } finally {
@@ -16887,7 +17498,7 @@ async function persistEmptyPiSession(input) {
       }
     }
   } finally {
-    await rm(temporary, { force: true });
+    await rm3(temporary, { force: true });
   }
 }
 async function readPiEmptySessionConfiguration(sessionFile) {
@@ -17042,16 +17653,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path10, added, removed, oldPosInc, options) {
-    const last = path10.lastComponent;
+  addToPath(path14, added, removed, oldPosInc, options) {
+    const last = path14.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path10.oldPos + oldPosInc,
+        oldPos: path14.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path10.oldPos + oldPosInc,
+        oldPos: path14.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -17463,8 +18074,8 @@ function splitLines(text2) {
 }
 
 // dist/pi-adapter.js
-import { randomUUID as randomUUID5 } from "node:crypto";
-import path9 from "node:path";
+import { randomUUID as randomUUID6 } from "node:crypto";
+import path13 from "node:path";
 
 // ../../harness-adapter/dist/question.js
 function invalidRequest(message3) {
@@ -17769,16 +18380,16 @@ function mergeLiveHarnessCommands(builtIns, idPrefix, live, exclusions = {}) {
 }
 
 // dist/pi-workflow-child-history.js
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { constants } from "node:fs";
 import { open as open3 } from "node:fs/promises";
-import path5 from "node:path";
-function record4(value) {
+import path9 from "node:path";
+function record5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var MAX_SESSION_BYTES = 8 * 1024 * 1024;
 async function childHistory(file2, parentSessionId, identity) {
-  if (!path5.isAbsolute(file2))
+  if (!path9.isAbsolute(file2))
     throw new Error("Pi child Session path is not absolute");
   const handle = await open3(file2, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
   try {
@@ -17791,18 +18402,18 @@ async function childHistory(file2, parentSessionId, identity) {
       throw new Error("Pi child Session exceeds read bounds");
     const values = buffer.subarray(0, bytesRead).toString("utf8").split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
     const header = values[0];
-    if (!record4(header) || header.type !== "session" || typeof header.id !== "string" || header.version !== 3)
+    if (!record5(header) || header.type !== "session" || typeof header.id !== "string" || header.version !== 3)
       throw new Error("Unsupported Pi child Session header");
     const entries = [];
     for (const entry of values.slice(1)) {
       const parsed = jsonValueSchema.safeParse(entry);
-      if (!parsed.success || !record4(parsed.data) || typeof parsed.data.id !== "string")
+      if (!parsed.success || !record5(parsed.data) || typeof parsed.data.id !== "string")
         throw new Error("Malformed Pi child Session entry");
       entries.push(parsed.data);
     }
     const history = { entries, leafId: String(entries.at(-1)?.id ?? "") || null };
     const snapshot = mapPiSnapshot(history, { sessionId: parentSessionId, model: null });
-    const prefix = createHash2("sha256").update(identity).digest("hex");
+    const prefix = createHash3("sha256").update(identity).digest("hex");
     return {
       turns: snapshot.turns.map((turn) => {
         const readonlyTurn = {
@@ -17823,7 +18434,7 @@ async function childHistory(file2, parentSessionId, identity) {
 async function readPiWorkflowChild(history, parentSessionId, address) {
   for (const entry of activePiEntries(history).reverse()) {
     const message3 = entry.message;
-    if (!record4(message3) || message3.role !== "toolResult" || message3.toolName !== "subagent")
+    if (!record5(message3) || message3.role !== "toolResult" || message3.toolName !== "subagent")
       continue;
     const summary = piWorkflowSummary(message3);
     if (!summary || summary.workflowRunId !== address.workflowRunId || summary.parentToolCallId !== message3.toolCallId)
@@ -17832,10 +18443,10 @@ async function readPiWorkflowChild(history, parentSessionId, address) {
     if (!child)
       break;
     const details = message3.details;
-    if (!record4(details) || !Array.isArray(details.results))
+    if (!record5(details) || !Array.isArray(details.results))
       break;
-    const result = details.results.findLast((candidate) => record4(candidate) && candidate.workflowKey === address.childId);
-    if (!record4(result))
+    const result = details.results.findLast((candidate) => record5(candidate) && candidate.workflowKey === address.childId);
+    if (!record5(result))
       break;
     const id = piWorkflowSubagentId(address);
     if (typeof result.sessionFile === "string") {
@@ -17881,22 +18492,22 @@ ${output}`,
 // dist/pi-subagent-history.js
 import { constants as constants2 } from "node:fs";
 import { open as open4 } from "node:fs/promises";
-import path6 from "node:path";
-function record5(value) {
+import path10 from "node:path";
+function record6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function state(value) {
   return value === "pending" ? "queued" : value === "completed" ? "complete" : value;
 }
 function piSubagentArtifact(value, runId, parentSessionId) {
-  if (!record5(value) || value.lifecycleArtifactVersion !== 3 || value.runId !== runId || value.sessionId !== parentSessionId || !["single", "parallel", "chain", "workflow"].includes(String(value.mode)))
+  if (!record6(value) || value.lifecycleArtifactVersion !== 3 || value.runId !== runId || value.sessionId !== parentSessionId || !["single", "parallel", "chain", "workflow"].includes(String(value.mode)))
     return null;
   if (value.steps !== void 0 && (!Array.isArray(value.steps) || value.steps.length > 128))
     return null;
   const steps = Array.isArray(value.steps) ? value.steps : [];
   const children = [];
   for (const [index, step] of steps.entries()) {
-    if (!record5(step) || typeof step.agent !== "string")
+    if (!record6(step) || typeof step.agent !== "string")
       return null;
     children.push({
       id: step.workflowKey ?? step.runId ?? `step:${index}`,
@@ -17929,17 +18540,17 @@ function piSubagentArtifact(value, runId, parentSessionId) {
 async function restorePiSubagents(history, parentSessionId, observer) {
   const receipts = /* @__PURE__ */ new Map();
   for (const entry of activePiEntries(history)) {
-    if (!record5(entry.message) || entry.message.role !== "toolResult" || entry.message.toolName !== "subagent" || entry.message.isError !== false || !record5(entry.message.details))
+    if (!record6(entry.message) || entry.message.role !== "toolResult" || entry.message.toolName !== "subagent" || entry.message.isError !== false || !record6(entry.message.details))
       continue;
     const details = entry.message.details;
-    if (!["single", "parallel", "chain", "workflow"].includes(String(details.mode)) || typeof details.asyncId !== "string" || typeof details.asyncDir !== "string" || !path6.isAbsolute(details.asyncDir) || path6.basename(details.asyncDir) !== details.asyncId)
+    if (!["single", "parallel", "chain", "workflow"].includes(String(details.mode)) || typeof details.asyncId !== "string" || typeof details.asyncDir !== "string" || !path10.isAbsolute(details.asyncDir) || path10.basename(details.asyncDir) !== details.asyncId)
       continue;
     receipts.set(details.asyncId, details.asyncDir);
   }
   for (const [id, directory] of [...receipts].slice(-128)) {
     let file2;
     try {
-      file2 = await open4(path6.join(directory, "status.json"), constants2.O_RDONLY | (constants2.O_NOFOLLOW ?? 0));
+      file2 = await open4(path10.join(directory, "status.json"), constants2.O_RDONLY | (constants2.O_NOFOLLOW ?? 0));
       const stat2 = await file2.stat();
       if (!stat2.isFile() || stat2.size > 1024 * 1024)
         continue;
@@ -18021,24 +18632,109 @@ async function rollbackPiLastTurn(transport, sourceSessionId, cwd) {
 import { createReadStream as createReadStream2 } from "node:fs";
 import { opendir, realpath as realpath3, stat } from "node:fs/promises";
 import os3 from "node:os";
-import path7 from "node:path";
+import path11 from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
-var PiSessionChangedError = class extends Error {
-  constructor() {
-    super("Pi Session changed during discovery; refresh and retry");
+
+// ../../harness-adapter/dist/session-import.js
+var SessionImportChangedError = class extends Error {
+  constructor(message3 = "Native Session changed during discovery; refresh and retry") {
+    super(message3);
+    this.name = "SessionImportChangedError";
   }
 };
-function sameFile(left, right) {
-  return left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs && left.ino === right.ino && left.dev === right.dev;
+function isMissingFileError(error51) {
+  return typeof error51 === "object" && error51 !== null && "code" in error51 && error51.code === "ENOENT";
+}
+function sameFileFingerprint(left, right) {
+  return left === null || right === null ? left === right : left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
+}
+function sessionImportTitle(value, maxLength = HARNESS_SESSION_IMPORT_TITLE_MAX_LENGTH) {
+  if (typeof value !== "string")
+    return null;
+  const normalized = value.replaceAll("\0", "").replaceAll(/\s+/gu, " ").trim();
+  if (!normalized)
+    return null;
+  if (normalized.length <= maxLength)
+    return normalized;
+  const characters = [...normalized];
+  if (characters.length <= maxLength)
+    return normalized;
+  return `${characters.slice(0, maxLength - 1).join("").trimEnd()}…`;
+}
+function sessionImportCandidate(input) {
+  const time3 = typeof input.updatedAt === "number" ? input.updatedAt : typeof input.updatedAt === "string" ? Date.parse(input.updatedAt) : Number.NaN;
+  const parsed = harnessSessionImportCandidateSchema.safeParse({
+    nativeSessionId: input.nativeSessionId,
+    cwd: input.cwd,
+    title: typeof input.title === "string" && input.title.trim().length > 0 ? input.title : null,
+    updatedAt: Math.floor(time3),
+    // Unknown must stay unknown; only an explicit boolean is a native statement.
+    running: typeof input.running === "boolean" ? input.running : null
+  });
+  return parsed.success ? parsed.data : null;
 }
+var SessionImportScope = class {
+  #abort = new AbortController();
+  #options;
+  #pending = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.#options = options;
+  }
+  #closed() {
+    return {
+      ok: false,
+      error: { code: "invalidState", message: this.#options.closedMessage, retryable: false }
+    };
+  }
+  read(operation) {
+    const signal = this.#abort.signal;
+    if (signal.aborted)
+      return Promise.resolve(this.#closed());
+    let started;
+    try {
+      started = operation(signal);
+    } catch (error51) {
+      started = Promise.reject(error51 instanceof Error ? error51 : new Error("Session read failed"));
+    }
+    const request = started.then((value) => signal.aborted ? this.#closed() : { ok: true, value }).catch(() => signal.aborted ? this.#closed() : {
+      ok: false,
+      error: {
+        code: "unavailable",
+        message: this.#options.unavailableMessage,
+        retryable: true
+      }
+    }).finally(() => this.#pending.delete(request));
+    this.#pending.add(request);
+    return request;
+  }
+  /** `read` for `resolveCandidate`: a null source is the selected Session having disappeared. */
+  async resolve(operation) {
+    const result = await this.read(operation);
+    if (!result.ok)
+      return result;
+    return result.value ? { ok: true, value: result.value } : {
+      ok: false,
+      error: {
+        code: "sessionNotFound",
+        message: this.#options.notFoundMessage,
+        retryable: false
+      }
+    };
+  }
+  /** Idempotent. Resolves after every started read has settled. */
+  async close() {
+    this.#abort.abort();
+    await Promise.allSettled(this.#pending);
+  }
+};
+
+// dist/pi-session-import.js
+var PI_SESSION_CHANGED = "Pi Session changed during discovery; refresh and retry";
 function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function missing(error51) {
-  return isRecord4(error51) && error51.code === "ENOENT";
-}
 function expandDirectory(value, home) {
-  return path7.resolve(value === "~" ? home : value.startsWith(`~${path7.sep}`) || value.startsWith("~/") ? path7.join(home, value.slice(2)) : value);
+  return path11.resolve(value === "~" ? home : value.startsWith(`~${path11.sep}`) || value.startsWith("~/") ? path11.join(home, value.slice(2)) : value);
 }
 function piSessionImportDirectory(environment) {
   const home = (process.platform === "win32" ? environment.USERPROFILE : environment.HOME) || os3.homedir();
@@ -18047,7 +18743,7 @@ function piSessionImportDirectory(environment) {
     return { directory: expandDirectory(custom2, home), flat: true };
   const agent = environment.PI_CODING_AGENT_DIR;
   return {
-    directory: path7.join(agent ? expandDirectory(agent, home) : path7.join(home, ".pi", "agent"), "sessions"),
+    directory: path11.join(agent ? expandDirectory(agent, home) : path11.join(home, ".pi", "agent"), "sessions"),
     flat: false
   };
 }
@@ -18056,7 +18752,7 @@ async function sessionFiles(directory, flat, signal) {
   const visit = async (dir, projectLevel) => {
     signal.throwIfAborted();
     const entries = await opendir(dir).catch((error51) => {
-      if (missing(error51))
+      if (isMissingFileError(error51))
         return null;
       throw error51;
     });
@@ -18065,9 +18761,9 @@ async function sessionFiles(directory, flat, signal) {
     for await (const entry of entries) {
       signal.throwIfAborted();
       if (projectLevel && entry.isDirectory())
-        await visit(path7.join(dir, entry.name), false);
+        await visit(path11.join(dir, entry.name), false);
       else if (!projectLevel && entry.isFile() && entry.name.endsWith(".jsonl")) {
-        files.push(path7.join(dir, entry.name));
+        files.push(path11.join(dir, entry.name));
       }
     }
   };
@@ -18100,7 +18796,7 @@ async function readCandidate(file2, signal) {
       if (!isRecord4(entry))
         return null;
       if (!header) {
-        if (entry.type !== "session" || entry.version !== 3 || typeof entry.id !== "string" || typeof entry.cwd !== "string" || !path7.isAbsolute(entry.cwd))
+        if (entry.type !== "session" || entry.version !== 3 || typeof entry.id !== "string" || typeof entry.cwd !== "string" || !path11.isAbsolute(entry.cwd))
           return null;
         header = entry;
         continue;
@@ -18111,12 +18807,12 @@ async function readCandidate(file2, signal) {
       if (!firstMessage && entry.type === "message" && message3?.role === "user") {
         const content = message3.content;
         const text2 = typeof content === "string" ? content : Array.isArray(content) ? content.filter((block) => isRecord4(block) && block.type === "text" && typeof block.text === "string").map((block) => block.text).join(" ") : "";
-        firstMessage = text2.replaceAll("\0", "").trim().slice(0, HARNESS_SESSION_IMPORT_TITLE_MAX_LENGTH) || null;
+        firstMessage = sessionImportTitle(text2);
       }
       hasUser = entry.type === "message" && message3?.role === "user" || typeof entry.parentId === "string" && entries.get(entry.parentId) === true;
       entries.set(entry.id, hasUser);
       if (entry.type === "session_info")
-        name = typeof entry.name === "string" ? entry.name.trim() || null : null;
+        name = sessionImportTitle(entry.name);
       if (entry.type === "message" && (message3?.role === "user" || message3?.role === "assistant")) {
         const time3 = typeof message3.timestamp === "number" ? message3.timestamp : typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : NaN;
         if (Number.isFinite(time3))
@@ -18132,8 +18828,8 @@ async function readCandidate(file2, signal) {
   if (!hasUser)
     return null;
   const after = await stat(file2);
-  if (!sameFile(before, after))
-    throw new PiSessionChangedError();
+  if (!sameFileFingerprint(before, after))
+    throw new SessionImportChangedError(PI_SESSION_CHANGED);
   const cwd = await realpath3(String(header.cwd));
   if (!(await stat(cwd)).isDirectory())
     return null;
@@ -18143,14 +18839,13 @@ async function readCandidate(file2, signal) {
     locator: { sessionFile: await realpath3(file2) },
     formatVersion: 1
   });
-  const candidate = harnessSessionImportCandidateSchema.safeParse({
+  const candidate = sessionImportCandidate({
     nativeSessionId: header.id,
     cwd,
     title: name ?? firstMessage,
-    updatedAt: Math.floor(updatedAt),
-    running: null
+    updatedAt
   });
-  return candidate.success && nativeRef.success ? { candidate: candidate.data, nativeRef: nativeRef.data } : null;
+  return candidate && nativeRef.success ? { candidate, nativeRef: nativeRef.data } : null;
 }
 async function readIdentity(file2, signal) {
   const stream = createReadStream2(file2, { encoding: "utf8", signal });
@@ -18198,7 +18893,7 @@ var PiSessionImportIndex = class {
       try {
         const fingerprint = await stat(file2);
         const cached2 = this.#cache.get(file2);
-        const source = cached2 && sameFile(cached2.fingerprint, fingerprint) ? cached2.source : await readCandidate(file2, signal);
+        const source = cached2 && sameFileFingerprint(cached2.fingerprint, fingerprint) ? cached2.source : await readCandidate(file2, signal);
         if (!source)
           continue;
         if (!(await stat(source.candidate.cwd)).isDirectory())
@@ -18209,7 +18904,7 @@ var PiSessionImportIndex = class {
         next.set(file2, { fingerprint, source });
         sources.push(source);
       } catch (error51) {
-        if (!missing(error51) && !(error51 instanceof PiSessionChangedError))
+        if (!isMissingFileError(error51) && !(error51 instanceof SessionImportChangedError))
           throw error51;
       }
     }
@@ -18224,14 +18919,14 @@ var PiSessionImportIndex = class {
       try {
         const fingerprint = await stat(file2);
         const cached2 = this.#cache.get(file2);
-        const id = cached2 && sameFile(cached2.fingerprint, fingerprint) ? cached2.source.nativeRef.nativeSessionId : await readIdentity(file2, signal);
+        const id = cached2 && sameFileFingerprint(cached2.fingerprint, fingerprint) ? cached2.source.nativeRef.nativeSessionId : await readIdentity(file2, signal);
         if (id !== nativeSessionId)
           continue;
         if (selected)
           throw new Error("Pi Session identity is ambiguous across files");
         selected = file2;
       } catch (error51) {
-        if (!missing(error51))
+        if (!isMissingFileError(error51))
           throw error51;
       }
     }
@@ -18241,7 +18936,7 @@ var PiSessionImportIndex = class {
       const source = await readCandidate(selected, signal);
       return source?.nativeRef.nativeSessionId === nativeSessionId ? source : null;
     } catch (error51) {
-      if (missing(error51))
+      if (isMissingFileError(error51))
         return null;
       throw error51;
     }
@@ -18250,8 +18945,8 @@ var PiSessionImportIndex = class {
 
 // dist/pi-rpc-session.js
 import { spawn, spawnSync } from "node:child_process";
-import { randomUUID as randomUUID4 } from "node:crypto";
-import path8 from "node:path";
+import { randomUUID as randomUUID5 } from "node:crypto";
+import path12 from "node:path";
 
 // dist/pi-slash-commands.js
 var DYNAMIC_ID_PREFIX = "pi.slash.";
@@ -18273,15 +18968,15 @@ function parsePiNativeCommands(response) {
   return data.commands.flatMap((entry) => {
     if (typeof entry !== "object" || entry === null)
       return [];
-    const record6 = entry;
-    const name = typeof record6.name === "string" ? record6.name.trim().replace(/^\//u, "") : "";
+    const record7 = entry;
+    const name = typeof record7.name === "string" ? record7.name.trim().replace(/^\//u, "") : "";
     if (!name)
       return [];
     return [
       {
         name,
-        ...typeof record6.description === "string" ? { description: record6.description } : {},
-        ...typeof record6.source === "string" ? { source: record6.source } : {}
+        ...typeof record7.description === "string" ? { description: record7.description } : {},
+        ...typeof record7.source === "string" ? { source: record7.source } : {}
       }
     ];
   });
@@ -18369,7 +19064,7 @@ function optionalPiStateContextUsage(value) {
 }
 
 // dist/pi-subagent-rpc.js
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 var PiSubagentRpc = class {
   send;
   timeoutMs;
@@ -18411,7 +19106,7 @@ var PiSubagentRpc = class {
     if (!Array.isArray(data?.commands) || !data.commands.some((command) => command?.name === "subagents-inspect-rpc" && command.source === "extension")) {
       throw new Error("Installed Pi has no pi-subagents Host inspection command");
     }
-    const requestId = randomUUID3();
+    const requestId = randomUUID4();
     const reply = new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.#pending.delete(requestId);
@@ -18557,7 +19252,11 @@ function parseAvailableModels(response) {
     if (!parsed || !isRecord6(model) || typeof model.reasoning !== "boolean") {
       throw new PiRpcFaultError("protocolError", "Pi RPC catalog contains a Model without reasoning capability");
     }
-    return { ...parsed, reasoning: model.reasoning };
+    return {
+      ...parsed,
+      reasoning: model.reasoning,
+      ...typeof model.api === "string" ? { api: model.api } : {}
+    };
   });
 }
 function assistantText(value) {
@@ -18642,13 +19341,14 @@ function piRpcProcessCommand(options, dependencies = {}) {
   const modelArguments = startupModel ? ["--provider", startupModel.provider, "--model", startupModel.id] : [];
   const thinkingArguments = options.emptySessionConfiguration ? ["--thinking", options.emptySessionConfiguration.thinkingLevel] : [];
   const arguments_ = [
+    ...options.fastExtension ? ["--extension", options.fastExtension] : [],
     "--mode",
     "rpc",
     ...modelArguments,
     ...thinkingArguments,
     ...sessionArguments
   ];
-  const extension = path8.win32.extname(command).toLowerCase();
+  const extension = path12.win32.extname(command).toLowerCase();
   if (platform !== "win32" || ![".cmd", ".bat"].includes(extension)) {
     return { command, arguments: arguments_, windowsVerbatimArguments: false };
   }
@@ -18687,6 +19387,8 @@ var PiRpcSession = class {
   #failed = false;
   #pending = /* @__PURE__ */ new Map();
   #state = null;
+  #fast = null;
+  #fastAcknowledgement = null;
   #latestCacheHitRatePercent;
   #manualCompaction = null;
   #stderrTail = "";
@@ -18713,7 +19415,9 @@ var PiRpcSession = class {
   get state() {
     if (!this.#state)
       throw new Error("Pi RPC Session has not started");
-    return this.#state;
+    if (this.#fast && (this.#fast.provider !== this.#state.provider || this.#fast.id !== this.#state.modelId))
+      this.#fast = null;
+    return this.#fast ? { ...this.#state, fast: true } : this.#state;
   }
   get stderrTail() {
     return this.#stderrTail;
@@ -18730,8 +19434,10 @@ var PiRpcSession = class {
   async start() {
     if (this.#child || this.#closed)
       throw new Error("Pi RPC Session cannot be started twice");
+    const fastExtension = this.#processAdapter === nodeProcessAdapter ? await ensurePiFastExtension({ ...process.env, ...this.#options.environment }) : void 0;
     const child = this.#processAdapter.spawn({
       cwd: this.#options.cwd,
+      ...fastExtension ? { fastExtension } : {},
       ...this.#options.command ? { command: this.#options.command } : {},
       environment: withNodeRuntimeOnPath({
         ...process.env,
@@ -18878,7 +19584,36 @@ var PiRpcSession = class {
       throw error51;
     }
   }
+  async supportsFastMode() {
+    return (await this.getCommands()).some((command) => command.name === PI_FAST_COMMAND && command.source === "extension");
+  }
+  async selectFastMode(enabled) {
+    if (!enabled && !this.#fast)
+      return this.state;
+    if (!await this.supportsFastMode())
+      throw new Error("Installed Pi does not support the Host Fast extension");
+    const nonce = randomUUID5();
+    const mode = enabled ? "on" : "off";
+    const acknowledgement = { message: `${PI_FAST_ACK}${nonce}:${mode}`, received: false };
+    this.#fastAcknowledgement = acknowledgement;
+    try {
+      await this.#send("prompt", { message: `/${PI_FAST_COMMAND} ${mode} ${nonce}` });
+      if (!acknowledgement.received)
+        throw new Error("Pi did not confirm the Fast selection");
+      this.#fast = enabled ? { provider: this.state.provider ?? "", id: this.state.modelId ?? "" } : null;
+      return this.state;
+    } catch (error51) {
+      const fault = error51 instanceof PiRpcFaultError ? error51 : new PiRpcFaultError("protocolError", `Pi Fast selection could not be confirmed: ${message2(error51)}`);
+      this.#fail(fault);
+      await this.close().catch(() => void 0);
+      throw fault;
+    } finally {
+      this.#fastAcknowledgement = null;
+    }
+  }
   async selectModel(model) {
+    if (this.#fast)
+      await this.selectFastMode(false);
     await this.#send("set_model", { provider: model.provider, modelId: model.id });
     return this.#refreshState("Model");
   }
@@ -18890,7 +19625,7 @@ var PiRpcSession = class {
   async #refreshState(operation) {
     try {
       this.#state = parseSessionState(await this.#send("get_state", {}));
-      return this.#state;
+      return this.state;
     } catch (error51) {
       const fault = error51 instanceof PiRpcFaultError ? error51 : new PiRpcFaultError("protocolError", `Pi RPC ${operation} state could not be confirmed: ${message2(error51)}`);
       this.#fail(fault);
@@ -19046,6 +19781,11 @@ var PiRpcSession = class {
     }
   }
   #handle(value) {
+    if (value.type === "extension_ui_request" && value.method === "notify" && typeof value.message === "string" && value.message.startsWith(PI_FAST_ACK)) {
+      if (this.#fastAcknowledgement?.message === value.message)
+        this.#fastAcknowledgement.received = true;
+      return;
+    }
     if (this.#closed || this.#failed)
       return;
     if (value.type === "response") {
@@ -19168,7 +19908,7 @@ var PiRpcSession = class {
     const active = {
       origin: "autonomous",
       autonomousEvents: events,
-      nativeTurnKey: assistantMessageId(value) ?? randomUUID4(),
+      nativeTurnKey: assistantMessageId(value) ?? randomUUID5(),
       nativeCancellationObserved: false,
       text: "",
       assistantMessageId: null,
@@ -19411,7 +20151,7 @@ var PiRpcSession = class {
     if (active.assistantMessageId !== null && active.reasoningMessageOpen) {
       active.onEvent({ type: "reasoning.completed", messageId: active.assistantMessageId });
     }
-    const messageId = assistantMessageId(value) ?? randomUUID4();
+    const messageId = assistantMessageId(value) ?? randomUUID5();
     active.assistantMessageId = messageId;
     active.sawStreamedMessageText = false;
     active.sawStreamedMessageReasoning = false;
@@ -19472,7 +20212,7 @@ var PiRpcSession = class {
     if (!child?.stdin.writable || this.#closed || this.#failed) {
       return Promise.reject(new Error("Pi RPC stdin is unavailable"));
     }
-    const id = `codexhost-${randomUUID4()}`;
+    const id = `codexhost-${randomUUID5()}`;
     return new Promise((resolve, reject) => {
       const pending = {
         command: type,
@@ -19647,7 +20387,7 @@ function nativeModelFromState(state2) {
 }
 function effectiveModelFromState(state2) {
   const model = nativeModelFromState(state2);
-  return model ? encodePiModelRef(model) : void 0;
+  return model ? encodePiModelRef({ ...model, ...state2.fast ? { fast: true } : {} }) : void 0;
 }
 function harnessStateFromPi(state2, thinkingLevels) {
   const effectiveModel = effectiveModelFromState(state2);
@@ -19733,10 +20473,10 @@ function stripDiffPrefix(pathString) {
   return pathString.startsWith("a/") || pathString.startsWith("b/") ? pathString.slice(2) : pathString;
 }
 function displayPath(nativePath, cwd) {
-  const resolvedCwd = path9.resolve(cwd);
-  const resolvedPath = path9.isAbsolute(nativePath) ? path9.resolve(nativePath) : path9.resolve(cwd, nativePath);
-  const relative = path9.relative(resolvedCwd, resolvedPath);
-  const inside = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path9.sep}`);
+  const resolvedCwd = path13.resolve(cwd);
+  const resolvedPath = path13.isAbsolute(nativePath) ? path13.resolve(nativePath) : path13.resolve(cwd, nativePath);
+  const relative = path13.relative(resolvedCwd, resolvedPath);
+  const inside = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path13.sep}`);
   const selected = inside ? relative : resolvedPath;
   const normalized = selected.replaceAll("\\", "/");
   if (normalized.length === 0 || normalized === ".")
@@ -19935,6 +20675,7 @@ var PiHarnessSession = class {
   #requestedModel;
   #requestedThinkingOptionId;
   #toolOutputLimit;
+  #isFastSupported;
   #acceptingTurn = false;
   #active = null;
   #closePromise = null;
@@ -19956,6 +20697,7 @@ var PiHarnessSession = class {
     this.#requestedModel = options.model;
     this.#requestedThinkingOptionId = options.thinkingOptionId;
     this.#toolOutputLimit = options.toolOutputLimit;
+    this.#isFastSupported = options.isFastSupported;
     this.capabilities = {
       configuration: {
         selectModel: true,
@@ -19984,13 +20726,13 @@ var PiHarnessSession = class {
     return this.#transport?.state.sessionId === id;
   }
   async readSubagentHistory(cwd) {
-    if (this.#phase !== "open" || path9.resolve(cwd) !== path9.resolve(this.#cwd)) {
+    if (this.#phase !== "open" || path13.resolve(cwd) !== path13.resolve(this.#cwd)) {
       throw new Error("Pi Subagent parent workspace or Session is unavailable");
     }
     return (await this.#ensureTransport()).getEntries();
   }
   async inspectSubagent(id, cwd) {
-    if (this.#phase !== "open" || path9.resolve(cwd) !== path9.resolve(this.#cwd)) {
+    if (this.#phase !== "open" || path13.resolve(cwd) !== path13.resolve(this.#cwd)) {
       throw new Error("Pi Subagent parent workspace or Session is unavailable");
     }
     const transport = await this.#ensureTransport();
@@ -20233,20 +20975,27 @@ var PiHarnessSession = class {
         error: invalidState("Pi Model selection requires a started Native Session")
       };
     }
-    let requested;
-    try {
-      requested = decodePiModelRef(command.model);
-    } catch (error51) {
-      return { ok: false, error: normalizedError(error51, "invalidRequest") };
-    }
     const previousModel = this.#state.effectiveModel;
     this.#configuring = true;
     try {
+      let requested;
+      try {
+        requested = decodePiModelRef(command.model);
+        if (requested.fast && !await this.#isFastSupported(command.model, transport))
+          throw new Error("Fast is unavailable for this Pi Model");
+      } catch (error51) {
+        return { ok: false, error: normalizedError(error51, "invalidRequest") };
+      }
       let state2;
       let thinkingLevels;
       try {
-        state2 = await transport.selectModel(requested);
+        state2 = samePiModel(nativeModelFromState(transport.state), requested) ? transport.state : await transport.selectModel(requested);
         thinkingLevels = await transport.getAvailableThinkingLevels();
+        if (requested.fast || state2.fast) {
+          if (!transport.selectFastMode)
+            throw new Error("Pi Fast extension is unavailable");
+          state2 = await transport.selectFastMode(requested.fast === true);
+        }
         this.#publishTransportState(state2, thinkingLevels);
       } catch (error51) {
         if (error51 instanceof PiRpcFaultError)
@@ -20383,7 +21132,7 @@ var PiHarnessSession = class {
     const transport = this.#transport;
     if (this.#phase === "open" && transport?.getCommands) {
       try {
-        this.#liveCommands = piLiveCommandCatalog(piCommandCatalog, await transport.getCommands());
+        this.#liveCommands = piLiveCommandCatalog(piCommandCatalog, (await transport.getCommands()).filter((command) => command.name !== PI_FAST_COMMAND));
       } catch {
       }
     }
@@ -20530,6 +21279,11 @@ var PiHarnessSession = class {
           this.#publishTransportState(state2, thinkingLevels);
           throw new Error("Pi did not activate the requested create Model");
         }
+        if (requested.fast) {
+          if (!await this.#isFastSupported(this.#requestedModel, transport) || !transport.selectFastMode)
+            throw new Error("Fast is unavailable for this Pi Model");
+          state2 = await transport.selectFastMode(true);
+        }
       }
       if (this.#requestedThinkingOptionId) {
         if (!thinkingLevels) {
@@ -20610,7 +21364,7 @@ var PiHarnessSession = class {
       }));
       return;
     }
-    const turnId = hostTurnIdSchema.parse(randomUUID5());
+    const turnId = hostTurnIdSchema.parse(randomUUID6());
     let resolveCompletion = () => void 0;
     const completion = new Promise((resolve) => {
       resolveCompletion = resolve;
@@ -20772,7 +21526,7 @@ var PiHarnessSession = class {
     if (active.interactionByNativeId.has(request.requestId)) {
       throw new Error("Pi Interaction started more than once");
     }
-    const interactionId = hostInteractionIdSchema.parse(randomUUID5());
+    const interactionId = hostInteractionIdSchema.parse(randomUUID6());
     const question = request.method === "select" ? {
       id: "answer",
       type: "choice",
@@ -21119,7 +21873,7 @@ var PiHarnessSession = class {
     this.#channel.emit({ kind: "event", event });
   }
   #newItemId() {
-    return hostItemIdSchema.parse(randomUUID5());
+    return hostItemIdSchema.parse(randomUUID6());
   }
 };
 var PiAdapter = class {
@@ -21182,27 +21936,17 @@ var PiAdapter = class {
   };
   sessionImport = Object.freeze({
     listCandidates: async () => {
-      const result = await this.#readImport((signal) => this.#importIndex.list(signal));
+      const result = await this.#importScope.read((signal) => this.#importIndex.list(signal));
       return result.ok ? { ok: true, value: result.value.map(({ candidate }) => candidate) } : result;
     },
-    resolveCandidate: async (nativeSessionId) => {
-      const result = await this.#readImport((signal) => this.#importIndex.resolve(nativeSessionId, signal));
-      if (!result.ok)
-        return result;
-      const source = result.value;
-      return source ? { ok: true, value: source } : {
-        ok: false,
-        error: {
-          code: "sessionNotFound",
-          message: "Pi Session is no longer importable",
-          retryable: false
-        }
-      };
-    }
+    resolveCandidate: (nativeSessionId) => this.#importScope.resolve((signal) => this.#importIndex.resolve(nativeSessionId, signal))
   });
   #importIndex;
-  #importAbort = new AbortController();
-  #importRequests = /* @__PURE__ */ new Set();
+  #importScope = new SessionImportScope({
+    closedMessage: "Pi Adapter is closed",
+    unavailableMessage: "Pi Session discovery failed; check storage access and duplicate Session identities, then retry after closing native clients",
+    notFoundMessage: "Pi Session is no longer importable"
+  });
   #closeTimeoutMs;
   #createTransport;
   #inspectionCache = /* @__PURE__ */ new Map();
@@ -21210,6 +21954,7 @@ var PiAdapter = class {
   #inspections = /* @__PURE__ */ new Set();
   #sessions = /* @__PURE__ */ new Set();
   #toolOutputLimit;
+  #environment;
   #closePromise = null;
   #thinkingSelectionSupported = null;
   constructor(options = {}, dependencies = {
@@ -21229,23 +21974,20 @@ var PiAdapter = class {
       remove: (name) => updateCatalog(imports.remove(name))
     };
     this.#createTransport = dependencies.createTransport;
+    this.#environment = options.environment ?? process.env;
     this.#importIndex = new PiSessionImportIndex({ ...process.env, ...options.environment });
     this.#closeTimeoutMs = options.closeTimeoutMs ?? 2e3;
     this.#toolOutputLimit = options.toolOutputLimit ?? DEFAULT_TOOL_OUTPUT_LIMIT;
   }
-  #readImport(operation) {
-    if (this.#importAbort.signal.aborted)
-      return Promise.resolve({ ok: false, error: invalidState("Pi Adapter is closed") });
-    const request = operation(this.#importAbort.signal).then((value) => ({ ok: true, value })).catch(() => ({
-      ok: false,
-      error: {
-        code: "unavailable",
-        message: "Pi Session discovery failed; check storage access and duplicate Session identities, then retry after closing native clients",
-        retryable: true
-      }
-    })).finally(() => this.#importRequests.delete(request));
-    this.#importRequests.add(request);
-    return request;
+  /** Pi itself holds no Account; this reports configured Provider balances. */
+  async inspectAccounts() {
+    if (this.#closePromise)
+      return [];
+    return fetchPiAccounts({ environment: this.#environment });
+  }
+  async inspectAccount() {
+    const accounts = await this.inspectAccounts();
+    return accounts[0] ?? null;
   }
   async inspect(input = {}) {
     if (this.#closePromise) {
@@ -21258,7 +22000,7 @@ var PiAdapter = class {
         }
       };
     }
-    const cwd = input.cwd ?? process.cwd();
+    const cwd = resolvePiInspectCwd(input.cwd);
     const inFlight = this.#inspectionInFlight.get(cwd);
     if (inFlight)
       return inFlight;
@@ -21292,7 +22034,9 @@ var PiAdapter = class {
       stage = "capabilities";
       const thinkingLevels = await transport.getAvailableThinkingLevels();
       this.#thinkingSelectionSupported = thinkingLevels !== null;
-      const catalog = normalizePiModelCatalog(models, nativeModelFromState(transport.state), thinkingLevels, transport.state.thinkingLevel);
+      const normalized = normalizePiModelCatalog(models, nativeModelFromState(transport.state), thinkingLevels, transport.state.thinkingLevel);
+      const fastModels = await transport.supportsFastMode?.() ? await piFastModelKeys(models, this.#environment) : /* @__PURE__ */ new Set();
+      const catalog = withPiFast(normalized, fastModels);
       await transport.close();
       return {
         status: "ready",
@@ -21329,6 +22073,27 @@ var PiAdapter = class {
     if (this.#closePromise) {
       return { ok: false, error: invalidState("Pi Adapter is closed") };
     }
+    if ("model" in input && input.model) {
+      let model;
+      try {
+        model = decodePiModelRef(input.model);
+      } catch (error51) {
+        return { ok: false, error: normalizedError(error51, "invalidRequest") };
+      }
+      if (model.fast) {
+        if (!this.#isFastSupported(input.model, input.cwd))
+          await this.inspect({ cwd: input.cwd });
+        if (!this.#isFastSupported(input.model, input.cwd) && input.kind !== "resume")
+          return {
+            ok: false,
+            error: {
+              code: "unsupported",
+              message: "Fast is unavailable for this Pi Model",
+              retryable: false
+            }
+          };
+      }
+    }
     if (input.cwd.length === 0) {
       return {
         ok: false,
@@ -21499,6 +22264,11 @@ var PiAdapter = class {
           await transport.verifySessionCwd(input.cwd);
         }
       }
+      if (input.kind === "resume" && input.model && this.#isFastSupported(input.model, input.cwd) && decodePiModelRef(input.model).fast && samePiModel(nativeModelFromState(transport.state), decodePiModelRef(input.model))) {
+        if (!transport.selectFastMode)
+          throw new Error("Pi Fast extension is unavailable");
+        await transport.selectFastMode(true);
+      }
       const startedThinkingLevels = await transport.getAvailableThinkingLevels();
       this.#thinkingSelectionSupported = startedThinkingLevels !== null;
       const initialUsage = await transport.getSessionUsage().catch(() => null);
@@ -21515,6 +22285,9 @@ var PiAdapter = class {
       return { ok: false, error: normalizedError(error51, "nativeFailure") };
     }
   }
+  #isFastSupported(ref, cwd) {
+    return this.#inspectionCache.get(cwd)?.catalog.models.some((model) => model.fastModel?.id === ref.id) ?? false;
+  }
   #trackSession(cwd, options) {
     const environment = options.environment;
     const createTransport = environment ? (input) => this.#createTransport({ ...input, environment }) : this.#createTransport;
@@ -21526,6 +22299,14 @@ var PiAdapter = class {
       ...options.thinkingOptionId ? { thinkingOptionId: options.thinkingOptionId } : {},
       toolOutputLimit: this.#toolOutputLimit,
       supportsThinkingSelection: options.supportsThinkingSelection,
+      isFastSupported: async (ref, transport) => {
+        if (this.#inspectionCache.has(cwd))
+          return this.#isFastSupported(ref, cwd);
+        if (!await transport.supportsFastMode?.())
+          return false;
+        const fastModels = await piFastModelKeys(await transport.getAvailableModels(), environment ?? this.#environment);
+        return fastModels.has(encodePiModelRef({ ...decodePiModelRef(ref), fast: false }).id);
+      },
       ...options.startedTransport ? { startedTransport: options.startedTransport } : {},
       ...options.startedThinkingLevels !== void 0 ? { startedThinkingLevels: options.startedThinkingLevels } : {},
       ...options.initialUsage !== void 0 ? { initialUsage: options.initialUsage } : {}
@@ -21535,9 +22316,8 @@ var PiAdapter = class {
   }
   close() {
     if (!this.#closePromise) {
-      this.#importAbort.abort();
       this.#closePromise = Promise.all([
-        ...this.#importRequests,
+        this.#importScope.close(),
         ...[...this.#inspections].map((transport) => transport.close()),
         ...[...this.#sessions].map((session) => session.close())
       ]).then(() => void 0);
@@ -21546,13 +22326,42 @@ var PiAdapter = class {
   }
 };
 
+// dist/installation.js
+var PI_LATEST_VERSION_URL = "https://pi.dev/api/latest-version";
+function createPiInstallation(environment, command) {
+  const run = (args, timeout) => runInstallationCommand(resolvePiExecutable({ environment, ...command ? { command } : {} }), args, environment, timeout);
+  return createInstallationManager({
+    async check() {
+      const currentVersion = versionFromOutput(await run(["--version"]));
+      const payload = JSON.parse(await fetchInstallationText(PI_LATEST_VERSION_URL));
+      const latestVersion = installationVersion(payload.version);
+      return {
+        currentVersion,
+        latestVersion,
+        updateAvailable: newerInstallationVersion(currentVersion, latestVersion),
+        canUpdate: true
+      };
+    },
+    async update() {
+      await run(["update"], 3e5);
+    }
+  });
+}
+
 // dist/plugin.js
 var PI_COMMAND_ENV = "CODEXHOST_PI_COMMAND";
 function createHarnessAdapter(context) {
   const environment = { ...context.environment };
-  return new PiAdapter({
+  return Object.assign(new PiAdapter({
     ...environment[PI_COMMAND_ENV] ? { command: environment[PI_COMMAND_ENV] } : {},
     environment
+  }), {
+    installation: createPiInstallation(environment, environment[PI_COMMAND_ENV]),
+    install: createHarnessInstaller(environment, {
+      posix: "https://pi.dev/install.sh",
+      windows: "https://pi.dev/install.ps1",
+      shell: "sh"
+    })
   });
 }
 export {