@codexhost/cli-darwin-x64 0.6.1 → 0.7.0

package/app/host-runtime.mjs

@@ -2278,7 +2278,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net5 = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes3, createHash: createHash8 } = __require("crypto");
+    var { randomBytes: randomBytes3, createHash: createHash9 } = __require("crypto");
     var { Duplex: Duplex2, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -2946,7 +2946,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest2 = createHash8("sha1").update(key + GUID).digest("base64");
+        const digest2 = createHash9("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest2) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -3315,7 +3315,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http = __require("http");
     var { Duplex: Duplex2 } = __require("stream");
-    var { createHash: createHash8 } = __require("crypto");
+    var { createHash: createHash9 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -3622,7 +3622,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest2 = createHash8("sha1").update(key + GUID).digest("base64");
+        const digest2 = createHash9("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -3709,6 +3709,92 @@ var require_websocket_server = __commonJS({
   }
 });
 
+// packages/host-runtime/src/delegation-cli-help.ts
+var COMMAND_HELP = {
+  "harness list": `codexhost harness list [--format json|compact]
+List Harnesses available in the active Runtime.`,
+  "harness inspect": `codexhost harness inspect <harness> [--cwd <path>] [--refresh true|false] [--format json|compact]
+Read available Models, native defaults, Thinking options, and configuration capabilities.
+Use the returned Model and Thinking IDs for explicit selections.`,
+  "delegate start": `codexhost delegate start --harness <id> --task <text> [--cwd <path>] [--model <opaque-ref>] [--thinking <option-id>] [--parent-thread <thread>] [--request-id <id>] [--format json|compact]
+Create an independent child Thread, submit the task, and return immediately.
+Omit --model and --thinking to use the Harness native defaults.
+--cwd overrides the child workspace. Otherwise use the resolved parent Thread workspace, then the Host Runtime process cwd.
+--parent-thread overrides caller inference. PARENT_THREAD_AMBIGUOUS requires an explicit parent.
+Reuse --request-id for an idempotent retry. Identical recent parent/target/task/configuration requests are also deduplicated briefly.
+The response confirms cwd and parent. Use its Thread reference with thread read, wait, send, or cancel.`,
+  "thread send": `codexhost thread send <thread> --message <text> [--format json|compact]
+Start a new Turn in an idle writable Thread and return immediately.
+THREAD_BUSY means the current Turn is still active: wait or cancel before sending. Messages are not queued.`,
+  "thread cancel": `codexhost thread cancel <thread> [--format json|compact]
+Request cancellation of the active Turn while preserving the Thread and history.
+cancelled=true (compact: cancelRequested=true) means the cancellation request was accepted. Read or wait to confirm the terminal state. An idle Thread returns false.`,
+  "thread read": `codexhost thread read <thread> [--view result|messages] [--cursor <cursor>] [--limit <n>] [--format json|compact]
+Read immediately without starting a Turn. The default result view reports the latest Turn's status and result.
+The messages view pages visible user/Agent messages, oldest first. Default limit 25, maximum 100; --cursor and --limit require --view messages.
+hasMore describes remaining messages now. Save nextCursor for later incremental reads even when hasMore=false.
+Compact messages output contains only the message page and status; compact result output includes the latest nonempty progress while running.
+Full JSON retains the complete snapshot. Tool calls/output, file activity, and reasoning are not included in either format.`,
+  "thread wait": `codexhost thread wait <thread> [--timeout-ms <n>] [--view result|messages] [--cursor <cursor>] [--limit <n>] [--format json|compact]
+Wait until the Thread is terminal or the timeout expires (default 30000 ms), then return the same snapshot as thread read plus timedOut.
+timedOut=true is a running checkpoint: the child keeps running. The response already includes the result when available; another read is unnecessary unless more information is needed.
+Message pagination uses --view messages, default limit 25, maximum 100. hasMore is for current pages; nextCursor also supports future incremental reads.`,
+  "thread list": `codexhost thread list [--cwd <path>] [--parent <thread>] [--limit <n>] [--cursor <cursor>] [--sort created-asc|created-desc|updated-asc|updated-desc|recency-asc|recency-desc] [--format json|compact]
+Find existing Threads by workspace, or use --parent to list a Thread's delegated children.
+Workspace listing defaults to the caller process cwd. Default limit 25 (maximum 100), sorted created-desc.
+--parent uses Delegation relationships. A null nextCursor ends the list.
+Compact output keeps task links, Harness, status, title, and workspace.`
+};
+var COMMON_HELP = `Thread references accept a bare ID or codex://threads/<id>.
+--format json is the compatible full JSON output (default); --format compact returns concise JSON using task links instead of internal IDs.
+Success is written to stdout; errors {"error":{"code":"...","message":"...","details":{...}}} go to stderr with exit code 1. Exit code 0 means the command succeeded, not that the delegated task succeeded.
+read/wait are non-consuming. Native Codex callers need local Runtime access; RUNTIME_UNREACHABLE requires the Host-provided environment and a sandbox that permits that connection.`;
+var DELEGATION_HELP = `usage:
+  codexhost harness list
+  codexhost harness inspect <harness>
+  codexhost delegate start --harness <id> --task <text>
+  codexhost thread send <thread> --message <text>
+  codexhost thread cancel <thread>
+  codexhost thread read <thread>
+  codexhost thread wait <thread>
+  codexhost thread list
+
+Use <command> --help for its options. Use harness list to discover targets.
+${COMMON_HELP}
+`;
+function hasHelpOption(arguments_2) {
+  for (let index = 0; index < arguments_2.length; index += 1) {
+    const argument = arguments_2[index];
+    if (argument === "--help" || argument === "-h") return true;
+    if (argument?.startsWith("--")) index += 1;
+  }
+  return false;
+}
+function delegationCliHelp(arguments_2) {
+  const [group, command, ...rest] = arguments_2;
+  if (!group || group === "--help" || group === "-h") return DELEGATION_HELP;
+  if (!command || command === "--help" || command === "-h" || command === "help") {
+    if (group === "delegate") return DELEGATION_HELP;
+    if (group === "harness" || group === "thread") {
+      const usages = Object.entries(COMMAND_HELP).filter(([name]) => name.startsWith(`${group} `)).map(([, help]) => help.split("\n")[0]);
+      return `${usages.join("\n")}
+
+${COMMON_HELP}
+`;
+    }
+  }
+  if (hasHelpOption(rest)) {
+    const name = `${group} ${command}`;
+    if (Object.hasOwn(COMMAND_HELP, name)) {
+      return `${COMMAND_HELP[name]}
+
+${COMMON_HELP}
+`;
+    }
+  }
+  return void 0;
+}
+
 // packages/host-runtime/src/delegation-types.ts
 var DELEGATION_RUNTIME_ENDPOINT_ENV = "CODEXHOST_RUNTIME_ENDPOINT";
 var DELEGATION_RUNTIME_TOKEN_ENV = "CODEXHOST_RUNTIME_TOKEN";
@@ -3725,6 +3811,114 @@ var DelegationControlError = class extends Error {
   details;
 };
 
+// packages/host-runtime/src/delegation-cli-output.ts
+function threadLink(threadId3) {
+  return `codex://threads/${threadId3}`;
+}
+function inspectOutput({ harnessId, inspection }) {
+  if (inspection.status !== "ready") return { harnessId, ...inspection };
+  const { catalog } = inspection;
+  return {
+    harnessId,
+    status: inspection.status,
+    models: catalog.models.map(({ ref, label, supportedThinkingOptionIds }) => ({
+      id: ref.id,
+      label,
+      ...supportedThinkingOptionIds ? { thinking: supportedThinkingOptionIds } : {}
+    })),
+    ...catalog.defaultModel ? { defaultModel: catalog.defaultModel.id } : {},
+    thinkingOptions: catalog.thinkingOptions,
+    ...catalog.defaultThinkingOptionId ? { defaultThinkingOptionId: catalog.defaultThinkingOptionId } : {},
+    capabilities: inspection.capabilities
+  };
+}
+function snapshotOutput(snapshot, view) {
+  const common = {
+    thread: threadLink(snapshot.threadId),
+    harnessId: snapshot.harnessId,
+    status: snapshot.status,
+    ...snapshot.timedOut !== void 0 ? { timedOut: snapshot.timedOut } : {}
+  };
+  if (view === "messages") {
+    if (typeof snapshot.hasMore !== "boolean") {
+      throw new DelegationControlError(
+        "INTERNAL_ERROR",
+        "Compact message pagination requires an updated Host Runtime; use --format json with this Runtime."
+      );
+    }
+    return {
+      ...common,
+      messages: (snapshot.messages ?? []).map(({ role, phase, text }) => ({
+        role,
+        ...phase ? { phase } : {},
+        text
+      })),
+      hasMore: snapshot.hasMore,
+      nextCursor: snapshot.nextCursor,
+      ...snapshot.result.message ? { error: snapshot.result.message } : {}
+    };
+  }
+  const progress = snapshot.progress.filter(({ text }) => text.trim()).at(-1)?.text;
+  return {
+    ...common,
+    result: snapshot.result,
+    ...snapshot.status === "running" && progress ? { progress } : {}
+  };
+}
+function compactDelegationOutput(command, body, view = "result") {
+  switch (command) {
+    case "harness list":
+      return body;
+    case "harness inspect":
+      return inspectOutput(body);
+    case "delegate start": {
+      const result = body;
+      const effective = result.configuration?.effective;
+      return {
+        thread: result.deepLink,
+        harnessId: result.harnessId,
+        status: result.status,
+        ...result.cwd ? { cwd: result.cwd } : {},
+        ...result.parentThreadId ? { parent: threadLink(result.parentThreadId) } : {},
+        ...effective?.resolvedModelLabel ? { model: effective.resolvedModelLabel } : {},
+        ...effective?.effectiveThinkingOptionId ? { thinking: effective.effectiveThinkingOptionId } : {}
+      };
+    }
+    case "thread send": {
+      const result = body;
+      return {
+        thread: threadLink(result.threadId),
+        harnessId: result.harnessId,
+        status: result.status
+      };
+    }
+    case "thread cancel": {
+      const result = body;
+      return {
+        thread: threadLink(result.threadId),
+        harnessId: result.harnessId,
+        cancelRequested: result.cancelled
+      };
+    }
+    case "thread read":
+    case "thread wait":
+      return snapshotOutput(body, view);
+    case "thread list": {
+      const result = body;
+      return {
+        threads: result.threads.map(({ deepLink, harnessId, status, title, cwd }) => ({
+          thread: deepLink,
+          harnessId,
+          status,
+          ...title ? { title } : {},
+          ...cwd ? { cwd } : {}
+        })),
+        nextCursor: result.nextCursor
+      };
+    }
+  }
+}
+
 // packages/host-runtime/src/delegation-cli.ts
 var DEFAULT_WAIT_TIMEOUT_MS = 3e4;
 var DEFAULT_LIMIT = 25;
@@ -3771,44 +3965,12 @@ function value(parsed, name) {
   return parsed.options.get(name);
 }
 function rejectUnknown(parsed, allowed) {
-  const known = new Set(allowed);
+  const known = /* @__PURE__ */ new Set([...allowed, "--format"]);
   for (const name of parsed.options.keys()) {
     if (!known.has(name))
       throw new DelegationControlError("INVALID_ARGUMENT", `Unknown option '${name}'`);
   }
 }
-var DELEGATION_HELP = `usage:
-  codexhost harness inspect <harness> [--cwd <path>] [--refresh true|false]
-  codexhost delegate start --harness <id> --task <text> [--model <opaque-ref>] [--thinking <option-id>] [--parent-thread <thread>] [--request-id <id>]
-  codexhost thread send <thread> --message <text>
-  codexhost thread cancel <thread>
-  codexhost thread read <thread> [--view result|messages] [--cursor <cursor>] [--limit <n>]
-  codexhost thread wait <thread> [--timeout-ms <n>] [--view result|messages] [--cursor <cursor>] [--limit <n>]
-  codexhost thread list [--cwd <path>] [--parent <thread>] [--limit <n>] [--cursor <cursor>] [--sort created-asc|created-desc|updated-asc|updated-desc|recency-asc|recency-desc]
-
-Thread identifiers accept a bare ID or codex://threads/<id>. Output is JSON by default.
-harness inspect returns the target Model catalog, default Model, Thinking options, and configuration capabilities without creating a Thread. Use opaque IDs exactly as returned.
-delegate start requires --harness and --task, creates and submits the child Thread, then returns immediately. --model and --thinking select values returned by harness inspect. Omit either option to preserve that target's current default behavior. --parent-thread overrides caller inference. Reuse --request-id for idempotent retries; without it, identical recent parent/target/task/configuration requests are deduplicated briefly.
-Successful start fields: delegationId, threadId, turnId, harnessId, deepLink, status, next.read, next.wait.
-thread send starts a new Turn in an idle writable Thread and returns immediately. It fails with THREAD_BUSY instead of queueing or starting a concurrent Turn.
-thread cancel requests cancellation of the current Turn while preserving the Thread. An idle Thread returns cancelled=false.
-thread read is non-blocking. Its default result view returns threadId, harnessId, status, latest turn, visible progress, result.availability/result.text, and nextCursor.
-thread read --view messages additionally returns paginated user/Agent-visible messages. The default page is 25 and --limit is capped at 100; --cursor and --limit require the messages view. Tool calls, tool output, file activity, reasoning summaries, hidden reasoning, and private Harness transcripts are never returned.
-thread wait defaults to 30000 ms and waits only until the Thread reaches a terminal state or the bounded timeout expires. A timeout is a successful running checkpoint with timedOut=true; the child keeps running.
-thread list defaults to the caller cwd, limit 25, created-desc; limit is capped at 100. --parent uses Delegation lineage, not Codex Subagent relationships.
-read and wait are non-consuming: they do not start a Turn, send input, wake an Agent, mark messages read, or inject a result into the parent Session.
-Native Codex as caller requires a session sandbox that permits local Runtime connections; otherwise RUNTIME_UNREACHABLE is returned. Native Codex as a target uses brokered official requests and is unaffected.
-
-Errors are JSON: {"error":{"code":"...","message":"...","details":{...}}}.
-INVALID_ARGUMENT: fix the named argument or incompatible option combination.
-HARNESS_NOT_FOUND: choose a Harness ID listed in error.details.validHarnessIds.
-THREAD_NOT_FOUND: verify the bare ID or codex:// deep link.
-THREAD_BUSY: wait for or cancel the active Turn before sending another message.
-PARENT_THREAD_AMBIGUOUS: pass --parent-thread explicitly.
-RUNTIME_UNREACHABLE: run inside the Host-provided environment and, for native Codex, allow local Runtime connections; codexhost never falls back to PATH or another Runtime.
-DELEGATION_FAILED: the target Session or initial task delivery failed and no successful child was published.
-INTERNAL_ERROR: retry after checking the Host Runtime diagnostics.
-`;
 async function requestRuntime(input) {
   const endpoint = input.environment[DELEGATION_RUNTIME_ENDPOINT_ENV];
   const token = input.environment[DELEGATION_RUNTIME_TOKEN_ENV];
@@ -3854,12 +4016,37 @@ async function runDelegationCli(input) {
   const environment = input.environment ?? process.env;
   try {
     const [group, command, ...rest] = input.arguments;
-    if (group === "delegate" && (!command || command === "--help" || command === "help") || group === "--help" || group === "-h") {
-      output.write(DELEGATION_HELP);
+    const help = delegationCliHelp(input.arguments);
+    if (help !== void 0) {
+      output.write(help);
+      return 0;
+    }
+    const parsed = options(rest);
+    const format = value(parsed, "--format") ?? "json";
+    if (format !== "json" && format !== "compact") {
+      throw new DelegationControlError("INVALID_ARGUMENT", "--format must be json or compact");
+    }
+    const writeResult = (name, body, view = "result") => writeJson(output, format === "json" ? body : compactDelegationOutput(name, body, view));
+    if (group === "harness" && command === "list") {
+      rejectUnknown(parsed, []);
+      if (parsed.positionals.length > 0) {
+        throw new DelegationControlError(
+          "INVALID_ARGUMENT",
+          "harness list accepts no positional arguments"
+        );
+      }
+      writeResult(
+        "harness list",
+        await requestRuntime({
+          environment,
+          path: "/v1/harness/list",
+          body: {},
+          ...input.fetchImpl ? { fetchImpl: input.fetchImpl } : {}
+        })
+      );
       return 0;
     }
     if (group === "harness" && command === "inspect") {
-      const parsed = options(rest);
       rejectUnknown(parsed, ["--cwd", "--refresh"]);
       if (parsed.positionals.length !== 1) {
         throw new DelegationControlError(
@@ -3875,8 +4062,8 @@ async function runDelegationCli(input) {
       if (refresh !== void 0 && refresh !== "true" && refresh !== "false") {
         throw new DelegationControlError("INVALID_ARGUMENT", "--refresh must be true or false");
       }
-      writeJson(
-        output,
+      writeResult(
+        "harness inspect",
         await requestRuntime({
           environment,
           path: "/v1/harness/inspect",
@@ -3891,10 +4078,10 @@ async function runDelegationCli(input) {
       return 0;
     }
     if (group === "delegate" && command === "start") {
-      const parsed = options(rest);
       rejectUnknown(parsed, [
         "--harness",
         "--task",
+        "--cwd",
         "--model",
         "--thinking",
         "--parent-thread",
@@ -3910,15 +4097,15 @@ async function runDelegationCli(input) {
       if (!harnessId || !task)
         throw new DelegationControlError("INVALID_ARGUMENT", "--harness and --task are required");
       const parentThread = value(parsed, "--parent-thread") ?? environment[DELEGATION_THREAD_ID_ENV];
-      writeJson(
-        output,
+      writeResult(
+        "delegate start",
         await requestRuntime({
           environment,
           path: "/v1/delegate/start",
           body: {
             harnessId,
             task,
-            cwd: process.cwd(),
+            ...value(parsed, "--cwd") ? { cwd: value(parsed, "--cwd") } : {},
             ...value(parsed, "--model") ? { model: { id: value(parsed, "--model") } } : {},
             ...value(parsed, "--thinking") ? { thinkingOptionId: value(parsed, "--thinking") } : {},
             ...parentThread ? { parentThreadId: normalizeThreadId(parentThread) } : {},
@@ -3930,7 +4117,6 @@ async function runDelegationCli(input) {
       return 0;
     }
     if (group === "thread" && command === "send") {
-      const parsed = options(rest);
       rejectUnknown(parsed, ["--message"]);
       if (parsed.positionals.length !== 1) {
         throw new DelegationControlError(
@@ -3946,8 +4132,8 @@ async function runDelegationCli(input) {
           "Thread identifier and --message are required"
         );
       }
-      writeJson(
-        output,
+      writeResult(
+        "thread send",
         await requestRuntime({
           environment,
           path: "/v1/thread/send",
@@ -3958,7 +4144,6 @@ async function runDelegationCli(input) {
       return 0;
     }
     if (group === "thread" && command === "cancel") {
-      const parsed = options(rest);
       rejectUnknown(parsed, []);
       if (parsed.positionals.length !== 1) {
         throw new DelegationControlError(
@@ -3970,8 +4155,8 @@ async function runDelegationCli(input) {
       if (!threadId3) {
         throw new DelegationControlError("INVALID_ARGUMENT", "Thread identifier is required");
       }
-      writeJson(
-        output,
+      writeResult(
+        "thread cancel",
         await requestRuntime({
           environment,
           path: "/v1/thread/cancel",
@@ -3982,7 +4167,6 @@ async function runDelegationCli(input) {
       return 0;
     }
     if (group === "thread" && (command === "read" || command === "wait")) {
-      const parsed = options(rest);
       rejectUnknown(parsed, ["--view", "--cursor", "--limit", "--timeout-ms"]);
       if (parsed.positionals.length !== 1)
         throw new DelegationControlError(
@@ -4014,19 +4198,19 @@ async function runDelegationCli(input) {
           timeoutMs: value(parsed, "--timeout-ms") ? positiveInteger(value(parsed, "--timeout-ms"), "--timeout-ms") : DEFAULT_WAIT_TIMEOUT_MS
         } : {}
       };
-      writeJson(
-        output,
+      writeResult(
+        command === "read" ? "thread read" : "thread wait",
         await requestRuntime({
           environment,
           path: command === "read" ? "/v1/thread/read" : "/v1/thread/wait",
           body,
           ...input.fetchImpl ? { fetchImpl: input.fetchImpl } : {}
-        })
+        }),
+        view
       );
       return 0;
     }
     if (group === "thread" && command === "list") {
-      const parsed = options(rest);
       rejectUnknown(parsed, ["--cwd", "--parent", "--limit", "--cursor", "--sort"]);
       if (parsed.positionals.length > 0)
         throw new DelegationControlError(
@@ -4044,8 +4228,8 @@ async function runDelegationCli(input) {
       ])).has(sort))
         throw new DelegationControlError("INVALID_ARGUMENT", "--sort is invalid");
       const parentThread = value(parsed, "--parent");
-      writeJson(
-        output,
+      writeResult(
+        "thread list",
         await requestRuntime({
           environment,
           path: "/v1/thread/list",
@@ -4083,7 +4267,7 @@ async function runDelegationCli(input) {
 
 // packages/host-runtime/src/run-host-runtime.ts
 import { randomBytes } from "node:crypto";
-import path20 from "node:path";
+import path21 from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
@@ -4429,9 +4613,85 @@ function selectInstallerReleaseArtifact(release, target) {
   });
 }
 
+// packages/update-manager/dist/github-cli-release.js
+import { execFile } from "node:child_process";
+import path2 from "node:path";
+var GITHUB_LATEST_RELEASE_ENDPOINT = "repos/BytePioneer-AI/codex-host/releases/latest";
+var MAX_RELEASE_RESPONSE_BYTES = 1024 * 1024;
+var GITHUB_CLI_TIMEOUT_MS = 5e3;
+function defaultExecutableCandidates(environment, platform) {
+  if (environment.CODEXHOST_GH_COMMAND)
+    return [environment.CODEXHOST_GH_COMMAND];
+  const candidates = ["gh"];
+  if (platform === "darwin") {
+    candidates.push("/opt/homebrew/bin/gh", "/usr/local/bin/gh");
+  } else if (platform === "win32") {
+    const programFiles = environment.ProgramFiles ?? environment.PROGRAMFILES;
+    const localAppData = environment.LOCALAPPDATA;
+    if (programFiles)
+      candidates.push(path2.win32.join(programFiles, "GitHub CLI", "gh.exe"));
+    if (localAppData) {
+      candidates.push(path2.win32.join(localAppData, "Programs", "GitHub CLI", "gh.exe"));
+    }
+  } else {
+    candidates.push("/usr/local/bin/gh", "/usr/bin/gh", "/snap/bin/gh");
+  }
+  return [...new Set(candidates.filter((candidate) => Boolean(candidate)))];
+}
+function runGitHubCli(executable2, arguments_2, options2) {
+  return new Promise((resolve, reject) => {
+    execFile(executable2, [...arguments_2], {
+      encoding: "utf8",
+      env: options2.environment,
+      maxBuffer: MAX_RELEASE_RESPONSE_BYTES,
+      timeout: GITHUB_CLI_TIMEOUT_MS,
+      windowsHide: true,
+      ...options2.signal ? { signal: options2.signal } : {}
+    }, (error51, stdout) => {
+      if (error51)
+        reject(error51);
+      else
+        resolve(stdout);
+    });
+  });
+}
+async function fetchLatestGitHubReleaseWithGitHubCli(options2 = {}) {
+  const environment = options2.environment ?? process.env;
+  const platform = options2.platform ?? process.platform;
+  const candidates = options2.executableCandidates ?? defaultExecutableCandidates(environment, platform);
+  const run = options2.run ?? runGitHubCli;
+  const arguments_2 = [
+    "api",
+    "--hostname",
+    "github.com",
+    "--method",
+    "GET",
+    "--header",
+    "Accept: application/vnd.github+json",
+    "--header",
+    "X-GitHub-Api-Version: 2022-11-28",
+    GITHUB_LATEST_RELEASE_ENDPOINT
+  ];
+  for (const executable2 of candidates) {
+    options2.signal?.throwIfAborted();
+    try {
+      return parseLatestGitHubRelease(JSON.parse(await run(executable2, arguments_2, {
+        environment,
+        ...options2.signal ? { signal: options2.signal } : {}
+      })));
+    } catch (error51) {
+      options2.signal?.throwIfAborted();
+      const code = error51?.code;
+      if (code !== "ENOENT" && code !== "EACCES")
+        return null;
+    }
+  }
+  return null;
+}
+
 // packages/update-manager/dist/operation-state.js
 import { lstat as lstat2, mkdir, open, readFile as readFile2, readdir, rm, writeFile } from "node:fs/promises";
-import path2 from "node:path";
+import path3 from "node:path";
 var LOCK_FILE = "active-update-v1.lock";
 var STATUS_FILE = "status-v1.json";
 var TERMINAL_PHASES = /* @__PURE__ */ new Set(["succeeded", "failed"]);
@@ -4446,12 +4706,12 @@ async function regularFile(filePath) {
   }
 }
 async function isUpdateOperationActive(stateDirectory) {
-  if (!path2.isAbsolute(stateDirectory))
+  if (!path3.isAbsolute(stateDirectory))
     throw new Error("update state directory must be absolute");
-  return regularFile(path2.join(stateDirectory, LOCK_FILE));
+  return regularFile(path3.join(stateDirectory, LOCK_FILE));
 }
 async function discoverLatestUpdateStatus(stateDirectory) {
-  if (!path2.isAbsolute(stateDirectory))
+  if (!path3.isAbsolute(stateDirectory))
     throw new Error("update state directory must be absolute");
   let entries;
   try {
@@ -4465,7 +4725,7 @@ async function discoverLatestUpdateStatus(stateDirectory) {
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.isSymbolicLink() || !entry.name.startsWith("update-"))
       continue;
-    const statusPath = path2.join(stateDirectory, entry.name, STATUS_FILE);
+    const statusPath = path3.join(stateDirectory, entry.name, STATUS_FILE);
     if (!await regularFile(statusPath))
       continue;
     try {
@@ -4493,8 +4753,8 @@ async function cleanupTerminalUpdateState(stateDirectory, options2 = {}) {
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.isSymbolicLink() || !entry.name.startsWith("update-"))
       continue;
-    const directory = path2.join(stateDirectory, entry.name);
-    const statusPath = path2.join(directory, STATUS_FILE);
+    const directory = path3.join(stateDirectory, entry.name);
+    const statusPath = path3.join(directory, STATUS_FILE);
     try {
       const status = parseUpdateStatus(JSON.parse(await readFile2(statusPath, "utf8")));
       if (TERMINAL_PHASES.has(status.phase) && now - status.updatedAt > retentionSeconds) {
@@ -4505,10 +4765,10 @@ async function cleanupTerminalUpdateState(stateDirectory, options2 = {}) {
   }
 }
 async function acquireUpdateOperationLock(stateDirectory) {
-  if (!path2.isAbsolute(stateDirectory))
+  if (!path3.isAbsolute(stateDirectory))
     throw new Error("update state directory must be absolute");
   await mkdir(stateDirectory, { recursive: true, mode: 448 });
-  const lockPath = path2.join(stateDirectory, LOCK_FILE);
+  const lockPath = path3.join(stateDirectory, LOCK_FILE);
   let handle;
   try {
     handle = await open(lockPath, "wx", 384);
@@ -4527,9 +4787,9 @@ async function acquireUpdateOperationLock(stateDirectory) {
     async setStatusPath(statusPath) {
       if (released)
         throw new Error("update operation lock is released");
-      if (!path2.isAbsolute(statusPath))
+      if (!path3.isAbsolute(statusPath))
         throw new Error("update status path must be absolute");
-      await writeFile(lockPath, `${JSON.stringify({ ownerPid: process.pid, statusPath: path2.normalize(statusPath) })}
+      await writeFile(lockPath, `${JSON.stringify({ ownerPid: process.pid, statusPath: path3.normalize(statusPath) })}
 `, { encoding: "utf8", mode: 384 });
     },
     async release() {
@@ -4551,7 +4811,7 @@ function processIsAlive(processId) {
   }
 }
 async function recoverUpdateOperationLock(stateDirectory) {
-  const lockPath = path2.join(stateDirectory, LOCK_FILE);
+  const lockPath = path3.join(stateDirectory, LOCK_FILE);
   if (!await regularFile(lockPath))
     return;
   let ownerPid;
@@ -4563,7 +4823,7 @@ async function recoverUpdateOperationLock(stateDirectory) {
   } catch {
     return;
   }
-  if (typeof statusPath !== "string" || !path2.isAbsolute(statusPath))
+  if (typeof statusPath !== "string" || !path3.isAbsolute(statusPath))
     return;
   try {
     const status = parseUpdateStatus(JSON.parse(await readFile2(statusPath, "utf8")));
@@ -4578,7 +4838,7 @@ async function recoverUpdateOperationLock(stateDirectory) {
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { chmod, copyFile, lstat as lstat4, mkdir as mkdir2, readFile as readFile3, rename, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
-import path3 from "node:path";
+import path4 from "node:path";
 
 // packages/update-manager/dist/artifact.js
 import { createHash } from "node:crypto";
@@ -4699,9 +4959,9 @@ async function replaceStatusFile(temporaryPath, statusPath) {
   }
 }
 function requireAbsolutePath(value2, label) {
-  if (!path3.isAbsolute(value2))
+  if (!path4.isAbsolute(value2))
     throw new Error(`${label} must be an absolute path`);
-  return path3.normalize(value2);
+  return path4.normalize(value2);
 }
 async function requireRegularFile(value2, label) {
   const filePath = requireAbsolutePath(value2, label);
@@ -4744,7 +5004,7 @@ function createBackgroundUpdateManager(dependencies2 = {}) {
   const now = dependencies2.now ?? Date.now;
   const preparedRequests = /* @__PURE__ */ new Set();
   async function writeStatusSnapshot(statusPath, status) {
-    const temporaryPath = path3.join(path3.dirname(statusPath), `.update-status-${randomId()}.tmp`);
+    const temporaryPath = path4.join(path4.dirname(statusPath), `.update-status-${randomId()}.tmp`);
     try {
       await writeFile2(temporaryPath, `${JSON.stringify(status)}
 `, {
@@ -4804,15 +5064,15 @@ function createBackgroundUpdateManager(dependencies2 = {}) {
     const updaterExecutable = await requireRegularFile(options2.updaterExecutable, "Updater executable");
     const stateDirectory = requireAbsolutePath(options2.stateDirectory, "update state directory");
     await mkdir2(stateDirectory, { recursive: true, mode: 448 });
-    const workDirectory = path3.join(stateDirectory, `update-${version2}-${randomId()}`);
+    const workDirectory = path4.join(stateDirectory, `update-${version2}-${randomId()}`);
     await mkdir2(workDirectory, { recursive: false, mode: 448 });
     const executableSuffix = platform === "win32" ? ".exe" : "";
-    const helperPath = path3.join(workDirectory, `codexhost-updater${executableSuffix}`);
+    const helperPath = path4.join(workDirectory, `codexhost-updater${executableSuffix}`);
     await copyFile(updaterExecutable, helperPath);
     if (platform !== "win32")
       await chmod(helperPath, 448);
-    const requestPath = path3.join(workDirectory, "request-v1.json");
-    const statusPath = path3.join(workDirectory, "status-v1.json");
+    const requestPath = path4.join(workDirectory, "request-v1.json");
+    const statusPath = path4.join(workDirectory, "status-v1.json");
     await writePrivateJson(statusPath, preparedStatus(version2, installation, now()));
     await options2.onPrepared?.({ version: version2, installation, statusPath });
     return {
@@ -4828,8 +5088,8 @@ function createBackgroundUpdateManager(dependencies2 = {}) {
   }
   async function prepareArtifact(common, installation, sourceValue, fileName) {
     const source = validateArtifact(sourceValue);
-    const temporaryPath = path3.join(common.workDirectory, `.${fileName}.download`);
-    const artifactPath = path3.join(common.workDirectory, fileName);
+    const temporaryPath = path4.join(common.workDirectory, `.${fileName}.download`);
+    const artifactPath = path4.join(common.workDirectory, fileName);
     const progress = progressReporter(common.statusPath, common.version, installation, source.size);
     try {
       const result = await download(source, temporaryPath, progress.update);
@@ -4903,7 +5163,7 @@ function createBackgroundUpdateManager(dependencies2 = {}) {
         throw new Error("macOS DMG updates require macOS");
       const common = await prepareCommon(options2, "macos-dmg");
       const appPath = requireAbsolutePath(options2.appPath, "macOS application path");
-      if (path3.extname(appPath) !== ".app") {
+      if (path4.extname(appPath) !== ".app") {
         throw new Error("macOS application path must end in .app");
       }
       const artifact = await prepareArtifact(common, "macos-dmg", options2.artifact, "update.dmg");
@@ -5702,10 +5962,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);
@@ -6114,11 +6374,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;
   });
 }
@@ -6265,16 +6525,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 {
@@ -6301,17 +6561,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;
@@ -6343,8 +6603,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")
@@ -19036,13 +19296,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}`);
     }
@@ -20465,7 +20725,7 @@ import { execFileSync } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { constants } from "node:fs";
 import { copyFile as copyFile2, mkdir as mkdir3, open as open3, readFile as readFile4, readdir as readdir2, rename as rename2, rm as rm3, stat } from "node:fs/promises";
-import path4 from "node:path";
+import path5 from "node:path";
 
 // packages/mapping-store/dist/records.js
 var nonBlankTextSchema6 = external_exports.string().refine((value2) => value2.trim().length > 0, {
@@ -20716,12 +20976,12 @@ var MappingStore = class {
   #initialized = false;
   #lockHandle = null;
   constructor(options2) {
-    this.#directory = path4.resolve(options2.directory);
-    this.#threadsDirectory = path4.join(this.#directory, "threads");
-    this.#delegationsDirectory = path4.join(this.#directory, "delegations");
-    this.#backupsDirectory = path4.join(this.#directory, "backups");
-    this.#quarantineDirectory = path4.join(this.#directory, "quarantine");
-    this.#lockPath = path4.join(this.#directory, "store.lock");
+    this.#directory = path5.resolve(options2.directory);
+    this.#threadsDirectory = path5.join(this.#directory, "threads");
+    this.#delegationsDirectory = path5.join(this.#directory, "delegations");
+    this.#backupsDirectory = path5.join(this.#directory, "backups");
+    this.#quarantineDirectory = path5.join(this.#directory, "quarantine");
+    this.#lockPath = path5.join(this.#directory, "store.lock");
     this.#instanceId = options2.instanceId ?? randomUUID2();
     this.#now = options2.now ?? (() => /* @__PURE__ */ new Date());
     this.#beforeReplace = options2.beforeReplace;
@@ -20740,8 +21000,8 @@ var MappingStore = class {
       await this.#cleanupResidue();
       const names = (await readdir2(this.#threadsDirectory)).filter((name) => name.endsWith(".json"));
       for (const name of names) {
-        const primary = path4.join(this.#threadsDirectory, name);
-        const backup = path4.join(this.#backupsDirectory, name);
+        const primary = path5.join(this.#threadsDirectory, name);
+        const backup = path5.join(this.#backupsDirectory, name);
         let record3 = null;
         try {
           record3 = await this.#readRecord(primary, name);
@@ -20750,7 +21010,7 @@ var MappingStore = class {
             record3 = await this.#readRecord(backup, name);
             await this.#replaceFile(primary, record3, false);
           } catch (backupError) {
-            const quarantine = path4.join(this.#quarantineDirectory, `${name}.${this.#now().getTime()}.invalid`);
+            const quarantine = path5.join(this.#quarantineDirectory, `${name}.${this.#now().getTime()}.invalid`);
             await rename2(primary, quarantine).catch(() => void 0);
             void primaryError;
             void backupError;
@@ -20766,14 +21026,14 @@ var MappingStore = class {
       }
       const delegationNames = (await readdir2(this.#delegationsDirectory)).filter((name) => name.endsWith(".json"));
       for (const name of delegationNames) {
-        const file2 = path4.join(this.#delegationsDirectory, name);
+        const file2 = path5.join(this.#delegationsDirectory, name);
         try {
           const parsed = storedDelegationRecordV1Schema.parse(JSON.parse(await readFile4(file2, "utf8")));
           if (`${parsed.delegationId}.json` !== name)
             throw new Error("filename mismatch");
           this.#delegations.set(parsed.delegationId, parsed);
         } catch {
-          const quarantine = path4.join(this.#quarantineDirectory, `${name}.${this.#now().getTime()}.invalid-delegation`);
+          const quarantine = path5.join(this.#quarantineDirectory, `${name}.${this.#now().getTime()}.invalid-delegation`);
           await rename2(file2, quarantine).catch(() => void 0);
         }
       }
@@ -20931,10 +21191,35 @@ var MappingStore = class {
       turnMappings: this.#mergeMappings(current.turnMappings, input.turnMappings ?? [])
     }));
   }
+  // Keep native ref, Turn mappings and the indexed create request in one serialized
+  // record mutation; separate setters could leave a child pointing at mixed Sessions.
+  async rebindSubagentSession(input) {
+    return this.#update(input.hostThreadId, (current) => {
+      const parent = this.#records.get(input.parentHostThreadId);
+      if (current.state !== "ready" || !current.nativeSessionRef || current.subagent?.parentHostThreadId !== input.parentHostThreadId || parent?.state !== "ready" || parent.harnessId !== current.harnessId || input.previousNativeSessionRef.harnessId !== current.harnessId || input.nativeSessionRef.harnessId !== current.harnessId || !sameJson(parent.nativeSessionRef, input.nativeSessionRef))
+        throw new MappingStoreError("MAPPING_CONFLICT", "Subagent replacement must belong to its current parent Session");
+      if (sameJson(current.nativeSessionRef, input.nativeSessionRef) && current.createRequestId === input.createRequestId)
+        return null;
+      if (!sameJson(current.nativeSessionRef, input.previousNativeSessionRef)) {
+        throw new MappingStoreError("MAPPING_CONFLICT", "Subagent replacement source Session is stale");
+      }
+      const nativeSessionId = input.nativeSessionRef.nativeSessionId;
+      return {
+        ...current,
+        createRequestId: input.createRequestId,
+        nativeSessionRef: input.nativeSessionRef,
+        turnMappings: current.turnMappings.map((mapping) => ({
+          ...mapping,
+          nativeTurnRef: { ...mapping.nativeTurnRef, nativeSessionId },
+          ...mapping.nativeCheckpointRef ? { nativeCheckpointRef: { ...mapping.nativeCheckpointRef, nativeSessionId } } : {}
+        }))
+      };
+    });
+  }
   async replaceReadySession(input) {
     return this.#update(input.hostThreadId, (current) => {
-      if (current.state !== "ready" || !current.nativeSessionRef || !current.forkSource || current.forkSource.hostThreadId !== input.forkSource.hostThreadId || current.nativeSessionRef.nativeSessionId === input.nativeSessionRef.nativeSessionId || input.turnMappings.length < 1 || input.turnMappings.length >= current.turnMappings.length || input.turnMappings.some(({ hostTurnId }, index) => hostTurnId !== current.turnMappings[index]?.hostTurnId)) {
-        throw new MappingStoreError("MAPPING_CONFLICT", "Ready Session replacement must retain an exact shorter derived prefix");
+      if (current.state !== "ready" || !current.nativeSessionRef || current.revision !== input.expectedRevision || !sameJson(current.nativeSessionRef, input.expectedNativeSessionRef) || !current.forkSource || current.forkSource.hostThreadId !== input.forkSource.hostThreadId || current.nativeSessionRef.nativeSessionId === input.nativeSessionRef.nativeSessionId || input.turnMappings.length < 1 || input.turnMappings.length >= current.turnMappings.length || input.turnMappings.some(({ hostTurnId }, index) => hostTurnId !== current.turnMappings[index]?.hostTurnId)) {
+        throw new MappingStoreError("MAPPING_CONFLICT", "Ready Session replacement must match the expected record and retain an exact shorter derived prefix");
       }
       return {
         ...current,
@@ -20946,8 +21231,8 @@ var MappingStore = class {
   }
   async replaceReadySessionAfterLastTurn(input) {
     return this.#update(input.hostThreadId, (current) => {
-      if (current.state !== "ready" || !current.nativeSessionRef || input.turnMappings.length !== current.turnMappings.length - 1 || input.turnMappings.some(({ hostTurnId }, index) => hostTurnId !== current.turnMappings[index]?.hostTurnId)) {
-        throw new MappingStoreError("MAPPING_CONFLICT", "Last-Turn Session replacement must retain the exact shorter Host Turn prefix");
+      if (current.state !== "ready" || !current.nativeSessionRef || current.revision !== input.expectedRevision || !sameJson(current.nativeSessionRef, input.expectedNativeSessionRef) || input.turnMappings.length !== current.turnMappings.length - 1 || input.turnMappings.some(({ hostTurnId }, index) => hostTurnId !== current.turnMappings[index]?.hostTurnId)) {
+        throw new MappingStoreError("MAPPING_CONFLICT", "Last-Turn Session replacement must match the expected record and retain the exact shorter Host Turn prefix");
       }
       return {
         ...current,
@@ -21168,10 +21453,10 @@ var MappingStore = class {
       readdir2(this.#directory)
     ]);
     await Promise.all([
-      ...threadNames.filter((name) => name.includes(".tmp-")).map((name) => rm3(path4.join(this.#threadsDirectory, name), { force: true })),
-      ...delegationNames.filter((name) => name.includes(".tmp-")).map((name) => rm3(path4.join(this.#delegationsDirectory, name), { force: true })),
+      ...threadNames.filter((name) => name.includes(".tmp-")).map((name) => rm3(path5.join(this.#threadsDirectory, name), { force: true })),
+      ...delegationNames.filter((name) => name.includes(".tmp-")).map((name) => rm3(path5.join(this.#delegationsDirectory, name), { force: true })),
       // Renamed aside by #acquireLock; nothing reads them back, and they accumulate one per run.
-      ...rootNames.filter((name) => name.startsWith(`${path4.basename(this.#lockPath)}.stale-`)).map((name) => rm3(path4.join(this.#directory, name), { force: true }))
+      ...rootNames.filter((name) => name.startsWith(`${path5.basename(this.#lockPath)}.stale-`)).map((name) => rm3(path5.join(this.#directory, name), { force: true }))
     ]);
   }
   async #acquireLock() {
@@ -21272,13 +21557,13 @@ var MappingStore = class {
     await next;
   }
   #recordPath(hostThreadId) {
-    return path4.join(this.#threadsDirectory, `${hostThreadId}.json`);
+    return path5.join(this.#threadsDirectory, `${hostThreadId}.json`);
   }
   #delegationPath(delegationId) {
-    return path4.join(this.#delegationsDirectory, `${delegationId}.json`);
+    return path5.join(this.#delegationsDirectory, `${delegationId}.json`);
   }
   #backupPath(hostThreadId) {
-    return path4.join(this.#backupsDirectory, `${hostThreadId}.json`);
+    return path5.join(this.#backupsDirectory, `${hostThreadId}.json`);
   }
   #requireInitialized() {
     if (!this.#initialized) {
@@ -22031,8 +22316,8 @@ function projectFileChangeKind(kind) {
   return { type: kind };
 }
 function projectFileChanges(changes) {
-  return changes.map(({ path: path25, kind, unifiedDiff }) => ({
-    path: path25,
+  return changes.map(({ path: path26, kind, unifiedDiff }) => ({
+    path: path26,
     kind: projectFileChangeKind(kind),
     diff: unifiedDiff
   }));
@@ -22253,7 +22538,9 @@ function projectItem(item, outcome, defaultCwd, includeCommandOutput = true, sen
         changes: projectFileChanges(item.changes),
         status: itemStatus(outcome)
       };
-    case "subagentDelegation":
+    case "subagentDelegation": {
+      const primary = item.subagents[0];
+      const sameConfiguration = item.subagents.every((subagent) => subagent.model === primary?.model && subagent.reasoningEffort === primary?.reasoningEffort);
       return {
         id: item.itemId,
         type: "collabAgentToolCall",
@@ -22262,13 +22549,14 @@ function projectItem(item, outcome, defaultCwd, includeCommandOutput = true, sen
         senderThreadId: senderThreadId ?? "",
         receiverThreadIds: item.subagents.map(({ subagentId }) => subagentId),
         prompt: item.prompt ?? null,
-        model: null,
-        reasoningEffort: null,
+        model: sameConfiguration ? primary?.model ?? null : null,
+        reasoningEffort: sameConfiguration ? primary?.reasoningEffort ?? null : null,
         agentsStates: Object.fromEntries(item.subagents.map(({ subagentId, status, resultSummary }) => [
           subagentId,
           { status: collabAgentStatus(status), message: resultSummary ?? null }
         ]))
       };
+    }
   }
 }
 function reasoningPreviewItemId(itemId) {
@@ -22344,9 +22632,9 @@ function projectHistoricalTurn(input) {
             return [];
         }
         return item.type === "reasoning" ? [
-          projectItem(item, outcome, cwd, true, ""),
+          projectItem(item, outcome, cwd, true, input.threadId ?? ""),
           projectReasoningTranscriptItem(item, outcome, cwd)
-        ] : [projectItem(item, outcome, cwd, true, "")];
+        ] : [projectItem(item, outcome, cwd, true, input.threadId ?? "")];
       })
     ],
     error: error51,
@@ -22978,13 +23266,13 @@ function decodeThreadForkRequest(request) {
   if (runtimeWorkspaceRoots !== void 0 && runtimeWorkspaceRoots !== null && (!Array.isArray(runtimeWorkspaceRoots) || runtimeWorkspaceRoots.some((root) => typeof root !== "string" || root.length === 0))) {
     throw new Error("thread/fork params.runtimeWorkspaceRoots must be text paths or null");
   }
-  const path25 = optionalText(params, "path", { allowEmpty: true });
+  const path26 = optionalText(params, "path", { allowEmpty: true });
   const ephemeral = optionalBoolean(params, "ephemeral");
   return {
     threadId: threadId3,
     ...lastTurnText ? { lastTurnId: hostTurnIdSchema.parse(lastTurnText) } : {},
     ...beforeTurnText ? { beforeTurnId: hostTurnIdSchema.parse(beforeTurnText) } : {},
-    ...path25 ? { path: path25 } : {},
+    ...path26 ? { path: path26 } : {},
     ...optionalField(params, "model"),
     ...optionalField(params, "modelProvider"),
     ...optionalField(params, "cwd"),
@@ -23995,18 +24283,149 @@ async function inspectHarnessAccounts(adapters, descriptors, timeoutMs = 12e3) {
 }
 
 // packages/host-runtime/src/app-server-host.ts
-import { createHash as createHash5, randomUUID as randomUUID8 } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID9 } from "node:crypto";
 import { rm as rm4 } from "node:fs/promises";
 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";
 
 // packages/host-runtime/src/external-thread-repository.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import os from "node:os";
-import path5 from "node:path";
+import path6 from "node:path";
+
+// packages/host-runtime/src/external-subagent-threads.ts
+import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
+function childCreateRequest(parent, nativeRef, id2) {
+  const key = createHash3("sha256").update(JSON.stringify([parent.hostThreadId, parent.harnessId, nativeRef.nativeSessionId, id2])).digest("hex");
+  return `subagent:${key}`;
+}
+function subagentMaterializer(store, parent, previousParent) {
+  if (previousParent && (previousParent.hostThreadId !== parent.hostThreadId || previousParent.harnessId !== parent.harnessId)) {
+    throw new Error("Subagent Session replacement must stay in the same Host Thread");
+  }
+  const previousRef = previousParent?.nativeSessionRef;
+  let legacy;
+  const legacyRecords = () => legacy ??= store.listThreads().then((records) => {
+    const byRequest = /* @__PURE__ */ new Map();
+    const children = /* @__PURE__ */ new Map();
+    for (const record3 of records) {
+      if (!record3.subagent || record3.harnessId !== parent.harnessId || !record3.nativeSessionRef)
+        continue;
+      const owner = {
+        hostThreadId: record3.subagent.parentHostThreadId,
+        harnessId: record3.harnessId
+      };
+      const key = childCreateRequest(
+        owner,
+        record3.nativeSessionRef,
+        record3.subagent.nativeSubagentId
+      );
+      if (!byRequest.has(key) || record3.state === "ready") byRequest.set(key, record3);
+      const siblings = children.get(owner.hostThreadId) ?? [];
+      siblings.push(record3);
+      children.set(owner.hostThreadId, siblings);
+    }
+    return { byRequest, children };
+  });
+  const rebind = async (existing, owner, visited = /* @__PURE__ */ new Set()) => {
+    if (!previousRef || !owner.nativeSessionRef || !existing.subagent || visited.has(existing.hostThreadId)) {
+      throw new Error("Invalid retained Subagent Session tree");
+    }
+    visited.add(existing.hostThreadId);
+    const rebound = await store.rebindSubagentSession({
+      hostThreadId: existing.hostThreadId,
+      parentHostThreadId: owner.hostThreadId,
+      previousNativeSessionRef: previousRef,
+      nativeSessionRef: owner.nativeSessionRef,
+      createRequestId: childCreateRequest(
+        owner,
+        owner.nativeSessionRef,
+        existing.subagent.nativeSubagentId
+      )
+    });
+    for (const descendant of (await legacyRecords()).children.get(existing.hostThreadId) ?? []) {
+      if (descendant.state === "ready" && descendant.nativeSessionRef?.nativeSessionId === previousRef.nativeSessionId) {
+        await rebind(descendant, rebound, visited);
+      }
+    }
+    return rebound;
+  };
+  return async (child) => {
+    if (!child.nativeSubagentId || !parent.nativeSessionRef || parent.state !== "ready")
+      return null;
+    const nativeRef = parent.nativeSessionRef;
+    const createRequestId = childCreateRequest(parent, nativeRef, child.nativeSubagentId);
+    const previousRequest = previousRef && previousRef.nativeSessionId !== nativeRef.nativeSessionId ? childCreateRequest(parent, previousRef, child.nativeSubagentId) : void 0;
+    let existing = await store.getThreadByCreateRequest(createRequestId);
+    if (!existing && previousRequest)
+      existing = await store.getThreadByCreateRequest(previousRequest);
+    if (!existing) {
+      const { byRequest } = await legacyRecords();
+      existing = byRequest.get(createRequestId) ?? (previousRequest ? byRequest.get(previousRequest) : void 0) ?? null;
+    }
+    if (existing?.state === "ready") {
+      if (existing.nativeSessionRef?.nativeSessionId === nativeRef.nativeSessionId) return existing;
+      if (!previousRef) throw new Error("Subagent belongs to a different Native Session");
+      return rebind(existing, parent);
+    }
+    const provisional = existing ?? await store.createProvisional({
+      hostThreadId: hostThreadIdSchema.parse(randomUUID3()),
+      createRequestId,
+      harnessId: parent.harnessId,
+      cwd: parent.cwd,
+      title: child.description,
+      transportModelId: parent.transportModelId,
+      ephemeral: parent.ephemeral,
+      historyMode: "paginated",
+      subagent: {
+        parentHostThreadId: parent.hostThreadId,
+        nativeSubagentId: child.nativeSubagentId,
+        ...child.role ? { role: child.role } : {}
+      }
+    });
+    return provisional.state === "ready" ? provisional : store.commitReady({
+      hostThreadId: provisional.hostThreadId,
+      nativeSessionRef: nativeRef
+    });
+  };
+}
+async function materializeExternalSubagent(store, parent, child) {
+  return subagentMaterializer(store, parent)(child);
+}
+async function projectExternalSnapshot(store, record3, snapshot, previousParent) {
+  const materialize = subagentMaterializer(store, record3, previousParent);
+  const turns = [];
+  for (const [index, turn] of snapshot.turns.entries()) {
+    const mapping = record3.turnMappings[index];
+    if (!mapping) throw new Error("External Snapshot mapping is incomplete");
+    const items = await Promise.all(
+      turn.items.map(async (entry) => {
+        if (entry.item.type !== "subagentDelegation") return entry;
+        const subagents = await Promise.all(
+          entry.item.subagents.map(async (child) => {
+            const stored = await materialize(child);
+            return stored ? { ...child, subagentId: stored.hostThreadId } : child;
+          })
+        );
+        return { ...entry, item: { ...entry.item, subagents } };
+      })
+    );
+    turns.push(
+      projectHistoricalTurn({
+        threadId: record3.hostThreadId,
+        turnId: mapping.hostTurnId,
+        cwd: record3.cwd,
+        snapshot: { ...turn, items }
+      })
+    );
+  }
+  return turns;
+}
+
+// packages/host-runtime/src/external-thread-repository.ts
 function nativeTurnKey2(ref) {
   return `${ref.harnessId}\0${ref.nativeSessionId}\0${ref.nativeTurnKey}\0${ref.formatVersion}`;
 }
@@ -24015,8 +24434,8 @@ function sameMapping(left, right) {
 }
 function defaultMappingStoreDirectory(environment) {
   const dataDirectory = environment.CODEXHOST_DATA_DIR;
-  return path5.join(
-    dataDirectory ? path5.resolve(dataDirectory) : path5.join(os.homedir(), ".codexhost"),
+  return path6.join(
+    dataDirectory ? path6.resolve(dataDirectory) : path6.join(os.homedir(), ".codexhost"),
     "mapping-store"
   );
 }
@@ -24041,6 +24460,9 @@ var ExternalThreadRepository = class {
   list() {
     return this.store.listThreads();
   }
+  materializeSubagent(parent, child) {
+    return materializeExternalSubagent(this.store, parent, child);
+  }
   findByCreateRequest(createRequestId) {
     return this.store.getThreadByCreateRequest(createRequestId);
   }
@@ -24110,7 +24532,7 @@ var ExternalThreadRepository = class {
         throw new Error("Derived Snapshot identity does not belong to its Native Session");
       }
       return {
-        hostTurnId: hostTurnIdSchema.parse(randomUUID3()),
+        hostTurnId: hostTurnIdSchema.parse(randomUUID4()),
         nativeTurnRef: turn.nativeTurnRef,
         ...turn.checkpoint ? { nativeCheckpointRef: turn.checkpoint } : {}
       };
@@ -24122,15 +24544,7 @@ var ExternalThreadRepository = class {
     });
     return {
       record: nextRecord,
-      turns: snapshot.turns.map((turn, index) => {
-        const mapping = mappings[index];
-        if (!mapping) throw new Error("Derived Snapshot mapping is incomplete");
-        return projectHistoricalTurn({
-          turnId: mapping.hostTurnId,
-          cwd: record3.cwd,
-          snapshot: turn
-        });
-      })
+      turns: await projectExternalSnapshot(this.store, nextRecord, snapshot)
     };
   }
   async commitForkRollback(derived, source, nativeSessionRef, snapshot) {
@@ -24164,6 +24578,8 @@ var ExternalThreadRepository = class {
     });
     const nextRecord = await this.store.replaceReadySession({
       hostThreadId: derived.hostThreadId,
+      expectedRevision: derived.revision,
+      expectedNativeSessionRef: derived.nativeSessionRef,
       nativeSessionRef,
       turnMappings: mappings,
       forkSource: {
@@ -24173,15 +24589,7 @@ var ExternalThreadRepository = class {
     });
     return {
       record: nextRecord,
-      turns: snapshot.turns.map((turn, index) => {
-        const mapping = mappings[index];
-        if (!mapping) throw new Error("External rollback Snapshot mapping is incomplete");
-        return projectHistoricalTurn({
-          turnId: mapping.hostTurnId,
-          cwd: derived.cwd,
-          snapshot: turn
-        });
-      })
+      turns: await projectExternalSnapshot(this.store, nextRecord, snapshot, derived)
     };
   }
   async commitLastTurnRollback(current, nativeSessionRef, snapshot) {
@@ -24201,30 +24609,26 @@ var ExternalThreadRepository = class {
     });
     const nextRecord = await this.store.replaceReadySessionAfterLastTurn({
       hostThreadId: current.hostThreadId,
+      expectedRevision: current.revision,
+      expectedNativeSessionRef: current.nativeSessionRef,
       nativeSessionRef,
       turnMappings: mappings
     });
     return {
       record: nextRecord,
-      turns: snapshot.turns.map((turn, index) => {
-        const mapping = mappings[index];
-        if (!mapping) throw new Error("Last-Turn rollback Snapshot mapping is incomplete");
-        return projectHistoricalTurn({
-          turnId: mapping.hostTurnId,
-          cwd: current.cwd,
-          snapshot: turn
-        });
-      })
+      turns: await projectExternalSnapshot(this.store, nextRecord, snapshot, current)
     };
   }
   async sessionTreeId(record3) {
     let current = record3;
     const visited = /* @__PURE__ */ new Set();
-    while (current.forkSource) {
+    while (current.subagent || current.forkSource) {
       if (visited.has(current.hostThreadId))
         throw new Error("External Thread Fork tree contains a cycle");
       visited.add(current.hostThreadId);
-      const source = await this.find(current.forkSource.hostThreadId);
+      const parentId = current.subagent?.parentHostThreadId ?? current.forkSource?.hostThreadId;
+      if (!parentId) break;
+      const source = await this.find(parentId);
       if (!source) break;
       current = source;
     }
@@ -24248,7 +24652,7 @@ var ExternalThreadRepository = class {
     const aligned = snapshot.turns.map((turn) => {
       const existing = mappingsByNative.get(nativeTurnKey2(turn.nativeTurnRef));
       const mapping = existing ?? {
-        hostTurnId: hostTurnIdSchema.parse(randomUUID3()),
+        hostTurnId: hostTurnIdSchema.parse(randomUUID4()),
         nativeTurnRef: turn.nativeTurnRef,
         ...turn.checkpoint ? { nativeCheckpointRef: turn.checkpoint } : {}
       };
@@ -24269,16 +24673,14 @@ var ExternalThreadRepository = class {
     const nextRecord = mappingsChanged ? await this.store.reconcileTurnMappings(record3.hostThreadId, orderedMappings) : record3;
     return {
       record: nextRecord,
-      turns: aligned.map(
-        ({ mapping, snapshot: turn }) => projectHistoricalTurn({ turnId: mapping.hostTurnId, cwd: record3.cwd, snapshot: turn })
-      )
+      turns: await projectExternalSnapshot(this.store, nextRecord, snapshot)
     };
   }
 };
 function createExternalThreadRecordInput(input) {
   return {
-    hostThreadId: input.hostThreadId ?? hostThreadIdSchema.parse(randomUUID3()),
-    createRequestId: input.createRequestId ?? randomUUID3(),
+    hostThreadId: input.hostThreadId ?? hostThreadIdSchema.parse(randomUUID4()),
+    createRequestId: input.createRequestId ?? randomUUID4(),
     harnessId: input.harnessId,
     cwd: input.cwd,
     ...input.title ? { title: input.title } : {},
@@ -24925,13 +25327,14 @@ async function restoreCurrentConfiguration(session, configuration) {
 }
 async function executeCurrentLastTurnRollback(input) {
   const { current, adapters, repository, runtime } = input;
-  if (current.record.turnMappings.length === 0) {
+  const currentRecord = current.record;
+  if (currentRecord.turnMappings.length === 0) {
     return {
       ok: false,
       error: { code: -32076, message: "External Thread has no Turn to roll back" }
     };
   }
-  const currentNativeRef = current.record.nativeSessionRef;
+  const currentNativeRef = currentRecord.nativeSessionRef;
   const adapter = adapters.get(current.harnessId);
   if (!currentNativeRef || !adapter) {
     return {
@@ -24979,7 +25382,7 @@ async function executeCurrentLastTurnRollback(input) {
     await session.close().catch(() => void 0);
     return { ok: false, error: mapExternalThreadHarnessError(snapshot.error, "read") };
   }
-  if (snapshot.value.turns.length !== current.record.turnMappings.length - 1) {
+  if (snapshot.value.turns.length !== currentRecord.turnMappings.length - 1) {
     await session.close().catch(() => void 0);
     return {
       ok: false,
@@ -24997,7 +25400,7 @@ async function executeCurrentLastTurnRollback(input) {
   let aligned;
   try {
     aligned = await repository.commitLastTurnRollback(
-      current.record,
+      currentRecord,
       finalNativeRef,
       snapshot.value
     );
@@ -25045,7 +25448,8 @@ async function executeExternalThreadRollback(input) {
       ...input.environment ? { environment: input.environment } : {}
     });
   }
-  const forkSource = derived.record.forkSource;
+  const derivedRecord = derived.record;
+  const forkSource = derivedRecord.forkSource;
   if (!forkSource) {
     return {
       ok: false,
@@ -25076,10 +25480,11 @@ async function executeExternalThreadRollback(input) {
     const sourceRefreshError = await runtime.refresh(source);
     if (sourceRefreshError) return { ok: false, error: sourceRefreshError };
   }
-  const sourceBoundaryIndex = source.record.turnMappings.findIndex(
+  const sourceRecord = source.record;
+  const sourceBoundaryIndex = sourceRecord.turnMappings.findIndex(
     ({ hostTurnId }) => hostTurnId === forkSource.hostTurnId
   );
-  if (sourceBoundaryIndex < 0 || derived.record.turnMappings.length !== sourceBoundaryIndex + 1) {
+  if (sourceBoundaryIndex < 0 || derivedRecord.turnMappings.length !== sourceBoundaryIndex + 1) {
     return {
       ok: false,
       error: {
@@ -25088,19 +25493,19 @@ async function executeExternalThreadRollback(input) {
       }
     };
   }
-  const excludedActiveTurnCount = source.running || source.record.turnMappings.length > derived.record.turnMappings.length ? 1 : 0;
-  const retainedCount = derived.record.turnMappings.length - rollback.numTurns + excludedActiveTurnCount;
-  if (retainedCount === derived.record.turnMappings.length) {
+  const excludedActiveTurnCount = source.running || sourceRecord.turnMappings.length > derivedRecord.turnMappings.length ? 1 : 0;
+  const retainedCount = derivedRecord.turnMappings.length - rollback.numTurns + excludedActiveTurnCount;
+  if (retainedCount === derivedRecord.turnMappings.length) {
     return { ok: true, thread: derived.thread };
   }
-  const boundary = source.record.turnMappings[retainedCount - 1];
+  const boundary = sourceRecord.turnMappings[retainedCount - 1];
   if (retainedCount < 1 || !boundary?.nativeCheckpointRef) {
     return {
       ok: false,
       error: { code: -32080, message: "External Fork Checkpoint is unavailable" }
     };
   }
-  const sourceNativeRef = source.record.nativeSessionRef;
+  const sourceNativeRef = sourceRecord.nativeSessionRef;
   const adapter = adapters.get(source.harnessId);
   if (!sourceNativeRef || !adapter) {
     return {
@@ -25128,7 +25533,7 @@ async function executeExternalThreadRollback(input) {
   }
   const session = opened.value;
   const finalNativeRef = session.initialState.nativeRef;
-  if (!finalNativeRef || finalNativeRef.nativeSessionId === sourceNativeRef.nativeSessionId || finalNativeRef.nativeSessionId === derived.record.nativeSessionRef?.nativeSessionId) {
+  if (!finalNativeRef || finalNativeRef.nativeSessionId === sourceNativeRef.nativeSessionId || finalNativeRef.nativeSessionId === derivedRecord.nativeSessionRef?.nativeSessionId) {
     await session.close().catch(() => void 0);
     return {
       ok: false,
@@ -25150,8 +25555,8 @@ async function executeExternalThreadRollback(input) {
   let aligned;
   try {
     aligned = await repository.commitForkRollback(
-      derived.record,
-      source.record,
+      derivedRecord,
+      sourceRecord,
       finalNativeRef,
       snapshot.value
     );
@@ -25396,9 +25801,43 @@ var ExternalThreadRuntime = class {
     } catch (error51) {
       this.#diagnose(error51);
     }
+    await this.#retireSubagents(current.id);
     this.#threads.delete(current.id);
     return this.register(input);
   }
+  async #retireSubagents(parentId) {
+    const ancestors = /* @__PURE__ */ new Map();
+    const descendant = async (record3) => {
+      const visited = /* @__PURE__ */ new Set();
+      let ownerId = record3?.subagent?.parentHostThreadId;
+      while (ownerId && !visited.has(ownerId)) {
+        if (ownerId === parentId) return true;
+        visited.add(ownerId);
+        let ancestor = ancestors.get(ownerId);
+        if (!ancestor) {
+          ancestor = this.#repository.find(ownerId);
+          ancestors.set(ownerId, ancestor);
+        }
+        ownerId = (await ancestor)?.subagent?.parentHostThreadId;
+      }
+      return false;
+    };
+    for (const [id2, restoring] of [...this.#restores]) {
+      if (await descendant(await this.#repository.find(id2))) {
+        await restoring.catch(this.#diagnose);
+      }
+    }
+    for (const child of this.#threads.values()) {
+      if (!await descendant(child.record)) continue;
+      this.#threads.delete(child.id);
+      try {
+        await child.session.close();
+        await child.outputTask;
+      } catch (error51) {
+        this.#diagnose(error51);
+      }
+    }
+  }
   async locate(threadId3) {
     const loaded = this.#threads.get(threadId3);
     if (loaded) return { kind: "external", record: loaded.record, thread: loaded };
@@ -25509,6 +25948,10 @@ var ExternalThreadRuntime = class {
         nativeSubagentId: subagent.nativeSubagentId,
         cwd: record3.cwd
       });
+      const latest = await this.#repository.find(record3.hostThreadId);
+      if (latest?.state === "ready" && latest.nativeSessionRef && JSON.stringify(latest.nativeSessionRef) !== JSON.stringify(parent)) {
+        return this.#restore(latest);
+      }
       if (!snapshot.ok) {
         throw new ExternalThreadOpenError(mapExternalThreadHarnessError(snapshot.error, "read"));
       }
@@ -25785,11 +26228,11 @@ var ExternalTurnSteering = class {
 };
 
 // packages/host-runtime/src/harness-delegation-coordinator.ts
-import { createHash as createHash4, randomUUID as randomUUID4 } from "node:crypto";
-import path6 from "node:path";
+import { createHash as createHash5, randomUUID as randomUUID5 } from "node:crypto";
+import path7 from "node:path";
 
 // packages/host-runtime/src/delegation-snapshot.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 var CURSOR_PREFIX = "codexhost:thread-messages:v1:";
 var DEFAULT_MESSAGE_LIMIT = 25;
 var MAX_MESSAGE_LIMIT = 100;
@@ -25843,7 +26286,7 @@ function allVisibleMessages(turns) {
   return messages;
 }
 function cursorFingerprint(threadId3) {
-  return createHash3("sha256").update(threadId3).digest("hex");
+  return createHash4("sha256").update(threadId3).digest("hex");
 }
 function encodeCursor(threadId3, offset) {
   const payload = JSON.stringify({ version: 1, fingerprint: cursorFingerprint(threadId3), offset });
@@ -25898,15 +26341,21 @@ function projectDelegationThreadSnapshot(input) {
   const latestTurnStatus = latestTurn ? turnStatus2(latestTurn.status) : null;
   const status = input.running ? "running" : latestTurnStatus === "failed" || latestTurnStatus === "interrupted" ? latestTurnStatus : threadStatus(input.thread.status, input.running);
   const latestTurnMessages = latestTurnId ? visible.filter((message) => message.turnId === latestTurnId && message.role === "agent") : [];
-  const final = latestTurnMessages.filter((message) => message.phase === "final").at(-1);
-  const progress = latestTurnMessages.filter((message) => message.phase !== "final").map(({ id: id2, turnId, text }) => ({ id: id2, turnId, text }));
+  const final = latestTurnMessages.filter((message) => message.phase === "final" && message.text.trim()).at(-1);
+  const progress = latestTurnMessages.filter((message) => message.phase !== "final" && message.text.trim()).map(({ id: id2, turnId, text }) => ({ id: id2, turnId, text }));
   const result = input.running ? { availability: "pending" } : final ? { availability: "available", text: final.text } : {
     availability: "unavailable",
     ...isRecord8(latestTurn?.error) && typeof latestTurn.error.message === "string" ? { message: latestTurn.error.message } : {}
   };
   const offset = options2.view === "messages" ? decodeCursor(input.threadId, options2.cursor) : visible.length;
-  const page = options2.view === "messages" ? visible.slice(offset, offset + options2.limit) : void 0;
-  const nextOffset = options2.view === "messages" ? offset + (page?.length ?? 0) : visible.length;
+  const page = options2.view === "messages" ? [] : void 0;
+  let nextOffset = offset;
+  if (page) {
+    while (nextOffset < visible.length && page.length < options2.limit) {
+      const message = visible[nextOffset++];
+      if (message?.text.trim()) page.push(message);
+    }
+  }
   return {
     threadId: input.threadId,
     harnessId: input.harnessId,
@@ -25914,7 +26363,10 @@ function projectDelegationThreadSnapshot(input) {
     turn: latestTurnId && latestTurnStatus ? { turnId: latestTurnId, status: latestTurnStatus } : null,
     progress,
     result,
-    ...page ? { messages: page } : {},
+    ...page ? {
+      messages: page,
+      hasMore: visible.slice(nextOffset).some((message) => message.text.trim())
+    } : {},
     nextCursor: encodeCursor(input.threadId, nextOffset)
   };
 }
@@ -25929,10 +26381,10 @@ function terminal(status) {
   return status === "completed" || status === "failed" || status === "interrupted";
 }
 function taskDigest(input) {
-  return createHash4("sha256").update(
+  return createHash5("sha256").update(
     JSON.stringify({
       task: input.task,
-      cwd: path6.resolve(input.cwd),
+      cwd: path7.resolve(input.cwd),
       modelId: input.model?.id ?? null,
       thinkingOptionId: input.thinkingOptionId ?? null
     })
@@ -25946,11 +26398,11 @@ function statusFromThread(thread) {
   return last ? "completed" : "creating";
 }
 function validateStart(input) {
-  if (!input.task?.trim())
+  if (typeof input.task !== "string" || !input.task.trim())
     throw new DelegationControlError("INVALID_ARGUMENT", "Task must not be empty");
-  if (!input.cwd?.trim())
+  if (input.cwd !== void 0 && (typeof input.cwd !== "string" || !input.cwd.trim()))
     throw new DelegationControlError("INVALID_ARGUMENT", "cwd must not be empty");
-  if (input.requestId !== void 0 && !input.requestId.trim()) {
+  if (input.requestId !== void 0 && (typeof input.requestId !== "string" || !input.requestId.trim())) {
     throw new DelegationControlError("INVALID_ARGUMENT", "Request ID must not be empty");
   }
 }
@@ -25968,6 +26420,7 @@ var HarnessDelegationCoordinator = class {
   #cancelOfficial;
   #startOfficial;
   #listOfficial;
+  #officialThreadCwd;
   #activeOfficialParents;
   constructor(input) {
     this.#adapters = input.adapters;
@@ -25983,8 +26436,12 @@ var HarnessDelegationCoordinator = class {
     this.#cancelOfficial = input.cancelOfficial;
     this.#startOfficial = input.startOfficial;
     this.#listOfficial = input.listOfficial;
+    this.#officialThreadCwd = input.officialThreadCwd;
     this.#activeOfficialParents = input.activeOfficialParents;
   }
+  async listHarnesses() {
+    return { harnesses: ["codex", ...this.#adapters.keys()] };
+  }
   async inspect(input) {
     if (input.harnessId === "codex") return this.#inspectOfficial(input);
     const adapter = this.#adapters.get(input.harnessId);
@@ -25998,7 +26455,7 @@ var HarnessDelegationCoordinator = class {
     return {
       harnessId: input.harnessId,
       inspection: await adapter.inspect({
-        ...input.cwd ? { cwd: path6.resolve(input.cwd) } : {},
+        ...input.cwd ? { cwd: path7.resolve(input.cwd) } : {},
         ...input.refresh !== void 0 ? { refresh: input.refresh } : {}
       })
     };
@@ -26006,7 +26463,13 @@ var HarnessDelegationCoordinator = class {
   async start(input) {
     validateStart(input);
     const parentThreadId = await this.#resolveParent(input.parentThreadId);
-    if (input.harnessId === "codex") return this.#startOfficial({ ...input, parentThreadId });
+    const parent = await this.#parentMetadata(parentThreadId);
+    const selectedCwd = input.cwd ?? parent.cwd ?? process.cwd();
+    if (input.harnessId === "codex") {
+      const result = await this.#startOfficial({ ...input, parentThreadId, cwd: selectedCwd });
+      return { ...result, parentThreadId, cwd: result.cwd ?? selectedCwd };
+    }
+    const startInput = { ...input, parentThreadId, cwd: path7.resolve(selectedCwd) };
     if (!this.#adapters.has(input.harnessId)) {
       throw new DelegationControlError(
         "HARNESS_NOT_FOUND",
@@ -26015,7 +26478,7 @@ var HarnessDelegationCoordinator = class {
       );
     }
     const targetHarnessId = input.harnessId;
-    const digest2 = taskDigest(input);
+    const digest2 = taskDigest(startInput);
     const duplicate = input.requestId ? await this.#repository.findDelegationByRequest(input.requestId) : await this.#repository.findRecentDelegation({
       parentHostThreadId: hostThreadIdSchema.parse(parentThreadId),
       targetHarnessId: harnessIdSchema.parse(targetHarnessId),
@@ -26042,21 +26505,20 @@ var HarnessDelegationCoordinator = class {
     if (input.model || input.thinkingOptionId) {
       const inspected = await this.inspect({
         harnessId: targetHarnessId,
-        cwd: input.cwd
+        cwd: startInput.cwd
       });
       this.#validateConfiguration(inspected.inspection, input.model, input.thinkingOptionId);
     }
-    const parent = await this.#parentMetadata(parentThreadId);
-    const delegationId = hostThreadIdSchema.parse(randomUUID4());
-    const childThreadId = hostThreadIdSchema.parse(randomUUID4());
-    const turnId = hostTurnIdSchema.parse(randomUUID4());
-    const createRequestId = input.requestId ? `delegation:${input.requestId}` : randomUUID4();
+    const delegationId = hostThreadIdSchema.parse(randomUUID5());
+    const childThreadId = hostThreadIdSchema.parse(randomUUID5());
+    const turnId = hostTurnIdSchema.parse(randomUUID5());
+    const createRequestId = input.requestId ? `delegation:${input.requestId}` : randomUUID5();
     let record3 = await this.#repository.createProvisional(
       createExternalThreadRecordInput({
         hostThreadId: childThreadId,
         createRequestId,
         harnessId: harnessIdSchema.parse(targetHarnessId),
-        cwd: path6.resolve(input.cwd),
+        cwd: startInput.cwd,
         title: input.task.trim().slice(0, 120),
         transportModelId: input.model || input.thinkingOptionId ? encodeExternalTransportSelection(targetHarnessId, {
           ...input.model ? { model: input.model } : {},
@@ -26127,17 +26589,21 @@ var HarnessDelegationCoordinator = class {
       }
       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 } : {}
-        }
-      });
+      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);
@@ -26171,7 +26637,7 @@ var HarnessDelegationCoordinator = class {
     if (thread.running || thread.activeTurnId) {
       throw new DelegationControlError("THREAD_BUSY", "Thread already has an active Turn");
     }
-    const turnId = hostTurnIdSchema.parse(randomUUID4());
+    const turnId = hostTurnIdSchema.parse(randomUUID5());
     try {
       await this.#startExternalTurn(thread, input.message, turnId);
     } catch (error51) {
@@ -26366,18 +26832,24 @@ var HarnessDelegationCoordinator = class {
   }
   async #parentMetadata(parentThreadId) {
     const record3 = await this.#repository.find(parentThreadId);
-    return { harnessId: record3 ? record3.harnessId : "codex" };
+    if (record3) return { harnessId: record3.harnessId, cwd: record3.cwd };
+    const cwd = await this.#officialThreadCwd(parentThreadId).catch(() => void 0);
+    return { harnessId: "codex", ...cwd ? { cwd } : {} };
   }
   async #existingResult(delegation) {
     const record3 = await this.#repository.find(delegation.childHostThreadId);
     const turnId = record3?.turnMappings.at(-1)?.hostTurnId ?? "pending";
-    return this.#result(
-      delegation.delegationId,
-      delegation.childHostThreadId,
-      turnId,
-      delegation.targetHarnessId,
-      delegation.status
-    );
+    return {
+      ...this.#result(
+        delegation.delegationId,
+        delegation.childHostThreadId,
+        turnId,
+        delegation.targetHarnessId,
+        delegation.status
+      ),
+      ...record3 ? { cwd: record3.cwd } : {},
+      parentThreadId: delegation.parentHostThreadId
+    };
   }
   #turnResult(threadId3, turnId, harnessId) {
     return {
@@ -26410,7 +26882,7 @@ var HarnessDelegationCoordinator = class {
 
 // packages/host-runtime/src/harness-plugin-loader.ts
 import { readdir as readdir3, realpath as realpath2 } from "node:fs/promises";
-import path8 from "node:path";
+import path9 from "node:path";
 import { pathToFileURL } from "node:url";
 
 // packages/host-runtime/src/harness-plugin-registry.ts
@@ -26448,16 +26920,16 @@ var HarnessPluginRegistry = class {
 
 // packages/host-runtime/src/plugin-files.ts
 import { open as open4, realpath, stat as stat2 } from "node:fs/promises";
-import path7 from "node:path";
+import path8 from "node:path";
 function inside(root, candidate) {
-  const relative = path7.relative(root, candidate);
-  return relative !== "" && !path7.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path7.sep}`);
+  const relative = path8.relative(root, candidate);
+  return relative !== "" && !path8.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path8.sep}`);
 }
 async function pluginResourcePath(root, relative) {
-  if (path7.isAbsolute(relative) || !inside(root, path7.resolve(root, relative))) {
+  if (path8.isAbsolute(relative) || !inside(root, path8.resolve(root, relative))) {
     throw new Error("Plugin resource escapes its root");
   }
-  const resolved = await realpath(path7.resolve(root, relative));
+  const resolved = await realpath(path8.resolve(root, relative));
   if (!inside(root, resolved) || !(await stat2(resolved)).isFile()) {
     throw new Error("Plugin resource must be a regular file inside its root");
   }
@@ -26602,7 +27074,7 @@ async function loadHarnessPlugins(options2) {
   const enabledIds = /* @__PURE__ */ new Set();
   const roots = /* @__PURE__ */ new Set();
   for (const configuredRoot of options2.roots) {
-    if (!path8.isAbsolute(configuredRoot)) {
+    if (!path9.isAbsolute(configuredRoot)) {
       diagnose({ code: "invalidRoot" });
       continue;
     }
@@ -26632,7 +27104,7 @@ async function loadHarnessPlugins(options2) {
       for (const directory of directories) {
         try {
           const file2 = await pluginResourcePath(root, `${directory.name}/manifest.json`);
-          const pluginRoot = await realpath2(path8.join(root, directory.name));
+          const pluginRoot = await realpath2(path9.join(root, directory.name));
           await pluginResourcePath(pluginRoot, "manifest.json");
           const manifest = harnessPluginManifestSchema.parse(
             JSON.parse(
@@ -26779,8 +27251,8 @@ function spawnOfficialAppServerConnection(input) {
 
 // packages/host-runtime/src/account/account-repository.ts
 import { mkdir as mkdir4, readFile as readFile5, rename as rename3, writeFile as writeFile3 } from "node:fs/promises";
-import path9 from "node:path";
-import { randomUUID as randomUUID5 } from "node:crypto";
+import path10 from "node:path";
+import { randomUUID as randomUUID6 } from "node:crypto";
 function validateAccountId(accountId) {
   if (!/^[A-Za-z0-9._~-]+$/u.test(accountId)) {
     throw new Error("Codex Account ID must be non-empty and filename-safe");
@@ -26798,19 +27270,19 @@ var AccountRepository = class {
   #mutationTail = Promise.resolve();
   #writeTail = Promise.resolve();
   constructor(input) {
-    this.#file = path9.join(path9.resolve(input.directory), "accounts.json");
+    this.#file = path10.join(path10.resolve(input.directory), "accounts.json");
     this.#defaultAccount = {
       ...input.defaultAccount,
       label: input.defaultAccount.label ?? input.defaultAccount.accountId
     };
     validateAccountId(this.#defaultAccount.accountId);
-    if (!path9.isAbsolute(this.#defaultAccount.codexHome)) {
+    if (!path10.isAbsolute(this.#defaultAccount.codexHome)) {
       throw new Error("Codex Account CODEX_HOME must be absolute");
     }
   }
   async initialize() {
     if (this.#initialized) return;
-    await mkdir4(path9.dirname(this.#file), { recursive: true });
+    await mkdir4(path10.dirname(this.#file), { recursive: true });
     let stored = null;
     try {
       stored = JSON.parse(await readFile5(this.#file, "utf8"));
@@ -26878,7 +27350,7 @@ var AccountRepository = class {
   async upsert(input) {
     this.#requireInitialized();
     validateAccountId(input.accountId);
-    if (!path9.isAbsolute(input.codexHome))
+    if (!path10.isAbsolute(input.codexHome))
       throw new Error("Codex Account CODEX_HOME must be absolute");
     return this.#mutate(async () => {
       const previous = this.#accounts.get(input.accountId);
@@ -26887,7 +27359,7 @@ var AccountRepository = class {
       const planType = input.planType === null ? void 0 : input.planType ?? previous?.planType;
       const account = {
         accountId: input.accountId,
-        codexHome: path9.normalize(input.codexHome),
+        codexHome: path10.normalize(input.codexHome),
         ...email3 ? { email: email3 } : {},
         ...planType ? { planType } : {},
         label: input.label ?? previous?.label ?? input.accountId,
@@ -26901,7 +27373,7 @@ var AccountRepository = class {
   }
   #validateAccount(account) {
     validateAccountId(account.accountId);
-    if (!path9.isAbsolute(account.codexHome)) throw new Error("Stored CODEX_HOME must be absolute");
+    if (!path10.isAbsolute(account.codexHome)) throw new Error("Stored CODEX_HOME must be absolute");
     if (account.email && (!account.email.includes("@") || account.email.length > 320)) {
       throw new Error("Stored Codex Account email is invalid");
     }
@@ -26922,7 +27394,7 @@ var AccountRepository = class {
       accounts: [...this.#accounts.values()]
     };
     const operation = this.#writeTail.then(async () => {
-      const temporary = `${this.#file}.${process.pid}.${randomUUID5()}.tmp`;
+      const temporary = `${this.#file}.${process.pid}.${randomUUID6()}.tmp`;
       await writeFile3(temporary, `${JSON.stringify(value2, null, 2)}
 `, { mode: 384 });
       await rename3(temporary, this.#file);
@@ -26945,19 +27417,19 @@ function isMissingFile(error51) {
 
 // packages/host-runtime/src/account/thread-account-store.ts
 import { mkdir as mkdir5, readFile as readFile6, rename as rename4, writeFile as writeFile4 } from "node:fs/promises";
-import { randomUUID as randomUUID6 } from "node:crypto";
-import path10 from "node:path";
+import { randomUUID as randomUUID7 } from "node:crypto";
+import path11 from "node:path";
 var ThreadAccountStore = class {
   #file;
   #bindings = /* @__PURE__ */ new Map();
   #initialized = false;
   #writeTail = Promise.resolve();
   constructor(input) {
-    this.#file = path10.join(path10.resolve(input.directory), "thread-accounts.json");
+    this.#file = path11.join(path11.resolve(input.directory), "thread-accounts.json");
   }
   async initialize() {
     if (this.#initialized) return;
-    await mkdir5(path10.dirname(this.#file), { recursive: true });
+    await mkdir5(path11.dirname(this.#file), { recursive: true });
     try {
       const stored = JSON.parse(await readFile6(this.#file, "utf8"));
       if (stored.formatVersion !== 1 || !stored.bindings || typeof stored.bindings !== "object") {
@@ -27016,7 +27488,7 @@ var ThreadAccountStore = class {
       bindings: Object.fromEntries(this.#bindings)
     };
     const operation = this.#writeTail.then(async () => {
-      const temporary = `${this.#file}.${process.pid}.${randomUUID6()}.tmp`;
+      const temporary = `${this.#file}.${process.pid}.${randomUUID7()}.tmp`;
       await writeFile4(temporary, `${JSON.stringify(value2, null, 2)}
 `, { mode: 384 });
       await rename4(temporary, this.#file);
@@ -27033,7 +27505,7 @@ function isMissingFile2(error51) {
 import { mkdir as mkdir6 } from "node:fs/promises";
 
 // packages/host-runtime/src/official-request-broker.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 var INTERNAL_REQUEST_PREFIX = "codexhost:official:";
 var MAX_RETIRED_IDS = 1024;
 function isRecord9(value2) {
@@ -27049,7 +27521,7 @@ var OfficialRequestBroker = class {
   constructor(input) {
     this.#send = input.send;
     this.#timeoutMs = input.timeoutMs ?? 3e4;
-    this.#nextId = input.nextId ?? (() => `${INTERNAL_REQUEST_PREFIX}${randomUUID7()}`);
+    this.#nextId = input.nextId ?? (() => `${INTERNAL_REQUEST_PREFIX}${randomUUID8()}`);
   }
   get pendingCount() {
     return this.#pending.size;
@@ -27413,21 +27885,45 @@ function externalAnchor(entry) {
   if (entry.source !== "external") throw new Error("Expected an External Thread list entry");
   return { timestamp: entry.timestamp, threadId: threadId(entry.thread) };
 }
-function includesExternalRecord(record3, query) {
+function includesExternalRecord(record3, query, byId) {
   if (record3.state !== "ready" || !record3.nativeSessionRef) return false;
-  if (record3.subagent) return false;
+  let current = record3;
+  const owners = /* @__PURE__ */ new Set();
+  while (current.subagent) {
+    if (owners.has(current.hostThreadId)) return false;
+    owners.add(current.hostThreadId);
+    const parent = byId.get(current.subagent.parentHostThreadId);
+    if (!parent || parent.state !== "ready" || parent.harnessId !== current.harnessId || parent.nativeSessionRef?.nativeSessionId !== current.nativeSessionRef?.nativeSessionId)
+      return false;
+    current = parent;
+  }
+  const sourceKind = record3.subagent ? "subAgentThreadSpawn" : "vscode";
+  const scoped = query.parentThreadId !== null || query.ancestorThreadId !== null;
+  if (record3.subagent && !scoped && !query.sourceKinds?.some((kind) => kind === "subAgent" || kind === "subAgentThreadSpawn"))
+    return false;
+  if (query.parentThreadId !== null && record3.subagent?.parentHostThreadId !== query.parentThreadId)
+    return false;
+  if (query.ancestorThreadId !== null) {
+    let parentId = record3.subagent?.parentHostThreadId;
+    const visited = /* @__PURE__ */ new Set([record3.hostThreadId]);
+    while (parentId && parentId !== query.ancestorThreadId && !visited.has(parentId)) {
+      visited.add(parentId);
+      parentId = byId.get(parentId)?.subagent?.parentHostThreadId;
+    }
+    if (record3.hostThreadId === query.ancestorThreadId || parentId !== query.ancestorThreadId)
+      return false;
+  }
   if (record3.archived !== query.archived) return false;
   if (query.cwd !== null && !query.cwd.includes(record3.cwd)) return false;
   if (query.modelProviders !== null && query.modelProviders.length > 0 && !query.modelProviders.includes("codexhost")) {
     return false;
   }
-  if (query.sourceKinds !== null && query.sourceKinds.length > 0 && !query.sourceKinds.includes("vscode")) {
+  if (query.sourceKinds !== null && query.sourceKinds.length > 0 && !query.sourceKinds.includes(sourceKind) && !(record3.subagent && query.sourceKinds.includes("subAgent"))) {
     return false;
   }
   if (query.searchTerm !== null && !record3.title.toLowerCase().includes(query.searchTerm.toLowerCase())) {
     return false;
   }
-  if (query.parentThreadId !== null || query.ancestorThreadId !== null) return false;
   if (query.isPinned === true) return false;
   return true;
 }
@@ -27437,25 +27933,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);
-      const sourceId = current.forkSource?.hostThreadId;
+      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;
@@ -27467,7 +27963,8 @@ function resolveExternalSessionTreeIds(records) {
 function listExternalThreadMetadata(input) {
   if (!input.query.supportsExternal) return { data: [], hasMore: false };
   const sessionIds = resolveExternalSessionTreeIds(input.records);
-  const entries = input.records.filter((record3) => includesExternalRecord(record3, input.query)).map((record3) => {
+  const byId = new Map(input.records.map((record3) => [record3.hostThreadId, record3]));
+  const entries = input.records.filter((record3) => includesExternalRecord(record3, input.query, byId)).map((record3) => {
     const runtime = input.runtimeFor(record3.hostThreadId);
     const sessionId = sessionIds.get(record3.hostThreadId);
     if (!sessionId) throw new Error("External Thread Session tree could not be resolved");
@@ -27549,6 +28046,7 @@ function threadId2(entry) {
   return entry.thread.id;
 }
 async function aggregateOfficialAccountThreadListPage(input) {
+  const pageLimit = typeof input.params.limit === "number" ? input.params.limit : input.query.limit;
   const cursorValue2 = typeof input.params.cursor === "string" ? input.params.cursor : null;
   const cursor = cursorValue2 ? decodeCursor2(cursorValue2) : { accounts: initialAccounts(input.accountIds) };
   const sources = Object.entries(cursor.accounts).map(([accountId, state]) => ({
@@ -27585,7 +28083,7 @@ async function aggregateOfficialAccountThreadListPage(input) {
         if (source.done) return null;
       }
       source.batchStart = source.cursor;
-      const page = await request(source, source.cursor, Math.max(1, input.query.limit));
+      const page = await request(source, source.cursor, Math.max(1, pageLimit));
       if (!source.requestedThisPage) {
         source.backwardsCursor = page.backwardsCursor;
         source.requestedThisPage = true;
@@ -27607,7 +28105,7 @@ async function aggregateOfficialAccountThreadListPage(input) {
   };
   const output = [];
   const emitted = /* @__PURE__ */ new Set();
-  while (output.length < input.query.limit) {
+  while (output.length < pageLimit) {
     const candidates = await Promise.all(
       sources.map(async (source) => ({ source, entry: await ensure(source) }))
     );
@@ -28141,18 +28639,18 @@ var AppServerHost = class {
     };
     this.#writer = new OrderedWriter(this.#options.desktopOutput);
     const environment = this.#options.environment ?? process.env;
-    const dataDirectory = path11.resolve(
-      environment.CODEXHOST_DATA_DIR ?? path11.join(os2.homedir(), ".codexhost")
+    const dataDirectory = path12.resolve(
+      environment.CODEXHOST_DATA_DIR ?? path12.join(os2.homedir(), ".codexhost")
     );
     const accountRepository = options2.accountRepository ?? new AccountRepository({
-      directory: path11.join(dataDirectory, "codex-accounts"),
+      directory: path12.join(dataDirectory, "codex-accounts"),
       defaultAccount: {
         accountId: "default",
-        codexHome: path11.resolve(environment.CODEX_HOME ?? path11.join(os2.homedir(), ".codex")),
+        codexHome: path12.resolve(environment.CODEX_HOME ?? path12.join(os2.homedir(), ".codex")),
         label: "Default Codex Account"
       }
     });
-    const threadAccountStore = options2.threadAccountStore ?? new ThreadAccountStore({ directory: path11.join(dataDirectory, "codex-accounts") });
+    const threadAccountStore = options2.threadAccountStore ?? new ThreadAccountStore({ directory: path12.join(dataDirectory, "codex-accounts") });
     this.#accountRepository = accountRepository;
     this.#threadAccountStore = threadAccountStore;
     this.#accountDataDirectory = dataDirectory;
@@ -28199,9 +28697,11 @@ var AppServerHost = class {
       cancelOfficial: (input) => this.#cancelOfficialDelegationThread(input),
       startOfficial: (input) => this.#startOfficialDelegation(input),
       listOfficial: (input) => this.#listDelegationThreads(input),
+      officialThreadCwd: (threadId3) => this.#readOfficialThreadCwd(threadId3),
       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),
@@ -28965,7 +29465,7 @@ var AppServerHost = class {
           throw new Error("Unknown Codex Account");
         const runtime = await this.#codexRuntimePool.get(params2.accountId);
         const response2 = await runtime.request("account/rateLimitResetCredit/consume", {
-          idempotencyKey: params2.idempotencyKey ?? randomUUID8()
+          idempotencyKey: params2.idempotencyKey ?? randomUUID9()
         });
         if (isRecord12(response2.error)) {
           await this.#writer.json(rpcEnvelope(request, { error: response2.error }));
@@ -29012,10 +29512,10 @@ var AppServerHost = class {
       }
       if (request.method === "codexhost/account/create") {
         const params2 = codexAccountCreateParamsSchema.parse(requestObject(request));
-        const accountId = randomUUID8();
+        const accountId = randomUUID9();
         const account = await this.#accountRepository.upsert({
           accountId,
-          codexHome: path11.join(this.#accountDataDirectory, "codex-homes", accountId),
+          codexHome: path12.join(this.#accountDataDirectory, "codex-homes", accountId),
           label: params2.label ?? `Codex Account ${accountId.slice(0, 8)}`
         });
         const activeAccountId = await this.#accountRepository.getActiveAccountId();
@@ -29071,12 +29571,12 @@ var AppServerHost = class {
         for (const [key, session2] of this.#officialLoginSessions) {
           if (session2.accountId === params2.accountId) this.#officialLoginSessions.delete(key);
         }
-        const managedCodexHome = path11.join(
+        const managedCodexHome = path12.join(
           this.#accountDataDirectory,
           "codex-homes",
           params2.accountId
         );
-        if (path11.resolve(account.codexHome) === path11.resolve(managedCodexHome)) {
+        if (path12.resolve(account.codexHome) === path12.resolve(managedCodexHome)) {
           try {
             await rm4(managedCodexHome, { recursive: true, force: true });
           } catch (error51) {
@@ -29225,6 +29725,13 @@ var AppServerHost = class {
     ]);
     return thread !== null || childDelegation !== null || delegation !== null;
   }
+  async #readOfficialThreadCwd(threadId3) {
+    const response = await this.#requestOfficial("thread/read", { threadId: threadId3 });
+    if (isRecord12(response.error)) return void 0;
+    const result = isRecord12(response.result) ? response.result : null;
+    const thread = result && isRecord12(result.thread) ? result.thread : null;
+    return thread && typeof thread.cwd === "string" && thread.cwd.trim() ? thread.cwd : void 0;
+  }
   async #inspectOfficialDelegationTarget(input) {
     const response = await this.#requestOfficial("model/list", {});
     if (isRecord12(response.error)) {
@@ -29293,7 +29800,7 @@ var AppServerHost = class {
       throw new DelegationControlError("INVALID_ARGUMENT", "Official Model Ref is invalid");
     }
     const nativeModelId = requestedModel ? decodeOfficialCodexModelRef(requestedModel) : void 0;
-    const digest2 = createHash5("sha256").update(
+    const digest2 = createHash6("sha256").update(
       JSON.stringify({
         task: input.task,
         cwd: input.cwd,
@@ -29396,7 +29903,7 @@ var AppServerHost = class {
       throw error51;
     }
     this.#activeOfficialTurns.set(threadId3, turnId);
-    const delegationId = hostThreadIdSchema.parse(randomUUID8());
+    const delegationId = hostThreadIdSchema.parse(randomUUID9());
     try {
       const source = await this.#repository.find(input.parentThreadId);
       const pendingTerminal = this.#pendingOfficialTerminalStatuses.get(threadId3);
@@ -29417,6 +29924,7 @@ var AppServerHost = class {
         harnessId: "codex",
         deepLink: `codex://threads/${threadId3}`,
         status: pendingTerminal ?? "running",
+        cwd: thread && typeof thread.cwd === "string" ? thread.cwd : input.cwd,
         ...requestedModel || input.thinkingOptionId ? {
           configuration: {
             requested: {
@@ -29559,7 +30067,7 @@ var AppServerHost = class {
   async #listDelegationThreads(input) {
     const [sortKey, sortDirection2] = input.sort.split("-");
     const request = {
-      id: `codexhost:delegation-list:${randomUUID8()}`,
+      id: `codexhost:delegation-list:${randomUUID9()}`,
       method: "thread/list",
       params: {
         cwd: input.cwd ? [input.cwd] : null,
@@ -29622,6 +30130,8 @@ var AppServerHost = class {
         records,
         runtimeFor: (threadId3) => {
           const thread = this.#externalRuntime.get(threadId3);
+          const subagentStatus = this.#subagentThreadStatuses.get(threadId3);
+          if (subagentStatus) return { running: subagentStatus === "active" };
           return thread ? { running: thread.running } : null;
         },
         requestOfficialPage: (params) => aggregateOfficialAccountThreadListPage({
@@ -30035,7 +30545,7 @@ var AppServerHost = class {
       );
       return;
     }
-    const turnId = requestedTurnId ?? hostTurnIdSchema.parse(randomUUID8());
+    const turnId = requestedTurnId ?? hostTurnIdSchema.parse(randomUUID9());
     const projection = {
       projector: new CodexTurnProjector({
         threadId: thread.id,
@@ -30894,7 +31404,7 @@ var AppServerHost = class {
     if (thread.running || thread.activeTurnId || this.#pendingExternalCommandRequests.has(thread.id)) {
       throw new ExternalSteerError(-32072, "External Thread already has an active Turn");
     }
-    const turnId = hostTurnIdSchema.parse(randomUUID8());
+    const turnId = hostTurnIdSchema.parse(randomUUID9());
     const startedAtMs = Date.now();
     const projection = {
       projector: new CodexTurnProjector({
@@ -31070,7 +31580,7 @@ var AppServerHost = class {
     if (event.type === "subagent.transcript.changed") {
       const nativeSubagentId = event.nativeSubagentId;
       const record3 = (await this.#repository.list()).find(
-        (candidate) => candidate.subagent?.parentHostThreadId === thread.id && candidate.subagent.nativeSubagentId === nativeSubagentId
+        (candidate) => candidate.subagent?.parentHostThreadId === thread.id && candidate.subagent.nativeSubagentId === nativeSubagentId && candidate.nativeSessionRef?.nativeSessionId === thread.record.nativeSessionRef?.nativeSessionId
       );
       if (record3) await this.#refreshOpenSubagentThread(record3.hostThreadId, false);
       return;
@@ -31078,7 +31588,7 @@ var AppServerHost = class {
     if (event.type === "subagent.state.changed") {
       const nativeSubagentId = event.nativeSubagentId;
       const record3 = (await this.#repository.list()).find(
-        (candidate) => candidate.subagent?.parentHostThreadId === thread.id && candidate.subagent.nativeSubagentId === nativeSubagentId
+        (candidate) => candidate.subagent?.parentHostThreadId === thread.id && candidate.subagent.nativeSubagentId === nativeSubagentId && candidate.nativeSessionRef?.nativeSessionId === thread.record.nativeSessionRef?.nativeSessionId
       );
       if (!record3) return;
       const status = event.status === "pending" || event.status === "running" ? "active" : "idle";
@@ -31182,33 +31692,13 @@ var AppServerHost = class {
   async #materializeSubagent(parent, subagent) {
     if (!subagent.nativeSubagentId || !parent.record.nativeSessionRef) return subagent;
     const status = subagent.status === "pending" || subagent.status === "running" ? "active" : "idle";
-    const records = await this.#repository.list();
-    const existing = records.find(
-      (record4) => record4.subagent?.parentHostThreadId === parent.id && record4.subagent.nativeSubagentId === subagent.nativeSubagentId
-    );
-    if (existing) {
-      this.#trackRunningSubagent(parent.id, existing.hostThreadId, status);
-      await this.#setSubagentThreadStatus(existing.hostThreadId, status);
-      return { ...subagent, subagentId: existing.hostThreadId };
+    const record3 = await this.#repository.materializeSubagent(parent.record, subagent);
+    if (!record3) return subagent;
+    if (this.#subagentThreadStatuses.has(record3.hostThreadId)) {
+      this.#trackRunningSubagent(parent.id, record3.hostThreadId, status);
+      await this.#setSubagentThreadStatus(record3.hostThreadId, status);
+      return { ...subagent, subagentId: record3.hostThreadId };
     }
-    const recordInput = createExternalThreadRecordInput({
-      harnessId: parent.record.harnessId,
-      cwd: parent.cwd,
-      title: subagent.description,
-      transportModelId: parent.transportModelId,
-      ephemeral: false,
-      historyMode: "paginated",
-      subagent: {
-        parentHostThreadId: parent.id,
-        nativeSubagentId: subagent.nativeSubagentId,
-        ...subagent.role ? { role: subagent.role } : {}
-      }
-    });
-    let record3 = await this.#repository.createProvisional(recordInput);
-    record3 = await this.#repository.commitNative(
-      record3.hostThreadId,
-      parent.record.nativeSessionRef
-    );
     const thread = externalThreadValue({
       record: record3,
       turns: [],
@@ -31452,7 +31942,7 @@ var AppServerHost = class {
     try {
       result = projection.projector.projectQuestion(
         interaction,
-        hostItemIdSchema.parse(randomUUID8())
+        hostItemIdSchema.parse(randomUUID9())
       );
     } catch (error51) {
       this.#diagnose(error51);
@@ -31608,7 +32098,7 @@ var AppServerHost = class {
 };
 
 // packages/host-runtime/src/codex-runtime/account-official-listeners.ts
-import path12 from "node:path";
+import path13 from "node:path";
 var AccountOfficialListeners = class {
   constructor(createListener) {
     this.createListener = createListener;
@@ -31619,7 +32109,7 @@ var AccountOfficialListeners = class {
   #closed = false;
   async endpoint(account) {
     if (this.#closed) throw new Error("Account official listeners are closed");
-    const key = path12.resolve(account.codexHome);
+    const key = path13.resolve(account.codexHome);
     const existing = this.#starting.get(key);
     if (existing) return existing;
     const listener = this.createListener(account);
@@ -31667,6 +32157,12 @@ var DelegationControlRegistry = class {
       "Harness inspection requires exactly one active Host Runtime session"
     ).inspect(input);
   }
+  async listHarnesses() {
+    return only(
+      [...this.#registrations],
+      "Harness discovery requires exactly one active Host Runtime session"
+    ).listHarnesses();
+  }
   async start(input) {
     return (await this.#registrationForStart(input)).start(input);
   }
@@ -31749,17 +32245,17 @@ var DelegationControlRegistry = class {
 
 // packages/host-runtime/src/installed-harness-plugins.ts
 import os3 from "node:os";
-import path14 from "node:path";
+import path15 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // packages/host-runtime/src/launcher-url-opener.ts
 import { spawn as spawn3 } from "node:child_process";
-import path13 from "node:path";
+import path14 from "node:path";
 var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]"]);
 var OPEN_TIMEOUT_MS = 1e4;
 function createLauncherUrlOpener(environment, spawnLauncher = (command, arguments_2, options2) => spawn3(command, arguments_2, options2)) {
   const launcher = environment.CODEXHOST_LAUNCHER_EXECUTABLE;
-  if (!launcher || !path13.isAbsolute(launcher)) return void 0;
+  if (!launcher || !path14.isAbsolute(launcher)) return void 0;
   const launcherEnvironment = Object.fromEntries(
     Object.entries(environment).filter(([name]) => {
       const normalized = name.toUpperCase();
@@ -31817,9 +32313,9 @@ function installedHarnessPluginOptions(environment, managedRemoteHost = false, h
   const opener = managedRemoteHost ? void 0 : createLauncherUrlOpener(environment);
   return {
     pluginRoots: [
-      path14.join(path14.dirname(fileURLToPath(hostRuntimeUrl)), "plugins"),
-      environment[HARNESS_PLUGIN_DIRECTORY_ENV] ?? path14.join(
-        environment.CODEXHOST_DATA_DIR ? path14.resolve(environment.CODEXHOST_DATA_DIR) : path14.join(os3.homedir(), ".codexhost"),
+      path15.join(path15.dirname(fileURLToPath(hostRuntimeUrl)), "plugins"),
+      environment[HARNESS_PLUGIN_DIRECTORY_ENV] ?? path15.join(
+        environment.CODEXHOST_DATA_DIR ? path15.resolve(environment.CODEXHOST_DATA_DIR) : path15.join(os3.homedir(), ".codexhost"),
         "plugins"
       )
     ],
@@ -31898,6 +32394,9 @@ async function startDelegationControlServer(input) {
       }
       const body = await jsonBody(request);
       switch (request.url) {
+        case "/v1/harness/list":
+          writeJson2(response, 200, await input.api.listHarnesses());
+          return;
         case "/v1/harness/inspect":
           writeJson2(response, 200, await input.api.inspect(body));
           return;
@@ -31941,13 +32440,15 @@ async function startDelegationControlServer(input) {
 }
 
 // packages/host-runtime/src/delegation-skill.ts
-import { createHash as createHash6, randomUUID as randomUUID9 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID10 } from "node:crypto";
 import { mkdir as mkdir7, open as open5, readFile as readFile7, rename as rename5, rm as rm5, stat as stat3 } from "node:fs/promises";
 import os4 from "node:os";
-import path15 from "node:path";
-var SKILL_VERSION = 5;
-var SKILL_RELATIVE_PATH = path15.join("skills", "codexhost-delegation", "SKILL.md");
+import path16 from "node:path";
+var SKILL_VERSION = 7;
+var SKILL_RELATIVE_PATH = path16.join("skills", "codexhost-delegation", "SKILL.md");
 var PREVIOUS_MANAGED_DIGESTS = [
+  "9d2f491850fb0b4084a31ba9b5e4a550b5e833747af322090d8ed0ff80b88c30",
+  "2bb0aebb9b06febbc6c0c0bcdb0b32506c7cdbf8dc3b734cc6b2a86621270e4e",
   "aff258622dc8ff321f32b15620d081e578cb9c9ed1134d6a57f35ca8e7762c0a",
   "ba509f57e5448e796b3dfdd5031dcb08672eded50b61c0a54de84cfa02c49dd3",
   "d3ddf6db9bc5c5df825479c885bbbf0ca08da66f7057a12e02e1fdf57525149e",
@@ -31971,21 +32472,13 @@ Before acting, run:
 
 \`codexhost delegate --help\`
 
-Treat its output as the sole authoritative source for:
-
-- available commands;
-- command parameters;
-- available target Harness IDs;
-- Thread identifier formats;
-- waiting and reading behavior;
-- response fields;
-- errors and recovery guidance.
-
-Do not construct commands, parameters, or Harness IDs from memory.
+Use CLI help as the authoritative source for commands and behavior. Consult
+command-specific help for options and the Harness listing command when the
+target is unknown. Prefer compact output when supported, and use its task links
+directly for subsequent commands.
 
-When the user asks for a specific Model or Thinking level, inspect the target
-Harness first and use the exact opaque IDs returned by the authoritative CLI.
-When they do not specify either setting, omit it so the target keeps its default.
+Use the Harness native defaults. Inspect the target when a Model or Thinking
+selection is needed or the default is unavailable.
 
 For a new delegation, create an independent child session and submit the
 requested task. For an existing external session, resolve the target from the
@@ -32004,22 +32497,12 @@ user’s request and the task:
 - check it again later;
 - leave it running in the background.
 
-When the result is needed, explicitly read the target Thread. Report only the
-visible result returned by that Thread.
-
-Provide the user with the necessary tracking information available from the
-CLI; omit unavailable fields rather than inventing them:
-
-- target agent;
-- \`delegationId\`;
-- \`threadId\`;
-- \`turnId\`;
-- \`deepLink\`;
-- current or final status.
+Report the result returned by read or a completed wait, together with the target
+agent, status, and a labeled task link. Keep internal tracking IDs in tool calls.
 `;
-var CURRENT_DIGEST = createHash6("sha256").update(CODEXHOST_DELEGATION_SKILL).digest("hex");
+var CURRENT_DIGEST = createHash7("sha256").update(CODEXHOST_DELEGATION_SKILL).digest("hex");
 function digest(value2) {
-  return createHash6("sha256").update(value2).digest("hex");
+  return createHash7("sha256").update(value2).digest("hex");
 }
 function managedVersion(value2) {
   const match = /^version:\s*(\d+)\s*$/mu.exec(value2);
@@ -32034,8 +32517,8 @@ async function readOptional(filePath) {
   }
 }
 async function atomicWrite(filePath, content) {
-  await mkdir7(path15.dirname(filePath), { recursive: true, mode: 448 });
-  const temporaryPath = path15.join(path15.dirname(filePath), `.SKILL.md.${randomUUID9()}.tmp`);
+  await mkdir7(path16.dirname(filePath), { recursive: true, mode: 448 });
+  const temporaryPath = path16.join(path16.dirname(filePath), `.SKILL.md.${randomUUID10()}.tmp`);
   const handle = await open5(temporaryPath, "wx", 384);
   try {
     await handle.writeFile(content, "utf8");
@@ -32052,8 +32535,8 @@ async function atomicWrite(filePath, content) {
 async function installDelegationSkills(input = {}) {
   const home = input.homeDirectory ?? os4.homedir();
   const destinations = [
-    path15.join(home, ".agents", SKILL_RELATIVE_PATH),
-    path15.join(home, ".claude", SKILL_RELATIVE_PATH)
+    path16.join(home, ".agents", SKILL_RELATIVE_PATH),
+    path16.join(home, ".claude", SKILL_RELATIVE_PATH)
   ];
   const knownDigests = /* @__PURE__ */ new Set([
     CURRENT_DIGEST,
@@ -32118,9 +32601,9 @@ async function installDelegationSkills(input = {}) {
 }
 
 // packages/host-runtime/src/remote-control-app-server.ts
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID11 } from "node:crypto";
 import { mkdir as mkdir8, open as open6, rename as rename6, rm as rm6 } from "node:fs/promises";
-import path16 from "node:path";
+import path17 from "node:path";
 
 // packages/host-runtime/src/remote-official-connection.ts
 import net from "node:net";
@@ -32310,30 +32793,30 @@ var BRIDGE_READY_METHOD = "codexhost/remote-control-bridge/ready";
 function absoluteEnvironmentPath2(environment, name, fallback, platform = process.platform) {
   const value2 = environment[name] ?? fallback;
   if (!value2) return null;
-  if (path16.isAbsolute(value2)) return path16.normalize(value2);
-  return platform === "win32" && path16.win32.isAbsolute(value2) ? path16.win32.normalize(value2) : null;
+  if (path17.isAbsolute(value2)) return path17.normalize(value2);
+  return platform === "win32" && path17.win32.isAbsolute(value2) ? path17.win32.normalize(value2) : null;
 }
 function nodeCompatibleWindowsPath(value2) {
   if (value2.startsWith("\\\\?\\UNC\\")) return `\\\\${value2.slice(8)}`;
   if (value2.startsWith("\\\\?\\")) return value2.slice(4);
   return value2;
 }
-function remoteControlBridgePipePath(processId = process.pid, instanceId = randomUUID10()) {
+function remoteControlBridgePipePath(processId = process.pid, instanceId = randomUUID11()) {
   const safeInstance = instanceId.replaceAll(/[^a-zA-Z0-9-]/gu, "");
   if (!safeInstance) throw new Error("Remote Control bridge instance ID is invalid");
   return `\\\\.\\pipe\\codexhost-remote-control-${processId}-${safeInstance}`;
 }
 function remoteControlBridgeDescriptorPath(environment) {
   const root = environment.LOCALAPPDATA;
-  if (!root || !path16.isAbsolute(root)) return null;
-  return path16.join(path16.normalize(root), "codexhost", REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE);
+  if (!root || !path17.isAbsolute(root)) return null;
+  return path17.join(path17.normalize(root), "codexhost", REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE);
 }
 async function publishRemoteControlAppServerDescriptor(plan) {
-  const directory = path16.dirname(plan.descriptorPath);
+  const directory = path17.dirname(plan.descriptorPath);
   await mkdir8(directory, { recursive: true, mode: 448 });
-  const temporaryPath = path16.join(
+  const temporaryPath = path17.join(
     directory,
-    `.${REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE}.${plan.descriptor.ownerPid}.${randomUUID10()}.tmp`
+    `.${REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE}.${plan.descriptor.ownerPid}.${randomUUID11()}.tmp`
   );
   const handle = await open6(temporaryPath, "wx", 384);
   try {
@@ -32424,14 +32907,14 @@ async function runRemoteControlAppServerBridge(input = {}) {
 import { createServer as createServer2 } from "node:http";
 import net2 from "node:net";
 import { chmod as chmod3, lstat as lstat6, mkdir as mkdir10, rm as rm8 } from "node:fs/promises";
-import path18 from "node:path";
+import path19 from "node:path";
 import { PassThrough as PassThrough2 } from "node:stream";
 
 // packages/host-runtime/src/remote-socket-lock.ts
-import { randomUUID as randomUUID11 } from "node:crypto";
+import { randomUUID as randomUUID12 } from "node:crypto";
 import { chmod as chmod2, lstat as lstat5, mkdir as mkdir9, open as open7, readFile as readFile8, readdir as readdir4, rename as rename7, rm as rm7 } from "node:fs/promises";
 import { uptime } from "node:os";
-import path17 from "node:path";
+import path18 from "node:path";
 import { setTimeout as delay4 } from "node:timers/promises";
 var LOCK_RETRY_COUNT = 200;
 var LOCK_RETRY_DELAY_MS = 25;
@@ -32505,7 +32988,7 @@ async function readLockEntrySnapshot(filePath) {
     source,
     identity: { dev: metadata.dev, ino: metadata.ino },
     mtimeMs: metadata.mtimeMs,
-    record: record3 && path17.basename(filePath) === lockEntryName(record3.ownerToken) ? record3 : null
+    record: record3 && path18.basename(filePath) === lockEntryName(record3.ownerToken) ? record3 : null
   };
 }
 function lockEntryIsAbandoned(snapshot) {
@@ -32526,7 +33009,7 @@ async function readLockEntryCatalog(lockDirectory) {
   let unsettled = false;
   for (const name of names) {
     if (!name.startsWith(LOCK_ENTRY_PREFIX) || !name.endsWith(LOCK_ENTRY_SUFFIX)) continue;
-    const snapshot = await readLockEntrySnapshot(path17.join(lockDirectory, name));
+    const snapshot = await readLockEntrySnapshot(path18.join(lockDirectory, name));
     if (snapshot === null) continue;
     if (lockEntryIsAbandoned(snapshot)) {
       if (!await removeAbandonedLockEntry(snapshot)) unsettled = true;
@@ -32554,7 +33037,7 @@ async function preparePrivateLockDirectory(lockDirectory) {
   await chmod2(lockDirectory, 448);
 }
 async function writeLockRecordAtomic(lockDirectory, entryPath, record3) {
-  const temporary = path17.join(lockDirectory, `.tmp-${record3.ownerToken}-${randomUUID11()}`);
+  const temporary = path18.join(lockDirectory, `.tmp-${record3.ownerToken}-${randomUUID12()}`);
   const handle = await open7(temporary, "wx", 384);
   try {
     await handle.writeFile(`${JSON.stringify(record3)}
@@ -32629,8 +33112,8 @@ async function withRemoteAppServerSocketInitializationLock(socketPath, action) {
   const legacyPath = `${socketPath}.initializing`;
   const lockDirectory = `${socketPath}.initializers`;
   await preparePrivateLockDirectory(lockDirectory);
-  const ownerToken = randomUUID11();
-  const entryPath = path17.join(lockDirectory, lockEntryName(ownerToken));
+  const ownerToken = randomUUID12();
+  const entryPath = path18.join(lockDirectory, lockEntryName(ownerToken));
   const baseRecord = {
     version: 2,
     ownerToken,
@@ -32804,14 +33287,14 @@ function remoteAppServerSocketPath(environment, listenUrl = "unix://") {
     throw new Error("Remote app-server listener must use a Unix URL");
   }
   const explicit = listenUrl.slice("unix://".length);
-  if (explicit.length > 0) return path18.posix.resolve(decodeURIComponent(explicit));
-  const codexHome = environment.CODEX_HOME ?? (environment.HOME ? path18.posix.join(environment.HOME, ".codex") : void 0);
+  if (explicit.length > 0) return path19.posix.resolve(decodeURIComponent(explicit));
+  const codexHome = environment.CODEX_HOME ?? (environment.HOME ? path19.posix.join(environment.HOME, ".codex") : void 0);
   if (!codexHome)
     throw new Error("CODEX_HOME or HOME is required for the remote app-server socket");
-  return path18.posix.join(codexHome, "app-server-control", "app-server-control.sock");
+  return path19.posix.join(codexHome, "app-server-control", "app-server-control.sock");
 }
 function officialListenerArgumentsForRemoteListener(arguments_2, socketPath) {
-  if (!path18.posix.isAbsolute(socketPath)) {
+  if (!path19.posix.isAbsolute(socketPath)) {
     throw new Error("Shared official app-server socket path must be absolute");
   }
   if (remoteUnixListenerUrl(arguments_2) === null) {
@@ -32922,7 +33405,7 @@ async function removeStaleSocket(socketPath) {
   await rm8(socketPath, { force: true });
 }
 async function prepareRemoteAppServerSocketDirectory(socketPath) {
-  const socketDirectory = path18.dirname(socketPath);
+  const socketDirectory = path19.dirname(socketPath);
   const existing = await lstat6(socketDirectory).catch((error51) => {
     if (error51.code === "ENOENT") return null;
     throw error51;
@@ -33127,20 +33610,20 @@ function createRemoteAppServerWebSocketListener(input) {
 
 // packages/host-runtime/src/remote-official-app-server.ts
 import { spawn as spawn4 } from "node:child_process";
-import { randomUUID as randomUUID12 } from "node:crypto";
+import { randomUUID as randomUUID13 } from "node:crypto";
 import { lstat as lstat7, rm as rm9 } from "node:fs/promises";
-import path19 from "node:path";
+import path20 from "node:path";
 var DEFAULT_CLOSE_TIMEOUT_MS = 2e3;
 var DEFAULT_LISTEN_TIMEOUT_MS = 1e4;
-function remoteOfficialAppServerSocketPath(desktopControlSocketPath, token = randomUUID12()) {
-  if (!path19.posix.isAbsolute(desktopControlSocketPath)) {
+function remoteOfficialAppServerSocketPath(desktopControlSocketPath, token = randomUUID13()) {
+  if (!path20.posix.isAbsolute(desktopControlSocketPath)) {
     throw new Error("Desktop control socket path must be absolute");
   }
   if (!/^[A-Za-z0-9-]+$/u.test(token) || !/[A-Za-z0-9]/u.test(token)) {
     throw new Error("Shared official app-server socket token is invalid");
   }
   const compactToken = token.replaceAll("-", "").slice(0, 15);
-  return path19.posix.join(path19.posix.dirname(desktopControlSocketPath), `.c-${compactToken}.sock`);
+  return path20.posix.join(path20.posix.dirname(desktopControlSocketPath), `.c-${compactToken}.sock`);
 }
 function errorMessage5(error51) {
   return error51 instanceof Error ? error51.message : String(error51);
@@ -33431,7 +33914,16 @@ function createHostUpdateCoordinator(options2) {
     });
     return contextPromise;
   };
-  const fetchLatest = options2.fetchLatest ?? ((signal) => fetchLatestGitHubRelease({ signal: signal ?? AbortSignal.timeout(15e3) }));
+  const fetchLatest = options2.fetchLatest ?? (async (signal) => {
+    const timeoutSignal = AbortSignal.timeout(15e3);
+    const requestSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+    const authenticated = await fetchLatestGitHubReleaseWithGitHubCli({
+      ...options2.environment ? { environment: options2.environment } : {},
+      platform,
+      signal: requestSignal
+    });
+    return authenticated ?? fetchLatestGitHubRelease({ signal: requestSignal });
+  });
   let candidate = null;
   async function latestStatus(context) {
     const discovered = await discoverLatestUpdateStatus(context.common.stateDirectory);
@@ -33607,9 +34099,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];
@@ -33736,8 +34228,8 @@ async function runHostRuntime(input) {
         });
         try {
           await officialListeners.endpoint({
-            codexHome: path20.resolve(
-              delegationEnvironment.CODEX_HOME ?? path20.join(homedir(), ".codex")
+            codexHome: path21.resolve(
+              delegationEnvironment.CODEX_HOME ?? path21.join(homedir(), ".codex")
             )
           });
           await listener.listen();
@@ -33838,7 +34330,7 @@ async function runHostRuntime(input) {
 }
 
 // packages/host-runtime/src/remote-host-install.ts
-import { createHash as createHash7, randomUUID as randomUUID13 } from "node:crypto";
+import { createHash as createHash8, randomUUID as randomUUID14 } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
 import {
   access,
@@ -33853,7 +34345,7 @@ import {
   stat as stat4,
   writeFile as writeFile5
 } from "node:fs/promises";
-import path21 from "node:path";
+import path22 from "node:path";
 var MANIFEST_FORMAT = 1;
 var WRAPPER_MARKER = "# codexhost remote SSH wrapper v1";
 var PROFILE_START = "# >>> codexhost remote SSH >>>";
@@ -33864,25 +34356,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
   };
 }
@@ -33898,10 +34390,10 @@ async function existingText(filePath) {
   }
 }
 async function fileSha256(filePath) {
-  return createHash7("sha256").update(await readFile9(filePath)).digest("hex");
+  return createHash8("sha256").update(await readFile9(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);
@@ -33911,7 +34403,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");
@@ -33921,9 +34413,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;
@@ -33934,10 +34426,10 @@ async function discoverExecutable(name, environment) {
   return null;
 }
 async function writeAtomic(filePath, contents, mode) {
-  await mkdir11(path21.dirname(filePath), { recursive: true, mode: 448 });
-  const temporary = path21.join(
-    path21.dirname(filePath),
-    `.${path21.basename(filePath)}.${process.pid}.${randomUUID13()}.tmp`
+  await mkdir11(path22.dirname(filePath), { recursive: true, mode: 448 });
+  const temporary = path22.join(
+    path22.dirname(filePath),
+    `.${path22.basename(filePath)}.${process.pid}.${randomUUID14()}.tmp`
   );
   try {
     if (typeof contents === "string") {
@@ -33958,10 +34450,10 @@ async function writeAtomic(filePath, contents, mode) {
   }
 }
 async function writeAtomicExecutable(filePath, sourcePath) {
-  await mkdir11(path21.dirname(filePath), { recursive: true, mode: 448 });
-  const temporary = path21.join(
-    path21.dirname(filePath),
-    `.${path21.basename(filePath)}.${process.pid}.${randomUUID13()}.tmp`
+  await mkdir11(path22.dirname(filePath), { recursive: true, mode: 448 });
+  const temporary = path22.join(
+    path22.dirname(filePath),
+    `.${path22.basename(filePath)}.${process.pid}.${randomUUID14()}.tmp`
   );
   try {
     await copyFile3(sourcePath, temporary);
@@ -34002,8 +34494,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)}`,
@@ -34020,7 +34512,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}`;
 }
@@ -34039,7 +34531,7 @@ ${WRAPPER_MARKER}
     return "legacy-wrapper";
   }
   if (manifest.entrypointSha256 !== void 0) {
-    return createHash7("sha256").update(entrypoint).digest("hex") === manifest.entrypointSha256 ? "native" : "modified";
+    return createHash8("sha256").update(entrypoint).digest("hex") === manifest.entrypointSha256 ? "native" : "modified";
   }
   const shim = await readFile9(manifest.shimPath).catch((error51) => {
     if (error51.code === "ENOENT") return null;
@@ -34085,9 +34577,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");
   }
@@ -34316,7 +34808,7 @@ async function uninstallRemoteHost(options2) {
 import { spawn as spawn5 } from "node:child_process";
 import { stat as stat5 } from "node:fs/promises";
 import net3 from "node:net";
-import path22 from "node:path";
+import path23 from "node:path";
 import { Duplex } from "node:stream";
 var CODEXHOST_STATUS_METHOD = "codexhost/update/status";
 var DIRECT_PROBE_TIMEOUT_MS = 5e3;
@@ -34335,9 +34827,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) => {
@@ -34464,7 +34956,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,
@@ -34472,7 +34964,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) {
@@ -34760,7 +35252,7 @@ var harnessBrokerServerFrameSchema = external_exports.union([
 var harnessBrokerDescriptorSchema = external_exports.object({
   schemaVersion: external_exports.literal(1),
   protocolVersion: external_exports.literal(HARNESS_BROKER_PROTOCOL_VERSION),
-  harnessId: external_exports.literal("claude-code"),
+  harnessId: harnessPluginIdSchema,
   generation: external_exports.string().uuid(),
   ownerPid: external_exports.number().int().positive(),
   socketPath: external_exports.string().min(1).max(512),
@@ -34811,33 +35303,48 @@ function consumeBrokerFrames(socket, onFrame, onError) {
 
 // packages/harness-broker/dist/paths.js
 import os5 from "node:os";
-import path23 from "node:path";
+import path24 from "node:path";
 var HARNESS_BROKER_DESCRIPTOR_ENV = "CODEXHOST_CLAUDE_BROKER_DESCRIPTOR";
 var HARNESS_BROKER_DESCRIPTOR_FILE = "claude-code-broker-v1.json";
 var HARNESS_BROKER_SOCKET_FILE = "claude-code-broker-v1.sock";
 function defaultHarnessBrokerDirectory(environment = process.env) {
   const home = environment.HOME || os5.homedir();
-  return path23.join(home, ".codexhost", "harness-broker");
+  return path24.join(home, ".codexhost", "harness-broker");
 }
-function defaultHarnessBrokerDescriptorPath(environment = process.env) {
-  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path23.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
+function defaultHarnessBrokerDescriptorPath(environment = process.env, harnessId = "claude-code") {
+  harnessPluginIdSchema.parse(harnessId);
+  if (harnessId !== "claude-code")
+    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) {
-  return path23.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_SOCKET_FILE);
+function defaultHarnessBrokerSocketPath(environment = process.env, harnessId = "claude-code") {
+  harnessPluginIdSchema.parse(harnessId);
+  if (harnessId !== "claude-code")
+    return path24.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.sock`);
+  return path24.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_SOCKET_FILE);
 }
 
 // packages/harness-broker/dist/validation.js
 var cwdSchema = external_exports.string().min(1).max(16384);
+var brokerEnvironmentSchema = external_exports.object({
+  CODEXHOST_CLI_PATH: external_exports.string().max(16384).optional(),
+  CODEXHOST_RUNTIME_ENDPOINT: external_exports.string().max(16384).optional(),
+  CODEXHOST_RUNTIME_TOKEN: external_exports.string().max(16384).optional(),
+  CODEXHOST_THREAD_ID: external_exports.string().max(256).optional()
+}).strict();
 var createSchema = external_exports.object({
   kind: external_exports.literal("create"),
   cwd: cwdSchema,
   executionPolicy: external_exports.enum(["default", "unattended-full-access"]).optional(),
+  environment: brokerEnvironmentSchema.optional(),
   model: harnessModelRefSchema.optional(),
   thinkingOptionId: harnessThinkingOptionIdSchema.optional(),
   permissionModeId: harnessPermissionModeIdSchema.optional()
 }).strict();
 var resumeSchema = external_exports.object({
   kind: external_exports.literal("resume"),
+  environment: brokerEnvironmentSchema.optional(),
+  permissionModeId: harnessPermissionModeIdSchema.optional(),
   model: harnessModelRefSchema.optional(),
   thinkingOptionId: harnessThinkingOptionIdSchema.optional(),
   nativeRef: nativeSessionRefSchema,
@@ -34846,12 +35353,14 @@ var resumeSchema = external_exports.object({
 }).strict();
 var forkSchema = external_exports.object({
   kind: external_exports.literal("fork"),
+  environment: brokerEnvironmentSchema.optional(),
   sourceRef: nativeSessionRefSchema,
   checkpoint: nativeCheckpointRefSchema,
   cwd: cwdSchema
 }).strict();
 var rollbackSchema = external_exports.object({
   kind: external_exports.literal("rollbackLastTurn"),
+  environment: brokerEnvironmentSchema.optional(),
   model: harnessModelRefSchema.optional(),
   thinkingOptionId: harnessThinkingOptionIdSchema.optional(),
   permissionModeId: harnessPermissionModeIdSchema.optional(),
@@ -35025,10 +35534,10 @@ var harnessOutputSchema = external_exports.custom((value2) => {
 });
 
 // packages/harness-broker/dist/server.js
-import { randomBytes as randomBytes2, randomUUID as randomUUID14 } from "node:crypto";
+import { randomBytes as randomBytes2, randomUUID as randomUUID15 } from "node:crypto";
 import { chmod as chmod5, lstat as lstat9, mkdir as mkdir12, open as open8, readFile as readFile10, rename as rename9, rm as rm11 } from "node:fs/promises";
 import net4, {} from "node:net";
-import path24 from "node:path";
+import path25 from "node:path";
 function harnessError(message, retryable = true) {
   return { code: "unavailable", message, retryable, stage: "harnessBroker" };
 }
@@ -35084,7 +35593,7 @@ async function assertNoLiveDescriptor(descriptorPath) {
   }
 }
 async function publishDescriptor(descriptorPath, descriptor) {
-  const temporary = `${descriptorPath}.${process.pid}.${randomUUID14()}.tmp`;
+  const temporary = `${descriptorPath}.${process.pid}.${randomUUID15()}.tmp`;
   const handle = await open8(temporary, "wx", 384);
   try {
     await handle.writeFile(`${JSON.stringify(descriptor)}
@@ -35150,25 +35659,23 @@ async function prepareUnixSocketPath(socketPath) {
   }
 }
 async function startHarnessBrokerServer(input) {
-  if (input.adapter.harnessId !== "claude-code") {
-    throw new Error("Harness broker accepts only the claude-code adapter");
-  }
-  if (process.platform !== "win32" && path24.dirname(input.descriptorPath) !== path24.dirname(input.socketPath)) {
+  harnessPluginIdSchema.parse(input.adapter.harnessId);
+  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);
-  const generation = input.generation ?? randomUUID14();
+  const generation = input.generation ?? randomUUID15();
   const token = input.token ?? randomBytes2(32).toString("hex");
   const descriptor = {
     schemaVersion: 1,
     protocolVersion: HARNESS_BROKER_PROTOCOL_VERSION,
-    harnessId: "claude-code",
+    harnessId: input.adapter.harnessId,
     generation,
     ownerPid: process.pid,
     socketPath: input.socketPath,
@@ -35181,7 +35688,7 @@ async function startHarnessBrokerServer(input) {
   let closed = false;
   const server = net4.createServer((socket) => {
     const state = {
-      id: randomUUID14(),
+      id: randomUUID15(),
       socket,
       authenticated: false,
       inputSequence: 0,
@@ -35224,8 +35731,9 @@ async function startHarnessBrokerServer(input) {
           if (output.kind === "event" && output.event.type === "session.state.changed") {
             const state2 = output.event.state;
             const observedNativeId = state2.nativeRef?.nativeSessionId;
-            if (state2.nativeRef && record3.nativeRef && (record3.nativeRef.harnessId !== state2.nativeRef.harnessId || record3.nativeRef.nativeSessionId !== state2.nativeRef.nativeSessionId || record3.nativeRef.formatVersion !== state2.nativeRef.formatVersion)) {
+            if (state2.nativeRef && (state2.nativeRef.harnessId !== input.adapter.harnessId || record3.nativeRef && (record3.nativeRef.harnessId !== state2.nativeRef.harnessId || record3.nativeRef.nativeSessionId !== state2.nativeRef.nativeSessionId || record3.nativeRef.formatVersion !== state2.nativeRef.formatVersion))) {
               record3.faulted = true;
+              releaseProvisionalWriter(record3);
               await send({
                 kind: "output",
                 sessionId: record3.id,
@@ -35236,7 +35744,7 @@ async function startHarnessBrokerServer(input) {
                     type: "session.faulted",
                     error: {
                       code: "protocolError",
-                      message: "Native Claude Session identity changed after open",
+                      message: "Native Harness Session identity changed after open",
                       retryable: false,
                       stage: "harnessBroker.identity"
                     }
@@ -35262,7 +35770,7 @@ async function startHarnessBrokerServer(input) {
                       type: "session.faulted",
                       error: {
                         code: "sessionBusy",
-                        message: "Native Claude Session already has an active writer",
+                        message: "Native Harness Session already has an active writer",
                         retryable: true,
                         stage: "harnessBroker.identity"
                       }
@@ -35360,20 +35868,25 @@ async function startHarnessBrokerServer(input) {
       if (request.method === "adapter.subagent.readSnapshot") {
         const subagents = input.adapter.subagents;
         if (!subagents)
-          return { ok: false, error: harnessError("Claude subagents are unavailable", false) };
-        return subagents.readSnapshot(subagentReadSnapshotSchema.parse(request.params));
+          return { ok: false, error: harnessError("Harness subagents are unavailable", false) };
+        const params = subagentReadSnapshotSchema.parse(request.params);
+        if (params.parent.harnessId !== input.adapter.harnessId)
+          return { ok: false, error: protocolError("Subagent parent belongs to another Harness") };
+        return subagents.readSnapshot(params);
       }
       if (request.method === "adapter.open") {
         const openInput = brokerOpenInputSchema.parse(request.params);
         const sourceRef = openInput.kind === "create" ? void 0 : openInput.kind === "resume" ? openInput.nativeRef : openInput.sourceRef;
         const sourceNativeId = sourceRef?.nativeSessionId;
+        if (sourceRef && sourceRef.harnessId !== input.adapter.harnessId)
+          return { ok: false, error: protocolError("Native Session belongs to another Harness") };
         const sourceKey = sourceNativeId ? nativeWriterKey(sourceNativeId) : void 0;
         if (sourceKey && nativeWriters.has(sourceKey)) {
           return {
             ok: false,
             error: {
               code: "sessionBusy",
-              message: "Native Claude Session already has an active writer",
+              message: "Native Harness Session already has an active writer",
               retryable: true,
               stage: "harnessBroker.open"
             }
@@ -35384,13 +35897,13 @@ async function startHarnessBrokerServer(input) {
             ok: false,
             error: {
               code: "sessionBusy",
-              message: "Native Claude Session identity claim is already pending",
+              message: "Native Harness Session identity claim is already pending",
               retryable: true,
               stage: "harnessBroker.open"
             }
           };
         }
-        const openReservation = randomUUID14();
+        const openReservation = randomUUID15();
         if (sourceKey)
           nativeWriters.set(sourceKey, openReservation);
         const provisionalReservation = openInput.kind === "create" ? openReservation : void 0;
@@ -35418,6 +35931,14 @@ async function startHarnessBrokerServer(input) {
           return { ok: false, error: harnessError("Harness broker connection closed") };
         }
         const openedRef = opened.value.initialState.nativeRef;
+        if (openedRef && openedRef.harnessId !== input.adapter.harnessId) {
+          releaseOpenReservations();
+          await opened.value.close().catch(() => void 0);
+          return {
+            ok: false,
+            error: protocolError("Adapter opened a Session for another Harness")
+          };
+        }
         if (sourceRef && (!openedRef || openedRef.harnessId !== sourceRef.harnessId || openedRef.formatVersion !== sourceRef.formatVersion || openInput.kind === "resume" && openedRef.nativeSessionId !== sourceRef.nativeSessionId)) {
           releaseOpenReservations();
           await opened.value.close().catch(() => void 0);
@@ -35425,7 +35946,7 @@ async function startHarnessBrokerServer(input) {
             ok: false,
             error: {
               code: "protocolError",
-              message: "Native Claude Session identity did not match the requested open",
+              message: "Native Harness Session identity did not match the requested open",
               retryable: false,
               stage: "harnessBroker.open"
             }
@@ -35441,7 +35962,7 @@ async function startHarnessBrokerServer(input) {
             ok: false,
             error: {
               code: "sessionBusy",
-              message: "Native Claude Session already has an active writer",
+              message: "Native Harness Session already has an active writer",
               retryable: true,
               stage: "harnessBroker.open"
             }
@@ -35453,6 +35974,7 @@ async function startHarnessBrokerServer(input) {
           generation: 1,
           owner: state.id,
           cwd: openInput.cwd,
+          ...openInput.environment ? { environment: openInput.environment } : {},
           ...nativeId ? { nativeId } : {},
           ...opened.value.initialState.nativeRef ? { nativeRef: opened.value.initialState.nativeRef } : {},
           ...nativeKey ? { writerKey: nativeKey } : {},
@@ -35493,7 +36015,7 @@ async function startHarnessBrokerServer(input) {
               ok: false,
               error: {
                 code: "sessionBusy",
-                message: "Native Claude Session identity has not been claimed yet",
+                message: "Native Harness Session identity has not been claimed yet",
                 retryable: true,
                 stage: "harnessBroker.identity"
               }
@@ -35570,7 +36092,7 @@ async function startHarnessBrokerServer(input) {
             ok: false,
             error: {
               code: "sessionBusy",
-              message: "Faulted Claude Session has no authoritative native identity",
+              message: "Faulted Harness Session has no authoritative native identity",
               retryable: false,
               stage: "harnessBroker.reopen"
             }
@@ -35582,7 +36104,12 @@ async function startHarnessBrokerServer(input) {
         record4.forwarderEpoch += 1;
         await oldSession.close().catch(() => void 0);
         await oldOutputTask.catch(() => void 0);
-        const reopened = await input.adapter.open({ kind: "resume", cwd: record4.cwd, nativeRef });
+        const reopened = await input.adapter.open({
+          kind: "resume",
+          cwd: record4.cwd,
+          nativeRef,
+          ...record4.environment ? { environment: record4.environment } : {}
+        });
         if (!reopened.ok)
           return reopened;
         const reopenedRef = reopened.value.initialState.nativeRef;
@@ -35592,7 +36119,7 @@ async function startHarnessBrokerServer(input) {
             ok: false,
             error: {
               code: "protocolError",
-              message: "Claude Aqua broker reopen changed the native Session identity",
+              message: "Aqua Harness broker reopen changed the native Session identity",
               retryable: false,
               stage: "harnessBroker.reopen"
             }
@@ -35656,7 +36183,7 @@ async function startHarnessBrokerServer(input) {
           }
           state.authenticated = true;
           state.inputSequence = 1;
-          await send({ kind: "response", id: randomUUID14(), ok: true, value: { ready: true } });
+          await send({ kind: "response", id: randomUUID15(), ok: true, value: { ready: true } });
           return;
         }
         const parsed = harnessBrokerRequestSchema.safeParse(raw);
@@ -35729,15 +36256,16 @@ async function startHarnessBrokerServer(input) {
 }
 
 // packages/host-runtime/src/aqua-harness-broker.ts
-async function runClaudeAquaHarnessBroker(environment = process.env) {
+async function runClaudeAquaHarnessBroker(environment = process.env, requestedHarnessId = "claude-code") {
+  const harnessId = harnessPluginIdSchema.parse(requestedHarnessId);
   if (process.platform !== "darwin") {
-    throw new Error("Claude Aqua Harness broker is available only on macOS");
+    throw new Error("Aqua Harness broker is available only on macOS");
   }
   const { pluginRoots, pluginContext } = installedHarnessPluginOptions(environment);
   const plugins = await loadHarnessPlugins({
     roots: pluginRoots,
     context: pluginContext,
-    onlyIds: /* @__PURE__ */ new Set(["claude-code"]),
+    onlyIds: /* @__PURE__ */ new Set([harnessId]),
     warmup: false,
     diagnose: (diagnostic) => process.stderr.write(`Harness plugin: ${JSON.stringify(diagnostic)}
 `)
@@ -35750,19 +36278,19 @@ async function runClaudeAquaHarnessBroker(environment = process.env) {
   let server;
   try {
     server = await startHarnessBrokerServer({
-      descriptorPath: defaultHarnessBrokerDescriptorPath(environment),
-      socketPath: defaultHarnessBrokerSocketPath(environment),
+      descriptorPath: defaultHarnessBrokerDescriptorPath(environment, harnessId),
+      socketPath: defaultHarnessBrokerSocketPath(environment, harnessId),
       adapter
     });
   } catch (error51) {
     await adapter.close().catch(() => void 0);
     throw error51;
   }
-  process.title = "codexhost claude-code Aqua harness broker";
+  process.title = `codexhost ${harnessId} Aqua harness broker`;
   process.stdout.write(
     `${JSON.stringify({
       method: "codexhost/harness-broker/ready",
-      params: { protocolVersion: 1, harnessId: "claude-code" }
+      params: { protocolVersion: 1, harnessId }
     })}
 `
   );
@@ -35785,7 +36313,7 @@ async function runClaudeAquaHarnessBroker(environment = process.env) {
 
 // packages/host-runtime/src/release-main.ts
 var arguments_ = process.argv.slice(2);
-process.exitCode = arguments_[0] === "--codexhost-delegation-cli" ? await runDelegationCli({ arguments: arguments_.slice(1), environment: process.env }) : arguments_[0] === "--codexhost-harness-broker" ? await runClaudeAquaHarnessBroker(process.env) : arguments_[0] === "--codexhost-remote" ? await runRemoteHostCli({ arguments: arguments_.slice(1), environment: process.env }) : arguments_[0] === "--codexhost-remote-control-bridge" ? await runRemoteControlAppServerBridge() : await runHostRuntime({
+process.exitCode = arguments_[0] === "--codexhost-delegation-cli" ? await runDelegationCli({ arguments: arguments_.slice(1), environment: process.env }) : arguments_[0] === "--codexhost-harness-broker" ? await runClaudeAquaHarnessBroker(process.env, arguments_[1] ?? "claude-code") : arguments_[0] === "--codexhost-remote" ? await runRemoteHostCli({ arguments: arguments_.slice(1), environment: process.env }) : arguments_[0] === "--codexhost-remote-control-bridge" ? await runRemoteControlAppServerBridge() : await runHostRuntime({
   arguments: arguments_,
   environment: process.env,
   hostRuntimeUrl: import.meta.url