@codexhost/cli-darwin-x64 0.13.1 → 0.13.2

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"]),
@@ -21467,14 +21471,37 @@ 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;
+  #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 +21562,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);
@@ -21558,8 +21585,15 @@ var RuntimeMaintenance = class {
             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 +21665,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 +21684,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 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() + UPDATER_START_TIMEOUT_MS;
     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 +21729,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";
@@ -31745,6 +31784,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 +31942,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 +32298,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 +32310,8 @@ var ExternalThreadRuntime = class {
   #diagnose;
   #environment;
   #repository;
-  #restores = /* @__PURE__ */ new Map();
+  #lifecycle = new ExternalThreadLifecycle();
+  #hasRunningDescendants;
   #subagentRunning;
   #threads = /* @__PURE__ */ new Map();
   constructor(input) {
@@ -32192,12 +32321,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 +32343,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 +32426,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 +32454,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 +32476,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 +32530,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 +32601,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 +32855,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;
     }
   }
@@ -37684,6 +38006,7 @@ var AppServerHost = class {
   #launchSettings;
   #accountInspections = new HarnessAccountInspectionCache();
   #externalRuntime;
+  #executionHosts = /* @__PURE__ */ new WeakMap();
   #externalPrewarms = new ExternalThreadPrewarms();
   #externalSteering = new ExternalTurnSteering();
   #liveCommandCache = new LiveCommandCatalogCache();
@@ -37818,6 +38141,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 +38200,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 +38341,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
@@ -40206,7 +40535,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 +40564,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 +40577,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 +41357,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 +41384,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 +41406,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 +41422,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 +41442,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 +41482,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 +41495,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 +41724,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 +41857,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 +43886,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 +45931,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 +45963,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 +46038,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 +46147,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);
@@ -47991,7 +48381,7 @@ import {
   readdirSync,
   renameSync,
   rmSync,
-  statSync,
+  statSync as statSync2,
   writeFileSync
 } from "node:fs";
 import os12 from "node:os";
@@ -48021,7 +48411,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,