@codexhost/cli-darwin-x64 0.13.1 → 0.13.3

package/app/host-runtime.mjs

@@ -4295,9 +4295,11 @@ async function runDelegationCli(input) {
           "INVALID_ARGUMENT",
           "--host conflicts with the Thread reference"
         );
+      const caller = command === "read" ? callerThreadId(environment) : void 0;
       const body = {
         ...reference,
         ...hostId2 ? { hostId: hostId2 } : {},
+        ...caller ? { callerThreadId: normalizeThreadId(caller) } : {},
         view,
         ...value(parsed2, "--cursor") ? { cursor: value(parsed2, "--cursor") } : {},
         ...value(parsed2, "--limit") ? { limit: positiveInteger(value(parsed2, "--limit"), "--limit", MAX_LIMIT) } : {},
@@ -4434,6 +4436,7 @@ import {
   realpath,
   stat,
   readdir as readdir2,
+  unlink,
   writeFile as writeFile3
 } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -19943,6 +19946,7 @@ config(en_default());
 var REMOTE_THREAD_REPLY_MAX_BYTES = 16 * 1024 * 1024;
 var REMOTE_THREAD_CONTROL_TIMEOUT_MS = 4e4;
 var DELEGATION_READ_METHOD = "codexhost/thread/delegation-read";
+var THREAD_REFERENCE_SOURCE_HOST_PARAM = "codexhostSourceHostId";
 var delegationReadParamsSchema = external_exports.strictObject({
   threadId: external_exports.string().min(1).max(1024),
   view: external_exports.enum(["result", "messages"]),
@@ -20023,6 +20027,15 @@ var harnessDisplaySetSchema = external_exports.strictObject({
   initializeOnly: external_exports.boolean().optional()
 });
 
+// packages/shared-contracts/dist/harness-presentation.js
+var localeSchema = external_exports.string().max(64).regex(/^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/u);
+var displayText = (maximum) => external_exports.string().min(1).max(maximum).refine((text) => text.trim().length > 0);
+var harnessLocalizationsSchema = external_exports.record(localeSchema, external_exports.object({
+  label: displayText(256).optional(),
+  description: displayText(1024).optional()
+}).strict()).refine((entries) => Object.keys(entries).length <= 16, "Too many locales");
+var harnessLocalizedTextSchema = external_exports.record(localeSchema, displayText(4096)).refine((entries) => typeof entries.en === "string", "English fallback is required").refine((entries) => Object.keys(entries).length <= 16, "Too many locales");
+
 // packages/shared-contracts/dist/model-price-overrides.js
 var MODEL_PRICE_OVERRIDES_GET_METHOD = "codexhost/usage/model-prices/get";
 var MODEL_PRICE_OVERRIDES_SET_METHOD = "codexhost/usage/model-prices/set";
@@ -20372,8 +20385,24 @@ var threadUsageSnapshotSchema = external_exports.object({
   }
 });
 var usagePercentSchema = external_exports.number().finite().min(0).max(100);
+var accountCreditsPeriodSchema = external_exports.enum([
+  "weekly",
+  "monthly",
+  "five_hour",
+  "seven_day",
+  "unknown"
+]);
+var accountCreditsScopeSchema = external_exports.object({
+  id: external_exports.string().min(1).max(256),
+  label: external_exports.string().min(1).max(256),
+  localizations: harnessLocalizationsSchema.optional()
+}).strict();
 var accountCreditsProductUsageSchema = external_exports.object({
   product: external_exports.string().min(1),
+  /** Native period and scope, never inferred from the display name. */
+  periodType: accountCreditsPeriodSchema.optional(),
+  scope: accountCreditsScopeSchema.optional(),
+  localizations: harnessLocalizationsSchema.optional(),
   used: external_exports.number().finite().nonnegative().optional(),
   // Zero is a real empty cap, not an absent field.
   limit: external_exports.number().finite().nonnegative().optional(),
@@ -20393,9 +20422,11 @@ var accountCreditsSnapshotSchema = external_exports.object({
   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(),
+  scope: accountCreditsScopeSchema.optional(),
+  localizations: harnessLocalizationsSchema.optional(),
   usedPercent: usagePercentSchema,
   resetsAt: external_exports.string().min(1).optional(),
-  periodType: external_exports.enum(["weekly", "monthly", "five_hour", "seven_day", "unknown"]),
+  periodType: accountCreditsPeriodSchema,
   productUsage: external_exports.array(accountCreditsProductUsageSchema).min(1).optional(),
   resetCredits: accountResetCreditsSchema.optional()
 }).strict();
@@ -20406,7 +20437,9 @@ var threadUsageInspectionParamsSchema = external_exports.object({
 var threadUsageInspectionSchema = external_exports.object({
   threadId: hostThreadIdSchema,
   usage: threadUsageSnapshotSchema.nullable(),
-  accountCredits: accountCreditsSnapshotSchema.optional()
+  accountCredits: accountCreditsSnapshotSchema.optional(),
+  /** Whether this source can provide cached account quota independently of usage. */
+  accountCreditsSupported: external_exports.boolean().optional()
 }).strict();
 
 // packages/shared-contracts/dist/harness-accounts.js
@@ -20533,7 +20566,8 @@ var harnessPermissionModeSchema = external_exports.object({
   id: harnessPermissionModeIdSchema,
   label: nonBlankTextSchema.max(HARNESS_PERMISSION_MODE_LABEL_MAX_LENGTH),
   description: nonBlankTextSchema.max(HARNESS_PERMISSION_MODE_DESCRIPTION_MAX_LENGTH).optional(),
-  dangerous: external_exports.boolean().optional()
+  dangerous: external_exports.boolean().optional(),
+  localizations: harnessLocalizationsSchema.optional()
 }).strict();
 var harnessPermissionModeCatalogSchema = external_exports.object({
   modes: external_exports.array(harnessPermissionModeSchema).min(1).max(HARNESS_PERMISSION_MODE_CATALOG_MAX_LENGTH),
@@ -20957,6 +20991,8 @@ var harnessInstallationStateSchema = external_exports.object({
   // Adapter-owned diagnostic text; UI uses messageCode rather than displaying it verbatim.
   message: external_exports.string().max(2048).optional(),
   messageCode: external_exports.string().min(1).max(128).optional(),
+  /** Safe plugin-owned explanation, distinct from raw diagnostic message. */
+  notice: harnessLocalizedTextSchema.optional(),
   latestVersionKind: external_exports.enum(["unknown", "tracking-branch"]).optional()
 }).strict();
 
@@ -21087,6 +21123,7 @@ var harnessCommandDescriptorSchema = external_exports.object({
   invocation: commandInvocationSchema,
   label: commandLabelSchema,
   description: commandDescriptionSchema.optional(),
+  localizations: harnessLocalizationsSchema.optional(),
   argumentMode: external_exports.enum(["none", "text"]),
   /**
    * Native distinction reported by the Harness. Omitted when the Harness does
@@ -21467,14 +21504,40 @@ var RuntimeMaintenance = class {
       options2.environment.CODEXHOST_DATA_DIR ?? path7.join(home, ".codexhost", "remote", "data"),
       "remote-update.json"
     );
+    this.#cancelPath = path7.join(path7.dirname(this.#statusPath), "remote-update.cancel");
   }
   options;
   #running;
   #statusPath;
+  #cancelPath;
   #update = { phase: "idle", targetVersion: null, error: null };
   #blocked = false;
+  #watch = null;
   #starting = null;
   #startingVersion = null;
+  get #startTimeoutMs() {
+    return this.options.updaterStartTimeoutMs ?? UPDATER_START_TIMEOUT_MS;
+  }
+  #ensureWatching() {
+    if (this.#watch) return;
+    this.#watch = setInterval(() => {
+      void this.status().catch(() => void 0).then(() => {
+        if (!this.#blocked && this.#watch) {
+          clearInterval(this.#watch);
+          this.#watch = null;
+        }
+      });
+    }, UPDATER_WATCH_INTERVAL_MS);
+    this.#watch.unref();
+  }
+  async #recordStartFailure(version2, failure) {
+    await writeFile3(this.#cancelPath, JSON.stringify({ targetVersion: version2 }), { mode: 384 });
+    await writeFile3(
+      this.#statusPath,
+      JSON.stringify({ phase: "failed", targetVersion: version2, error: failure }),
+      { mode: 384 }
+    );
+  }
   #sshPending = /* @__PURE__ */ new Set();
   async setupSsh(input) {
     if (this.options.remote) throw new Error("SSH installation must run from the local computer");
@@ -21535,7 +21598,7 @@ var RuntimeMaintenance = class {
       installation(this.options.runtimePath, this.options.environment),
       this.#resources()
     ]);
-    if (this.#update.phase === "idle" || this.#blocked) {
+    if (this.#update.phase === "idle" || this.#blocked || this.#update.phase === "failed") {
       try {
         const value2 = JSON.parse(await readFile5(this.#statusPath, "utf8"));
         const parsed2 = runtimeStatusSchema.shape.update.parse(value2);
@@ -21551,15 +21614,22 @@ var RuntimeMaintenance = class {
             }
           } else {
             const written = (await stat(this.#statusPath)).mtimeMs;
-            alive = Date.now() - written < UPDATER_START_TIMEOUT_MS * 2;
+            alive = Date.now() - written < this.#startTimeoutMs * 2;
           }
           if (!alive) {
             parsed2.phase = "failed";
             parsed2.error = "The previous remote update was interrupted; retry the update";
           }
         }
-        if (this.#update === observedUpdate) this.#update = parsed2;
-        if (["failed", "succeeded"].includes(this.#update.phase)) this.#blocked = false;
+        if (this.#update === observedUpdate) {
+          this.#update = parsed2;
+          if (["installing", "restarting"].includes(this.#update.phase)) {
+            this.#blocked = true;
+            this.#ensureWatching();
+          } else if (["failed", "succeeded"].includes(this.#update.phase)) {
+            this.#blocked = false;
+          }
+        }
       } catch {
       }
     }
@@ -21631,6 +21701,7 @@ var RuntimeMaintenance = class {
     await chmod2(helper, 448);
     const request = path7.join(work, "request.json");
     this.#update = { phase: "installing", targetVersion: version2, error: null };
+    await unlink(this.#cancelPath).catch(() => void 0);
     await writeFile3(this.#statusPath, JSON.stringify(this.#update), { mode: 384 });
     await writeFile3(
       request,
@@ -21649,35 +21720,38 @@ var RuntimeMaintenance = class {
     );
     const starter = spawn3(
       "/bin/sh",
-      ["-c", '"$0" remote --request "$1" </dev/null >/dev/null 2>&1 &', helper, request],
-      { detached: true, stdio: "ignore", env: this.options.environment }
+      ["-c", '"$0" remote --request "$1" </dev/null >/dev/null 2>&1 & echo $!', helper, request],
+      { detached: true, stdio: ["ignore", "pipe", "ignore"], env: this.options.environment }
     );
+    let pidOutput = "";
+    starter.stdout?.on("data", (chunk) => {
+      pidOutput += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    });
     await new Promise((resolve, reject) => {
       starter.once("error", reject);
       starter.once(
-        "exit",
+        "close",
         (code) => code === 0 ? resolve() : reject(new Error("Remote updater could not be started"))
       );
     });
-    const deadline = Date.now() + UPDATER_START_TIMEOUT_MS;
+    const helperPid = Number.parseInt(pidOutput.trim(), 10);
+    if (!Number.isSafeInteger(helperPid) || helperPid <= 0) {
+      throw new Error("Remote updater could not be started");
+    }
+    const deadline = Date.now() + this.#startTimeoutMs;
     while (!await this.#helperReported()) {
       if (Date.now() >= deadline) {
+        try {
+          process.kill(helperPid);
+        } catch {
+        }
         const failure = "Remote updater did not start";
-        await writeFile3(
-          this.#statusPath,
-          JSON.stringify({ phase: "failed", targetVersion: version2, error: failure }),
-          { mode: 384 }
-        );
+        await this.#recordStartFailure(version2, failure);
         throw new Error(failure);
       }
       await new Promise((resolve) => setTimeout(resolve, 50));
     }
-    const watch = setInterval(() => {
-      void this.status().catch(() => void 0).then(() => {
-        if (!this.#blocked) clearInterval(watch);
-      });
-    }, UPDATER_WATCH_INTERVAL_MS);
-    watch.unref();
+    this.#ensureWatching();
   }
   async #helperReported() {
     try {
@@ -21691,6 +21765,7 @@ var RuntimeMaintenance = class {
 
 // packages/host-runtime/src/run-host-runtime.ts
 import { randomBytes as randomBytes4 } from "node:crypto";
+import { statSync } from "node:fs";
 import path37 from "node:path";
 import { homedir as homedir4 } from "node:os";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
@@ -24964,6 +25039,16 @@ function rewriteDelegationMentionInput(input, skill) {
   return rewritten;
 }
 
+// packages/harness-adapter/dist/account-credits.js
+function parseHarnessAccountCredits(value2) {
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2))
+    return null;
+  const publicValue = { ...value2 };
+  delete publicValue.fetchedAt;
+  const parsed2 = accountCreditsSnapshotSchema.safeParse(publicValue);
+  return parsed2.success ? parsed2.data : null;
+}
+
 // packages/harness-adapter/dist/output-channel.js
 var HarnessOutputChannel = class {
   outputs;
@@ -27063,6 +27148,7 @@ function projectCodexRateLimitsToCredits(usage, resetCredits) {
   const resetsAtUnix = hasFiveHour ? usage.planFiveHourResetsAtUnix : usage.planSevenDayResetsAtUnix;
   const secondary = hasFiveHour && hasSevenDay && usage.planSevenDayUsedPercent !== void 0 ? {
     product: "7-day window",
+    periodType: "seven_day",
     usagePercent: usage.planSevenDayUsedPercent,
     ...usage.planSevenDayResetsAtUnix !== void 0 ? { resetsAt: isoFromUnix(usage.planSevenDayResetsAtUnix) } : {}
   } : void 0;
@@ -31745,6 +31831,16 @@ var ExternalThreadIdleRelease = class {
     const state = this.#activity.get(thread);
     if (state) state.outputFailed = true;
   }
+  /** After a successful Session revival, allow idle release again. */
+  clearOutputFailed(thread) {
+    const state = this.#activity.get(thread);
+    if (state) {
+      state.outputFailed = false;
+      state.lastActivity = Date.now();
+    } else {
+      this.touch(thread);
+    }
+  }
   failure(thread) {
     return this.#activity.get(thread)?.closeFailed ? CLOSE_FAILURE : void 0;
   }
@@ -31893,6 +31989,80 @@ var ExternalThreadIdleRelease = class {
   }
 };
 
+// packages/host-runtime/src/external-thread-lifecycle.ts
+var RELEASE_TIMEOUT_MS = 6e4;
+var ExternalSessionReleaseError = class extends Error {
+  constructor(cause) {
+    super(
+      "External Session shutdown could not be confirmed. Retry to confirm release; recovery is blocked until the old Session closes and its output drains. If the Harness cannot retry shutdown, stop residual processes and restart Codex Desktop.",
+      { cause }
+    );
+    this.name = "ExternalSessionReleaseError";
+  }
+};
+var ExternalThreadLifecycle = class {
+  #pending = /* @__PURE__ */ new Map();
+  #closing = /* @__PURE__ */ new WeakMap();
+  #releasing = /* @__PURE__ */ new Map();
+  busy(id2) {
+    return this.#pending.has(id2) || this.#releasing.has(id2);
+  }
+  pending() {
+    return [...this.#pending];
+  }
+  run(id2, operation) {
+    const previous = this.#pending.get(id2) ?? Promise.resolve();
+    const task = previous.then(async () => {
+      const releasing = this.#releasing.get(id2);
+      if (releasing) await this.release(id2, releasing.session, releasing.output);
+      return operation();
+    });
+    const settled = task.then(
+      () => void 0,
+      () => void 0
+    );
+    this.#pending.set(id2, settled);
+    void settled.then(() => {
+      if (this.#pending.get(id2) === settled) this.#pending.delete(id2);
+    });
+    return task;
+  }
+  /** Call inside the Thread's lifecycle operation. A timeout never cancels the owned close. */
+  async release(id2, session, output) {
+    this.#releasing.set(id2, { session, output });
+    let closing = this.#closing.get(session);
+    if (!closing) {
+      closing = Promise.resolve().then(() => session.close());
+      this.#closing.set(session, closing);
+      const attempt = closing;
+      void closing.catch(() => {
+        if (this.#closing.get(session) === attempt) this.#closing.delete(session);
+      });
+    }
+    let timeout;
+    try {
+      await Promise.race([
+        closing.then(() => output),
+        new Promise((_, reject) => {
+          timeout = setTimeout(
+            () => reject(new Error("Session shutdown timed out")),
+            RELEASE_TIMEOUT_MS
+          );
+          timeout.unref();
+        })
+      ]);
+      this.#releasing.delete(id2);
+    } catch (error51) {
+      throw new ExternalSessionReleaseError(error51);
+    } finally {
+      if (timeout) clearTimeout(timeout);
+    }
+  }
+  async drain() {
+    while (this.#pending.size) await Promise.all(this.#pending.values());
+  }
+};
+
 // packages/host-runtime/src/usage-metering.ts
 var TOKENS_PER_PRICE_UNIT = 1e6;
 var UsageMeter = class {
@@ -32175,6 +32345,11 @@ var ExternalThreadOpenError = class extends Error {
 function errorMessage3(error51) {
   return error51 instanceof Error ? error51.message : String(error51);
 }
+function recoveryError(error51) {
+  if (error51 instanceof ExternalThreadOpenError) return error51.rpcError;
+  if (error51 instanceof ExternalSessionReleaseError) return { code: -32075, message: error51.message };
+  return { code: -32076, message: "External Thread recovery failed; retry the request" };
+}
 var ExternalThreadRuntime = class {
   idleRelease;
   #adapters;
@@ -32182,7 +32357,8 @@ var ExternalThreadRuntime = class {
   #diagnose;
   #environment;
   #repository;
-  #restores = /* @__PURE__ */ new Map();
+  #lifecycle = new ExternalThreadLifecycle();
+  #hasRunningDescendants;
   #subagentRunning;
   #threads = /* @__PURE__ */ new Map();
   constructor(input) {
@@ -32192,12 +32368,13 @@ var ExternalThreadRuntime = class {
     this.#consumeOutputs = input.consumeOutputs;
     this.#diagnose = input.diagnose;
     this.#subagentRunning = input.subagentRunning ?? (() => false);
+    this.#hasRunningDescendants = input.hasRunningDescendants ?? (() => false);
     this.idleRelease = new ExternalThreadIdleRelease({
       threads: () => this.values(),
       get: (id2) => this.get(id2),
       remove: (id2) => this.remove(id2),
       queue: input.idleRelease?.queue ?? new DesktopRequestQueue(),
-      canRelease: input.idleRelease?.canRelease ?? (() => false),
+      canRelease: (thread) => !thread.sessionUnavailable && !this.#lifecycle.busy(thread.id) && (input.idleRelease?.canRelease(thread) ?? false),
       ...input.idleRelease?.onClosed ? { onClosed: input.idleRelease.onClosed } : {},
       diagnose: input.diagnose
     });
@@ -32213,7 +32390,45 @@ var ExternalThreadRuntime = class {
   }
   clear() {
     this.#threads.clear();
-    this.#restores.clear();
+  }
+  drain() {
+    return this.#lifecycle.drain();
+  }
+  #withLifecycle(threadId2, operation) {
+    return this.#lifecycle.run(threadId2, async () => {
+      await this.idleRelease.waitForClose(threadId2);
+      return operation();
+    });
+  }
+  markSessionUnavailable(thread) {
+    thread.sessionUnavailable = true;
+  }
+  #idleForRestore(thread) {
+    if (thread.running || thread.activeTurnId !== null) return false;
+    if (thread.session.hasBackgroundWork?.()) return false;
+    if (this.#hasRunningDescendants(thread.id)) return false;
+    return true;
+  }
+  async #dropIdleSession(thread) {
+    if (this.#threads.get(thread.id) !== thread) return;
+    thread.sessionUnavailable = true;
+    await this.#lifecycle.release(thread.id, thread.session, thread.outputTask);
+    if (this.#threads.get(thread.id) !== thread) return;
+    await this.#retireSubagents(thread);
+    if (this.#threads.get(thread.id) === thread) this.#threads.delete(thread.id);
+  }
+  /** Called without awaiting from the output consumer: release itself drains that consumer. */
+  async discardUnavailableIdle(thread) {
+    const session = thread.session;
+    try {
+      await this.#withLifecycle(thread.id, async () => {
+        if (this.#threads.get(thread.id) !== thread || thread.session !== session || !thread.sessionUnavailable || !this.#idleForRestore(thread))
+          return;
+        await this.#dropIdleSession(thread);
+      });
+    } catch (error51) {
+      this.#diagnose(error51);
+    }
   }
   register(input) {
     const harnessId = input.record.harnessId;
@@ -32258,7 +32473,8 @@ var ExternalThreadRuntime = class {
       ephemeralTurnIds: /* @__PURE__ */ new Set(),
       persistenceError: null,
       projectedTerminalTurnId: null,
-      ignoredInteractionIds: /* @__PURE__ */ new Set()
+      ignoredInteractionIds: /* @__PURE__ */ new Set(),
+      sessionUnavailable: false
     };
     this.idleRelease.touch(externalThread);
     externalThread.outputTask = this.#consumeOutputs(externalThread);
@@ -32285,11 +32501,12 @@ var ExternalThreadRuntime = class {
     } catch (error51) {
       this.#diagnose(error51);
     }
-    await this.#retireSubagents(current.id);
+    await this.#retireSubagents(current, true);
     this.#threads.delete(current.id);
     return this.register(input);
   }
-  async #retireSubagents(parentId) {
+  async #retireSubagents(parent, bestEffort = false) {
+    const parentId = parent.id;
     const ancestors = /* @__PURE__ */ new Map();
     const descendant = async (record4) => {
       const visited = /* @__PURE__ */ new Set();
@@ -32306,24 +32523,35 @@ var ExternalThreadRuntime = class {
       }
       return false;
     };
-    for (const [id2, restoring] of [...this.#restores]) {
-      if (await descendant(await this.#repository.find(id2))) {
-        await restoring.catch(this.#diagnose);
-      }
+    for (const [id2, pending] of this.#lifecycle.pending()) {
+      if (id2 !== parentId && await descendant(await this.#repository.find(id2))) await pending;
     }
-    for (const child of this.#threads.values()) {
+    for (const child of [...this.#threads.values()]) {
       if (!await descendant(child.record)) continue;
-      this.#threads.delete(child.id);
-      try {
-        await child.session.close();
-        await child.outputTask;
-      } catch (error51) {
-        this.#diagnose(error51);
-      }
+      const retire = async () => {
+        if (this.#threads.get(parentId) !== parent || this.#threads.get(child.id) !== child) return;
+        if (bestEffort) {
+          this.#threads.delete(child.id);
+          await child.session.close();
+          await child.outputTask;
+        } else {
+          child.sessionUnavailable = true;
+          await this.#lifecycle.release(child.id, child.session, child.outputTask);
+          if (this.#threads.get(child.id) === child) this.#threads.delete(child.id);
+        }
+      };
+      if (bestEffort) await retire().catch(this.#diagnose);
+      else await this.#withLifecycle(child.id, retire);
     }
   }
   async locate(threadId2) {
-    await this.idleRelease.waitForClose(threadId2);
+    try {
+      return await this.#withLifecycle(threadId2, () => this.#locate(threadId2));
+    } catch (error51) {
+      return { kind: "error", error: recoveryError(error51) };
+    }
+  }
+  async #locate(threadId2) {
     const loaded = this.#threads.get(threadId2);
     if (loaded) {
       const failure = this.idleRelease.failure(loaded);
@@ -32349,37 +32577,61 @@ var ExternalThreadRuntime = class {
     return { kind: "external", record: record4, thread: null };
   }
   async resolve(threadId2) {
-    const location = await this.locate(threadId2);
-    if (location.kind !== "external") return location;
-    if (location.thread) {
-      this.idleRelease.touch(location.thread);
-      return { kind: "external", thread: location.thread, historyFresh: false };
-    }
-    const { record: record4 } = location;
-    let restoring = this.#restores.get(threadId2);
-    if (!restoring) {
-      const restored = this.#threads.get(threadId2);
-      if (restored) {
-        this.idleRelease.touch(restored);
-        return { kind: "external", thread: restored, historyFresh: false };
-      }
-      restoring = this.#restore(record4).finally(() => {
-        this.#restores.delete(threadId2);
+    try {
+      return await this.#withLifecycle(threadId2, async () => {
+        const location = await this.#locate(threadId2);
+        if (location.kind !== "external") return location;
+        if (location.thread) {
+          if (location.thread.sessionUnavailable && this.#idleForRestore(location.thread)) {
+            await this.#dropIdleSession(location.thread);
+            const current = this.#threads.get(threadId2);
+            if (current) return { kind: "external", thread: current, historyFresh: false };
+          } else {
+            this.idleRelease.touch(location.thread);
+            return { kind: "external", thread: location.thread, historyFresh: false };
+          }
+        }
+        return {
+          kind: "external",
+          thread: await this.#restore(location.record),
+          historyFresh: true
+        };
       });
-      this.#restores.set(threadId2, restoring);
+    } catch (error51) {
+      return { kind: "error", error: recoveryError(error51) };
     }
+  }
+  async refresh(thread) {
     try {
-      return { kind: "external", thread: await restoring, historyFresh: true };
+      return await this.#withLifecycle(thread.id, () => this.#refresh(thread));
     } catch (error51) {
+      return recoveryError(error51);
+    }
+  }
+  async #refresh(thread) {
+    if (this.#threads.get(thread.id) !== thread) {
       return {
-        kind: "error",
-        error: error51 instanceof ExternalThreadOpenError ? error51.rpcError : { code: -32076, message: "External Thread recovery failed" }
+        code: -32076,
+        message: "External Session changed during recovery; retry the request"
       };
     }
-  }
-  async refresh(thread) {
-    const snapshot2 = await thread.session.readSnapshot();
-    if (!snapshot2.ok) return mapExternalThreadHarnessError(snapshot2.error, "read");
+    const failure = this.idleRelease.failure(thread);
+    if (failure) return { code: -32075, message: failure };
+    if (thread.sessionUnavailable && this.#idleForRestore(thread)) {
+      const revived = await this.#reviveIdleSession(thread);
+      if (revived) return revived;
+    }
+    let snapshot2 = await thread.session.readSnapshot();
+    if (!snapshot2.ok) {
+      if (snapshot2.error.code === "invalidState" && this.#idleForRestore(thread) && this.#threads.get(thread.id) === thread) {
+        const revived = await this.#reviveIdleSession(thread);
+        if (revived) return revived;
+        snapshot2 = await thread.session.readSnapshot();
+        if (!snapshot2.ok) return mapExternalThreadHarnessError(snapshot2.error, "read");
+      } else {
+        return mapExternalThreadHarnessError(snapshot2.error, "read");
+      }
+    }
     try {
       const aligned = await this.#repository.alignSnapshot(thread.record, snapshot2.value);
       thread.record = aligned.record;
@@ -32396,6 +32648,122 @@ var ExternalThreadRuntime = class {
       return { code: -32081, message: "External Thread history could not be persisted" };
     }
   }
+  async #reviveIdleSession(thread) {
+    thread.sessionUnavailable = true;
+    const harnessId = thread.record.harnessId;
+    const adapter = this.#adapters.get(harnessId);
+    if (!adapter || !thread.record.nativeSessionRef) {
+      await this.#dropIdleSession(thread);
+      return { code: -32077, message: "External Harness is unavailable" };
+    }
+    await this.#lifecycle.release(thread.id, thread.session, thread.outputTask);
+    await this.#retireSubagents(thread);
+    if (this.#threads.get(thread.id) !== thread) {
+      return { code: -32076, message: "External Thread recovery failed" };
+    }
+    const restoredSelection = decodeExternalTransportSelection(
+      harnessId,
+      thread.record.transportModelId
+    );
+    const opened = await adapter.open({
+      kind: "resume",
+      cwd: thread.record.cwd,
+      environment: { ...this.#environment, [DELEGATION_THREAD_ID_ENV]: thread.record.hostThreadId },
+      nativeRef: thread.record.nativeSessionRef,
+      knownTurnRefs: thread.record.turnMappings.map(({ nativeTurnRef }) => nativeTurnRef),
+      ...restoredSelection?.model ? { model: restoredSelection.model } : {},
+      ...restoredSelection?.thinkingOptionId ? { thinkingOptionId: restoredSelection.thinkingOptionId } : {},
+      ...restoredSelection?.permissionModeId ? { permissionModeId: restoredSelection.permissionModeId } : {}
+    });
+    if (!opened.ok) {
+      await this.#dropIdleSession(thread);
+      return mapExternalThreadHarnessError(opened.error, "resume");
+    }
+    const session = opened.value;
+    if (this.#threads.get(thread.id) !== thread) {
+      await this.#lifecycle.release(thread.id, session, Promise.resolve());
+      return { code: -32076, message: "External Thread recovery failed" };
+    }
+    try {
+      const snapshot2 = await session.readSnapshot();
+      if (!snapshot2.ok) {
+        await this.#lifecycle.release(thread.id, session, Promise.resolve());
+        await this.#dropIdleSession(thread);
+        return mapExternalThreadHarnessError(snapshot2.error, "read");
+      }
+      let aligned = await this.#repository.alignSnapshot(thread.record, snapshot2.value);
+      if (this.#threads.get(thread.id) !== thread) {
+        await this.#lifecycle.release(thread.id, session, Promise.resolve());
+        return { code: -32076, message: "External Thread recovery failed" };
+      }
+      const restoredState = snapshot2.value.state;
+      const effectiveModel = restoredState ? restoredState.effectiveModel : restoredSelection?.model;
+      const effectiveThinkingOptionId = restoredState ? restoredState.effectiveThinkingOptionId : restoredSelection?.thinkingOptionId;
+      const effectivePermissionModeId = restoredState ? restoredState.effectivePermissionModeId : restoredSelection?.permissionModeId;
+      let transportModelId = aligned.record.transportModelId;
+      if (restoredState && effectiveModel) {
+        const liveSelection = {
+          model: effectiveModel,
+          ...effectiveThinkingOptionId ? { thinkingOptionId: effectiveThinkingOptionId } : {},
+          ...effectivePermissionModeId ? { permissionModeId: effectivePermissionModeId } : {}
+        };
+        transportModelId = encodeExternalTransportSelection(harnessId, liveSelection);
+        if (transportModelId !== aligned.record.transportModelId) {
+          try {
+            aligned = {
+              ...aligned,
+              record: await this.#repository.setTransportModelId(
+                aligned.record.hostThreadId,
+                transportModelId
+              )
+            };
+          } catch (error51) {
+            this.#diagnose(error51);
+          }
+        }
+      }
+      if (this.#threads.get(thread.id) !== thread) {
+        await this.#lifecycle.release(thread.id, session, Promise.resolve());
+        return { code: -32076, message: "External Thread recovery failed" };
+      }
+      const initialState = restoredState ?? session.initialState;
+      const observerState = {
+        ...initialState,
+        ...effectiveModel ? { effectiveModel } : {},
+        ...effectiveThinkingOptionId ? { effectiveThinkingOptionId } : {},
+        ...effectivePermissionModeId ? { effectivePermissionModeId } : {}
+      };
+      thread.session = session;
+      thread.record = aligned.record;
+      thread.turns = aligned.turns;
+      thread.historyHydrated = true;
+      thread.sessionUnavailable = false;
+      thread.persistenceError = null;
+      thread.transportModelId = transportModelId;
+      if (effectiveModel) thread.requestedModel = effectiveModel;
+      if (effectiveThinkingOptionId) thread.requestedThinkingOptionId = effectiveThinkingOptionId;
+      if (effectivePermissionModeId) thread.requestedPermissionModeId = effectivePermissionModeId;
+      thread.stateObserver = new SessionStateObserver(observerState);
+      thread.latestUsage = session.initialUsage;
+      thread.usageMeter = new UsageMeter();
+      thread.usageTurnId = null;
+      thread.thread = externalThreadValue({
+        record: aligned.record,
+        turns: aligned.turns,
+        sessionId: thread.sessionId,
+        running: thread.running
+      });
+      thread.outputTask = this.#consumeOutputs(thread);
+      this.idleRelease.clearOutputFailed(thread);
+      return null;
+    } catch (error51) {
+      if (error51 instanceof ExternalSessionReleaseError) throw error51;
+      await this.#lifecycle.release(thread.id, session, Promise.resolve());
+      this.#diagnose(error51);
+      await this.#dropIdleSession(thread);
+      return { code: -32081, message: "External Thread history could not be persisted" };
+    }
+  }
   async persistTerminalIdentity(thread, event) {
     if (thread.persistenceError) return thread.persistenceError;
     if (!event.nativeTurnRef) {
@@ -32534,7 +32902,8 @@ var ExternalThreadRuntime = class {
         transportModelId
       });
     } catch (error51) {
-      await session.close().catch(() => void 0);
+      if (error51 instanceof ExternalSessionReleaseError) throw error51;
+      await this.#lifecycle.release(record4.hostThreadId, session, Promise.resolve());
       throw error51;
     }
   }
@@ -35467,7 +35836,9 @@ function hasValidSessionUsage(value2) {
 }
 function isAdapter(value2) {
   if (!value2 || typeof value2 !== "object") return false;
-  return hasValidSessionUsage(value2) && ["inspect", "open", "close"].every((key) => typeof Reflect.get(value2, key) === "function");
+  return hasValidSessionUsage(value2) && ["inspect", "open", "close"].every((key) => typeof Reflect.get(value2, key) === "function") && ["credits", "refreshCredits"].every(
+    (key) => Reflect.get(value2, key) === void 0 || typeof Reflect.get(value2, key) === "function"
+  );
 }
 function isUsageAdapter(value2) {
   if (!value2 || typeof value2 !== "object" || typeof Reflect.get(value2, "close") !== "function")
@@ -37335,6 +37706,16 @@ async function moveThreadSection(input) {
   }
 }
 
+// packages/host-runtime/src/external-thread-official-defaults.ts
+var EMPTY_RESULTS = /* @__PURE__ */ new Map([
+  ["thread/attachment/list", () => ({ data: [], nextCursor: null })],
+  ["thread/queue/list", () => ({ data: [], nextCursor: null })],
+  ["thread/settings/update", () => ({})]
+]);
+function externalThreadEmptyOfficialResult(method) {
+  return EMPTY_RESULTS.get(method)?.();
+}
+
 // packages/host-runtime/src/observed-session-usage.ts
 var ObservedSessionUsage = class {
   constructor(providers, prices, diagnose) {
@@ -37503,16 +37884,6 @@ function officialThreadBusy(thread) {
   const latestTurn = turns.at(-1);
   return isRecord18(latestTurn) && (latestTurn.status === "inProgress" || latestTurn.status === "running");
 }
-function isCreditsAdapter(adapter) {
-  return typeof adapter.credits === "function";
-}
-function projectAccountCredits(value2) {
-  if (!isRecord18(value2)) return null;
-  const rest = { ...value2 };
-  delete rest.fetchedAt;
-  const parsed2 = accountCreditsSnapshotSchema.safeParse(rest);
-  return parsed2.success ? parsed2.data : null;
-}
 function errorMessage4(error51) {
   return error51 instanceof Error ? error51.message : String(error51);
 }
@@ -37684,6 +38055,7 @@ var AppServerHost = class {
   #launchSettings;
   #accountInspections = new HarnessAccountInspectionCache();
   #externalRuntime;
+  #executionHosts = /* @__PURE__ */ new WeakMap();
   #externalPrewarms = new ExternalThreadPrewarms();
   #externalSteering = new ExternalTurnSteering();
   #liveCommandCache = new LiveCommandCatalogCache();
@@ -37818,6 +38190,7 @@ var AppServerHost = class {
       consumeOutputs: (thread) => this.#consumeHarnessOutputs(thread),
       diagnose: (error51) => this.#diagnose(error51),
       subagentRunning: (threadId2) => this.#subagentThreadStatuses.get(threadId2) === "active",
+      hasRunningDescendants: (threadId2) => this.#hasRunningSubagents(threadId2),
       idleRelease: {
         queue: this.#desktopRequests,
         onClosed: async (thread) => {
@@ -37876,7 +38249,11 @@ var AppServerHost = class {
       wait: (input) => this.#waitForPlugins().then(() => this.#delegationCoordinator.wait(input)),
       list: (input) => this.#waitForPlugins().then(() => this.#delegationCoordinator.list(input)),
       canHandleStart: (input) => this.#canHandleDelegationStart(input),
-      ownsThread: (threadId2) => this.#ownsDelegationThread(threadId2)
+      ownsThread: (threadId2) => this.#ownsDelegationThread(threadId2),
+      executionHostId: (threadId2) => {
+        const thread = this.#externalRuntime.get(threadId2);
+        return thread ? this.#executionHosts.get(thread) : void 0;
+      }
     });
     this.#unregisterDelegationApi = typeof unregisterDelegationApi === "function" ? unregisterDelegationApi : void 0;
   }
@@ -38013,6 +38390,7 @@ var AppServerHost = class {
       await Promise.allSettled(threads.map(({ session }) => session.close()));
       await Promise.allSettled(threads.map(({ outputTask }) => outputTask));
       await this.#closeAdapters();
+      await this.#externalRuntime.drain();
       for (const pending of [...this.#pendingDesktopApprovals.values()]) {
         await this.#resolveDesktopApproval(pending.interaction.interactionId).catch(
           () => void 0
@@ -38942,8 +39320,9 @@ var AppServerHost = class {
       const location = await this.#locateExternalThread(request.params.threadId);
       if (await this.#writeResolutionError(request, location)) return;
       if (location.kind === "external") {
+        const emptyResult = externalThreadEmptyOfficialResult(request.method);
         await this.#writer.json(
-          rpcError(request, -32076, `External Thread does not support ${request.method}`)
+          emptyResult ? rpcEnvelope(request, { result: emptyResult }) : rpcError(request, -32076, `External Thread does not support ${request.method}`)
         );
         return;
       }
@@ -39999,6 +40378,7 @@ var AppServerHost = class {
       const result2 = threadUsageInspectionSchema.parse({
         threadId: params.data.threadId,
         usage: await this.#observedSessionUsage.read(params.data.threadId),
+        accountCreditsSupported: true,
         ...accountCredits ? { accountCredits } : {}
       });
       await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(result2) }));
@@ -40006,11 +40386,17 @@ var AppServerHost = class {
     }
     if (params.data.refresh === "exact") void resolution.thread.session.refreshUsage?.();
     const adapter = this.#externalAdapters.get(resolution.thread.harnessId);
-    if (adapter && isCreditsAdapter(adapter)) void adapter.refreshCredits?.();
-    const credits = adapter && isCreditsAdapter(adapter) ? projectAccountCredits(adapter.credits()) : null;
+    if (adapter?.credits && adapter.refreshCredits)
+      void Promise.resolve().then(() => adapter.refreshCredits?.()).catch(() => void 0);
+    let credits = null;
+    try {
+      credits = parseHarnessAccountCredits(adapter?.credits?.());
+    } catch {
+    }
     const result = threadUsageInspectionSchema.parse({
       threadId: params.data.threadId,
       usage: await this.#threadUsage(resolution.thread),
+      accountCreditsSupported: typeof adapter?.credits === "function",
       ...credits ? { accountCredits: credits } : {}
     });
     await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(result) }));
@@ -40206,7 +40592,7 @@ var AppServerHost = class {
       this.#pendingExternalCommandRequests.delete(thread.id);
     }
   }
-  async #beginExternalCommand(thread, descriptor, arguments_2, requestedTurnId) {
+  async #beginExternalCommand(thread, descriptor, arguments_2, requestedTurnId, sourceHostId) {
     const commands = thread.session.commands;
     if (!commands) {
       throw new ExternalCommandError(-32078, "External Harness does not expose commands");
@@ -40235,6 +40621,7 @@ var AppServerHost = class {
     thread.ephemeralTurnIds.add(turnId);
     if (descriptor.invocation === "/compact") this.#manualCompactionTurns.set(thread, turnId);
     else this.#manualCompactionTurns.delete(thread);
+    const restoreExecutionHost = this.#setExecutionHost(thread, sourceHostId);
     try {
       if (thread.unsubmittedPrewarm && await this.#externalRuntime.submitPrewarm(thread)) {
         await this.#notifyExternalThreadStarted(thread.thread);
@@ -40247,6 +40634,7 @@ var AppServerHost = class {
       if (!result.ok) throw new ExternalCommandError(-32073, result.error.message);
       return { turnId: result.value.turnId, turn: projection.projector.pendingTurn(), gate };
     } catch (error51) {
+      restoreExecutionHost();
       thread.running = false;
       thread.activeTurnId = null;
       thread.projectedTurns.delete(turnId);
@@ -41026,7 +41414,8 @@ var AppServerHost = class {
         thread,
         text,
         void 0,
-        typeof params.clientUserMessageId === "string" ? params.clientUserMessageId : void 0
+        typeof params.clientUserMessageId === "string" ? params.clientUserMessageId : void 0,
+        params[THREAD_REFERENCE_SOURCE_HOST_PARAM]
       );
       try {
         await this.#writer.json(rpcEnvelope(request, { result: { turn: started.turn } }));
@@ -41052,7 +41441,8 @@ var AppServerHost = class {
           thread,
           text,
           assertActive,
-          typeof requestObject(request).clientUserMessageId === "string" ? requestObject(request).clientUserMessageId : void 0
+          typeof requestObject(request).clientUserMessageId === "string" ? requestObject(request).clientUserMessageId : void 0,
+          requestObject(request)[THREAD_REFERENCE_SOURCE_HOST_PARAM]
         )
       );
       try {
@@ -41073,12 +41463,12 @@ var AppServerHost = class {
     }
   }
   /** Keep command restoration and dispatch identical for start and steer submissions. */
-  async #beginExternalInputTurn(thread, inputText, assertActive, clientUserMessageId) {
+  async #beginExternalInputTurn(thread, inputText, assertActive, clientUserMessageId, sourceHostId) {
     const text = restoreHarnessCommandMentions(inputText);
     const commands = thread.session.commands;
     if (!commands || !isExternalCommandCandidate(text)) {
       assertActive?.();
-      return this.#beginExternalTurn(thread, text, clientUserMessageId);
+      return this.#beginExternalTurn(thread, text, clientUserMessageId, sourceHostId);
     }
     this.#pendingExternalCommandRequests.add(thread.id);
     try {
@@ -41089,9 +41479,15 @@ var AppServerHost = class {
       assertActive?.();
       if (!command) {
         this.#pendingExternalCommandRequests.delete(thread.id);
-        return await this.#beginExternalTurn(thread, text, clientUserMessageId);
+        return await this.#beginExternalTurn(thread, text, clientUserMessageId, sourceHostId);
       }
-      return await this.#beginExternalCommand(thread, command.descriptor, command.arguments);
+      return await this.#beginExternalCommand(
+        thread,
+        command.descriptor,
+        command.arguments,
+        void 0,
+        sourceHostId
+      );
     } catch (error51) {
       if (error51 instanceof ExternalCommandError || error51 instanceof ExternalSteerError) throw error51;
       this.#diagnose(error51);
@@ -41103,7 +41499,20 @@ var AppServerHost = class {
       this.#pendingExternalCommandRequests.delete(thread.id);
     }
   }
-  async #beginExternalTurn(thread, text, clientUserMessageId) {
+  /** Apply context before native execution; a rejected start restores the prior identity. */
+  #setExecutionHost(thread, sourceHostId) {
+    const previousHostId = this.#executionHosts.get(thread);
+    if (typeof sourceHostId === "string" && sourceHostId.length > 0 && sourceHostId.length <= 1024 && !/[\u0000-\u0020\u007f]/u.test(sourceHostId)) {
+      this.#executionHosts.set(thread, sourceHostId);
+    } else {
+      this.#executionHosts.delete(thread);
+    }
+    return () => {
+      if (previousHostId === void 0) this.#executionHosts.delete(thread);
+      else this.#executionHosts.set(thread, previousHostId);
+    };
+  }
+  async #beginExternalTurn(thread, text, clientUserMessageId, sourceHostId) {
     if (this.#closeRequested || this.#externalRuntime.get(thread.id) !== thread) {
       throw new ExternalSteerError(-32073, "External Thread is no longer available");
     }
@@ -41130,6 +41539,7 @@ var AppServerHost = class {
     thread.projectedTerminalTurnId = null;
     thread.projectedTurns.set(turnId, projection);
     thread.responseGates.set(turnId, gate);
+    const restoreExecutionHost = this.#setExecutionHost(thread, sourceHostId);
     try {
       if (thread.unsubmittedPrewarm && await this.#externalRuntime.submitPrewarm(thread)) {
         await this.#notifyExternalThreadStarted(thread.thread);
@@ -41142,6 +41552,7 @@ var AppServerHost = class {
       if (!result.ok) throw new ExternalSteerError(-32073, result.error.message);
       return { turnId, turn: projection.projector.pendingTurn(), gate };
     } catch (error51) {
+      restoreExecutionHost();
       thread.running = false;
       thread.activeTurnId = null;
       thread.projectedTurns.delete(turnId);
@@ -41370,7 +41781,11 @@ var AppServerHost = class {
     if (event.type === "session.faulted") {
       this.#externalSteering.fault(thread.id, new Error(event.error.message));
       thread.stateObserver.fault(new Error(event.error.message));
+      this.#externalRuntime.markSessionUnavailable(thread);
       this.#diagnose(`${thread.harnessId} Harness Session faulted: ${event.error.message}`);
+      if (!thread.running && !thread.activeTurnId && !this.#hasRunningSubagents(thread.id) && !thread.session.hasBackgroundWork?.()) {
+        void this.#externalRuntime.discardUnavailableIdle(thread);
+      }
       return;
     }
     if (event.type === "turn.autonomous.started") {
@@ -41499,6 +41914,11 @@ var AppServerHost = class {
     return { ...subagent, subagentId: record4.hostThreadId };
   }
   async #refreshOpenSubagentThread(threadId2, terminal3 = true) {
+    await this.#desktopRequests.run(threadId2, async () => {
+      await this.#refreshOpenSubagentThreadBody(threadId2, terminal3);
+    });
+  }
+  async #refreshOpenSubagentThreadBody(threadId2, terminal3) {
     const child = this.#externalRuntime.get(threadId2);
     if (!child) return;
     const previousItems = new Map(
@@ -43523,15 +43943,28 @@ var DelegationControlRegistry = class {
     return (await this.#registrationForThread(input.threadId)).cancel(input);
   }
   async read(input) {
-    if (input.hostId !== void 0 && input.hostId !== "local") {
-      if (!input.hostId || !this.#remoteRead)
+    const { callerThreadId: callerThreadId2, ...read } = input;
+    if (read.hostId !== void 0 && read.hostId !== "local") {
+      if (typeof callerThreadId2 === "string" && callerThreadId2) {
+        const callers = await this.#matching(
+          (registration) => registration.executionHostId?.(callerThreadId2) === read.hostId && registration.ownsThread(callerThreadId2)
+        );
+        if (callers.length > 1)
+          only(callers, "Calling Thread has ambiguous execution Host context");
+        if (callers.length === 1) {
+          const { hostId: hostId2, ...local } = read;
+          const snapshot2 = await (await this.#registrationForThread(local.threadId)).read(local);
+          return { ...snapshot2, hostId: hostId2 };
+        }
+      }
+      if (!read.hostId || !this.#remoteRead)
         throw new DelegationControlError(
           "RUNTIME_UNREACHABLE",
           "Remote Thread reading is unavailable"
         );
-      return this.#remoteRead(input);
+      return this.#remoteRead(read);
     }
-    return (await this.#registrationForThread(input.threadId)).read(input);
+    return (await this.#registrationForThread(read.threadId)).read(read);
   }
   async wait(input) {
     if (input.hostId !== void 0 && input.hostId !== "local")
@@ -45555,9 +45988,21 @@ function requiredRuntimeConfiguration(environment) {
   if (!stockCodexPath) throw new Error(`${STOCK_CODEX_PATH_ENV} is required`);
   return { stockCodexPath };
 }
-function delegationCliEnvironment(environment) {
-  const cliPath = environment[DELEGATION_CLI_PATH_ENV] ?? environment[UPDATE_RUNTIME_ENV.launcherExecutable];
-  const nodePath2 = environment[UPDATE_RUNTIME_ENV.npmNodePath];
+function delegationCliEnvironment(environment, hostRuntimePath) {
+  let packagedCli;
+  if (hostRuntimePath && path37.isAbsolute(hostRuntimePath)) {
+    const candidate = path37.resolve(
+      path37.dirname(hostRuntimePath),
+      "../bin",
+      process.platform === "win32" ? "codexhost.exe" : "codexhost"
+    );
+    try {
+      if (statSync(candidate).isFile()) packagedCli = candidate;
+    } catch {
+    }
+  }
+  const cliPath = environment[DELEGATION_CLI_PATH_ENV] ?? environment[UPDATE_RUNTIME_ENV.launcherExecutable] ?? packagedCli;
+  const nodePath2 = environment[DELEGATION_CLI_NODE_PATH_ENV] ?? environment[UPDATE_RUNTIME_ENV.npmNodePath] ?? (packagedCli && cliPath === packagedCli ? process.execPath : void 0);
   return {
     ...cliPath ? { [DELEGATION_CLI_PATH_ENV]: cliPath } : {},
     ...nodePath2 && path37.isAbsolute(nodePath2) ? { [DELEGATION_CLI_NODE_PATH_ENV]: nodePath2 } : {}
@@ -45575,7 +46020,7 @@ async function prepareDelegationRuntime(input) {
   const server = await startDelegationControlServer({ token, api: registry2, watchApi: registry2 });
   const environment = {
     ...input.environment,
-    ...delegationCliEnvironment(input.environment),
+    ...delegationCliEnvironment(input.environment, input.hostRuntimePath),
     [DELEGATION_RUNTIME_ENDPOINT_ENV]: server.endpoint,
     [DELEGATION_RUNTIME_TOKEN_ENV]: token
   };
@@ -45650,6 +46095,7 @@ async function runHostRuntime(input) {
     const environment = remoteControlPlan?.environment ?? input.environment;
     return prepareDelegationRuntime({
       environment,
+      ...hostRuntimePath ? { hostRuntimePath } : {},
       createHost: async (delegationEnvironment, onDelegationApi, registry2) => {
         const official = await prepareLocalCodex({
           stockCodexPath,
@@ -45758,6 +46204,7 @@ async function runHostRuntime(input) {
   if (!listenUrl) throw new Error("Remote app-server listener URL is unavailable");
   return prepareDelegationRuntime({
     environment: input.environment,
+    ...hostRuntimePath ? { hostRuntimePath } : {},
     createHost: async (delegationEnvironment, _onDelegationApi, registry2) => {
       const socketPath = remoteAppServerSocketPath(delegationEnvironment, listenUrl);
       const officialPlan = createRemoteOfficialAppServerPlan(input.arguments, socketPath);
@@ -47463,8 +47910,11 @@ async function startHarnessBrokerServer(input) {
         retireWhenIdle = false;
       if (request.method === "adapter.credits") {
         harnessAccountListParamsSchema.parse(request.params);
-        const adapter = input.adapter;
-        return accountCreditsSnapshotSchema.nullable().parse(adapter.credits?.() ?? null);
+        const value2 = input.adapter.credits?.();
+        const credits = parseHarnessAccountCredits(value2);
+        if (value2 != null && !credits)
+          throw new Error("Invalid account credits snapshot");
+        return credits;
       }
       if (request.method === "adapter.inspectAccount") {
         harnessAccountListParamsSchema.parse(request.params);
@@ -47991,7 +48441,7 @@ import {
   readdirSync,
   renameSync,
   rmSync,
-  statSync,
+  statSync as statSync2,
   writeFileSync
 } from "node:fs";
 import os12 from "node:os";
@@ -48021,7 +48471,7 @@ function pruneRuntimeLogs(input) {
       if (!Number.isSafeInteger(pid)) continue;
       try {
         const filePath = path42.join(input.directory, entry.name);
-        const stats = statSync(filePath);
+        const stats = statSync2(filePath);
         files.push({
           filePath,
           pid,