@codexhost/cli-darwin-x64 0.10.1 → 0.11.0

package/app/plugins/pi/plugin.mjs

@@ -5,15 +5,10 @@ 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";
-import path3 from "node:path";
-import { pathToFileURL } from "node:url";
+// dist/account-balance.js
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
 
 // ../../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -781,10 +776,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path10) {
-  if (!path10)
+function getElementAtPath(obj, path13) {
+  if (!path13)
     return obj;
-  return path10.reduce((acc, key) => acc?.[key], obj);
+  return path13.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1193,11 +1188,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path10, issues) {
+function prefixIssues(path13, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path10);
+    iss.path.unshift(path13);
     return iss;
   });
 }
@@ -1344,16 +1339,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, path13 = []) => {
     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 }, [...path13, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path13, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path13, ...issue2.path]);
       } else {
-        const fullpath = [...path10, ...issue2.path];
+        const fullpath = [...path13, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1380,17 +1375,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, path13 = []) => {
     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 }, [...path13, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path13, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path13, ...issue2.path]);
       } else {
-        const fullpath = [...path10, ...issue2.path];
+        const fullpath = [...path13, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1422,8 +1417,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 path13 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path13) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14115,13 +14110,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 path13 = ref.slice(1).split("/").filter(Boolean);
+  if (path13.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path10[0] === defsKey) {
-    const key = path10[1];
+  if (path13[0] === defsKey) {
+    const key = path13[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14584,6 +14579,55 @@ 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/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 +14681,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 +14747,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 +14760,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 +14783,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 +14814,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 +14958,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 +14992,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 +15121,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 +15253,19 @@ 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"])
+}).strict();
+var harnessInstallationStateSchema = external_exports.object({
+  currentVersion: external_exports.string().min(1).max(128),
+  latestVersion: external_exports.string().min(1).max(128),
+  updateAvailable: external_exports.boolean(),
+  canUpdate: external_exports.boolean(),
+  message: external_exports.string().max(2048).optional()
+}).strict();
+
 // ../../shared-contracts/dist/codex-accounts.js
 var accountIdSchema = external_exports.string().min(1).max(256).regex(/^[A-Za-z0-9._~-]+$/u);
 var nonBlankTextSchema3 = external_exports.string().trim().min(1);
@@ -15466,11 +15568,164 @@ var updateStatusResultSchema = external_exports.strictObject({
 // ../../shared-contracts/dist/index.js
 var workspaceContractVersionSchema = external_exports.literal(WORKSPACE_CONTRACT_VERSION);
 
+// 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 path.join(environment.HOME ?? environment.USERPROFILE ?? homedir(), ".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(path.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 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 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 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 parsed.success ? parsed.data : null;
+}
+function usageEndpoint(baseUrl) {
+  let url2;
+  try {
+    url2 = new URL(baseUrl);
+  } catch {
+    return null;
+  }
+  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(path.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 [];
+  }
+}
+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 [];
+  }
+}
+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;
+  }
+}
+
+// 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 path5 from "node:path";
+import { pathToFileURL } from "node:url";
+
 // ../../harness-discovery/dist/environment.js
 import fs from "node:fs";
-import path from "node:path";
+import path2 from "node:path";
 function targetPath(platform) {
-  return platform === "win32" ? path.win32 : path.posix;
+  return platform === "win32" ? path2.win32 : path2.posix;
 }
 function environmentValue(environment, name) {
   const lowered = name.toLowerCase();
@@ -15512,12 +15767,28 @@ function newestFirst(names) {
   return [...names].sort((left, right) => right.localeCompare(left, void 0, { numeric: true }));
 }
 
+// ../../harness-discovery/dist/invocation.js
+import path3 from "node:path";
+function commandInvocation(command, arguments_, environment, platform = process.platform) {
+  const extension = path3.win32.extname(command).toLowerCase();
+  if (platform !== "win32" || ![".cmd", ".bat"].includes(extension)) {
+    return { command, arguments: [...arguments_], windowsVerbatimArguments: false };
+  }
+  const quote = (value) => `"${value.replaceAll("%", "%%").replaceAll('"', '""')}"`;
+  const commandLine = [command, ...arguments_].map(quote).join(" ");
+  return {
+    command: environmentValue(environment, "ComSpec") ?? "cmd.exe",
+    arguments: ["/d", "/v:off", "/s", "/c", `"${commandLine}"`],
+    windowsVerbatimArguments: true
+  };
+}
+
 // ../../harness-discovery/dist/node-runtime.js
-import path2 from "node:path";
+import path4 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 runtimeDirectory = path4.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))) {
@@ -15689,6 +15960,116 @@ function resolveHarnessExecutable(spec, input, dependencies = {}) {
   return void 0;
 }
 
+// ../../harness-discovery/dist/installation.js
+import { execFile } from "node:child_process";
+import { homedir as homedir2 } 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 ?? homedir2(),
+      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();
+  }
+}
+
 // dist/command.js
 var piDiscoverySpec = {
   id: "pi",
@@ -15756,6 +16137,15 @@ function describeOauth(credential) {
     ...match ? { vendor: match.vendor } : {}
   };
 }
+function readPiCodexProviderNames(environment) {
+  const agentDir = environment.PI_CODING_AGENT_DIR ?? path5.join(environment.HOME ?? environment.USERPROFILE ?? os2.homedir(), ".pi/agent");
+  try {
+    const auth = parseAuth(readFileSync(path5.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 +16156,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(path5.join(dir, "index.ts"), { force: true });
+  rmSync(path5.join(dir, "import.json"), { force: true });
   try {
     rmdirSync(dir);
   } catch {
@@ -15775,26 +16165,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 = path5.dirname(executable);
   while (true) {
-    const manifest = path3.join(directory, "package.json");
+    const manifest = path5.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 = path5.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(path5.join(directory, "dist/core/auth-storage.js")).href);
+  const ai = path5.join(directory, "node_modules/@earendil-works/pi-ai/dist");
+  const all = await import(pathToFileURL(path5.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(path5.join(ai, "providers/openai-codex.js")).href,
+    xai: pathToFileURL(path5.join(ai, "providers/xai.js")).href
   };
   for (const [id, url2] of Object.entries(providerModules)) {
     const module = await import(url2);
@@ -15807,9 +16197,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(path5.dirname(authPath)) ? path5.dirname(authPath) : os2.homedir(),
+        env: { ...environment, PI_CODING_AGENT_DIR: path5.dirname(authPath), PI_OFFLINE: "1" },
         timeout: 15e3,
         maxBuffer: 4 * 1024 * 1024
       });
@@ -15839,26 +16229,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 ?? path5.join(env.HOME ?? os2.homedir(), ".pi/agent");
+  const authPath = path5.join(agentDir, "auth.json");
+  const extensionsDir = path5.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) => path5.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(path5.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 +16256,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 = path5.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 +16270,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(path5.join(location(name), "import.json")))
         continue;
       try {
         const meta3 = readRecord(name);
@@ -15901,7 +16291,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 +16304,7 @@ function createPiCredentialImports(options = {}) {
           ...describeOauth(credential)
         });
       }
-      const modelsPath = path3.join(agentDir, "models.json");
+      const modelsPath = path5.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 +16326,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 +16338,15 @@ function createPiCredentialImports(options = {}) {
       try {
         sdk.backend.withLock((current) => {
           const auth = parseAuth(current);
-          const modelsPath = path3.join(agentDir, "models.json");
+          const modelsPath = path5.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(path5.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(path5.join(dir, "import.json"), JSON.stringify({ version: 1, owner, record: record7, extension }), { flag: "wx", mode: 384 });
+          writeFileSync(path5.join(dir, "index.ts"), extension, { flag: "wx", mode: 384 });
           auth[name] = { type: "oauth", ...transfer.oauth, codexhostImportId: owner };
           saveAuth(auth);
           committed = true;
@@ -15975,7 +16365,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 = path5.join(location(name), "import.json");
         const previous = readFileSync(metadataPath, "utf8");
         const updated = {
           ...meta3,
@@ -16009,15 +16399,229 @@ function createPiCredentialImports(options = {}) {
   };
 }
 
+// dist/pi-fast-mode.js
+import { createHash, randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir, readFile as readFile2, rename, rm, writeFile } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import path6 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 ?? path6.join(environment.HOME ?? environment.USERPROFILE ?? homedir3(), ".codexhost");
+  const directory = path6.resolve(dataDirectory, "extensions", "pi-codex-fast");
+  const file2 = path6.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 writeFile(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 rm(temporary, { force: true });
+  }
+  return file2;
+}
+async function piFastModelKeys(models, environment) {
+  try {
+    const codexHome = environment.CODEX_HOME ?? path6.join(environment.HOME ?? environment.USERPROFILE ?? homedir3(), ".codex");
+    const cache = JSON.parse(await readFile2(path6.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 rm2 } from "node:fs/promises";
+import path7 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 +16635,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 +16724,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 +16741,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 +16763,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 +16834,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 +16974,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 +17001,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 +17009,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 +17029,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 +17334,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 || !path7.isAbsolute(destination) || path7.resolve(destination) === path7.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 +17358,7 @@ async function persistEmptyPiSession(input) {
     cwd,
     parentSession: sourceSessionFile
   };
-  const temporary = path4.join(path4.dirname(destination), `.codexhost-${randomUUID2()}.tmp`);
+  const temporary = path7.join(path7.dirname(destination), `.codexhost-${randomUUID3()}.tmp`);
   try {
     const file2 = await open2(temporary, "wx", 384);
     try {
@@ -16879,7 +17369,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(path7.dirname(destination), "r");
       try {
         await directory.sync();
       } finally {
@@ -16887,7 +17377,7 @@ async function persistEmptyPiSession(input) {
       }
     }
   } finally {
-    await rm(temporary, { force: true });
+    await rm2(temporary, { force: true });
   }
 }
 async function readPiEmptySessionConfiguration(sessionFile) {
@@ -17042,16 +17532,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path10, added, removed, oldPosInc, options) {
-    const last = path10.lastComponent;
+  addToPath(path13, added, removed, oldPosInc, options) {
+    const last = path13.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path10.oldPos + oldPosInc,
+        oldPos: path13.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path10.oldPos + oldPosInc,
+        oldPos: path13.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -17463,8 +17953,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 path12 from "node:path";
 
 // ../../harness-adapter/dist/question.js
 function invalidRequest(message3) {
@@ -17769,16 +18259,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 path8 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 (!path8.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 +18281,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 +18313,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 +18322,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 +18371,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 path9 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 +18419,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" || !path9.isAbsolute(details.asyncDir) || path9.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(path9.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,7 +18511,7 @@ 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 path10 from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 var PiSessionChangedError = class extends Error {
   constructor() {
@@ -18038,7 +18528,7 @@ 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 path10.resolve(value === "~" ? home : value.startsWith(`~${path10.sep}`) || value.startsWith("~/") ? path10.join(home, value.slice(2)) : value);
 }
 function piSessionImportDirectory(environment) {
   const home = (process.platform === "win32" ? environment.USERPROFILE : environment.HOME) || os3.homedir();
@@ -18047,7 +18537,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: path10.join(agent ? expandDirectory(agent, home) : path10.join(home, ".pi", "agent"), "sessions"),
     flat: false
   };
 }
@@ -18065,9 +18555,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(path10.join(dir, entry.name), false);
       else if (!projectLevel && entry.isFile() && entry.name.endsWith(".jsonl")) {
-        files.push(path7.join(dir, entry.name));
+        files.push(path10.join(dir, entry.name));
       }
     }
   };
@@ -18100,7 +18590,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" || !path10.isAbsolute(entry.cwd))
           return null;
         header = entry;
         continue;
@@ -18250,8 +18740,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 path11 from "node:path";
 
 // dist/pi-slash-commands.js
 var DYNAMIC_ID_PREFIX = "pi.slash.";
@@ -18273,15 +18763,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 +18859,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 +18901,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 +19047,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 +19136,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 = path11.win32.extname(command).toLowerCase();
   if (platform !== "win32" || ![".cmd", ".bat"].includes(extension)) {
     return { command, arguments: arguments_, windowsVerbatimArguments: false };
   }
@@ -18687,6 +19182,8 @@ var PiRpcSession = class {
   #failed = false;
   #pending = /* @__PURE__ */ new Map();
   #state = null;
+  #fast = null;
+  #fastAcknowledgement = null;
   #latestCacheHitRatePercent;
   #manualCompaction = null;
   #stderrTail = "";
@@ -18713,7 +19210,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 +19229,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 +19379,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 +19420,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 +19576,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 +19703,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 +19946,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 +20007,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 +20182,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 +20268,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 = path12.resolve(cwd);
+  const resolvedPath = path12.isAbsolute(nativePath) ? path12.resolve(nativePath) : path12.resolve(cwd, nativePath);
+  const relative = path12.relative(resolvedCwd, resolvedPath);
+  const inside = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path12.sep}`);
   const selected = inside ? relative : resolvedPath;
   const normalized = selected.replaceAll("\\", "/");
   if (normalized.length === 0 || normalized === ".")
@@ -19935,6 +20470,7 @@ var PiHarnessSession = class {
   #requestedModel;
   #requestedThinkingOptionId;
   #toolOutputLimit;
+  #isFastSupported;
   #acceptingTurn = false;
   #active = null;
   #closePromise = null;
@@ -19956,6 +20492,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 +20521,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" || path12.resolve(cwd) !== path12.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" || path12.resolve(cwd) !== path12.resolve(this.#cwd)) {
       throw new Error("Pi Subagent parent workspace or Session is unavailable");
     }
     const transport = await this.#ensureTransport();
@@ -20233,20 +20770,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 +20927,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 +21074,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 +21159,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 +21321,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 +21668,7 @@ var PiHarnessSession = class {
     this.#channel.emit({ kind: "event", event });
   }
   #newItemId() {
-    return hostItemIdSchema.parse(randomUUID5());
+    return hostItemIdSchema.parse(randomUUID6());
   }
 };
 var PiAdapter = class {
@@ -21210,6 +21759,7 @@ var PiAdapter = class {
   #inspections = /* @__PURE__ */ new Set();
   #sessions = /* @__PURE__ */ new Set();
   #toolOutputLimit;
+  #environment;
   #closePromise = null;
   #thinkingSelectionSupported = null;
   constructor(options = {}, dependencies = {
@@ -21229,10 +21779,21 @@ 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;
   }
+  /** 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;
+  }
   #readImport(operation) {
     if (this.#importAbort.signal.aborted)
       return Promise.resolve({ ok: false, error: invalidState("Pi Adapter is closed") });
@@ -21292,7 +21853,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 +21892,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 +22083,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 +22104,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 +22118,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 } : {}
@@ -21546,14 +22146,36 @@ 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]) });
 }
 export {
   PI_COMMAND_ENV,