@liberseek/boft-cli-win32-arm64 0.6.9 → 0.7.0

package/app/host-runtime.mjs

@@ -4283,7 +4283,7 @@ async function runDelegationCli(input) {
 
 // packages/host-runtime/src/run-host-runtime.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
-import path20 from "node:path";
+import path21 from "node:path";
 import { homedir as homedir2 } from "node:os";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
@@ -5978,10 +5978,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path25) {
-  if (!path25)
+function getElementAtPath(obj, path26) {
+  if (!path26)
     return obj;
-  return path25.reduce((acc, key) => acc?.[key], obj);
+  return path26.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -6390,11 +6390,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path25, issues) {
+function prefixIssues(path26, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path25);
+    iss.path.unshift(path26);
     return iss;
   });
 }
@@ -6541,16 +6541,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path25 = []) => {
+  const processError = (error52, path26 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path25, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path26, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path25, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path26, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path25, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path26, ...issue2.path]);
       } else {
-        const fullpath = [...path25, ...issue2.path];
+        const fullpath = [...path26, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -6577,17 +6577,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path25 = []) => {
+  const processError = (error52, path26 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path25, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path26, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path25, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path26, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path25, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path26, ...issue2.path]);
       } else {
-        const fullpath = [...path25, ...issue2.path];
+        const fullpath = [...path26, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -6619,8 +6619,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path25 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path25) {
+  const path26 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path26) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -19312,13 +19312,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path25 = ref.slice(1).split("/").filter(Boolean);
-  if (path25.length === 0) {
+  const path26 = ref.slice(1).split("/").filter(Boolean);
+  if (path26.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path25[0] === defsKey) {
-    const key = path25[1];
+  if (path26[0] === defsKey) {
+    const key = path26[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -19729,6 +19729,48 @@ config(en_default());
 // packages/shared-contracts/dist/version.js
 var WORKSPACE_CONTRACT_VERSION = 1;
 
+// packages/shared-contracts/dist/idle-release.js
+var IDLE_RELEASE_SETTINGS_METHOD = "codexhost/settings/idle-release/set";
+var IDLE_RELEASE_TIMEOUT_MINUTES_MIN = 5;
+var IDLE_RELEASE_TIMEOUT_MINUTES_MAX = 1440;
+var idleReleaseSettingsSchema = external_exports.strictObject({
+  enabled: external_exports.boolean(),
+  timeoutMinutes: external_exports.number().int().min(IDLE_RELEASE_TIMEOUT_MINUTES_MIN).max(IDLE_RELEASE_TIMEOUT_MINUTES_MAX)
+});
+var DEFAULT_IDLE_RELEASE_SETTINGS = Object.freeze({
+  enabled: false,
+  timeoutMinutes: 30
+});
+
+// packages/shared-contracts/dist/loaded-sessions.js
+var LOADED_SESSIONS_METHOD = "codexhost/sessions/loaded/list";
+var loadedSessionStateSchema = external_exports.enum([
+  "idle",
+  "running",
+  "busy",
+  "closing",
+  "failed",
+  "blocked"
+]);
+var loadedSessionReasonSchema = external_exports.enum([
+  "none",
+  "disabled",
+  "timeout",
+  "operation",
+  "background",
+  "identity",
+  "persistence",
+  "closeFailed"
+]);
+var loadedSessionsSchema = external_exports.array(external_exports.strictObject({
+  threadId: external_exports.string(),
+  title: external_exports.string(),
+  harnessId: external_exports.string(),
+  state: loadedSessionStateSchema,
+  reason: loadedSessionReasonSchema,
+  inactiveMs: external_exports.number().nonnegative()
+}));
+
 // packages/shared-contracts/dist/ids.js
 var opaqueIdSchema = external_exports.string().refine((value2) => value2.trim().length > 0, {
   message: "Identifier must not be empty or whitespace"
@@ -20919,10 +20961,20 @@ function processIdentity(pid) {
     if (systemErrorCode2(error51) !== "EPERM")
       return null;
   }
-  if (process.platform !== "win32") {
+  if (process.platform !== "win32" && process.platform !== "darwin") {
     return { executablePath: null, startedAt: null };
   }
   try {
+    if (process.platform === "darwin") {
+      const result2 = execFileSync("/bin/ps", ["-p", String(pid), "-o", "lstart="], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        env: { ...process.env, LC_ALL: "C" },
+        timeout: 1e3
+      }).trim();
+      const startedAt2 = Date.parse(result2);
+      return { executablePath: null, startedAt: Number.isFinite(startedAt2) ? startedAt2 : null };
+    }
     const query = [
       "$ErrorActionPreference = 'Stop'",
       `$process = Get-Process -Id ${pid}`,
@@ -20964,7 +21016,7 @@ function lockOwnerIsLive(lock) {
   const identity = processIdentity(lock.pid);
   if (!identity)
     return false;
-  if (process.platform !== "win32")
+  if (process.platform !== "win32" && process.platform !== "darwin")
     return true;
   if (identity.executablePath && lock.executablePath) {
     if (normalizeExecutablePath(identity.executablePath) !== normalizeExecutablePath(lock.executablePath)) {
@@ -21920,6 +21972,8 @@ function projectCodexQuestionRequest(input) {
           const mapped = labels.get(value2);
           if (mapped !== void 0)
             return mapped;
+          if (question.options.some((option) => option.value === value2))
+            return value2;
           if (question.allowOther)
             return value2;
           throw responseError2("contains an undeclared choice");
@@ -22194,6 +22248,681 @@ function projectCodexRateLimitsToCredits(usage, resetCredits) {
   };
 }
 
+// node_modules/diff/libesm/diff/base.js
+var Diff = class {
+  diff(oldStr, newStr, options2 = {}) {
+    let callback;
+    if (typeof options2 === "function") {
+      callback = options2;
+      options2 = {};
+    } else if ("callback" in options2) {
+      callback = options2.callback;
+    }
+    const oldString = this.castInput(oldStr, options2);
+    const newString = this.castInput(newStr, options2);
+    const oldTokens = this.removeEmpty(this.tokenize(oldString, options2));
+    const newTokens = this.removeEmpty(this.tokenize(newString, options2));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options2, callback);
+  }
+  diffWithOptionsObj(oldTokens, newTokens, options2, callback) {
+    var _a3;
+    const done = (value2) => {
+      value2 = this.postProcess(value2, options2);
+      if (callback) {
+        setTimeout(function() {
+          callback(value2);
+        }, 0);
+        return void 0;
+      } else {
+        return value2;
+      }
+    };
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let editLength = 1;
+    let maxEditLength = newLen + oldLen;
+    if (options2.maxEditLength != null) {
+      maxEditLength = Math.min(maxEditLength, options2.maxEditLength);
+    }
+    const maxExecutionTime = (_a3 = options2.timeout) !== null && _a3 !== void 0 ? _a3 : Infinity;
+    const abortAfterTimestamp = Date.now() + maxExecutionTime;
+    const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
+    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options2);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    }
+    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    const execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = void 0;
+        }
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = void 0;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = this.addToPath(addPath, true, false, 0, options2);
+        } else {
+          basePath = this.addToPath(removePath, false, true, 1, options2);
+        }
+        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options2);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    };
+    if (callback) {
+      (function exec() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(void 0);
+          }
+          if (!execEditLength()) {
+            exec();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  }
+  addToPath(path26, added, removed, oldPosInc, options2) {
+    const last = path26.lastComponent;
+    if (last && !options2.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path26.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path26.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
+    }
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options2) {
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options2)) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+      if (options2.oneChangePerToken) {
+        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+    }
+    if (commonCount && !options2.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  }
+  equals(left, right, options2) {
+    if (options2.comparator) {
+      return options2.comparator(left, right);
+    } else {
+      return left === right || !!options2.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  }
+  removeEmpty(array2) {
+    const ret = [];
+    for (let i = 0; i < array2.length; i++) {
+      if (array2[i]) {
+        ret.push(array2[i]);
+      }
+    }
+    return ret;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  castInput(value2, options2) {
+    return value2;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  tokenize(value2, options2) {
+    return Array.from(value2);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options2) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return false;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (; componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value2 = newTokens.slice(newPos, newPos + component.count);
+          value2 = value2.map(function(value3, i) {
+            const oldValue = oldTokens[oldPos + i];
+            return oldValue.length > value3.length ? oldValue : value3;
+          });
+          component.value = this.join(value2);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
+      }
+    }
+    return components;
+  }
+};
+
+// node_modules/diff/libesm/diff/line.js
+var LineDiff = class extends Diff {
+  constructor() {
+    super(...arguments);
+    this.tokenize = tokenize;
+  }
+  equals(left, right, options2) {
+    if (options2.ignoreWhitespace) {
+      if (!options2.newlineIsToken || !left.includes("\n")) {
+        left = left.trim();
+      }
+      if (!options2.newlineIsToken || !right.includes("\n")) {
+        right = right.trim();
+      }
+    } else if (options2.ignoreNewlineAtEof && !options2.newlineIsToken) {
+      if (left.endsWith("\n")) {
+        left = left.slice(0, -1);
+      }
+      if (right.endsWith("\n")) {
+        right = right.slice(0, -1);
+      }
+    }
+    return super.equals(left, right, options2);
+  }
+};
+var lineDiff = new LineDiff();
+function diffLines(oldStr, newStr, options2) {
+  return lineDiff.diff(oldStr, newStr, options2);
+}
+function tokenize(value2, options2) {
+  if (options2.stripTrailingCr) {
+    value2 = value2.replace(/\r\n/g, "\n");
+  }
+  const retLines = [], linesAndNewlines = value2.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (let i = 0; i < linesAndNewlines.length; i++) {
+    const line = linesAndNewlines[i];
+    if (i % 2 && !options2.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
+    }
+  }
+  return retLines;
+}
+
+// node_modules/diff/libesm/diff/array.js
+var ArrayDiff = class extends Diff {
+  tokenize(value2) {
+    return value2.slice();
+  }
+  join(value2) {
+    return value2;
+  }
+  removeEmpty(value2) {
+    return value2;
+  }
+};
+var arrayDiff = new ArrayDiff();
+function diffArrays(oldArr, newArr, options2) {
+  return arrayDiff.diff(oldArr, newArr, options2);
+}
+
+// node_modules/diff/libesm/patch/parse.js
+function parsePatch(uniDiff) {
+  const diffstr = uniDiff.split(/\n/), list = [];
+  let i = 0;
+  function parseIndex() {
+    const index = {};
+    list.push(index);
+    while (i < diffstr.length) {
+      const line = diffstr[i];
+      if (/^(---|\+\+\+|@@)\s/.test(line)) {
+        break;
+      }
+      const header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line);
+      if (header) {
+        index.index = header[1];
+      }
+      i++;
+    }
+    parseFileHeader(index);
+    parseFileHeader(index);
+    index.hunks = [];
+    while (i < diffstr.length) {
+      const line = diffstr[i];
+      if (/^(Index:\s|diff\s|---\s|\+\+\+\s|===================================================================)/.test(line)) {
+        break;
+      } else if (/^@@/.test(line)) {
+        index.hunks.push(parseHunk());
+      } else if (line) {
+        throw new Error("Unknown line " + (i + 1) + " " + JSON.stringify(line));
+      } else {
+        i++;
+      }
+    }
+  }
+  function parseFileHeader(index) {
+    const fileHeader = /^(---|\+\+\+)\s+(.*)\r?$/.exec(diffstr[i]);
+    if (fileHeader) {
+      const data = fileHeader[2].split("	", 2), header = (data[1] || "").trim();
+      let fileName = data[0].replace(/\\\\/g, "\\");
+      if (/^".*"$/.test(fileName)) {
+        fileName = fileName.substr(1, fileName.length - 2);
+      }
+      if (fileHeader[1] === "---") {
+        index.oldFileName = fileName;
+        index.oldHeader = header;
+      } else {
+        index.newFileName = fileName;
+        index.newHeader = header;
+      }
+      i++;
+    }
+  }
+  function parseHunk() {
+    var _a3;
+    const chunkHeaderIndex = i, chunkHeaderLine = diffstr[i++], chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+    const hunk = {
+      oldStart: +chunkHeader[1],
+      oldLines: typeof chunkHeader[2] === "undefined" ? 1 : +chunkHeader[2],
+      newStart: +chunkHeader[3],
+      newLines: typeof chunkHeader[4] === "undefined" ? 1 : +chunkHeader[4],
+      lines: []
+    };
+    if (hunk.oldLines === 0) {
+      hunk.oldStart += 1;
+    }
+    if (hunk.newLines === 0) {
+      hunk.newStart += 1;
+    }
+    let addCount = 0, removeCount = 0;
+    for (; i < diffstr.length && (removeCount < hunk.oldLines || addCount < hunk.newLines || ((_a3 = diffstr[i]) === null || _a3 === void 0 ? void 0 : _a3.startsWith("\\"))); i++) {
+      const operation = diffstr[i].length == 0 && i != diffstr.length - 1 ? " " : diffstr[i][0];
+      if (operation === "+" || operation === "-" || operation === " " || operation === "\\") {
+        hunk.lines.push(diffstr[i]);
+        if (operation === "+") {
+          addCount++;
+        } else if (operation === "-") {
+          removeCount++;
+        } else if (operation === " ") {
+          addCount++;
+          removeCount++;
+        }
+      } else {
+        throw new Error(`Hunk at line ${chunkHeaderIndex + 1} contained invalid line ${diffstr[i]}`);
+      }
+    }
+    if (!addCount && hunk.newLines === 1) {
+      hunk.newLines = 0;
+    }
+    if (!removeCount && hunk.oldLines === 1) {
+      hunk.oldLines = 0;
+    }
+    if (addCount !== hunk.newLines) {
+      throw new Error("Added line count did not match for hunk at line " + (chunkHeaderIndex + 1));
+    }
+    if (removeCount !== hunk.oldLines) {
+      throw new Error("Removed line count did not match for hunk at line " + (chunkHeaderIndex + 1));
+    }
+    return hunk;
+  }
+  while (i < diffstr.length) {
+    parseIndex();
+  }
+  return list;
+}
+
+// node_modules/diff/libesm/patch/create.js
+function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options2) {
+  let optionsObj;
+  if (!options2) {
+    optionsObj = {};
+  } else if (typeof options2 === "function") {
+    optionsObj = { callback: options2 };
+  } else {
+    optionsObj = options2;
+  }
+  if (typeof optionsObj.context === "undefined") {
+    optionsObj.context = 4;
+  }
+  const context = optionsObj.context;
+  if (optionsObj.newlineIsToken) {
+    throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
+  }
+  if (!optionsObj.callback) {
+    return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
+  } else {
+    const { callback } = optionsObj;
+    diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
+      const patch = diffLinesResultToPatch(diff);
+      callback(patch);
+    } }));
+  }
+  function diffLinesResultToPatch(diff) {
+    if (!diff) {
+      return;
+    }
+    diff.push({ value: "", lines: [] });
+    function contextLines(lines) {
+      return lines.map(function(entry) {
+        return " " + entry;
+      });
+    }
+    const hunks = [];
+    let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
+    for (let i = 0; i < diff.length; i++) {
+      const current = diff[i], lines = current.lines || splitLines(current.value);
+      current.lines = lines;
+      if (current.added || current.removed) {
+        if (!oldRangeStart) {
+          const prev = diff[i - 1];
+          oldRangeStart = oldLine;
+          newRangeStart = newLine;
+          if (prev) {
+            curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
+            oldRangeStart -= curRange.length;
+            newRangeStart -= curRange.length;
+          }
+        }
+        for (const line of lines) {
+          curRange.push((current.added ? "+" : "-") + line);
+        }
+        if (current.added) {
+          newLine += lines.length;
+        } else {
+          oldLine += lines.length;
+        }
+      } else {
+        if (oldRangeStart) {
+          if (lines.length <= context * 2 && i < diff.length - 2) {
+            for (const line of contextLines(lines)) {
+              curRange.push(line);
+            }
+          } else {
+            const contextSize = Math.min(lines.length, context);
+            for (const line of contextLines(lines.slice(0, contextSize))) {
+              curRange.push(line);
+            }
+            const hunk = {
+              oldStart: oldRangeStart,
+              oldLines: oldLine - oldRangeStart + contextSize,
+              newStart: newRangeStart,
+              newLines: newLine - newRangeStart + contextSize,
+              lines: curRange
+            };
+            hunks.push(hunk);
+            oldRangeStart = 0;
+            newRangeStart = 0;
+            curRange = [];
+          }
+        }
+        oldLine += lines.length;
+        newLine += lines.length;
+      }
+    }
+    for (const hunk of hunks) {
+      for (let i = 0; i < hunk.lines.length; i++) {
+        if (hunk.lines[i].endsWith("\n")) {
+          hunk.lines[i] = hunk.lines[i].slice(0, -1);
+        } else {
+          hunk.lines.splice(i + 1, 0, "\");
+          i++;
+        }
+      }
+    }
+    return {
+      oldFileName,
+      newFileName,
+      oldHeader,
+      newHeader,
+      hunks
+    };
+  }
+}
+function formatPatch(patch) {
+  if (Array.isArray(patch)) {
+    return patch.map(formatPatch).join("\n");
+  }
+  const ret = [];
+  if (patch.oldFileName == patch.newFileName) {
+    ret.push("Index: " + patch.oldFileName);
+  }
+  ret.push("===================================================================");
+  ret.push("--- " + patch.oldFileName + (typeof patch.oldHeader === "undefined" ? "" : "	" + patch.oldHeader));
+  ret.push("+++ " + patch.newFileName + (typeof patch.newHeader === "undefined" ? "" : "	" + patch.newHeader));
+  for (let i = 0; i < patch.hunks.length; i++) {
+    const hunk = patch.hunks[i];
+    if (hunk.oldLines === 0) {
+      hunk.oldStart -= 1;
+    }
+    if (hunk.newLines === 0) {
+      hunk.newStart -= 1;
+    }
+    ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@");
+    for (const line of hunk.lines) {
+      ret.push(line);
+    }
+  }
+  return ret.join("\n") + "\n";
+}
+function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options2) {
+  if (typeof options2 === "function") {
+    options2 = { callback: options2 };
+  }
+  if (!(options2 === null || options2 === void 0 ? void 0 : options2.callback)) {
+    const patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options2);
+    if (!patchObj) {
+      return;
+    }
+    return formatPatch(patchObj);
+  } else {
+    const { callback } = options2;
+    structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, Object.assign(Object.assign({}, options2), { callback: (patchObj) => {
+      if (!patchObj) {
+        callback(void 0);
+      } else {
+        callback(formatPatch(patchObj));
+      }
+    } }));
+  }
+}
+function splitLines(text2) {
+  const hasTrailingNl = text2.endsWith("\n");
+  const result = text2.split("\n").map((line) => line + "\n");
+  if (hasTrailingNl) {
+    result.pop();
+  } else {
+    result.push(result.pop().slice(0, -1));
+  }
+  return result;
+}
+
+// packages/protocol-core/dist/file-change-summary.js
+import path6 from "node:path";
+function filePathKey(file2, cwd) {
+  const windows = /^[a-z]:[/\\]/i.test(cwd) || /^[a-z]:[/\\]/i.test(file2);
+  const paths = windows ? path6.win32 : path6.posix;
+  const resolved = paths.resolve(cwd, file2).replaceAll("\\", "/");
+  return windows ? resolved.toLowerCase() : resolved;
+}
+function composePatches(changes) {
+  if (changes.some((change) => change.diffScope === "fragment"))
+    return null;
+  const original = [];
+  const current = [];
+  for (const change of changes) {
+    let patches;
+    try {
+      patches = parsePatch(change.unifiedDiff);
+    } catch {
+      return null;
+    }
+    const [patch] = patches;
+    if (!patch || patches.length !== 1)
+      return null;
+    const hunks2 = patch.hunks;
+    for (const hunk2 of [...hunks2].reverse()) {
+      const start = hunk2.oldStart - 1;
+      while (current.length < start + hunk2.oldLines) {
+        const line = {};
+        original.push(line);
+        current.push(line);
+      }
+      const replacement = [];
+      let offset = start;
+      for (const [i, entry] of hunk2.lines.entries()) {
+        const operation = entry[0];
+        if (operation === "\\")
+          continue;
+        const text2 = entry.slice(1) + (hunk2.lines[i + 1]?.startsWith("\\") ? "" : "\n");
+        if (operation === "+")
+          replacement.push({ text: text2 });
+        else {
+          const line = current[offset++];
+          if (!line || line.text !== void 0 && line.text !== text2)
+            return null;
+          line.text = text2;
+          if (operation === " ")
+            replacement.push(line);
+        }
+      }
+      current.splice(start, hunk2.oldLines, ...replacement);
+    }
+  }
+  const hunks = [];
+  let oldStart = 1;
+  let newStart = 1;
+  let hunk;
+  for (const part of diffArrays(original, current, {
+    comparator: (a, b) => a === b || a.text !== void 0 && a.text === b.text
+  })) {
+    if (!part.added && !part.removed) {
+      hunk = void 0;
+      oldStart += part.count;
+      newStart += part.count;
+      continue;
+    }
+    if (!hunk) {
+      hunk = { oldStart, newStart, oldLines: 0, newLines: 0, lines: [] };
+      hunks.push(hunk);
+    }
+    for (const line of part.value) {
+      const text2 = line.text;
+      if (text2 === void 0)
+        return null;
+      hunk.lines.push((part.added ? "+" : "-") + text2.replace(/\n$/, ""));
+      if (!text2.endsWith("\n"))
+        hunk.lines.push("\");
+    }
+    if (part.added) {
+      hunk.newLines += part.count;
+      newStart += part.count;
+    } else {
+      hunk.oldLines += part.count;
+      oldStart += part.count;
+    }
+  }
+  return hunks;
+}
+function summarizeFileChanges(changes, cwd) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const change of changes) {
+    const key = filePathKey(change.path, cwd);
+    const group = groups.get(key);
+    if (group)
+      group.push(change);
+    else
+      groups.set(key, [change]);
+  }
+  return [...groups.values()].flatMap((group) => {
+    const first = group[0];
+    if (group.length === 1)
+      return [first];
+    const last = group.at(-1) ?? first;
+    const hunks = composePatches(group);
+    const kind = last.kind === "delete" ? "delete" : first.kind === "add" ? "add" : "update";
+    if (hunks) {
+      if (hunks.length === 0 && first.kind !== "add" === (last.kind !== "delete"))
+        return [];
+      return [
+        {
+          path: first.path,
+          kind,
+          unifiedDiff: formatPatch({
+            oldFileName: first.kind === "add" ? "/dev/null" : `a/${first.path}`,
+            newFileName: last.kind === "delete" ? "/dev/null" : `b/${first.path}`,
+            oldHeader: "",
+            newHeader: "",
+            hunks
+          })
+        }
+      ];
+    }
+    const bodies = group.map(({ unifiedDiff }) => {
+      const start = unifiedDiff.indexOf("@@");
+      return start < 0 ? unifiedDiff : unifiedDiff.slice(start);
+    });
+    const headerEnd = first.unifiedDiff.indexOf("@@");
+    const header = headerEnd < 0 ? "" : first.unifiedDiff.slice(0, headerEnd);
+    return [
+      {
+        path: first.path,
+        kind,
+        unifiedDiff: header + bodies.join("\n"),
+        diffScope: "fragment"
+      }
+    ];
+  });
+}
+
 // packages/protocol-core/dist/codex-ui-projector.js
 function resolvedItemDurationMs(item, startedAtMs, completedAtMs) {
   if ((item.type === "commandExecution" || item.type === "toolExecution" || item.type === "reasoning" || item.type === "agentMessage") && item.durationMs !== void 0) {
@@ -22215,17 +22944,17 @@ function itemStatus(outcome) {
 function isRecord5(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
-function nestedString(value2, keys) {
+function nestedString(value2, keys, preserveText = false) {
   if (!isRecord5(value2))
     return void 0;
   for (const key of keys) {
     const field = value2[key];
-    if (typeof field === "string" && field.trim().length > 0)
-      return field.trim();
+    if (typeof field === "string" && (preserveText || field.trim().length > 0))
+      return preserveText ? field : field.trim();
   }
   for (const wrapper of ["input", "arguments", "params"]) {
-    const nested = nestedString(value2[wrapper], keys);
-    if (nested)
+    const nested = nestedString(value2[wrapper], keys, preserveText);
+    if (nested !== void 0)
       return nested;
   }
   return void 0;
@@ -22290,24 +23019,7 @@ function isWriteTool(toolName) {
   return ["write", "writefile", "filewrite", "create", "createfile"].includes(compactToolName(toolName));
 }
 function simpleUnifiedDiff(displayedPath, oldText, newText, kind) {
-  const oldLines = oldText === "" ? [] : oldText.split("\n");
-  const newLines = newText === "" ? [] : newText.split("\n");
-  if (oldLines.at(-1) === "")
-    oldLines.pop();
-  if (newLines.at(-1) === "")
-    newLines.pop();
-  const oldHeader = kind === "add" ? "/dev/null" : `a/${displayedPath}`;
-  const newHeader = `b/${displayedPath}`;
-  const oldRange = kind === "add" ? "0,0" : `1,${oldLines.length}`;
-  const newRange = newLines.length === 0 ? "0,0" : `1,${newLines.length}`;
-  return [
-    `--- ${oldHeader}`,
-    `+++ ${newHeader}`,
-    `@@ -${oldRange} +${newRange} @@`,
-    ...oldLines.map((line) => `-${line}`),
-    ...newLines.map((line) => `+${line}`),
-    ""
-  ].join("\n");
+  return createTwoFilesPatch(kind === "add" ? "/dev/null" : `a/${displayedPath}`, `b/${displayedPath}`, oldText, newText);
 }
 function fileChangeFromTool(toolName, args) {
   if (!isFileMutatingTool(toolName))
@@ -22316,40 +23028,27 @@ function fileChangeFromTool(toolName, args) {
   if (!displayedPath)
     return null;
   if (isWriteTool(toolName)) {
-    const content = nestedString(args, [
-      "content",
-      "new_string",
-      "newString",
-      "newText",
-      "file_text",
-      "text",
-      "new"
-    ]);
+    const content = nestedString(args, ["content", "new_string", "newString", "newText", "file_text", "text", "new"], true);
     if (content === void 0)
       return null;
     return [
       {
         path: displayedPath,
         kind: "add",
+        diffScope: "fragment",
         unifiedDiff: simpleUnifiedDiff(displayedPath, "", content, "add")
       }
     ];
   }
-  const oldText = nestedString(args, ["old_string", "oldString", "oldText", "old_text", "old"]);
-  const newText = nestedString(args, [
-    "new_string",
-    "newString",
-    "newText",
-    "new_text",
-    "content",
-    "new"
-  ]);
+  const oldText = nestedString(args, ["old_string", "oldString", "oldText", "old_text", "old"], true);
+  const newText = nestedString(args, ["new_string", "newString", "newText", "new_text", "content", "new"], true);
   if (oldText === void 0 || newText === void 0)
     return null;
   return [
     {
       path: displayedPath,
       kind: "update",
+      diffScope: "fragment",
       unifiedDiff: simpleUnifiedDiff(displayedPath, oldText, newText, "update")
     }
   ];
@@ -22360,21 +23059,25 @@ function projectFileChangeKind(kind) {
   return { type: kind };
 }
 function projectFileChanges(changes) {
-  return changes.map(({ path: path25, kind, unifiedDiff }) => ({
-    path: path25,
+  return changes.map(({ path: path26, kind, unifiedDiff }) => ({
+    path: path26,
     kind: projectFileChangeKind(kind),
     diff: unifiedDiff
   }));
 }
-function wireFileChangeItem(projected) {
-  if (projected.item.type === "fileChange")
-    return projected.item;
-  if (!projected.wireFileChanges)
+function itemFileChanges(item) {
+  return item.type === "fileChange" ? item.changes : item.type === "toolExecution" ? fileChangeFromTool(item.toolName, item.arguments) : null;
+}
+function summarizeHostFiles(items, cwd) {
+  const first = items.find(({ item }) => itemFileChanges(item) !== null);
+  if (!first)
     return null;
+  const nativeSources = new Set(items.flatMap(({ item }) => item.type === "fileChange" ? item.sourceItemIds ?? [] : []));
+  const changes = items.flatMap(({ item, outcome }) => outcome && outcome.status !== "succeeded" || nativeSources.has(item.itemId) ? [] : itemFileChanges(item) ?? []);
   return {
     type: "fileChange",
-    itemId: projected.item.itemId,
-    changes: projected.wireFileChanges
+    itemId: first.item.itemId,
+    changes: summarizeFileChanges(changes, cwd)
   };
 }
 function isTodoTool(toolName) {
@@ -22652,6 +23355,7 @@ function historicalStatus(outcome) {
 }
 function projectHistoricalTurn(input) {
   const { turnId, cwd, snapshot } = input;
+  const files = summarizeHostFiles(snapshot.items, cwd);
   const error51 = snapshot.outcome.status === "failed" ? {
     message: snapshot.outcome.error.message,
     codexErrorInfo: "other",
@@ -22671,15 +23375,12 @@ function projectHistoricalTurn(input) {
         content: userInputContent(snapshot.input)
       },
       ...snapshot.items.flatMap(({ item, outcome }) => {
+        if (itemFileChanges(item) !== null) {
+          return files?.itemId === item.itemId ? [projectItem(files, { status: "succeeded" }, cwd)] : [];
+        }
         if (item.type === "toolExecution") {
           if (isTodoTool(item.toolName) || todoPlanFromTool(item.toolName, item.arguments))
             return [];
-          const changes = fileChangeFromTool(item.toolName, item.arguments);
-          if (changes) {
-            return [
-              projectItem({ type: "fileChange", itemId: item.itemId, changes }, outcome, cwd, true, "")
-            ];
-          }
           if (isFileMutatingTool(item.toolName))
             return [];
         }
@@ -22722,7 +23423,6 @@ var CodexTurnProjector = class {
   #input;
   #interactions = /* @__PURE__ */ new Map();
   #items = /* @__PURE__ */ new Map();
-  #itemOrder = [];
   #wireItemOrder = [];
   #startedAt;
   #startedAtMs;
@@ -22730,6 +23430,7 @@ var CodexTurnProjector = class {
   #turnId;
   #completed = false;
   #started = false;
+  #fileItemId = null;
   constructor(input) {
     this.#threadId = input.threadId;
     this.#turnId = input.turnId;
@@ -22751,8 +23452,7 @@ var CodexTurnProjector = class {
           if (projected.item.type === "agentMessage") {
             return [projectItem(projected.item, projected.outcome, this.#cwd)];
           }
-          const fileItem = wireFileChangeItem(projected);
-          return fileItem ? [projectItem(fileItem, projected.outcome, this.#cwd)] : [];
+          return itemId === this.#fileItemId ? [projectItem(this.#fileSummary(), null, this.#cwd)] : [];
         })
       ],
       error: null,
@@ -22870,11 +23570,9 @@ var CodexTurnProjector = class {
       reasoningPartStarted: false,
       streamedCommandOutput: false,
       wireStarted: false,
-      wireFileChanges: null,
       startedAtMs
     };
     this.#items.set(event.item.itemId, projected);
-    this.#itemOrder.push(event.item.itemId);
     if ((event.item.type === "agentMessage" || event.item.type === "reasoning") && event.item.text.length === 0) {
       return { messages: [] };
     }
@@ -22885,30 +23583,18 @@ var CodexTurnProjector = class {
       }
       const changes = fileChangeFromTool(event.item.toolName, event.item.arguments);
       if (changes) {
-        projected.wireFileChanges = changes;
-        const fileItem = {
-          type: "fileChange",
-          itemId: event.item.itemId,
-          changes
-        };
-        return {
-          messages: [
-            this.#startWireItem(projected, fileItem, startedAtMs),
-            ...this.#fileChangeUpdates(event.item.itemId, changes)
-          ]
-        };
+        return { messages: this.#fileChangeUpdates(startedAtMs) };
       }
       if (isFileMutatingTool(event.item.toolName))
         return { messages: [] };
     }
+    if (event.item.type === "fileChange")
+      return { messages: this.#fileChangeUpdates(startedAtMs) };
     const startedItem = event.item.type === "reasoning" ? { ...event.item, text: "" } : event.item;
     const messages = [this.#startWireItem(projected, startedItem, startedAtMs)];
     if (event.item.type === "reasoning") {
       messages.push(this.#startReasoningTranscript(event.item, startedAtMs), this.#reasoningOutputDelta(event.item.itemId, event.item.text, startedAtMs), ...this.#reasoningDelta(projected, event.item.text, startedAtMs));
     }
-    if (event.item.type === "fileChange") {
-      messages.push(...this.#fileChangeUpdates(event.item.itemId, event.item.changes));
-    }
     return { messages };
   }
   #updateItem(event, emittedAtMs) {
@@ -22974,7 +23660,7 @@ var CodexTurnProjector = class {
         }
       }
     } else if (event.update.type === "fileChanges.replace") {
-      messages.push(...this.#fileChangeUpdates(event.itemId, event.update.changes));
+      messages.push(...this.#fileChangeUpdates(emittedAtMs));
     } else if (event.update.type === "subagents.replace") {
       messages.push({
         method: "item/started",
@@ -23011,6 +23697,9 @@ var CodexTurnProjector = class {
     const durationMs = resolvedItemDurationMs(projected.item, startedAtMs, emittedAtMs);
     projected.item = withResolvedDuration(projected.item, durationMs);
     projected.durationMs = durationMs;
+    if (itemFileChanges(projected.item) !== null) {
+      return { messages: this.#fileChangeUpdates(emittedAtMs) };
+    }
     const completedItem = (item) => ({
       method: "item/completed",
       emittedAtMs,
@@ -23028,28 +23717,11 @@ var CodexTurnProjector = class {
           const plan = planFromTodoValue(projected.item.arguments) ?? planFromTodoValue(projected.item.output);
           return { messages: plan ? [this.#planUpdated(plan, emittedAtMs)] : [] };
         }
-        const changes = fileChangeFromTool(projected.item.toolName, projected.item.arguments);
-        if (changes) {
-          projected.wireFileChanges = changes;
-          const fileItem2 = {
-            type: "fileChange",
-            itemId: projected.item.itemId,
-            changes
-          };
-          return {
-            messages: [
-              this.#startWireItem(projected, fileItem2, startedAtMs),
-              ...this.#fileChangeUpdates(projected.item.itemId, changes),
-              completedItem(projectItem(fileItem2, projected.outcome, this.#cwd, true, this.#threadId))
-            ]
-          };
-        }
       }
       return { messages: [] };
     }
-    const fileItem = wireFileChangeItem(projected);
     const messages = [
-      completedItem(projectItem(fileItem ?? projected.item, projected.outcome, this.#cwd, !projected.streamedCommandOutput, this.#threadId))
+      completedItem(projectItem(projected.item, projected.outcome, this.#cwd, !projected.streamedCommandOutput, this.#threadId))
     ];
     if (projected.item.type === "reasoning") {
       const reasoning = projected.item;
@@ -23108,8 +23780,7 @@ var CodexTurnProjector = class {
           if (projected.item.type === "agentMessage") {
             return [projectItem(projected.item, projected.outcome, this.#cwd)];
           }
-          const fileItem = wireFileChangeItem(projected);
-          return fileItem ? [projectItem(fileItem, projected.outcome, this.#cwd)] : [];
+          return itemId === this.#fileItemId ? [projectItem(this.#fileSummary(), { status: "succeeded" }, this.#cwd)] : [];
         })
       ],
       error: error51,
@@ -23121,6 +23792,17 @@ var CodexTurnProjector = class {
     return {
       completedTurn: turn,
       messages: [
+        ...this.#fileItemId ? [
+          {
+            method: "item/completed",
+            emittedAtMs: completedAtMs,
+            params: {
+              threadId: this.#threadId,
+              turnId: this.#turnId,
+              item: projectItem(this.#fileSummary(), { status: "succeeded" }, this.#cwd)
+            }
+          }
+        ] : [],
         ...error51 ? [
           {
             method: "error",
@@ -23234,15 +23916,31 @@ var CodexTurnProjector = class {
       }
     };
   }
-  #fileChangeUpdates(itemId, changes) {
-    const projectedChanges = projectFileChanges(changes);
+  #fileSummary() {
+    const summary = summarizeHostFiles([...this.#items.values()], this.#cwd);
+    if (!summary)
+      throw new Error("File summary requested without a file Item");
+    return this.#fileItemId ? { ...summary, itemId: this.#fileItemId } : summary;
+  }
+  #fileChangeUpdates(emittedAtMs) {
+    const summary = this.#fileSummary();
+    const messages = [];
+    if (!this.#fileItemId) {
+      this.#fileItemId = summary.itemId;
+      const source = this.#items.get(summary.itemId);
+      if (!source)
+        throw new Error("File summary references an unknown Item");
+      messages.push(this.#startWireItem(source, summary, emittedAtMs));
+    }
+    const projectedChanges = projectFileChanges(summary.changes);
     return [
+      ...messages,
       {
         method: "item/fileChange/patchUpdated",
         params: {
           threadId: this.#threadId,
           turnId: this.#turnId,
-          itemId,
+          itemId: this.#fileItemId,
           changes: projectedChanges
         }
       },
@@ -23251,21 +23949,11 @@ var CodexTurnProjector = class {
         params: {
           threadId: this.#threadId,
           turnId: this.#turnId,
-          diff: diffText(this.#allFileChanges())
+          diff: diffText(summary.changes)
         }
       }
     ];
   }
-  #allFileChanges() {
-    return this.#itemOrder.flatMap((itemId) => {
-      const projected = this.#items.get(itemId);
-      if (!projected)
-        return [];
-      if (projected.item.type === "fileChange")
-        return projected.item.changes;
-      return projected.wireFileChanges ?? [];
-    });
-  }
   #activeItem(itemId) {
     const projected = this.#items.get(itemId);
     if (!projected)
@@ -23319,13 +24007,13 @@ function decodeThreadForkRequest(request) {
   if (runtimeWorkspaceRoots !== void 0 && runtimeWorkspaceRoots !== null && (!Array.isArray(runtimeWorkspaceRoots) || runtimeWorkspaceRoots.some((root) => typeof root !== "string" || root.length === 0))) {
     throw new Error("thread/fork params.runtimeWorkspaceRoots must be text paths or null");
   }
-  const path25 = optionalText(params, "path", { allowEmpty: true });
+  const path26 = optionalText(params, "path", { allowEmpty: true });
   const ephemeral = optionalBoolean(params, "ephemeral");
   return {
     threadId: threadId2,
     ...lastTurnText ? { lastTurnId: hostTurnIdSchema.parse(lastTurnText) } : {},
     ...beforeTurnText ? { beforeTurnId: hostTurnIdSchema.parse(beforeTurnText) } : {},
-    ...path25 ? { path: path25 } : {},
+    ...path26 ? { path: path26 } : {},
     ...optionalField(params, "model"),
     ...optionalField(params, "modelProvider"),
     ...optionalField(params, "cwd"),
@@ -24484,7 +25172,7 @@ var HarnessAccountInspectionCache = class {
 // packages/host-runtime/src/app-server-host.ts
 import { createHash as createHash6, randomUUID as randomUUID8 } from "node:crypto";
 import os2 from "node:os";
-import path11 from "node:path";
+import path12 from "node:path";
 
 // packages/host-runtime/src/external-thread-fork.ts
 import nodePath from "node:path";
@@ -24492,7 +25180,7 @@ import nodePath from "node:path";
 // packages/host-runtime/src/external-thread-repository.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
 import os from "node:os";
-import path6 from "node:path";
+import path7 from "node:path";
 
 // packages/host-runtime/src/external-subagent-threads.ts
 import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
@@ -24632,8 +25320,8 @@ function sameMapping(left, right) {
 }
 function defaultMappingStoreDirectory(environment) {
   const dataDirectory = environment.CODEXHOST_DATA_DIR;
-  return path6.join(
-    dataDirectory ? path6.resolve(dataDirectory) : path6.join(os.homedir(), ".codexhost"),
+  return path7.join(
+    dataDirectory ? path7.resolve(dataDirectory) : path7.join(os.homedir(), ".codexhost"),
     "mapping-store"
   );
 }
@@ -25866,16 +26554,236 @@ var SessionStateObserver = class {
   }
 };
 
-// packages/host-runtime/src/external-thread-runtime.ts
-function nativeTurnKey3(turn) {
-  const ref = turn.nativeTurnRef;
-  return `${ref.harnessId}\0${ref.nativeSessionId}\0${ref.nativeTurnKey}\0${ref.formatVersion}`;
-}
-function mergeReadonlySnapshot(previous, next) {
-  const nextByTurn = new Map(next.turns.map((turn) => [nativeTurnKey3(turn), turn]));
-  const retainedKeys = /* @__PURE__ */ new Set();
-  const turns = previous.turns.map((turn) => {
-    const key = nativeTurnKey3(turn);
+// packages/host-runtime/src/desktop-request-queue.ts
+var DesktopRequestQueue = class {
+  #threads = /* @__PURE__ */ new Map();
+  #pending = /* @__PURE__ */ new Set();
+  run(threadId2, operation) {
+    const previous = threadId2 === void 0 ? void 0 : this.#threads.get(threadId2);
+    const task = (previous ?? Promise.resolve()).then(operation);
+    const settled = task.then(
+      () => void 0,
+      () => void 0
+    );
+    this.#pending.add(settled);
+    if (threadId2 !== void 0) this.#threads.set(threadId2, settled);
+    void settled.then(() => {
+      this.#pending.delete(settled);
+      if (threadId2 !== void 0 && this.#threads.get(threadId2) === settled) {
+        this.#threads.delete(threadId2);
+      }
+    });
+    return task;
+  }
+  /** Call after admission stops, before taking the Session snapshot for shutdown. */
+  async drain() {
+    await Promise.all(this.#pending);
+  }
+};
+
+// packages/host-runtime/src/external-thread-idle-release.ts
+var CHECK_INTERVAL_MS = 6e4;
+var CLOSE_TIMEOUT_MS = 6e4;
+var CLOSE_FAILURE = "External Session resource release failed. Further use is blocked to avoid duplicate writers. Restart Codex Desktop to retry recovery; residual processes may require manual cleanup.";
+var ExternalThreadIdleRelease = class {
+  constructor(options2) {
+    this.options = options2;
+  }
+  options;
+  #activity = /* @__PURE__ */ new WeakMap();
+  #operations = /* @__PURE__ */ new Map();
+  #closing = /* @__PURE__ */ new Map();
+  #pending = /* @__PURE__ */ new Set();
+  #scheduled = /* @__PURE__ */ new Set();
+  #settings = { ...DEFAULT_IDLE_RELEASE_SETTINGS };
+  #timer;
+  #stopped = false;
+  configure(value2) {
+    const settings = idleReleaseSettingsSchema.parse(value2);
+    if (this.#stopped) throw new Error("Host is shutting down");
+    this.#settings = settings;
+    if (settings.enabled && !this.#timer) {
+      this.#timer = setInterval(() => this.check(), CHECK_INTERVAL_MS);
+      this.#timer.unref();
+    } else if (!settings.enabled && this.#timer) {
+      clearInterval(this.#timer);
+      this.#timer = void 0;
+    }
+    return { ...settings };
+  }
+  touch(thread) {
+    const state = this.#activity.get(thread);
+    if (state) state.lastActivity = Date.now();
+    else
+      this.#activity.set(thread, {
+        lastActivity: Date.now(),
+        outputFailed: false,
+        closeFailed: false
+      });
+  }
+  outputFailed(thread) {
+    this.touch(thread);
+    const state = this.#activity.get(thread);
+    if (state) state.outputFailed = true;
+  }
+  failure(thread) {
+    return this.#activity.get(thread)?.closeFailed ? CLOSE_FAILURE : void 0;
+  }
+  async waitForClose(id2) {
+    await this.#closing.get(id2);
+  }
+  /** Acquire before resolving a Session, not after an await has exposed its reference. */
+  async runOperation(id2, operation) {
+    if (this.#stopped) throw new Error("Host is shutting down");
+    if (id2) {
+      while (this.#closing.has(id2)) await this.#closing.get(id2);
+    }
+    if (this.#stopped) throw new Error("Host is shutting down");
+    return this.#track(id2, operation);
+  }
+  /** Closing may emit outputs: consume them without waiting on the close being drained. */
+  consumeOutput(thread, operation) {
+    this.touch(thread);
+    return this.#track(thread.id, operation, false);
+  }
+  #track(id2, operation, drain = true) {
+    if (id2) this.#operations.set(id2, (this.#operations.get(id2) ?? 0) + 1);
+    const task = Promise.resolve().then(operation).finally(() => {
+      if (id2) {
+        const remaining = (this.#operations.get(id2) ?? 1) - 1;
+        if (remaining) this.#operations.set(id2, remaining);
+        else {
+          this.#operations.delete(id2);
+          const thread = this.options.get(id2);
+          if (thread) this.touch(thread);
+        }
+      }
+      this.#pending.delete(task);
+    });
+    if (drain) this.#pending.add(task);
+    return task;
+  }
+  /** Read only: never resolve a Session or touch its activity clock. */
+  list() {
+    const now = Date.now();
+    return this.options.threads().map((thread) => {
+      const activity = this.#activity.get(thread);
+      const inactiveMs = Math.max(0, now - (activity?.lastActivity ?? now));
+      let state = "idle";
+      let reason = "none";
+      if (activity?.closeFailed) {
+        state = "failed";
+        reason = "closeFailed";
+      } else if (this.#closing.has(thread.id)) {
+        state = "closing";
+      } else if (thread.running || thread.activeTurnId) {
+        state = "running";
+        reason = "operation";
+      } else if (thread.persistenceError || activity?.outputFailed) {
+        state = "blocked";
+        reason = "persistence";
+      } else if (thread.record.subagent || thread.record.state !== "ready" || !thread.record.nativeSessionRef) {
+        state = "blocked";
+        reason = "identity";
+      } else if (this.#operations.has(thread.id)) {
+        state = "busy";
+        reason = "operation";
+      } else if (!this.options.canRelease(thread)) {
+        state = "busy";
+        reason = "background";
+      } else if (!this.#settings.enabled) {
+        reason = "disabled";
+      } else if (inactiveMs < this.#settings.timeoutMinutes * 6e4) {
+        reason = "timeout";
+      }
+      return {
+        threadId: thread.id,
+        title: thread.record.title ?? thread.id,
+        harnessId: thread.harnessId,
+        state,
+        reason,
+        inactiveMs
+      };
+    });
+  }
+  #eligible(thread) {
+    const state = this.#activity.get(thread);
+    return !this.#stopped && this.#settings.enabled && !!state && !state.outputFailed && !state.closeFailed && this.options.get(thread.id) === thread && !this.#closing.has(thread.id) && !this.#operations.has(thread.id) && !thread.record.subagent && thread.record.state === "ready" && !!thread.record.nativeSessionRef && !thread.persistenceError && !thread.running && !thread.activeTurnId && this.options.canRelease(thread) && Date.now() - state.lastActivity >= this.#settings.timeoutMinutes * 6e4;
+  }
+  check() {
+    for (const thread of this.options.threads()) {
+      if (this.#scheduled.has(thread.id) || !this.#eligible(thread)) continue;
+      this.#scheduled.add(thread.id);
+      const task = this.options.queue.run(thread.id, async () => {
+        if (!this.#eligible(thread)) return;
+        const closing = this.#close(thread);
+        this.#closing.set(thread.id, closing);
+        try {
+          await closing;
+        } finally {
+          this.#closing.delete(thread.id);
+        }
+      }).catch(this.options.diagnose).finally(() => this.#scheduled.delete(thread.id));
+      this.#pending.add(task);
+      void task.finally(() => this.#pending.delete(task));
+    }
+  }
+  async #close(thread) {
+    const state = this.#activity.get(thread);
+    if (!state) return;
+    let timeout;
+    const closed = Promise.resolve().then(async () => {
+      await thread.session.close();
+      await thread.outputTask;
+      await this.options.onClosed?.(thread);
+    });
+    try {
+      await Promise.race([
+        closed,
+        new Promise((_, reject) => {
+          timeout = setTimeout(
+            () => reject(new Error("Session release timed out")),
+            CLOSE_TIMEOUT_MS
+          );
+          timeout.unref();
+        })
+      ]);
+      if (state.outputFailed || thread.persistenceError || thread.record.state !== "ready" || !thread.record.nativeSessionRef) {
+        throw new Error("Session release could not confirm persisted history and identity");
+      }
+      if (this.options.get(thread.id) !== thread) throw new Error("Session changed during release");
+      this.options.remove(thread.id);
+    } catch (error51) {
+      state.closeFailed = true;
+      this.options.diagnose(error51);
+    } finally {
+      if (timeout) clearTimeout(timeout);
+    }
+  }
+  disable() {
+    this.#settings = { ...this.#settings, enabled: false };
+    if (this.#timer) clearInterval(this.#timer);
+    this.#timer = void 0;
+  }
+  stop() {
+    this.#stopped = true;
+    this.disable();
+  }
+  async drain() {
+    while (this.#pending.size) await Promise.allSettled([...this.#pending]);
+  }
+};
+
+// packages/host-runtime/src/external-thread-runtime.ts
+function nativeTurnKey3(turn) {
+  const ref = turn.nativeTurnRef;
+  return `${ref.harnessId}\0${ref.nativeSessionId}\0${ref.nativeTurnKey}\0${ref.formatVersion}`;
+}
+function mergeReadonlySnapshot(previous, next) {
+  const nextByTurn = new Map(next.turns.map((turn) => [nativeTurnKey3(turn), turn]));
+  const retainedKeys = /* @__PURE__ */ new Set();
+  const turns = previous.turns.map((turn) => {
+    const key = nativeTurnKey3(turn);
     retainedKeys.add(key);
     const update = nextByTurn.get(key);
     if (!update) return turn;
@@ -25955,12 +26863,14 @@ function errorMessage2(error51) {
   return error51 instanceof Error ? error51.message : String(error51);
 }
 var ExternalThreadRuntime = class {
+  idleRelease;
   #adapters;
   #consumeOutputs;
   #diagnose;
   #environment;
   #repository;
   #restores = /* @__PURE__ */ new Map();
+  #subagentRunning;
   #threads = /* @__PURE__ */ new Map();
   constructor(input) {
     this.#adapters = input.adapters;
@@ -25968,6 +26878,16 @@ var ExternalThreadRuntime = class {
     this.#repository = input.repository;
     this.#consumeOutputs = input.consumeOutputs;
     this.#diagnose = input.diagnose;
+    this.#subagentRunning = input.subagentRunning ?? (() => 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),
+      ...input.idleRelease?.onClosed ? { onClosed: input.idleRelease.onClosed } : {},
+      diagnose: input.diagnose
+    });
   }
   get(threadId2) {
     return this.#threads.get(threadId2);
@@ -25997,6 +26917,7 @@ var ExternalThreadRuntime = class {
       ...effectiveThinkingOptionId ? { effectiveThinkingOptionId } : {},
       ...effectivePermissionModeId ? { effectivePermissionModeId } : {}
     };
+    const running = this.#subagentRunning(input.record.hostThreadId);
     const externalThread = {
       id: input.record.hostThreadId,
       cwd: input.record.cwd,
@@ -26009,11 +26930,11 @@ var ExternalThreadRuntime = class {
       record: input.record,
       sessionId: input.sessionId,
       stateObserver: new SessionStateObserver(observerState),
-      thread: input.thread,
+      thread: running ? { ...input.thread, status: { type: "active", activeFlags: [] } } : input.thread,
       transportModelId: input.transportModelId ?? input.record.transportModelId,
       turns: input.turns,
       historyHydrated: true,
-      running: false,
+      running,
       activeTurnId: null,
       latestUsage: input.session.initialUsage,
       usageTurnId: null,
@@ -26023,6 +26944,7 @@ var ExternalThreadRuntime = class {
       persistenceError: null,
       ignoredInteractionIds: /* @__PURE__ */ new Set()
     };
+    this.idleRelease.touch(externalThread);
     externalThread.outputTask = this.#consumeOutputs(externalThread);
     this.#threads.set(externalThread.id, externalThread);
     return externalThread;
@@ -26075,8 +26997,13 @@ var ExternalThreadRuntime = class {
     }
   }
   async locate(threadId2) {
+    await this.idleRelease.waitForClose(threadId2);
     const loaded = this.#threads.get(threadId2);
-    if (loaded) return { kind: "external", record: loaded.record, thread: loaded };
+    if (loaded) {
+      const failure = this.idleRelease.failure(loaded);
+      if (failure) return { kind: "error", error: { code: -32075, message: failure } };
+      return { kind: "external", record: loaded.record, thread: loaded };
+    }
     let record3;
     try {
       record3 = await this.#repository.find(threadId2);
@@ -26099,13 +27026,17 @@ var ExternalThreadRuntime = class {
     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: record3 } = location;
     let restoring = this.#restores.get(threadId2);
     if (!restoring) {
       const restored = this.#threads.get(threadId2);
-      if (restored) return { kind: "external", thread: restored, historyFresh: false };
+      if (restored) {
+        this.idleRelease.touch(restored);
+        return { kind: "external", thread: restored, historyFresh: false };
+      }
       restoring = this.#restore(record3).finally(() => {
         this.#restores.delete(threadId2);
       });
@@ -26465,7 +27396,7 @@ var ExternalTurnSteering = class {
 
 // packages/host-runtime/src/harness-delegation-coordinator.ts
 import { createHash as createHash5, randomUUID as randomUUID5 } from "node:crypto";
-import path7 from "node:path";
+import path8 from "node:path";
 
 // packages/host-runtime/src/delegation-snapshot.ts
 import { createHash as createHash4 } from "node:crypto";
@@ -26636,7 +27567,7 @@ function taskDigest(input) {
   return createHash5("sha256").update(
     JSON.stringify({
       task: input.task,
-      cwd: path7.resolve(input.cwd),
+      cwd: path8.resolve(input.cwd),
       modelId: input.model?.id ?? null,
       thinkingOptionId: input.thinkingOptionId ?? null
     })
@@ -26707,7 +27638,7 @@ var HarnessDelegationCoordinator = class {
     return {
       harnessId: input.harnessId,
       inspection: await adapter.inspect({
-        ...input.cwd ? { cwd: path7.resolve(input.cwd) } : {},
+        ...input.cwd ? { cwd: path8.resolve(input.cwd) } : {},
         ...input.refresh !== void 0 ? { refresh: input.refresh } : {}
       })
     };
@@ -26721,7 +27652,7 @@ var HarnessDelegationCoordinator = class {
       const result = await this.#startOfficial({ ...input, parentThreadId, cwd: selectedCwd });
       return { ...result, parentThreadId, cwd: result.cwd ?? selectedCwd };
     }
-    const startInput = { ...input, parentThreadId, cwd: path7.resolve(selectedCwd) };
+    const startInput = { ...input, parentThreadId, cwd: path8.resolve(selectedCwd) };
     if (!this.#adapters.has(input.harnessId)) {
       throw new DelegationControlError(
         "HARNESS_NOT_FOUND",
@@ -26782,94 +27713,101 @@ var HarnessDelegationCoordinator = class {
     );
     let delegation = null;
     let session = null;
-    try {
-      delegation = await this.#repository.createDelegation({
-        delegationId,
-        parentHostThreadId: hostThreadIdSchema.parse(parentThreadId),
-        childHostThreadId: childThreadId,
-        sourceHarnessId: harnessIdSchema.parse(parent.harnessId),
-        targetHarnessId: harnessIdSchema.parse(targetHarnessId),
-        status: "creating",
-        ...input.requestId ? { requestId: input.requestId } : {},
-        taskDigest: digest2
-      });
-      const opened = await adapter.open({
-        kind: "create",
-        cwd: record3.cwd,
-        environment: { ...this.#environment, [DELEGATION_THREAD_ID_ENV]: childThreadId },
-        executionPolicy: "unattended-full-access",
-        ...input.model ? { model: input.model } : {},
-        ...input.thinkingOptionId ? { thinkingOptionId: input.thinkingOptionId } : {}
-      });
-      if (!opened.ok) throw new DelegationControlError("DELEGATION_FAILED", opened.error.message);
-      session = opened.value;
-      if (session.initialState.nativeRef) {
-        record3 = await this.#repository.commitNative(
-          record3.hostThreadId,
-          session.initialState.nativeRef
-        );
-      }
-      const threadValue = externalThreadValue({
-        record: record3,
-        turns: [],
-        sessionId: record3.hostThreadId,
-        running: true
-      });
-      const thread = this.#registerExternalThread({
-        record: record3,
-        session,
-        sessionId: record3.hostThreadId,
-        thread: threadValue,
-        turns: [],
-        ...input.model ? { requestedModel: input.model } : {},
-        ...input.thinkingOptionId ? { requestedThinkingOptionId: input.thinkingOptionId } : {},
-        ...session.initialState.nativeRef ? {} : { restoredState: session.initialState }
-      });
-      const beforeRevision = thread.stateObserver.revision;
-      await this.#startExternalTurn(thread, input.task, turnId);
-      if (!thread.record.nativeSessionRef) {
-        const deadline = Date.now() + NATIVE_REF_TIMEOUT_MS;
-        let revision = beforeRevision;
-        while (!thread.record.nativeSessionRef) {
-          const remaining = deadline - Date.now();
-          if (remaining <= 0) {
-            throw new Error("Target Harness Native Session identity was not persisted");
+    return this.#externalRuntime.idleRelease.runOperation(childThreadId, async () => {
+      try {
+        delegation = await this.#repository.createDelegation({
+          delegationId,
+          parentHostThreadId: hostThreadIdSchema.parse(parentThreadId),
+          childHostThreadId: childThreadId,
+          sourceHarnessId: harnessIdSchema.parse(parent.harnessId),
+          targetHarnessId: harnessIdSchema.parse(targetHarnessId),
+          status: "creating",
+          ...input.requestId ? { requestId: input.requestId } : {},
+          taskDigest: digest2
+        });
+        const opened = await adapter.open({
+          kind: "create",
+          cwd: record3.cwd,
+          environment: { ...this.#environment, [DELEGATION_THREAD_ID_ENV]: childThreadId },
+          executionPolicy: "unattended-full-access",
+          ...input.model ? { model: input.model } : {},
+          ...input.thinkingOptionId ? { thinkingOptionId: input.thinkingOptionId } : {}
+        });
+        if (!opened.ok) throw new DelegationControlError("DELEGATION_FAILED", opened.error.message);
+        session = opened.value;
+        if (session.initialState.nativeRef) {
+          record3 = await this.#repository.commitNative(
+            record3.hostThreadId,
+            session.initialState.nativeRef
+          );
+        }
+        const threadValue = externalThreadValue({
+          record: record3,
+          turns: [],
+          sessionId: record3.hostThreadId,
+          running: true
+        });
+        const thread = this.#registerExternalThread({
+          record: record3,
+          session,
+          sessionId: record3.hostThreadId,
+          thread: threadValue,
+          turns: [],
+          ...input.model ? { requestedModel: input.model } : {},
+          ...input.thinkingOptionId ? { requestedThinkingOptionId: input.thinkingOptionId } : {},
+          ...session.initialState.nativeRef ? {} : { restoredState: session.initialState }
+        });
+        const beforeRevision = thread.stateObserver.revision;
+        await this.#startExternalTurn(thread, input.task, turnId);
+        if (!thread.record.nativeSessionRef) {
+          const deadline = Date.now() + NATIVE_REF_TIMEOUT_MS;
+          let revision = beforeRevision;
+          while (!thread.record.nativeSessionRef) {
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) {
+              throw new Error("Target Harness Native Session identity was not persisted");
+            }
+            await thread.stateObserver.waitForChange(revision, remaining);
+            revision = thread.stateObserver.revision;
           }
-          await thread.stateObserver.waitForChange(revision, remaining);
-          revision = thread.stateObserver.revision;
         }
+        await this.#repository.setDelegationStatus(delegationId, "running");
+        await this.#notifyThreadStarted(thread.thread);
+        return {
+          ...this.#result(delegationId, childThreadId, turnId, targetHarnessId, "running", {
+            requested: {
+              ...input.model ? { model: input.model } : {},
+              ...input.thinkingOptionId ? { thinkingOptionId: input.thinkingOptionId } : {}
+            },
+            effective: {
+              ...thread.stateObserver.state.effectiveModel ? { effectiveModel: thread.stateObserver.state.effectiveModel } : {},
+              ...thread.stateObserver.state.resolvedModelLabel ? { resolvedModelLabel: thread.stateObserver.state.resolvedModelLabel } : {},
+              ...thread.stateObserver.state.effectiveThinkingOptionId ? {
+                effectiveThinkingOptionId: thread.stateObserver.state.effectiveThinkingOptionId
+              } : {}
+            }
+          }),
+          cwd: record3.cwd,
+          parentThreadId
+        };
+      } catch (error51) {
+        if (session) await session.close().catch(() => void 0);
+        this.#externalRuntime.remove(childThreadId);
+        if (delegation)
+          await this.#repository.removeDelegation(delegation.delegationId).catch(() => void 0);
+        await this.#repository.removeThread(childThreadId).catch(() => void 0);
+        if (error51 instanceof DelegationControlError) throw error51;
+        throw new DelegationControlError(
+          "DELEGATION_FAILED",
+          error51 instanceof Error ? error51.message : String(error51)
+        );
       }
-      await this.#repository.setDelegationStatus(delegationId, "running");
-      await this.#notifyThreadStarted(thread.thread);
-      return {
-        ...this.#result(delegationId, childThreadId, turnId, targetHarnessId, "running", {
-          requested: {
-            ...input.model ? { model: input.model } : {},
-            ...input.thinkingOptionId ? { thinkingOptionId: input.thinkingOptionId } : {}
-          },
-          effective: {
-            ...thread.stateObserver.state.effectiveModel ? { effectiveModel: thread.stateObserver.state.effectiveModel } : {},
-            ...thread.stateObserver.state.resolvedModelLabel ? { resolvedModelLabel: thread.stateObserver.state.resolvedModelLabel } : {},
-            ...thread.stateObserver.state.effectiveThinkingOptionId ? { effectiveThinkingOptionId: thread.stateObserver.state.effectiveThinkingOptionId } : {}
-          }
-        }),
-        cwd: record3.cwd,
-        parentThreadId
-      };
-    } catch (error51) {
-      if (session) await session.close().catch(() => void 0);
-      this.#externalRuntime.remove(childThreadId);
-      if (delegation)
-        await this.#repository.removeDelegation(delegation.delegationId).catch(() => void 0);
-      await this.#repository.removeThread(childThreadId).catch(() => void 0);
-      if (error51 instanceof DelegationControlError) throw error51;
-      throw new DelegationControlError(
-        "DELEGATION_FAILED",
-        error51 instanceof Error ? error51.message : String(error51)
-      );
-    }
+    });
   }
   async send(input) {
+    return this.#externalRuntime.idleRelease.runOperation(input.threadId, () => this.#send(input));
+  }
+  async #send(input) {
     if (!input.message?.trim()) {
       throw new DelegationControlError("INVALID_ARGUMENT", "Message must not be empty");
     }
@@ -26901,6 +27839,12 @@ var HarnessDelegationCoordinator = class {
     return this.#turnResult(thread.id, turnId, thread.harnessId);
   }
   async cancel(input) {
+    return this.#externalRuntime.idleRelease.runOperation(
+      input.threadId,
+      () => this.#cancel(input)
+    );
+  }
+  async #cancel(input) {
     const location = await this.#externalRuntime.locate(input.threadId);
     if (location.kind === "official") return this.#cancelOfficial(input);
     if (location.kind === "error") {
@@ -26925,6 +27869,9 @@ var HarnessDelegationCoordinator = class {
     return { threadId: thread.id, turnId, harnessId: thread.harnessId, cancelled: true };
   }
   async read(input) {
+    return this.#externalRuntime.idleRelease.runOperation(input.threadId, () => this.#read(input));
+  }
+  async #read(input) {
     validateReadOptions(input);
     const location = await this.#externalRuntime.locate(input.threadId);
     if (location.kind === "official") return this.#readOfficial(input);
@@ -27134,7 +28081,7 @@ var HarnessDelegationCoordinator = class {
 
 // packages/host-runtime/src/harness-plugin-loader.ts
 import { readdir as readdir3, realpath as realpath2 } from "node:fs/promises";
-import path9 from "node:path";
+import path10 from "node:path";
 import { pathToFileURL } from "node:url";
 
 // packages/host-runtime/src/harness-plugin-registry.ts
@@ -27172,16 +28119,16 @@ var HarnessPluginRegistry = class {
 
 // packages/host-runtime/src/plugin-files.ts
 import { open as open4, realpath, stat as stat2 } from "node:fs/promises";
-import path8 from "node:path";
+import path9 from "node:path";
 function inside(root, candidate) {
-  const relative = path8.relative(root, candidate);
-  return relative !== "" && !path8.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path8.sep}`);
+  const relative = path9.relative(root, candidate);
+  return relative !== "" && !path9.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path9.sep}`);
 }
 async function pluginResourcePath(root, relative) {
-  if (path8.isAbsolute(relative) || !inside(root, path8.resolve(root, relative))) {
+  if (path9.isAbsolute(relative) || !inside(root, path9.resolve(root, relative))) {
     throw new Error("Plugin resource escapes its root");
   }
-  const resolved = await realpath(path8.resolve(root, relative));
+  const resolved = await realpath(path9.resolve(root, relative));
   if (!inside(root, resolved) || !(await stat2(resolved)).isFile()) {
     throw new Error("Plugin resource must be a regular file inside its root");
   }
@@ -27263,10 +28210,11 @@ function unavailableAdapter(descriptor, code) {
     close: async () => void 0
   };
 }
-async function loadAdapter(candidate, context, timeoutMs, diagnose, warmup) {
+async function loadAdapter(candidate, context, timeoutMs, diagnose, warmup, signal) {
   const { manifest } = candidate;
   let expired = false;
   let timer;
+  let onAbort;
   const operation = (async () => {
     const entry = await pluginResourcePath(candidate.root, manifest.entry);
     if (!/\.(?:mjs|js)$/u.test(entry))
@@ -27292,7 +28240,7 @@ async function loadAdapter(candidate, context, timeoutMs, diagnose, warmup) {
     return value2;
   })();
   try {
-    const adapter = await Promise.race([
+    const races = [
       operation,
       new Promise((_, reject) => {
         timer = setTimeout(() => {
@@ -27300,15 +28248,31 @@ async function loadAdapter(candidate, context, timeoutMs, diagnose, warmup) {
           reject(new PluginLoadTimeout());
         }, timeoutMs);
       })
-    ]);
+    ];
+    if (signal) {
+      races.push(
+        new Promise((_, reject) => {
+          onAbort = () => {
+            expired = true;
+            reject(new PluginLoadCancelled());
+          };
+          if (signal.aborted) onAbort();
+          else signal.addEventListener("abort", onAbort, { once: true });
+        })
+      );
+    }
+    const adapter = await Promise.race(races);
     if (!adapter) throw new PluginLoadTimeout();
     return adapter;
   } finally {
     if (timer) clearTimeout(timer);
+    if (signal && onAbort) signal.removeEventListener("abort", onAbort);
   }
 }
 var PluginLoadTimeout = class extends Error {
 };
+var PluginLoadCancelled = class extends Error {
+};
 async function loadHarnessPlugins(options2) {
   const timeoutMs = options2.loadTimeoutMs ?? 1e4;
   if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 6e4) {
@@ -27326,7 +28290,7 @@ async function loadHarnessPlugins(options2) {
   const enabledIds = /* @__PURE__ */ new Set();
   const roots = /* @__PURE__ */ new Set();
   for (const configuredRoot of options2.roots) {
-    if (!path9.isAbsolute(configuredRoot)) {
+    if (!path10.isAbsolute(configuredRoot)) {
       diagnose({ code: "invalidRoot" });
       continue;
     }
@@ -27356,7 +28320,7 @@ async function loadHarnessPlugins(options2) {
       for (const directory of directories) {
         try {
           const file2 = await pluginResourcePath(root, `${directory.name}/manifest.json`);
-          const pluginRoot = await realpath2(path9.join(root, directory.name));
+          const pluginRoot = await realpath2(path10.join(root, directory.name));
           await pluginResourcePath(pluginRoot, "manifest.json");
           const manifest = harnessPluginManifestSchema.parse(
             JSON.parse(
@@ -27394,13 +28358,15 @@ async function loadHarnessPlugins(options2) {
     }
     pending.push(candidate);
   }
-  const deadline = Date.now() + timeoutMs;
+  if (options2.signal?.aborted) return registry2;
   let next = 0;
   const loaded = /* @__PURE__ */ new Map();
   const worker = async () => {
     for (; ; ) {
+      if (options2.signal?.aborted) return;
       const candidate = pending[next++];
       if (!candidate) return;
+      if (options2.signal?.aborted) return;
       const { manifest } = candidate;
       const descriptor = harnessPluginDescriptorSchema.parse({
         id: manifest.id,
@@ -27416,16 +28382,20 @@ async function loadHarnessPlugins(options2) {
       } else {
         try {
           if (manifest.icon) descriptor.icon = await readPluginIcon(candidate.root, manifest.icon);
-          const remaining = deadline - Date.now();
-          if (remaining <= 0) throw new PluginLoadTimeout();
           adapter = await loadAdapter(
             candidate,
             options2.context,
-            remaining,
+            timeoutMs,
             diagnose,
-            options2.warmup !== false
+            options2.warmup !== false,
+            options2.signal
           );
+          if (options2.signal?.aborted) {
+            await adapter.close().catch(() => diagnose({ id: manifest.id, code: "cleanupFailed" }));
+            return;
+          }
         } catch (error51) {
+          if (error51 instanceof PluginLoadCancelled) return;
           failure = error51 instanceof PluginLoadTimeout ? "loadTimeout" : "loadFailed";
           adapter = unavailableAdapter(descriptor, failure);
         }
@@ -27633,7 +28603,7 @@ var SingleNativeCodexAccount = class {
 
 // packages/host-runtime/src/account/codex-home-auth.ts
 import { readFile as readFile5 } from "node:fs/promises";
-import path10 from "node:path";
+import path11 from "node:path";
 var CODEX_API_AUTH_IDENTITY_FALLBACK = "BANK OF TOKEN";
 function tomlUnquote(value2) {
   const trimmed = value2.trim();
@@ -27779,10 +28749,10 @@ function inspectCodexApiUsageSource(input) {
   return { baseUrl, apiKey };
 }
 async function inspectCodexHomeAuth(codexHome) {
-  const root = path10.resolve(codexHome);
+  const root = path11.resolve(codexHome);
   const [configToml, authJson] = await Promise.all([
-    readOptionalUtf8(path10.join(root, "config.toml")),
-    readOptionalUtf8(path10.join(root, "auth.json"))
+    readOptionalUtf8(path11.join(root, "config.toml")),
+    readOptionalUtf8(path11.join(root, "auth.json"))
   ]);
   return inspectCodexAuthDocuments({
     ...configToml ? { configToml } : {},
@@ -27790,10 +28760,10 @@ async function inspectCodexHomeAuth(codexHome) {
   });
 }
 async function inspectCodexHomeApiUsageSource(codexHome, env = process.env) {
-  const root = path10.resolve(codexHome);
+  const root = path11.resolve(codexHome);
   const [configToml, authJson] = await Promise.all([
-    readOptionalUtf8(path10.join(root, "config.toml")),
-    readOptionalUtf8(path10.join(root, "auth.json"))
+    readOptionalUtf8(path11.join(root, "config.toml")),
+    readOptionalUtf8(path11.join(root, "auth.json"))
   ]);
   return inspectCodexApiUsageSource({
     ...configToml ? { configToml } : {},
@@ -28835,25 +29805,25 @@ function resolveExternalSessionTreeIds(records) {
   const resolve = (start) => {
     const cached2 = resolved.get(start.hostThreadId);
     if (cached2) return cached2;
-    const path25 = [];
+    const path26 = [];
     const visited = /* @__PURE__ */ new Set();
     let current = start;
     while (true) {
       const known = resolved.get(current.hostThreadId);
       if (known) {
-        for (const record3 of path25) resolved.set(record3.hostThreadId, known);
+        for (const record3 of path26) resolved.set(record3.hostThreadId, known);
         return known;
       }
       if (visited.has(current.hostThreadId)) {
         throw new Error("External Thread Fork tree contains a cycle");
       }
       visited.add(current.hostThreadId);
-      path25.push(current);
+      path26.push(current);
       const sourceId = current.subagent?.parentHostThreadId ?? current.forkSource?.hostThreadId;
       const source = sourceId ? byId.get(sourceId) : void 0;
       if (!source) {
         const root = current.hostThreadId;
-        for (const record3 of path25) resolved.set(record3.hostThreadId, root);
+        for (const record3 of path26) resolved.set(record3.hostThreadId, root);
         return root;
       }
       current = source;
@@ -29189,6 +30159,9 @@ function isHostApprovalRequestId(value2) {
 function isHostQuestionRequestId(value2) {
   return typeof value2 === "number" && Number.isSafeInteger(value2) && value2 >= HOST_QUESTION_REQUEST_ID_MIN && value2 <= HOST_QUESTION_REQUEST_ID_MAX;
 }
+function jsonRpcResponseFailed(value2) {
+  return value2.error != null;
+}
 function classifyCreateRequestRoute(request, defaultAgent) {
   const route = decodeCreateRoute(request);
   if (!route) return null;
@@ -29291,6 +30264,9 @@ var AppServerHost = class {
   #runningSubagentsByParent = /* @__PURE__ */ new Map();
   #pendingExternalCommandRequests = /* @__PURE__ */ new Set();
   #closeRequested = false;
+  #pluginLoadAbort = new AbortController();
+  #pluginLoading;
+  #desktopRequests = new DesktopRequestQueue();
   #drainActiveWorkOnInputEnd = false;
   #desktopInputEnded = false;
   constructor(options2) {
@@ -29302,7 +30278,7 @@ var AppServerHost = class {
     };
     this.#writer = new OrderedWriter(this.#options.desktopOutput);
     const environment = this.#options.environment ?? process.env;
-    const permanentHome = path11.resolve(environment.CODEX_HOME ?? path11.join(os2.homedir(), ".codex"));
+    const permanentHome = path12.resolve(environment.CODEX_HOME ?? path12.join(os2.homedir(), ".codex"));
     this.#ownsOfficialRuntimeScope = options2.officialRuntimeScope === void 0;
     this.#officialRuntimeScope = options2.officialRuntimeScope ?? new OfficialRuntimeScope({
       diagnosticOutput: this.#options.diagnosticOutput,
@@ -29373,7 +30349,24 @@ var AppServerHost = class {
       environment: this.#options.environment ?? process.env,
       repository: this.#repository,
       consumeOutputs: (thread) => this.#consumeHarnessOutputs(thread),
-      diagnose: (error51) => this.#diagnose(error51)
+      diagnose: (error51) => this.#diagnose(error51),
+      subagentRunning: (threadId2) => this.#subagentThreadStatuses.get(threadId2) === "active",
+      idleRelease: {
+        queue: this.#desktopRequests,
+        onClosed: async (thread) => {
+          for (const pending of [...this.#pendingDesktopApprovals.values()]) {
+            if (pending.thread === thread)
+              await this.#resolveDesktopApproval(pending.interaction.interactionId);
+          }
+          for (const pending of [...this.#pendingDesktopQuestions.values()]) {
+            if (pending.thread === thread)
+              await this.#resolveDesktopQuestion(pending.interaction.interactionId);
+          }
+        },
+        canRelease: (thread) => !this.#hasRunningSubagents(thread.id) && !this.#externalSteering.hasPending(thread.id) && !this.#pendingExternalCommandRequests.has(thread.id) && ![...this.#pendingDesktopApprovals.values()].some(
+          (pending) => pending.thread === thread
+        ) && ![...this.#pendingDesktopQuestions.values()].some((pending) => pending.thread === thread)
+      }
     });
     this.#delegationCoordinator = new HarnessDelegationCoordinator({
       adapters: this.#externalAdapters,
@@ -29393,14 +30386,14 @@ var AppServerHost = class {
       activeOfficialParents: () => [...this.#activeOfficialTurns.keys()]
     });
     const unregisterDelegationApi = options2.onDelegationApi?.({
-      listHarnesses: () => this.#delegationCoordinator.listHarnesses(),
-      inspect: (input) => this.#delegationCoordinator.inspect(input),
-      start: (input) => this.#delegationCoordinator.start(input),
-      send: (input) => this.#delegationCoordinator.send(input),
-      cancel: (input) => this.#delegationCoordinator.cancel(input),
-      read: (input) => this.#delegationCoordinator.read(input),
-      wait: (input) => this.#delegationCoordinator.wait(input),
-      list: (input) => this.#delegationCoordinator.list(input),
+      listHarnesses: () => this.#waitForPlugins().then(() => this.#delegationCoordinator.listHarnesses()),
+      inspect: (input) => this.#waitForPlugins().then(() => this.#delegationCoordinator.inspect(input)),
+      start: (input) => this.#waitForPlugins().then(() => this.#delegationCoordinator.start(input)),
+      send: (input) => this.#waitForPlugins().then(() => this.#delegationCoordinator.send(input)),
+      cancel: (input) => this.#waitForPlugins().then(() => this.#delegationCoordinator.cancel(input)),
+      read: (input) => this.#waitForPlugins().then(() => this.#delegationCoordinator.read(input)),
+      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)
     });
@@ -29409,6 +30402,8 @@ var AppServerHost = class {
   close() {
     if (this.#closeRequested) return;
     this.#closeRequested = true;
+    this.#externalRuntime.idleRelease.disable();
+    this.#pluginLoadAbort.abort();
     this.#externalSteering.close();
     this.#signalActiveWorkChanged();
     this.#options.desktopInput.destroy();
@@ -29427,25 +30422,38 @@ var AppServerHost = class {
     if (typeof desktopInput.end === "function") desktopInput.end();
     else desktopInput.destroy();
   }
+  #waitForPlugins() {
+    return this.#pluginLoading ??= this.#loadInstalledPlugins().catch((error51) => {
+      this.#diagnose(`Harness plugin load failed: ${errorMessage3(error51)}`);
+    });
+  }
+  async #loadInstalledPlugins() {
+    if (!this.#options.pluginRoots || this.#pluginLoadAbort.signal.aborted) return;
+    const plugins = await loadHarnessPlugins({
+      roots: this.#options.pluginRoots,
+      context: this.#options.pluginContext ?? {
+        environment: this.#options.environment ?? process.env,
+        platform: process.platform,
+        managedRemoteHost: false
+      },
+      reservedIds: new Set(this.#externalAdapters.keys()),
+      signal: this.#pluginLoadAbort.signal,
+      diagnose: (diagnostic) => this.#diagnose(`Harness plugin: ${JSON.stringify(diagnostic)}`)
+    });
+    if (this.#pluginLoadAbort.signal.aborted) {
+      await plugins.close().catch((error51) => this.#diagnose(error51));
+      return;
+    }
+    this.#pluginDescriptors = plugins.list();
+    for (const [id2, adapter] of plugins.adapters) this.#externalAdapters.set(id2, adapter);
+  }
   async run() {
     try {
-      if (this.#options.pluginRoots) {
-        const plugins = await loadHarnessPlugins({
-          roots: this.#options.pluginRoots,
-          context: this.#options.pluginContext ?? {
-            environment: this.#options.environment ?? process.env,
-            platform: process.platform,
-            managedRemoteHost: false
-          },
-          reservedIds: new Set(this.#externalAdapters.keys()),
-          diagnose: (diagnostic) => this.#diagnose(`Harness plugin: ${JSON.stringify(diagnostic)}`)
-        });
-        this.#pluginDescriptors = plugins.list();
-        for (const [id2, adapter] of plugins.adapters) this.#externalAdapters.set(id2, adapter);
-      }
       await this.#repository.initialize();
     } catch (error51) {
       this.#diagnose(`Host initialization failed: ${errorMessage3(error51)}`);
+      this.#pluginLoadAbort.abort();
+      await this.#pluginLoading;
       await Promise.allSettled(
         [...new Set(this.#externalAdapters.values())].map(
           (adapter) => Promise.resolve().then(() => adapter.close())
@@ -29469,6 +30477,7 @@ var AppServerHost = class {
         await this.#officialRuntimeScope.owner.stop().catch((closeError) => this.#diagnose(closeError));
       }
     }
+    void this.#waitForPlugins();
     if (this.#closeRequested) await this.#closeOfficialRuntime();
     try {
       void this.#officialRuntime.failure().then(async () => {
@@ -29483,7 +30492,12 @@ var AppServerHost = class {
       await this.#closeOfficialRuntime();
       return this.#closeRequested ? 0 : 1;
     } finally {
+      this.#pluginLoadAbort.abort();
       this.#externalSteering.close();
+      await this.#desktopRequests.drain();
+      this.#externalRuntime.idleRelease.stop();
+      await this.#externalRuntime.idleRelease.drain();
+      await this.#pluginLoading;
       const threads = this.#externalRuntime.values();
       await Promise.allSettled(threads.map(({ session }) => session.close()));
       await Promise.allSettled(threads.map(({ outputTask }) => outputTask));
@@ -29573,454 +30587,486 @@ var AppServerHost = class {
         }
         continue;
       }
-      if (request.method === "codexhost/update/check" || request.method === "codexhost/update/start" || request.method === "codexhost/update/status") {
-        this.#dispatchDesktopRequest(() => this.#handleUpdateRequest(request));
-        continue;
-      }
-      if (request.method === "codexhost/account/usage/inspect" || request.method === "codexhost/account/list" || request.method === "codexhost/account/refresh") {
-        this.#dispatchDesktopRequest(() => this.#handleCodexAccountRequest(request));
-        continue;
+      const threadId2 = isRecord14(request.params) && typeof request.params.threadId === "string" ? request.params.threadId : void 0;
+      this.#dispatchDesktopRequest(
+        () => this.#desktopRequests.run(
+          threadId2,
+          () => this.#externalRuntime.idleRelease.runOperation(
+            threadId2,
+            () => this.#handleDesktopRequest(request, frame)
+          )
+        )
+      );
+    }
+    this.#desktopInputEnded = true;
+    this.#externalRuntime.idleRelease.disable();
+    this.#pluginLoadAbort.abort();
+    await this.#desktopRequests.drain();
+    this.#externalSteering.close();
+    if (this.#drainActiveWorkOnInputEnd) await this.#waitForActiveWorkToDrain();
+    await this.#closeOfficialRuntime();
+  }
+  async #handleDesktopRequest(request, frame) {
+    if (this.#closeRequested) return;
+    if (request.method === LOADED_SESSIONS_METHOD) {
+      await this.#writer.json(
+        rpcEnvelope(request, { result: this.#externalRuntime.idleRelease.list() })
+      );
+      return;
+    }
+    if (request.method === IDLE_RELEASE_SETTINGS_METHOD) {
+      const parsed = idleReleaseSettingsSchema.safeParse(request.params);
+      if (!parsed.success) {
+        await this.#writer.json(rpcError(request, -32602, "Invalid idle release settings"));
+      } else {
+        const settings = this.#externalRuntime.idleRelease.configure(parsed.data);
+        await this.#writer.json(rpcEnvelope(request, { result: settings }));
       }
-      if (request.method === "codexhost/harness/accounts/sources") {
-        this.#dispatchDesktopRequest(async () => {
-          if (!harnessAccountSourceListParamsSchema.safeParse(request.params).success) {
-            await this.#writer.json(
-              rpcError(request, -32602, "Invalid Harness account source list params")
-            );
-            return;
-          }
-          const result = listHarnessAccountSources(
-            this.#externalAdapters.values(),
-            this.#pluginDescriptors
+      return;
+    }
+    if (request.method === "codexhost/update/check" || request.method === "codexhost/update/start" || request.method === "codexhost/update/status") {
+      this.#dispatchDesktopRequest(() => this.#handleUpdateRequest(request));
+      return;
+    }
+    if (request.method === "codexhost/account/usage/inspect" || request.method === "codexhost/account/list" || request.method === "codexhost/account/refresh") {
+      this.#dispatchDesktopRequest(() => this.#handleCodexAccountRequest(request));
+      return;
+    }
+    if (request.method === "codexhost/harness/accounts/sources") {
+      this.#dispatchDesktopRequest(async () => {
+        if (!harnessAccountSourceListParamsSchema.safeParse(request.params).success) {
+          await this.#writer.json(
+            rpcError(request, -32602, "Invalid Harness account source list params")
           );
-          await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(result) }));
-        });
-        continue;
-      }
-      if (request.method === "codexhost/harness/accounts/inspect") {
-        this.#dispatchDesktopRequest(async () => {
-          const params = harnessAccountInspectParamsSchema.safeParse(request.params);
-          if (!params.success) {
-            await this.#writer.json(
-              rpcError(request, -32602, "Invalid Harness account inspection params")
-            );
-            return;
-          }
-          const adapter = this.#externalAdapters.get(params.data.harnessId);
-          if (!adapter) {
-            await this.#writer.json(
-              rpcError(request, -32077, `Harness '${params.data.harnessId}' is unavailable`)
-            );
-            return;
-          }
-          const result = harnessAccountInspectResultSchema.parse(
-            await this.#inspectHarnessAccount(adapter, params.data.refresh === true)
+          return;
+        }
+        await this.#waitForPlugins();
+        const result = listHarnessAccountSources(
+          this.#externalAdapters.values(),
+          this.#pluginDescriptors
+        );
+        await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(result) }));
+      });
+      return;
+    }
+    if (request.method === "codexhost/harness/accounts/inspect") {
+      this.#dispatchDesktopRequest(async () => {
+        const params = harnessAccountInspectParamsSchema.safeParse(request.params);
+        if (!params.success) {
+          await this.#writer.json(
+            rpcError(request, -32602, "Invalid Harness account inspection params")
           );
-          await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(result) }));
-        });
-        continue;
-      }
-      if (request.method === "codexhost/harness/accounts/list") {
-        this.#dispatchDesktopRequest(async () => {
-          const params = harnessAccountListParamsSchema.safeParse(request.params);
-          if (!params.success) {
-            await this.#writer.json(
-              rpcError(request, -32602, "Invalid Harness account list params")
-            );
-            return;
-          }
-          const inspections = await Promise.all(
-            [...this.#externalAdapters.values()].map(
-              (adapter) => this.#inspectHarnessAccount(adapter, params.data.refresh === true)
-            )
+          return;
+        }
+        await this.#waitForPlugins();
+        const adapter = this.#externalAdapters.get(params.data.harnessId);
+        if (!adapter) {
+          await this.#writer.json(
+            rpcError(request, -32077, `Harness '${params.data.harnessId}' is unavailable`)
           );
-          const result = harnessAccountListResultSchema.parse({
-            accounts: inspections.flatMap(
-              ({ harnessId, harnessName: harnessName2, account }) => account ? [{ ...account, harnessId, harnessName: harnessName2 }] : []
-            )
-          });
-          await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(result) }));
-        });
-        continue;
-      }
-      if (request.method === "codexhost/harness/inspect") {
-        this.#dispatchDesktopRequest(() => this.#inspectHarness(request));
-        continue;
-      }
-      if (request.method === "codexhost/harness/web-ui/open") {
-        this.#dispatchDesktopRequest(() => this.#openHarnessWebUi(request));
-        continue;
-      }
-      if (request.method === "codexhost/harness/plugins/list") {
-        this.#dispatchDesktopRequest(async () => {
-          if (!harnessPluginListParamsSchema.safeParse(request.params).success) {
-            await this.#writer.json(
-              rpcError(request, -32602, "Invalid Harness plugin list params")
-            );
-            return;
-          }
-          const result = harnessPluginListResultSchema.parse({ plugins: this.#pluginDescriptors });
-          await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(result) }));
+          return;
+        }
+        const result = harnessAccountInspectResultSchema.parse(
+          await this.#inspectHarnessAccount(adapter, params.data.refresh === true)
+        );
+        await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(result) }));
+      });
+      return;
+    }
+    if (request.method === "codexhost/harness/accounts/list") {
+      this.#dispatchDesktopRequest(async () => {
+        const params = harnessAccountListParamsSchema.safeParse(request.params);
+        if (!params.success) {
+          await this.#writer.json(rpcError(request, -32602, "Invalid Harness account list params"));
+          return;
+        }
+        await this.#waitForPlugins();
+        const inspections = await Promise.all(
+          [...this.#externalAdapters.values()].map(
+            (adapter) => this.#inspectHarnessAccount(adapter, params.data.refresh === true)
+          )
+        );
+        const result = harnessAccountListResultSchema.parse({
+          accounts: inspections.flatMap(
+            ({ harnessId, harnessName: harnessName2, account }) => account ? [{ ...account, harnessId, harnessName: harnessName2 }] : []
+          )
         });
-        continue;
-      }
-      if (isSessionImportRequest(request.method)) {
-        this.#dispatchDesktopRequest(() => this.#handleSessionImport(request));
-        continue;
-      }
-      if (request.method === "codexhost/thread/fork") {
-        await this.#forkExternalThreadFromRenderer(request);
-        continue;
+        await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(result) }));
+      });
+      return;
+    }
+    if (request.method === "codexhost/harness/inspect") {
+      this.#dispatchDesktopRequest(() => this.#inspectHarness(request));
+      return;
+    }
+    if (request.method === "codexhost/harness/web-ui/open") {
+      this.#dispatchDesktopRequest(() => this.#openHarnessWebUi(request));
+      return;
+    }
+    if (request.method === "codexhost/harness/plugins/list") {
+      this.#dispatchDesktopRequest(async () => {
+        if (!harnessPluginListParamsSchema.safeParse(request.params).success) {
+          await this.#writer.json(rpcError(request, -32602, "Invalid Harness plugin list params"));
+          return;
+        }
+        await this.#waitForPlugins();
+        const result = harnessPluginListResultSchema.parse({ plugins: this.#pluginDescriptors });
+        await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(result) }));
+      });
+      return;
+    }
+    if (isSessionImportRequest(request.method)) {
+      this.#dispatchDesktopRequest(() => this.#handleSessionImport(request));
+      return;
+    }
+    if (request.method === "codexhost/thread/fork") {
+      await this.#forkExternalThreadFromRenderer(request);
+      return;
+    }
+    if (request.method === "codexhost/thread/inspect") {
+      await this.#inspectThread(request);
+      return;
+    }
+    if (request.method === "codexhost/thread/usage/inspect") {
+      await this.#inspectThreadUsage(request);
+      return;
+    }
+    if (request.method === "codexhost/thread/ownership/list") {
+      await this.#listThreadOwnership(request);
+      return;
+    }
+    if (request.method === "codexhost/thread/model/select") {
+      await this.#selectThreadModel(request);
+      return;
+    }
+    if (request.method === "codexhost/thread/thinking/select") {
+      await this.#selectThreadThinking(request);
+      return;
+    }
+    if (request.method === "codexhost/thread/permission-mode/select") {
+      await this.#selectThreadPermissionMode(request);
+      return;
+    }
+    if (request.method === "codexhost/harness/commands/inspect") {
+      const params = harnessCommandsInspectParamsSchema.safeParse(request.params);
+      if (!params.success) {
+        await this.#writer.json(
+          rpcError(request, -32602, "Invalid Harness command inspection params")
+        );
+      } else {
+        await this.#writeHarnessCommandCatalog(request, params.data.harnessId);
       }
-      if (request.method === "codexhost/thread/inspect") {
-        await this.#inspectThread(request);
-        continue;
+      return;
+    }
+    if (request.method === "codexhost/thread/commands/inspect") {
+      await this.#inspectThreadCommands(request);
+      return;
+    }
+    if (request.method === "codexhost/thread/command/execute") {
+      await this.#executeThreadCommand(request);
+      return;
+    }
+    if (request.method === "thread/list") {
+      let listRequest;
+      try {
+        const decoded = decodeThreadListRequest(request);
+        if (!decoded) throw new Error("Expected thread/list request");
+        listRequest = decoded;
+      } catch (error51) {
+        await this.#writer.json(rpcError(request, -32602, errorMessage3(error51)));
+        return;
       }
-      if (request.method === "codexhost/thread/usage/inspect") {
-        await this.#inspectThreadUsage(request);
-        continue;
+      if (!listRequest.supportsExternal) {
+        await this.#forwardOfficialRequest(request, frame);
+        return;
       }
-      if (request.method === "codexhost/thread/ownership/list") {
-        await this.#listThreadOwnership(request);
-        continue;
+      this.#dispatchDesktopRequest(() => this.#listThreads(request, listRequest));
+      return;
+    }
+    if (request.method === "thread/archive" || request.method === "thread/unarchive") {
+      let threadId2;
+      try {
+        const decoded = decodeThreadArchiveRequest(request);
+        if (!decoded) throw new Error(`Expected ${request.method} request`);
+        threadId2 = decoded.threadId;
+      } catch (error51) {
+        await this.#writer.json(rpcError(request, -32602, errorMessage3(error51)));
+        return;
       }
-      if (request.method === "codexhost/thread/model/select") {
-        await this.#selectThreadModel(request);
-        continue;
+      const location = await this.#locateExternalThread(threadId2);
+      if (await this.#writeResolutionError(request, location)) return;
+      if (location.kind === "official") {
+        await this.#forwardOfficialRequest(request, frame);
+        return;
       }
-      if (request.method === "codexhost/thread/thinking/select") {
-        await this.#selectThreadThinking(request);
-        continue;
+      if (location.kind === "external") {
+        await this.#setExternalThreadArchived(
+          request,
+          location,
+          request.method === "thread/archive"
+        );
       }
-      if (request.method === "codexhost/thread/permission-mode/select") {
-        await this.#selectThreadPermissionMode(request);
-        continue;
+      return;
+    }
+    if (request.method === "thread/metadata/update") {
+      let threadId2;
+      let decoded;
+      try {
+        const parsed = decodeThreadMetadataUpdateRequest(request);
+        if (!parsed) throw new Error("Expected thread/metadata/update request");
+        decoded = parsed;
+        threadId2 = decoded.threadId;
+      } catch (error51) {
+        await this.#writer.json(rpcError(request, -32602, errorMessage3(error51)));
+        return;
       }
-      if (request.method === "codexhost/harness/commands/inspect") {
-        const params = harnessCommandsInspectParamsSchema.safeParse(request.params);
-        if (!params.success) {
-          await this.#writer.json(
-            rpcError(request, -32602, "Invalid Harness command inspection params")
-          );
-        } else {
-          await this.#writeHarnessCommandCatalog(request, params.data.harnessId);
-        }
-        continue;
+      const location = await this.#locateExternalThread(threadId2);
+      if (await this.#writeResolutionError(request, location)) return;
+      if (location.kind === "official") {
+        await this.#forwardOfficialRequest(request, frame);
+        return;
       }
-      if (request.method === "codexhost/thread/commands/inspect") {
-        await this.#inspectThreadCommands(request);
-        continue;
+      if (location.kind !== "external") return;
+      if (decoded.isPinned === void 0 || decoded.gitInfo !== void 0) {
+        await this.#writer.json(
+          rpcError(request, -32078, "External Thread metadata updates are unsupported")
+        );
+        return;
       }
-      if (request.method === "codexhost/thread/command/execute") {
-        this.#dispatchDesktopRequest(() => this.#executeThreadCommand(request));
-        continue;
+      await this.#setExternalThreadPinned(request, location, decoded.isPinned ?? false);
+      return;
+    }
+    let createRoute;
+    try {
+      createRoute = classifyCreateRequestRoute(request, this.#options.defaultAgent);
+    } catch (error51) {
+      await this.#writer.json(rpcError(request, -32602, errorMessage3(error51)));
+      return;
+    }
+    if (createRoute) {
+      this.#options.onCreateRequestRoute?.(createRoute);
+      this.#options.onRequestRoute?.(
+        this.#routeObservationTracker.registerCreate(
+          request.id,
+          createRoute,
+          classifyThreadPurpose(request)
+        )
+      );
+    }
+    if (createRoute && createRoute.selectedHarness !== "codex") {
+      await this.#startExternalThread(request, createRoute.selectedHarness);
+      return;
+    }
+    if (request.method === "thread/fork") {
+      const params = isRecord14(request.params) ? request.params : {};
+      const resolution = typeof params.threadId === "string" ? await this.#resolveExternalThread(params.threadId) : { kind: "official" };
+      if (resolution.kind === "error") {
+        await this.#writer.json(rpcError(request, resolution.error.code, resolution.error.message));
+        return;
       }
-      if (request.method === "thread/list") {
-        let listRequest;
+      if (resolution.kind === "external") {
+        let fork;
         try {
-          const decoded = decodeThreadListRequest(request);
-          if (!decoded) throw new Error("Expected thread/list request");
-          listRequest = decoded;
+          const decoded = decodeThreadForkRequest(request);
+          if (!decoded) throw new Error("Expected thread/fork request");
+          fork = decoded;
         } catch (error51) {
           await this.#writer.json(rpcError(request, -32602, errorMessage3(error51)));
-          continue;
-        }
-        if (!listRequest.supportsExternal) {
-          await this.#forwardOfficialRequest(request, frame);
-          continue;
+          return;
         }
-        this.#dispatchDesktopRequest(() => this.#listThreads(request, listRequest));
-        continue;
+        await this.#forkExternalThread(request, resolution.thread, fork);
+        return;
       }
-      if (request.method === "thread/archive" || request.method === "thread/unarchive") {
-        let threadId2;
+    }
+    if (request.method === "thread/revert") {
+      const params = isRecord14(request.params) ? request.params : {};
+      const resolution = typeof params.threadId === "string" ? await this.#resolveExternalThread(params.threadId) : { kind: "official" };
+      if (resolution.kind === "error") {
+        await this.#writer.json(rpcError(request, resolution.error.code, resolution.error.message));
+        return;
+      }
+      if (resolution.kind === "external") {
+        let revert;
         try {
-          const decoded = decodeThreadArchiveRequest(request);
-          if (!decoded) throw new Error(`Expected ${request.method} request`);
-          threadId2 = decoded.threadId;
+          const decoded = decodeThreadRevertRequest(request);
+          if (!decoded) throw new Error("Expected thread/revert request");
+          revert = decoded;
         } catch (error51) {
           await this.#writer.json(rpcError(request, -32602, errorMessage3(error51)));
-          continue;
-        }
-        const location = await this.#locateExternalThread(threadId2);
-        if (await this.#writeResolutionError(request, location)) continue;
-        if (location.kind === "official") {
-          await this.#forwardOfficialRequest(request, frame);
-          continue;
-        }
-        if (location.kind === "external") {
-          await this.#setExternalThreadArchived(
-            request,
-            location,
-            request.method === "thread/archive"
-          );
+          return;
         }
-        continue;
+        await this.#revertExternalThread(request, resolution.thread, revert);
+        return;
+      }
+    }
+    if (request.method === "thread/rollback") {
+      const params = isRecord14(request.params) ? request.params : {};
+      const resolution = typeof params.threadId === "string" ? await this.#resolveExternalThread(params.threadId) : { kind: "official" };
+      if (resolution.kind === "error") {
+        await this.#writer.json(rpcError(request, resolution.error.code, resolution.error.message));
+        return;
       }
-      if (request.method === "thread/metadata/update") {
-        let threadId2;
-        let decoded;
+      if (resolution.kind === "external") {
+        let rollback;
         try {
-          const parsed2 = decodeThreadMetadataUpdateRequest(request);
-          if (!parsed2) throw new Error("Expected thread/metadata/update request");
-          decoded = parsed2;
-          threadId2 = decoded.threadId;
+          const decoded = decodeThreadRollbackRequest(request);
+          if (!decoded) throw new Error("Expected thread/rollback request");
+          rollback = decoded;
         } catch (error51) {
           await this.#writer.json(rpcError(request, -32602, errorMessage3(error51)));
-          continue;
-        }
-        const location = await this.#locateExternalThread(threadId2);
-        if (await this.#writeResolutionError(request, location)) continue;
-        if (location.kind === "official") {
-          await this.#forwardOfficialRequest(request, frame);
-          continue;
-        }
-        if (location.kind !== "external") continue;
-        if (decoded.isPinned === void 0 || decoded.gitInfo !== void 0) {
-          await this.#writer.json(
-            rpcError(request, -32078, "External Thread metadata updates are unsupported")
-          );
-          continue;
+          return;
         }
-        await this.#setExternalThreadPinned(request, location, decoded.isPinned ?? false);
-        continue;
+        await this.#rollbackExternalThread(request, resolution.thread, rollback);
+        return;
       }
-      let createRoute;
-      try {
-        createRoute = classifyCreateRequestRoute(request, this.#options.defaultAgent);
-      } catch (error51) {
-        await this.#writer.json(rpcError(request, -32602, errorMessage3(error51)));
-        continue;
+    }
+    if (request.method === "thread/turns/list" || request.method === "thread/items/list") {
+      const params = requestObject(request);
+      const resolution = typeof params.threadId === "string" ? await this.#resolveExternalThread(params.threadId) : { kind: "official" };
+      if (await this.#writeResolutionError(request, resolution)) return;
+      if (resolution.kind === "external") {
+        await this.#listExternalHistory(
+          request,
+          resolution.thread,
+          params,
+          resolution.historyFresh
+        );
+        return;
       }
-      if (createRoute) {
-        this.#options.onCreateRequestRoute?.(createRoute);
+    }
+    if (request.method === "turn/start") {
+      const params = requestObject(request);
+      const threadId2 = params.threadId;
+      const resolution = typeof threadId2 === "string" ? await this.#resolveExternalThread(threadId2) : { kind: "official" };
+      if (typeof threadId2 === "string") {
         this.#options.onRequestRoute?.(
-          this.#routeObservationTracker.registerCreate(
-            request.id,
-            createRoute,
-            classifyThreadPurpose(request)
+          this.#routeObservationTracker.observeTurn(
+            threadId2,
+            resolution.kind === "external" ? resolution.thread.harnessId : "codex"
           )
         );
       }
-      if (createRoute && createRoute.selectedHarness !== "codex") {
-        await this.#startExternalThread(request, createRoute.selectedHarness);
-        continue;
+      if (await this.#writeResolutionError(request, resolution)) return;
+      if (resolution.kind === "external") {
+        this.#dispatchDesktopRequest(
+          () => this.#startExternalTurn(request, resolution.thread),
+          resolution.thread.id
+        );
+        return;
       }
-      if (request.method === "thread/fork") {
-        const params = isRecord14(request.params) ? request.params : {};
-        const resolution = typeof params.threadId === "string" ? await this.#resolveExternalThread(params.threadId) : { kind: "official" };
-        if (resolution.kind === "error") {
-          await this.#writer.json(
-            rpcError(request, resolution.error.code, resolution.error.message)
-          );
-          continue;
-        }
-        if (resolution.kind === "external") {
-          let fork;
-          try {
-            const decoded = decodeThreadForkRequest(request);
-            if (!decoded) throw new Error("Expected thread/fork request");
-            fork = decoded;
-          } catch (error51) {
-            await this.#writer.json(rpcError(request, -32602, errorMessage3(error51)));
-            continue;
-          }
-          await this.#forkExternalThread(request, resolution.thread, fork);
-          continue;
-        }
+      if (typeof threadId2 === "string") {
+        this.#pendingOfficialTurnStarts.set(request.id, threadId2);
       }
-      if (request.method === "thread/revert") {
-        const params = isRecord14(request.params) ? request.params : {};
-        const resolution = typeof params.threadId === "string" ? await this.#resolveExternalThread(params.threadId) : { kind: "official" };
-        if (resolution.kind === "error") {
-          await this.#writer.json(
-            rpcError(request, resolution.error.code, resolution.error.message)
-          );
-          continue;
-        }
-        if (resolution.kind === "external") {
-          let revert;
-          try {
-            const decoded = decodeThreadRevertRequest(request);
-            if (!decoded) throw new Error("Expected thread/revert request");
-            revert = decoded;
-          } catch (error51) {
-            await this.#writer.json(rpcError(request, -32602, errorMessage3(error51)));
-            continue;
-          }
-          await this.#revertExternalThread(request, resolution.thread, revert);
-          continue;
-        }
+    }
+    if (request.method === "turn/steer") {
+      const params = requestObject(request);
+      const resolution = typeof params.threadId === "string" ? await this.#resolveExternalThread(params.threadId) : { kind: "official" };
+      if (await this.#writeResolutionError(request, resolution)) return;
+      if (resolution.kind === "external") {
+        this.#dispatchDesktopRequest(
+          () => this.#steerExternalTurn(request, resolution.thread),
+          resolution.thread.id
+        );
+        return;
       }
-      if (request.method === "thread/rollback") {
-        const params = isRecord14(request.params) ? request.params : {};
-        const resolution = typeof params.threadId === "string" ? await this.#resolveExternalThread(params.threadId) : { kind: "official" };
-        if (resolution.kind === "error") {
-          await this.#writer.json(
-            rpcError(request, resolution.error.code, resolution.error.message)
-          );
-          continue;
-        }
-        if (resolution.kind === "external") {
-          let rollback;
-          try {
-            const decoded = decodeThreadRollbackRequest(request);
-            if (!decoded) throw new Error("Expected thread/rollback request");
-            rollback = decoded;
-          } catch (error51) {
-            await this.#writer.json(rpcError(request, -32602, errorMessage3(error51)));
-            continue;
-          }
-          await this.#rollbackExternalThread(request, resolution.thread, rollback);
-          continue;
-        }
+    }
+    if (request.method === "turn/interrupt") {
+      const params = requestObject(request);
+      const resolution = typeof params.threadId === "string" ? await this.#resolveExternalThread(params.threadId) : { kind: "official" };
+      if (await this.#writeResolutionError(request, resolution)) return;
+      if (resolution.kind === "external") {
+        await this.#interruptExternalTurn(request, resolution.thread, params.turnId);
+        return;
+      }
+    }
+    if (request.method === "thread/read") {
+      const params = requestObject(request);
+      const location = typeof params.threadId === "string" ? await this.#locateExternalThread(params.threadId) : { kind: "official" };
+      if (location.kind === "error") {
+        await this.#writer.json(rpcError(request, location.error.code, location.error.message));
+        return;
       }
-      if (request.method === "thread/turns/list" || request.method === "thread/items/list") {
-        const params = requestObject(request);
-        const resolution = typeof params.threadId === "string" ? await this.#resolveExternalThread(params.threadId) : { kind: "official" };
-        if (await this.#writeResolutionError(request, resolution)) continue;
-        if (resolution.kind === "external") {
-          await this.#listExternalHistory(
+      if (location.kind === "official") {
+        await this.#forwardOfficialRequest(request, frame);
+        return;
+      }
+      if (params.includeTurns !== true) {
+        await this.#readExternalThreadMetadata(request, location);
+        return;
+      }
+      if (location.record.historyMode === "paginated") {
+        await this.#writer.json(
+          rpcError(request, -32602, "Paginated External Threads require thread/turns/list")
+        );
+        return;
+      }
+    }
+    if (request.method === "thread/read" || request.method === "thread/resume") {
+      const params = requestObject(request);
+      const resolution = typeof params.threadId === "string" ? await this.#resolveExternalThread(params.threadId) : { kind: "official" };
+      if (await this.#writeResolutionError(request, resolution)) return;
+      if (resolution.kind === "external") {
+        if (request.method === "thread/read") {
+          await this.#readExternalThread(
             request,
             resolution.thread,
-            params,
+            params.includeTurns === true,
             resolution.historyFresh
           );
-          continue;
-        }
-      }
-      if (request.method === "turn/start") {
-        const params = requestObject(request);
-        const threadId2 = params.threadId;
-        const resolution = typeof threadId2 === "string" ? await this.#resolveExternalThread(threadId2) : { kind: "official" };
-        if (typeof threadId2 === "string") {
-          this.#options.onRequestRoute?.(
-            this.#routeObservationTracker.observeTurn(
-              threadId2,
-              resolution.kind === "external" ? resolution.thread.harnessId : "codex"
-            )
+        } else {
+          await this.#resumeExternalThread(
+            request,
+            resolution.thread,
+            params,
+            resolution.historyFresh
           );
         }
-        if (await this.#writeResolutionError(request, resolution)) continue;
-        if (resolution.kind === "external") {
-          this.#dispatchDesktopRequest(() => this.#startExternalTurn(request, resolution.thread));
-          continue;
-        }
-        if (typeof threadId2 === "string") {
-          this.#pendingOfficialTurnStarts.set(request.id, threadId2);
-        }
-      }
-      if (request.method === "turn/steer") {
-        const params = requestObject(request);
-        const resolution = typeof params.threadId === "string" ? await this.#resolveExternalThread(params.threadId) : { kind: "official" };
-        if (await this.#writeResolutionError(request, resolution)) continue;
-        if (resolution.kind === "external") {
-          this.#dispatchDesktopRequest(() => this.#steerExternalTurn(request, resolution.thread));
-          continue;
-        }
-      }
-      if (request.method === "turn/interrupt") {
-        const params = requestObject(request);
-        const resolution = typeof params.threadId === "string" ? await this.#resolveExternalThread(params.threadId) : { kind: "official" };
-        if (await this.#writeResolutionError(request, resolution)) continue;
-        if (resolution.kind === "external") {
-          await this.#interruptExternalTurn(request, resolution.thread, params.turnId);
-          continue;
-        }
+        return;
       }
-      if (request.method === "thread/read") {
-        const params = requestObject(request);
-        const location = typeof params.threadId === "string" ? await this.#locateExternalThread(params.threadId) : { kind: "official" };
-        if (location.kind === "error") {
-          await this.#writer.json(rpcError(request, location.error.code, location.error.message));
-          continue;
-        }
+    }
+    if (request.method === "thread/unsubscribe") {
+      const params = requestObject(request);
+      if (typeof params.threadId === "string") {
+        const location = await this.#locateExternalThread(params.threadId);
+        if (await this.#writeResolutionError(request, location)) return;
         if (location.kind === "official") {
           await this.#forwardOfficialRequest(request, frame);
-          continue;
-        }
-        if (params.includeTurns !== true) {
-          await this.#readExternalThreadMetadata(request, location);
-          continue;
+          return;
         }
-        if (location.record.historyMode === "paginated") {
+        if (location.kind === "external") {
           await this.#writer.json(
-            rpcError(request, -32602, "Paginated External Threads require thread/turns/list")
+            rpcEnvelope(request, {
+              result: { status: location.thread ? "notSubscribed" : "notLoaded" }
+            })
           );
-          continue;
-        }
-      }
-      if (request.method === "thread/read" || request.method === "thread/resume") {
-        const params = requestObject(request);
-        const resolution = typeof params.threadId === "string" ? await this.#resolveExternalThread(params.threadId) : { kind: "official" };
-        if (await this.#writeResolutionError(request, resolution)) continue;
-        if (resolution.kind === "external") {
-          if (request.method === "thread/read") {
-            await this.#readExternalThread(
-              request,
-              resolution.thread,
-              params.includeTurns === true,
-              resolution.historyFresh
-            );
-          } else {
-            await this.#resumeExternalThread(
-              request,
-              resolution.thread,
-              params,
-              resolution.historyFresh
-            );
-          }
-          continue;
-        }
-      }
-      if (request.method === "thread/unsubscribe") {
-        const params = requestObject(request);
-        if (typeof params.threadId === "string") {
-          const location = await this.#locateExternalThread(params.threadId);
-          if (await this.#writeResolutionError(request, location)) continue;
-          if (location.kind === "official") {
-            await this.#forwardOfficialRequest(request, frame);
-            continue;
-          }
-          if (location.kind === "external") {
-            await this.#writer.json(
-              rpcEnvelope(request, {
-                result: { status: location.thread ? "notSubscribed" : "notLoaded" }
-              })
-            );
-            continue;
-          }
+          return;
         }
       }
-      if (request.method === "thread/name/set" || request.method === "thread/delete") {
-        const params = requestObject(request);
-        const location = typeof params.threadId === "string" ? await this.#locateExternalThread(params.threadId) : { kind: "official" };
-        if (await this.#writeResolutionError(request, location)) continue;
-        if (location.kind === "external") {
-          if (request.method === "thread/name/set") {
-            await this.#setExternalThreadName(request, location, params.name);
-          } else {
-            await this.#deleteExternalThread(request, location);
-          }
-          continue;
+    }
+    if (request.method === "thread/name/set" || request.method === "thread/delete") {
+      const params = requestObject(request);
+      const location = typeof params.threadId === "string" ? await this.#locateExternalThread(params.threadId) : { kind: "official" };
+      if (await this.#writeResolutionError(request, location)) return;
+      if (location.kind === "external") {
+        if (request.method === "thread/name/set") {
+          await this.#setExternalThreadName(request, location, params.name);
+        } else {
+          await this.#deleteExternalThread(request, location);
         }
+        return;
       }
-      if (request.method.startsWith("thread/") && !EXPLICIT_EXTERNAL_THREAD_METHODS.has(request.method) && isRecord14(request.params) && typeof request.params.threadId === "string") {
-        const location = await this.#locateExternalThread(request.params.threadId);
-        if (await this.#writeResolutionError(request, location)) continue;
-        if (location.kind === "external") {
-          await this.#writer.json(
-            rpcError(request, -32076, `External Thread does not support ${request.method}`)
-          );
-          continue;
-        }
+    }
+    if (request.method.startsWith("thread/") && !EXPLICIT_EXTERNAL_THREAD_METHODS.has(request.method) && isRecord14(request.params) && typeof request.params.threadId === "string") {
+      const location = await this.#locateExternalThread(request.params.threadId);
+      if (await this.#writeResolutionError(request, location)) return;
+      if (location.kind === "external") {
+        await this.#writer.json(
+          rpcError(request, -32076, `External Thread does not support ${request.method}`)
+        );
+        return;
       }
-      await this.#forwardOfficialRequest(request, frame);
     }
-    this.#desktopInputEnded = true;
-    this.#externalSteering.close();
-    if (this.#drainActiveWorkOnInputEnd) await this.#waitForActiveWorkToDrain();
-    await this.#closeOfficialRuntime();
+    await this.#forwardOfficialRequest(request, frame);
   }
   async #forwardOfficialNonRequest(value2, frame) {
     const response = isRecord14(value2) ? value2 : null;
@@ -30731,6 +31777,7 @@ var AppServerHost = class {
       await this.#writer.json(rpcError(request, -32602, "Invalid Harness inspection params"));
       return;
     }
+    await this.#waitForPlugins();
     const registered = [...this.#externalAdapters].find(
       ([harnessId]) => harnessId === params.data.harnessId
     );
@@ -30770,6 +31817,7 @@ var AppServerHost = class {
       await this.#writer.json(rpcError(request, -32602, "Invalid Harness Web UI params"));
       return;
     }
+    await this.#waitForPlugins();
     const adapter = [...this.#externalAdapters].find(
       ([harnessId]) => harnessId === params.data.harnessId
     )?.[1];
@@ -30792,6 +31840,7 @@ var AppServerHost = class {
     }
   }
   async #handleSessionImport(request) {
+    await this.#waitForPlugins();
     this.#sessionImportRequests ??= new SessionImportRequests({
       adapters: this.#externalAdapters,
       descriptors: () => this.#pluginDescriptors,
@@ -30931,6 +31980,7 @@ var AppServerHost = class {
     await this.#writeHarnessCommandCatalog(request, location.record.harnessId);
   }
   async #writeHarnessCommandCatalog(request, harnessId) {
+    await this.#waitForPlugins();
     const adapter = this.#externalAdapters.get(harnessId);
     if (!adapter) {
       await this.#writer.json(rpcError(request, -32077, `Harness '${harnessId}' is unavailable`));
@@ -30955,7 +32005,12 @@ var AppServerHost = class {
       await this.#writer.json(rpcError(request, -32078, "Thread is not externally owned"));
       return;
     }
-    const thread = resolution.thread;
+    this.#dispatchDesktopRequest(
+      () => this.#executeResolvedThreadCommand(request, resolution.thread, params.data),
+      resolution.thread.id
+    );
+  }
+  async #executeResolvedThreadCommand(request, thread, params) {
     if (thread.running || this.#externalSteering.hasPending(thread.id) || this.#pendingExternalCommandRequests.has(thread.id)) {
       await this.#writer.json(
         rpcError(request, -32072, "External Thread already has an active operation")
@@ -30976,13 +32031,13 @@ var AppServerHost = class {
         await this.#writer.json(rpcError(request, -32078, catalog.error.message));
         return;
       }
-      const descriptor = catalog.value.commands.find(({ id: id2 }) => id2 === params.data.commandId);
+      const descriptor = catalog.value.commands.find(({ id: id2 }) => id2 === params.commandId);
       if (!descriptor) {
         await this.#writer.json(
           rpcError(
             request,
             -32078,
-            `External Harness does not expose command '${params.data.commandId}'`
+            `External Harness does not expose command '${params.commandId}'`
           )
         );
         return;
@@ -30991,9 +32046,9 @@ var AppServerHost = class {
         await this.#startExternalCommand(
           request,
           thread,
-          params.data.commandId,
-          params.data.arguments,
-          params.data.turnId,
+          params.commandId,
+          params.arguments,
+          params.turnId,
           "command"
         );
       } catch (error51) {
@@ -31308,6 +32363,7 @@ var AppServerHost = class {
     }
   }
   async #startExternalThread(request, harnessId) {
+    await this.#waitForPlugins();
     const adapter = this.#externalAdapters.get(harnessId);
     if (!adapter) {
       this.#routeObservationTracker.rejectCreate(request.id);
@@ -31364,60 +32420,64 @@ var AppServerHost = class {
       return;
     }
     const session = sessionResult.value;
-    try {
-      if (session.initialState.nativeRef) {
-        record3 = await this.#repository.commitNative(
-          record3.hostThreadId,
-          session.initialState.nativeRef
+    await this.#externalRuntime.idleRelease.runOperation(record3.hostThreadId, async () => {
+      try {
+        if (session.initialState.nativeRef) {
+          record3 = await this.#repository.commitNative(
+            record3.hostThreadId,
+            session.initialState.nativeRef
+          );
+        }
+        const thread = externalThreadValue({
+          record: record3,
+          turns: [],
+          sessionId: record3.hostThreadId
+        });
+        const externalThread = this.#registerExternalThread({
+          record: record3,
+          session,
+          sessionId: record3.hostThreadId,
+          thread,
+          turns: [],
+          ...requestedModel ? { requestedModel } : {},
+          ...requestedThinkingOptionId ? { requestedThinkingOptionId } : {},
+          ...requestedPermissionModeId ? { requestedPermissionModeId } : {}
+        });
+        this.#routeObservationTracker.bindCreatedThread(request.id, externalThread.id);
+        await this.#writer.json(
+          rpcEnvelope(request, {
+            result: {
+              thread,
+              model: transportModelId,
+              modelProvider: "codexhost",
+              cwd,
+              approvalPolicy: typeof params.approvalPolicy === "string" ? params.approvalPolicy : "never",
+              approvalsReviewer: "user",
+              sandbox: sandboxResult(params),
+              reasoningEffort: "medium",
+              serviceTier: "flex",
+              multiAgentMode: "explicitRequestOnly",
+              activePermissionProfile: null,
+              runtimeWorkspaceRoots: Array.isArray(params.runtimeWorkspaceRoots) ? params.runtimeWorkspaceRoots : [],
+              instructionSources: []
+            }
+          })
+        );
+        await this.#writer.json({
+          method: "thread/started",
+          emittedAtMs: Date.now(),
+          params: { thread }
+        });
+      } catch {
+        this.#externalRuntime.remove(record3.hostThreadId);
+        this.#routeObservationTracker.forgetThread(record3.hostThreadId);
+        await session.close().catch(() => void 0);
+        await this.#repository.removeProvisional(record3.hostThreadId).catch(() => void 0);
+        await this.#writer.json(
+          rpcError(request, -32081, "External Thread could not be persisted")
         );
       }
-      const thread = externalThreadValue({
-        record: record3,
-        turns: [],
-        sessionId: record3.hostThreadId
-      });
-      const externalThread = this.#registerExternalThread({
-        record: record3,
-        session,
-        sessionId: record3.hostThreadId,
-        thread,
-        turns: [],
-        ...requestedModel ? { requestedModel } : {},
-        ...requestedThinkingOptionId ? { requestedThinkingOptionId } : {},
-        ...requestedPermissionModeId ? { requestedPermissionModeId } : {}
-      });
-      this.#routeObservationTracker.bindCreatedThread(request.id, externalThread.id);
-      await this.#writer.json(
-        rpcEnvelope(request, {
-          result: {
-            thread,
-            model: transportModelId,
-            modelProvider: "codexhost",
-            cwd,
-            approvalPolicy: typeof params.approvalPolicy === "string" ? params.approvalPolicy : "never",
-            approvalsReviewer: "user",
-            sandbox: sandboxResult(params),
-            reasoningEffort: "medium",
-            serviceTier: "flex",
-            multiAgentMode: "explicitRequestOnly",
-            activePermissionProfile: null,
-            runtimeWorkspaceRoots: Array.isArray(params.runtimeWorkspaceRoots) ? params.runtimeWorkspaceRoots : [],
-            instructionSources: []
-          }
-        })
-      );
-      await this.#writer.json({
-        method: "thread/started",
-        emittedAtMs: Date.now(),
-        params: { thread }
-      });
-    } catch {
-      this.#externalRuntime.remove(record3.hostThreadId);
-      this.#routeObservationTracker.forgetThread(record3.hostThreadId);
-      await session.close().catch(() => void 0);
-      await this.#repository.removeProvisional(record3.hostThreadId).catch(() => void 0);
-      await this.#writer.json(rpcError(request, -32081, "External Thread could not be persisted"));
-    }
+    });
   }
   #registerExternalThread(input) {
     return this.#externalRuntime.register(input);
@@ -31425,7 +32485,10 @@ var AppServerHost = class {
   #locateExternalThread(threadId2) {
     return this.#externalRuntime.locate(threadId2);
   }
-  #resolveExternalThread(threadId2) {
+  async #resolveExternalThread(threadId2) {
+    const location = await this.#locateExternalThread(threadId2);
+    if (location.kind !== "external") return location;
+    await this.#waitForPlugins();
     return this.#externalRuntime.resolve(threadId2);
   }
   async #writeResolutionError(request, resolution) {
@@ -31950,12 +33013,16 @@ var AppServerHost = class {
     try {
       for await (const output of thread.session.outputs) {
         try {
-          await this.#projectHarnessOutput(thread, output);
+          await this.#externalRuntime.idleRelease.consumeOutput(
+            thread,
+            () => this.#projectHarnessOutput(thread, output)
+          );
         } catch (error51) {
           await this.#recoverFailedProjection(thread, error51);
         }
       }
     } catch (error51) {
+      this.#externalRuntime.idleRelease.outputFailed(thread);
       this.#diagnose(error51);
     } finally {
       this.#externalSteering.fault(
@@ -32195,6 +33262,7 @@ var AppServerHost = class {
     if (event.type === "turn.completed" && !ephemeralTurn) {
       const persistenceError = await this.#persistTerminalIdentity(thread, event);
       if (persistenceError) {
+        this.#externalRuntime.idleRelease.outputFailed(thread);
         event = {
           type: "turn.completed",
           turnId: event.turnId,
@@ -32421,32 +33489,37 @@ var AppServerHost = class {
   }
   async #handleDesktopApprovalResponse(value2) {
     if (!isRecord14(value2) || !isHostApprovalRequestId(value2.id)) return false;
-    const pending = this.#pendingDesktopApprovals.get(value2.id);
+    const requestId = value2.id;
+    const pending = this.#pendingDesktopApprovals.get(requestId);
     if (!pending) return true;
-    this.#pendingDesktopApprovals.delete(value2.id);
-    let response;
-    try {
-      response = "error" in value2 ? pending.projection.denyResponse : pending.projection.parseResponse(value2.result);
-    } catch (error51) {
-      this.#diagnose(error51);
-      response = pending.projection.denyResponse;
-    }
-    const result = await pending.thread.session.execute({
-      type: "interaction.respond",
-      interactionId: pending.interaction.interactionId,
-      response
-    });
-    if (!result.ok && result.error.code !== "invalidState") {
-      this.#diagnose(`Approval response failed: ${result.error.message}`);
-      const cancelled = await pending.thread.session.execute({
-        type: "turn.cancel",
-        turnId: pending.interaction.turnId
+    return this.#externalRuntime.idleRelease.runOperation(pending.thread.id, async () => {
+      if (this.#externalRuntime.get(pending.thread.id) !== pending.thread || this.#externalRuntime.idleRelease.failure(pending.thread))
+        return true;
+      this.#pendingDesktopApprovals.delete(requestId);
+      let response;
+      try {
+        response = jsonRpcResponseFailed(value2) ? pending.projection.denyResponse : pending.projection.parseResponse(value2.result);
+      } catch (error51) {
+        this.#diagnose(error51);
+        response = pending.projection.denyResponse;
+      }
+      const result = await pending.thread.session.execute({
+        type: "interaction.respond",
+        interactionId: pending.interaction.interactionId,
+        response
       });
-      if (!cancelled.ok && cancelled.error.code !== "invalidState") {
-        this.#diagnose(`Approval fail-closed cancellation failed: ${cancelled.error.message}`);
+      if (!result.ok && result.error.code !== "invalidState") {
+        this.#diagnose(`Approval response failed: ${result.error.message}`);
+        const cancelled = await pending.thread.session.execute({
+          type: "turn.cancel",
+          turnId: pending.interaction.turnId
+        });
+        if (!cancelled.ok && cancelled.error.code !== "invalidState") {
+          this.#diagnose(`Approval fail-closed cancellation failed: ${cancelled.error.message}`);
+        }
       }
-    }
-    return true;
+      return true;
+    });
   }
   async #denyApproval(thread, interaction) {
     const denyActions = interaction.actions.filter(({ effect }) => effect === "deny");
@@ -32525,7 +33598,7 @@ var AppServerHost = class {
     };
     if (timeoutMs !== null) {
       pending.timeout = setTimeout(() => {
-        void this.#cancelExpiredQuestion(requestId);
+        void this.#cancelExpiredQuestion(requestId).catch((error51) => this.#diagnose(error51));
       }, timeoutMs);
     }
     this.#pendingDesktopQuestions.set(requestId, pending);
@@ -32543,39 +33616,48 @@ var AppServerHost = class {
   }
   async #handleDesktopQuestionResponse(value2) {
     if (!isRecord14(value2) || !isHostQuestionRequestId(value2.id)) return false;
-    const pending = this.#pendingDesktopQuestions.get(value2.id);
+    const requestId = value2.id;
+    const pending = this.#pendingDesktopQuestions.get(requestId);
     if (!pending) return true;
-    this.#pendingDesktopQuestions.delete(value2.id);
-    if (pending.timeout) clearTimeout(pending.timeout);
-    let response;
-    try {
-      response = "error" in value2 ? { type: "question", answers: {}, cancelled: true } : pending.projection.parseResponse(value2.result);
-    } catch (error51) {
-      this.#diagnose(error51);
-      response = { type: "question", answers: {}, cancelled: true };
-    }
-    const result = await pending.thread.session.execute({
-      type: "interaction.respond",
-      interactionId: pending.interaction.interactionId,
-      response
+    return this.#externalRuntime.idleRelease.runOperation(pending.thread.id, async () => {
+      if (this.#externalRuntime.get(pending.thread.id) !== pending.thread || this.#externalRuntime.idleRelease.failure(pending.thread))
+        return true;
+      this.#pendingDesktopQuestions.delete(requestId);
+      if (pending.timeout) clearTimeout(pending.timeout);
+      let response;
+      try {
+        response = jsonRpcResponseFailed(value2) ? { type: "question", answers: {}, cancelled: true } : pending.projection.parseResponse(value2.result);
+      } catch (error51) {
+        this.#diagnose(error51);
+        response = { type: "question", answers: {}, cancelled: true };
+      }
+      const result = await pending.thread.session.execute({
+        type: "interaction.respond",
+        interactionId: pending.interaction.interactionId,
+        response
+      });
+      if (!result.ok && result.error.code !== "invalidState") {
+        this.#diagnose(`Question response failed: ${result.error.message}`);
+      }
+      return true;
     });
-    if (!result.ok && result.error.code !== "invalidState") {
-      this.#diagnose(`Question response failed: ${result.error.message}`);
-    }
-    return true;
   }
   async #cancelExpiredQuestion(requestId) {
     const pending = this.#pendingDesktopQuestions.get(requestId);
     if (!pending) return;
-    await this.#resolveDesktopQuestion(pending.interaction.interactionId);
-    const result = await pending.thread.session.execute({
-      type: "interaction.respond",
-      interactionId: pending.interaction.interactionId,
-      response: { type: "question", answers: {}, cancelled: true }
+    await this.#externalRuntime.idleRelease.runOperation(pending.thread.id, async () => {
+      if (this.#externalRuntime.get(pending.thread.id) !== pending.thread || this.#externalRuntime.idleRelease.failure(pending.thread))
+        return;
+      await this.#resolveDesktopQuestion(pending.interaction.interactionId);
+      const result = await pending.thread.session.execute({
+        type: "interaction.respond",
+        interactionId: pending.interaction.interactionId,
+        response: { type: "question", answers: {}, cancelled: true }
+      });
+      if (!result.ok && result.error.code !== "invalidState") {
+        this.#diagnose(`Question expiry failed: ${result.error.message}`);
+      }
     });
-    if (!result.ok && result.error.code !== "invalidState") {
-      this.#diagnose(`Question expiry failed: ${result.error.message}`);
-    }
   }
   #retireDesktopQuestion(interactionId) {
     for (const [requestId, pending] of this.#pendingDesktopQuestions) {
@@ -32643,8 +33725,9 @@ var AppServerHost = class {
     }
     await this.#writer.json(projection);
   }
-  #dispatchDesktopRequest(run) {
-    void run().catch((error51) => this.#diagnose(error51));
+  #dispatchDesktopRequest(run, threadId2) {
+    const task = threadId2 ? this.#externalRuntime.idleRelease.runOperation(threadId2, run) : run();
+    void task.catch((error51) => this.#diagnose(error51));
   }
   #diagnose(error51) {
     this.#options.diagnosticOutput.write(`codexhost Host Runtime: ${errorMessage3(error51)}
@@ -32655,7 +33738,7 @@ var AppServerHost = class {
 // packages/host-runtime/src/native-account-host.ts
 import { mkdir as mkdir6, realpath as realpath3 } from "node:fs/promises";
 import { homedir } from "node:os";
-import path15 from "node:path";
+import path16 from "node:path";
 
 // packages/host-runtime/src/codex-runtime/owned-official-backends.ts
 import { createHash as createHash7, randomBytes } from "node:crypto";
@@ -32665,7 +33748,7 @@ import { Writable as Writable2 } from "node:stream";
 import { createServer } from "node:http";
 import net from "node:net";
 import { chmod as chmod3, lstat as lstat6, mkdir as mkdir5, rm as rm5 } from "node:fs/promises";
-import path13 from "node:path";
+import path14 from "node:path";
 import { PassThrough } from "node:stream";
 
 // node_modules/ws/wrapper.mjs
@@ -32683,7 +33766,7 @@ var wrapper_default = import_websocket.default;
 import { randomUUID as randomUUID9 } from "node:crypto";
 import { chmod as chmod2, lstat as lstat5, mkdir as mkdir4, open as open5, readFile as readFile6, readdir as readdir4, rename as rename3, rm as rm4 } from "node:fs/promises";
 import { uptime } from "node:os";
-import path12 from "node:path";
+import path13 from "node:path";
 import { setTimeout as delay4 } from "node:timers/promises";
 var LOCK_RETRY_COUNT = 200;
 var LOCK_RETRY_DELAY_MS = 25;
@@ -32757,7 +33840,7 @@ async function readLockEntrySnapshot(filePath) {
     source,
     identity: { dev: metadata.dev, ino: metadata.ino },
     mtimeMs: metadata.mtimeMs,
-    record: record3 && path12.basename(filePath) === lockEntryName(record3.ownerToken) ? record3 : null
+    record: record3 && path13.basename(filePath) === lockEntryName(record3.ownerToken) ? record3 : null
   };
 }
 function lockEntryIsAbandoned(snapshot) {
@@ -32778,7 +33861,7 @@ async function readLockEntryCatalog(lockDirectory) {
   let unsettled = false;
   for (const name of names) {
     if (!name.startsWith(LOCK_ENTRY_PREFIX) || !name.endsWith(LOCK_ENTRY_SUFFIX)) continue;
-    const snapshot = await readLockEntrySnapshot(path12.join(lockDirectory, name));
+    const snapshot = await readLockEntrySnapshot(path13.join(lockDirectory, name));
     if (snapshot === null) continue;
     if (lockEntryIsAbandoned(snapshot)) {
       if (!await removeAbandonedLockEntry(snapshot)) unsettled = true;
@@ -32806,7 +33889,7 @@ async function preparePrivateLockDirectory(lockDirectory) {
   await chmod2(lockDirectory, 448);
 }
 async function writeLockRecordAtomic(lockDirectory, entryPath, record3) {
-  const temporary = path12.join(lockDirectory, `.tmp-${record3.ownerToken}-${randomUUID9()}`);
+  const temporary = path13.join(lockDirectory, `.tmp-${record3.ownerToken}-${randomUUID9()}`);
   const handle = await open5(temporary, "wx", 384);
   try {
     await handle.writeFile(`${JSON.stringify(record3)}
@@ -32882,7 +33965,7 @@ async function withRemoteAppServerSocketInitializationLock(socketPath, action) {
   const lockDirectory = `${socketPath}.initializers`;
   await preparePrivateLockDirectory(lockDirectory);
   const ownerToken = randomUUID9();
-  const entryPath = path12.join(lockDirectory, lockEntryName(ownerToken));
+  const entryPath = path13.join(lockDirectory, lockEntryName(ownerToken));
   const baseRecord = {
     version: 2,
     ownerToken,
@@ -33056,14 +34139,14 @@ function remoteAppServerSocketPath(environment, listenUrl = "unix://") {
     throw new Error("Remote app-server listener must use a Unix URL");
   }
   const explicit = listenUrl.slice("unix://".length);
-  if (explicit.length > 0) return path13.posix.resolve(decodeURIComponent(explicit));
-  const codexHome = environment.CODEX_HOME ?? (environment.HOME ? path13.posix.join(environment.HOME, ".codex") : void 0);
+  if (explicit.length > 0) return path14.posix.resolve(decodeURIComponent(explicit));
+  const codexHome = environment.CODEX_HOME ?? (environment.HOME ? path14.posix.join(environment.HOME, ".codex") : void 0);
   if (!codexHome)
     throw new Error("CODEX_HOME or HOME is required for the remote app-server socket");
-  return path13.posix.join(codexHome, "app-server-control", "app-server-control.sock");
+  return path14.posix.join(codexHome, "app-server-control", "app-server-control.sock");
 }
 function officialListenerArgumentsForRemoteListener(arguments_2, socketPath) {
-  if (!path13.posix.isAbsolute(socketPath)) {
+  if (!path14.posix.isAbsolute(socketPath)) {
     throw new Error("Shared official app-server socket path must be absolute");
   }
   if (remoteUnixListenerUrl(arguments_2) === null) {
@@ -33174,7 +34257,7 @@ async function removeStaleSocket(socketPath) {
   await rm5(socketPath, { force: true });
 }
 async function prepareRemoteAppServerSocketDirectory(socketPath) {
-  const socketDirectory = path13.dirname(socketPath);
+  const socketDirectory = path14.dirname(socketPath);
   const existing = await lstat6(socketDirectory).catch((error51) => {
     if (error51.code === "ENOENT") return null;
     throw error51;
@@ -33381,18 +34464,18 @@ function createRemoteAppServerWebSocketListener(input) {
 import { spawn as spawn3 } from "node:child_process";
 import { randomUUID as randomUUID10 } from "node:crypto";
 import { lstat as lstat7, rm as rm6 } from "node:fs/promises";
-import path14 from "node:path";
+import path15 from "node:path";
 var DEFAULT_CLOSE_TIMEOUT_MS = 2e3;
 var DEFAULT_LISTEN_TIMEOUT_MS = 1e4;
 function remoteOfficialAppServerSocketPath(desktopControlSocketPath, token = randomUUID10()) {
-  if (!path14.posix.isAbsolute(desktopControlSocketPath)) {
+  if (!path15.posix.isAbsolute(desktopControlSocketPath)) {
     throw new Error("Desktop control socket path must be absolute");
   }
   if (!/^[A-Za-z0-9-]+$/u.test(token) || !/[A-Za-z0-9]/u.test(token)) {
     throw new Error("Shared official app-server socket token is invalid");
   }
   const compactToken = token.replaceAll("-", "").slice(0, 15);
-  return path14.posix.join(path14.posix.dirname(desktopControlSocketPath), `.c-${compactToken}.sock`);
+  return path15.posix.join(path15.posix.dirname(desktopControlSocketPath), `.c-${compactToken}.sock`);
 }
 function errorMessage4(error51) {
   return error51 instanceof Error ? error51.message : String(error51);
@@ -33875,19 +34958,19 @@ function createOwnedUnixBackend(input) {
 
 // packages/host-runtime/src/native-account-host.ts
 async function canonicalCodexHome(home) {
-  const absolute = path15.resolve(home);
+  const absolute = path16.resolve(home);
   try {
     return await realpath3(absolute);
   } catch (error51) {
     if (!(error51 instanceof Error && "code" in error51 && error51.code === "ENOENT")) throw error51;
-    const parent = path15.dirname(absolute);
+    const parent = path16.dirname(absolute);
     if (parent === absolute) throw error51;
-    return path15.join(await canonicalCodexHome(parent), path15.basename(absolute));
+    return path16.join(await canonicalCodexHome(parent), path16.basename(absolute));
   }
 }
 async function prepareLocalCodex(input) {
   const home = await canonicalCodexHome(
-    input.environment.CODEX_HOME ?? path15.join(homedir(), ".codex")
+    input.environment.CODEX_HOME ?? path16.join(homedir(), ".codex")
   );
   await mkdir6(home, { recursive: true });
   const scope = new OfficialRuntimeScope({
@@ -34054,17 +35137,17 @@ var DelegationControlRegistry = class {
 
 // packages/host-runtime/src/installed-harness-plugins.ts
 import os3 from "node:os";
-import path17 from "node:path";
+import path18 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // packages/host-runtime/src/launcher-url-opener.ts
 import { spawn as spawn4 } from "node:child_process";
-import path16 from "node:path";
+import path17 from "node:path";
 var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]"]);
 var OPEN_TIMEOUT_MS = 1e4;
 function createLauncherUrlOpener(environment, spawnLauncher = (command, arguments_2, options2) => spawn4(command, arguments_2, options2)) {
   const launcher = environment.CODEXHOST_LAUNCHER_EXECUTABLE;
-  if (!launcher || !path16.isAbsolute(launcher)) return void 0;
+  if (!launcher || !path17.isAbsolute(launcher)) return void 0;
   const launcherEnvironment = Object.fromEntries(
     Object.entries(environment).filter(([name]) => {
       const normalized = name.toUpperCase();
@@ -34122,9 +35205,9 @@ function installedHarnessPluginOptions(environment, managedRemoteHost = false, h
   const opener = managedRemoteHost ? void 0 : createLauncherUrlOpener(environment);
   return {
     pluginRoots: [
-      path17.join(path17.dirname(fileURLToPath(hostRuntimeUrl)), "plugins"),
-      environment[HARNESS_PLUGIN_DIRECTORY_ENV] ?? path17.join(
-        environment.CODEXHOST_DATA_DIR ? path17.resolve(environment.CODEXHOST_DATA_DIR) : path17.join(os3.homedir(), ".codexhost"),
+      path18.join(path18.dirname(fileURLToPath(hostRuntimeUrl)), "plugins"),
+      environment[HARNESS_PLUGIN_DIRECTORY_ENV] ?? path18.join(
+        environment.CODEXHOST_DATA_DIR ? path18.resolve(environment.CODEXHOST_DATA_DIR) : path18.join(os3.homedir(), ".codexhost"),
         "plugins"
       )
     ],
@@ -34252,9 +35335,9 @@ async function startDelegationControlServer(input) {
 import { createHash as createHash8, randomUUID as randomUUID11 } from "node:crypto";
 import { mkdir as mkdir7, open as open6, readFile as readFile7, rename as rename4, rm as rm7, stat as stat3 } from "node:fs/promises";
 import os4 from "node:os";
-import path18 from "node:path";
+import path19 from "node:path";
 var SKILL_VERSION = 7;
-var SKILL_RELATIVE_PATH = path18.join("skills", "codexhost-delegation", "SKILL.md");
+var SKILL_RELATIVE_PATH = path19.join("skills", "codexhost-delegation", "SKILL.md");
 var PREVIOUS_MANAGED_DIGESTS = [
   "9d2f491850fb0b4084a31ba9b5e4a550b5e833747af322090d8ed0ff80b88c30",
   "2bb0aebb9b06febbc6c0c0bcdb0b32506c7cdbf8dc3b734cc6b2a86621270e4e",
@@ -34327,8 +35410,8 @@ async function readOptional(filePath) {
   }
 }
 async function atomicWrite(filePath, content) {
-  await mkdir7(path18.dirname(filePath), { recursive: true, mode: 448 });
-  const temporaryPath = path18.join(path18.dirname(filePath), `.SKILL.md.${randomUUID11()}.tmp`);
+  await mkdir7(path19.dirname(filePath), { recursive: true, mode: 448 });
+  const temporaryPath = path19.join(path19.dirname(filePath), `.SKILL.md.${randomUUID11()}.tmp`);
   const handle = await open6(temporaryPath, "wx", 384);
   try {
     await handle.writeFile(content, "utf8");
@@ -34345,8 +35428,8 @@ async function atomicWrite(filePath, content) {
 async function installDelegationSkills(input = {}) {
   const home = input.homeDirectory ?? os4.homedir();
   const destinations = [
-    path18.join(home, ".agents", SKILL_RELATIVE_PATH),
-    path18.join(home, ".claude", SKILL_RELATIVE_PATH)
+    path19.join(home, ".agents", SKILL_RELATIVE_PATH),
+    path19.join(home, ".claude", SKILL_RELATIVE_PATH)
   ];
   const knownDigests = /* @__PURE__ */ new Set([
     CURRENT_DIGEST,
@@ -34413,7 +35496,7 @@ async function installDelegationSkills(input = {}) {
 // packages/host-runtime/src/remote-control-app-server.ts
 import { randomUUID as randomUUID12 } from "node:crypto";
 import { mkdir as mkdir8, open as open7, rename as rename5, rm as rm8 } from "node:fs/promises";
-import path19 from "node:path";
+import path20 from "node:path";
 var REMOTE_CONTROL_BRIDGE_PIPE_ENV = "CODEXHOST_REMOTE_CONTROL_BRIDGE_PIPE";
 var REMOTE_CONTROL_BRIDGE_NODE_ENV = "CODEXHOST_REMOTE_CONTROL_BRIDGE_NODE_PATH";
 var REMOTE_CONTROL_BRIDGE_RUNTIME_ENV = "CODEXHOST_REMOTE_CONTROL_BRIDGE_RUNTIME_PATH";
@@ -34424,8 +35507,8 @@ var BRIDGE_READY_METHOD = "codexhost/remote-control-bridge/ready";
 function absoluteEnvironmentPath2(environment, name, fallback, platform = process.platform) {
   const value2 = environment[name] ?? fallback;
   if (!value2) return null;
-  if (path19.isAbsolute(value2)) return path19.normalize(value2);
-  return platform === "win32" && path19.win32.isAbsolute(value2) ? path19.win32.normalize(value2) : null;
+  if (path20.isAbsolute(value2)) return path20.normalize(value2);
+  return platform === "win32" && path20.win32.isAbsolute(value2) ? path20.win32.normalize(value2) : null;
 }
 function nodeCompatibleWindowsPath(value2) {
   if (value2.startsWith("\\\\?\\UNC\\")) return `\\\\${value2.slice(8)}`;
@@ -34439,13 +35522,13 @@ function remoteControlBridgePipePath(processId = process.pid, instanceId = rando
 }
 function remoteControlBridgeDescriptorPath(environment) {
   const root = environment.LOCALAPPDATA;
-  if (!root || !path19.isAbsolute(root)) return null;
-  return path19.join(path19.normalize(root), "codexhost", REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE);
+  if (!root || !path20.isAbsolute(root)) return null;
+  return path20.join(path20.normalize(root), "codexhost", REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE);
 }
 async function publishRemoteControlAppServerDescriptor(plan) {
-  const directory = path19.dirname(plan.descriptorPath);
+  const directory = path20.dirname(plan.descriptorPath);
   await mkdir8(directory, { recursive: true, mode: 448 });
-  const temporaryPath = path19.join(
+  const temporaryPath = path20.join(
     directory,
     `.${REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE}.${plan.descriptor.ownerPid}.${randomUUID12()}.tmp`
   );
@@ -34746,9 +35829,9 @@ function hasLauncherManagedUpdateRuntime(environment, hostRuntimePath) {
   if (!environment[UPDATE_RUNTIME_ENV.launcherPid]) return false;
   const npmPackageRoot = environment[UPDATE_RUNTIME_ENV.npmPackageRoot];
   if (!npmPackageRoot || !hostRuntimePath) return true;
-  if (!path20.isAbsolute(npmPackageRoot) || !path20.isAbsolute(hostRuntimePath)) return false;
-  const runtimePackageRoot = path20.dirname(path20.dirname(path20.normalize(hostRuntimePath)));
-  return path20.relative(path20.normalize(npmPackageRoot), runtimePackageRoot) === "";
+  if (!path21.isAbsolute(npmPackageRoot) || !path21.isAbsolute(hostRuntimePath)) return false;
+  const runtimePackageRoot = path21.dirname(path21.dirname(path21.normalize(hostRuntimePath)));
+  return path21.relative(path21.normalize(npmPackageRoot), runtimePackageRoot) === "";
 }
 function requiredRuntimeConfiguration(environment) {
   const stockCodexPath = environment[STOCK_CODEX_PATH_ENV];
@@ -34894,8 +35977,8 @@ async function runHostRuntime(input) {
       const socketPath = remoteAppServerSocketPath(delegationEnvironment, listenUrl);
       const officialPlan = createRemoteOfficialAppServerPlan(input.arguments, socketPath);
       const officialRuntimeScope = new OfficialRuntimeScope({
-        permanentHome: path20.resolve(
-          delegationEnvironment.CODEX_HOME ?? path20.join(homedir2(), ".codex")
+        permanentHome: path21.resolve(
+          delegationEnvironment.CODEX_HOME ?? path21.join(homedir2(), ".codex")
         ),
         diagnosticOutput: process.stderr,
         createBackend: () => createOwnedUnixBackend({
@@ -34991,7 +36074,7 @@ import {
   stat as stat4,
   writeFile as writeFile3
 } from "node:fs/promises";
-import path21 from "node:path";
+import path22 from "node:path";
 var MANIFEST_FORMAT = 1;
 var WRAPPER_MARKER = "# codexhost remote SSH wrapper v1";
 var PROFILE_START = "# >>> codexhost remote SSH >>>";
@@ -35002,25 +36085,25 @@ function resolvePaths(options2) {
   if (!configuredHome) {
     throw new Error("A non-root HOME is required for remote Host installation");
   }
-  const home = path21.resolve(configuredHome);
-  if (!home || home === path21.parse(home).root) {
+  const home = path22.resolve(configuredHome);
+  if (!home || home === path22.parse(home).root) {
     throw new Error("A non-root HOME is required for remote Host installation");
   }
-  const installRoot = path21.resolve(options2.installRoot ?? path21.join(home, ".codexhost", "remote"));
-  const profilePath = path21.resolve(
-    options2.profilePath ?? path21.join(
+  const installRoot = path22.resolve(options2.installRoot ?? path22.join(home, ".codexhost", "remote"));
+  const profilePath = path22.resolve(
+    options2.profilePath ?? path22.join(
       home,
-      path21.basename(environment.SHELL ?? "") === "zsh" ? ".zshenv" : path21.basename(environment.SHELL ?? "") === "bash" ? ".bashrc" : ".profile"
+      path22.basename(environment.SHELL ?? "") === "zsh" ? ".zshenv" : path22.basename(environment.SHELL ?? "") === "bash" ? ".bashrc" : ".profile"
     )
   );
-  const binDirectory = path21.join(installRoot, "bin");
+  const binDirectory = path22.join(installRoot, "bin");
   return {
     home,
     installRoot,
     binDirectory,
-    wrapperPath: path21.join(binDirectory, "codex"),
-    manifestPath: path21.join(installRoot, "manifest.json"),
-    dataDirectory: path21.join(installRoot, "data"),
+    wrapperPath: path22.join(binDirectory, "codex"),
+    manifestPath: path22.join(installRoot, "manifest.json"),
+    dataDirectory: path22.join(installRoot, "data"),
     profilePath
   };
 }
@@ -35039,7 +36122,7 @@ async function fileSha256(filePath) {
   return createHash9("sha256").update(await readFile8(filePath)).digest("hex");
 }
 async function executable(filePath, label) {
-  const absolute = path21.resolve(filePath);
+  const absolute = path22.resolve(filePath);
   try {
     if (!(await stat4(absolute)).isFile()) throw new Error("not a regular file");
     await access(absolute, fsConstants.X_OK);
@@ -35049,7 +36132,7 @@ async function executable(filePath, label) {
   return absolute;
 }
 async function existingFile(filePath, label) {
-  const absolute = path21.resolve(filePath);
+  const absolute = path22.resolve(filePath);
   try {
     const metadata = await stat4(absolute);
     if (!metadata.isFile()) throw new Error("not a regular file");
@@ -35059,9 +36142,9 @@ async function existingFile(filePath, label) {
   return absolute;
 }
 async function discoverExecutable(name, environment) {
-  for (const directory of (environment.PATH ?? "").split(path21.delimiter)) {
+  for (const directory of (environment.PATH ?? "").split(path22.delimiter)) {
     if (!directory) continue;
-    const candidate = path21.resolve(directory, name);
+    const candidate = path22.resolve(directory, name);
     try {
       await access(candidate, fsConstants.X_OK);
       return candidate;
@@ -35072,10 +36155,10 @@ async function discoverExecutable(name, environment) {
   return null;
 }
 async function writeAtomic(filePath, contents, mode) {
-  await mkdir9(path21.dirname(filePath), { recursive: true, mode: 448 });
-  const temporary = path21.join(
-    path21.dirname(filePath),
-    `.${path21.basename(filePath)}.${process.pid}.${randomUUID13()}.tmp`
+  await mkdir9(path22.dirname(filePath), { recursive: true, mode: 448 });
+  const temporary = path22.join(
+    path22.dirname(filePath),
+    `.${path22.basename(filePath)}.${process.pid}.${randomUUID13()}.tmp`
   );
   try {
     if (typeof contents === "string") {
@@ -35096,10 +36179,10 @@ async function writeAtomic(filePath, contents, mode) {
   }
 }
 async function writeAtomicExecutable(filePath, sourcePath) {
-  await mkdir9(path21.dirname(filePath), { recursive: true, mode: 448 });
-  const temporary = path21.join(
-    path21.dirname(filePath),
-    `.${path21.basename(filePath)}.${process.pid}.${randomUUID13()}.tmp`
+  await mkdir9(path22.dirname(filePath), { recursive: true, mode: 448 });
+  const temporary = path22.join(
+    path22.dirname(filePath),
+    `.${path22.basename(filePath)}.${process.pid}.${randomUUID13()}.tmp`
   );
   try {
     await copyFile3(sourcePath, temporary);
@@ -35140,8 +36223,8 @@ function removeManagedProfileBlock(contents) {
 function installManagedProfileBlock(contents, manifest) {
   const base = removeManagedProfileBlock(contents);
   const environment = [
-    `export CODEX_INSTALL_DIR=${shellQuote(path21.dirname(manifest.wrapperPath))}`,
-    `export PATH=${shellQuote(path21.dirname(manifest.wrapperPath))}:${shellQuote(path21.dirname(manifest.nodePath))}:${shellQuote(path21.dirname(manifest.stockCodexPath))}:"\${PATH:-/usr/local/bin:/usr/bin:/bin}"`,
+    `export CODEX_INSTALL_DIR=${shellQuote(path22.dirname(manifest.wrapperPath))}`,
+    `export PATH=${shellQuote(path22.dirname(manifest.wrapperPath))}:${shellQuote(path22.dirname(manifest.nodePath))}:${shellQuote(path22.dirname(manifest.stockCodexPath))}:"\${PATH:-/usr/local/bin:/usr/bin:/bin}"`,
     `export CODEXHOST_STOCK_CODEX_PATH=${shellQuote(manifest.stockCodexPath)}`,
     `export CODEXHOST_HOST_NODE_PATH=${shellQuote(manifest.nodePath)}`,
     `export CODEXHOST_HOST_RUNTIME_PATH=${shellQuote(manifest.hostRuntimePath)}`,
@@ -35158,7 +36241,7 @@ function installManagedProfileBlock(contents, manifest) {
     PROFILE_END,
     ""
   ].join("\n");
-  if (path21.basename(manifest.profilePath) === ".bashrc") return `${block}${base}`;
+  if (path22.basename(manifest.profilePath) === ".bashrc") return `${block}${base}`;
   const separator = base.length > 0 && !base.endsWith("\n") ? "\n" : "";
   return `${base}${separator}${block}`;
 }
@@ -35223,9 +36306,9 @@ async function readManifest(filePath) {
   ];
   const optionalPaths = ["claudeCommand", "profileBackupPath"];
   if (manifest.format !== MANIFEST_FORMAT || Object.keys(manifest).some((key) => !allowed.has(key)) || requiredPaths.some(
-    (key) => typeof manifest[key] !== "string" || !path21.isAbsolute(manifest[key])
+    (key) => typeof manifest[key] !== "string" || !path22.isAbsolute(manifest[key])
   ) || optionalPaths.some(
-    (key) => manifest[key] !== void 0 && (typeof manifest[key] !== "string" || !path21.isAbsolute(manifest[key]))
+    (key) => manifest[key] !== void 0 && (typeof manifest[key] !== "string" || !path22.isAbsolute(manifest[key]))
   ) || manifest.entrypointSha256 !== void 0 && (typeof manifest.entrypointSha256 !== "string" || !/^[a-f0-9]{64}$/u.test(manifest.entrypointSha256))) {
     throw new Error("Remote Host manifest has an unsupported format");
   }
@@ -35454,7 +36537,7 @@ async function uninstallRemoteHost(options2) {
 import { spawn as spawn5 } from "node:child_process";
 import { stat as stat5 } from "node:fs/promises";
 import net3 from "node:net";
-import path22 from "node:path";
+import path23 from "node:path";
 import { Duplex } from "node:stream";
 
 // packages/host-runtime/src/app-server-websocket-options.ts
@@ -35481,9 +36564,9 @@ function classifyRemoteHostProbeResponse(response, socketPath) {
 }
 var lifecycleDependencyOverrides = {};
 function socketPathFor(environment) {
-  const codexHome = environment.CODEX_HOME ?? (environment.HOME ? path22.join(environment.HOME, ".codex") : void 0);
+  const codexHome = environment.CODEX_HOME ?? (environment.HOME ? path23.join(environment.HOME, ".codex") : void 0);
   if (!codexHome) throw new Error("CODEX_HOME or HOME is required for remote Host lifecycle");
-  return path22.join(codexHome, "app-server-control", "app-server-control.sock");
+  return path23.join(codexHome, "app-server-control", "app-server-control.sock");
 }
 async function defaultSocketExists(socketPath) {
   const metadata = await stat5(socketPath).catch((error51) => {
@@ -35613,7 +36696,7 @@ function installedManifest(status) {
 function managedEnvironment(manifest, environment) {
   return {
     ...environment,
-    CODEX_INSTALL_DIR: path22.dirname(manifest.wrapperPath),
+    CODEX_INSTALL_DIR: path23.dirname(manifest.wrapperPath),
     CODEXHOST_STOCK_CODEX_PATH: manifest.stockCodexPath,
     CODEXHOST_HOST_NODE_PATH: manifest.nodePath,
     CODEXHOST_HOST_RUNTIME_PATH: manifest.hostRuntimePath,
@@ -35621,7 +36704,7 @@ function managedEnvironment(manifest, environment) {
     CODEXHOST_DEFAULT_AGENT: "codex",
     CODEXHOST_REMOTE_SSH_MANAGED: "1",
     ...manifest.claudeCommand ? { CODEXHOST_CLAUDE_COMMAND: manifest.claudeCommand } : {},
-    PATH: `${path22.dirname(manifest.wrapperPath)}${path22.delimiter}${path22.dirname(manifest.stockCodexPath)}${path22.delimiter}${environment.PATH ?? "/usr/bin:/bin"}`
+    PATH: `${path23.dirname(manifest.wrapperPath)}${path23.delimiter}${path23.dirname(manifest.stockCodexPath)}${path23.delimiter}${environment.PATH ?? "/usr/bin:/bin"}`
   };
 }
 async function defaultRunTerminator(manifest, socketPath, role, environment) {
@@ -35963,25 +37046,25 @@ function consumeBrokerFrames(socket, onFrame, onError) {
 
 // packages/harness-broker/dist/paths.js
 import os5 from "node:os";
-import path23 from "node:path";
+import path24 from "node:path";
 var HARNESS_BROKER_DESCRIPTOR_ENV = "CODEXHOST_CLAUDE_BROKER_DESCRIPTOR";
 var HARNESS_BROKER_DESCRIPTOR_FILE = "claude-code-broker-v1.json";
 var HARNESS_BROKER_SOCKET_FILE = "claude-code-broker-v1.sock";
 function defaultHarnessBrokerDirectory(environment = process.env) {
   const home = environment.HOME || os5.homedir();
-  return path23.join(home, ".codexhost", "harness-broker");
+  return path24.join(home, ".codexhost", "harness-broker");
 }
 function defaultHarnessBrokerDescriptorPath(environment = process.env, harnessId = "claude-code") {
   harnessPluginIdSchema.parse(harnessId);
   if (harnessId !== "claude-code")
-    return path23.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.json`);
-  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path23.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
+    return path24.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.json`);
+  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path24.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
 }
 function defaultHarnessBrokerSocketPath(environment = process.env, harnessId = "claude-code") {
   harnessPluginIdSchema.parse(harnessId);
   if (harnessId !== "claude-code")
-    return path23.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.sock`);
-  return path23.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_SOCKET_FILE);
+    return path24.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.sock`);
+  return path24.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_SOCKET_FILE);
 }
 
 // packages/harness-broker/dist/validation.js
@@ -36218,7 +37301,7 @@ var harnessOutputSchema = external_exports.custom((value2) => {
 import { randomBytes as randomBytes3, randomUUID as randomUUID14 } from "node:crypto";
 import { chmod as chmod5, lstat as lstat9, mkdir as mkdir10, open as open8, readFile as readFile9, rename as rename7, rm as rm10 } from "node:fs/promises";
 import net4, {} from "node:net";
-import path24 from "node:path";
+import path25 from "node:path";
 function harnessError(message, retryable = true) {
   return { code: "unavailable", message, retryable, stage: "harnessBroker" };
 }
@@ -36341,13 +37424,13 @@ async function prepareUnixSocketPath(socketPath) {
 }
 async function startHarnessBrokerServer(input) {
   harnessPluginIdSchema.parse(input.adapter.harnessId);
-  if (process.platform !== "win32" && path24.dirname(input.descriptorPath) !== path24.dirname(input.socketPath)) {
+  if (process.platform !== "win32" && path25.dirname(input.descriptorPath) !== path25.dirname(input.socketPath)) {
     throw new Error("Harness broker descriptor and socket must share one private directory");
   }
   if (process.platform === "darwin" && Buffer.byteLength(input.socketPath) > 103) {
     throw new Error("Harness broker Unix socket path is too long for macOS");
   }
-  await privateDirectory(path24.dirname(input.descriptorPath));
+  await privateDirectory(path25.dirname(input.descriptorPath));
   await assertNoLiveDescriptor(input.descriptorPath);
   if (process.platform !== "win32")
     await prepareUnixSocketPath(input.socketPath);