@codexhost/cli-darwin-x64 0.9.1 → 0.10.0

package/app/host-runtime.mjs

@@ -2278,7 +2278,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net5 = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes4, createHash: createHash10 } = __require("crypto");
+    var { randomBytes: randomBytes4, createHash: createHash11 } = __require("crypto");
     var { Duplex: Duplex2, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -2946,7 +2946,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest2 = createHash10("sha1").update(key + GUID).digest("base64");
+        const digest2 = createHash11("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest2) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -3315,7 +3315,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http = __require("http");
     var { Duplex: Duplex2 } = __require("stream");
-    var { createHash: createHash10 } = __require("crypto");
+    var { createHash: createHash11 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -3622,7 +3622,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest2 = createHash10("sha1").update(key + GUID).digest("base64");
+        const digest2 = createHash11("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -4283,7 +4283,7 @@ async function runDelegationCli(input) {
 
 // packages/host-runtime/src/run-host-runtime.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
-import path21 from "node:path";
+import path23 from "node:path";
 import { homedir as homedir2 } from "node:os";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
@@ -5978,10 +5978,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path26) {
-  if (!path26)
+function getElementAtPath(obj, path28) {
+  if (!path28)
     return obj;
-  return path26.reduce((acc, key) => acc?.[key], obj);
+  return path28.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -6390,11 +6390,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path26, issues) {
+function prefixIssues(path28, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path26);
+    iss.path.unshift(path28);
     return iss;
   });
 }
@@ -6541,16 +6541,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path26 = []) => {
+  const processError = (error52, path28 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path26, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path28, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path26, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path28, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path26, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path28, ...issue2.path]);
       } else {
-        const fullpath = [...path26, ...issue2.path];
+        const fullpath = [...path28, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -6577,17 +6577,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path26 = []) => {
+  const processError = (error52, path28 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path26, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path28, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path26, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path28, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path26, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path28, ...issue2.path]);
       } else {
-        const fullpath = [...path26, ...issue2.path];
+        const fullpath = [...path28, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -6619,8 +6619,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path26 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path26) {
+  const path28 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path28) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -19312,13 +19312,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path26 = ref.slice(1).split("/").filter(Boolean);
-  if (path26.length === 0) {
+  const path28 = ref.slice(1).split("/").filter(Boolean);
+  if (path28.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path26[0] === defsKey) {
-    const key = path26[1];
+  if (path28[0] === defsKey) {
+    const key = path28[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -19726,6 +19726,62 @@ function date4(params) {
 // node_modules/zod/v4/classic/external.js
 config(en_default());
 
+// packages/shared-contracts/dist/credential-imports.js
+var credentialSourceSchema = external_exports.object({
+  id: external_exports.string().min(1).max(256),
+  harnessId: external_exports.string().min(1),
+  label: external_exports.string().min(1).max(512),
+  provider: external_exports.enum(["openai-codex", "xai"])
+}).strict();
+var credentialImportNameSchema = external_exports.string().regex(/^[a-z][a-z0-9-]{0,47}$/);
+var credentialImportRecordSchema = external_exports.object({
+  name: credentialImportNameSchema,
+  source: credentialSourceSchema,
+  importedAt: external_exports.string()
+}).strict();
+var credentialImportsRequestSchema = external_exports.discriminatedUnion("action", [
+  external_exports.object({ action: external_exports.literal("list") }).strict(),
+  external_exports.object({
+    action: external_exports.literal("import"),
+    sourceId: external_exports.string().min(1).max(256),
+    name: credentialImportNameSchema,
+    confirmed: external_exports.literal(true)
+  }).strict(),
+  external_exports.object({
+    action: external_exports.literal("reimport"),
+    sourceId: external_exports.string().min(1).max(256),
+    name: credentialImportNameSchema,
+    confirmed: external_exports.literal(true)
+  }).strict(),
+  external_exports.object({
+    action: external_exports.literal("remove"),
+    name: credentialImportNameSchema,
+    confirmed: external_exports.literal(true)
+  }).strict()
+]);
+var credentialOtherLoginSchema = external_exports.object({
+  provider: external_exports.string().min(1).max(128),
+  type: external_exports.enum(["oauth", "api_key", "unknown"]),
+  /** Best-effort account label (e.g. the email in a Codex token), derived locally when present. */
+  label: external_exports.string().min(1).max(512).optional(),
+  /** Recognized credential vendor, derived from the OAuth token issuer. Absent when unknown. */
+  vendor: external_exports.enum(["openai-codex", "xai"]).optional()
+}).strict();
+var credentialImportsResultSchema = external_exports.object({
+  sources: external_exports.array(credentialSourceSchema),
+  targets: external_exports.array(external_exports.object({
+    harnessId: external_exports.string(),
+    providers: external_exports.array(external_exports.enum(["openai-codex", "xai"])),
+    imports: external_exports.array(credentialImportRecordSchema),
+    others: external_exports.array(credentialOtherLoginSchema).default([])
+  }).strict())
+}).strict();
+var credentialImportsParamsSchema = external_exports.object({
+  targetHarnessId: external_exports.string().min(1).max(128).optional(),
+  request: credentialImportsRequestSchema
+}).strict();
+var CREDENTIAL_IMPORTS_METHOD = "codexhost/harness/credential-imports";
+
 // packages/shared-contracts/dist/version.js
 var WORKSPACE_CONTRACT_VERSION = 1;
 
@@ -20466,10 +20522,21 @@ var harnessCommandDescriptorSchema = external_exports.object({
   invocation: commandInvocationSchema,
   label: commandLabelSchema,
   description: commandDescriptionSchema.optional(),
-  argumentMode: external_exports.enum(["none", "text"])
+  argumentMode: external_exports.enum(["none", "text"]),
+  /**
+   * Native distinction reported by the Harness. Omitted when the Harness does
+   * not tell skills and commands apart; consumers treat that as "command".
+   */
+  kind: external_exports.enum(["command", "skill"]).optional()
 }).strict();
 var harnessCommandCatalogSchema = external_exports.object({
-  commands: external_exports.array(harnessCommandDescriptorSchema)
+  commands: external_exports.array(harnessCommandDescriptorSchema),
+  /**
+   * `live` when the catalog includes what a native Session reports for its
+   * workspace (custom commands, skills); `static` for Adapter built-ins only.
+   * Omitted by Adapters; set by the Host on inspection results.
+   */
+  source: external_exports.enum(["live", "static"]).optional()
 }).strict().superRefine((catalog, context) => {
   const ids = /* @__PURE__ */ new Set();
   for (const [index, command] of catalog.commands.entries()) {
@@ -20483,7 +20550,11 @@ var harnessCommandCatalogSchema = external_exports.object({
     ids.add(command.id);
   }
 });
-var harnessCommandsInspectParamsSchema = external_exports.object({ harnessId: harnessIdSchema }).strict();
+var harnessCommandsInspectParamsSchema = external_exports.object({
+  harnessId: harnessIdSchema,
+  /** Workspace of a draft without a Thread, for its live catalog when known. */
+  cwd: external_exports.string().min(1).optional()
+}).strict();
 var threadCommandsInspectParamsSchema = external_exports.object({
   threadId: hostThreadIdSchema
 }).strict();
@@ -20627,9 +20698,360 @@ var updateStatusResultSchema = external_exports.strictObject({
   status: updateStatusSchema.nullable()
 });
 
+// packages/shared-contracts/dist/delegation-mention.js
+var DELEGATION_MENTION_PATH_PREFIX = "subagent://codexhost.";
+var MENTION_LINK_PATTERN = /\[@([^\]\n]+)\]\(<?subagent:\/\/codexhost\.([a-z0-9][a-z0-9-]*)>?\)/gu;
+function stripDelegationMentions(text) {
+  const mentions = [];
+  const seen = /* @__PURE__ */ new Set();
+  const rewritten = text.replace(MENTION_LINK_PATTERN, (_match, label, harnessId) => {
+    const trimmed = label.trim();
+    if (!seen.has(harnessId)) {
+      seen.add(harnessId);
+      mentions.push({ harnessId, label: trimmed });
+    }
+    return `@${trimmed}`;
+  });
+  return { text: rewritten, mentions };
+}
+var COMMAND_LINK_PATTERN = /([ \t]*)\[@([^\]\n]+)\]\(<?subagent:\/\/codexhost-command\.([^)\s>]+)>?\)([ \t]*)/gu;
+function restoreHarnessCommandMentions(text) {
+  let invocation = null;
+  const rest = text.replace(COMMAND_LINK_PATTERN, (match, before, _label, encoded, after) => {
+    if (invocation === null) {
+      try {
+        invocation = `/${decodeURIComponent(encoded)}`;
+      } catch {
+        return match;
+      }
+    }
+    return before || after ? " " : "";
+  });
+  if (invocation === null)
+    return text;
+  const argumentsText = rest.trim();
+  return argumentsText ? `${invocation} ${argumentsText}` : invocation;
+}
+
 // packages/shared-contracts/dist/index.js
 var workspaceContractVersionSchema = external_exports.literal(WORKSPACE_CONTRACT_VERSION);
 
+// packages/host-runtime/src/account/codex-credential-export.ts
+import { createHash as createHash2 } from "node:crypto";
+import { readFile as readFile4 } from "node:fs/promises";
+import os from "node:os";
+import path5 from "node:path";
+async function readCodexCredential(environment) {
+  try {
+    const home = environment.CODEX_HOME ?? path5.join(environment.HOME ?? os.homedir(), ".codex");
+    const auth = JSON.parse(await readFile4(path5.join(home, "auth.json"), "utf8"));
+    if (auth.OPENAI_API_KEY || auth.auth_mode && auth.auth_mode !== "chatgpt") return [];
+    const t = auth.tokens;
+    if (!t || ![t.access_token, t.refresh_token, t.account_id].every(
+      (v) => typeof v === "string" && v.length
+    ))
+      return [];
+    const claims = JSON.parse(Buffer.from(t.access_token.split(".")[1], "base64url").toString());
+    if (claims.client_id !== "app_EMoamEEZ73f0CkXaXp7hrann" || !Number.isFinite(claims.exp * 1e3))
+      return [];
+    const account = claims["https://api.openai.com/auth"]?.chatgpt_account_id;
+    if (account !== t.account_id) return [];
+    let email3;
+    try {
+      email3 = JSON.parse(Buffer.from(t.id_token.split(".")[1], "base64url").toString()).email;
+    } catch {
+    }
+    const identity = `${t.account_id}:${claims.sub ?? ""}`;
+    return [
+      {
+        source: {
+          id: `codex:${createHash2("sha256").update(identity).digest("hex")}`,
+          harnessId: "codex",
+          provider: "openai-codex",
+          label: typeof email3 === "string" && email3 ? email3 : "Codex"
+        },
+        oauth: {
+          access: t.access_token,
+          refresh: t.refresh_token,
+          expires: claims.exp * 1e3,
+          accountId: t.account_id
+        }
+      }
+    ];
+  } catch {
+    return [];
+  }
+}
+
+// packages/host-runtime/src/credential-imports.ts
+async function handleCredentialImports(params, adapters, environment) {
+  const input = credentialImportsParamsSchema.parse(params);
+  const installed = [...adapters];
+  const sources = await readCodexCredential(environment);
+  for (const adapter of installed) {
+    if (adapter.credentialExport) sources.push(...await adapter.credentialExport.read());
+  }
+  const request = input.request;
+  if (request.action !== "list") {
+    const target = installed.find((a) => a.harnessId === input.targetHarnessId)?.credentialImports;
+    if (!target) throw new Error("Target Harness does not support credential imports");
+    if (request.action === "remove") await target.remove(request.name);
+    else {
+      const source = sources.find((s) => s.source.id === request.sourceId);
+      if (!source || !target.providers.includes(source.source.provider))
+        throw new Error("Source login changed or is unavailable; refresh and confirm again");
+      if (request.action === "reimport") await target.reimport(request.name, source);
+      else await target.add(request.name, source);
+    }
+  }
+  const targets = [];
+  for (const adapter of installed) {
+    if (!adapter.credentialImports) continue;
+    try {
+      targets.push({
+        harnessId: adapter.harnessId,
+        providers: [...adapter.credentialImports.providers],
+        imports: await adapter.credentialImports.list(),
+        others: await listOthers(adapter)
+      });
+    } catch {
+    }
+  }
+  return credentialImportsResultSchema.parse({ sources: sources.map((s) => s.source), targets });
+}
+async function listOthers(adapter) {
+  try {
+    return await adapter.credentialImports?.listOthers?.() ?? [];
+  } catch {
+    return [];
+  }
+}
+
+// packages/host-runtime/src/delegation-skill.ts
+import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir as mkdir3, open as open3, readFile as readFile5, rename as rename2, rm as rm3, stat } from "node:fs/promises";
+import os2 from "node:os";
+import path6 from "node:path";
+var SKILL_VERSION = 7;
+var DELEGATION_SKILL_NAME = "codexhost-delegation";
+var SKILL_RELATIVE_PATH = path6.join("skills", DELEGATION_SKILL_NAME, "SKILL.md");
+var PREVIOUS_MANAGED_DIGESTS = [
+  "9d2f491850fb0b4084a31ba9b5e4a550b5e833747af322090d8ed0ff80b88c30",
+  "2bb0aebb9b06febbc6c0c0bcdb0b32506c7cdbf8dc3b734cc6b2a86621270e4e",
+  "aff258622dc8ff321f32b15620d081e578cb9c9ed1134d6a57f35ca8e7762c0a",
+  "ba509f57e5448e796b3dfdd5031dcb08672eded50b61c0a54de84cfa02c49dd3",
+  "d3ddf6db9bc5c5df825479c885bbbf0ca08da66f7057a12e02e1fdf57525149e",
+  "15eb63519ff867e1536c97188a0c43738d7a49d38d4d6adeb7a1036726e7246d"
+];
+var CODEXHOST_DELEGATION_SKILL = `---
+name: codexhost-delegation
+version: ${SKILL_VERSION}
+description: >
+  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
+
+Before acting, run:
+
+\`codexhost delegate --help\`
+
+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.
+
+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
+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.
+
+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;
+- cancel its current Turn;
+- read its current state immediately;
+- wait for a bounded period;
+- check it again later;
+- leave it running in the background.
+
+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 = createHash3("sha256").update(CODEXHOST_DELEGATION_SKILL).digest("hex");
+function digest(value2) {
+  return createHash3("sha256").update(value2).digest("hex");
+}
+function managedVersion(value2) {
+  const match = /^version:\s*(\d+)\s*$/mu.exec(value2);
+  return match ? Number(match[1]) : null;
+}
+async function readOptional(filePath) {
+  try {
+    return await readFile5(filePath, "utf8");
+  } catch (error51) {
+    if (error51.code === "ENOENT") return null;
+    throw error51;
+  }
+}
+async function atomicWrite(filePath, content) {
+  await mkdir3(path6.dirname(filePath), { recursive: true, mode: 448 });
+  const temporaryPath = path6.join(path6.dirname(filePath), `.SKILL.md.${randomUUID2()}.tmp`);
+  const handle = await open3(temporaryPath, "wx", 384);
+  try {
+    await handle.writeFile(content, "utf8");
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  try {
+    await rename2(temporaryPath, filePath);
+  } finally {
+    await rm3(temporaryPath, { force: true });
+  }
+}
+async function installDelegationSkills(input = {}) {
+  const home = input.homeDirectory ?? os2.homedir();
+  const destinations = [
+    path6.join(home, ".agents", SKILL_RELATIVE_PATH),
+    path6.join(home, ".claude", SKILL_RELATIVE_PATH)
+  ];
+  const knownDigests = /* @__PURE__ */ new Set([
+    CURRENT_DIGEST,
+    ...PREVIOUS_MANAGED_DIGESTS,
+    ...input.previousManagedDigests ?? []
+  ]);
+  const results = [];
+  for (const destination of destinations) {
+    const current = await readOptional(destination);
+    if (current === CODEXHOST_DELEGATION_SKILL) {
+      results.push({
+        path: destination,
+        status: "current",
+        version: SKILL_VERSION,
+        digest: CURRENT_DIGEST
+      });
+      continue;
+    }
+    if (current !== null) {
+      const currentDigest = digest(current);
+      const version2 = managedVersion(current);
+      if (!knownDigests.has(currentDigest)) {
+        results.push({ path: destination, status: "conflict", version: version2, digest: currentDigest });
+        continue;
+      }
+      await atomicWrite(destination, CODEXHOST_DELEGATION_SKILL);
+      results.push({
+        path: destination,
+        status: "updated",
+        version: SKILL_VERSION,
+        digest: CURRENT_DIGEST
+      });
+      continue;
+    }
+    await atomicWrite(destination, CODEXHOST_DELEGATION_SKILL);
+    results.push({
+      path: destination,
+      status: "installed",
+      version: SKILL_VERSION,
+      digest: CURRENT_DIGEST
+    });
+  }
+  for (const result of results) {
+    if (result.status === "conflict") continue;
+    const source = await readFile5(result.path, "utf8");
+    const metadata = await stat(result.path);
+    if (!metadata.isFile() || source !== CODEXHOST_DELEGATION_SKILL) {
+      throw new Error(`Delegation Skill verification failed: ${result.path}`);
+    }
+  }
+  const managed = results.filter((result) => result.status !== "conflict");
+  if (managed.some((result) => result.digest !== CURRENT_DIGEST)) {
+    throw new Error("Delegation Skill copies are inconsistent");
+  }
+  if (results.every((result) => result.status !== "conflict")) {
+    const copies = await Promise.all(results.map((result) => readFile5(result.path, "utf8")));
+    if (copies.some((copy) => copy !== copies[0])) {
+      throw new Error("Delegation Skill copies are inconsistent");
+    }
+  }
+  return results;
+}
+async function managedDelegationSkillReference(input = {}) {
+  const filePath = path6.join(input.homeDirectory ?? os2.homedir(), ".agents", SKILL_RELATIVE_PATH);
+  try {
+    return await readOptional(filePath) === CODEXHOST_DELEGATION_SKILL ? { name: DELEGATION_SKILL_NAME, path: filePath } : null;
+  } catch {
+    return null;
+  }
+}
+
+// packages/host-runtime/src/delegation-mention-rewrite.ts
+function describeTargets(mentions) {
+  return mentions.map(({ harnessId, label }) => `@${label} (Harness \`${harnessId}\`)`).join(", ");
+}
+function delegationMentionInstruction(mentions) {
+  const plural = mentions.length > 1;
+  return [
+    `[codexhost delegation] The user mentioned ${describeTargets(mentions)}.`,
+    `Use the ${DELEGATION_SKILL_NAME} skill to delegate this request to ${plural ? "each mentioned Harness" : "that Harness"}`,
+    "with `codexhost delegate start --harness <id>`, instead of doing the task yourself."
+  ].join(" ");
+}
+function appendInstruction(text, mentions) {
+  const instruction = delegationMentionInstruction(mentions);
+  return text.trim().length === 0 ? instruction : `${text}
+
+${instruction}`;
+}
+function rewriteDelegationMentionText(text) {
+  const { text: stripped, mentions } = stripDelegationMentions(text);
+  return mentions.length === 0 ? text : appendInstruction(stripped, mentions);
+}
+function isRecord(value2) {
+  return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
+}
+function rewriteDelegationMentionInput(input, skill) {
+  const mentions = [];
+  const seen = /* @__PURE__ */ new Set();
+  let lastTextIndex = -1;
+  const rewritten = input.map((item, index) => {
+    if (!isRecord(item) || item.type !== "text" || typeof item.text !== "string") return item;
+    lastTextIndex = index;
+    const result = stripDelegationMentions(item.text);
+    for (const mention of result.mentions) {
+      if (seen.has(mention.harnessId)) continue;
+      seen.add(mention.harnessId);
+      mentions.push(mention);
+    }
+    return result.mentions.length === 0 ? item : { ...item, text: result.text };
+  });
+  if (mentions.length === 0) return null;
+  const target = rewritten[lastTextIndex];
+  if (isRecord(target) && typeof target.text === "string") {
+    rewritten[lastTextIndex] = {
+      ...target,
+      text: appendInstruction(target.text, mentions)
+    };
+  }
+  const hasSkill = rewritten.some(
+    (item) => isRecord(item) && item.type === "skill" && item.name === skill?.name
+  );
+  if (skill && !hasSkill) rewritten.push({ type: "skill", name: skill.name, path: skill.path });
+  return rewritten;
+}
+
 // packages/harness-adapter/dist/output-channel.js
 var HarnessOutputChannel = class {
   outputs;
@@ -20708,11 +21130,11 @@ var usageFields = /* @__PURE__ */ new Set([
   "totalCredits",
   "contextUsagePercent"
 ]);
-function isRecord(value2) {
+function isRecord2(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function parseHostUsage(value2) {
-  if (!isRecord(value2))
+  if (!isRecord2(value2))
     throw new Error("Harness Usage must be an object");
   const keys = Object.keys(value2);
   if (keys.length === 0)
@@ -20769,6 +21191,82 @@ function parseHostUsage(value2) {
   return { ...value2 };
 }
 
+// packages/harness-adapter/dist/live-command-catalog.js
+var COMMON_EXCLUDED_LIVE_COMMANDS = /* @__PURE__ */ new Set([
+  // Session lifecycle
+  "branch",
+  "clear",
+  "exit",
+  "fork",
+  "fresh",
+  "new",
+  "quit",
+  "rename",
+  "rename-chat",
+  "reset",
+  "resume",
+  "rewind",
+  "session",
+  "sessions",
+  // Desktop-owned configuration
+  "autocompact",
+  "color",
+  "config",
+  "effort",
+  "fast",
+  "keybindings",
+  "model",
+  "models",
+  "output-style",
+  "permissions",
+  "settings",
+  "statusline",
+  "terminal-setup",
+  "theme",
+  "vim",
+  // Trust and approval policy
+  "always-approve",
+  "auto-mode-setup",
+  // Native login
+  "login",
+  "logout",
+  // Work outliving the Turn
+  "autopilot",
+  "background",
+  "bg",
+  "goal",
+  "jobs",
+  "loop",
+  "multitask",
+  "queue",
+  "remote-control",
+  "schedule",
+  "steer",
+  // Native terminal UI
+  "copy",
+  "debug",
+  "feedback",
+  "heapdump",
+  "share",
+  "shell",
+  // Plugin and MCP management
+  "marketplace",
+  "mcp",
+  "plugins",
+  "reload-plugins"
+]);
+var COMMON_EXCLUDED_LIVE_COMMAND_PREFIXES = ["__", "hooks-"];
+function isExcludedLiveCommand(name, kind, extra = {}) {
+  const normalized = name.trim().replace(/^\//u, "");
+  if (new Set(extra.names ?? []).has(normalized))
+    return true;
+  if (extra.prefixes?.some((prefix) => normalized.startsWith(prefix)))
+    return true;
+  if (kind === "skill")
+    return false;
+  return COMMON_EXCLUDED_LIVE_COMMANDS.has(normalized) || COMMON_EXCLUDED_LIVE_COMMAND_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+}
+
 // packages/harness-adapter/dist/index.js
 var packageMetadata = {
   name: "@codexhost/harness-adapter",
@@ -20777,10 +21275,10 @@ var packageMetadata = {
 
 // packages/mapping-store/dist/mapping-store.js
 import { execFileSync } from "node:child_process";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { constants } from "node:fs";
-import { copyFile as copyFile2, mkdir as mkdir3, open as open3, readFile as readFile4, readdir as readdir2, rename as rename2, rm as rm3, stat } from "node:fs/promises";
-import path5 from "node:path";
+import { copyFile as copyFile2, mkdir as mkdir4, open as open4, readFile as readFile6, readdir as readdir2, rename as rename3, rm as rm4, stat as stat2 } from "node:fs/promises";
+import path7 from "node:path";
 
 // packages/mapping-store/dist/records.js
 var nonBlankTextSchema6 = external_exports.string().refine((value2) => value2.trim().length > 0, {
@@ -20931,7 +21429,7 @@ function systemErrorCode2(error51) {
 }
 async function exists(file2) {
   try {
-    await stat(file2);
+    await stat2(file2);
     return true;
   } catch (error51) {
     if (systemErrorCode2(error51) === "ENOENT")
@@ -21041,13 +21539,13 @@ var MappingStore = class {
   #initialized = false;
   #lockHandle = null;
   constructor(options2) {
-    this.#directory = path5.resolve(options2.directory);
-    this.#threadsDirectory = path5.join(this.#directory, "threads");
-    this.#delegationsDirectory = path5.join(this.#directory, "delegations");
-    this.#backupsDirectory = path5.join(this.#directory, "backups");
-    this.#quarantineDirectory = path5.join(this.#directory, "quarantine");
-    this.#lockPath = path5.join(this.#directory, "store.lock");
-    this.#instanceId = options2.instanceId ?? randomUUID2();
+    this.#directory = path7.resolve(options2.directory);
+    this.#threadsDirectory = path7.join(this.#directory, "threads");
+    this.#delegationsDirectory = path7.join(this.#directory, "delegations");
+    this.#backupsDirectory = path7.join(this.#directory, "backups");
+    this.#quarantineDirectory = path7.join(this.#directory, "quarantine");
+    this.#lockPath = path7.join(this.#directory, "store.lock");
+    this.#instanceId = options2.instanceId ?? randomUUID3();
     this.#now = options2.now ?? (() => /* @__PURE__ */ new Date());
     this.#beforeReplace = options2.beforeReplace;
   }
@@ -21055,18 +21553,18 @@ var MappingStore = class {
     if (this.#initialized)
       return;
     await Promise.all([
-      mkdir3(this.#threadsDirectory, { recursive: true }),
-      mkdir3(this.#delegationsDirectory, { recursive: true }),
-      mkdir3(this.#backupsDirectory, { recursive: true }),
-      mkdir3(this.#quarantineDirectory, { recursive: true })
+      mkdir4(this.#threadsDirectory, { recursive: true }),
+      mkdir4(this.#delegationsDirectory, { recursive: true }),
+      mkdir4(this.#backupsDirectory, { recursive: true }),
+      mkdir4(this.#quarantineDirectory, { recursive: true })
     ]);
     await this.#acquireLock();
     try {
       await this.#cleanupResidue();
       const names = (await readdir2(this.#threadsDirectory)).filter((name) => name.endsWith(".json"));
       for (const name of names) {
-        const primary = path5.join(this.#threadsDirectory, name);
-        const backup = path5.join(this.#backupsDirectory, name);
+        const primary = path7.join(this.#threadsDirectory, name);
+        const backup = path7.join(this.#backupsDirectory, name);
         let record3 = null;
         try {
           record3 = await this.#readRecord(primary, name);
@@ -21075,31 +21573,31 @@ var MappingStore = class {
             record3 = await this.#readRecord(backup, name);
             await this.#replaceFile(primary, record3, false);
           } catch (backupError) {
-            const quarantine = path5.join(this.#quarantineDirectory, `${name}.${this.#now().getTime()}.invalid`);
-            await rename2(primary, quarantine).catch(() => void 0);
+            const quarantine = path7.join(this.#quarantineDirectory, `${name}.${this.#now().getTime()}.invalid`);
+            await rename3(primary, quarantine).catch(() => void 0);
             void primaryError;
             void backupError;
             continue;
           }
         }
         if (record3.state === "creating" && !record3.nativeSessionRef) {
-          await rm3(primary, { force: true });
-          await rm3(backup, { force: true });
+          await rm4(primary, { force: true });
+          await rm4(backup, { force: true });
           continue;
         }
         this.#records.set(record3.hostThreadId, record3);
       }
       const delegationNames = (await readdir2(this.#delegationsDirectory)).filter((name) => name.endsWith(".json"));
       for (const name of delegationNames) {
-        const file2 = path5.join(this.#delegationsDirectory, name);
+        const file2 = path7.join(this.#delegationsDirectory, name);
         try {
-          const parsed = storedDelegationRecordV1Schema.parse(JSON.parse(await readFile4(file2, "utf8")));
+          const parsed = storedDelegationRecordV1Schema.parse(JSON.parse(await readFile6(file2, "utf8")));
           if (`${parsed.delegationId}.json` !== name)
             throw new Error("filename mismatch");
           this.#delegations.set(parsed.delegationId, parsed);
         } catch {
-          const quarantine = path5.join(this.#quarantineDirectory, `${name}.${this.#now().getTime()}.invalid-delegation`);
-          await rename2(file2, quarantine).catch(() => void 0);
+          const quarantine = path7.join(this.#quarantineDirectory, `${name}.${this.#now().getTime()}.invalid-delegation`);
+          await rename3(file2, quarantine).catch(() => void 0);
         }
       }
       this.#rebuildIndexes();
@@ -21197,7 +21695,7 @@ var MappingStore = class {
   }
   async removeDelegation(delegationId) {
     this.#requireInitialized();
-    await rm3(this.#delegationPath(delegationId), { force: true });
+    await rm4(this.#delegationPath(delegationId), { force: true });
     this.#delegations.delete(delegationId);
     this.#rebuildIndexes();
   }
@@ -21370,8 +21868,8 @@ var MappingStore = class {
     if (!this.#records.has(hostThreadId))
       return;
     await Promise.all([
-      rm3(this.#recordPath(hostThreadId), { force: true }),
-      rm3(this.#backupPath(hostThreadId), { force: true })
+      rm4(this.#recordPath(hostThreadId), { force: true }),
+      rm4(this.#backupPath(hostThreadId), { force: true })
     ]);
     this.#records.delete(hostThreadId);
     this.#rebuildIndexes();
@@ -21384,9 +21882,9 @@ var MappingStore = class {
     if (handle)
       await handle.close().catch(() => void 0);
     try {
-      const current = JSON.parse(await readFile4(this.#lockPath, "utf8"));
+      const current = JSON.parse(await readFile6(this.#lockPath, "utf8"));
       if (current.instanceId === this.#instanceId)
-        await rm3(this.#lockPath, { force: true });
+        await rm4(this.#lockPath, { force: true });
     } catch {
     }
   }
@@ -21453,11 +21951,11 @@ var MappingStore = class {
     this.#rebuildIndexes();
   }
   async #replaceFile(target, record3, preserveBackup) {
-    const temp = `${target}.tmp-${randomUUID2()}`;
+    const temp = `${target}.tmp-${randomUUID3()}`;
     let handle = null;
     try {
       await this.#beforeReplace?.(cloneRecord(record3));
-      handle = await open3(temp, "wx", constants.S_IRUSR | constants.S_IWUSR);
+      handle = await open4(temp, "wx", constants.S_IRUSR | constants.S_IWUSR);
       await handle.writeFile(`${JSON.stringify(record3, null, 2)}
 `, "utf8");
       await handle.sync();
@@ -21466,10 +21964,10 @@ var MappingStore = class {
       if (preserveBackup && await exists(target)) {
         await copyFile2(target, this.#backupPath(record3.hostThreadId));
       }
-      await rename2(temp, target);
+      await rename3(temp, target);
     } catch (error51) {
       await handle?.close().catch(() => void 0);
-      await rm3(temp, { force: true }).catch(() => void 0);
+      await rm4(temp, { force: true }).catch(() => void 0);
       if (error51 instanceof MappingStoreError)
         throw error51;
       throw new MappingStoreError("IO_ERROR", "Mapping Store atomic replacement failed", {
@@ -21479,19 +21977,19 @@ var MappingStore = class {
   }
   async #replaceDelegationFile(record3) {
     const target = this.#delegationPath(record3.delegationId);
-    const temp = `${target}.tmp-${randomUUID2()}`;
+    const temp = `${target}.tmp-${randomUUID3()}`;
     let handle = null;
     try {
-      handle = await open3(temp, "wx", constants.S_IRUSR | constants.S_IWUSR);
+      handle = await open4(temp, "wx", constants.S_IRUSR | constants.S_IWUSR);
       await handle.writeFile(`${JSON.stringify(record3, null, 2)}
 `, "utf8");
       await handle.sync();
       await handle.close();
       handle = null;
-      await rename2(temp, target);
+      await rename3(temp, target);
     } catch (error51) {
       await handle?.close().catch(() => void 0);
-      await rm3(temp, { force: true }).catch(() => void 0);
+      await rm4(temp, { force: true }).catch(() => void 0);
       if (error51 instanceof MappingStoreError)
         throw error51;
       throw new MappingStoreError("IO_ERROR", "Delegation atomic replacement failed", {
@@ -21500,7 +21998,7 @@ var MappingStore = class {
     }
   }
   async #readRecord(file2, expectedName) {
-    const parsed = storedThreadRecordV1Schema.safeParse(JSON.parse(await readFile4(file2, "utf8")));
+    const parsed = storedThreadRecordV1Schema.safeParse(JSON.parse(await readFile6(file2, "utf8")));
     if (!parsed.success) {
       throw new MappingStoreError("INVALID_RECORD", "Mapping Store record is invalid", {
         cause: parsed.error
@@ -21518,15 +22016,15 @@ var MappingStore = class {
       readdir2(this.#directory)
     ]);
     await Promise.all([
-      ...threadNames.filter((name) => name.includes(".tmp-")).map((name) => rm3(path5.join(this.#threadsDirectory, name), { force: true })),
-      ...delegationNames.filter((name) => name.includes(".tmp-")).map((name) => rm3(path5.join(this.#delegationsDirectory, name), { force: true })),
+      ...threadNames.filter((name) => name.includes(".tmp-")).map((name) => rm4(path7.join(this.#threadsDirectory, name), { force: true })),
+      ...delegationNames.filter((name) => name.includes(".tmp-")).map((name) => rm4(path7.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(`${path5.basename(this.#lockPath)}.stale-`)).map((name) => rm3(path5.join(this.#directory, name), { force: true }))
+      ...rootNames.filter((name) => name.startsWith(`${path7.basename(this.#lockPath)}.stale-`)).map((name) => rm4(path7.join(this.#directory, name), { force: true }))
     ]);
   }
   async #acquireLock() {
     const attempt = async () => {
-      const handle = await open3(this.#lockPath, "wx", constants.S_IRUSR | constants.S_IWUSR);
+      const handle = await open4(this.#lockPath, "wx", constants.S_IRUSR | constants.S_IWUSR);
       const lock = {
         pid: process.pid,
         instanceId: this.#instanceId,
@@ -21548,13 +22046,13 @@ var MappingStore = class {
     }
     let existing = {};
     try {
-      existing = JSON.parse(await readFile4(this.#lockPath, "utf8"));
+      existing = JSON.parse(await readFile6(this.#lockPath, "utf8"));
     } catch {
     }
     if (typeof existing.pid === "number" && lockOwnerIsLive(existing)) {
       throw new MappingStoreError("STORE_LOCKED", "Another codexhost process owns Mapping Store");
     }
-    await rename2(this.#lockPath, `${this.#lockPath}.stale-${this.#now().getTime()}`).catch(() => void 0);
+    await rename3(this.#lockPath, `${this.#lockPath}.stale-${this.#now().getTime()}`).catch(() => void 0);
     try {
       this.#lockHandle = await attempt();
     } catch (error51) {
@@ -21622,13 +22120,13 @@ var MappingStore = class {
     await next;
   }
   #recordPath(hostThreadId) {
-    return path5.join(this.#threadsDirectory, `${hostThreadId}.json`);
+    return path7.join(this.#threadsDirectory, `${hostThreadId}.json`);
   }
   #delegationPath(delegationId) {
-    return path5.join(this.#delegationsDirectory, `${delegationId}.json`);
+    return path7.join(this.#delegationsDirectory, `${delegationId}.json`);
   }
   #backupPath(hostThreadId) {
-    return path5.join(this.#backupsDirectory, `${hostThreadId}.json`);
+    return path7.join(this.#backupsDirectory, `${hostThreadId}.json`);
   }
   #requireInitialized() {
     if (!this.#initialized) {
@@ -21648,7 +22146,7 @@ var TITLE_MAX_LENGTH = 150;
 var DESCRIPTION_MAX_LENGTH = 500;
 var SERVER_NAME_MAX_LENGTH = 80;
 var ELLIPSIS = "…";
-function isRecord2(value2) {
+function isRecord3(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function boundedText(value2, field, maxLength) {
@@ -21702,7 +22200,7 @@ function responseError(message) {
 function responsePersist(value2) {
   if (value2 === void 0 || value2 === null)
     return null;
-  if (!isRecord2(value2) || Object.keys(value2).length !== 1 || value2.persist !== "session" && value2.persist !== "always") {
+  if (!isRecord3(value2) || Object.keys(value2).length !== 1 || value2.persist !== "session" && value2.persist !== "always") {
     throw responseError("contains malformed persist metadata");
   }
   return value2.persist;
@@ -21748,7 +22246,7 @@ function projectCodexApprovalRequest(input) {
     },
     denyResponse,
     parseResponse(result) {
-      if (!isRecord2(result) || typeof result.action !== "string") {
+      if (!isRecord3(result) || typeof result.action !== "string") {
         throw responseError("missing action");
       }
       if (Object.keys(result).some((key) => key !== "action" && key !== "content" && key !== "_meta")) {
@@ -21756,7 +22254,7 @@ function projectCodexApprovalRequest(input) {
       }
       const selectedPersist = responsePersist(result._meta);
       if (result.action === "accept") {
-        if ("content" in result && (!isRecord2(result.content) || Object.keys(result.content).length !== 0)) {
+        if ("content" in result && (!isRecord3(result.content) || Object.keys(result.content).length !== 0)) {
           throw responseError("contains non-empty accepted content");
         }
         if (selectedPersist === "session") {
@@ -21816,7 +22314,7 @@ function projectApprovalChoices(input) {
     },
     denyResponse,
     parseResponse(result) {
-      if (!isRecord2(result) || typeof result.action !== "string")
+      if (!isRecord3(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");
@@ -21831,7 +22329,7 @@ function projectApprovalChoices(input) {
         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)) {
+      if (result.action !== "accept" || !isRecord3(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 };
@@ -21840,7 +22338,7 @@ function projectApprovalChoices(input) {
 }
 
 // packages/protocol-core/dist/codex-question.js
-function isRecord3(value2) {
+function isRecord4(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function responseError2(message) {
@@ -21909,7 +22407,7 @@ function projectCodexQuestionRequest(input) {
       }
     },
     parseResponse(result) {
-      if (!isRecord3(result) || !isRecord3(result.answers)) {
+      if (!isRecord4(result) || !isRecord4(result.answers)) {
         throw responseError2("missing answers object");
       }
       const rawAnswers = result.answers;
@@ -21922,7 +22420,7 @@ function projectCodexQuestionRequest(input) {
         const question = interaction.questions.find(({ id: id2 }) => id2 === questionId);
         if (!question)
           throw responseError2("contains an unknown Question ID");
-        if (!isRecord3(answerValue) || !Array.isArray(answerValue.answers)) {
+        if (!isRecord4(answerValue) || !Array.isArray(answerValue.answers)) {
           throw responseError2("answer entry has no answers array");
         }
         const values = answerValue.answers;
@@ -22004,7 +22502,7 @@ function projectCodexThreadUsage(input) {
 }
 
 // packages/protocol-core/dist/codex-native-usage.js
-function isRecord4(value2) {
+function isRecord5(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function nonNegativeSafeInteger(value2) {
@@ -22034,20 +22532,20 @@ function addBreakdown(target, source) {
   }
 }
 function observeCodexTokenUsage(value2) {
-  if (!isRecord4(value2) || value2.method !== "thread/tokenUsage/updated")
+  if (!isRecord5(value2) || value2.method !== "thread/tokenUsage/updated")
     return null;
   const params = value2.params;
-  if (!isRecord4(params))
+  if (!isRecord5(params))
     return null;
   const threadId2 = hostThreadIdSchema.safeParse(params.threadId);
   const turnId = hostTurnIdSchema.safeParse(params.turnId);
   if (!threadId2.success || !turnId.success)
     return null;
   const tokenUsage = params.tokenUsage;
-  if (!isRecord4(tokenUsage))
+  if (!isRecord5(tokenUsage))
     return null;
-  const total = isRecord4(tokenUsage.total) ? tokenUsage.total : void 0;
-  const last = isRecord4(tokenUsage.last) ? tokenUsage.last : void 0;
+  const total = isRecord5(tokenUsage.total) ? tokenUsage.total : void 0;
+  const last = isRecord5(tokenUsage.last) ? tokenUsage.last : void 0;
   const usage = {};
   addBreakdown(usage, total);
   const contextUsedTokens = nonNegativeSafeInteger(last?.totalTokens);
@@ -22072,7 +22570,7 @@ function observeCodexTokenUsage(value2) {
   }
 }
 function parseRateLimitWindow(value2) {
-  if (!isRecord4(value2))
+  if (!isRecord5(value2))
     return null;
   const usedPercent = finitePercent(value2.usedPercent);
   const windowDurationMins = nonNegativeSafeInteger(value2.windowDurationMins);
@@ -22083,7 +22581,7 @@ function parseRateLimitWindow(value2) {
   return { usedPercent, windowDurationMins, ...resetsAt !== void 0 ? { resetsAt } : {} };
 }
 function parseRateLimitCandidate(value2, options2 = {}) {
-  if (!isRecord4(value2))
+  if (!isRecord5(value2))
     return null;
   if (options2.genericOnly && value2.limitId !== void 0 && value2.limitId !== null && value2.limitId !== "codex") {
     return null;
@@ -22093,16 +22591,16 @@ function parseRateLimitCandidate(value2, options2 = {}) {
   return primary || secondary ? { primary, secondary } : null;
 }
 function rateLimitCandidates(value2) {
-  if (!isRecord4(value2))
+  if (!isRecord5(value2))
     return [];
-  const result = isRecord4(value2.result) ? value2.result : value2;
-  if (!isRecord4(result))
+  const result = isRecord5(value2.result) ? value2.result : value2;
+  if (!isRecord5(result))
     return [];
   const candidates = [];
   const base = parseRateLimitCandidate(result.rateLimits, { genericOnly: true });
   if (base)
     candidates.push(base);
-  const notificationParams = isRecord4(value2.params) ? value2.params : void 0;
+  const notificationParams = isRecord5(value2.params) ? value2.params : void 0;
   const notificationSnapshot = parseRateLimitCandidate(notificationParams?.rateLimits, {
     genericOnly: true
   });
@@ -22146,14 +22644,14 @@ function parseAvailableCount(value2) {
   return void 0;
 }
 function rateLimitResetCreditsSummary(value2) {
-  if (!isRecord4(value2))
+  if (!isRecord5(value2))
     return null;
-  const result = isRecord4(value2.result) ? value2.result : value2;
-  const fromResult = isRecord4(result) && isRecord4(result.rateLimitResetCredits) ? result.rateLimitResetCredits : null;
+  const result = isRecord5(value2.result) ? value2.result : value2;
+  const fromResult = isRecord5(result) && isRecord5(result.rateLimitResetCredits) ? result.rateLimitResetCredits : null;
   if (fromResult)
     return fromResult;
-  const params = isRecord4(value2.params) ? value2.params : void 0;
-  return isRecord4(params?.rateLimitResetCredits) ? params.rateLimitResetCredits : null;
+  const params = isRecord5(value2.params) ? value2.params : void 0;
+  return isRecord5(params?.rateLimitResetCredits) ? params.rateLimitResetCredits : null;
 }
 function observeCodexRateLimitResetCredits(value2) {
   const summary = rateLimitResetCreditsSummary(value2);
@@ -22165,7 +22663,7 @@ function observeCodexRateLimitResetCredits(value2) {
   const expiresAtUnix = [];
   if (Array.isArray(summary.credits)) {
     for (const credit of summary.credits) {
-      if (!isRecord4(credit))
+      if (!isRecord5(credit))
         continue;
       if (credit.status !== void 0 && credit.status !== "available")
         continue;
@@ -22316,16 +22814,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path26, added, removed, oldPosInc, options2) {
-    const last = path26.lastComponent;
+  addToPath(path28, added, removed, oldPosInc, options2) {
+    const last = path28.lastComponent;
     if (last && !options2.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path26.oldPos + oldPosInc,
+        oldPos: path28.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path26.oldPos + oldPosInc,
+        oldPos: path28.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -22754,10 +23252,10 @@ function splitLines(text) {
 }
 
 // packages/protocol-core/dist/file-change-summary.js
-import path6 from "node:path";
+import path8 from "node:path";
 function filePathKey(file2, cwd) {
   const windows = /^[a-z]:[/\\]/i.test(cwd) || /^[a-z]:[/\\]/i.test(file2);
-  const paths = windows ? path6.win32 : path6.posix;
+  const paths = windows ? path8.win32 : path8.posix;
   const resolved = paths.resolve(cwd, file2).replaceAll("\\", "/");
   return windows ? resolved.toLowerCase() : resolved;
 }
@@ -22908,11 +23406,11 @@ function itemStatus(outcome) {
     return "inProgress";
   return outcome.status === "succeeded" ? "completed" : "failed";
 }
-function isRecord5(value2) {
+function isRecord6(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function nestedString(value2, keys, preserveText = false) {
-  if (!isRecord5(value2))
+  if (!isRecord6(value2))
     return void 0;
   for (const key of keys) {
     const field = value2[key];
@@ -23026,8 +23524,8 @@ function projectFileChangeKind(kind) {
   return { type: kind };
 }
 function projectFileChanges(changes) {
-  return changes.map(({ path: path26, kind, unifiedDiff }) => ({
-    path: path26,
+  return changes.map(({ path: path28, kind, unifiedDiff }) => ({
+    path: path28,
     kind: projectFileChangeKind(kind),
     diff: unifiedDiff
   }));
@@ -23067,7 +23565,7 @@ function planFromTodoValue(value2) {
   const record3 = unwrapToolRecord(value2);
   if (!record3)
     return planFromChecklistText(typeof value2 === "string" ? value2 : null);
-  if (isRecord5(record3.TodosUpdated)) {
+  if (isRecord6(record3.TodosUpdated)) {
     const nested = planFromTodoValue(record3.TodosUpdated);
     if (nested)
       return nested;
@@ -23082,7 +23580,7 @@ function planFromTodoValue(value2) {
       plan.push({ step: entry.trim(), status: "pending" });
       continue;
     }
-    if (!isRecord5(entry))
+    if (!isRecord6(entry))
       continue;
     const step = nestedString(entry, ["content", "step", "text", "title", "description", "task"]);
     if (!step)
@@ -23137,7 +23635,7 @@ function unwrapToolRecord(value2) {
   }
   if (Array.isArray(value2))
     return { todos: value2 };
-  if (!isRecord5(value2))
+  if (!isRecord6(value2))
     return null;
   for (const wrapper of ["input", "arguments", "params"]) {
     if (value2[wrapper] === void 0)
@@ -23927,7 +24425,7 @@ var CodexTurnProjector = class {
 };
 
 // packages/protocol-core/dist/thread-fork.js
-function isRecord6(value2) {
+function isRecord7(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function optionalText(params, name, options2 = {}) {
@@ -23950,7 +24448,7 @@ function optionalBoolean(params, name) {
 function decodeThreadForkRequest(request) {
   if (request.method !== "thread/fork")
     return null;
-  if (!isRecord6(request.params))
+  if (!isRecord7(request.params))
     throw new Error("thread/fork params must be an object");
   const params = request.params;
   const threadId2 = optionalText(params, "threadId");
@@ -23965,13 +24463,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 path26 = optionalText(params, "path", { allowEmpty: true });
+  const path28 = optionalText(params, "path", { allowEmpty: true });
   const ephemeral = optionalBoolean(params, "ephemeral");
   return {
     threadId: threadId2,
     ...lastTurnText ? { lastTurnId: hostTurnIdSchema.parse(lastTurnText) } : {},
     ...beforeTurnText ? { beforeTurnId: hostTurnIdSchema.parse(beforeTurnText) } : {},
-    ...path26 ? { path: path26 } : {},
+    ...path28 ? { path: path28 } : {},
     ...optionalField(params, "model"),
     ...optionalField(params, "modelProvider"),
     ...optionalField(params, "cwd"),
@@ -23986,7 +24484,7 @@ function decodeThreadForkRequest(request) {
 function decodeThreadRevertRequest(request) {
   if (request.method !== "thread/revert")
     return null;
-  if (!isRecord6(request.params))
+  if (!isRecord7(request.params))
     throw new Error("thread/revert params must be an object");
   const { threadId: threadId2, beforeTurnId } = request.params;
   if (typeof threadId2 !== "string" || threadId2.length === 0) {
@@ -24000,7 +24498,7 @@ function decodeThreadRevertRequest(request) {
 function decodeThreadRollbackRequest(request) {
   if (request.method !== "thread/rollback")
     return null;
-  if (!isRecord6(request.params))
+  if (!isRecord7(request.params))
     throw new Error("thread/rollback params must be an object");
   const { threadId: threadId2, numTurns } = request.params;
   if (typeof threadId2 !== "string" || threadId2.length === 0) {
@@ -24064,7 +24562,7 @@ function threadForkResult(thread, input) {
 }
 
 // packages/protocol-core/dist/thread-management.js
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 var HOST_CURSOR_PREFIX = "codexhost:thread-list:v1:";
 var MAX_CURSOR_LENGTH = 65536;
 var DEFAULT_PAGE_SIZE = 25;
@@ -24097,13 +24595,13 @@ var THREAD_SOURCE_KINDS = /* @__PURE__ */ new Set([
   "subAgentOther",
   "unknown"
 ]);
-function isRecord7(value2) {
+function isRecord8(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function paramsObject(request, method) {
   if (request.params === void 0 && method === "thread/list")
     return {};
-  if (!isRecord7(request.params))
+  if (!isRecord8(request.params))
     throw new Error(`${method} params must be an object`);
   return request.params;
 }
@@ -24161,7 +24659,7 @@ function decodeSortKey(value2) {
   return value2;
 }
 function queryFingerprint(value2) {
-  return createHash2("sha256").update(JSON.stringify(value2)).digest("hex");
+  return createHash4("sha256").update(JSON.stringify(value2)).digest("hex");
 }
 function cursorPayload(value2) {
   return {
@@ -24175,7 +24673,7 @@ function cursorPayload(value2) {
   };
 }
 function parseCursorPayload(value2) {
-  if (!isRecord7(value2) || value2.formatVersion !== 1)
+  if (!isRecord8(value2) || value2.formatVersion !== 1)
     throw new Error("Host cursor is invalid");
   const { queryFingerprint: fingerprint, sortDirection: sortDirection2, officialCursor, officialDone } = value2;
   const { externalAnchor: externalAnchor2, externalDone } = value2;
@@ -24184,7 +24682,7 @@ function parseCursorPayload(value2) {
   }
   let anchor = null;
   if (externalAnchor2 !== null) {
-    if (!isRecord7(externalAnchor2) || !Number.isSafeInteger(externalAnchor2.timestamp) || typeof externalAnchor2.threadId !== "string" || externalAnchor2.threadId.length === 0) {
+    if (!isRecord8(externalAnchor2) || !Number.isSafeInteger(externalAnchor2.timestamp) || typeof externalAnchor2.threadId !== "string" || externalAnchor2.threadId.length === 0) {
       throw new Error("Host cursor is invalid");
     }
     anchor = {
@@ -24307,7 +24805,7 @@ function decodeThreadMetadataUpdateRequest(request) {
   if (params.gitInfo === null) {
     gitInfo = null;
   } else if (params.gitInfo !== void 0) {
-    if (!isRecord7(params.gitInfo)) {
+    if (!isRecord8(params.gitInfo)) {
       throw new Error("thread/metadata/update params.gitInfo must be an object or null");
     }
     gitInfo = {};
@@ -24335,7 +24833,7 @@ function optionalCursor(value2, name) {
   return value2;
 }
 function decodeOfficialThreadListPage(value2) {
-  if (!isRecord7(value2) || !Array.isArray(value2.data) || value2.data.some((row) => !isRecord7(row))) {
+  if (!isRecord8(value2) || !Array.isArray(value2.data) || value2.data.some((row) => !isRecord8(row))) {
     throw new Error("Official thread/list response is invalid");
   }
   return {
@@ -25147,22 +25645,22 @@ var HarnessAccountInspectionCache = class {
 };
 
 // packages/host-runtime/src/app-server-host.ts
-import { createHash as createHash6, randomUUID as randomUUID9 } from "node:crypto";
-import os3 from "node:os";
-import path12 from "node:path";
+import { createHash as createHash8, randomUUID as randomUUID10 } from "node:crypto";
+import os5 from "node:os";
+import path15 from "node:path";
 
 // packages/host-runtime/src/external-thread-fork.ts
 import nodePath from "node:path";
 
 // packages/host-runtime/src/external-thread-repository.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
-import os from "node:os";
-import path7 from "node:path";
+import { randomUUID as randomUUID5 } from "node:crypto";
+import os3 from "node:os";
+import path9 from "node:path";
 
 // packages/host-runtime/src/external-subagent-threads.ts
-import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID4 } from "node:crypto";
 function childCreateRequest(parent, nativeRef, id2) {
-  const key = createHash3("sha256").update(JSON.stringify([parent.hostThreadId, parent.harnessId, nativeRef.nativeSessionId, id2])).digest("hex");
+  const key = createHash5("sha256").update(JSON.stringify([parent.hostThreadId, parent.harnessId, nativeRef.nativeSessionId, id2])).digest("hex");
   return `subagent:${key}`;
 }
 function subagentMaterializer(store, parent, previousParent) {
@@ -25235,7 +25733,7 @@ function subagentMaterializer(store, parent, previousParent) {
       return rebind(existing, parent);
     }
     const provisional = existing ?? await store.createProvisional({
-      hostThreadId: hostThreadIdSchema.parse(randomUUID3()),
+      hostThreadId: hostThreadIdSchema.parse(randomUUID4()),
       createRequestId,
       harnessId: parent.harnessId,
       cwd: parent.cwd,
@@ -25297,8 +25795,8 @@ function sameMapping(left, right) {
 }
 function defaultMappingStoreDirectory(environment) {
   const dataDirectory = environment.CODEXHOST_DATA_DIR;
-  return path7.join(
-    dataDirectory ? path7.resolve(dataDirectory) : path7.join(os.homedir(), ".codexhost"),
+  return path9.join(
+    dataDirectory ? path9.resolve(dataDirectory) : path9.join(os3.homedir(), ".codexhost"),
     "mapping-store"
   );
 }
@@ -25395,7 +25893,7 @@ var ExternalThreadRepository = class {
         throw new Error("Derived Snapshot identity does not belong to its Native Session");
       }
       return {
-        hostTurnId: hostTurnIdSchema.parse(randomUUID4()),
+        hostTurnId: hostTurnIdSchema.parse(randomUUID5()),
         nativeTurnRef: turn.nativeTurnRef,
         ...turn.checkpoint ? { nativeCheckpointRef: turn.checkpoint } : {}
       };
@@ -25515,7 +26013,7 @@ var ExternalThreadRepository = class {
     const aligned = snapshot.turns.map((turn) => {
       const existing = mappingsByNative.get(nativeTurnKey2(turn.nativeTurnRef));
       const mapping = existing ?? {
-        hostTurnId: hostTurnIdSchema.parse(randomUUID4()),
+        hostTurnId: hostTurnIdSchema.parse(randomUUID5()),
         nativeTurnRef: turn.nativeTurnRef,
         ...turn.checkpoint ? { nativeCheckpointRef: turn.checkpoint } : {}
       };
@@ -25542,8 +26040,8 @@ var ExternalThreadRepository = class {
 };
 function createExternalThreadRecordInput(input) {
   return {
-    hostThreadId: input.hostThreadId ?? hostThreadIdSchema.parse(randomUUID4()),
-    createRequestId: input.createRequestId ?? randomUUID4(),
+    hostThreadId: input.hostThreadId ?? hostThreadIdSchema.parse(randomUUID5()),
+    createRequestId: input.createRequestId ?? randomUUID5(),
     harnessId: input.harnessId,
     cwd: input.cwd,
     ...input.title ? { title: input.title } : {},
@@ -25704,6 +26202,7 @@ async function executeExternalThreadFork(input) {
     return { ok: false, error: mapExternalThreadHarnessError(opened.error, "fork") };
   }
   const session = opened.value;
+  const inheritedPermissionModeId = await inheritSourcePermissionMode(source, session);
   try {
     const derivedNativeRef = session.initialState.nativeRef;
     if (!derivedNativeRef || derivedNativeRef.nativeSessionId === nativeSessionRef.nativeSessionId) {
@@ -25731,7 +26230,8 @@ async function executeExternalThreadFork(input) {
       sessionId: source.sessionId,
       thread,
       turns: aligned.turns,
-      ...snapshot.value.state ? { restoredState: snapshot.value.state } : {}
+      ...snapshot.value.state ? { restoredState: snapshot.value.state } : {},
+      ...inheritedPermissionModeId ? { requestedPermissionModeId: inheritedPermissionModeId } : {}
     });
     return {
       ok: true,
@@ -25749,6 +26249,23 @@ async function executeExternalThreadFork(input) {
     };
   }
 }
+async function inheritSourcePermissionMode(source, session) {
+  const sourceModeId = source.stateObserver.state.effectivePermissionModeId ?? source.requestedPermissionModeId;
+  if (!sourceModeId) return void 0;
+  const configuration = session.capabilities.configuration;
+  if (!configuration.selectPermissionMode || permissionModeFixedAtCreate(configuration)) {
+    return void 0;
+  }
+  try {
+    const selected = await session.execute({
+      type: "permissionMode.select",
+      permissionModeId: sourceModeId
+    });
+    return selected.ok ? sourceModeId : void 0;
+  } catch {
+    return void 0;
+  }
+}
 
 // packages/host-runtime/src/harness-session-import.ts
 function fixedError(code, message) {
@@ -27313,9 +27830,12 @@ var ExternalTurnSteering = class {
       if (!cancelled.ok) throw new ExternalSteerError(-32074, cancelled.error.message);
       const outcome = await Promise.race([terminal2.promise, failure.promise]);
       clearTimeout(timeout);
-      if (failureReason) throw failureReason;
-      if (this.#closed)
-        throw new ExternalSteerError(-32074, "External steering connection is closed");
+      const assertActive = () => {
+        if (failureReason) throw failureReason;
+        if (this.#closed)
+          throw new ExternalSteerError(-32074, "External steering connection is closed");
+      };
+      assertActive();
       if (outcome.status === "failed") throw new ExternalSteerError(-32074, outcome.error.message);
       if (thread.persistenceError)
         throw new ExternalSteerError(
@@ -27325,7 +27845,7 @@ var ExternalTurnSteering = class {
       if (thread.running || thread.activeTurnId) {
         throw new ExternalSteerError(-32072, "Another External Turn started before replacement");
       }
-      return await start(input.text);
+      return await start(input.text, assertActive);
     } finally {
       clearTimeout(timeout);
       if (this.#pending.get(thread.id) === pending) this.#pending.delete(thread.id);
@@ -27333,16 +27853,98 @@ var ExternalTurnSteering = class {
   }
 };
 
+// packages/host-runtime/src/external-command-routing.ts
+var ExternalCommandError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+function isExternalCommandCandidate(text) {
+  return /^\/[^\s/]+(?:\s|$)/u.test(text.trimStart());
+}
+async function inspectLiveCommandCatalog(commands, timeoutMs = 1e3) {
+  let timeout;
+  try {
+    const result = await Promise.race([
+      commands.list(),
+      new Promise((resolve) => {
+        timeout = setTimeout(() => resolve(null), timeoutMs);
+      })
+    ]);
+    return result?.ok ? harnessCommandCatalogSchema.parse(result.value) : null;
+  } catch {
+    return null;
+  } finally {
+    if (timeout !== void 0) clearTimeout(timeout);
+  }
+}
+async function resolveExternalCommand(commands, text, options2 = {}) {
+  const catalog = await commands.list();
+  if (!catalog.ok) throw new ExternalCommandError(-32073, catalog.error.message);
+  const commandText = text.trim();
+  const matched = catalog.value.commands.toSorted((left, right) => right.invocation.length - left.invocation.length).find((command) => {
+    if (commandText === command.invocation) return true;
+    return command.argumentMode === "text" && commandText.startsWith(`${command.invocation} `);
+  });
+  if (!matched) {
+    const name = /^\/(\S+)/u.exec(commandText)?.[1] ?? "";
+    if (name && !isExcludedLiveCommand(name, "command") && options2.liveCatalogPending?.(catalog.value)) {
+      return null;
+    }
+    throw new ExternalCommandError(
+      -32078,
+      "External Harness does not expose the requested command"
+    );
+  }
+  const argumentText = commandText.slice(matched.invocation.length).trimStart();
+  return {
+    commandId: matched.id,
+    ...argumentText.length > 0 ? { arguments: { text: argumentText } } : {}
+  };
+}
+
+// packages/host-runtime/src/live-command-catalog-cache.ts
+import path10 from "node:path";
+var MAX_ENTRIES = 64;
+function isLiveCommandCatalog(catalog, staticCatalog) {
+  const staticIds = new Set(staticCatalog.commands.map(({ id: id2 }) => id2));
+  return catalog.commands.some(({ id: id2 }) => !staticIds.has(id2));
+}
+var LiveCommandCatalogCache = class {
+  #entries = /* @__PURE__ */ new Map();
+  #key(harnessId, cwd) {
+    return `${harnessId}\0${path10.resolve(cwd)}`;
+  }
+  remember(harnessId, cwd, catalog) {
+    const key = this.#key(harnessId, cwd);
+    this.#entries.delete(key);
+    this.#entries.set(key, catalog);
+    while (this.#entries.size > MAX_ENTRIES) {
+      const oldest = this.#entries.keys().next().value;
+      if (oldest === void 0) break;
+      this.#entries.delete(oldest);
+    }
+  }
+  lookup(harnessId, cwd) {
+    return this.#entries.get(this.#key(harnessId, cwd));
+  }
+};
+function sameWorkspace(left, right) {
+  return path10.resolve(left) === path10.resolve(right);
+}
+
 // packages/host-runtime/src/harness-delegation-coordinator.ts
-import { createHash as createHash5, randomUUID as randomUUID5 } from "node:crypto";
-import path8 from "node:path";
+import { createHash as createHash7, randomUUID as randomUUID6 } from "node:crypto";
+import path11 from "node:path";
 
 // packages/host-runtime/src/delegation-snapshot.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 var CURSOR_PREFIX = "codexhost:thread-messages:v1:";
 var DEFAULT_MESSAGE_LIMIT = 25;
 var MAX_MESSAGE_LIMIT = 100;
-function isRecord8(value2) {
+function isRecord9(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function stringValue(value2) {
@@ -27351,12 +27953,12 @@ function stringValue(value2) {
 function textFromUserItem(item) {
   if (!Array.isArray(item.content)) return "";
   return item.content.flatMap(
-    (part) => isRecord8(part) && part.type === "text" && typeof part.text === "string" ? [part.text] : []
+    (part) => isRecord9(part) && part.type === "text" && typeof part.text === "string" ? [part.text] : []
   ).join("\n");
 }
 function threadStatus(value2, running) {
   if (running) return "running";
-  if (isRecord8(value2)) {
+  if (isRecord9(value2)) {
     if (value2.type === "active") return "running";
   }
   return "completed";
@@ -27373,10 +27975,10 @@ function allVisibleMessages(turns) {
     const turnId = stringValue(turn.id);
     if (!turnId || !Array.isArray(turn.items)) continue;
     const agentItems = turn.items.filter(
-      (item) => isRecord8(item) && item.type === "agentMessage"
+      (item) => isRecord9(item) && item.type === "agentMessage"
     );
     for (const item of turn.items) {
-      if (!isRecord8(item)) continue;
+      if (!isRecord9(item)) continue;
       const id2 = stringValue(item.id);
       if (!id2) continue;
       if (item.type === "userMessage") {
@@ -27392,7 +27994,7 @@ function allVisibleMessages(turns) {
   return messages;
 }
 function cursorFingerprint(threadId2) {
-  return createHash4("sha256").update(threadId2).digest("hex");
+  return createHash6("sha256").update(threadId2).digest("hex");
 }
 function encodeCursor(threadId2, offset) {
   const payload = JSON.stringify({ version: 1, fingerprint: cursorFingerprint(threadId2), offset });
@@ -27451,7 +28053,7 @@ function projectDelegationThreadSnapshot(input) {
   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 } : {}
+    ...isRecord9(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" ? [] : void 0;
@@ -27487,10 +28089,10 @@ function terminal(status) {
   return status === "completed" || status === "failed" || status === "interrupted";
 }
 function taskDigest(input) {
-  return createHash5("sha256").update(
+  return createHash7("sha256").update(
     JSON.stringify({
       task: input.task,
-      cwd: path8.resolve(input.cwd),
+      cwd: path11.resolve(input.cwd),
       modelId: input.model?.id ?? null,
       thinkingOptionId: input.thinkingOptionId ?? null
     })
@@ -27561,7 +28163,7 @@ var HarnessDelegationCoordinator = class {
     return {
       harnessId: input.harnessId,
       inspection: await adapter.inspect({
-        ...input.cwd ? { cwd: path8.resolve(input.cwd) } : {},
+        ...input.cwd ? { cwd: path11.resolve(input.cwd) } : {},
         ...input.refresh !== void 0 ? { refresh: input.refresh } : {}
       })
     };
@@ -27575,7 +28177,7 @@ var HarnessDelegationCoordinator = class {
       const result = await this.#startOfficial({ ...input, parentThreadId, cwd: selectedCwd });
       return { ...result, parentThreadId, cwd: result.cwd ?? selectedCwd };
     }
-    const startInput = { ...input, parentThreadId, cwd: path8.resolve(selectedCwd) };
+    const startInput = { ...input, parentThreadId, cwd: path11.resolve(selectedCwd) };
     if (!this.#adapters.has(input.harnessId)) {
       throw new DelegationControlError(
         "HARNESS_NOT_FOUND",
@@ -27615,10 +28217,10 @@ var HarnessDelegationCoordinator = class {
       });
       this.#validateConfiguration(inspected.inspection, input.model, input.thinkingOptionId);
     }
-    const delegationId = hostThreadIdSchema.parse(randomUUID5());
-    const childThreadId = hostThreadIdSchema.parse(randomUUID5());
-    const turnId = hostTurnIdSchema.parse(randomUUID5());
-    const createRequestId = input.requestId ? `delegation:${input.requestId}` : randomUUID5();
+    const delegationId = hostThreadIdSchema.parse(randomUUID6());
+    const childThreadId = hostThreadIdSchema.parse(randomUUID6());
+    const turnId = hostTurnIdSchema.parse(randomUUID6());
+    const createRequestId = input.requestId ? `delegation:${input.requestId}` : randomUUID6();
     let record3 = await this.#repository.createProvisional(
       createExternalThreadRecordInput({
         hostThreadId: childThreadId,
@@ -27750,7 +28352,7 @@ var HarnessDelegationCoordinator = class {
     if (thread.running || thread.activeTurnId) {
       throw new DelegationControlError("THREAD_BUSY", "Thread already has an active Turn");
     }
-    const turnId = hostTurnIdSchema.parse(randomUUID5());
+    const turnId = hostTurnIdSchema.parse(randomUUID6());
     try {
       await this.#startExternalTurn(thread, input.message, turnId);
     } catch (error51) {
@@ -28004,7 +28606,7 @@ var HarnessDelegationCoordinator = class {
 
 // packages/host-runtime/src/harness-plugin-loader.ts
 import { readdir as readdir3, realpath as realpath2 } from "node:fs/promises";
-import path10 from "node:path";
+import path13 from "node:path";
 import { pathToFileURL } from "node:url";
 
 // packages/host-runtime/src/harness-plugin-registry.ts
@@ -28041,25 +28643,25 @@ var HarnessPluginRegistry = class {
 };
 
 // packages/host-runtime/src/plugin-files.ts
-import { open as open4, realpath, stat as stat2 } from "node:fs/promises";
-import path9 from "node:path";
+import { open as open5, realpath, stat as stat3 } from "node:fs/promises";
+import path12 from "node:path";
 function inside(root, candidate) {
-  const relative = path9.relative(root, candidate);
-  return relative !== "" && !path9.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path9.sep}`);
+  const relative = path12.relative(root, candidate);
+  return relative !== "" && !path12.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path12.sep}`);
 }
 async function pluginResourcePath(root, relative) {
-  if (path9.isAbsolute(relative) || !inside(root, path9.resolve(root, relative))) {
+  if (path12.isAbsolute(relative) || !inside(root, path12.resolve(root, relative))) {
     throw new Error("Plugin resource escapes its root");
   }
-  const resolved = await realpath(path9.resolve(root, relative));
-  if (!inside(root, resolved) || !(await stat2(resolved)).isFile()) {
+  const resolved = await realpath(path12.resolve(root, relative));
+  if (!inside(root, resolved) || !(await stat3(resolved)).isFile()) {
     throw new Error("Plugin resource must be a regular file inside its root");
   }
   return resolved;
 }
 async function readPluginFile(file2, maximum) {
-  if (!(await stat2(file2)).isFile()) throw new Error("Plugin resource is not a regular file");
-  const handle = await open4(file2, "r");
+  if (!(await stat3(file2)).isFile()) throw new Error("Plugin resource is not a regular file");
+  const handle = await open5(file2, "r");
   try {
     const info = await handle.stat();
     if (!info.isFile() || info.size > maximum) throw new Error("Plugin resource exceeds its limit");
@@ -28213,7 +28815,7 @@ async function loadHarnessPlugins(options2) {
   const enabledIds = /* @__PURE__ */ new Set();
   const roots = /* @__PURE__ */ new Set();
   for (const configuredRoot of options2.roots) {
-    if (!path10.isAbsolute(configuredRoot)) {
+    if (!path13.isAbsolute(configuredRoot)) {
       diagnose({ code: "invalidRoot" });
       continue;
     }
@@ -28243,7 +28845,7 @@ async function loadHarnessPlugins(options2) {
       for (const directory of directories) {
         try {
           const file2 = await pluginResourcePath(root, `${directory.name}/manifest.json`);
-          const pluginRoot = await realpath2(path10.join(root, directory.name));
+          const pluginRoot = await realpath2(path13.join(root, directory.name));
           await pluginResourcePath(pluginRoot, "manifest.json");
           const manifest = harnessPluginManifestSchema.parse(
             JSON.parse(
@@ -28338,28 +28940,28 @@ async function loadHarnessPlugins(options2) {
 }
 
 // packages/host-runtime/src/harness-launch-settings.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
-import { mkdir as mkdir4, readFile as readFile5, rename as rename3, rm as rm4, stat as stat3, writeFile as writeFile3 } from "node:fs/promises";
-import os2 from "node:os";
-import path11 from "node:path";
+import { randomUUID as randomUUID7 } from "node:crypto";
+import { mkdir as mkdir5, readFile as readFile7, rename as rename4, rm as rm5, stat as stat4, writeFile as writeFile3 } from "node:fs/promises";
+import os4 from "node:os";
+import path14 from "node:path";
 var HarnessLaunchSettingsStore = class {
   #directory;
   #initial = /* @__PURE__ */ new Map();
   constructor(environment) {
-    this.#directory = path11.join(
-      environment.CODEXHOST_DATA_DIR ? path11.resolve(environment.CODEXHOST_DATA_DIR) : path11.join(os2.homedir(), ".codexhost"),
+    this.#directory = path14.join(
+      environment.CODEXHOST_DATA_DIR ? path14.resolve(environment.CODEXHOST_DATA_DIR) : path14.join(os4.homedir(), ".codexhost"),
       "harness-launch-settings"
     );
   }
   #file(id2) {
-    return path11.join(this.#directory, `${harnessPluginIdSchema.parse(id2)}.json`);
+    return path14.join(this.#directory, `${harnessPluginIdSchema.parse(id2)}.json`);
   }
   async #read(id2) {
     try {
       const value2 = harnessLaunchPathSchema.parse(
-        JSON.parse(await readFile5(this.#file(id2), "utf8"))
+        JSON.parse(await readFile7(this.#file(id2), "utf8"))
       );
-      if (!path11.isAbsolute(value2)) throw new Error("Expected an absolute entrypoint path");
+      if (!path14.isAbsolute(value2)) throw new Error("Expected an absolute entrypoint path");
       return value2;
     } catch (error51) {
       if (error51 && typeof error51 === "object" && "code" in error51 && error51.code === "ENOENT")
@@ -28385,22 +28987,22 @@ var HarnessLaunchSettingsStore = class {
     const initial = await this.initialCommand(id2) ?? null;
     const file2 = this.#file(id2);
     if (value2 === null) {
-      await rm4(file2, { force: true });
+      await rm5(file2, { force: true });
     } else {
       value2 = harnessLaunchPathSchema.parse(value2);
-      if (!path11.isAbsolute(value2))
+      if (!path14.isAbsolute(value2))
         throw new Error("Use an absolute entrypoint path without arguments");
-      const metadata = await stat3(value2).catch(() => void 0);
+      const metadata = await stat4(value2).catch(() => void 0);
       if (!metadata?.isDirectory() && !metadata?.isFile())
         throw new Error("The installation path must be an existing directory on this Host");
-      await mkdir4(this.#directory, { recursive: true, mode: 448 });
-      const temporary = `${file2}.${randomUUID6()}.tmp`;
+      await mkdir5(this.#directory, { recursive: true, mode: 448 });
+      const temporary = `${file2}.${randomUUID7()}.tmp`;
       try {
         await writeFile3(temporary, `${JSON.stringify(value2)}
 `, { mode: 384, flag: "wx" });
-        await rename3(temporary, file2);
+        await rename4(temporary, file2);
       } finally {
-        await rm4(temporary, { force: true });
+        await rm5(temporary, { force: true });
       }
     }
     return { path: value2, restartRequired: value2 !== initial };
@@ -28563,11 +29165,11 @@ function spawnOfficialAppServerConnection(input) {
 }
 
 // packages/host-runtime/src/account/codex-account-control.ts
-function isRecord9(value2) {
+function isRecord10(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function currentCodexAccountFromOfficialRead(result) {
-  if (!isRecord9(result) || !isRecord9(result.account) || result.account.type !== "chatgpt") {
+  if (!isRecord10(result) || !isRecord10(result.account) || result.account.type !== "chatgpt") {
     return null;
   }
   const email3 = external_exports.string().email().max(320).safeParse(result.account.email);
@@ -28597,13 +29199,13 @@ var SingleNativeCodexAccount = class {
 };
 
 // packages/host-runtime/src/codex-runtime/official-runtime-owner.ts
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 
 // packages/host-runtime/src/official-request-broker.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 var INTERNAL_REQUEST_PREFIX = "codexhost:official:";
 var MAX_RETIRED_IDS = 1024;
-function isRecord10(value2) {
+function isRecord11(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 var OfficialRequestBroker = class {
@@ -28616,7 +29218,7 @@ var OfficialRequestBroker = class {
   constructor(input) {
     this.#send = input.send;
     this.#timeoutMs = input.timeoutMs ?? 3e4;
-    this.#nextId = input.nextId ?? (() => `${INTERNAL_REQUEST_PREFIX}${randomUUID7()}`);
+    this.#nextId = input.nextId ?? (() => `${INTERNAL_REQUEST_PREFIX}${randomUUID8()}`);
   }
   get pendingCount() {
     return this.#pending.size;
@@ -28646,7 +29248,7 @@ var OfficialRequestBroker = class {
     });
   }
   handle(value2) {
-    if (!isRecord10(value2) || typeof value2.id !== "string") return false;
+    if (!isRecord11(value2) || typeof value2.id !== "string") return false;
     const pending = this.#pending.get(value2.id);
     if (!pending) return this.#retired.has(value2.id);
     clearTimeout(pending.timeout);
@@ -28970,7 +29572,7 @@ var OfficialRuntimeOwner = class {
   }
   #attach(role, output, onBackendStopped) {
     const client = {
-      id: randomUUID8(),
+      id: randomUUID9(),
       role,
       output,
       ...onBackendStopped ? { onBackendStopped } : {},
@@ -29128,7 +29730,7 @@ var OfficialRuntimeOwner = class {
     if (!object4(value2)) return client.output(event);
     if (typeof value2.id === "string" || typeof value2.id === "number") {
       if (typeof value2.method === "string") {
-        const id2 = `codexhost:server:${client.id}:${event.generation}:${randomUUID8()}`;
+        const id2 = `codexhost:server:${client.id}:${event.generation}:${randomUUID9()}`;
         client.serverRequests.set(id2, value2.id);
         const projected = { ...value2, id: id2 };
         return client.output({
@@ -29366,11 +29968,11 @@ function createOwnedConnectionBackend(factory) {
 }
 
 // packages/host-runtime/src/route-observation.ts
-function isRecord11(value2) {
+function isRecord12(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function classifyThreadPurpose(request) {
-  return isRecord11(request.params) && request.params.ephemeral === true ? "ephemeral" : "conversation";
+  return isRecord12(request.params) && request.params.ephemeral === true ? "ephemeral" : "conversation";
 }
 var RequestRouteObservationTracker = class {
   #nextCreateOrdinal = 0;
@@ -29395,13 +29997,13 @@ var RequestRouteObservationTracker = class {
     this.#createByThreadId.set(threadId2, tracked);
   }
   bindOfficialResponse(response) {
-    if (!isRecord11(response) || !("id" in response)) return;
+    if (!isRecord12(response) || !("id" in response)) return;
     const tracked = this.#pendingByRequestId.get(response.id);
     if (!tracked) return;
     this.#pendingByRequestId.delete(response.id);
     const result = response.result;
-    const thread = isRecord11(result) ? result.thread : null;
-    if (isRecord11(thread) && typeof thread.id === "string") {
+    const thread = isRecord12(result) ? result.thread : null;
+    if (isRecord12(thread) && typeof thread.id === "string") {
       this.#createByThreadId.set(thread.id, tracked);
     }
   }
@@ -29523,25 +30125,25 @@ function resolveExternalSessionTreeIds(records) {
   const resolve = (start) => {
     const cached2 = resolved.get(start.hostThreadId);
     if (cached2) return cached2;
-    const path26 = [];
+    const path28 = [];
     const visited = /* @__PURE__ */ new Set();
     let current = start;
     while (true) {
       const known = resolved.get(current.hostThreadId);
       if (known) {
-        for (const record3 of path26) resolved.set(record3.hostThreadId, known);
+        for (const record3 of path28) 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);
-      path26.push(current);
+      path28.push(current);
       const sourceId = current.subagent?.parentHostThreadId ?? current.forkSource?.hostThreadId;
       const source = sourceId ? byId.get(sourceId) : void 0;
       if (!source) {
         const root = current.hostThreadId;
-        for (const record3 of path26) resolved.set(record3.hostThreadId, root);
+        for (const record3 of path28) resolved.set(record3.hostThreadId, root);
         return root;
       }
       current = source;
@@ -29595,11 +30197,11 @@ var OfficialThreadListError = class extends Error {
   }
   rpcError;
 };
-function isRecord12(value2) {
+function isRecord13(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function officialThreadListPageFromResponse(response) {
-  if (isRecord12(response.error)) {
+  if (isRecord13(response.error)) {
     if (!Number.isSafeInteger(response.error.code) || typeof response.error.message !== "string") {
       throw new Error("Official thread/list error response is invalid");
     }
@@ -29767,14 +30369,14 @@ var THREAD_USAGE_UPDATED_METHOD = "codexhost/thread/usage/updated";
 function delay3(milliseconds) {
   return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
-function isRecord13(value2) {
+function isRecord14(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function isCreditsAdapter(adapter) {
   return typeof adapter.credits === "function";
 }
 function projectAccountCredits(value2) {
-  if (!isRecord13(value2)) return null;
+  if (!isRecord14(value2)) return null;
   const rest = { ...value2 };
   delete rest.fetchedAt;
   const parsed = accountCreditsSnapshotSchema.safeParse(rest);
@@ -29897,12 +30499,12 @@ function classifyCreateRequestRoute(request, defaultAgent) {
   };
 }
 function requestObject(request) {
-  if (!isRecord13(request.params)) throw new Error(`${request.method} params must be an object`);
+  if (!isRecord14(request.params)) throw new Error(`${request.method} params must be an object`);
   return request.params;
 }
 function requestText(params) {
   if (!Array.isArray(params.input)) throw new Error("turn/start input must be an array");
-  const text = params.input.filter((item) => isRecord13(item) && item.type === "text").map((item) => item.text).filter((value2) => typeof value2 === "string").join("\n");
+  const text = params.input.filter((item) => isRecord14(item) && item.type === "text").map((item) => item.text).filter((value2) => typeof value2 === "string").join("\n");
   if (!text) throw new Error("turn/start must contain text input");
   return text;
 }
@@ -29956,6 +30558,7 @@ var AppServerHost = class {
   #accountInspections = new HarnessAccountInspectionCache();
   #externalRuntime;
   #externalSteering = new ExternalTurnSteering();
+  #liveCommandCache = new LiveCommandCatalogCache();
   #repository;
   #pendingDesktopApprovals = /* @__PURE__ */ new Map();
   #pendingDesktopQuestions = /* @__PURE__ */ new Map();
@@ -29997,7 +30600,7 @@ var AppServerHost = class {
     this.#launchSettings = new HarnessLaunchSettingsStore(
       this.#options.pluginContext?.environment ?? environment
     );
-    const permanentHome = path12.resolve(environment.CODEX_HOME ?? path12.join(os3.homedir(), ".codex"));
+    const permanentHome = path15.resolve(environment.CODEX_HOME ?? path15.join(os5.homedir(), ".codex"));
     this.#ownsOfficialRuntimeScope = options2.officialRuntimeScope === void 0;
     this.#officialRuntimeScope = options2.officialRuntimeScope ?? new OfficialRuntimeScope({
       diagnosticOutput: this.#options.diagnosticOutput,
@@ -30010,7 +30613,8 @@ var AppServerHost = class {
             ...officialEnvironment(environment),
             CODEX_HOME: permanentHome
           },
-          ...this.#options.spawnOfficial ? { spawnOfficial: this.#options.spawnOfficial } : {}
+          ...this.#options.spawnOfficial ? { spawnOfficial: this.#options.spawnOfficial } : {},
+          ...this.#options.officialCloseTimeoutMs === void 0 ? {} : { closeTimeoutMs: this.#options.officialCloseTimeoutMs }
         })
       )
     });
@@ -30258,12 +30862,12 @@ var AppServerHost = class {
     for (const resolve of waiters) resolve();
   }
   #observeOfficialTurnStartResponse(value2) {
-    if (!isRecord13(value2) || !("id" in value2)) return;
+    if (!isRecord14(value2) || !("id" in value2)) return;
     const threadId2 = this.#pendingOfficialTurnStarts.get(value2.id);
     if (!threadId2) return;
     this.#pendingOfficialTurnStarts.delete(value2.id);
-    const result = isRecord13(value2.result) ? value2.result : null;
-    const turn = result && isRecord13(result.turn) ? result.turn : null;
+    const result = isRecord14(value2.result) ? value2.result : null;
+    const turn = result && isRecord14(result.turn) ? result.turn : null;
     if (turn && typeof turn.id === "string") {
       this.#activeOfficialTurns.set(threadId2, turn.id);
     }
@@ -30277,7 +30881,7 @@ var AppServerHost = class {
   async #forwardDesktop() {
     for await (const frame of readLfFrames(this.#options.desktopInput)) {
       const parsed = parseJsonFrame(frame);
-      if (isRecord13(parsed) && parsed.method === "initialized" && !("id" in parsed)) {
+      if (isRecord14(parsed) && parsed.method === "initialized" && !("id" in parsed)) {
         continue;
       }
       if (await this.#handleDesktopApprovalResponse(parsed)) continue;
@@ -30301,7 +30905,7 @@ var AppServerHost = class {
         }
         continue;
       }
-      const threadId2 = isRecord13(request.params) && typeof request.params.threadId === "string" ? request.params.threadId : void 0;
+      const threadId2 = isRecord14(request.params) && typeof request.params.threadId === "string" ? request.params.threadId : void 0;
       this.#dispatchDesktopRequest(
         () => this.#desktopRequests.run(
           threadId2,
@@ -30346,6 +30950,32 @@ var AppServerHost = class {
       this.#dispatchDesktopRequest(() => this.#handleCodexAccountRequest(request));
       return;
     }
+    if (request.method === CREDENTIAL_IMPORTS_METHOD) {
+      this.#dispatchDesktopRequest(async () => {
+        if (!credentialImportsParamsSchema.safeParse(request.params).success) {
+          await this.#writer.json(rpcError(request, -32602, "Invalid credential import request"));
+          return;
+        }
+        await this.#waitForPlugins();
+        try {
+          const result = await handleCredentialImports(
+            request.params,
+            this.#externalAdapters.values(),
+            this.#options.environment ?? process.env
+          );
+          await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(result) }));
+        } catch {
+          await this.#writer.json(
+            rpcError(
+              request,
+              -32077,
+              "Credential operation failed. Check the source login, choose an unused Provider name, and verify Pi configuration access."
+            )
+          );
+        }
+      });
+      return;
+    }
     if (request.method === "codexhost/harness/accounts/sources") {
       this.#dispatchDesktopRequest(async () => {
         if (!harnessAccountSourceListParamsSchema.safeParse(request.params).success) {
@@ -30503,7 +31133,7 @@ var AppServerHost = class {
           rpcError(request, -32602, "Invalid Harness command inspection params")
         );
       } else {
-        await this.#writeHarnessCommandCatalog(request, params.data.harnessId);
+        await this.#writeHarnessCommandCatalog(request, params.data.harnessId, params.data.cwd);
       }
       return;
     }
@@ -30600,7 +31230,7 @@ var AppServerHost = class {
       return;
     }
     if (request.method === "thread/fork") {
-      const params = isRecord13(request.params) ? request.params : {};
+      const params = isRecord14(request.params) ? request.params : {};
       const resolution = typeof params.threadId === "string" ? await this.#resolveExternalThread(params.threadId) : { kind: "official" };
       if (resolution.kind === "error") {
         await this.#writer.json(rpcError(request, resolution.error.code, resolution.error.message));
@@ -30621,7 +31251,7 @@ var AppServerHost = class {
       }
     }
     if (request.method === "thread/revert") {
-      const params = isRecord13(request.params) ? request.params : {};
+      const params = isRecord14(request.params) ? request.params : {};
       const resolution = typeof params.threadId === "string" ? await this.#resolveExternalThread(params.threadId) : { kind: "official" };
       if (resolution.kind === "error") {
         await this.#writer.json(rpcError(request, resolution.error.code, resolution.error.message));
@@ -30642,7 +31272,7 @@ var AppServerHost = class {
       }
     }
     if (request.method === "thread/rollback") {
-      const params = isRecord13(request.params) ? request.params : {};
+      const params = isRecord14(request.params) ? request.params : {};
       const resolution = typeof params.threadId === "string" ? await this.#resolveExternalThread(params.threadId) : { kind: "official" };
       if (resolution.kind === "error") {
         await this.#writer.json(rpcError(request, resolution.error.code, resolution.error.message));
@@ -30798,7 +31428,7 @@ var AppServerHost = class {
         return;
       }
     }
-    if (request.method.startsWith("thread/") && !EXPLICIT_EXTERNAL_THREAD_METHODS.has(request.method) && isRecord13(request.params) && typeof request.params.threadId === "string") {
+    if (request.method.startsWith("thread/") && !EXPLICIT_EXTERNAL_THREAD_METHODS.has(request.method) && isRecord14(request.params) && typeof request.params.threadId === "string") {
       const location = await this.#locateExternalThread(request.params.threadId);
       if (await this.#writeResolutionError(request, location)) return;
       if (location.kind === "external") {
@@ -30808,10 +31438,30 @@ var AppServerHost = class {
         return;
       }
     }
-    await this.#forwardOfficialRequest(request, frame);
+    await this.#forwardOfficialRequest(
+      request,
+      await this.#rewriteOfficialDelegationMentions(request, frame)
+    );
+  }
+  /** Native Codex Turns: turn `#` delegation chips into an explicit Skill-backed request. */
+  async #rewriteOfficialDelegationMentions(request, frame) {
+    if (request.method !== "turn/start" && request.method !== "turn/steer") return frame;
+    if (!isRecord14(request.params) || !Array.isArray(request.params.input)) return frame;
+    const input = request.params.input;
+    if (!input.some(
+      (item) => isRecord14(item) && typeof item.text === "string" && item.text.includes(DELEGATION_MENTION_PATH_PREFIX)
+    )) {
+      return frame;
+    }
+    const rewritten = rewriteDelegationMentionInput(input, await managedDelegationSkillReference());
+    if (!rewritten) return frame;
+    return encodeJsonFrame({
+      ...request,
+      params: { ...request.params, input: rewritten }
+    });
   }
   async #forwardOfficialNonRequest(value2, frame) {
-    const response = isRecord13(value2) ? value2 : null;
+    const response = isRecord14(value2) ? value2 : null;
     const request = response && (typeof response.id === "string" || typeof response.id === "number") ? this.#officialServerRequests.get(response.id) : null;
     if (request !== void 0 && response) {
       this.#officialServerRequests.delete(response.id);
@@ -30840,7 +31490,7 @@ var AppServerHost = class {
     const parsed = input.value;
     this.#observeOfficialTurnStartResponse(parsed);
     let forwarded = parsed;
-    if (isRecord13(parsed) && typeof parsed.method === "string" && "id" in parsed) {
+    if (isRecord14(parsed) && typeof parsed.method === "string" && "id" in parsed) {
       const originalId = parsed.id;
       if (typeof originalId === "string" || typeof originalId === "number") {
         const forwardedId = `codexhost:official:${++this.#nextOfficialServerRequestId}`;
@@ -30848,7 +31498,7 @@ var AppServerHost = class {
         forwarded = { ...parsed, id: forwardedId };
       }
     }
-    const accountScopedNotification = isRecord13(parsed) && typeof parsed.method === "string" && (parsed.method === "account/updated" || parsed.method.startsWith("account/rateLimits/"));
+    const accountScopedNotification = isRecord14(parsed) && typeof parsed.method === "string" && (parsed.method === "account/updated" || parsed.method.startsWith("account/rateLimits/"));
     if (accountScopedNotification) {
       if (parsed.method === "account/updated") this.#officialRateLimits.reset(input.accountId);
     }
@@ -30917,10 +31567,10 @@ var AppServerHost = class {
     }
   }
   async #observeOfficialTurnLifecycle(value2) {
-    if (!isRecord13(value2) || !isRecord13(value2.params)) return;
+    if (!isRecord14(value2) || !isRecord14(value2.params)) return;
     const params = value2.params;
     if (value2.method === "turn/started" && typeof params.threadId === "string") {
-      const turn = isRecord13(params.turn) ? params.turn : null;
+      const turn = isRecord14(params.turn) ? params.turn : null;
       if (turn && typeof turn.id === "string") {
         this.#forgetPendingOfficialTurnStarts(params.threadId);
         this.#activeOfficialTurns.set(params.threadId, turn.id);
@@ -30933,7 +31583,7 @@ var AppServerHost = class {
       const delegation = await this.#repository.getDelegationByChild(
         hostThreadIdSchema.parse(params.threadId)
       );
-      const turn = isRecord13(params.turn) ? params.turn : null;
+      const turn = isRecord14(params.turn) ? params.turn : null;
       const status = turn?.status === "failed" ? "failed" : turn?.status === "interrupted" || turn?.status === "cancelled" ? "interrupted" : "completed";
       if (this.#pendingOfficialDelegationThreads.has(params.threadId)) {
         this.#pendingOfficialTerminalStatuses.set(params.threadId, status);
@@ -30963,28 +31613,28 @@ var AppServerHost = class {
   }
   async #readOfficialThreadCwd(threadId2) {
     const response = await this.#requestOfficial("thread/read", { threadId: threadId2 });
-    if (isRecord13(response.error)) return void 0;
-    const result = isRecord13(response.result) ? response.result : null;
-    const thread = result && isRecord13(result.thread) ? result.thread : null;
+    if (isRecord14(response.error)) return void 0;
+    const result = isRecord14(response.result) ? response.result : null;
+    const thread = result && isRecord14(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 (isRecord13(response.error)) {
+    if (isRecord14(response.error)) {
       throw new DelegationControlError(
         "DELEGATION_FAILED",
         typeof response.error.message === "string" ? response.error.message : "Official Model catalog could not be read"
       );
     }
-    const result = isRecord13(response.result) ? response.result : null;
+    const result = isRecord14(response.result) ? response.result : null;
     const data = result && Array.isArray(result.data) ? result.data : [];
     const thinkingById = /* @__PURE__ */ new Map();
     const models = data.flatMap((candidate) => {
-      if (!isRecord13(candidate) || typeof candidate.model !== "string" || !candidate.model.trim()) {
+      if (!isRecord14(candidate) || typeof candidate.model !== "string" || !candidate.model.trim()) {
         return [];
       }
       const supportedThinkingOptionIds = Array.isArray(candidate.supportedReasoningEfforts) ? candidate.supportedReasoningEfforts.flatMap((option) => {
-        if (!isRecord13(option) || typeof option.reasoningEffort !== "string" || !option.reasoningEffort.trim()) {
+        if (!isRecord14(option) || typeof option.reasoningEffort !== "string" || !option.reasoningEffort.trim()) {
           return [];
         }
         const id2 = harnessThinkingOptionIdSchema.safeParse(option.reasoningEffort);
@@ -31004,9 +31654,9 @@ var AppServerHost = class {
       ];
     });
     const defaultEntry = data.find(
-      (candidate) => isRecord13(candidate) && candidate.isDefault === true
+      (candidate) => isRecord14(candidate) && candidate.isDefault === true
     );
-    const defaultModel = isRecord13(defaultEntry) && typeof defaultEntry.model === "string" ? encodeOfficialCodexModelRef(defaultEntry.model) : void 0;
+    const defaultModel = isRecord14(defaultEntry) && typeof defaultEntry.model === "string" ? encodeOfficialCodexModelRef(defaultEntry.model) : void 0;
     return {
       harnessId: input.harnessId,
       inspection: {
@@ -31036,7 +31686,7 @@ var AppServerHost = class {
       throw new DelegationControlError("INVALID_ARGUMENT", "Official Model Ref is invalid");
     }
     const nativeModelId = requestedModel ? decodeOfficialCodexModelRef(requestedModel) : void 0;
-    const digest2 = createHash6("sha256").update(
+    const digest2 = createHash8("sha256").update(
       JSON.stringify({
         task: input.task,
         cwd: input.cwd,
@@ -31112,8 +31762,8 @@ var AppServerHost = class {
       ephemeral: false,
       historyMode: "paginated"
     });
-    const startedResult = isRecord13(started.result) ? started.result : null;
-    const thread = startedResult && isRecord13(startedResult.thread) ? startedResult.thread : null;
+    const startedResult = isRecord14(started.result) ? started.result : null;
+    const thread = startedResult && isRecord14(startedResult.thread) ? startedResult.thread : null;
     const threadId2 = thread && typeof thread.id === "string" ? thread.id : null;
     if (!threadId2) throw new Error("Official thread/start returned no Thread identity");
     this.#pendingOfficialDelegationThreads.add(threadId2);
@@ -31125,8 +31775,8 @@ var AppServerHost = class {
         ...nativeModelId ? { model: nativeModelId } : {},
         ...input.thinkingOptionId ? { effort: input.thinkingOptionId } : {}
       });
-      const turnResult = isRecord13(turn.result) ? turn.result : null;
-      const turnValue = turnResult && isRecord13(turnResult.turn) ? turnResult.turn : null;
+      const turnResult = isRecord14(turn.result) ? turn.result : null;
+      const turnValue = turnResult && isRecord14(turnResult.turn) ? turnResult.turn : null;
       const parsedTurnId = turnValue && typeof turnValue.id === "string" ? turnValue.id : null;
       if (!parsedTurnId) throw new Error("Official turn/start returned no Turn identity");
       turnId = parsedTurnId;
@@ -31137,7 +31787,7 @@ var AppServerHost = class {
       throw error51;
     }
     this.#activeOfficialTurns.set(threadId2, turnId);
-    const delegationId = hostThreadIdSchema.parse(randomUUID9());
+    const delegationId = hostThreadIdSchema.parse(randomUUID10());
     try {
       const source = await this.#repository.find(input.parentThreadId);
       const pendingTerminal = this.#pendingOfficialTerminalStatuses.get(threadId2);
@@ -31196,27 +31846,27 @@ var AppServerHost = class {
       threadId: input.threadId,
       includeTurns: true
     });
-    if (isRecord13(current.error) || !isRecord13(current.result)) {
+    if (isRecord14(current.error) || !isRecord14(current.result)) {
       throw new DelegationControlError("THREAD_NOT_FOUND", "Official Thread was not found");
     }
-    const currentThread = isRecord13(current.result.thread) ? current.result.thread : null;
+    const currentThread = isRecord14(current.result.thread) ? current.result.thread : null;
     const currentTurns = currentThread && Array.isArray(currentThread.turns) ? currentThread.turns : [];
     const latestTurn = currentTurns.at(-1);
-    if (currentThread && isRecord13(currentThread.status) && currentThread.status.type === "active" || isRecord13(latestTurn) && (latestTurn.status === "inProgress" || latestTurn.status === "running")) {
+    if (currentThread && isRecord14(currentThread.status) && currentThread.status.type === "active" || isRecord14(latestTurn) && (latestTurn.status === "inProgress" || latestTurn.status === "running")) {
       throw new DelegationControlError("THREAD_BUSY", "Thread already has an active Turn");
     }
     const response = await this.#requestOfficial("turn/start", {
       threadId: input.threadId,
       input: [{ type: "text", text: input.message }]
     });
-    if (isRecord13(response.error)) {
+    if (isRecord14(response.error)) {
       throw new DelegationControlError(
         "DELEGATION_FAILED",
         typeof response.error.message === "string" ? response.error.message : "Turn start failed"
       );
     }
-    const result = isRecord13(response.result) ? response.result : null;
-    const turn = result && isRecord13(result.turn) ? result.turn : null;
+    const result = isRecord14(response.result) ? response.result : null;
+    const turn = result && isRecord14(result.turn) ? result.turn : null;
     const turnId = turn && typeof turn.id === "string" ? turn.id : null;
     if (!turnId) throw new Error("Official turn/start returned no Turn identity");
     this.#activeOfficialTurns.set(input.threadId, turnId);
@@ -31238,13 +31888,13 @@ var AppServerHost = class {
         threadId: input.threadId,
         includeTurns: true
       });
-      if (isRecord13(current.error) || !isRecord13(current.result)) {
+      if (isRecord14(current.error) || !isRecord14(current.result)) {
         throw new DelegationControlError("THREAD_NOT_FOUND", "Official Thread was not found");
       }
-      const currentThread = isRecord13(current.result.thread) ? current.result.thread : null;
+      const currentThread = isRecord14(current.result.thread) ? current.result.thread : null;
       const currentTurns = currentThread && Array.isArray(currentThread.turns) ? currentThread.turns : [];
       const latestTurn = currentTurns.at(-1);
-      if (isRecord13(latestTurn) && typeof latestTurn.id === "string" && (latestTurn.status === "inProgress" || latestTurn.status === "running")) {
+      if (isRecord14(latestTurn) && typeof latestTurn.id === "string" && (latestTurn.status === "inProgress" || latestTurn.status === "running")) {
         turnId = latestTurn.id;
         this.#activeOfficialTurns.set(input.threadId, turnId);
       } else {
@@ -31255,7 +31905,7 @@ var AppServerHost = class {
       threadId: input.threadId,
       turnId
     });
-    if (isRecord13(response.error)) {
+    if (isRecord14(response.error)) {
       throw new DelegationControlError(
         "DELEGATION_FAILED",
         typeof response.error.message === "string" ? response.error.message : "Turn cancel failed"
@@ -31268,18 +31918,18 @@ var AppServerHost = class {
       threadId: input.threadId,
       includeTurns: true
     });
-    if (isRecord13(response.error)) {
+    if (isRecord14(response.error)) {
       throw new DelegationControlError(
         "THREAD_NOT_FOUND",
         typeof response.error.message === "string" ? response.error.message : "Official Thread was not found"
       );
     }
-    const result = isRecord13(response.result) ? response.result : null;
-    const thread = result && isRecord13(result.thread) ? result.thread : null;
+    const result = isRecord14(response.result) ? response.result : null;
+    const thread = result && isRecord14(result.thread) ? result.thread : null;
     if (!thread)
       throw new DelegationControlError("THREAD_NOT_FOUND", "Official Thread was not found");
-    const turns = Array.isArray(thread.turns) ? thread.turns.filter((turn) => isRecord13(turn)) : [];
-    const running = this.#activeOfficialTurns.has(input.threadId) || isRecord13(thread.status) && thread.status.type === "active";
+    const turns = Array.isArray(thread.turns) ? thread.turns.filter((turn) => isRecord14(turn)) : [];
+    const running = this.#activeOfficialTurns.has(input.threadId) || isRecord14(thread.status) && thread.status.type === "active";
     const snapshot = projectDelegationThreadSnapshot({
       threadId: input.threadId,
       harnessId: "codex",
@@ -31301,7 +31951,7 @@ var AppServerHost = class {
   async #listDelegationThreads(input) {
     const [sortKey, sortDirection2] = input.sort.split("-");
     const request = {
-      id: `codexhost:delegation-list:${randomUUID9()}`,
+      id: `codexhost:delegation-list:${randomUUID10()}`,
       method: "thread/list",
       params: {
         cwd: input.cwd ? [input.cwd] : null,
@@ -31329,7 +31979,7 @@ var AppServerHost = class {
       threads: result.data.flatMap((entry) => {
         if (typeof entry.id !== "string") return [];
         const record3 = records.find((candidate) => candidate.hostThreadId === entry.id);
-        const status = isRecord13(entry.status) && entry.status.type === "active" ? "running" : "completed";
+        const status = isRecord14(entry.status) && entry.status.type === "active" ? "running" : "completed";
         return [
           {
             threadId: entry.id,
@@ -31649,21 +32299,67 @@ var AppServerHost = class {
       await this.#writer.json(rpcEnvelope(request, { result: { commands: [] } }));
       return;
     }
-    await this.#writeHarnessCommandCatalog(request, location.record.harnessId);
+    const loaded = this.#externalRuntime.get(params.data.threadId);
+    if (loaded) {
+      const catalog = await this.#inspectLoadedCommands(loaded);
+      if (catalog) {
+        await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(catalog) }));
+        return;
+      }
+    }
+    await this.#writeHarnessCommandCatalog(
+      request,
+      location.record.harnessId,
+      loaded?.cwd ?? location.record.cwd,
+      params.data.threadId
+    );
   }
-  async #writeHarnessCommandCatalog(request, harnessId) {
+  /**
+   * Catalog of a loaded Session, marked live or static. A live catalog is
+   * remembered for its Harness and workspace so later drafts there can show it.
+   */
+  async #inspectLoadedCommands(thread) {
+    if (!thread.session.commands) return null;
+    const catalog = await inspectLiveCommandCatalog(thread.session.commands);
+    if (!catalog) return null;
+    const staticCatalog = this.#externalAdapters.get(thread.harnessId)?.commandCatalog;
+    if (staticCatalog && !isLiveCommandCatalog(catalog, staticCatalog)) return null;
+    const live = { ...catalog, source: "live" };
+    this.#liveCommandCache.remember(thread.harnessId, thread.cwd, live);
+    return live;
+  }
+  async #writeHarnessCommandCatalog(request, harnessId, cwd, inspectedThreadId) {
     await this.#waitForPlugins();
     const adapter = this.#externalAdapters.get(harnessId);
     if (!adapter) {
       await this.#writer.json(rpcError(request, -32077, `Harness '${harnessId}' is unavailable`));
       return;
     }
+    let catalog;
     try {
-      const catalog = harnessCommandCatalogSchema.parse(adapter.commandCatalog ?? { commands: [] });
-      await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(catalog) }));
+      catalog = harnessCommandCatalogSchema.parse({
+        ...adapter.commandCatalog ?? { commands: [] },
+        ...adapter.liveCommandCatalog ? { source: "static" } : {}
+      });
     } catch {
       await this.#writer.json(rpcError(request, -32078, "Harness command catalog is invalid"));
+      return;
     }
+    if (cwd && adapter.liveCommandCatalog) {
+      for (const thread of this.#externalRuntime.values()) {
+        if (thread.id === inspectedThreadId) continue;
+        if (thread.harnessId !== harnessId || !sameWorkspace(thread.cwd, cwd)) continue;
+        const live = await this.#inspectLoadedCommands(thread);
+        if (live) {
+          catalog = live;
+          break;
+        }
+      }
+      if (catalog.source === "static") {
+        catalog = this.#liveCommandCache.lookup(harnessId, cwd) ?? catalog;
+      }
+    }
+    await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(catalog) }));
   }
   async #executeThreadCommand(request) {
     const params = threadCommandExecuteParamsSchema.safeParse(request.params);
@@ -31715,39 +32411,43 @@ var AppServerHost = class {
         return;
       }
       try {
-        await this.#startExternalCommand(
-          request,
+        const started = await this.#beginExternalCommand(
           thread,
           params.commandId,
           params.arguments,
-          params.turnId,
-          "command"
+          params.turnId
         );
+        try {
+          const result = threadCommandExecuteResultSchema.parse({
+            accepted: true,
+            turnId: started.turnId
+          });
+          await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(result) }));
+        } finally {
+          started.gate.resolve();
+        }
       } catch (error51) {
         this.#diagnose(error51);
         await this.#writer.json(
-          rpcError(request, -32073, `External Harness command failed: ${errorMessage3(error51)}`)
+          error51 instanceof ExternalCommandError ? rpcError(request, error51.code, error51.message) : rpcError(request, -32073, `External Harness command failed: ${errorMessage3(error51)}`)
         );
       }
     } finally {
       this.#pendingExternalCommandRequests.delete(thread.id);
     }
   }
-  async #startExternalCommand(request, thread, commandId, arguments_2, requestedTurnId, responseKind) {
+  async #beginExternalCommand(thread, commandId, arguments_2, requestedTurnId) {
     const commands = thread.session.commands;
     if (!commands) {
-      await this.#writer.json(
-        rpcError(request, -32078, "External Harness does not expose commands")
-      );
-      return;
+      throw new ExternalCommandError(-32078, "External Harness does not expose commands");
     }
-    if (thread.running || this.#externalSteering.hasPending(thread.id)) {
-      await this.#writer.json(
-        rpcError(request, -32072, "External Thread already has an active operation")
-      );
-      return;
+    if (this.#closeRequested || this.#externalRuntime.get(thread.id) !== thread) {
+      throw new ExternalCommandError(-32073, "External Thread is no longer available");
+    }
+    if (thread.running || thread.activeTurnId) {
+      throw new ExternalCommandError(-32072, "External Thread already has an active operation");
     }
-    const turnId = requestedTurnId ?? hostTurnIdSchema.parse(randomUUID9());
+    const turnId = requestedTurnId ?? hostTurnIdSchema.parse(randomUUID10());
     const projection = {
       projector: new CodexTurnProjector({
         threadId: thread.id,
@@ -31762,13 +32462,14 @@ var AppServerHost = class {
     thread.projectedTurns.set(turnId, projection);
     thread.responseGates.set(turnId, gate);
     thread.ephemeralTurnIds.add(turnId);
-    let result;
     try {
-      result = await commands.execute({
+      const result = await commands.execute({
         turnId,
         commandId,
         ...arguments_2 ? { arguments: arguments_2 } : {}
       });
+      if (!result.ok) throw new ExternalCommandError(-32073, result.error.message);
+      return { turnId: result.value.turnId, turn: projection.projector.pendingTurn(), gate };
     } catch (error51) {
       thread.running = false;
       thread.activeTurnId = null;
@@ -31779,28 +32480,6 @@ var AppServerHost = class {
       this.#signalActiveWorkChanged();
       throw error51;
     }
-    if (!result.ok) {
-      thread.running = false;
-      thread.activeTurnId = null;
-      thread.projectedTurns.delete(turnId);
-      thread.responseGates.delete(turnId);
-      thread.ephemeralTurnIds.delete(turnId);
-      gate.resolve();
-      this.#signalActiveWorkChanged();
-      await this.#writer.json(rpcError(request, -32073, result.error.message));
-      return;
-    }
-    try {
-      const response = responseKind === "command" ? jsonValueSchema.parse(
-        threadCommandExecuteResultSchema.parse({
-          accepted: true,
-          turnId: result.value.turnId
-        })
-      ) : { turn: projection.projector.pendingTurn() };
-      await this.#writer.json(rpcEnvelope(request, { result: response }));
-    } finally {
-      gate.resolve();
-    }
   }
   async #selectThreadModel(request) {
     const params = threadModelSelectParamsSchema.safeParse(request.params);
@@ -32423,10 +33102,10 @@ var AppServerHost = class {
       ...typeof params.serviceTier === "string" ? { serviceTier: params.serviceTier } : {}
     });
     try {
-      if (params.initialTurnsPage !== void 0 && params.initialTurnsPage !== null && !isRecord13(params.initialTurnsPage)) {
+      if (params.initialTurnsPage !== void 0 && params.initialTurnsPage !== null && !isRecord14(params.initialTurnsPage)) {
         throw new ExternalHistoryRequestError("initialTurnsPage must be an object");
       }
-      const initialPageParams = isRecord13(params.initialTurnsPage) ? params.initialTurnsPage : null;
+      const initialPageParams = isRecord14(params.initialTurnsPage) ? params.initialTurnsPage : null;
       const initialTurnsPage = initialPageParams ? listExternalTurns(turns, initialPageParams) : null;
       const paginated = thread.record.historyMode === "paginated";
       const turnsBackwardsCursor = paginated ? listExternalTurns(turns, { limit: 1, itemsView: "notLoaded" }).backwardsCursor : null;
@@ -32521,53 +33200,8 @@ var AppServerHost = class {
       await this.#writer.json(rpcError(request, -32602, errorMessage3(error51)));
       return;
     }
-    const commandCandidate = text.trimStart();
-    if (thread.session.commands && /^\/[^\s/]+(?:\s|$)/u.test(commandCandidate)) {
-      const commandText = commandCandidate.trimEnd();
-      this.#pendingExternalCommandRequests.add(thread.id);
-      try {
-        const catalog = await thread.session.commands.list();
-        if (!catalog.ok) {
-          await this.#writer.json(rpcError(request, -32073, catalog.error.message));
-          return;
-        }
-        const matched = catalog.value.commands.toSorted((left, right) => right.invocation.length - left.invocation.length).find((command) => {
-          if (commandText === command.invocation) return true;
-          return command.argumentMode === "text" && commandText.startsWith(`${command.invocation} `);
-        });
-        if (matched) {
-          const argumentText = commandText.slice(matched.invocation.length).trimStart();
-          try {
-            await this.#startExternalCommand(
-              request,
-              thread,
-              matched.id,
-              argumentText.length > 0 ? { text: argumentText } : void 0,
-              void 0,
-              "turn"
-            );
-          } catch (error51) {
-            this.#diagnose(error51);
-            await this.#writer.json(
-              rpcError(request, -32073, `External Harness command failed: ${errorMessage3(error51)}`)
-            );
-          }
-          return;
-        }
-        await this.#writer.json(
-          rpcError(request, -32078, "External Harness does not expose the requested command")
-        );
-        return;
-      } finally {
-        this.#pendingExternalCommandRequests.delete(thread.id);
-      }
-    }
-    if (this.#externalSteering.hasPending(thread.id)) {
-      await this.#writer.json(rpcError(request, -32072, "External Thread is changing direction"));
-      return;
-    }
     try {
-      const started = await this.#beginExternalTurn(thread, text);
+      const started = await this.#beginExternalInputTurn(thread, text);
       try {
         await this.#writer.json(rpcEnvelope(request, { result: { turn: started.turn } }));
       } finally {
@@ -32577,7 +33211,7 @@ var AppServerHost = class {
       await this.#writer.json(
         rpcError(
           request,
-          error51 instanceof ExternalSteerError ? error51.code : -32073,
+          error51 instanceof ExternalSteerError || error51 instanceof ExternalCommandError ? error51.code : -32073,
           errorMessage3(error51)
         )
       );
@@ -32588,7 +33222,7 @@ var AppServerHost = class {
       const started = await this.#externalSteering.run(
         thread,
         requestObject(request),
-        (text) => this.#beginExternalTurn(thread, text)
+        (text, assertActive) => this.#beginExternalInputTurn(thread, text, assertActive)
       );
       try {
         await this.#writer.json(rpcEnvelope(request, { result: { turnId: started.turnId } }));
@@ -32599,7 +33233,7 @@ var AppServerHost = class {
       await this.#writer.json(
         rpcError(
           request,
-          error51 instanceof ExternalSteerError ? error51.code : -32074,
+          error51 instanceof ExternalSteerError || error51 instanceof ExternalCommandError ? error51.code : -32074,
           errorMessage3(error51)
         )
       );
@@ -32607,6 +33241,37 @@ var AppServerHost = class {
       this.#signalActiveWorkChanged();
     }
   }
+  /** Keep command restoration and dispatch identical for start and steer submissions. */
+  async #beginExternalInputTurn(thread, inputText, assertActive) {
+    const text = restoreHarnessCommandMentions(inputText);
+    const commands = thread.session.commands;
+    if (!commands || !isExternalCommandCandidate(text)) {
+      assertActive?.();
+      return this.#beginExternalTurn(thread, text);
+    }
+    this.#pendingExternalCommandRequests.add(thread.id);
+    try {
+      const adapter = this.#externalAdapters.get(thread.harnessId);
+      const command = await resolveExternalCommand(commands, text, {
+        liveCatalogPending: (catalog) => adapter?.liveCommandCatalog === true && !isLiveCommandCatalog(catalog, adapter.commandCatalog ?? { commands: [] })
+      });
+      assertActive?.();
+      if (!command) {
+        this.#pendingExternalCommandRequests.delete(thread.id);
+        return await this.#beginExternalTurn(thread, text);
+      }
+      return await this.#beginExternalCommand(thread, command.commandId, command.arguments);
+    } catch (error51) {
+      if (error51 instanceof ExternalCommandError || error51 instanceof ExternalSteerError) throw error51;
+      this.#diagnose(error51);
+      throw new ExternalCommandError(
+        -32073,
+        `External Harness command failed: ${errorMessage3(error51)}`
+      );
+    } finally {
+      this.#pendingExternalCommandRequests.delete(thread.id);
+    }
+  }
   async #beginExternalTurn(thread, text) {
     if (this.#closeRequested || this.#externalRuntime.get(thread.id) !== thread) {
       throw new ExternalSteerError(-32073, "External Thread is no longer available");
@@ -32614,7 +33279,7 @@ var AppServerHost = class {
     if (thread.running || thread.activeTurnId || this.#pendingExternalCommandRequests.has(thread.id)) {
       throw new ExternalSteerError(-32072, "External Thread already has an active Turn");
     }
-    const turnId = hostTurnIdSchema.parse(randomUUID9());
+    const turnId = hostTurnIdSchema.parse(randomUUID10());
     const startedAtMs = Date.now();
     const projection = {
       projector: new CodexTurnProjector({
@@ -32633,7 +33298,7 @@ var AppServerHost = class {
       const result = await thread.session.execute({
         type: "turn.start",
         turnId,
-        input: [{ type: "text", text }]
+        input: [{ type: "text", text: rewriteDelegationMentionText(text) }]
       });
       if (!result.ok) throw new ExternalSteerError(-32073, result.error.message);
       return { turnId, turn: projection.projector.pendingTurn(), gate };
@@ -32935,7 +33600,7 @@ var AppServerHost = class {
     const previousItems = new Map(
       child.turns.flatMap(
         (turn) => Array.isArray(turn.items) ? turn.items.flatMap(
-          (item) => isRecord13(item) && typeof item.id === "string" ? [[item.id, JSON.stringify(item)]] : []
+          (item) => isRecord14(item) && typeof item.id === "string" ? [[item.id, JSON.stringify(item)]] : []
         ) : []
       )
     );
@@ -32948,7 +33613,7 @@ var AppServerHost = class {
     for (const turn of child.turns) {
       if (typeof turn.id !== "string" || !Array.isArray(turn.items)) continue;
       const changedItems = turn.items.filter(
-        (item) => isRecord13(item) && typeof item.id === "string" && previousItems.get(item.id) !== JSON.stringify(item)
+        (item) => isRecord14(item) && typeof item.id === "string" && previousItems.get(item.id) !== JSON.stringify(item)
       );
       if (changedItems.length > 0) {
         await this.#writer.json({
@@ -33080,7 +33745,7 @@ var AppServerHost = class {
     }
   }
   async #handleDesktopApprovalResponse(value2) {
-    if (!isRecord13(value2) || !isHostApprovalRequestId(value2.id)) return false;
+    if (!isRecord14(value2) || !isHostApprovalRequestId(value2.id)) return false;
     const requestId = value2.id;
     const pending = this.#pendingDesktopApprovals.get(requestId);
     if (!pending) return true;
@@ -33162,7 +33827,7 @@ var AppServerHost = class {
     try {
       result = projection.projector.projectQuestion(
         interaction,
-        hostItemIdSchema.parse(randomUUID9())
+        hostItemIdSchema.parse(randomUUID10())
       );
     } catch (error51) {
       this.#diagnose(error51);
@@ -33207,7 +33872,7 @@ var AppServerHost = class {
     }
   }
   async #handleDesktopQuestionResponse(value2) {
-    if (!isRecord13(value2) || !isHostQuestionRequestId(value2.id)) return false;
+    if (!isRecord14(value2) || !isHostQuestionRequestId(value2.id)) return false;
     const requestId = value2.id;
     const pending = this.#pendingDesktopQuestions.get(requestId);
     if (!pending) return true;
@@ -33328,19 +33993,19 @@ var AppServerHost = class {
 };
 
 // packages/host-runtime/src/native-account-host.ts
-import { mkdir as mkdir7, realpath as realpath3 } from "node:fs/promises";
+import { mkdir as mkdir8, realpath as realpath3 } from "node:fs/promises";
 import { homedir } from "node:os";
-import path16 from "node:path";
+import path19 from "node:path";
 
 // packages/host-runtime/src/codex-runtime/owned-official-backends.ts
-import { createHash as createHash7, randomBytes } from "node:crypto";
+import { createHash as createHash9, randomBytes } from "node:crypto";
 import { Writable as Writable2 } from "node:stream";
 
 // packages/host-runtime/src/remote-app-server.ts
 import { createServer } from "node:http";
 import net from "node:net";
-import { chmod as chmod3, lstat as lstat6, mkdir as mkdir6, rm as rm6 } from "node:fs/promises";
-import path14 from "node:path";
+import { chmod as chmod3, lstat as lstat6, mkdir as mkdir7, rm as rm7 } from "node:fs/promises";
+import path17 from "node:path";
 import { PassThrough } from "node:stream";
 
 // node_modules/ws/wrapper.mjs
@@ -33355,10 +34020,10 @@ var import_websocket_server = __toESM(require_websocket_server(), 1);
 var wrapper_default = import_websocket.default;
 
 // packages/host-runtime/src/remote-socket-lock.ts
-import { randomUUID as randomUUID10 } from "node:crypto";
-import { chmod as chmod2, lstat as lstat5, mkdir as mkdir5, open as open5, readFile as readFile6, readdir as readdir4, rename as rename4, rm as rm5 } from "node:fs/promises";
+import { randomUUID as randomUUID11 } from "node:crypto";
+import { chmod as chmod2, lstat as lstat5, mkdir as mkdir6, open as open6, readFile as readFile8, readdir as readdir4, rename as rename5, rm as rm6 } from "node:fs/promises";
 import { uptime } from "node:os";
-import path13 from "node:path";
+import path16 from "node:path";
 import { setTimeout as delay4 } from "node:timers/promises";
 var LOCK_RETRY_COUNT = 200;
 var LOCK_RETRY_DELAY_MS = 25;
@@ -33421,7 +34086,7 @@ async function readLockEntrySnapshot(filePath) {
     throw error51;
   });
   if (metadata === null || !metadata.isFile()) return null;
-  const source = await readFile6(filePath, "utf8").catch((error51) => {
+  const source = await readFile8(filePath, "utf8").catch((error51) => {
     if (error51.code === "ENOENT") return null;
     throw error51;
   });
@@ -33432,7 +34097,7 @@ async function readLockEntrySnapshot(filePath) {
     source,
     identity: { dev: metadata.dev, ino: metadata.ino },
     mtimeMs: metadata.mtimeMs,
-    record: record3 && path13.basename(filePath) === lockEntryName(record3.ownerToken) ? record3 : null
+    record: record3 && path16.basename(filePath) === lockEntryName(record3.ownerToken) ? record3 : null
   };
 }
 function lockEntryIsAbandoned(snapshot) {
@@ -33444,7 +34109,7 @@ async function removeAbandonedLockEntry(snapshot) {
   if (current === null || current.source !== snapshot.source || !sameUnixFileIdentity(current.identity, snapshot.identity) || !lockEntryIsAbandoned(current)) {
     return false;
   }
-  await rm5(snapshot.filePath, { force: true });
+  await rm6(snapshot.filePath, { force: true });
   return true;
 }
 async function readLockEntryCatalog(lockDirectory) {
@@ -33453,7 +34118,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(path13.join(lockDirectory, name));
+    const snapshot = await readLockEntrySnapshot(path16.join(lockDirectory, name));
     if (snapshot === null) continue;
     if (lockEntryIsAbandoned(snapshot)) {
       if (!await removeAbandonedLockEntry(snapshot)) unsettled = true;
@@ -33468,7 +34133,7 @@ async function readLockEntryCatalog(lockDirectory) {
   return { entries, unsettled };
 }
 async function preparePrivateLockDirectory(lockDirectory) {
-  await mkdir5(lockDirectory, { mode: 448 }).catch((error51) => {
+  await mkdir6(lockDirectory, { mode: 448 }).catch((error51) => {
     if (error51.code !== "EEXIST") throw error51;
   });
   const metadata = await lstat5(lockDirectory);
@@ -33481,8 +34146,8 @@ async function preparePrivateLockDirectory(lockDirectory) {
   await chmod2(lockDirectory, 448);
 }
 async function writeLockRecordAtomic(lockDirectory, entryPath, record3) {
-  const temporary = path13.join(lockDirectory, `.tmp-${record3.ownerToken}-${randomUUID10()}`);
-  const handle = await open5(temporary, "wx", 384);
+  const temporary = path16.join(lockDirectory, `.tmp-${record3.ownerToken}-${randomUUID11()}`);
+  const handle = await open6(temporary, "wx", 384);
   try {
     await handle.writeFile(`${JSON.stringify(record3)}
 `, "utf8");
@@ -33491,15 +34156,15 @@ async function writeLockRecordAtomic(lockDirectory, entryPath, record3) {
     await handle.close();
   }
   try {
-    await rename4(temporary, entryPath);
+    await rename5(temporary, entryPath);
   } finally {
-    await rm5(temporary, { force: true });
+    await rm6(temporary, { force: true });
   }
 }
 async function removeOwnedLockEntry(entryPath, ownerToken) {
   const snapshot = await readLockEntrySnapshot(entryPath);
   if (snapshot?.record?.ownerToken !== ownerToken) return;
-  await rm5(entryPath, { force: true });
+  await rm6(entryPath, { force: true });
 }
 async function legacyLockState(legacyPath) {
   const metadata = await lstat5(legacyPath).catch((error51) => {
@@ -33508,7 +34173,7 @@ async function legacyLockState(legacyPath) {
   });
   if (metadata === null) return "absent";
   if (!metadata.isFile()) return "blocking";
-  const source = await readFile6(legacyPath, "utf8").catch((error51) => {
+  const source = await readFile8(legacyPath, "utf8").catch((error51) => {
     if (error51.code === "ENOENT") return null;
     throw error51;
   });
@@ -33519,7 +34184,7 @@ async function legacyLockState(legacyPath) {
   return ownerIsAbandoned(record3, metadata.mtimeMs) ? "abandoned" : "blocking";
 }
 async function tryAcquireLegacyCompatibilityGuard(legacyPath, record3) {
-  const handle = await open5(legacyPath, "wx", 384).catch((error51) => {
+  const handle = await open6(legacyPath, "wx", 384).catch((error51) => {
     if (error51.code === "EEXIST") return null;
     throw error51;
   });
@@ -33545,7 +34210,7 @@ async function releaseLegacyCompatibilityGuard(legacyPath, guard) {
       throw error51;
     });
     if (metadata?.isFile() && sameUnixFileIdentity({ dev: metadata.dev, ino: metadata.ino }, guard.identity)) {
-      await rm5(legacyPath, { force: true });
+      await rm6(legacyPath, { force: true });
     }
   }
 }
@@ -33556,8 +34221,8 @@ async function withRemoteAppServerSocketInitializationLock(socketPath, action) {
   const legacyPath = `${socketPath}.initializing`;
   const lockDirectory = `${socketPath}.initializers`;
   await preparePrivateLockDirectory(lockDirectory);
-  const ownerToken = randomUUID10();
-  const entryPath = path13.join(lockDirectory, lockEntryName(ownerToken));
+  const ownerToken = randomUUID11();
+  const entryPath = path16.join(lockDirectory, lockEntryName(ownerToken));
   const baseRecord = {
     version: 2,
     ownerToken,
@@ -33731,14 +34396,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 path14.posix.resolve(decodeURIComponent(explicit));
-  const codexHome = environment.CODEX_HOME ?? (environment.HOME ? path14.posix.join(environment.HOME, ".codex") : void 0);
+  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 (!codexHome)
     throw new Error("CODEX_HOME or HOME is required for the remote app-server socket");
-  return path14.posix.join(codexHome, "app-server-control", "app-server-control.sock");
+  return path17.posix.join(codexHome, "app-server-control", "app-server-control.sock");
 }
 function officialListenerArgumentsForRemoteListener(arguments_2, socketPath) {
-  if (!path14.posix.isAbsolute(socketPath)) {
+  if (!path17.posix.isAbsolute(socketPath)) {
     throw new Error("Shared official app-server socket path must be absolute");
   }
   if (remoteUnixListenerUrl(arguments_2) === null) {
@@ -33846,10 +34511,10 @@ async function removeStaleSocket(socketPath) {
     });
   });
   if (active) throw new Error(`Remote app-server socket is already in use at ${socketPath}`);
-  await rm6(socketPath, { force: true });
+  await rm7(socketPath, { force: true });
 }
 async function prepareRemoteAppServerSocketDirectory(socketPath) {
-  const socketDirectory = path14.dirname(socketPath);
+  const socketDirectory = path17.dirname(socketPath);
   const existing = await lstat6(socketDirectory).catch((error51) => {
     if (error51.code === "ENOENT") return null;
     throw error51;
@@ -33863,7 +34528,7 @@ async function prepareRemoteAppServerSocketDirectory(socketPath) {
       );
     }
   }
-  await mkdir6(socketDirectory, { recursive: true, mode: 448 });
+  await mkdir7(socketDirectory, { recursive: true, mode: 448 });
   await chmod3(socketDirectory, 448);
 }
 function sendOutputFrames(socket, output) {
@@ -34036,7 +34701,7 @@ function createRemoteAppServerWebSocketListener(input) {
             if (ownedSocketIdentity) {
               const current = await unixSocketIdentity(input.socketPath);
               if (current && sameUnixFileIdentity2(current, ownedSocketIdentity)) {
-                await rm6(input.socketPath, { force: true });
+                await rm7(input.socketPath, { force: true });
               }
               ownedSocketIdentity = null;
             }
@@ -34054,20 +34719,20 @@ function createRemoteAppServerWebSocketListener(input) {
 
 // packages/host-runtime/src/remote-official-app-server.ts
 import { spawn as spawn3 } from "node:child_process";
-import { randomUUID as randomUUID11 } from "node:crypto";
-import { lstat as lstat7, rm as rm7 } from "node:fs/promises";
-import path15 from "node:path";
+import { randomUUID as randomUUID12 } from "node:crypto";
+import { lstat as lstat7, rm as rm8 } from "node:fs/promises";
+import path18 from "node:path";
 var DEFAULT_CLOSE_TIMEOUT_MS = 2e3;
 var DEFAULT_LISTEN_TIMEOUT_MS = 1e4;
-function remoteOfficialAppServerSocketPath(desktopControlSocketPath, token = randomUUID11()) {
-  if (!path15.posix.isAbsolute(desktopControlSocketPath)) {
+function remoteOfficialAppServerSocketPath(desktopControlSocketPath, token = randomUUID12()) {
+  if (!path18.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 path15.posix.join(path15.posix.dirname(desktopControlSocketPath), `.c-${compactToken}.sock`);
+  return path18.posix.join(path18.posix.dirname(desktopControlSocketPath), `.c-${compactToken}.sock`);
 }
 function errorMessage4(error51) {
   return error51 instanceof Error ? error51.message : String(error51);
@@ -34139,7 +34804,7 @@ function createRemoteOfficialAppServerListener(input) {
     if (ownedSocketIdentity === null) return;
     const current = await socketIdentity(input.socketPath).catch(() => null);
     if (current && sameUnixFileIdentity3(current, ownedSocketIdentity)) {
-      await rm7(input.socketPath, { force: true });
+      await rm8(input.socketPath, { force: true });
     }
     ownedSocketIdentity = null;
   };
@@ -34500,7 +35165,7 @@ function createOwnedLoopbackBackend(input) {
       "--ws-auth",
       "capability-token",
       "--ws-token-sha256",
-      createHash7("sha256").update(capabilityToken).digest("hex")
+      createHash9("sha256").update(capabilityToken).digest("hex")
     ],
     // Managed stderr may carry credential-bearing errors. Never forward raw bytes.
     diagnosticOutput: new Writable2({
@@ -34553,21 +35218,21 @@ function createOwnedUnixBackend(input) {
 
 // packages/host-runtime/src/native-account-host.ts
 async function canonicalCodexHome(home) {
-  const absolute = path16.resolve(home);
+  const absolute = path19.resolve(home);
   try {
     return await realpath3(absolute);
   } catch (error51) {
     if (!(error51 instanceof Error && "code" in error51 && error51.code === "ENOENT")) throw error51;
-    const parent = path16.dirname(absolute);
+    const parent = path19.dirname(absolute);
     if (parent === absolute) throw error51;
-    return path16.join(await canonicalCodexHome(parent), path16.basename(absolute));
+    return path19.join(await canonicalCodexHome(parent), path19.basename(absolute));
   }
 }
 async function prepareLocalCodex(input) {
   const home = await canonicalCodexHome(
-    input.environment.CODEX_HOME ?? path16.join(homedir(), ".codex")
+    input.environment.CODEX_HOME ?? path19.join(homedir(), ".codex")
   );
-  await mkdir7(home, { recursive: true });
+  await mkdir8(home, { recursive: true });
   const scope = new OfficialRuntimeScope({
     permanentHome: home,
     diagnosticOutput: input.diagnosticOutput,
@@ -34731,18 +35396,18 @@ var DelegationControlRegistry = class {
 };
 
 // packages/host-runtime/src/installed-harness-plugins.ts
-import os4 from "node:os";
-import path18 from "node:path";
+import os6 from "node:os";
+import path21 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // packages/host-runtime/src/launcher-url-opener.ts
 import { spawn as spawn4 } from "node:child_process";
-import path17 from "node:path";
+import path20 from "node:path";
 var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]"]);
 var OPEN_TIMEOUT_MS = 1e4;
 function createLauncherUrlOpener(environment, spawnLauncher = (command, arguments_2, options2) => spawn4(command, arguments_2, options2)) {
   const launcher = environment.CODEXHOST_LAUNCHER_EXECUTABLE;
-  if (!launcher || !path17.isAbsolute(launcher)) return void 0;
+  if (!launcher || !path20.isAbsolute(launcher)) return void 0;
   const launcherEnvironment = Object.fromEntries(
     Object.entries(environment).filter(([name]) => {
       const normalized = name.toUpperCase();
@@ -34800,9 +35465,9 @@ function installedHarnessPluginOptions(environment, managedRemoteHost = false, h
   const opener = managedRemoteHost ? void 0 : createLauncherUrlOpener(environment);
   return {
     pluginRoots: [
-      path18.join(path18.dirname(fileURLToPath(hostRuntimeUrl)), "plugins"),
-      environment[HARNESS_PLUGIN_DIRECTORY_ENV] ?? path18.join(
-        environment.CODEXHOST_DATA_DIR ? path18.resolve(environment.CODEXHOST_DATA_DIR) : path18.join(os4.homedir(), ".codexhost"),
+      path21.join(path21.dirname(fileURLToPath(hostRuntimeUrl)), "plugins"),
+      environment[HARNESS_PLUGIN_DIRECTORY_ENV] ?? path21.join(
+        environment.CODEXHOST_DATA_DIR ? path21.resolve(environment.CODEXHOST_DATA_DIR) : path21.join(os6.homedir(), ".codexhost"),
         "plugins"
       )
     ],
@@ -34926,171 +35591,10 @@ async function startDelegationControlServer(input) {
   };
 }
 
-// packages/host-runtime/src/delegation-skill.ts
-import { createHash as createHash8, randomUUID as randomUUID12 } from "node:crypto";
-import { mkdir as mkdir8, open as open6, readFile as readFile7, rename as rename5, rm as rm8, stat as stat4 } from "node:fs/promises";
-import os5 from "node:os";
-import path19 from "node:path";
-var SKILL_VERSION = 7;
-var SKILL_RELATIVE_PATH = path19.join("skills", "codexhost-delegation", "SKILL.md");
-var PREVIOUS_MANAGED_DIGESTS = [
-  "9d2f491850fb0b4084a31ba9b5e4a550b5e833747af322090d8ed0ff80b88c30",
-  "2bb0aebb9b06febbc6c0c0bcdb0b32506c7cdbf8dc3b734cc6b2a86621270e4e",
-  "aff258622dc8ff321f32b15620d081e578cb9c9ed1134d6a57f35ca8e7762c0a",
-  "ba509f57e5448e796b3dfdd5031dcb08672eded50b61c0a54de84cfa02c49dd3",
-  "d3ddf6db9bc5c5df825479c885bbbf0ca08da66f7057a12e02e1fdf57525149e",
-  "15eb63519ff867e1536c97188a0c43738d7a49d38d4d6adeb7a1036726e7246d"
-];
-var CODEXHOST_DELEGATION_SKILL = `---
-name: codexhost-delegation
-version: ${SKILL_VERSION}
-description: >
-  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
-
-Before acting, run:
-
-\`codexhost delegate --help\`
-
-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.
-
-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
-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.
-
-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;
-- cancel its current Turn;
-- read its current state immediately;
-- wait for a bounded period;
-- check it again later;
-- leave it running in the background.
-
-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 = createHash8("sha256").update(CODEXHOST_DELEGATION_SKILL).digest("hex");
-function digest(value2) {
-  return createHash8("sha256").update(value2).digest("hex");
-}
-function managedVersion(value2) {
-  const match = /^version:\s*(\d+)\s*$/mu.exec(value2);
-  return match ? Number(match[1]) : null;
-}
-async function readOptional(filePath) {
-  try {
-    return await readFile7(filePath, "utf8");
-  } catch (error51) {
-    if (error51.code === "ENOENT") return null;
-    throw error51;
-  }
-}
-async function atomicWrite(filePath, content) {
-  await mkdir8(path19.dirname(filePath), { recursive: true, mode: 448 });
-  const temporaryPath = path19.join(path19.dirname(filePath), `.SKILL.md.${randomUUID12()}.tmp`);
-  const handle = await open6(temporaryPath, "wx", 384);
-  try {
-    await handle.writeFile(content, "utf8");
-    await handle.sync();
-  } finally {
-    await handle.close();
-  }
-  try {
-    await rename5(temporaryPath, filePath);
-  } finally {
-    await rm8(temporaryPath, { force: true });
-  }
-}
-async function installDelegationSkills(input = {}) {
-  const home = input.homeDirectory ?? os5.homedir();
-  const destinations = [
-    path19.join(home, ".agents", SKILL_RELATIVE_PATH),
-    path19.join(home, ".claude", SKILL_RELATIVE_PATH)
-  ];
-  const knownDigests = /* @__PURE__ */ new Set([
-    CURRENT_DIGEST,
-    ...PREVIOUS_MANAGED_DIGESTS,
-    ...input.previousManagedDigests ?? []
-  ]);
-  const results = [];
-  for (const destination of destinations) {
-    const current = await readOptional(destination);
-    if (current === CODEXHOST_DELEGATION_SKILL) {
-      results.push({
-        path: destination,
-        status: "current",
-        version: SKILL_VERSION,
-        digest: CURRENT_DIGEST
-      });
-      continue;
-    }
-    if (current !== null) {
-      const currentDigest = digest(current);
-      const version2 = managedVersion(current);
-      if (!knownDigests.has(currentDigest)) {
-        results.push({ path: destination, status: "conflict", version: version2, digest: currentDigest });
-        continue;
-      }
-      await atomicWrite(destination, CODEXHOST_DELEGATION_SKILL);
-      results.push({
-        path: destination,
-        status: "updated",
-        version: SKILL_VERSION,
-        digest: CURRENT_DIGEST
-      });
-      continue;
-    }
-    await atomicWrite(destination, CODEXHOST_DELEGATION_SKILL);
-    results.push({
-      path: destination,
-      status: "installed",
-      version: SKILL_VERSION,
-      digest: CURRENT_DIGEST
-    });
-  }
-  for (const result of results) {
-    if (result.status === "conflict") continue;
-    const source = await readFile7(result.path, "utf8");
-    const metadata = await stat4(result.path);
-    if (!metadata.isFile() || source !== CODEXHOST_DELEGATION_SKILL) {
-      throw new Error(`Delegation Skill verification failed: ${result.path}`);
-    }
-  }
-  const managed = results.filter((result) => result.status !== "conflict");
-  if (managed.some((result) => result.digest !== CURRENT_DIGEST)) {
-    throw new Error("Delegation Skill copies are inconsistent");
-  }
-  if (results.every((result) => result.status !== "conflict")) {
-    const copies = await Promise.all(results.map((result) => readFile7(result.path, "utf8")));
-    if (copies.some((copy) => copy !== copies[0])) {
-      throw new Error("Delegation Skill copies are inconsistent");
-    }
-  }
-  return results;
-}
-
 // packages/host-runtime/src/remote-control-app-server.ts
 import { randomUUID as randomUUID13 } from "node:crypto";
 import { mkdir as mkdir9, open as open7, rename as rename6, rm as rm9 } from "node:fs/promises";
-import path20 from "node:path";
+import path22 from "node:path";
 var REMOTE_CONTROL_BRIDGE_PIPE_ENV = "CODEXHOST_REMOTE_CONTROL_BRIDGE_PIPE";
 var REMOTE_CONTROL_BRIDGE_NODE_ENV = "CODEXHOST_REMOTE_CONTROL_BRIDGE_NODE_PATH";
 var REMOTE_CONTROL_BRIDGE_RUNTIME_ENV = "CODEXHOST_REMOTE_CONTROL_BRIDGE_RUNTIME_PATH";
@@ -35101,8 +35605,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 (path20.isAbsolute(value2)) return path20.normalize(value2);
-  return platform === "win32" && path20.win32.isAbsolute(value2) ? path20.win32.normalize(value2) : null;
+  if (path22.isAbsolute(value2)) return path22.normalize(value2);
+  return platform === "win32" && path22.win32.isAbsolute(value2) ? path22.win32.normalize(value2) : null;
 }
 function nodeCompatibleWindowsPath(value2) {
   if (value2.startsWith("\\\\?\\UNC\\")) return `\\\\${value2.slice(8)}`;
@@ -35116,13 +35620,13 @@ function remoteControlBridgePipePath(processId = process.pid, instanceId = rando
 }
 function remoteControlBridgeDescriptorPath(environment) {
   const root = environment.LOCALAPPDATA;
-  if (!root || !path20.isAbsolute(root)) return null;
-  return path20.join(path20.normalize(root), "codexhost", REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE);
+  if (!root || !path22.isAbsolute(root)) return null;
+  return path22.join(path22.normalize(root), "codexhost", REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE);
 }
 async function publishRemoteControlAppServerDescriptor(plan) {
-  const directory = path20.dirname(plan.descriptorPath);
+  const directory = path22.dirname(plan.descriptorPath);
   await mkdir9(directory, { recursive: true, mode: 448 });
-  const temporaryPath = path20.join(
+  const temporaryPath = path22.join(
     directory,
     `.${REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE}.${plan.descriptor.ownerPid}.${randomUUID13()}.tmp`
   );
@@ -35423,9 +35927,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 (!path21.isAbsolute(npmPackageRoot) || !path21.isAbsolute(hostRuntimePath)) return false;
-  const runtimePackageRoot = path21.dirname(path21.dirname(path21.normalize(hostRuntimePath)));
-  return path21.relative(path21.normalize(npmPackageRoot), runtimePackageRoot) === "";
+  if (!path23.isAbsolute(npmPackageRoot) || !path23.isAbsolute(hostRuntimePath)) return false;
+  const runtimePackageRoot = path23.dirname(path23.dirname(path23.normalize(hostRuntimePath)));
+  return path23.relative(path23.normalize(npmPackageRoot), runtimePackageRoot) === "";
 }
 function requiredRuntimeConfiguration(environment) {
   const stockCodexPath = environment[STOCK_CODEX_PATH_ENV];
@@ -35571,8 +36075,8 @@ async function runHostRuntime(input) {
       const socketPath = remoteAppServerSocketPath(delegationEnvironment, listenUrl);
       const officialPlan = createRemoteOfficialAppServerPlan(input.arguments, socketPath);
       const officialRuntimeScope = new OfficialRuntimeScope({
-        permanentHome: path21.resolve(
-          delegationEnvironment.CODEX_HOME ?? path21.join(homedir2(), ".codex")
+        permanentHome: path23.resolve(
+          delegationEnvironment.CODEX_HOME ?? path23.join(homedir2(), ".codex")
         ),
         diagnosticOutput: process.stderr,
         createBackend: () => createOwnedUnixBackend({
@@ -35653,7 +36157,7 @@ async function runHostRuntime(input) {
 }
 
 // packages/host-runtime/src/remote-host-install.ts
-import { createHash as createHash9, randomUUID as randomUUID14 } from "node:crypto";
+import { createHash as createHash10, randomUUID as randomUUID14 } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
 import {
   access,
@@ -35661,14 +36165,14 @@ import {
   copyFile as copyFile3,
   lstat as lstat8,
   mkdir as mkdir10,
-  readFile as readFile8,
+  readFile as readFile9,
   rename as rename7,
   rm as rm10,
   rmdir,
   stat as stat5,
   writeFile as writeFile4
 } from "node:fs/promises";
-import path22 from "node:path";
+import path24 from "node:path";
 var MANIFEST_FORMAT = 1;
 var WRAPPER_MARKER = "# codexhost remote SSH wrapper v1";
 var PROFILE_START = "# >>> codexhost remote SSH >>>";
@@ -35679,25 +36183,25 @@ function resolvePaths(options2) {
   if (!configuredHome) {
     throw new Error("A non-root HOME is required for remote Host installation");
   }
-  const home = path22.resolve(configuredHome);
-  if (!home || home === path22.parse(home).root) {
+  const home = path24.resolve(configuredHome);
+  if (!home || home === path24.parse(home).root) {
     throw new Error("A non-root HOME is required for remote Host installation");
   }
-  const installRoot = path22.resolve(options2.installRoot ?? path22.join(home, ".codexhost", "remote"));
-  const profilePath = path22.resolve(
-    options2.profilePath ?? path22.join(
+  const installRoot = path24.resolve(options2.installRoot ?? path24.join(home, ".codexhost", "remote"));
+  const profilePath = path24.resolve(
+    options2.profilePath ?? path24.join(
       home,
-      path22.basename(environment.SHELL ?? "") === "zsh" ? ".zshenv" : path22.basename(environment.SHELL ?? "") === "bash" ? ".bashrc" : ".profile"
+      path24.basename(environment.SHELL ?? "") === "zsh" ? ".zshenv" : path24.basename(environment.SHELL ?? "") === "bash" ? ".bashrc" : ".profile"
     )
   );
-  const binDirectory = path22.join(installRoot, "bin");
+  const binDirectory = path24.join(installRoot, "bin");
   return {
     home,
     installRoot,
     binDirectory,
-    wrapperPath: path22.join(binDirectory, "codex"),
-    manifestPath: path22.join(installRoot, "manifest.json"),
-    dataDirectory: path22.join(installRoot, "data"),
+    wrapperPath: path24.join(binDirectory, "codex"),
+    manifestPath: path24.join(installRoot, "manifest.json"),
+    dataDirectory: path24.join(installRoot, "data"),
     profilePath
   };
 }
@@ -35706,17 +36210,17 @@ function shellQuote(value2) {
 }
 async function existingText(filePath) {
   try {
-    return await readFile8(filePath, "utf8");
+    return await readFile9(filePath, "utf8");
   } catch (error51) {
     if (error51.code === "ENOENT") return null;
     throw error51;
   }
 }
 async function fileSha256(filePath) {
-  return createHash9("sha256").update(await readFile8(filePath)).digest("hex");
+  return createHash10("sha256").update(await readFile9(filePath)).digest("hex");
 }
 async function executable(filePath, label) {
-  const absolute = path22.resolve(filePath);
+  const absolute = path24.resolve(filePath);
   try {
     if (!(await stat5(absolute)).isFile()) throw new Error("not a regular file");
     await access(absolute, fsConstants.X_OK);
@@ -35726,7 +36230,7 @@ async function executable(filePath, label) {
   return absolute;
 }
 async function existingFile(filePath, label) {
-  const absolute = path22.resolve(filePath);
+  const absolute = path24.resolve(filePath);
   try {
     const metadata = await stat5(absolute);
     if (!metadata.isFile()) throw new Error("not a regular file");
@@ -35736,9 +36240,9 @@ async function existingFile(filePath, label) {
   return absolute;
 }
 async function discoverExecutable(name, environment) {
-  for (const directory of (environment.PATH ?? "").split(path22.delimiter)) {
+  for (const directory of (environment.PATH ?? "").split(path24.delimiter)) {
     if (!directory) continue;
-    const candidate = path22.resolve(directory, name);
+    const candidate = path24.resolve(directory, name);
     try {
       await access(candidate, fsConstants.X_OK);
       return candidate;
@@ -35749,10 +36253,10 @@ async function discoverExecutable(name, environment) {
   return null;
 }
 async function writeAtomic(filePath, contents, mode) {
-  await mkdir10(path22.dirname(filePath), { recursive: true, mode: 448 });
-  const temporary = path22.join(
-    path22.dirname(filePath),
-    `.${path22.basename(filePath)}.${process.pid}.${randomUUID14()}.tmp`
+  await mkdir10(path24.dirname(filePath), { recursive: true, mode: 448 });
+  const temporary = path24.join(
+    path24.dirname(filePath),
+    `.${path24.basename(filePath)}.${process.pid}.${randomUUID14()}.tmp`
   );
   try {
     if (typeof contents === "string") {
@@ -35773,10 +36277,10 @@ async function writeAtomic(filePath, contents, mode) {
   }
 }
 async function writeAtomicExecutable(filePath, sourcePath) {
-  await mkdir10(path22.dirname(filePath), { recursive: true, mode: 448 });
-  const temporary = path22.join(
-    path22.dirname(filePath),
-    `.${path22.basename(filePath)}.${process.pid}.${randomUUID14()}.tmp`
+  await mkdir10(path24.dirname(filePath), { recursive: true, mode: 448 });
+  const temporary = path24.join(
+    path24.dirname(filePath),
+    `.${path24.basename(filePath)}.${process.pid}.${randomUUID14()}.tmp`
   );
   try {
     await copyFile3(sourcePath, temporary);
@@ -35817,15 +36321,14 @@ function removeManagedProfileBlock(contents) {
 function installManagedProfileBlock(contents, manifest) {
   const base = removeManagedProfileBlock(contents);
   const environment = [
-    `export CODEX_INSTALL_DIR=${shellQuote(path22.dirname(manifest.wrapperPath))}`,
-    `export PATH=${shellQuote(path22.dirname(manifest.wrapperPath))}:${shellQuote(path22.dirname(manifest.nodePath))}:${shellQuote(path22.dirname(manifest.stockCodexPath))}:"\${PATH:-/usr/local/bin:/usr/bin:/bin}"`,
+    `export CODEX_INSTALL_DIR=${shellQuote(path24.dirname(manifest.wrapperPath))}`,
+    `export PATH=${shellQuote(path24.dirname(manifest.wrapperPath))}:${shellQuote(path24.dirname(manifest.nodePath))}:${shellQuote(path24.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)}`,
     `export CODEXHOST_DATA_DIR=${shellQuote(manifest.dataDirectory)}`,
     "export CODEXHOST_DEFAULT_AGENT='codex'",
-    "export CODEXHOST_REMOTE_SSH_MANAGED='1'",
-    ...manifest.claudeCommand ? [`export CODEXHOST_CLAUDE_COMMAND=${shellQuote(manifest.claudeCommand)}`] : []
+    "export CODEXHOST_REMOTE_SSH_MANAGED='1'"
   ];
   const block = [
     PROFILE_START,
@@ -35835,7 +36338,7 @@ function installManagedProfileBlock(contents, manifest) {
     PROFILE_END,
     ""
   ].join("\n");
-  if (path22.basename(manifest.profilePath) === ".bashrc") return `${block}${base}`;
+  if (path24.basename(manifest.profilePath) === ".bashrc") return `${block}${base}`;
   const separator = base.length > 0 && !base.endsWith("\n") ? "\n" : "";
   return `${base}${separator}${block}`;
 }
@@ -35847,16 +36350,16 @@ async function managedEntrypointState(manifest) {
   if (metadata === null) return "missing";
   if (!metadata.isFile()) return "modified";
   if (process.platform !== "win32" && (metadata.mode & 73) === 0) return "modified";
-  const entrypoint = await readFile8(manifest.wrapperPath);
+  const entrypoint = await readFile9(manifest.wrapperPath);
   if (entrypoint.subarray(0, 256).toString("utf8").startsWith(`#!/usr/bin/env sh
 ${WRAPPER_MARKER}
 `)) {
     return "legacy-wrapper";
   }
   if (manifest.entrypointSha256 !== void 0) {
-    return createHash9("sha256").update(entrypoint).digest("hex") === manifest.entrypointSha256 ? "native" : "modified";
+    return createHash10("sha256").update(entrypoint).digest("hex") === manifest.entrypointSha256 ? "native" : "modified";
   }
-  const shim = await readFile8(manifest.shimPath).catch((error51) => {
+  const shim = await readFile9(manifest.shimPath).catch((error51) => {
     if (error51.code === "ENOENT") return null;
     throw error51;
   });
@@ -35887,6 +36390,7 @@ async function readManifest(filePath) {
     "dataDirectory",
     "entrypointSha256",
     "claudeCommand",
+    // Inert metadata accepted from older format-1 manifests.
     "profileBackupPath"
   ]);
   const requiredPaths = [
@@ -35900,9 +36404,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" || !path22.isAbsolute(manifest[key])
+    (key) => typeof manifest[key] !== "string" || !path24.isAbsolute(manifest[key])
   ) || optionalPaths.some(
-    (key) => manifest[key] !== void 0 && (typeof manifest[key] !== "string" || !path22.isAbsolute(manifest[key]))
+    (key) => manifest[key] !== void 0 && (typeof manifest[key] !== "string" || !path24.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");
   }
@@ -35924,7 +36428,7 @@ async function installRemoteHost(options2) {
   const paths = resolvePaths(options2);
   const previousManifest = await readManifest(paths.manifestPath);
   const previousManifestFile = previousManifest ? {
-    contents: await readFile8(paths.manifestPath),
+    contents: await readFile9(paths.manifestPath),
     mode: (await stat5(paths.manifestPath)).mode & 511
   } : null;
   const existingEntrypoint = await lstat8(paths.wrapperPath).catch(
@@ -35949,7 +36453,7 @@ async function installRemoteHost(options2) {
   }
   const profilePath = previousManifest?.profilePath ?? paths.profilePath;
   const previousEntrypoint = existingEntrypoint?.isFile() ? {
-    contents: await readFile8(paths.wrapperPath),
+    contents: await readFile9(paths.wrapperPath),
     mode: existingEntrypoint.mode & 511
   } : null;
   const discoveredStock = options2.stockCodexPath ?? previousManifest?.stockCodexPath ?? await discoverExecutable("codex", environment);
@@ -35966,8 +36470,6 @@ async function installRemoteHost(options2) {
   const nodePath2 = await executable(options2.nodePath, "Node runtime");
   const shimPath = await executable(options2.shimPath, "codexhost Shim");
   const hostRuntimePath = await existingFile(options2.hostRuntimePath, "codexhost Host Runtime");
-  const discoveredClaude = options2.claudeCommand ?? previousManifest?.claudeCommand ?? await discoverExecutable("claude", environment);
-  const claudeCommand = discoveredClaude ? await executable(discoveredClaude, "Claude Code command") : void 0;
   let manifest = {
     format: MANIFEST_FORMAT,
     wrapperPath: paths.wrapperPath,
@@ -35977,7 +36479,6 @@ async function installRemoteHost(options2) {
     shimPath,
     hostRuntimePath,
     dataDirectory: paths.dataDirectory,
-    ...claudeCommand ? { claudeCommand } : {},
     ...previousManifest?.profileBackupPath ? { profileBackupPath: previousManifest.profileBackupPath } : {}
   };
   const existingProfileSource = await existingText(profilePath);
@@ -36131,7 +36632,7 @@ async function uninstallRemoteHost(options2) {
 import { spawn as spawn5 } from "node:child_process";
 import { stat as stat6 } from "node:fs/promises";
 import net3 from "node:net";
-import path23 from "node:path";
+import path25 from "node:path";
 import { Duplex } from "node:stream";
 var CODEXHOST_STATUS_METHOD = "codexhost/update/status";
 var DIRECT_PROBE_TIMEOUT_MS = 5e3;
@@ -36150,9 +36651,9 @@ function classifyRemoteHostProbeResponse(response, socketPath) {
 }
 var lifecycleDependencyOverrides = {};
 function socketPathFor(environment) {
-  const codexHome = environment.CODEX_HOME ?? (environment.HOME ? path23.join(environment.HOME, ".codex") : void 0);
+  const codexHome = environment.CODEX_HOME ?? (environment.HOME ? path25.join(environment.HOME, ".codex") : void 0);
   if (!codexHome) throw new Error("CODEX_HOME or HOME is required for remote Host lifecycle");
-  return path23.join(codexHome, "app-server-control", "app-server-control.sock");
+  return path25.join(codexHome, "app-server-control", "app-server-control.sock");
 }
 async function defaultSocketExists(socketPath) {
   const metadata = await stat6(socketPath).catch((error51) => {
@@ -36279,15 +36780,14 @@ function installedManifest(status) {
 function managedEnvironment(manifest, environment) {
   return {
     ...environment,
-    CODEX_INSTALL_DIR: path23.dirname(manifest.wrapperPath),
+    CODEX_INSTALL_DIR: path25.dirname(manifest.wrapperPath),
     CODEXHOST_STOCK_CODEX_PATH: manifest.stockCodexPath,
     CODEXHOST_HOST_NODE_PATH: manifest.nodePath,
     CODEXHOST_HOST_RUNTIME_PATH: manifest.hostRuntimePath,
     CODEXHOST_DATA_DIR: manifest.dataDirectory,
     CODEXHOST_DEFAULT_AGENT: "codex",
     CODEXHOST_REMOTE_SSH_MANAGED: "1",
-    ...manifest.claudeCommand ? { CODEXHOST_CLAUDE_COMMAND: manifest.claudeCommand } : {},
-    PATH: `${path23.dirname(manifest.wrapperPath)}${path23.delimiter}${path23.dirname(manifest.stockCodexPath)}${path23.delimiter}${environment.PATH ?? "/usr/bin:/bin"}`
+    PATH: `${path25.dirname(manifest.wrapperPath)}${path25.delimiter}${path25.dirname(manifest.stockCodexPath)}${path25.delimiter}${environment.PATH ?? "/usr/bin:/bin"}`
   };
 }
 async function defaultRunTerminator(manifest, socketPath, role, environment) {
@@ -36435,9 +36935,6 @@ function parseRemoteCliArguments(arguments_2) {
       case "--stock-codex":
         options2.stockCodexPath = value2;
         break;
-      case "--claude-command":
-        options2.claudeCommand = value2;
-        break;
       case "--node":
         resources.nodePath = value2;
         break;
@@ -36464,7 +36961,7 @@ async function runRemoteHostCli(input) {
       output.write(
         [
           "usage:",
-          "  codexhost remote install [--stock-codex PATH] [--claude-command PATH]",
+          "  codexhost remote install [--stock-codex PATH]",
           "  codexhost remote start",
           "  codexhost remote stop",
           "  codexhost remote status",
@@ -36625,26 +37122,26 @@ function consumeBrokerFrames(socket, onFrame, onError) {
 }
 
 // packages/harness-broker/dist/paths.js
-import os6 from "node:os";
-import path24 from "node:path";
+import os7 from "node:os";
+import path26 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 || os6.homedir();
-  return path24.join(home, ".codexhost", "harness-broker");
+  const home = environment.HOME || os7.homedir();
+  return path26.join(home, ".codexhost", "harness-broker");
 }
 function defaultHarnessBrokerDescriptorPath(environment = process.env, harnessId = "claude-code") {
   harnessPluginIdSchema.parse(harnessId);
   if (harnessId !== "claude-code")
-    return path24.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.json`);
-  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path24.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
+    return path26.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.json`);
+  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path26.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
 }
 function defaultHarnessBrokerSocketPath(environment = process.env, harnessId = "claude-code") {
   harnessPluginIdSchema.parse(harnessId);
   if (harnessId !== "claude-code")
-    return path24.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.sock`);
-  return path24.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_SOCKET_FILE);
+    return path26.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.sock`);
+  return path26.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_SOCKET_FILE);
 }
 
 // packages/harness-broker/dist/validation.js
@@ -36858,9 +37355,9 @@ var harnessOutputSchema = external_exports.custom((value2) => {
 
 // packages/harness-broker/dist/server.js
 import { randomBytes as randomBytes3, randomUUID as randomUUID15 } from "node:crypto";
-import { chmod as chmod5, lstat as lstat9, mkdir as mkdir11, open as open8, readFile as readFile9, rename as rename8, rm as rm11 } from "node:fs/promises";
+import { chmod as chmod5, lstat as lstat9, mkdir as mkdir11, open as open8, readFile as readFile10, rename as rename8, rm as rm11 } from "node:fs/promises";
 import net4, {} from "node:net";
-import path25 from "node:path";
+import path27 from "node:path";
 function harnessError(message, retryable = true) {
   return { code: "unavailable", message, retryable, stage: "harnessBroker" };
 }
@@ -36906,7 +37403,7 @@ async function assertNoLiveDescriptor(descriptorPath) {
         throw new Error("Harness broker descriptor is not owner-only");
       }
     }
-    const descriptor = harnessBrokerDescriptorSchema.parse(JSON.parse(await readFile9(descriptorPath, "utf8")));
+    const descriptor = harnessBrokerDescriptorSchema.parse(JSON.parse(await readFile10(descriptorPath, "utf8")));
     if (processIsAlive2(descriptor.ownerPid)) {
       throw new Error("Harness broker descriptor already has a live owner");
     }
@@ -36983,13 +37480,13 @@ async function prepareUnixSocketPath(socketPath) {
 }
 async function startHarnessBrokerServer(input) {
   harnessPluginIdSchema.parse(input.adapter.harnessId);
-  if (process.platform !== "win32" && path25.dirname(input.descriptorPath) !== path25.dirname(input.socketPath)) {
+  if (process.platform !== "win32" && path27.dirname(input.descriptorPath) !== path27.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(path25.dirname(input.descriptorPath));
+  await privateDirectory(path27.dirname(input.descriptorPath));
   await assertNoLiveDescriptor(input.descriptorPath);
   if (process.platform !== "win32")
     await prepareUnixSocketPath(input.socketPath);