@codexhost/cli-darwin-x64 0.6.0 → 0.6.2

package/app/host-runtime.mjs

@@ -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,8 @@ async function runDelegationCli(input) {
 
 // packages/host-runtime/src/run-host-runtime.ts
 import { randomBytes } from "node:crypto";
-import path19 from "node:path";
+import path20 from "node:path";
+import { homedir } from "node:os";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/update-manager/dist/distribution.js
@@ -5701,10 +5886,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path24) {
-  if (!path24)
+function getElementAtPath(obj, path25) {
+  if (!path25)
     return obj;
-  return path24.reduce((acc, key) => acc?.[key], obj);
+  return path25.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -6113,11 +6298,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path24, issues) {
+function prefixIssues(path25, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path24);
+    iss.path.unshift(path25);
     return iss;
   });
 }
@@ -6264,16 +6449,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path24 = []) => {
+  const processError = (error52, path25 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path24, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path25, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path24, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path25, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path24, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path25, ...issue2.path]);
       } else {
-        const fullpath = [...path24, ...issue2.path];
+        const fullpath = [...path25, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -6300,17 +6485,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path24 = []) => {
+  const processError = (error52, path25 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path24, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path25, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path24, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path25, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path24, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path25, ...issue2.path]);
       } else {
-        const fullpath = [...path24, ...issue2.path];
+        const fullpath = [...path25, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -6342,8 +6527,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path24 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path24) {
+  const path25 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path25) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -19035,13 +19220,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path24 = ref.slice(1).split("/").filter(Boolean);
-  if (path24.length === 0) {
+  const path25 = ref.slice(1).split("/").filter(Boolean);
+  if (path25.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path24[0] === defsKey) {
-    const key = path24[1];
+  if (path25[0] === defsKey) {
+    const key = path25[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -19475,6 +19660,8 @@ var threadUsageSnapshotSchema = external_exports.object({
   reasoningOutputTokens: nonNegativeSafeIntegerSchema.optional(),
   totalTokens: nonNegativeSafeIntegerSchema.optional(),
   totalCostUsd: finiteNonNegativeNumberSchema.optional(),
+  totalCredits: finiteNonNegativeNumberSchema.optional(),
+  contextUsagePercent: finiteNonNegativeNumberSchema.optional(),
   cacheHitRatePercent: cacheHitRatePercentSchema.optional(),
   contextWindowTokens: nonNegativeSafeIntegerSchema.optional(),
   contextUsedTokens: nonNegativeSafeIntegerSchema.optional(),
@@ -20386,7 +20573,9 @@ var usageFields = /* @__PURE__ */ new Set([
   ...tokenFields,
   ...safeIntegerFields,
   ...percentFields,
-  "totalCostUsd"
+  "totalCostUsd",
+  "totalCredits",
+  "contextUsagePercent"
 ]);
 function isRecord(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
@@ -20402,6 +20591,12 @@ function parseHostUsage(value2) {
       throw new Error(`Harness Usage contains unknown field '${key}'`);
     }
   }
+  for (const field of ["totalCredits", "contextUsagePercent"]) {
+    const candidate = value2[field];
+    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0)) {
+      throw new Error(`Harness Usage '${field}' must be a finite non-negative number`);
+    }
+  }
   for (const field of tokenFields) {
     const candidate = value2[field];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
@@ -20726,7 +20921,7 @@ var MappingStore = class {
     ]);
     await this.#acquireLock();
     try {
-      await this.#cleanupTemps();
+      await this.#cleanupResidue();
       const names = (await readdir2(this.#threadsDirectory)).filter((name) => name.endsWith(".json"));
       for (const name of names) {
         const primary = path4.join(this.#threadsDirectory, name);
@@ -21150,14 +21345,17 @@ var MappingStore = class {
     }
     return parsed.data;
   }
-  async #cleanupTemps() {
-    const [threadNames, delegationNames] = await Promise.all([
+  async #cleanupResidue() {
+    const [threadNames, delegationNames, rootNames] = await Promise.all([
       readdir2(this.#threadsDirectory),
-      readdir2(this.#delegationsDirectory)
+      readdir2(this.#delegationsDirectory),
+      readdir2(this.#directory)
     ]);
     await Promise.all([
       ...threadNames.filter((name) => name.includes(".tmp-")).map((name) => rm3(path4.join(this.#threadsDirectory, name), { force: true })),
-      ...delegationNames.filter((name) => name.includes(".tmp-")).map((name) => rm3(path4.join(this.#delegationsDirectory, name), { force: true }))
+      ...delegationNames.filter((name) => name.includes(".tmp-")).map((name) => rm3(path4.join(this.#delegationsDirectory, name), { force: true })),
+      // Renamed aside by #acquireLock; nothing reads them back, and they accumulate one per run.
+      ...rootNames.filter((name) => name.startsWith(`${path4.basename(this.#lockPath)}.stale-`)).map((name) => rm3(path4.join(this.#directory, name), { force: true }))
     ]);
   }
   async #acquireLock() {
@@ -21349,6 +21547,9 @@ function projectCodexApprovalRequest(input) {
     throw new Error("Host Approval subject is unsupported");
   }
   validateActions(interaction);
+  if (new Set(interaction.actions.map(({ effect }) => effect)).size !== interaction.actions.length) {
+    return projectApprovalChoices(input);
+  }
   const allow = requiredActionForEffect(interaction, "allowOnce");
   const allowForSession = optionalActionForEffect(interaction, "allowForSession");
   const allowAlways = optionalActionForEffect(interaction, "allowAlways");
@@ -21414,6 +21615,63 @@ function projectCodexApprovalRequest(input) {
     }
   };
 }
+function projectApprovalChoices(input) {
+  const { interaction } = input;
+  const allow = actionsForEffect(interaction, "allowOnce")[0];
+  const deny = actionsForEffect(interaction, "deny")[0];
+  if (!allow || !deny)
+    throw new Error("Host Approval must declare allowOnce and deny actions");
+  const denyResponse = { type: "approval", actionId: deny.id };
+  return {
+    request: {
+      method: "mcpServer/elicitation/request",
+      params: {
+        serverName: boundedText(input.serverName, "server name", SERVER_NAME_MAX_LENGTH),
+        threadId: input.threadId,
+        turnId: interaction.turnId,
+        mode: "form",
+        message: [
+          clampedText(interaction.title, "title", TITLE_MAX_LENGTH),
+          ...interaction.description ? [interaction.description] : []
+        ].join("\n\n"),
+        requestedSchema: {
+          type: "object",
+          properties: {
+            actionId: {
+              type: "string",
+              title: "Approval",
+              oneOf: interaction.actions.map(({ id: id2, label }) => ({ const: id2, title: label })),
+              default: allow.id
+            }
+          },
+          required: ["actionId"]
+        }
+      }
+    },
+    denyResponse,
+    parseResponse(result) {
+      if (!isRecord2(result) || typeof result.action !== "string")
+        throw responseError("missing action");
+      if (Object.keys(result).some((key) => !["action", "content", "_meta"].includes(key))) {
+        throw responseError("contains unreviewed fields");
+      }
+      if (result._meta !== void 0 && result._meta !== null) {
+        throw responseError("contains unexpected persist metadata");
+      }
+      if (result.action === "decline" || result.action === "cancel") {
+        if (result.content !== void 0 && result.content !== null) {
+          throw responseError("contains fields incompatible with denial");
+        }
+        return denyResponse;
+      }
+      const content = result.content;
+      if (result.action !== "accept" || !isRecord2(content) || Object.keys(content).length !== 1 || !interaction.actions.some(({ id: id2 }) => id2 === content.actionId)) {
+        throw responseError("contains an undeclared approval choice");
+      }
+      return { type: "approval", actionId: content.actionId };
+    }
+  };
+}
 
 // packages/protocol-core/dist/codex-question.js
 function isRecord3(value2) {
@@ -21957,8 +22215,8 @@ function projectFileChangeKind(kind) {
   return { type: kind };
 }
 function projectFileChanges(changes) {
-  return changes.map(({ path: path24, kind, unifiedDiff }) => ({
-    path: path24,
+  return changes.map(({ path: path25, kind, unifiedDiff }) => ({
+    path: path25,
     kind: projectFileChangeKind(kind),
     diff: unifiedDiff
   }));
@@ -22116,7 +22374,7 @@ function projectItem(item, outcome, defaultCwd, includeCommandOutput = true, sen
         id: item.itemId,
         type: "agentMessage",
         text: item.text,
-        phase: null,
+        phase: item.phase ?? null,
         memoryCitation: null
       };
     case "reasoning":
@@ -22179,7 +22437,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",
@@ -22188,13 +22448,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) {
@@ -22238,6 +22499,9 @@ function historicalStatus(outcome) {
 }
 function projectHistoricalTurn(input) {
   const { turnId, cwd, snapshot } = input;
+  const startedAtMs = snapshot.startedAtMs;
+  const completedAtMs = snapshot.completedAtMs;
+  const hasTiming = startedAtMs !== void 0 && completedAtMs !== void 0 && Number.isFinite(startedAtMs) && Number.isFinite(completedAtMs) && startedAtMs >= 0 && completedAtMs >= startedAtMs;
   const error51 = snapshot.outcome.status === "failed" ? {
     message: snapshot.outcome.error.message,
     codexErrorInfo: "other",
@@ -22273,9 +22537,9 @@ function projectHistoricalTurn(input) {
       })
     ],
     error: error51,
-    startedAt: null,
-    completedAt: null,
-    durationMs: null,
+    startedAt: hasTiming ? Math.floor(startedAtMs / 1e3) : null,
+    completedAt: hasTiming ? Math.floor(completedAtMs / 1e3) : null,
+    durationMs: hasTiming ? completedAtMs - startedAtMs : null,
     itemsView: "full"
   };
 }
@@ -22901,13 +23165,13 @@ function decodeThreadForkRequest(request) {
   if (runtimeWorkspaceRoots !== void 0 && runtimeWorkspaceRoots !== null && (!Array.isArray(runtimeWorkspaceRoots) || runtimeWorkspaceRoots.some((root) => typeof root !== "string" || root.length === 0))) {
     throw new Error("thread/fork params.runtimeWorkspaceRoots must be text paths or null");
   }
-  const path24 = optionalText(params, "path", { allowEmpty: true });
+  const path25 = optionalText(params, "path", { allowEmpty: true });
   const ephemeral = optionalBoolean(params, "ephemeral");
   return {
     threadId: threadId3,
     ...lastTurnText ? { lastTurnId: hostTurnIdSchema.parse(lastTurnText) } : {},
     ...beforeTurnText ? { beforeTurnId: hostTurnIdSchema.parse(beforeTurnText) } : {},
-    ...path24 ? { path: path24 } : {},
+    ...path25 ? { path: path25 } : {},
     ...optionalField(params, "model"),
     ...optionalField(params, "modelProvider"),
     ...optionalField(params, "cwd"),
@@ -24862,6 +25126,7 @@ async function executeCurrentLastTurnRollback(input) {
       error: { code: -32079, message: "External Native Session is unavailable" }
     };
   }
+  const configuration = currentConfiguration(current);
   let opened;
   try {
     opened = await adapter.open({
@@ -24871,7 +25136,10 @@ async function executeCurrentLastTurnRollback(input) {
         ...input.environment ?? process.env,
         [DELEGATION_THREAD_ID_ENV]: current.id
       },
-      sourceRef: currentNativeRef
+      sourceRef: currentNativeRef,
+      ...configuration.effectiveModel ? { model: configuration.effectiveModel } : {},
+      ...configuration.effectiveThinkingOptionId ? { thinkingOptionId: configuration.effectiveThinkingOptionId } : {},
+      ...configuration.effectivePermissionModeId ? { permissionModeId: configuration.effectivePermissionModeId } : {}
     });
   } catch {
     return { ok: false, error: { code: -32076, message: "External Thread rollback failed" } };
@@ -24888,7 +25156,6 @@ async function executeCurrentLastTurnRollback(input) {
       error: { code: -32076, message: "External rollback did not return a valid Session" }
     };
   }
-  const configuration = currentConfiguration(current);
   const configurationError = await restoreCurrentConfiguration(session, configuration);
   if (configurationError) {
     await session.close().catch(() => void 0);
@@ -25460,6 +25727,8 @@ var ExternalThreadRuntime = class {
       environment: { ...this.#environment, [DELEGATION_THREAD_ID_ENV]: record3.hostThreadId },
       nativeRef: record3.nativeSessionRef,
       knownTurnRefs: record3.turnMappings.map(({ nativeTurnRef }) => nativeTurnRef),
+      ...restoredSelection?.model ? { model: restoredSelection.model } : {},
+      ...restoredSelection?.thinkingOptionId ? { thinkingOptionId: restoredSelection.thinkingOptionId } : {},
       ...harnessId === "grok" && restoredSelection?.permissionModeId ? { permissionModeId: restoredSelection.permissionModeId } : {}
     });
     if (!opened.ok) {
@@ -25816,15 +26085,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,
@@ -25832,7 +26107,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)
   };
 }
@@ -25864,11 +26142,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");
   }
 }
@@ -25886,6 +26164,7 @@ var HarnessDelegationCoordinator = class {
   #cancelOfficial;
   #startOfficial;
   #listOfficial;
+  #officialThreadCwd;
   #activeOfficialParents;
   constructor(input) {
     this.#adapters = input.adapters;
@@ -25901,8 +26180,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);
@@ -25924,7 +26207,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: path6.resolve(selectedCwd) };
     if (!this.#adapters.has(input.harnessId)) {
       throw new DelegationControlError(
         "HARNESS_NOT_FOUND",
@@ -25933,7 +26222,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),
@@ -25960,11 +26249,10 @@ 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());
@@ -25974,7 +26262,7 @@ var HarnessDelegationCoordinator = class {
         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 } : {},
@@ -26045,17 +26333,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);
@@ -26284,18 +26576,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 {
@@ -27355,25 +27653,25 @@ function resolveExternalSessionTreeIds(records) {
   const resolve = (start) => {
     const cached2 = resolved.get(start.hostThreadId);
     if (cached2) return cached2;
-    const path24 = [];
+    const path25 = [];
     const visited = /* @__PURE__ */ new Set();
     let current = start;
     while (true) {
       const known = resolved.get(current.hostThreadId);
       if (known) {
-        for (const record3 of path24) resolved.set(record3.hostThreadId, known);
+        for (const record3 of path25) resolved.set(record3.hostThreadId, known);
         return known;
       }
       if (visited.has(current.hostThreadId)) {
         throw new Error("External Thread Fork tree contains a cycle");
       }
       visited.add(current.hostThreadId);
-      path24.push(current);
+      path25.push(current);
       const sourceId = current.forkSource?.hostThreadId;
       const source = sourceId ? byId.get(sourceId) : void 0;
       if (!source) {
         const root = current.hostThreadId;
-        for (const record3 of path24) resolved.set(record3.hostThreadId, root);
+        for (const record3 of path25) resolved.set(record3.hostThreadId, root);
         return root;
       }
       current = source;
@@ -27914,6 +28212,8 @@ function approvalServerName(harnessId) {
       return "Oh My Pi";
     case "antigravity":
       return "Antigravity CLI";
+    case "kiro-cli":
+      return "Kiro CLI";
     default:
       return harnessId;
   }
@@ -28115,9 +28415,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),
@@ -29141,6 +29443,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)) {
@@ -29333,6 +29642,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: {
@@ -31523,6 +31833,40 @@ var AppServerHost = class {
   }
 };
 
+// packages/host-runtime/src/codex-runtime/account-official-listeners.ts
+import path12 from "node:path";
+var AccountOfficialListeners = class {
+  constructor(createListener) {
+    this.createListener = createListener;
+  }
+  createListener;
+  #listeners = /* @__PURE__ */ new Map();
+  #starting = /* @__PURE__ */ new Map();
+  #closed = false;
+  async endpoint(account) {
+    if (this.#closed) throw new Error("Account official listeners are closed");
+    const key = path12.resolve(account.codexHome);
+    const existing = this.#starting.get(key);
+    if (existing) return existing;
+    const listener = this.createListener(account);
+    this.#listeners.set(key, listener);
+    const starting = listener.listen().catch(async (error51) => {
+      await listener.close();
+      this.#listeners.delete(key);
+      this.#starting.delete(key);
+      throw error51;
+    });
+    this.#starting.set(key, starting);
+    return starting;
+  }
+  async close() {
+    this.#closed = true;
+    await Promise.all([...this.#listeners.values()].map((listener) => listener.close()));
+    this.#listeners.clear();
+    this.#starting.clear();
+  }
+};
+
 // packages/host-runtime/src/delegation-control-registry.ts
 function only(values, message) {
   const value2 = values.length === 1 ? values[0] : void 0;
@@ -31549,6 +31893,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);
   }
@@ -31591,9 +31941,28 @@ var DelegationControlRegistry = class {
     );
   }
   async #registrationForThread(threadId3) {
-    return only(
-      await this.#matching((registration) => registration.ownsThread(threadId3)),
-      "Thread is not owned by exactly one active Host Runtime session"
+    const registrations = [...this.#registrations];
+    const matches = await this.#matching((registration) => registration.ownsThread(threadId3));
+    if (matches.length === 1) return matches[0];
+    if (matches.length > 1) {
+      throw new DelegationControlError(
+        "PARENT_THREAD_AMBIGUOUS",
+        "Thread is not owned by exactly one active Host Runtime session",
+        { matchingRuntimeCount: matches.length }
+      );
+    }
+    if (registrations.length === 0) {
+      throw new DelegationControlError(
+        "PARENT_THREAD_AMBIGUOUS",
+        "Thread is not owned by exactly one active Host Runtime session",
+        { matchingRuntimeCount: 0 }
+      );
+    }
+    if (registrations.length === 1) return registrations[0];
+    throw new DelegationControlError(
+      "PARENT_THREAD_AMBIGUOUS",
+      "Thread is not owned by exactly one active Host Runtime session",
+      { matchingRuntimeCount: 0 }
     );
   }
   #compareThreads(left, right, sort) {
@@ -31612,17 +31981,17 @@ var DelegationControlRegistry = class {
 
 // packages/host-runtime/src/installed-harness-plugins.ts
 import os3 from "node:os";
-import path13 from "node:path";
+import path14 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // packages/host-runtime/src/launcher-url-opener.ts
 import { spawn as spawn3 } from "node:child_process";
-import path12 from "node:path";
+import path13 from "node:path";
 var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]"]);
 var OPEN_TIMEOUT_MS = 1e4;
 function createLauncherUrlOpener(environment, spawnLauncher = (command, arguments_2, options2) => spawn3(command, arguments_2, options2)) {
   const launcher = environment.CODEXHOST_LAUNCHER_EXECUTABLE;
-  if (!launcher || !path12.isAbsolute(launcher)) return void 0;
+  if (!launcher || !path13.isAbsolute(launcher)) return void 0;
   const launcherEnvironment = Object.fromEntries(
     Object.entries(environment).filter(([name]) => {
       const normalized = name.toUpperCase();
@@ -31680,9 +32049,9 @@ function installedHarnessPluginOptions(environment, managedRemoteHost = false, h
   const opener = managedRemoteHost ? void 0 : createLauncherUrlOpener(environment);
   return {
     pluginRoots: [
-      path13.join(path13.dirname(fileURLToPath(hostRuntimeUrl)), "plugins"),
-      environment[HARNESS_PLUGIN_DIRECTORY_ENV] ?? path13.join(
-        environment.CODEXHOST_DATA_DIR ? path13.resolve(environment.CODEXHOST_DATA_DIR) : path13.join(os3.homedir(), ".codexhost"),
+      path14.join(path14.dirname(fileURLToPath(hostRuntimeUrl)), "plugins"),
+      environment[HARNESS_PLUGIN_DIRECTORY_ENV] ?? path14.join(
+        environment.CODEXHOST_DATA_DIR ? path14.resolve(environment.CODEXHOST_DATA_DIR) : path14.join(os3.homedir(), ".codexhost"),
         "plugins"
       )
     ],
@@ -31761,6 +32130,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;
@@ -31807,10 +32179,13 @@ async function startDelegationControlServer(input) {
 import { createHash as createHash6, randomUUID as randomUUID9 } from "node:crypto";
 import { mkdir as mkdir7, open as open5, readFile as readFile7, rename as rename5, rm as rm5, stat as stat3 } from "node:fs/promises";
 import os4 from "node:os";
-import path14 from "node:path";
-var SKILL_VERSION = 4;
-var SKILL_RELATIVE_PATH = path14.join("skills", "codexhost-delegation", "SKILL.md");
+import path15 from "node:path";
+var SKILL_VERSION = 7;
+var SKILL_RELATIVE_PATH = path15.join("skills", "codexhost-delegation", "SKILL.md");
 var PREVIOUS_MANAGED_DIGESTS = [
+  "9d2f491850fb0b4084a31ba9b5e4a550b5e833747af322090d8ed0ff80b88c30",
+  "2bb0aebb9b06febbc6c0c0bcdb0b32506c7cdbf8dc3b734cc6b2a86621270e4e",
+  "aff258622dc8ff321f32b15620d081e578cb9c9ed1134d6a57f35ca8e7762c0a",
   "ba509f57e5448e796b3dfdd5031dcb08672eded50b61c0a54de84cfa02c49dd3",
   "d3ddf6db9bc5c5df825479c885bbbf0ca08da66f7057a12e02e1fdf57525149e",
   "15eb63519ff867e1536c97188a0c43738d7a49d38d4d6adeb7a1036726e7246d"
@@ -31819,12 +32194,12 @@ var CODEXHOST_DELEGATION_SKILL = `---
 name: codexhost-delegation
 version: ${SKILL_VERSION}
 description: >
-  Delegate work to another coding agent. Use when the user explicitly asks
-  Claude Code, Pi, Codex/OpenAI, OMP, Grok, another agent, or an agent mentioned
-  as @<agent> to independently review, investigate, implement, test, or verify
-  something. Do not use when the user is merely discussing, comparing, or
-  configuring agents, choosing a Model or Provider, or asking the current agent
-  to role-play as another agent.
+  Delegate tasks to other coding agents, or read and follow up on existing
+  external agent sessions. Use when the user asks another agent (including
+  @agent) to independently perform a task, or asks to view a specified external
+  session's content, progress, or results, send follow-up messages, wait, or
+  cancel a task. Not for recapping the current conversation, discussing or
+  configuring agents, or role-playing.
 ---
 
 # Execute the task
@@ -31833,25 +32208,22 @@ 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.
+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.
 
-Do not construct commands, parameters, or Harness IDs from memory.
+Use the Harness native defaults. Inspect the target when a Model or Thinking
+selection is needed or the default is unavailable.
 
-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.
+For a new delegation, create an independent child session and submit the
+requested task. For an existing external session, resolve the target from the
+user-provided session link, identifier, or context and operate on that Thread
+directly; it need not have been created by the current assistant. If the target
+is ambiguous, ask the user to identify it. Keep requests to view or summarize a
+session read-only.
 
-Create an independent child session and submit the requested task.
-
-After starting the task, choose the appropriate next action based on the
+For a new or existing task, choose the appropriate next action based on the
 user’s request and the task:
 
 - send a follow-up message to the same Thread;
@@ -31861,17 +32233,8 @@ user’s request and the task:
 - check it again later;
 - leave it running in the background.
 
-When the result is needed, explicitly read the child Thread. Report only the
-visible result returned by that Thread.
-
-Provide the user with the necessary tracking information, including:
-
-- 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");
 function digest(value2) {
@@ -31890,8 +32253,8 @@ async function readOptional(filePath) {
   }
 }
 async function atomicWrite(filePath, content) {
-  await mkdir7(path14.dirname(filePath), { recursive: true, mode: 448 });
-  const temporaryPath = path14.join(path14.dirname(filePath), `.SKILL.md.${randomUUID9()}.tmp`);
+  await mkdir7(path15.dirname(filePath), { recursive: true, mode: 448 });
+  const temporaryPath = path15.join(path15.dirname(filePath), `.SKILL.md.${randomUUID9()}.tmp`);
   const handle = await open5(temporaryPath, "wx", 384);
   try {
     await handle.writeFile(content, "utf8");
@@ -31908,8 +32271,8 @@ async function atomicWrite(filePath, content) {
 async function installDelegationSkills(input = {}) {
   const home = input.homeDirectory ?? os4.homedir();
   const destinations = [
-    path14.join(home, ".agents", SKILL_RELATIVE_PATH),
-    path14.join(home, ".claude", SKILL_RELATIVE_PATH)
+    path15.join(home, ".agents", SKILL_RELATIVE_PATH),
+    path15.join(home, ".claude", SKILL_RELATIVE_PATH)
   ];
   const knownDigests = /* @__PURE__ */ new Set([
     CURRENT_DIGEST,
@@ -31976,7 +32339,7 @@ async function installDelegationSkills(input = {}) {
 // packages/host-runtime/src/remote-control-app-server.ts
 import { randomUUID as randomUUID10 } from "node:crypto";
 import { mkdir as mkdir8, open as open6, rename as rename6, rm as rm6 } from "node:fs/promises";
-import path15 from "node:path";
+import path16 from "node:path";
 
 // packages/host-runtime/src/remote-official-connection.ts
 import net from "node:net";
@@ -32166,8 +32529,8 @@ var BRIDGE_READY_METHOD = "codexhost/remote-control-bridge/ready";
 function absoluteEnvironmentPath2(environment, name, fallback, platform = process.platform) {
   const value2 = environment[name] ?? fallback;
   if (!value2) return null;
-  if (path15.isAbsolute(value2)) return path15.normalize(value2);
-  return platform === "win32" && path15.win32.isAbsolute(value2) ? path15.win32.normalize(value2) : null;
+  if (path16.isAbsolute(value2)) return path16.normalize(value2);
+  return platform === "win32" && path16.win32.isAbsolute(value2) ? path16.win32.normalize(value2) : null;
 }
 function nodeCompatibleWindowsPath(value2) {
   if (value2.startsWith("\\\\?\\UNC\\")) return `\\\\${value2.slice(8)}`;
@@ -32181,13 +32544,13 @@ function remoteControlBridgePipePath(processId = process.pid, instanceId = rando
 }
 function remoteControlBridgeDescriptorPath(environment) {
   const root = environment.LOCALAPPDATA;
-  if (!root || !path15.isAbsolute(root)) return null;
-  return path15.join(path15.normalize(root), "codexhost", REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE);
+  if (!root || !path16.isAbsolute(root)) return null;
+  return path16.join(path16.normalize(root), "codexhost", REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE);
 }
 async function publishRemoteControlAppServerDescriptor(plan) {
-  const directory = path15.dirname(plan.descriptorPath);
+  const directory = path16.dirname(plan.descriptorPath);
   await mkdir8(directory, { recursive: true, mode: 448 });
-  const temporaryPath = path15.join(
+  const temporaryPath = path16.join(
     directory,
     `.${REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE}.${plan.descriptor.ownerPid}.${randomUUID10()}.tmp`
   );
@@ -32280,14 +32643,14 @@ async function runRemoteControlAppServerBridge(input = {}) {
 import { createServer as createServer2 } from "node:http";
 import net2 from "node:net";
 import { chmod as chmod3, lstat as lstat6, mkdir as mkdir10, rm as rm8 } from "node:fs/promises";
-import path17 from "node:path";
+import path18 from "node:path";
 import { PassThrough as PassThrough2 } from "node:stream";
 
 // packages/host-runtime/src/remote-socket-lock.ts
 import { randomUUID as randomUUID11 } from "node:crypto";
 import { chmod as chmod2, lstat as lstat5, mkdir as mkdir9, open as open7, readFile as readFile8, readdir as readdir4, rename as rename7, rm as rm7 } from "node:fs/promises";
 import { uptime } from "node:os";
-import path16 from "node:path";
+import path17 from "node:path";
 import { setTimeout as delay4 } from "node:timers/promises";
 var LOCK_RETRY_COUNT = 200;
 var LOCK_RETRY_DELAY_MS = 25;
@@ -32361,7 +32724,7 @@ async function readLockEntrySnapshot(filePath) {
     source,
     identity: { dev: metadata.dev, ino: metadata.ino },
     mtimeMs: metadata.mtimeMs,
-    record: record3 && path16.basename(filePath) === lockEntryName(record3.ownerToken) ? record3 : null
+    record: record3 && path17.basename(filePath) === lockEntryName(record3.ownerToken) ? record3 : null
   };
 }
 function lockEntryIsAbandoned(snapshot) {
@@ -32382,7 +32745,7 @@ async function readLockEntryCatalog(lockDirectory) {
   let unsettled = false;
   for (const name of names) {
     if (!name.startsWith(LOCK_ENTRY_PREFIX) || !name.endsWith(LOCK_ENTRY_SUFFIX)) continue;
-    const snapshot = await readLockEntrySnapshot(path16.join(lockDirectory, name));
+    const snapshot = await readLockEntrySnapshot(path17.join(lockDirectory, name));
     if (snapshot === null) continue;
     if (lockEntryIsAbandoned(snapshot)) {
       if (!await removeAbandonedLockEntry(snapshot)) unsettled = true;
@@ -32410,7 +32773,7 @@ async function preparePrivateLockDirectory(lockDirectory) {
   await chmod2(lockDirectory, 448);
 }
 async function writeLockRecordAtomic(lockDirectory, entryPath, record3) {
-  const temporary = path16.join(lockDirectory, `.tmp-${record3.ownerToken}-${randomUUID11()}`);
+  const temporary = path17.join(lockDirectory, `.tmp-${record3.ownerToken}-${randomUUID11()}`);
   const handle = await open7(temporary, "wx", 384);
   try {
     await handle.writeFile(`${JSON.stringify(record3)}
@@ -32486,7 +32849,7 @@ async function withRemoteAppServerSocketInitializationLock(socketPath, action) {
   const lockDirectory = `${socketPath}.initializers`;
   await preparePrivateLockDirectory(lockDirectory);
   const ownerToken = randomUUID11();
-  const entryPath = path16.join(lockDirectory, lockEntryName(ownerToken));
+  const entryPath = path17.join(lockDirectory, lockEntryName(ownerToken));
   const baseRecord = {
     version: 2,
     ownerToken,
@@ -32660,14 +33023,14 @@ function remoteAppServerSocketPath(environment, listenUrl = "unix://") {
     throw new Error("Remote app-server listener must use a Unix URL");
   }
   const explicit = listenUrl.slice("unix://".length);
-  if (explicit.length > 0) return path17.posix.resolve(decodeURIComponent(explicit));
-  const codexHome = environment.CODEX_HOME ?? (environment.HOME ? path17.posix.join(environment.HOME, ".codex") : void 0);
+  if (explicit.length > 0) return path18.posix.resolve(decodeURIComponent(explicit));
+  const codexHome = environment.CODEX_HOME ?? (environment.HOME ? path18.posix.join(environment.HOME, ".codex") : void 0);
   if (!codexHome)
     throw new Error("CODEX_HOME or HOME is required for the remote app-server socket");
-  return path17.posix.join(codexHome, "app-server-control", "app-server-control.sock");
+  return path18.posix.join(codexHome, "app-server-control", "app-server-control.sock");
 }
 function officialListenerArgumentsForRemoteListener(arguments_2, socketPath) {
-  if (!path17.posix.isAbsolute(socketPath)) {
+  if (!path18.posix.isAbsolute(socketPath)) {
     throw new Error("Shared official app-server socket path must be absolute");
   }
   if (remoteUnixListenerUrl(arguments_2) === null) {
@@ -32778,7 +33141,7 @@ async function removeStaleSocket(socketPath) {
   await rm8(socketPath, { force: true });
 }
 async function prepareRemoteAppServerSocketDirectory(socketPath) {
-  const socketDirectory = path17.dirname(socketPath);
+  const socketDirectory = path18.dirname(socketPath);
   const existing = await lstat6(socketDirectory).catch((error51) => {
     if (error51.code === "ENOENT") return null;
     throw error51;
@@ -32985,18 +33348,18 @@ function createRemoteAppServerWebSocketListener(input) {
 import { spawn as spawn4 } from "node:child_process";
 import { randomUUID as randomUUID12 } from "node:crypto";
 import { lstat as lstat7, rm as rm9 } from "node:fs/promises";
-import path18 from "node:path";
+import path19 from "node:path";
 var DEFAULT_CLOSE_TIMEOUT_MS = 2e3;
 var DEFAULT_LISTEN_TIMEOUT_MS = 1e4;
 function remoteOfficialAppServerSocketPath(desktopControlSocketPath, token = randomUUID12()) {
-  if (!path18.posix.isAbsolute(desktopControlSocketPath)) {
+  if (!path19.posix.isAbsolute(desktopControlSocketPath)) {
     throw new Error("Desktop control socket path must be absolute");
   }
   if (!/^[A-Za-z0-9-]+$/u.test(token) || !/[A-Za-z0-9]/u.test(token)) {
     throw new Error("Shared official app-server socket token is invalid");
   }
   const compactToken = token.replaceAll("-", "").slice(0, 15);
-  return path18.posix.join(path18.posix.dirname(desktopControlSocketPath), `.c-${compactToken}.sock`);
+  return path19.posix.join(path19.posix.dirname(desktopControlSocketPath), `.c-${compactToken}.sock`);
 }
 function errorMessage5(error51) {
   return error51 instanceof Error ? error51.message : String(error51);
@@ -33463,9 +33826,9 @@ function hasLauncherManagedUpdateRuntime(environment, hostRuntimePath) {
   if (!environment[UPDATE_RUNTIME_ENV.launcherPid]) return false;
   const npmPackageRoot = environment[UPDATE_RUNTIME_ENV.npmPackageRoot];
   if (!npmPackageRoot || !hostRuntimePath) return true;
-  if (!path19.isAbsolute(npmPackageRoot) || !path19.isAbsolute(hostRuntimePath)) return false;
-  const runtimePackageRoot = path19.dirname(path19.dirname(path19.normalize(hostRuntimePath)));
-  return path19.relative(path19.normalize(npmPackageRoot), runtimePackageRoot) === "";
+  if (!path20.isAbsolute(npmPackageRoot) || !path20.isAbsolute(hostRuntimePath)) return false;
+  const runtimePackageRoot = path20.dirname(path20.dirname(path20.normalize(hostRuntimePath)));
+  return path20.relative(path20.normalize(npmPackageRoot), runtimePackageRoot) === "";
 }
 function requiredRuntimeConfiguration(environment) {
   const stockCodexPath = environment[STOCK_CODEX_PATH_ENV];
@@ -33546,19 +33909,15 @@ async function runHostRuntime(input) {
         const officialPlan = createRemoteControlOfficialAppServerPlan(
           remoteControlPlan.officialArguments
         );
-        const officialListener = createLoopbackOfficialAppServerListener({
-          stockCodexPath,
-          arguments: officialPlan.listenerArguments,
-          environment: officialEnvironment(delegationEnvironment),
-          diagnosticOutput: process.stderr
-        });
-        let officialEndpoint = null;
-        const createOfficialConnection = () => {
-          if (!officialEndpoint) {
-            throw new Error("Shared official app-server endpoint is unavailable");
-          }
-          return createRemoteOfficialAppServerConnection(officialEndpoint);
-        };
+        const officialListeners = new AccountOfficialListeners(
+          (account) => createLoopbackOfficialAppServerListener({
+            stockCodexPath,
+            arguments: officialPlan.listenerArguments,
+            environment: officialAccountEnvironment(delegationEnvironment, account),
+            diagnosticOutput: process.stderr
+          })
+        );
+        const createOfficialConnection = async (account) => createRemoteOfficialAppServerConnection(await officialListeners.endpoint(account));
         const mappingStore = createProductionExternalThreadStore(delegationEnvironment);
         await mappingStore.initialize();
         const host = new AppServerHost({
@@ -33595,7 +33954,11 @@ async function runHostRuntime(input) {
           }
         });
         try {
-          officialEndpoint = await officialListener.listen();
+          await officialListeners.endpoint({
+            codexHome: path20.resolve(
+              delegationEnvironment.CODEX_HOME ?? path20.join(homedir(), ".codex")
+            )
+          });
           await listener.listen();
           await publishRemoteControlAppServerDescriptor(remoteControlPlan);
           return await host.run();
@@ -33604,7 +33967,7 @@ async function runHostRuntime(input) {
             await listener.close();
           } finally {
             try {
-              await officialListener.close();
+              await officialListeners.close();
             } finally {
               await mappingStore.close();
             }
@@ -33709,7 +34072,7 @@ import {
   stat as stat4,
   writeFile as writeFile5
 } from "node:fs/promises";
-import path20 from "node:path";
+import path21 from "node:path";
 var MANIFEST_FORMAT = 1;
 var WRAPPER_MARKER = "# codexhost remote SSH wrapper v1";
 var PROFILE_START = "# >>> codexhost remote SSH >>>";
@@ -33720,25 +34083,25 @@ function resolvePaths(options2) {
   if (!configuredHome) {
     throw new Error("A non-root HOME is required for remote Host installation");
   }
-  const home = path20.resolve(configuredHome);
-  if (!home || home === path20.parse(home).root) {
+  const home = path21.resolve(configuredHome);
+  if (!home || home === path21.parse(home).root) {
     throw new Error("A non-root HOME is required for remote Host installation");
   }
-  const installRoot = path20.resolve(options2.installRoot ?? path20.join(home, ".codexhost", "remote"));
-  const profilePath = path20.resolve(
-    options2.profilePath ?? path20.join(
+  const installRoot = path21.resolve(options2.installRoot ?? path21.join(home, ".codexhost", "remote"));
+  const profilePath = path21.resolve(
+    options2.profilePath ?? path21.join(
       home,
-      path20.basename(environment.SHELL ?? "") === "zsh" ? ".zshenv" : path20.basename(environment.SHELL ?? "") === "bash" ? ".bashrc" : ".profile"
+      path21.basename(environment.SHELL ?? "") === "zsh" ? ".zshenv" : path21.basename(environment.SHELL ?? "") === "bash" ? ".bashrc" : ".profile"
     )
   );
-  const binDirectory = path20.join(installRoot, "bin");
+  const binDirectory = path21.join(installRoot, "bin");
   return {
     home,
     installRoot,
     binDirectory,
-    wrapperPath: path20.join(binDirectory, "codex"),
-    manifestPath: path20.join(installRoot, "manifest.json"),
-    dataDirectory: path20.join(installRoot, "data"),
+    wrapperPath: path21.join(binDirectory, "codex"),
+    manifestPath: path21.join(installRoot, "manifest.json"),
+    dataDirectory: path21.join(installRoot, "data"),
     profilePath
   };
 }
@@ -33757,7 +34120,7 @@ async function fileSha256(filePath) {
   return createHash7("sha256").update(await readFile9(filePath)).digest("hex");
 }
 async function executable(filePath, label) {
-  const absolute = path20.resolve(filePath);
+  const absolute = path21.resolve(filePath);
   try {
     if (!(await stat4(absolute)).isFile()) throw new Error("not a regular file");
     await access(absolute, fsConstants.X_OK);
@@ -33767,7 +34130,7 @@ async function executable(filePath, label) {
   return absolute;
 }
 async function existingFile(filePath, label) {
-  const absolute = path20.resolve(filePath);
+  const absolute = path21.resolve(filePath);
   try {
     const metadata = await stat4(absolute);
     if (!metadata.isFile()) throw new Error("not a regular file");
@@ -33777,9 +34140,9 @@ async function existingFile(filePath, label) {
   return absolute;
 }
 async function discoverExecutable(name, environment) {
-  for (const directory of (environment.PATH ?? "").split(path20.delimiter)) {
+  for (const directory of (environment.PATH ?? "").split(path21.delimiter)) {
     if (!directory) continue;
-    const candidate = path20.resolve(directory, name);
+    const candidate = path21.resolve(directory, name);
     try {
       await access(candidate, fsConstants.X_OK);
       return candidate;
@@ -33790,10 +34153,10 @@ async function discoverExecutable(name, environment) {
   return null;
 }
 async function writeAtomic(filePath, contents, mode) {
-  await mkdir11(path20.dirname(filePath), { recursive: true, mode: 448 });
-  const temporary = path20.join(
-    path20.dirname(filePath),
-    `.${path20.basename(filePath)}.${process.pid}.${randomUUID13()}.tmp`
+  await mkdir11(path21.dirname(filePath), { recursive: true, mode: 448 });
+  const temporary = path21.join(
+    path21.dirname(filePath),
+    `.${path21.basename(filePath)}.${process.pid}.${randomUUID13()}.tmp`
   );
   try {
     if (typeof contents === "string") {
@@ -33814,10 +34177,10 @@ async function writeAtomic(filePath, contents, mode) {
   }
 }
 async function writeAtomicExecutable(filePath, sourcePath) {
-  await mkdir11(path20.dirname(filePath), { recursive: true, mode: 448 });
-  const temporary = path20.join(
-    path20.dirname(filePath),
-    `.${path20.basename(filePath)}.${process.pid}.${randomUUID13()}.tmp`
+  await mkdir11(path21.dirname(filePath), { recursive: true, mode: 448 });
+  const temporary = path21.join(
+    path21.dirname(filePath),
+    `.${path21.basename(filePath)}.${process.pid}.${randomUUID13()}.tmp`
   );
   try {
     await copyFile3(sourcePath, temporary);
@@ -33858,8 +34221,8 @@ function removeManagedProfileBlock(contents) {
 function installManagedProfileBlock(contents, manifest) {
   const base = removeManagedProfileBlock(contents);
   const environment = [
-    `export CODEX_INSTALL_DIR=${shellQuote(path20.dirname(manifest.wrapperPath))}`,
-    `export PATH=${shellQuote(path20.dirname(manifest.wrapperPath))}:${shellQuote(path20.dirname(manifest.nodePath))}:${shellQuote(path20.dirname(manifest.stockCodexPath))}:"\${PATH:-/usr/local/bin:/usr/bin:/bin}"`,
+    `export CODEX_INSTALL_DIR=${shellQuote(path21.dirname(manifest.wrapperPath))}`,
+    `export PATH=${shellQuote(path21.dirname(manifest.wrapperPath))}:${shellQuote(path21.dirname(manifest.nodePath))}:${shellQuote(path21.dirname(manifest.stockCodexPath))}:"\${PATH:-/usr/local/bin:/usr/bin:/bin}"`,
     `export CODEXHOST_STOCK_CODEX_PATH=${shellQuote(manifest.stockCodexPath)}`,
     `export CODEXHOST_HOST_NODE_PATH=${shellQuote(manifest.nodePath)}`,
     `export CODEXHOST_HOST_RUNTIME_PATH=${shellQuote(manifest.hostRuntimePath)}`,
@@ -33876,7 +34239,7 @@ function installManagedProfileBlock(contents, manifest) {
     PROFILE_END,
     ""
   ].join("\n");
-  if (path20.basename(manifest.profilePath) === ".bashrc") return `${block}${base}`;
+  if (path21.basename(manifest.profilePath) === ".bashrc") return `${block}${base}`;
   const separator = base.length > 0 && !base.endsWith("\n") ? "\n" : "";
   return `${base}${separator}${block}`;
 }
@@ -33941,9 +34304,9 @@ async function readManifest(filePath) {
   ];
   const optionalPaths = ["claudeCommand", "profileBackupPath"];
   if (manifest.format !== MANIFEST_FORMAT || Object.keys(manifest).some((key) => !allowed.has(key)) || requiredPaths.some(
-    (key) => typeof manifest[key] !== "string" || !path20.isAbsolute(manifest[key])
+    (key) => typeof manifest[key] !== "string" || !path21.isAbsolute(manifest[key])
   ) || optionalPaths.some(
-    (key) => manifest[key] !== void 0 && (typeof manifest[key] !== "string" || !path20.isAbsolute(manifest[key]))
+    (key) => manifest[key] !== void 0 && (typeof manifest[key] !== "string" || !path21.isAbsolute(manifest[key]))
   ) || manifest.entrypointSha256 !== void 0 && (typeof manifest.entrypointSha256 !== "string" || !/^[a-f0-9]{64}$/u.test(manifest.entrypointSha256))) {
     throw new Error("Remote Host manifest has an unsupported format");
   }
@@ -34172,7 +34535,7 @@ async function uninstallRemoteHost(options2) {
 import { spawn as spawn5 } from "node:child_process";
 import { stat as stat5 } from "node:fs/promises";
 import net3 from "node:net";
-import path21 from "node:path";
+import path22 from "node:path";
 import { Duplex } from "node:stream";
 var CODEXHOST_STATUS_METHOD = "codexhost/update/status";
 var DIRECT_PROBE_TIMEOUT_MS = 5e3;
@@ -34191,9 +34554,9 @@ function classifyRemoteHostProbeResponse(response, socketPath) {
 }
 var lifecycleDependencyOverrides = {};
 function socketPathFor(environment) {
-  const codexHome = environment.CODEX_HOME ?? (environment.HOME ? path21.join(environment.HOME, ".codex") : void 0);
+  const codexHome = environment.CODEX_HOME ?? (environment.HOME ? path22.join(environment.HOME, ".codex") : void 0);
   if (!codexHome) throw new Error("CODEX_HOME or HOME is required for remote Host lifecycle");
-  return path21.join(codexHome, "app-server-control", "app-server-control.sock");
+  return path22.join(codexHome, "app-server-control", "app-server-control.sock");
 }
 async function defaultSocketExists(socketPath) {
   const metadata = await stat5(socketPath).catch((error51) => {
@@ -34320,7 +34683,7 @@ function installedManifest(status) {
 function managedEnvironment(manifest, environment) {
   return {
     ...environment,
-    CODEX_INSTALL_DIR: path21.dirname(manifest.wrapperPath),
+    CODEX_INSTALL_DIR: path22.dirname(manifest.wrapperPath),
     CODEXHOST_STOCK_CODEX_PATH: manifest.stockCodexPath,
     CODEXHOST_HOST_NODE_PATH: manifest.nodePath,
     CODEXHOST_HOST_RUNTIME_PATH: manifest.hostRuntimePath,
@@ -34328,7 +34691,7 @@ function managedEnvironment(manifest, environment) {
     CODEXHOST_DEFAULT_AGENT: "codex",
     CODEXHOST_REMOTE_SSH_MANAGED: "1",
     ...manifest.claudeCommand ? { CODEXHOST_CLAUDE_COMMAND: manifest.claudeCommand } : {},
-    PATH: `${path21.dirname(manifest.wrapperPath)}${path21.delimiter}${path21.dirname(manifest.stockCodexPath)}${path21.delimiter}${environment.PATH ?? "/usr/bin:/bin"}`
+    PATH: `${path22.dirname(manifest.wrapperPath)}${path22.delimiter}${path22.dirname(manifest.stockCodexPath)}${path22.delimiter}${environment.PATH ?? "/usr/bin:/bin"}`
   };
 }
 async function defaultRunTerminator(manifest, socketPath, role, environment) {
@@ -34667,19 +35030,19 @@ function consumeBrokerFrames(socket, onFrame, onError) {
 
 // packages/harness-broker/dist/paths.js
 import os5 from "node:os";
-import path22 from "node:path";
+import path23 from "node:path";
 var HARNESS_BROKER_DESCRIPTOR_ENV = "CODEXHOST_CLAUDE_BROKER_DESCRIPTOR";
 var HARNESS_BROKER_DESCRIPTOR_FILE = "claude-code-broker-v1.json";
 var HARNESS_BROKER_SOCKET_FILE = "claude-code-broker-v1.sock";
 function defaultHarnessBrokerDirectory(environment = process.env) {
   const home = environment.HOME || os5.homedir();
-  return path22.join(home, ".codexhost", "harness-broker");
+  return path23.join(home, ".codexhost", "harness-broker");
 }
 function defaultHarnessBrokerDescriptorPath(environment = process.env) {
-  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path22.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
+  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path23.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
 }
 function defaultHarnessBrokerSocketPath(environment = process.env) {
-  return path22.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_SOCKET_FILE);
+  return path23.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_SOCKET_FILE);
 }
 
 // packages/harness-broker/dist/validation.js
@@ -34694,6 +35057,8 @@ var createSchema = external_exports.object({
 }).strict();
 var resumeSchema = external_exports.object({
   kind: external_exports.literal("resume"),
+  model: harnessModelRefSchema.optional(),
+  thinkingOptionId: harnessThinkingOptionIdSchema.optional(),
   nativeRef: nativeSessionRefSchema,
   cwd: cwdSchema,
   knownTurnRefs: external_exports.array(nativeTurnRefSchema).max(1e5).optional()
@@ -34706,6 +35071,9 @@ var forkSchema = external_exports.object({
 }).strict();
 var rollbackSchema = external_exports.object({
   kind: external_exports.literal("rollbackLastTurn"),
+  model: harnessModelRefSchema.optional(),
+  thinkingOptionId: harnessThinkingOptionIdSchema.optional(),
+  permissionModeId: harnessPermissionModeIdSchema.optional(),
   sourceRef: nativeSessionRefSchema,
   cwd: cwdSchema
 }).strict();
@@ -34879,7 +35247,7 @@ var harnessOutputSchema = external_exports.custom((value2) => {
 import { randomBytes as randomBytes2, randomUUID as randomUUID14 } from "node:crypto";
 import { chmod as chmod5, lstat as lstat9, mkdir as mkdir12, open as open8, readFile as readFile10, rename as rename9, rm as rm11 } from "node:fs/promises";
 import net4, {} from "node:net";
-import path23 from "node:path";
+import path24 from "node:path";
 function harnessError(message, retryable = true) {
   return { code: "unavailable", message, retryable, stage: "harnessBroker" };
 }
@@ -35004,13 +35372,13 @@ async function startHarnessBrokerServer(input) {
   if (input.adapter.harnessId !== "claude-code") {
     throw new Error("Harness broker accepts only the claude-code adapter");
   }
-  if (process.platform !== "win32" && path23.dirname(input.descriptorPath) !== path23.dirname(input.socketPath)) {
+  if (process.platform !== "win32" && path24.dirname(input.descriptorPath) !== path24.dirname(input.socketPath)) {
     throw new Error("Harness broker descriptor and socket must share one private directory");
   }
   if (process.platform === "darwin" && Buffer.byteLength(input.socketPath) > 103) {
     throw new Error("Harness broker Unix socket path is too long for macOS");
   }
-  await privateDirectory(path23.dirname(input.descriptorPath));
+  await privateDirectory(path24.dirname(input.descriptorPath));
   await assertNoLiveDescriptor(input.descriptorPath);
   if (process.platform !== "win32")
     await prepareUnixSocketPath(input.socketPath);