@codexhost/cli-darwin-x64 0.6.1 → 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",
@@ -22253,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",
@@ -22262,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) {
@@ -25898,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,
@@ -25914,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)
   };
 }
@@ -25946,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");
   }
 }
@@ -25968,6 +26164,7 @@ var HarnessDelegationCoordinator = class {
   #cancelOfficial;
   #startOfficial;
   #listOfficial;
+  #officialThreadCwd;
   #activeOfficialParents;
   constructor(input) {
     this.#adapters = input.adapters;
@@ -25983,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);
@@ -26006,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",
@@ -26015,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),
@@ -26042,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());
@@ -26056,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 } : {},
@@ -26127,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);
@@ -26366,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 {
@@ -28199,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),
@@ -29225,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)) {
@@ -29417,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: {
@@ -31667,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);
   }
@@ -31898,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;
@@ -31945,9 +32180,11 @@ import { createHash as createHash6, randomUUID as randomUUID9 } from "node:crypt
 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_VERSION = 7;
 var SKILL_RELATIVE_PATH = path15.join("skills", "codexhost-delegation", "SKILL.md");
 var PREVIOUS_MANAGED_DIGESTS = [
+  "9d2f491850fb0b4084a31ba9b5e4a550b5e833747af322090d8ed0ff80b88c30",
+  "2bb0aebb9b06febbc6c0c0bcdb0b32506c7cdbf8dc3b734cc6b2a86621270e4e",
   "aff258622dc8ff321f32b15620d081e578cb9c9ed1134d6a57f35ca8e7762c0a",
   "ba509f57e5448e796b3dfdd5031dcb08672eded50b61c0a54de84cfa02c49dd3",
   "d3ddf6db9bc5c5df825479c885bbbf0ca08da66f7057a12e02e1fdf57525149e",
@@ -31971,21 +32208,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.
+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.
-
-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,18 +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 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");
 function digest(value2) {