@liberseek/boft-cli-win32-arm64 0.6.4 → 0.6.5

package/app/host-runtime.mjs

@@ -4100,7 +4100,8 @@ async function runDelegationCli(input) {
 
 // packages/host-runtime/src/run-host-runtime.ts
 import { randomBytes } from "node:crypto";
-import path20 from "node:path";
+import path21 from "node:path";
+import { homedir } from "node:os";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/update-manager/dist/distribution.js
@@ -5958,10 +5959,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path25) {
-  if (!path25)
+function getElementAtPath(obj, path26) {
+  if (!path26)
     return obj;
-  return path25.reduce((acc, key) => acc?.[key], obj);
+  return path26.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -6370,11 +6371,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path25, issues) {
+function prefixIssues(path26, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path25);
+    iss.path.unshift(path26);
     return iss;
   });
 }
@@ -6521,16 +6522,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path25 = []) => {
+  const processError = (error52, path26 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path25, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path26, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path25, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path26, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path25, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path26, ...issue2.path]);
       } else {
-        const fullpath = [...path25, ...issue2.path];
+        const fullpath = [...path26, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -6557,17 +6558,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path25 = []) => {
+  const processError = (error52, path26 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path25, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path26, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path25, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path26, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path25, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path26, ...issue2.path]);
       } else {
-        const fullpath = [...path25, ...issue2.path];
+        const fullpath = [...path26, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -6599,8 +6600,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path25 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path25) {
+  const path26 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path26) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -19292,13 +19293,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path25 = ref.slice(1).split("/").filter(Boolean);
-  if (path25.length === 0) {
+  const path26 = ref.slice(1).split("/").filter(Boolean);
+  if (path26.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path25[0] === defsKey) {
-    const key = path25[1];
+  if (path26[0] === defsKey) {
+    const key = path26[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -20687,6 +20688,12 @@ function parseHostUsage(value2) {
       throw new Error(`Harness Usage contains unknown field '${key}'`);
     }
   }
+  for (const field of ["totalCredits", "contextUsagePercent"]) {
+    const candidate = value2[field];
+    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0)) {
+      throw new Error(`Harness Usage '${field}' must be a finite non-negative number`);
+    }
+  }
   for (const field of tokenFields) {
     const candidate = value2[field];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
@@ -22329,8 +22336,8 @@ function projectFileChangeKind(kind) {
   return { type: kind };
 }
 function projectFileChanges(changes) {
-  return changes.map(({ path: path25, kind, unifiedDiff }) => ({
-    path: path25,
+  return changes.map(({ path: path26, kind, unifiedDiff }) => ({
+    path: path26,
     kind: projectFileChangeKind(kind),
     diff: unifiedDiff
   }));
@@ -22625,7 +22632,9 @@ function projectHistoricalTurn(input) {
     codexErrorInfo: "other",
     additionalDetails: null
   } : null;
-  const { startedAtMs, completedAtMs } = snapshot;
+  const startedAtMs = snapshot.startedAtMs;
+  const completedAtMs = snapshot.completedAtMs;
+  const hasTiming = startedAtMs !== void 0 && completedAtMs !== void 0 && Number.isFinite(startedAtMs) && Number.isFinite(completedAtMs) && startedAtMs >= 0 && completedAtMs >= startedAtMs;
   return {
     id: turnId,
     status: historicalStatus(snapshot.outcome),
@@ -22656,9 +22665,9 @@ function projectHistoricalTurn(input) {
       })
     ],
     error: error51,
-    startedAt: startedAtMs === void 0 ? null : Math.floor(startedAtMs / 1e3),
-    completedAt: completedAtMs === void 0 ? null : Math.floor(completedAtMs / 1e3),
-    durationMs: startedAtMs === void 0 || completedAtMs === void 0 ? null : Math.max(0, completedAtMs - startedAtMs),
+    startedAt: hasTiming ? Math.floor(startedAtMs / 1e3) : null,
+    completedAt: hasTiming ? Math.floor(completedAtMs / 1e3) : null,
+    durationMs: hasTiming ? completedAtMs - startedAtMs : null,
     itemsView: "full"
   };
 }
@@ -23285,13 +23294,13 @@ function decodeThreadForkRequest(request) {
   if (runtimeWorkspaceRoots !== void 0 && runtimeWorkspaceRoots !== null && (!Array.isArray(runtimeWorkspaceRoots) || runtimeWorkspaceRoots.some((root) => typeof root !== "string" || root.length === 0))) {
     throw new Error("thread/fork params.runtimeWorkspaceRoots must be text paths or null");
   }
-  const path25 = optionalText(params, "path", { allowEmpty: true });
+  const path26 = optionalText(params, "path", { allowEmpty: true });
   const ephemeral = optionalBoolean(params, "ephemeral");
   return {
     threadId: threadId3,
     ...lastTurnText ? { lastTurnId: hostTurnIdSchema.parse(lastTurnText) } : {},
     ...beforeTurnText ? { beforeTurnId: hostTurnIdSchema.parse(beforeTurnText) } : {},
-    ...path25 ? { path: path25 } : {},
+    ...path26 ? { path: path26 } : {},
     ...optionalField(params, "model"),
     ...optionalField(params, "modelProvider"),
     ...optionalField(params, "cwd"),
@@ -25284,6 +25293,7 @@ async function executeCurrentLastTurnRollback(input) {
       error: { code: -32079, message: "External Native Session is unavailable" }
     };
   }
+  const configuration = currentConfiguration(current);
   let opened;
   try {
     opened = await adapter.open({
@@ -25293,7 +25303,10 @@ async function executeCurrentLastTurnRollback(input) {
         ...input.environment ?? process.env,
         [DELEGATION_THREAD_ID_ENV]: current.id
       },
-      sourceRef: currentNativeRef
+      sourceRef: currentNativeRef,
+      ...configuration.effectiveModel ? { model: configuration.effectiveModel } : {},
+      ...configuration.effectiveThinkingOptionId ? { thinkingOptionId: configuration.effectiveThinkingOptionId } : {},
+      ...configuration.effectivePermissionModeId ? { permissionModeId: configuration.effectivePermissionModeId } : {}
     });
   } catch {
     return { ok: false, error: { code: -32076, message: "External Thread rollback failed" } };
@@ -25310,7 +25323,6 @@ async function executeCurrentLastTurnRollback(input) {
       error: { code: -32076, message: "External rollback did not return a valid Session" }
     };
   }
-  const configuration = currentConfiguration(current);
   const configurationError = await restoreCurrentConfiguration(session, configuration);
   if (configurationError) {
     await session.close().catch(() => void 0);
@@ -25882,6 +25894,8 @@ var ExternalThreadRuntime = class {
       environment: { ...this.#environment, [DELEGATION_THREAD_ID_ENV]: record3.hostThreadId },
       nativeRef: record3.nativeSessionRef,
       knownTurnRefs: record3.turnMappings.map(({ nativeTurnRef }) => nativeTurnRef),
+      ...restoredSelection?.model ? { model: restoredSelection.model } : {},
+      ...restoredSelection?.thinkingOptionId ? { thinkingOptionId: restoredSelection.thinkingOptionId } : {},
       ...harnessId === "grok" && restoredSelection?.permissionModeId ? { permissionModeId: restoredSelection.permissionModeId } : {}
     });
     if (!opened.ok) {
@@ -27798,25 +27812,25 @@ function resolveExternalSessionTreeIds(records) {
   const resolve = (start) => {
     const cached2 = resolved.get(start.hostThreadId);
     if (cached2) return cached2;
-    const path25 = [];
+    const path26 = [];
     const visited = /* @__PURE__ */ new Set();
     let current = start;
     while (true) {
       const known = resolved.get(current.hostThreadId);
       if (known) {
-        for (const record3 of path25) resolved.set(record3.hostThreadId, known);
+        for (const record3 of path26) resolved.set(record3.hostThreadId, known);
         return known;
       }
       if (visited.has(current.hostThreadId)) {
         throw new Error("External Thread Fork tree contains a cycle");
       }
       visited.add(current.hostThreadId);
-      path25.push(current);
+      path26.push(current);
       const sourceId = current.forkSource?.hostThreadId;
       const source = sourceId ? byId.get(sourceId) : void 0;
       if (!source) {
         const root = current.hostThreadId;
-        for (const record3 of path25) resolved.set(record3.hostThreadId, root);
+        for (const record3 of path26) resolved.set(record3.hostThreadId, root);
         return root;
       }
       current = source;
@@ -28361,6 +28375,8 @@ function approvalServerName(harnessId) {
       return "Oh My Pi";
     case "antigravity":
       return "Antigravity CLI";
+    case "kiro-cli":
+      return "Kiro CLI";
     default:
       return harnessId;
   }
@@ -32107,6 +32123,40 @@ var AppServerHost = class {
   }
 };
 
+// packages/host-runtime/src/codex-runtime/account-official-listeners.ts
+import path13 from "node:path";
+var AccountOfficialListeners = class {
+  constructor(createListener) {
+    this.createListener = createListener;
+  }
+  createListener;
+  #listeners = /* @__PURE__ */ new Map();
+  #starting = /* @__PURE__ */ new Map();
+  #closed = false;
+  async endpoint(account) {
+    if (this.#closed) throw new Error("Account official listeners are closed");
+    const key = path13.resolve(account.codexHome);
+    const existing = this.#starting.get(key);
+    if (existing) return existing;
+    const listener = this.createListener(account);
+    this.#listeners.set(key, listener);
+    const starting = listener.listen().catch(async (error51) => {
+      await listener.close();
+      this.#listeners.delete(key);
+      this.#starting.delete(key);
+      throw error51;
+    });
+    this.#starting.set(key, starting);
+    return starting;
+  }
+  async close() {
+    this.#closed = true;
+    await Promise.all([...this.#listeners.values()].map((listener) => listener.close()));
+    this.#listeners.clear();
+    this.#starting.clear();
+  }
+};
+
 // packages/host-runtime/src/delegation-control-registry.ts
 function only(values, message) {
   const value2 = values.length === 1 ? values[0] : void 0;
@@ -32215,17 +32265,17 @@ var DelegationControlRegistry = class {
 
 // packages/host-runtime/src/installed-harness-plugins.ts
 import os3 from "node:os";
-import path14 from "node:path";
+import path15 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // packages/host-runtime/src/launcher-url-opener.ts
 import { spawn as spawn3 } from "node:child_process";
-import path13 from "node:path";
+import path14 from "node:path";
 var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]"]);
 var OPEN_TIMEOUT_MS = 1e4;
 function createLauncherUrlOpener(environment, spawnLauncher = (command, arguments_2, options2) => spawn3(command, arguments_2, options2)) {
   const launcher = environment.CODEXHOST_LAUNCHER_EXECUTABLE;
-  if (!launcher || !path13.isAbsolute(launcher)) return void 0;
+  if (!launcher || !path14.isAbsolute(launcher)) return void 0;
   const launcherEnvironment = Object.fromEntries(
     Object.entries(environment).filter(([name]) => {
       const normalized = name.toUpperCase();
@@ -32283,9 +32333,9 @@ function installedHarnessPluginOptions(environment, managedRemoteHost = false, h
   const opener = managedRemoteHost ? void 0 : createLauncherUrlOpener(environment);
   return {
     pluginRoots: [
-      path14.join(path14.dirname(fileURLToPath(hostRuntimeUrl)), "plugins"),
-      environment[HARNESS_PLUGIN_DIRECTORY_ENV] ?? path14.join(
-        environment.CODEXHOST_DATA_DIR ? path14.resolve(environment.CODEXHOST_DATA_DIR) : path14.join(os3.homedir(), ".codexhost"),
+      path15.join(path15.dirname(fileURLToPath(hostRuntimeUrl)), "plugins"),
+      environment[HARNESS_PLUGIN_DIRECTORY_ENV] ?? path15.join(
+        environment.CODEXHOST_DATA_DIR ? path15.resolve(environment.CODEXHOST_DATA_DIR) : path15.join(os3.homedir(), ".codexhost"),
         "plugins"
       )
     ],
@@ -32410,9 +32460,9 @@ async function startDelegationControlServer(input) {
 import { createHash as createHash6, randomUUID as randomUUID9 } from "node:crypto";
 import { mkdir as mkdir7, open as open5, readFile as readFile8, rename as rename5, rm as rm5, stat as stat3 } from "node:fs/promises";
 import os4 from "node:os";
-import path15 from "node:path";
+import path16 from "node:path";
 var SKILL_VERSION = 5;
-var SKILL_RELATIVE_PATH = path15.join("skills", "codexhost-delegation", "SKILL.md");
+var SKILL_RELATIVE_PATH = path16.join("skills", "codexhost-delegation", "SKILL.md");
 var PREVIOUS_MANAGED_DIGESTS = [
   "aff258622dc8ff321f32b15620d081e578cb9c9ed1134d6a57f35ca8e7762c0a",
   "ba509f57e5448e796b3dfdd5031dcb08672eded50b61c0a54de84cfa02c49dd3",
@@ -32501,8 +32551,8 @@ async function readOptional(filePath) {
   }
 }
 async function atomicWrite(filePath, content) {
-  await mkdir7(path15.dirname(filePath), { recursive: true, mode: 448 });
-  const temporaryPath = path15.join(path15.dirname(filePath), `.SKILL.md.${randomUUID9()}.tmp`);
+  await mkdir7(path16.dirname(filePath), { recursive: true, mode: 448 });
+  const temporaryPath = path16.join(path16.dirname(filePath), `.SKILL.md.${randomUUID9()}.tmp`);
   const handle = await open5(temporaryPath, "wx", 384);
   try {
     await handle.writeFile(content, "utf8");
@@ -32519,8 +32569,8 @@ async function atomicWrite(filePath, content) {
 async function installDelegationSkills(input = {}) {
   const home = input.homeDirectory ?? os4.homedir();
   const destinations = [
-    path15.join(home, ".agents", SKILL_RELATIVE_PATH),
-    path15.join(home, ".claude", SKILL_RELATIVE_PATH)
+    path16.join(home, ".agents", SKILL_RELATIVE_PATH),
+    path16.join(home, ".claude", SKILL_RELATIVE_PATH)
   ];
   const knownDigests = /* @__PURE__ */ new Set([
     CURRENT_DIGEST,
@@ -32587,7 +32637,7 @@ async function installDelegationSkills(input = {}) {
 // packages/host-runtime/src/remote-control-app-server.ts
 import { randomUUID as randomUUID10 } from "node:crypto";
 import { mkdir as mkdir8, open as open6, rename as rename6, rm as rm6 } from "node:fs/promises";
-import path16 from "node:path";
+import path17 from "node:path";
 
 // packages/host-runtime/src/remote-official-connection.ts
 import net from "node:net";
@@ -32777,8 +32827,8 @@ var BRIDGE_READY_METHOD = "codexhost/remote-control-bridge/ready";
 function absoluteEnvironmentPath2(environment, name, fallback, platform = process.platform) {
   const value2 = environment[name] ?? fallback;
   if (!value2) return null;
-  if (path16.isAbsolute(value2)) return path16.normalize(value2);
-  return platform === "win32" && path16.win32.isAbsolute(value2) ? path16.win32.normalize(value2) : null;
+  if (path17.isAbsolute(value2)) return path17.normalize(value2);
+  return platform === "win32" && path17.win32.isAbsolute(value2) ? path17.win32.normalize(value2) : null;
 }
 function nodeCompatibleWindowsPath(value2) {
   if (value2.startsWith("\\\\?\\UNC\\")) return `\\\\${value2.slice(8)}`;
@@ -32792,13 +32842,13 @@ function remoteControlBridgePipePath(processId = process.pid, instanceId = rando
 }
 function remoteControlBridgeDescriptorPath(environment) {
   const root = environment.LOCALAPPDATA;
-  if (!root || !path16.isAbsolute(root)) return null;
-  return path16.join(path16.normalize(root), "codexhost", REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE);
+  if (!root || !path17.isAbsolute(root)) return null;
+  return path17.join(path17.normalize(root), "codexhost", REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE);
 }
 async function publishRemoteControlAppServerDescriptor(plan) {
-  const directory = path16.dirname(plan.descriptorPath);
+  const directory = path17.dirname(plan.descriptorPath);
   await mkdir8(directory, { recursive: true, mode: 448 });
-  const temporaryPath = path16.join(
+  const temporaryPath = path17.join(
     directory,
     `.${REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE}.${plan.descriptor.ownerPid}.${randomUUID10()}.tmp`
   );
@@ -32891,14 +32941,14 @@ async function runRemoteControlAppServerBridge(input = {}) {
 import { createServer as createServer2 } from "node:http";
 import net2 from "node:net";
 import { chmod as chmod3, lstat as lstat6, mkdir as mkdir10, rm as rm8 } from "node:fs/promises";
-import path18 from "node:path";
+import path19 from "node:path";
 import { PassThrough as PassThrough2 } from "node:stream";
 
 // packages/host-runtime/src/remote-socket-lock.ts
 import { randomUUID as randomUUID11 } from "node:crypto";
 import { chmod as chmod2, lstat as lstat5, mkdir as mkdir9, open as open7, readFile as readFile9, readdir as readdir4, rename as rename7, rm as rm7 } from "node:fs/promises";
 import { uptime } from "node:os";
-import path17 from "node:path";
+import path18 from "node:path";
 import { setTimeout as delay4 } from "node:timers/promises";
 var LOCK_RETRY_COUNT = 200;
 var LOCK_RETRY_DELAY_MS = 25;
@@ -32972,7 +33022,7 @@ async function readLockEntrySnapshot(filePath) {
     source,
     identity: { dev: metadata.dev, ino: metadata.ino },
     mtimeMs: metadata.mtimeMs,
-    record: record3 && path17.basename(filePath) === lockEntryName(record3.ownerToken) ? record3 : null
+    record: record3 && path18.basename(filePath) === lockEntryName(record3.ownerToken) ? record3 : null
   };
 }
 function lockEntryIsAbandoned(snapshot) {
@@ -32993,7 +33043,7 @@ async function readLockEntryCatalog(lockDirectory) {
   let unsettled = false;
   for (const name of names) {
     if (!name.startsWith(LOCK_ENTRY_PREFIX) || !name.endsWith(LOCK_ENTRY_SUFFIX)) continue;
-    const snapshot = await readLockEntrySnapshot(path17.join(lockDirectory, name));
+    const snapshot = await readLockEntrySnapshot(path18.join(lockDirectory, name));
     if (snapshot === null) continue;
     if (lockEntryIsAbandoned(snapshot)) {
       if (!await removeAbandonedLockEntry(snapshot)) unsettled = true;
@@ -33021,7 +33071,7 @@ async function preparePrivateLockDirectory(lockDirectory) {
   await chmod2(lockDirectory, 448);
 }
 async function writeLockRecordAtomic(lockDirectory, entryPath, record3) {
-  const temporary = path17.join(lockDirectory, `.tmp-${record3.ownerToken}-${randomUUID11()}`);
+  const temporary = path18.join(lockDirectory, `.tmp-${record3.ownerToken}-${randomUUID11()}`);
   const handle = await open7(temporary, "wx", 384);
   try {
     await handle.writeFile(`${JSON.stringify(record3)}
@@ -33097,7 +33147,7 @@ async function withRemoteAppServerSocketInitializationLock(socketPath, action) {
   const lockDirectory = `${socketPath}.initializers`;
   await preparePrivateLockDirectory(lockDirectory);
   const ownerToken = randomUUID11();
-  const entryPath = path17.join(lockDirectory, lockEntryName(ownerToken));
+  const entryPath = path18.join(lockDirectory, lockEntryName(ownerToken));
   const baseRecord = {
     version: 2,
     ownerToken,
@@ -33271,14 +33321,14 @@ function remoteAppServerSocketPath(environment, listenUrl = "unix://") {
     throw new Error("Remote app-server listener must use a Unix URL");
   }
   const explicit = listenUrl.slice("unix://".length);
-  if (explicit.length > 0) return path18.posix.resolve(decodeURIComponent(explicit));
-  const codexHome = environment.CODEX_HOME ?? (environment.HOME ? path18.posix.join(environment.HOME, ".codex") : void 0);
+  if (explicit.length > 0) return path19.posix.resolve(decodeURIComponent(explicit));
+  const codexHome = environment.CODEX_HOME ?? (environment.HOME ? path19.posix.join(environment.HOME, ".codex") : void 0);
   if (!codexHome)
     throw new Error("CODEX_HOME or HOME is required for the remote app-server socket");
-  return path18.posix.join(codexHome, "app-server-control", "app-server-control.sock");
+  return path19.posix.join(codexHome, "app-server-control", "app-server-control.sock");
 }
 function officialListenerArgumentsForRemoteListener(arguments_2, socketPath) {
-  if (!path18.posix.isAbsolute(socketPath)) {
+  if (!path19.posix.isAbsolute(socketPath)) {
     throw new Error("Shared official app-server socket path must be absolute");
   }
   if (remoteUnixListenerUrl(arguments_2) === null) {
@@ -33389,7 +33439,7 @@ async function removeStaleSocket(socketPath) {
   await rm8(socketPath, { force: true });
 }
 async function prepareRemoteAppServerSocketDirectory(socketPath) {
-  const socketDirectory = path18.dirname(socketPath);
+  const socketDirectory = path19.dirname(socketPath);
   const existing = await lstat6(socketDirectory).catch((error51) => {
     if (error51.code === "ENOENT") return null;
     throw error51;
@@ -33596,18 +33646,18 @@ function createRemoteAppServerWebSocketListener(input) {
 import { spawn as spawn4 } from "node:child_process";
 import { randomUUID as randomUUID12 } from "node:crypto";
 import { lstat as lstat7, rm as rm9 } from "node:fs/promises";
-import path19 from "node:path";
+import path20 from "node:path";
 var DEFAULT_CLOSE_TIMEOUT_MS = 2e3;
 var DEFAULT_LISTEN_TIMEOUT_MS = 1e4;
 function remoteOfficialAppServerSocketPath(desktopControlSocketPath, token = randomUUID12()) {
-  if (!path19.posix.isAbsolute(desktopControlSocketPath)) {
+  if (!path20.posix.isAbsolute(desktopControlSocketPath)) {
     throw new Error("Desktop control socket path must be absolute");
   }
   if (!/^[A-Za-z0-9-]+$/u.test(token) || !/[A-Za-z0-9]/u.test(token)) {
     throw new Error("Shared official app-server socket token is invalid");
   }
   const compactToken = token.replaceAll("-", "").slice(0, 15);
-  return path19.posix.join(path19.posix.dirname(desktopControlSocketPath), `.c-${compactToken}.sock`);
+  return path20.posix.join(path20.posix.dirname(desktopControlSocketPath), `.c-${compactToken}.sock`);
 }
 function errorMessage5(error51) {
   return error51 instanceof Error ? error51.message : String(error51);
@@ -34074,9 +34124,9 @@ function hasLauncherManagedUpdateRuntime(environment, hostRuntimePath) {
   if (!environment[UPDATE_RUNTIME_ENV.launcherPid]) return false;
   const npmPackageRoot = environment[UPDATE_RUNTIME_ENV.npmPackageRoot];
   if (!npmPackageRoot || !hostRuntimePath) return true;
-  if (!path20.isAbsolute(npmPackageRoot) || !path20.isAbsolute(hostRuntimePath)) return false;
-  const runtimePackageRoot = path20.dirname(path20.dirname(path20.normalize(hostRuntimePath)));
-  return path20.relative(path20.normalize(npmPackageRoot), runtimePackageRoot) === "";
+  if (!path21.isAbsolute(npmPackageRoot) || !path21.isAbsolute(hostRuntimePath)) return false;
+  const runtimePackageRoot = path21.dirname(path21.dirname(path21.normalize(hostRuntimePath)));
+  return path21.relative(path21.normalize(npmPackageRoot), runtimePackageRoot) === "";
 }
 function requiredRuntimeConfiguration(environment) {
   const stockCodexPath = environment[STOCK_CODEX_PATH_ENV];
@@ -34157,19 +34207,15 @@ async function runHostRuntime(input) {
         const officialPlan = createRemoteControlOfficialAppServerPlan(
           remoteControlPlan.officialArguments
         );
-        const officialListener = createLoopbackOfficialAppServerListener({
-          stockCodexPath,
-          arguments: officialPlan.listenerArguments,
-          environment: officialEnvironment(delegationEnvironment),
-          diagnosticOutput: process.stderr
-        });
-        let officialEndpoint = null;
-        const createOfficialConnection = () => {
-          if (!officialEndpoint) {
-            throw new Error("Shared official app-server endpoint is unavailable");
-          }
-          return createRemoteOfficialAppServerConnection(officialEndpoint);
-        };
+        const officialListeners = new AccountOfficialListeners(
+          (account) => createLoopbackOfficialAppServerListener({
+            stockCodexPath,
+            arguments: officialPlan.listenerArguments,
+            environment: officialAccountEnvironment(delegationEnvironment, account),
+            diagnosticOutput: process.stderr
+          })
+        );
+        const createOfficialConnection = async (account) => createRemoteOfficialAppServerConnection(await officialListeners.endpoint(account));
         const mappingStore = createProductionExternalThreadStore(delegationEnvironment);
         await mappingStore.initialize();
         const host = new AppServerHost({
@@ -34206,7 +34252,11 @@ async function runHostRuntime(input) {
           }
         });
         try {
-          officialEndpoint = await officialListener.listen();
+          await officialListeners.endpoint({
+            codexHome: path21.resolve(
+              delegationEnvironment.CODEX_HOME ?? path21.join(homedir(), ".codex")
+            )
+          });
           await listener.listen();
           await publishRemoteControlAppServerDescriptor(remoteControlPlan);
           return await host.run();
@@ -34215,7 +34265,7 @@ async function runHostRuntime(input) {
             await listener.close();
           } finally {
             try {
-              await officialListener.close();
+              await officialListeners.close();
             } finally {
               await mappingStore.close();
             }
@@ -34320,7 +34370,7 @@ import {
   stat as stat4,
   writeFile as writeFile5
 } from "node:fs/promises";
-import path21 from "node:path";
+import path22 from "node:path";
 var MANIFEST_FORMAT = 1;
 var WRAPPER_MARKER = "# codexhost remote SSH wrapper v1";
 var PROFILE_START = "# >>> codexhost remote SSH >>>";
@@ -34331,25 +34381,25 @@ function resolvePaths(options2) {
   if (!configuredHome) {
     throw new Error("A non-root HOME is required for remote Host installation");
   }
-  const home = path21.resolve(configuredHome);
-  if (!home || home === path21.parse(home).root) {
+  const home = path22.resolve(configuredHome);
+  if (!home || home === path22.parse(home).root) {
     throw new Error("A non-root HOME is required for remote Host installation");
   }
-  const installRoot = path21.resolve(options2.installRoot ?? path21.join(home, ".codexhost", "remote"));
-  const profilePath = path21.resolve(
-    options2.profilePath ?? path21.join(
+  const installRoot = path22.resolve(options2.installRoot ?? path22.join(home, ".codexhost", "remote"));
+  const profilePath = path22.resolve(
+    options2.profilePath ?? path22.join(
       home,
-      path21.basename(environment.SHELL ?? "") === "zsh" ? ".zshenv" : path21.basename(environment.SHELL ?? "") === "bash" ? ".bashrc" : ".profile"
+      path22.basename(environment.SHELL ?? "") === "zsh" ? ".zshenv" : path22.basename(environment.SHELL ?? "") === "bash" ? ".bashrc" : ".profile"
     )
   );
-  const binDirectory = path21.join(installRoot, "bin");
+  const binDirectory = path22.join(installRoot, "bin");
   return {
     home,
     installRoot,
     binDirectory,
-    wrapperPath: path21.join(binDirectory, "codex"),
-    manifestPath: path21.join(installRoot, "manifest.json"),
-    dataDirectory: path21.join(installRoot, "data"),
+    wrapperPath: path22.join(binDirectory, "codex"),
+    manifestPath: path22.join(installRoot, "manifest.json"),
+    dataDirectory: path22.join(installRoot, "data"),
     profilePath
   };
 }
@@ -34368,7 +34418,7 @@ async function fileSha256(filePath) {
   return createHash7("sha256").update(await readFile10(filePath)).digest("hex");
 }
 async function executable(filePath, label) {
-  const absolute = path21.resolve(filePath);
+  const absolute = path22.resolve(filePath);
   try {
     if (!(await stat4(absolute)).isFile()) throw new Error("not a regular file");
     await access(absolute, fsConstants.X_OK);
@@ -34378,7 +34428,7 @@ async function executable(filePath, label) {
   return absolute;
 }
 async function existingFile(filePath, label) {
-  const absolute = path21.resolve(filePath);
+  const absolute = path22.resolve(filePath);
   try {
     const metadata = await stat4(absolute);
     if (!metadata.isFile()) throw new Error("not a regular file");
@@ -34388,9 +34438,9 @@ async function existingFile(filePath, label) {
   return absolute;
 }
 async function discoverExecutable(name, environment) {
-  for (const directory of (environment.PATH ?? "").split(path21.delimiter)) {
+  for (const directory of (environment.PATH ?? "").split(path22.delimiter)) {
     if (!directory) continue;
-    const candidate = path21.resolve(directory, name);
+    const candidate = path22.resolve(directory, name);
     try {
       await access(candidate, fsConstants.X_OK);
       return candidate;
@@ -34401,10 +34451,10 @@ async function discoverExecutable(name, environment) {
   return null;
 }
 async function writeAtomic(filePath, contents, mode) {
-  await mkdir11(path21.dirname(filePath), { recursive: true, mode: 448 });
-  const temporary = path21.join(
-    path21.dirname(filePath),
-    `.${path21.basename(filePath)}.${process.pid}.${randomUUID13()}.tmp`
+  await mkdir11(path22.dirname(filePath), { recursive: true, mode: 448 });
+  const temporary = path22.join(
+    path22.dirname(filePath),
+    `.${path22.basename(filePath)}.${process.pid}.${randomUUID13()}.tmp`
   );
   try {
     if (typeof contents === "string") {
@@ -34425,10 +34475,10 @@ async function writeAtomic(filePath, contents, mode) {
   }
 }
 async function writeAtomicExecutable(filePath, sourcePath) {
-  await mkdir11(path21.dirname(filePath), { recursive: true, mode: 448 });
-  const temporary = path21.join(
-    path21.dirname(filePath),
-    `.${path21.basename(filePath)}.${process.pid}.${randomUUID13()}.tmp`
+  await mkdir11(path22.dirname(filePath), { recursive: true, mode: 448 });
+  const temporary = path22.join(
+    path22.dirname(filePath),
+    `.${path22.basename(filePath)}.${process.pid}.${randomUUID13()}.tmp`
   );
   try {
     await copyFile3(sourcePath, temporary);
@@ -34469,8 +34519,8 @@ function removeManagedProfileBlock(contents) {
 function installManagedProfileBlock(contents, manifest) {
   const base = removeManagedProfileBlock(contents);
   const environment = [
-    `export CODEX_INSTALL_DIR=${shellQuote(path21.dirname(manifest.wrapperPath))}`,
-    `export PATH=${shellQuote(path21.dirname(manifest.wrapperPath))}:${shellQuote(path21.dirname(manifest.nodePath))}:${shellQuote(path21.dirname(manifest.stockCodexPath))}:"\${PATH:-/usr/local/bin:/usr/bin:/bin}"`,
+    `export CODEX_INSTALL_DIR=${shellQuote(path22.dirname(manifest.wrapperPath))}`,
+    `export PATH=${shellQuote(path22.dirname(manifest.wrapperPath))}:${shellQuote(path22.dirname(manifest.nodePath))}:${shellQuote(path22.dirname(manifest.stockCodexPath))}:"\${PATH:-/usr/local/bin:/usr/bin:/bin}"`,
     `export CODEXHOST_STOCK_CODEX_PATH=${shellQuote(manifest.stockCodexPath)}`,
     `export CODEXHOST_HOST_NODE_PATH=${shellQuote(manifest.nodePath)}`,
     `export CODEXHOST_HOST_RUNTIME_PATH=${shellQuote(manifest.hostRuntimePath)}`,
@@ -34487,7 +34537,7 @@ function installManagedProfileBlock(contents, manifest) {
     PROFILE_END,
     ""
   ].join("\n");
-  if (path21.basename(manifest.profilePath) === ".bashrc") return `${block}${base}`;
+  if (path22.basename(manifest.profilePath) === ".bashrc") return `${block}${base}`;
   const separator = base.length > 0 && !base.endsWith("\n") ? "\n" : "";
   return `${base}${separator}${block}`;
 }
@@ -34552,9 +34602,9 @@ async function readManifest(filePath) {
   ];
   const optionalPaths = ["claudeCommand", "profileBackupPath"];
   if (manifest.format !== MANIFEST_FORMAT || Object.keys(manifest).some((key) => !allowed.has(key)) || requiredPaths.some(
-    (key) => typeof manifest[key] !== "string" || !path21.isAbsolute(manifest[key])
+    (key) => typeof manifest[key] !== "string" || !path22.isAbsolute(manifest[key])
   ) || optionalPaths.some(
-    (key) => manifest[key] !== void 0 && (typeof manifest[key] !== "string" || !path21.isAbsolute(manifest[key]))
+    (key) => manifest[key] !== void 0 && (typeof manifest[key] !== "string" || !path22.isAbsolute(manifest[key]))
   ) || manifest.entrypointSha256 !== void 0 && (typeof manifest.entrypointSha256 !== "string" || !/^[a-f0-9]{64}$/u.test(manifest.entrypointSha256))) {
     throw new Error("Remote Host manifest has an unsupported format");
   }
@@ -34783,7 +34833,7 @@ async function uninstallRemoteHost(options2) {
 import { spawn as spawn5 } from "node:child_process";
 import { stat as stat5 } from "node:fs/promises";
 import net3 from "node:net";
-import path22 from "node:path";
+import path23 from "node:path";
 import { Duplex } from "node:stream";
 var CODEXHOST_STATUS_METHOD = "codexhost/update/status";
 var DIRECT_PROBE_TIMEOUT_MS = 5e3;
@@ -34802,9 +34852,9 @@ function classifyRemoteHostProbeResponse(response, socketPath) {
 }
 var lifecycleDependencyOverrides = {};
 function socketPathFor(environment) {
-  const codexHome = environment.CODEX_HOME ?? (environment.HOME ? path22.join(environment.HOME, ".codex") : void 0);
+  const codexHome = environment.CODEX_HOME ?? (environment.HOME ? path23.join(environment.HOME, ".codex") : void 0);
   if (!codexHome) throw new Error("CODEX_HOME or HOME is required for remote Host lifecycle");
-  return path22.join(codexHome, "app-server-control", "app-server-control.sock");
+  return path23.join(codexHome, "app-server-control", "app-server-control.sock");
 }
 async function defaultSocketExists(socketPath) {
   const metadata = await stat5(socketPath).catch((error51) => {
@@ -34934,7 +34984,7 @@ function installedManifest(status) {
 function managedEnvironment(manifest, environment) {
   return {
     ...environment,
-    CODEX_INSTALL_DIR: path22.dirname(manifest.wrapperPath),
+    CODEX_INSTALL_DIR: path23.dirname(manifest.wrapperPath),
     CODEXHOST_STOCK_CODEX_PATH: manifest.stockCodexPath,
     CODEXHOST_HOST_NODE_PATH: manifest.nodePath,
     CODEXHOST_HOST_RUNTIME_PATH: manifest.hostRuntimePath,
@@ -34942,7 +34992,7 @@ function managedEnvironment(manifest, environment) {
     CODEXHOST_DEFAULT_AGENT: "codex",
     CODEXHOST_REMOTE_SSH_MANAGED: "1",
     ...manifest.claudeCommand ? { CODEXHOST_CLAUDE_COMMAND: manifest.claudeCommand } : {},
-    PATH: `${path22.dirname(manifest.wrapperPath)}${path22.delimiter}${path22.dirname(manifest.stockCodexPath)}${path22.delimiter}${environment.PATH ?? "/usr/bin:/bin"}`
+    PATH: `${path23.dirname(manifest.wrapperPath)}${path23.delimiter}${path23.dirname(manifest.stockCodexPath)}${path23.delimiter}${environment.PATH ?? "/usr/bin:/bin"}`
   };
 }
 async function defaultRunTerminator(manifest, socketPath, role, environment) {
@@ -35284,19 +35334,19 @@ function consumeBrokerFrames(socket, onFrame, onError) {
 
 // packages/harness-broker/dist/paths.js
 import os5 from "node:os";
-import path23 from "node:path";
+import path24 from "node:path";
 var HARNESS_BROKER_DESCRIPTOR_ENV = "CODEXHOST_CLAUDE_BROKER_DESCRIPTOR";
 var HARNESS_BROKER_DESCRIPTOR_FILE = "claude-code-broker-v1.json";
 var HARNESS_BROKER_SOCKET_FILE = "claude-code-broker-v1.sock";
 function defaultHarnessBrokerDirectory(environment = process.env) {
   const home = environment.HOME || os5.homedir();
-  return path23.join(home, ".codexhost", "harness-broker");
+  return path24.join(home, ".codexhost", "harness-broker");
 }
 function defaultHarnessBrokerDescriptorPath(environment = process.env) {
-  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path23.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
+  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path24.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
 }
 function defaultHarnessBrokerSocketPath(environment = process.env) {
-  return path23.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_SOCKET_FILE);
+  return path24.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_SOCKET_FILE);
 }
 
 // packages/harness-broker/dist/validation.js
@@ -35311,6 +35361,8 @@ var createSchema = external_exports.object({
 }).strict();
 var resumeSchema = external_exports.object({
   kind: external_exports.literal("resume"),
+  model: harnessModelRefSchema.optional(),
+  thinkingOptionId: harnessThinkingOptionIdSchema.optional(),
   nativeRef: nativeSessionRefSchema,
   cwd: cwdSchema,
   knownTurnRefs: external_exports.array(nativeTurnRefSchema).max(1e5).optional()
@@ -35323,6 +35375,9 @@ var forkSchema = external_exports.object({
 }).strict();
 var rollbackSchema = external_exports.object({
   kind: external_exports.literal("rollbackLastTurn"),
+  model: harnessModelRefSchema.optional(),
+  thinkingOptionId: harnessThinkingOptionIdSchema.optional(),
+  permissionModeId: harnessPermissionModeIdSchema.optional(),
   sourceRef: nativeSessionRefSchema,
   cwd: cwdSchema
 }).strict();
@@ -35517,7 +35572,7 @@ var harnessOutputSchema = external_exports.custom((value2) => {
 import { randomBytes as randomBytes2, randomUUID as randomUUID14 } from "node:crypto";
 import { chmod as chmod5, lstat as lstat9, mkdir as mkdir12, open as open8, readFile as readFile11, rename as rename9, rm as rm11 } from "node:fs/promises";
 import net4, {} from "node:net";
-import path24 from "node:path";
+import path25 from "node:path";
 function harnessError(message, retryable = true) {
   return { code: "unavailable", message, retryable, stage: "harnessBroker" };
 }
@@ -35642,13 +35697,13 @@ async function startHarnessBrokerServer(input) {
   if (input.adapter.harnessId !== "claude-code") {
     throw new Error("Harness broker accepts only the claude-code adapter");
   }
-  if (process.platform !== "win32" && path24.dirname(input.descriptorPath) !== path24.dirname(input.socketPath)) {
+  if (process.platform !== "win32" && path25.dirname(input.descriptorPath) !== path25.dirname(input.socketPath)) {
     throw new Error("Harness broker descriptor and socket must share one private directory");
   }
   if (process.platform === "darwin" && Buffer.byteLength(input.socketPath) > 103) {
     throw new Error("Harness broker Unix socket path is too long for macOS");
   }
-  await privateDirectory(path24.dirname(input.descriptorPath));
+  await privateDirectory(path25.dirname(input.descriptorPath));
   await assertNoLiveDescriptor(input.descriptorPath);
   if (process.platform !== "win32")
     await prepareUnixSocketPath(input.socketPath);