@codexhost/cli-win32-arm64 0.6.0 → 0.6.1

package/app/host-runtime.mjs

@@ -4083,7 +4083,8 @@ async function runDelegationCli(input) {
 
 // packages/host-runtime/src/run-host-runtime.ts
 import { randomBytes } from "node:crypto";
-import path19 from "node:path";
+import path20 from "node:path";
+import { homedir } from "node:os";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/update-manager/dist/distribution.js
@@ -5701,10 +5702,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path24) {
-  if (!path24)
+function getElementAtPath(obj, path25) {
+  if (!path25)
     return obj;
-  return path24.reduce((acc, key) => acc?.[key], obj);
+  return path25.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -6113,11 +6114,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path24, issues) {
+function prefixIssues(path25, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path24);
+    iss.path.unshift(path25);
     return iss;
   });
 }
@@ -6264,16 +6265,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path24 = []) => {
+  const processError = (error52, path25 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path24, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path25, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path24, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path25, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path24, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path25, ...issue2.path]);
       } else {
-        const fullpath = [...path24, ...issue2.path];
+        const fullpath = [...path25, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -6300,17 +6301,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path24 = []) => {
+  const processError = (error52, path25 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path24, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path25, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path24, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path25, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path24, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path25, ...issue2.path]);
       } else {
-        const fullpath = [...path24, ...issue2.path];
+        const fullpath = [...path25, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -6342,8 +6343,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path24 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path24) {
+  const path25 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path25) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -19035,13 +19036,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path24 = ref.slice(1).split("/").filter(Boolean);
-  if (path24.length === 0) {
+  const path25 = ref.slice(1).split("/").filter(Boolean);
+  if (path25.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path24[0] === defsKey) {
-    const key = path24[1];
+  if (path25[0] === defsKey) {
+    const key = path25[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -19475,6 +19476,8 @@ var threadUsageSnapshotSchema = external_exports.object({
   reasoningOutputTokens: nonNegativeSafeIntegerSchema.optional(),
   totalTokens: nonNegativeSafeIntegerSchema.optional(),
   totalCostUsd: finiteNonNegativeNumberSchema.optional(),
+  totalCredits: finiteNonNegativeNumberSchema.optional(),
+  contextUsagePercent: finiteNonNegativeNumberSchema.optional(),
   cacheHitRatePercent: cacheHitRatePercentSchema.optional(),
   contextWindowTokens: nonNegativeSafeIntegerSchema.optional(),
   contextUsedTokens: nonNegativeSafeIntegerSchema.optional(),
@@ -20386,7 +20389,9 @@ var usageFields = /* @__PURE__ */ new Set([
   ...tokenFields,
   ...safeIntegerFields,
   ...percentFields,
-  "totalCostUsd"
+  "totalCostUsd",
+  "totalCredits",
+  "contextUsagePercent"
 ]);
 function isRecord(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
@@ -20402,6 +20407,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)) {
@@ -20726,7 +20737,7 @@ var MappingStore = class {
     ]);
     await this.#acquireLock();
     try {
-      await this.#cleanupTemps();
+      await this.#cleanupResidue();
       const names = (await readdir2(this.#threadsDirectory)).filter((name) => name.endsWith(".json"));
       for (const name of names) {
         const primary = path4.join(this.#threadsDirectory, name);
@@ -21150,14 +21161,17 @@ var MappingStore = class {
     }
     return parsed.data;
   }
-  async #cleanupTemps() {
-    const [threadNames, delegationNames] = await Promise.all([
+  async #cleanupResidue() {
+    const [threadNames, delegationNames, rootNames] = await Promise.all([
       readdir2(this.#threadsDirectory),
-      readdir2(this.#delegationsDirectory)
+      readdir2(this.#delegationsDirectory),
+      readdir2(this.#directory)
     ]);
     await Promise.all([
       ...threadNames.filter((name) => name.includes(".tmp-")).map((name) => rm3(path4.join(this.#threadsDirectory, name), { force: true })),
-      ...delegationNames.filter((name) => name.includes(".tmp-")).map((name) => rm3(path4.join(this.#delegationsDirectory, name), { force: true }))
+      ...delegationNames.filter((name) => name.includes(".tmp-")).map((name) => rm3(path4.join(this.#delegationsDirectory, name), { force: true })),
+      // Renamed aside by #acquireLock; nothing reads them back, and they accumulate one per run.
+      ...rootNames.filter((name) => name.startsWith(`${path4.basename(this.#lockPath)}.stale-`)).map((name) => rm3(path4.join(this.#directory, name), { force: true }))
     ]);
   }
   async #acquireLock() {
@@ -21349,6 +21363,9 @@ function projectCodexApprovalRequest(input) {
     throw new Error("Host Approval subject is unsupported");
   }
   validateActions(interaction);
+  if (new Set(interaction.actions.map(({ effect }) => effect)).size !== interaction.actions.length) {
+    return projectApprovalChoices(input);
+  }
   const allow = requiredActionForEffect(interaction, "allowOnce");
   const allowForSession = optionalActionForEffect(interaction, "allowForSession");
   const allowAlways = optionalActionForEffect(interaction, "allowAlways");
@@ -21414,6 +21431,63 @@ function projectCodexApprovalRequest(input) {
     }
   };
 }
+function projectApprovalChoices(input) {
+  const { interaction } = input;
+  const allow = actionsForEffect(interaction, "allowOnce")[0];
+  const deny = actionsForEffect(interaction, "deny")[0];
+  if (!allow || !deny)
+    throw new Error("Host Approval must declare allowOnce and deny actions");
+  const denyResponse = { type: "approval", actionId: deny.id };
+  return {
+    request: {
+      method: "mcpServer/elicitation/request",
+      params: {
+        serverName: boundedText(input.serverName, "server name", SERVER_NAME_MAX_LENGTH),
+        threadId: input.threadId,
+        turnId: interaction.turnId,
+        mode: "form",
+        message: [
+          clampedText(interaction.title, "title", TITLE_MAX_LENGTH),
+          ...interaction.description ? [interaction.description] : []
+        ].join("\n\n"),
+        requestedSchema: {
+          type: "object",
+          properties: {
+            actionId: {
+              type: "string",
+              title: "Approval",
+              oneOf: interaction.actions.map(({ id: id2, label }) => ({ const: id2, title: label })),
+              default: allow.id
+            }
+          },
+          required: ["actionId"]
+        }
+      }
+    },
+    denyResponse,
+    parseResponse(result) {
+      if (!isRecord2(result) || typeof result.action !== "string")
+        throw responseError("missing action");
+      if (Object.keys(result).some((key) => !["action", "content", "_meta"].includes(key))) {
+        throw responseError("contains unreviewed fields");
+      }
+      if (result._meta !== void 0 && result._meta !== null) {
+        throw responseError("contains unexpected persist metadata");
+      }
+      if (result.action === "decline" || result.action === "cancel") {
+        if (result.content !== void 0 && result.content !== null) {
+          throw responseError("contains fields incompatible with denial");
+        }
+        return denyResponse;
+      }
+      const content = result.content;
+      if (result.action !== "accept" || !isRecord2(content) || Object.keys(content).length !== 1 || !interaction.actions.some(({ id: id2 }) => id2 === content.actionId)) {
+        throw responseError("contains an undeclared approval choice");
+      }
+      return { type: "approval", actionId: content.actionId };
+    }
+  };
+}
 
 // packages/protocol-core/dist/codex-question.js
 function isRecord3(value2) {
@@ -21957,8 +22031,8 @@ function projectFileChangeKind(kind) {
   return { type: kind };
 }
 function projectFileChanges(changes) {
-  return changes.map(({ path: path24, kind, unifiedDiff }) => ({
-    path: path24,
+  return changes.map(({ path: path25, kind, unifiedDiff }) => ({
+    path: path25,
     kind: projectFileChangeKind(kind),
     diff: unifiedDiff
   }));
@@ -22116,7 +22190,7 @@ function projectItem(item, outcome, defaultCwd, includeCommandOutput = true, sen
         id: item.itemId,
         type: "agentMessage",
         text: item.text,
-        phase: null,
+        phase: item.phase ?? null,
         memoryCitation: null
       };
     case "reasoning":
@@ -22238,6 +22312,9 @@ function historicalStatus(outcome) {
 }
 function projectHistoricalTurn(input) {
   const { turnId, cwd, snapshot } = input;
+  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;
   const error51 = snapshot.outcome.status === "failed" ? {
     message: snapshot.outcome.error.message,
     codexErrorInfo: "other",
@@ -22273,9 +22350,9 @@ function projectHistoricalTurn(input) {
       })
     ],
     error: error51,
-    startedAt: null,
-    completedAt: null,
-    durationMs: null,
+    startedAt: hasTiming ? Math.floor(startedAtMs / 1e3) : null,
+    completedAt: hasTiming ? Math.floor(completedAtMs / 1e3) : null,
+    durationMs: hasTiming ? completedAtMs - startedAtMs : null,
     itemsView: "full"
   };
 }
@@ -22901,13 +22978,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 path24 = optionalText(params, "path", { allowEmpty: true });
+  const path25 = optionalText(params, "path", { allowEmpty: true });
   const ephemeral = optionalBoolean(params, "ephemeral");
   return {
     threadId: threadId3,
     ...lastTurnText ? { lastTurnId: hostTurnIdSchema.parse(lastTurnText) } : {},
     ...beforeTurnText ? { beforeTurnId: hostTurnIdSchema.parse(beforeTurnText) } : {},
-    ...path24 ? { path: path24 } : {},
+    ...path25 ? { path: path25 } : {},
     ...optionalField(params, "model"),
     ...optionalField(params, "modelProvider"),
     ...optionalField(params, "cwd"),
@@ -24862,6 +24939,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({
@@ -24871,7 +24949,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" } };
@@ -24888,7 +24969,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);
@@ -25460,6 +25540,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) {
@@ -27355,25 +27437,25 @@ function resolveExternalSessionTreeIds(records) {
   const resolve = (start) => {
     const cached2 = resolved.get(start.hostThreadId);
     if (cached2) return cached2;
-    const path24 = [];
+    const path25 = [];
     const visited = /* @__PURE__ */ new Set();
     let current = start;
     while (true) {
       const known = resolved.get(current.hostThreadId);
       if (known) {
-        for (const record3 of path24) resolved.set(record3.hostThreadId, known);
+        for (const record3 of path25) 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);
-      path24.push(current);
+      path25.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 path24) resolved.set(record3.hostThreadId, root);
+        for (const record3 of path25) resolved.set(record3.hostThreadId, root);
         return root;
       }
       current = source;
@@ -27914,6 +27996,8 @@ function approvalServerName(harnessId) {
       return "Oh My Pi";
     case "antigravity":
       return "Antigravity CLI";
+    case "kiro-cli":
+      return "Kiro CLI";
     default:
       return harnessId;
   }
@@ -31523,6 +31607,40 @@ var AppServerHost = class {
   }
 };
 
+// packages/host-runtime/src/codex-runtime/account-official-listeners.ts
+import path12 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 = path12.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;
@@ -31591,9 +31709,28 @@ var DelegationControlRegistry = class {
     );
   }
   async #registrationForThread(threadId3) {
-    return only(
-      await this.#matching((registration) => registration.ownsThread(threadId3)),
-      "Thread is not owned by exactly one active Host Runtime session"
+    const registrations = [...this.#registrations];
+    const matches = await this.#matching((registration) => registration.ownsThread(threadId3));
+    if (matches.length === 1) return matches[0];
+    if (matches.length > 1) {
+      throw new DelegationControlError(
+        "PARENT_THREAD_AMBIGUOUS",
+        "Thread is not owned by exactly one active Host Runtime session",
+        { matchingRuntimeCount: matches.length }
+      );
+    }
+    if (registrations.length === 0) {
+      throw new DelegationControlError(
+        "PARENT_THREAD_AMBIGUOUS",
+        "Thread is not owned by exactly one active Host Runtime session",
+        { matchingRuntimeCount: 0 }
+      );
+    }
+    if (registrations.length === 1) return registrations[0];
+    throw new DelegationControlError(
+      "PARENT_THREAD_AMBIGUOUS",
+      "Thread is not owned by exactly one active Host Runtime session",
+      { matchingRuntimeCount: 0 }
     );
   }
   #compareThreads(left, right, sort) {
@@ -31612,17 +31749,17 @@ var DelegationControlRegistry = class {
 
 // packages/host-runtime/src/installed-harness-plugins.ts
 import os3 from "node:os";
-import path13 from "node:path";
+import path14 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 path12 from "node:path";
+import path13 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 || !path12.isAbsolute(launcher)) return void 0;
+  if (!launcher || !path13.isAbsolute(launcher)) return void 0;
   const launcherEnvironment = Object.fromEntries(
     Object.entries(environment).filter(([name]) => {
       const normalized = name.toUpperCase();
@@ -31680,9 +31817,9 @@ function installedHarnessPluginOptions(environment, managedRemoteHost = false, h
   const opener = managedRemoteHost ? void 0 : createLauncherUrlOpener(environment);
   return {
     pluginRoots: [
-      path13.join(path13.dirname(fileURLToPath(hostRuntimeUrl)), "plugins"),
-      environment[HARNESS_PLUGIN_DIRECTORY_ENV] ?? path13.join(
-        environment.CODEXHOST_DATA_DIR ? path13.resolve(environment.CODEXHOST_DATA_DIR) : path13.join(os3.homedir(), ".codexhost"),
+      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"),
         "plugins"
       )
     ],
@@ -31807,10 +31944,11 @@ async function startDelegationControlServer(input) {
 import { createHash as createHash6, randomUUID as randomUUID9 } from "node:crypto";
 import { mkdir as mkdir7, open as open5, readFile as readFile7, rename as rename5, rm as rm5, stat as stat3 } from "node:fs/promises";
 import os4 from "node:os";
-import path14 from "node:path";
-var SKILL_VERSION = 4;
-var SKILL_RELATIVE_PATH = path14.join("skills", "codexhost-delegation", "SKILL.md");
+import path15 from "node:path";
+var SKILL_VERSION = 5;
+var SKILL_RELATIVE_PATH = path15.join("skills", "codexhost-delegation", "SKILL.md");
 var PREVIOUS_MANAGED_DIGESTS = [
+  "aff258622dc8ff321f32b15620d081e578cb9c9ed1134d6a57f35ca8e7762c0a",
   "ba509f57e5448e796b3dfdd5031dcb08672eded50b61c0a54de84cfa02c49dd3",
   "d3ddf6db9bc5c5df825479c885bbbf0ca08da66f7057a12e02e1fdf57525149e",
   "15eb63519ff867e1536c97188a0c43738d7a49d38d4d6adeb7a1036726e7246d"
@@ -31819,12 +31957,12 @@ var CODEXHOST_DELEGATION_SKILL = `---
 name: codexhost-delegation
 version: ${SKILL_VERSION}
 description: >
-  Delegate work to another coding agent. Use when the user explicitly asks
-  Claude Code, Pi, Codex/OpenAI, OMP, Grok, another agent, or an agent mentioned
-  as @<agent> to independently review, investigate, implement, test, or verify
-  something. Do not use when the user is merely discussing, comparing, or
-  configuring agents, choosing a Model or Provider, or asking the current agent
-  to role-play as another agent.
+  Delegate tasks to other coding agents, or read and follow up on existing
+  external agent sessions. Use when the user asks another agent (including
+  @agent) to independently perform a task, or asks to view a specified external
+  session's content, progress, or results, send follow-up messages, wait, or
+  cancel a task. Not for recapping the current conversation, discussing or
+  configuring agents, or role-playing.
 ---
 
 # Execute the task
@@ -31849,9 +31987,14 @@ When the user asks for a specific Model or Thinking level, inspect the target
 Harness first and use the exact opaque IDs returned by the authoritative CLI.
 When they do not specify either setting, omit it so the target keeps its default.
 
-Create an independent child session and submit the requested task.
+For a new delegation, create an independent child session and submit the
+requested task. For an existing external session, resolve the target from the
+user-provided session link, identifier, or context and operate on that Thread
+directly; it need not have been created by the current assistant. If the target
+is ambiguous, ask the user to identify it. Keep requests to view or summarize a
+session read-only.
 
-After starting the task, choose the appropriate next action based on the
+For a new or existing task, choose the appropriate next action based on the
 user’s request and the task:
 
 - send a follow-up message to the same Thread;
@@ -31861,10 +32004,11 @@ user’s request and the task:
 - check it again later;
 - leave it running in the background.
 
-When the result is needed, explicitly read the child Thread. Report only the
+When the result is needed, explicitly read the target Thread. Report only the
 visible result returned by that Thread.
 
-Provide the user with the necessary tracking information, including:
+Provide the user with the necessary tracking information available from the
+CLI; omit unavailable fields rather than inventing them:
 
 - target agent;
 - \`delegationId\`;
@@ -31890,8 +32034,8 @@ async function readOptional(filePath) {
   }
 }
 async function atomicWrite(filePath, content) {
-  await mkdir7(path14.dirname(filePath), { recursive: true, mode: 448 });
-  const temporaryPath = path14.join(path14.dirname(filePath), `.SKILL.md.${randomUUID9()}.tmp`);
+  await mkdir7(path15.dirname(filePath), { recursive: true, mode: 448 });
+  const temporaryPath = path15.join(path15.dirname(filePath), `.SKILL.md.${randomUUID9()}.tmp`);
   const handle = await open5(temporaryPath, "wx", 384);
   try {
     await handle.writeFile(content, "utf8");
@@ -31908,8 +32052,8 @@ async function atomicWrite(filePath, content) {
 async function installDelegationSkills(input = {}) {
   const home = input.homeDirectory ?? os4.homedir();
   const destinations = [
-    path14.join(home, ".agents", SKILL_RELATIVE_PATH),
-    path14.join(home, ".claude", SKILL_RELATIVE_PATH)
+    path15.join(home, ".agents", SKILL_RELATIVE_PATH),
+    path15.join(home, ".claude", SKILL_RELATIVE_PATH)
   ];
   const knownDigests = /* @__PURE__ */ new Set([
     CURRENT_DIGEST,
@@ -31976,7 +32120,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 path15 from "node:path";
+import path16 from "node:path";
 
 // packages/host-runtime/src/remote-official-connection.ts
 import net from "node:net";
@@ -32166,8 +32310,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 (path15.isAbsolute(value2)) return path15.normalize(value2);
-  return platform === "win32" && path15.win32.isAbsolute(value2) ? path15.win32.normalize(value2) : null;
+  if (path16.isAbsolute(value2)) return path16.normalize(value2);
+  return platform === "win32" && path16.win32.isAbsolute(value2) ? path16.win32.normalize(value2) : null;
 }
 function nodeCompatibleWindowsPath(value2) {
   if (value2.startsWith("\\\\?\\UNC\\")) return `\\\\${value2.slice(8)}`;
@@ -32181,13 +32325,13 @@ function remoteControlBridgePipePath(processId = process.pid, instanceId = rando
 }
 function remoteControlBridgeDescriptorPath(environment) {
   const root = environment.LOCALAPPDATA;
-  if (!root || !path15.isAbsolute(root)) return null;
-  return path15.join(path15.normalize(root), "codexhost", REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE);
+  if (!root || !path16.isAbsolute(root)) return null;
+  return path16.join(path16.normalize(root), "codexhost", REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE);
 }
 async function publishRemoteControlAppServerDescriptor(plan) {
-  const directory = path15.dirname(plan.descriptorPath);
+  const directory = path16.dirname(plan.descriptorPath);
   await mkdir8(directory, { recursive: true, mode: 448 });
-  const temporaryPath = path15.join(
+  const temporaryPath = path16.join(
     directory,
     `.${REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE}.${plan.descriptor.ownerPid}.${randomUUID10()}.tmp`
   );
@@ -32280,14 +32424,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 path17 from "node:path";
+import path18 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 readFile8, readdir as readdir4, rename as rename7, rm as rm7 } from "node:fs/promises";
 import { uptime } from "node:os";
-import path16 from "node:path";
+import path17 from "node:path";
 import { setTimeout as delay4 } from "node:timers/promises";
 var LOCK_RETRY_COUNT = 200;
 var LOCK_RETRY_DELAY_MS = 25;
@@ -32361,7 +32505,7 @@ async function readLockEntrySnapshot(filePath) {
     source,
     identity: { dev: metadata.dev, ino: metadata.ino },
     mtimeMs: metadata.mtimeMs,
-    record: record3 && path16.basename(filePath) === lockEntryName(record3.ownerToken) ? record3 : null
+    record: record3 && path17.basename(filePath) === lockEntryName(record3.ownerToken) ? record3 : null
   };
 }
 function lockEntryIsAbandoned(snapshot) {
@@ -32382,7 +32526,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(path16.join(lockDirectory, name));
+    const snapshot = await readLockEntrySnapshot(path17.join(lockDirectory, name));
     if (snapshot === null) continue;
     if (lockEntryIsAbandoned(snapshot)) {
       if (!await removeAbandonedLockEntry(snapshot)) unsettled = true;
@@ -32410,7 +32554,7 @@ async function preparePrivateLockDirectory(lockDirectory) {
   await chmod2(lockDirectory, 448);
 }
 async function writeLockRecordAtomic(lockDirectory, entryPath, record3) {
-  const temporary = path16.join(lockDirectory, `.tmp-${record3.ownerToken}-${randomUUID11()}`);
+  const temporary = path17.join(lockDirectory, `.tmp-${record3.ownerToken}-${randomUUID11()}`);
   const handle = await open7(temporary, "wx", 384);
   try {
     await handle.writeFile(`${JSON.stringify(record3)}
@@ -32486,7 +32630,7 @@ async function withRemoteAppServerSocketInitializationLock(socketPath, action) {
   const lockDirectory = `${socketPath}.initializers`;
   await preparePrivateLockDirectory(lockDirectory);
   const ownerToken = randomUUID11();
-  const entryPath = path16.join(lockDirectory, lockEntryName(ownerToken));
+  const entryPath = path17.join(lockDirectory, lockEntryName(ownerToken));
   const baseRecord = {
     version: 2,
     ownerToken,
@@ -32660,14 +32804,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 path17.posix.resolve(decodeURIComponent(explicit));
-  const codexHome = environment.CODEX_HOME ?? (environment.HOME ? path17.posix.join(environment.HOME, ".codex") : void 0);
+  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 (!codexHome)
     throw new Error("CODEX_HOME or HOME is required for the remote app-server socket");
-  return path17.posix.join(codexHome, "app-server-control", "app-server-control.sock");
+  return path18.posix.join(codexHome, "app-server-control", "app-server-control.sock");
 }
 function officialListenerArgumentsForRemoteListener(arguments_2, socketPath) {
-  if (!path17.posix.isAbsolute(socketPath)) {
+  if (!path18.posix.isAbsolute(socketPath)) {
     throw new Error("Shared official app-server socket path must be absolute");
   }
   if (remoteUnixListenerUrl(arguments_2) === null) {
@@ -32778,7 +32922,7 @@ async function removeStaleSocket(socketPath) {
   await rm8(socketPath, { force: true });
 }
 async function prepareRemoteAppServerSocketDirectory(socketPath) {
-  const socketDirectory = path17.dirname(socketPath);
+  const socketDirectory = path18.dirname(socketPath);
   const existing = await lstat6(socketDirectory).catch((error51) => {
     if (error51.code === "ENOENT") return null;
     throw error51;
@@ -32985,18 +33129,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 path18 from "node:path";
+import path19 from "node:path";
 var DEFAULT_CLOSE_TIMEOUT_MS = 2e3;
 var DEFAULT_LISTEN_TIMEOUT_MS = 1e4;
 function remoteOfficialAppServerSocketPath(desktopControlSocketPath, token = randomUUID12()) {
-  if (!path18.posix.isAbsolute(desktopControlSocketPath)) {
+  if (!path19.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 path18.posix.join(path18.posix.dirname(desktopControlSocketPath), `.c-${compactToken}.sock`);
+  return path19.posix.join(path19.posix.dirname(desktopControlSocketPath), `.c-${compactToken}.sock`);
 }
 function errorMessage5(error51) {
   return error51 instanceof Error ? error51.message : String(error51);
@@ -33463,9 +33607,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 (!path19.isAbsolute(npmPackageRoot) || !path19.isAbsolute(hostRuntimePath)) return false;
-  const runtimePackageRoot = path19.dirname(path19.dirname(path19.normalize(hostRuntimePath)));
-  return path19.relative(path19.normalize(npmPackageRoot), runtimePackageRoot) === "";
+  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) === "";
 }
 function requiredRuntimeConfiguration(environment) {
   const stockCodexPath = environment[STOCK_CODEX_PATH_ENV];
@@ -33546,19 +33690,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({
@@ -33595,7 +33735,11 @@ async function runHostRuntime(input) {
           }
         });
         try {
-          officialEndpoint = await officialListener.listen();
+          await officialListeners.endpoint({
+            codexHome: path20.resolve(
+              delegationEnvironment.CODEX_HOME ?? path20.join(homedir(), ".codex")
+            )
+          });
           await listener.listen();
           await publishRemoteControlAppServerDescriptor(remoteControlPlan);
           return await host.run();
@@ -33604,7 +33748,7 @@ async function runHostRuntime(input) {
             await listener.close();
           } finally {
             try {
-              await officialListener.close();
+              await officialListeners.close();
             } finally {
               await mappingStore.close();
             }
@@ -33709,7 +33853,7 @@ import {
   stat as stat4,
   writeFile as writeFile5
 } from "node:fs/promises";
-import path20 from "node:path";
+import path21 from "node:path";
 var MANIFEST_FORMAT = 1;
 var WRAPPER_MARKER = "# codexhost remote SSH wrapper v1";
 var PROFILE_START = "# >>> codexhost remote SSH >>>";
@@ -33720,25 +33864,25 @@ function resolvePaths(options2) {
   if (!configuredHome) {
     throw new Error("A non-root HOME is required for remote Host installation");
   }
-  const home = path20.resolve(configuredHome);
-  if (!home || home === path20.parse(home).root) {
+  const home = path21.resolve(configuredHome);
+  if (!home || home === path21.parse(home).root) {
     throw new Error("A non-root HOME is required for remote Host installation");
   }
-  const installRoot = path20.resolve(options2.installRoot ?? path20.join(home, ".codexhost", "remote"));
-  const profilePath = path20.resolve(
-    options2.profilePath ?? path20.join(
+  const installRoot = path21.resolve(options2.installRoot ?? path21.join(home, ".codexhost", "remote"));
+  const profilePath = path21.resolve(
+    options2.profilePath ?? path21.join(
       home,
-      path20.basename(environment.SHELL ?? "") === "zsh" ? ".zshenv" : path20.basename(environment.SHELL ?? "") === "bash" ? ".bashrc" : ".profile"
+      path21.basename(environment.SHELL ?? "") === "zsh" ? ".zshenv" : path21.basename(environment.SHELL ?? "") === "bash" ? ".bashrc" : ".profile"
     )
   );
-  const binDirectory = path20.join(installRoot, "bin");
+  const binDirectory = path21.join(installRoot, "bin");
   return {
     home,
     installRoot,
     binDirectory,
-    wrapperPath: path20.join(binDirectory, "codex"),
-    manifestPath: path20.join(installRoot, "manifest.json"),
-    dataDirectory: path20.join(installRoot, "data"),
+    wrapperPath: path21.join(binDirectory, "codex"),
+    manifestPath: path21.join(installRoot, "manifest.json"),
+    dataDirectory: path21.join(installRoot, "data"),
     profilePath
   };
 }
@@ -33757,7 +33901,7 @@ async function fileSha256(filePath) {
   return createHash7("sha256").update(await readFile9(filePath)).digest("hex");
 }
 async function executable(filePath, label) {
-  const absolute = path20.resolve(filePath);
+  const absolute = path21.resolve(filePath);
   try {
     if (!(await stat4(absolute)).isFile()) throw new Error("not a regular file");
     await access(absolute, fsConstants.X_OK);
@@ -33767,7 +33911,7 @@ async function executable(filePath, label) {
   return absolute;
 }
 async function existingFile(filePath, label) {
-  const absolute = path20.resolve(filePath);
+  const absolute = path21.resolve(filePath);
   try {
     const metadata = await stat4(absolute);
     if (!metadata.isFile()) throw new Error("not a regular file");
@@ -33777,9 +33921,9 @@ async function existingFile(filePath, label) {
   return absolute;
 }
 async function discoverExecutable(name, environment) {
-  for (const directory of (environment.PATH ?? "").split(path20.delimiter)) {
+  for (const directory of (environment.PATH ?? "").split(path21.delimiter)) {
     if (!directory) continue;
-    const candidate = path20.resolve(directory, name);
+    const candidate = path21.resolve(directory, name);
     try {
       await access(candidate, fsConstants.X_OK);
       return candidate;
@@ -33790,10 +33934,10 @@ async function discoverExecutable(name, environment) {
   return null;
 }
 async function writeAtomic(filePath, contents, mode) {
-  await mkdir11(path20.dirname(filePath), { recursive: true, mode: 448 });
-  const temporary = path20.join(
-    path20.dirname(filePath),
-    `.${path20.basename(filePath)}.${process.pid}.${randomUUID13()}.tmp`
+  await mkdir11(path21.dirname(filePath), { recursive: true, mode: 448 });
+  const temporary = path21.join(
+    path21.dirname(filePath),
+    `.${path21.basename(filePath)}.${process.pid}.${randomUUID13()}.tmp`
   );
   try {
     if (typeof contents === "string") {
@@ -33814,10 +33958,10 @@ async function writeAtomic(filePath, contents, mode) {
   }
 }
 async function writeAtomicExecutable(filePath, sourcePath) {
-  await mkdir11(path20.dirname(filePath), { recursive: true, mode: 448 });
-  const temporary = path20.join(
-    path20.dirname(filePath),
-    `.${path20.basename(filePath)}.${process.pid}.${randomUUID13()}.tmp`
+  await mkdir11(path21.dirname(filePath), { recursive: true, mode: 448 });
+  const temporary = path21.join(
+    path21.dirname(filePath),
+    `.${path21.basename(filePath)}.${process.pid}.${randomUUID13()}.tmp`
   );
   try {
     await copyFile3(sourcePath, temporary);
@@ -33858,8 +34002,8 @@ function removeManagedProfileBlock(contents) {
 function installManagedProfileBlock(contents, manifest) {
   const base = removeManagedProfileBlock(contents);
   const environment = [
-    `export CODEX_INSTALL_DIR=${shellQuote(path20.dirname(manifest.wrapperPath))}`,
-    `export PATH=${shellQuote(path20.dirname(manifest.wrapperPath))}:${shellQuote(path20.dirname(manifest.nodePath))}:${shellQuote(path20.dirname(manifest.stockCodexPath))}:"\${PATH:-/usr/local/bin:/usr/bin:/bin}"`,
+    `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 CODEXHOST_STOCK_CODEX_PATH=${shellQuote(manifest.stockCodexPath)}`,
     `export CODEXHOST_HOST_NODE_PATH=${shellQuote(manifest.nodePath)}`,
     `export CODEXHOST_HOST_RUNTIME_PATH=${shellQuote(manifest.hostRuntimePath)}`,
@@ -33876,7 +34020,7 @@ function installManagedProfileBlock(contents, manifest) {
     PROFILE_END,
     ""
   ].join("\n");
-  if (path20.basename(manifest.profilePath) === ".bashrc") return `${block}${base}`;
+  if (path21.basename(manifest.profilePath) === ".bashrc") return `${block}${base}`;
   const separator = base.length > 0 && !base.endsWith("\n") ? "\n" : "";
   return `${base}${separator}${block}`;
 }
@@ -33941,9 +34085,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" || !path20.isAbsolute(manifest[key])
+    (key) => typeof manifest[key] !== "string" || !path21.isAbsolute(manifest[key])
   ) || optionalPaths.some(
-    (key) => manifest[key] !== void 0 && (typeof manifest[key] !== "string" || !path20.isAbsolute(manifest[key]))
+    (key) => manifest[key] !== void 0 && (typeof manifest[key] !== "string" || !path21.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");
   }
@@ -34172,7 +34316,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 path21 from "node:path";
+import path22 from "node:path";
 import { Duplex } from "node:stream";
 var CODEXHOST_STATUS_METHOD = "codexhost/update/status";
 var DIRECT_PROBE_TIMEOUT_MS = 5e3;
@@ -34191,9 +34335,9 @@ function classifyRemoteHostProbeResponse(response, socketPath) {
 }
 var lifecycleDependencyOverrides = {};
 function socketPathFor(environment) {
-  const codexHome = environment.CODEX_HOME ?? (environment.HOME ? path21.join(environment.HOME, ".codex") : void 0);
+  const codexHome = environment.CODEX_HOME ?? (environment.HOME ? path22.join(environment.HOME, ".codex") : void 0);
   if (!codexHome) throw new Error("CODEX_HOME or HOME is required for remote Host lifecycle");
-  return path21.join(codexHome, "app-server-control", "app-server-control.sock");
+  return path22.join(codexHome, "app-server-control", "app-server-control.sock");
 }
 async function defaultSocketExists(socketPath) {
   const metadata = await stat5(socketPath).catch((error51) => {
@@ -34320,7 +34464,7 @@ function installedManifest(status) {
 function managedEnvironment(manifest, environment) {
   return {
     ...environment,
-    CODEX_INSTALL_DIR: path21.dirname(manifest.wrapperPath),
+    CODEX_INSTALL_DIR: path22.dirname(manifest.wrapperPath),
     CODEXHOST_STOCK_CODEX_PATH: manifest.stockCodexPath,
     CODEXHOST_HOST_NODE_PATH: manifest.nodePath,
     CODEXHOST_HOST_RUNTIME_PATH: manifest.hostRuntimePath,
@@ -34328,7 +34472,7 @@ function managedEnvironment(manifest, environment) {
     CODEXHOST_DEFAULT_AGENT: "codex",
     CODEXHOST_REMOTE_SSH_MANAGED: "1",
     ...manifest.claudeCommand ? { CODEXHOST_CLAUDE_COMMAND: manifest.claudeCommand } : {},
-    PATH: `${path21.dirname(manifest.wrapperPath)}${path21.delimiter}${path21.dirname(manifest.stockCodexPath)}${path21.delimiter}${environment.PATH ?? "/usr/bin:/bin"}`
+    PATH: `${path22.dirname(manifest.wrapperPath)}${path22.delimiter}${path22.dirname(manifest.stockCodexPath)}${path22.delimiter}${environment.PATH ?? "/usr/bin:/bin"}`
   };
 }
 async function defaultRunTerminator(manifest, socketPath, role, environment) {
@@ -34667,19 +34811,19 @@ function consumeBrokerFrames(socket, onFrame, onError) {
 
 // packages/harness-broker/dist/paths.js
 import os5 from "node:os";
-import path22 from "node:path";
+import path23 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 path22.join(home, ".codexhost", "harness-broker");
+  return path23.join(home, ".codexhost", "harness-broker");
 }
 function defaultHarnessBrokerDescriptorPath(environment = process.env) {
-  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path22.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
+  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path23.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
 }
 function defaultHarnessBrokerSocketPath(environment = process.env) {
-  return path22.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_SOCKET_FILE);
+  return path23.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_SOCKET_FILE);
 }
 
 // packages/harness-broker/dist/validation.js
@@ -34694,6 +34838,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()
@@ -34706,6 +34852,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();
@@ -34879,7 +35028,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 readFile10, rename as rename9, rm as rm11 } from "node:fs/promises";
 import net4, {} from "node:net";
-import path23 from "node:path";
+import path24 from "node:path";
 function harnessError(message, retryable = true) {
   return { code: "unavailable", message, retryable, stage: "harnessBroker" };
 }
@@ -35004,13 +35153,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" && path23.dirname(input.descriptorPath) !== path23.dirname(input.socketPath)) {
+  if (process.platform !== "win32" && path24.dirname(input.descriptorPath) !== path24.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(path23.dirname(input.descriptorPath));
+  await privateDirectory(path24.dirname(input.descriptorPath));
   await assertNoLiveDescriptor(input.descriptorPath);
   if (process.platform !== "win32")
     await prepareUnixSocketPath(input.socketPath);