@codexhost/cli-darwin-x64 0.13.3 → 0.14.0

package/app/host-runtime.mjs

@@ -3716,8 +3716,10 @@ List Harnesses available in the active Runtime.`,
   "harness inspect": `codexhost harness inspect <harness> [--cwd <path>] [--refresh true|false] [--format json|compact]
 Read available Models, native defaults, Thinking options, and configuration capabilities.
 Use the returned Model and Thinking IDs for explicit selections.`,
-  "delegate start": `codexhost delegate start --harness <id> --task <text> [--cwd <path>] [--model <opaque-ref>] [--thinking <option-id>] [--parent-thread <thread>] [--request-id <id>] [--watch true|false] [--watch-timeout-ms <n>] [--format json|compact]
+  "delegate start": `codexhost delegate start --harness <id> --task <text> [--task-name <name>] [--cwd <path>] [--model <opaque-ref>] [--thinking <option-id>] [--parent-thread <thread>] [--request-id <id>] [--watch true|false] [--watch-timeout-ms <n>] [--format json|compact]
 Create an independent child Thread, submit the task, and return immediately.
+--task-name supplies a short subtask name (1-120 characters); otherwise the first task line is used.
+The child title is "subtask name · parent title", fixed at creation; renaming the parent does not rename existing children.
 Omit --model and --thinking to use the Harness native defaults.
 --cwd overrides the child workspace. Otherwise use the resolved parent Thread workspace, then the Host Runtime process cwd.
 --parent-thread overrides caller inference. PARENT_THREAD_AMBIGUOUS requires an explicit parent.
@@ -4161,6 +4163,7 @@ async function runDelegationCli(input) {
       rejectUnknown(parsed2, [
         "--harness",
         "--task",
+        "--task-name",
         "--cwd",
         "--model",
         "--thinking",
@@ -4195,6 +4198,7 @@ async function runDelegationCli(input) {
           body: {
             harnessId,
             task,
+            ...value(parsed2, "--task-name") !== void 0 ? { taskName: value(parsed2, "--task-name") } : {},
             ...value(parsed2, "--cwd") ? { cwd: value(parsed2, "--cwd") } : {},
             ...value(parsed2, "--model") ? { model: { id: value(parsed2, "--model") } } : {},
             ...value(parsed2, "--thinking") ? { thinkingOptionId: value(parsed2, "--thinking") } : {},
@@ -20089,10 +20093,19 @@ var model = external_exports.string().min(1).max(512);
 var project = external_exports.string().min(1).max(4096);
 var usageStatisticsParamsSchema = external_exports.strictObject({
   range: external_exports.enum(USAGE_STATISTICS_RANGES),
+  /** Display timezone for ranges, dates and hourly buckets; omitted means the Host's local zone. */
+  timeZone: external_exports.string().min(1).max(128).refine((value2) => {
+    try {
+      new Intl.DateTimeFormat("en", { timeZone: value2 });
+      return true;
+    } catch {
+      return false;
+    }
+  }, "Unsupported usage statistics timezone").optional(),
   harness: harness.optional(),
   model: model.nullable().optional(),
   project: project.nullable().optional(),
-  /** One local date inside the range. */
+  /** One date in the query timezone inside the range. */
   date: localDate.optional()
 });
 var usageStatisticsTotalsSchema = external_exports.strictObject({
@@ -20128,7 +20141,7 @@ var usageStatisticsSessionSchema = external_exports.strictObject({
 });
 var usageStatisticsResultSchema = external_exports.strictObject({
   range: external_exports.enum(USAGE_STATISTICS_RANGES),
-  /** First local date of the range; null for all time. */
+  /** First date in the query timezone (Host local when omitted); null for all time. */
   from: localDate.nullable(),
   to: localDate,
   /** The filters these figures apply, echoed so a late answer to older filters is recognised. */
@@ -20168,7 +20181,7 @@ var usageStatisticsResultSchema = external_exports.strictObject({
   totals: usageStatisticsTotalsSchema,
   /** Each date and Harness of the range: every filter except the day. */
   daily: external_exports.array(external_exports.strictObject({ date: localDate, harness, ...totals })).max(2e5),
-  /** Local weekday (0 = Sunday) and hour, all filters applied. */
+  /** Weekday (0 = Sunday) and hour in the query timezone, all filters applied. */
   hourly: external_exports.array(external_exports.strictObject({
     weekday: external_exports.number().int().min(0).max(6),
     hour: external_exports.number().int().min(0).max(23),
@@ -20231,6 +20244,8 @@ var CONSOLE_HOST_METHODS = Object.freeze([
   "codexhost/harness/display-settings/set",
   "codexhost/harness/inspect",
   "codexhost/harness/installation",
+  "codexhost/harness/installation/start",
+  "codexhost/harness/installation/status",
   "codexhost/harness/launch-settings/get",
   "codexhost/harness/launch-settings/set",
   "codexhost/harness/web-ui/open",
@@ -20312,7 +20327,18 @@ var threadManualCompactionStartedSchema = external_exports.strictObject({
 var nonNegativeSafeIntegerSchema = external_exports.number().int().safe().nonnegative();
 var finiteNonNegativeNumberSchema = external_exports.number().finite().nonnegative();
 var cacheHitRatePercentSchema = external_exports.number().finite().min(0).max(100);
+var indicatorTextSchema = (maximum) => harnessLocalizedTextSchema.refine((entries) => Object.values(entries).every((text) => text.length <= maximum));
+var composerIndicatorsSchema = external_exports.array(external_exports.object({
+  kind: external_exports.literal("countdown"),
+  id: external_exports.string().min(1).max(64),
+  expiresAtUnix: nonNegativeSafeIntegerSchema,
+  label: indicatorTextSchema(256).optional(),
+  tooltip: indicatorTextSchema(1024).optional()
+}).strict()).max(2).refine((entries) => new Set(entries.map(({ id: id2 }) => id2)).size === entries.length, {
+  message: "Composer indicator IDs must be unique"
+});
 var threadUsageSnapshotSchema = external_exports.object({
+  composerIndicators: composerIndicatorsSchema.optional(),
   inputTokens: nonNegativeSafeIntegerSchema.optional(),
   cachedInputTokens: nonNegativeSafeIntegerSchema.optional(),
   cacheWriteInputTokens: nonNegativeSafeIntegerSchema.optional(),
@@ -20728,7 +20754,9 @@ var harnessSessionCapabilitiesSchema = external_exports.object({
   }).strict().optional(),
   autonomousTurns: external_exports.object({
     observe: external_exports.boolean()
-  }).strict().optional()
+  }).strict().optional(),
+  /** True only when `turn.steer` delivers input into the active Turn through a native primitive. */
+  steer: external_exports.boolean().optional()
 }).strict();
 var harnessConfigurationStateSchema = external_exports.object({
   effectiveModel: harnessModelRefSchema.optional(),
@@ -20776,7 +20804,9 @@ var harnessInspectionSchema = external_exports.union([
 var harnessInspectParamsSchema = external_exports.object({
   harnessId: harnessIdSchema,
   cwd: nonBlankTextSchema2.max(16384).optional(),
-  refresh: external_exports.boolean().optional()
+  refresh: external_exports.boolean().optional(),
+  /** `availability` asks only whether the Harness can run; see `InspectHarnessInput.purpose`. */
+  purpose: external_exports.literal("availability").optional()
 }).strict();
 var harnessWebUiOpenParamsSchema = external_exports.object({
   harnessId: harnessIdSchema
@@ -20859,6 +20889,16 @@ var threadOwnershipListResultSchema = external_exports.object({
     seen.add(thread.threadId);
   }
 });
+var threadSteeringInspectParamsSchema = external_exports.object({
+  threadId: hostThreadIdSchema,
+  /** The text about to be steered; a Harness command always stops and restarts. */
+  text: external_exports.string().optional()
+}).strict();
+var THREAD_STEER_DELIVERY_PARAM = "codexhostSteerDelivery";
+var threadSteerDeliverySchema = external_exports.enum(["activeTurn", "newTurn"]);
+var threadSteeringInspectResultSchema = external_exports.object({
+  delivery: external_exports.enum(["official", "activeTurn", "newTurn"])
+}).strict();
 
 // packages/shared-contracts/dist/harness-plugins.js
 var HARNESS_PLUGIN_API_VERSION = 1;
@@ -20979,6 +21019,8 @@ var harnessLaunchSettingsSchema = external_exports.object({
 
 // packages/shared-contracts/dist/harness-installation.js
 var HARNESS_INSTALLATION_METHOD = "codexhost/harness/installation";
+var HARNESS_INSTALLATION_START_METHOD = "codexhost/harness/installation/start";
+var HARNESS_INSTALLATION_STATUS_METHOD = "codexhost/harness/installation/status";
 var harnessInstallationParamsSchema = external_exports.object({
   harnessId: harnessIdSchema,
   action: external_exports.enum(["check", "update", "install"])
@@ -20988,6 +21030,10 @@ var harnessInstallationStateSchema = external_exports.object({
   latestVersion: external_exports.string().min(1).max(128),
   updateAvailable: external_exports.boolean(),
   canUpdate: external_exports.boolean(),
+  /** Defaults to CLI; some Harnesses ship only inside a desktop application. */
+  versionKind: external_exports.enum(["cli", "application"]).optional(),
+  /** Official download opened by the user; does not imply an automatic installation. */
+  manualUpdateUrl: external_exports.url().max(2048).refine((value2) => /^https:\/\/[^/?#@]+(?:[/?#]|$)/iu.test(value2), "Manual updates require a credential-free HTTPS URL").optional(),
   // Adapter-owned diagnostic text; UI uses messageCode rather than displaying it verbatim.
   message: external_exports.string().max(2048).optional(),
   messageCode: external_exports.string().min(1).max(128).optional(),
@@ -20995,6 +21041,20 @@ var harnessInstallationStateSchema = external_exports.object({
   notice: harnessLocalizedTextSchema.optional(),
   latestVersionKind: external_exports.enum(["unknown", "tracking-branch"]).optional()
 }).strict();
+var harnessInstallationTaskParamsSchema = external_exports.object({ taskId: external_exports.string().uuid() }).strict();
+var harnessInstallationTaskSchema = external_exports.discriminatedUnion("status", [
+  external_exports.object({ taskId: external_exports.string().uuid(), status: external_exports.literal("running") }).strict(),
+  external_exports.object({
+    taskId: external_exports.string().uuid(),
+    status: external_exports.literal("succeeded"),
+    result: harnessInstallationStateSchema
+  }).strict(),
+  external_exports.object({
+    taskId: external_exports.string().uuid(),
+    status: external_exports.literal("failed"),
+    error: external_exports.object({ code: external_exports.number().int(), message: external_exports.string().min(1).max(2048) }).strict()
+  }).strict()
+]);
 
 // packages/shared-contracts/dist/codex-accounts.js
 var accountIdSchema = external_exports.string().min(1).max(256).regex(/^[A-Za-z0-9._~-]+$/u);
@@ -22982,9 +23042,13 @@ function requestManagerFromHookState(value2, hostId2) {
   const direct = manager(value2) ?? manager(value2.manager);
   if (direct)
     return direct;
-  if (!hostId2 || typeof value2.addManager !== "function" || typeof value2.getForHostId !== "function" || typeof value2.waitForManagerForHostId !== "function")
+  if (!hostId2 || typeof value2.addManager !== "function" || typeof value2.getForHostId !== "function")
     return null;
-  return manager(value2.getForHostId(hostId2));
+  try {
+    return manager(value2.getForHostId(hostId2));
+  } catch {
+    return null;
+  }
 }
 function discoverRendererHosts(root, ancestors = committedReactAncestors, managerFrom = requestManagerFromHookState) {
   const editors = [
@@ -23020,7 +23084,7 @@ function discoverRendererHosts(root, ancestors = committedReactAncestors, manage
       const manager = managerFrom(value2);
       if (manager)
         managers.add(manager);
-      if (value2 && typeof value2 === "object" && "addManager" in value2 && typeof value2.addManager === "function" && "getForHostId" in value2 && typeof value2.getForHostId === "function" && "waitForManagerForHostId" in value2 && typeof value2.waitForManagerForHostId === "function") {
+      if (value2 && typeof value2 === "object" && "addManager" in value2 && typeof value2.addManager === "function" && "getForHostId" in value2 && typeof value2.getForHostId === "function") {
         registries.add(value2);
       }
       hook = hook.next && typeof hook.next === "object" ? hook.next : null;
@@ -23036,7 +23100,13 @@ function discoverRendererHosts(root, ancestors = committedReactAncestors, manage
 function resolveRendererHostManager(discovery, hostId2, managerFrom = requestManagerFromHookState) {
   if (!hostId2)
     return null;
-  const candidates = discovery.registries.length ? discovery.registries.map((registry2) => managerFrom(registry2.getForHostId(hostId2))) : discovery.managers;
+  const candidates = discovery.registries.length ? discovery.registries.flatMap((registry2) => {
+    try {
+      return [managerFrom(registry2.getForHostId(hostId2))];
+    } catch {
+      return [];
+    }
+  }) : discovery.managers;
   const matching = new Set(candidates.filter((manager) => manager && (manager.getHostId?.() ?? manager.requestClient.hostId) === hostId2 && (manager.requestClient.hostId === void 0 || manager.requestClient.hostId === hostId2)));
   return matching.size === 1 ? matching.values().next().value ?? null : null;
 }
@@ -24048,6 +24118,64 @@ async function handleHarnessInstallation(params, adapters) {
   }
 }
 
+// packages/host-runtime/src/harness-installation-tasks.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+var HarnessInstallationTasks = class {
+  #tasks = /* @__PURE__ */ new Map();
+  #active = /* @__PURE__ */ new Map();
+  #prune() {
+    const cutoff = Date.now() - 15 * 6e4;
+    for (const [id2, task] of this.#tasks) {
+      if (task.finishedAt !== void 0 && task.finishedAt < cutoff) this.#tasks.delete(id2);
+    }
+  }
+  start(params, adapters) {
+    const parsed2 = harnessInstallationParamsSchema.safeParse(params);
+    if (!parsed2.success)
+      throw new HarnessInstallationError(-32602, "Invalid Harness installation request");
+    this.#prune();
+    const key = JSON.stringify([parsed2.data.harnessId, parsed2.data.action]);
+    const activeId = this.#active.get(key);
+    const active = activeId ? this.#tasks.get(activeId) : void 0;
+    if (active) return active.state;
+    const taskId = randomUUID3();
+    const task = {
+      state: { taskId, status: "running" }
+    };
+    this.#tasks.set(taskId, task);
+    this.#active.set(key, taskId);
+    void handleHarnessInstallation(parsed2.data, adapters).then(
+      (result) => {
+        task.state = { taskId, status: "succeeded", result };
+      },
+      (error51) => {
+        task.state = {
+          taskId,
+          status: "failed",
+          error: error51 instanceof HarnessInstallationError ? { code: error51.code, message: error51.message } : { code: -32077, message: "Harness version management failed" }
+        };
+      }
+    ).finally(() => {
+      task.finishedAt = Date.now();
+      this.#active.delete(key);
+    });
+    return task.state;
+  }
+  status(params) {
+    const parsed2 = harnessInstallationTaskParamsSchema.safeParse(params);
+    if (!parsed2.success)
+      throw new HarnessInstallationError(-32602, "Invalid Harness installation task request");
+    this.#prune();
+    const task = this.#tasks.get(parsed2.data.taskId);
+    if (!task)
+      throw new HarnessInstallationError(
+        -32079,
+        "Harness installation task is unavailable on this Host"
+      );
+    return task.state;
+  }
+};
+
 // packages/host-runtime/src/account/codex-credential-export.ts
 import { createHash as createHash3 } from "node:crypto";
 import { readFile as readFile8 } from "node:fs/promises";
@@ -24140,7 +24268,7 @@ async function listOthers(adapter) {
 }
 
 // packages/host-runtime/src/harness-display-settings.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { link, mkdir as mkdir6, readFile as readFile9, rename as rename4, rm as rm5, writeFile as writeFile6 } from "node:fs/promises";
 import os4 from "node:os";
 import path13 from "node:path";
@@ -24165,7 +24293,7 @@ var HarnessDisplaySettingsStore = class {
   async set(input) {
     const entries = harnessDisplayEntriesSchema.parse(input.entries);
     await mkdir6(path13.dirname(this.#file), { recursive: true, mode: 448 });
-    const temporary = `${this.#file}.${randomUUID3()}.tmp`;
+    const temporary = `${this.#file}.${randomUUID4()}.tmp`;
     try {
       await writeFile6(temporary, `${JSON.stringify(entries)}
 `, { mode: 384, flag: "wx" });
@@ -24186,7 +24314,7 @@ var HarnessDisplaySettingsStore = class {
 };
 
 // packages/host-runtime/src/model-price-overrides-file.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 import { mkdir as mkdir8, readFile as readFile11, rename as rename6, rm as rm6, writeFile as writeFile8 } from "node:fs/promises";
 import path15 from "node:path";
 
@@ -24761,7 +24889,7 @@ async function updateModelPriceOverridesFile(file2, change) {
   const updated = { ...document, models: next };
   parseModelPriceOverrides(updated);
   await mkdir8(path15.dirname(file2), { recursive: true });
-  const temporary = `${file2}.${randomUUID4()}.tmp`;
+  const temporary = `${file2}.${randomUUID5()}.tmp`;
   try {
     await writeFile8(temporary, `${JSON.stringify(updated, null, 2)}
 `, { flag: "wx" });
@@ -24797,11 +24925,11 @@ async function handleModelPriceOverridesRequest(catalog, method, params) {
 }
 
 // packages/host-runtime/src/delegation-skill.ts
-import { createHash as createHash4, randomUUID as randomUUID5 } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID6 } from "node:crypto";
 import { mkdir as mkdir9, open as open4, readFile as readFile12, rename as rename7, rm as rm7, stat as stat5 } from "node:fs/promises";
 import os6 from "node:os";
 import path16 from "node:path";
-var SKILL_VERSION = 9;
+var SKILL_VERSION = 10;
 var DELEGATION_SKILL_NAME = "codexhost-delegation";
 var SKILL_RELATIVE_PATH = path16.join("skills", DELEGATION_SKILL_NAME, "SKILL.md");
 var PREVIOUS_MANAGED_DIGESTS = [
@@ -24815,7 +24943,9 @@ var PREVIOUS_MANAGED_DIGESTS = [
   "fa7944cd1e72ffbaf932fca2074bdb78aad4670d8990b6711220dd83c39509a0",
   "b9c1cce41d2556e73a6514aa55618d7d3f2f9ef935f5ae50b0da5a04941514b4",
   // v8, which ran a bare `codexhost` from PATH.
-  "ca06be59f0d47c9a54d05ed2d9588c9c737306cc155cb4dff3fe2a2a61891dde"
+  "ca06be59f0d47c9a54d05ed2d9588c9c737306cc155cb4dff3fe2a2a61891dde",
+  // v9, before the child-session name guidance.
+  "b72a059e139bd5b93b95f7ac02ab80f428d5a721cc67b004210d5263e75baed7"
 ];
 var CODEXHOST_DELEGATION_SKILL = `---
 name: codexhost-delegation
@@ -24852,7 +24982,8 @@ 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
+requested task. Give it a short task name that tells it apart from sibling
+tasks, using the help's task-name option. 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
@@ -24894,7 +25025,7 @@ async function readOptional(filePath) {
 }
 async function atomicWrite(filePath, content) {
   await mkdir9(path16.dirname(filePath), { recursive: true, mode: 448 });
-  const temporaryPath = path16.join(path16.dirname(filePath), `.SKILL.md.${randomUUID5()}.tmp`);
+  const temporaryPath = path16.join(path16.dirname(filePath), `.SKILL.md.${randomUUID6()}.tmp`);
   const handle = await open4(temporaryPath, "wx", 384);
   try {
     await handle.writeFile(content, "utf8");
@@ -25131,6 +25262,7 @@ var usageFields = /* @__PURE__ */ new Set([
   ...safeIntegerFields,
   ...percentFields,
   "sessionCacheUsage",
+  "composerIndicators",
   "totalCostUsd",
   "totalCredits",
   "contextUsagePercent",
@@ -25153,6 +25285,7 @@ function parseHostUsage(value2) {
       throw new Error(`Harness Usage contains unknown field '${key}'`);
     }
   }
+  const indicators = value2.composerIndicators === void 0 ? {} : { composerIndicators: composerIndicatorsSchema.parse(value2.composerIndicators) };
   for (const field of [
     "totalCredits",
     "contextUsagePercent",
@@ -25223,9 +25356,9 @@ function parseHostUsage(value2) {
     if (value2.costSource !== "publicPrice") {
       throw new Error("Harness Usage 'unpricedModels' must be provided with a 'publicPrice' cost");
     }
-    return { ...value2, unpricedModels: [...models] };
+    return { ...value2, ...indicators, unpricedModels: [...models] };
   }
-  return { ...value2 };
+  return { ...value2, ...indicators };
 }
 var requestTokenFields = [
   "inputTokens",
@@ -25376,7 +25509,7 @@ var packageMetadata = {
 
 // packages/mapping-store/dist/mapping-store.js
 import { execFileSync } from "node:child_process";
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 import { constants as constants3 } from "node:fs";
 import { copyFile as copyFile3, mkdir as mkdir11, open as open7, readFile as readFile15, readdir as readdir4, rename as rename10, rm as rm10, stat as stat6 } from "node:fs/promises";
 import path18 from "node:path";
@@ -25436,7 +25569,7 @@ var storedThreadMetadataV1Schema = external_exports.object({
   formatVersion: external_exports.literal(1),
   hostThreadId: storedHostThreadIdSchema,
   ...storedThreadMetadataFieldsShape
-}).strict();
+}).passthrough();
 function refineThreadRecord(record4, context) {
   if (record4.state === "ready" && !record4.nativeSessionRef) {
     context.addIssue({
@@ -25495,8 +25628,8 @@ function refineThreadRecord(record4, context) {
     }
   }
 }
-var storedThreadCoreV1Schema = external_exports.object(storedThreadCoreV1Shape).strict().superRefine(refineThreadRecord);
-var storedThreadRecordV1Schema = external_exports.object({ ...storedThreadCoreV1Shape, ...storedThreadMetadataFieldsShape }).strict().superRefine(refineThreadRecord);
+var storedThreadCoreV1Schema = external_exports.object(storedThreadCoreV1Shape).passthrough().superRefine(refineThreadRecord);
+var storedThreadRecordV1Schema = external_exports.object({ ...storedThreadCoreV1Shape, ...storedThreadMetadataFieldsShape }).passthrough().superRefine(refineThreadRecord);
 var delegationStatusSchema = external_exports.enum([
   "creating",
   "running",
@@ -25523,7 +25656,7 @@ var storedDelegationRecordV1Schema = external_exports.object({
 });
 
 // packages/mapping-store/dist/section-placements.js
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 import { constants } from "node:fs";
 import { open as open5, readFile as readFile13, rename as rename8, rm as rm8 } from "node:fs/promises";
 var threadIdSchema = external_exports.string().min(1).max(1024);
@@ -25575,7 +25708,7 @@ async function readSectionPlacementsFile(file2) {
 }
 async function writeSectionPlacementsFile(file2, placements) {
   const parsed2 = parseSectionPlacements({ formatVersion: 1, placements });
-  const temp = `${file2}.tmp-${randomUUID6()}`;
+  const temp = `${file2}.tmp-${randomUUID7()}`;
   let handle = null;
   try {
     handle = await open5(temp, "wx", constants.S_IRUSR | constants.S_IWUSR);
@@ -25594,7 +25727,7 @@ async function writeSectionPlacementsFile(file2, placements) {
 }
 
 // packages/mapping-store/dist/superseded-sessions.js
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 import { constants as constants2 } from "node:fs";
 import { mkdir as mkdir10, open as open6, readFile as readFile14, rename as rename9, rm as rm9 } from "node:fs/promises";
 import path17 from "node:path";
@@ -25629,7 +25762,7 @@ async function writeSupersededSessionsFile(file2, sessions) {
     formatVersion: 1,
     sessions: sessions.slice(-SUPERSEDED_SESSIONS_MAX)
   }).sessions;
-  const temp = `${file2}.tmp-${randomUUID7()}`;
+  const temp = `${file2}.tmp-${randomUUID8()}`;
   let handle = null;
   try {
     await mkdir10(path17.dirname(file2), { recursive: true });
@@ -25874,7 +26007,7 @@ var MappingStore = class {
     this.#sectionsDirectory = path18.join(this.#directory, "sections");
     this.#metadataDirectory = path18.join(this.#directory, "thread-metadata");
     this.#lockPath = path18.join(this.#directory, "store.lock");
-    this.#instanceId = options2.instanceId ?? randomUUID8();
+    this.#instanceId = options2.instanceId ?? randomUUID9();
     this.#now = options2.now ?? (() => /* @__PURE__ */ new Date());
     this.#beforeReplace = options2.beforeReplace;
   }
@@ -26398,7 +26531,7 @@ var MappingStore = class {
     this.#rebuildIndexes();
   }
   async #replaceFile(target, record4, preserveBackup) {
-    const temp = `${target}.tmp-${randomUUID8()}`;
+    const temp = `${target}.tmp-${randomUUID9()}`;
     let handle = null;
     try {
       await this.#beforeReplace?.(cloneRecord(record4));
@@ -26422,18 +26555,20 @@ var MappingStore = class {
       });
     }
   }
-  /** Atomically writes, or with null removes, a Thread's Desktop metadata file. */
+  /** Atomically patches owned metadata fields, retaining unknown fields on disk. */
   async #writeMetadataFile(hostThreadId, metadata) {
     const target = this.#metadataPath(hostThreadId);
-    const temp = `${target}.tmp-${randomUUID8()}`;
+    const temp = `${target}.tmp-${randomUUID9()}`;
     let handle = null;
     try {
-      if (!metadata) {
+      const retained = Object.fromEntries(Object.entries(await this.#readMetadata(hostThreadId) ?? {}).filter(([name]) => !["formatVersion", "hostThreadId", ...THREAD_METADATA_FIELDS].includes(name)));
+      if (!metadata && Object.keys(retained).length === 0) {
         await rm10(target, { force: true });
         return;
       }
+      const next = { ...retained, formatVersion: 1, hostThreadId, ...metadata };
       handle = await open7(temp, "wx", constants3.S_IRUSR | constants3.S_IWUSR);
-      await handle.writeFile(`${JSON.stringify(metadata, null, 2)}
+      await handle.writeFile(`${JSON.stringify(next, null, 2)}
 `, "utf8");
       await handle.sync();
       await handle.close();
@@ -26470,7 +26605,7 @@ var MappingStore = class {
   }
   async #replaceDelegationFile(record4) {
     const target = this.#delegationPath(record4.delegationId);
-    const temp = `${target}.tmp-${randomUUID8()}`;
+    const temp = `${target}.tmp-${randomUUID9()}`;
     let handle = null;
     try {
       handle = await open7(temp, "wx", constants3.S_IRUSR | constants3.S_IWUSR);
@@ -28155,8 +28290,18 @@ function collabAgentStatus(status2) {
       return "interrupted";
   }
 }
+function projectUserMessage(item, clientId) {
+  return {
+    id: item.itemId,
+    type: "userMessage",
+    clientId,
+    content: item.input.map(({ text }) => ({ type: "text", text, text_elements: [] }))
+  };
+}
 function projectItem(item, outcome, defaultCwd, includeCommandOutput = true, senderThreadId) {
   switch (item.type) {
+    case "userMessage":
+      return projectUserMessage(item, null);
     case "agentMessage":
       return {
         id: item.itemId,
@@ -28368,6 +28513,7 @@ var CodexTurnProjector = class {
   #interactions = /* @__PURE__ */ new Map();
   #items = /* @__PURE__ */ new Map();
   #wireItemOrder = [];
+  #userMessageClientIds = /* @__PURE__ */ new Map();
   #startedAt;
   #startedAtMs;
   #threadId;
@@ -28409,6 +28555,10 @@ var CodexTurnProjector = class {
     }
     return items;
   }
+  /** Associate steered input with the Desktop message that submitted it, before it is published. */
+  bindUserMessageClientId(itemId, clientId) {
+    this.#userMessageClientIds.set(itemId, clientId);
+  }
   pendingTurn(startedAt = null) {
     return {
       id: this.#turnId,
@@ -28419,6 +28569,8 @@ var CodexTurnProjector = class {
           const projected = this.#items.get(itemId);
           if (!projected?.wireStarted)
             return [];
+          if (projected.item.type === "userMessage")
+            return [this.#projectItem(projected.item)];
           if (projected.item.type === "agentMessage") {
             return [projectItem(projected.item, projected.outcome, this.#cwd)];
           }
@@ -28746,7 +28898,7 @@ var CodexTurnProjector = class {
       return { messages: [] };
     }
     const messages = [
-      completedItem(projectItem(projected.item, projected.outcome, this.#cwd, !projected.streamedCommandOutput, this.#threadId))
+      completedItem(this.#projectItem(projected.item, projected.outcome, !projected.streamedCommandOutput))
     ];
     if (projected.item.type === "reasoning") {
       const reasoning = projected.item;
@@ -28811,6 +28963,8 @@ var CodexTurnProjector = class {
               projectReasoningTranscriptItem(reasoning, projected.outcome, this.#cwd, projected.durationMs ?? null)
             ];
           }
+          if (projected.item.type === "userMessage")
+            return [this.#projectItem(projected.item)];
           if (projected.item.type === "agentMessage") {
             return [projectItem(projected.item, projected.outcome, this.#cwd)];
           }
@@ -28896,10 +29050,13 @@ var CodexTurnProjector = class {
         threadId: this.#threadId,
         turnId: this.#turnId,
         startedAtMs,
-        item: projectItem(item, null, this.#cwd, true, this.#threadId)
+        item: this.#projectItem(item, null)
       }
     };
   }
+  #projectItem(item, outcome = null, includeCommandOutput = true) {
+    return item.type === "userMessage" ? projectUserMessage(item, this.#userMessageClientIds.get(item.itemId) ?? null) : projectItem(item, outcome, this.#cwd, includeCommandOutput, this.#threadId);
+  }
   #startReasoningTranscript(item, startedAtMs) {
     return {
       method: "item/started",
@@ -30291,7 +30448,7 @@ var HarnessAccountInspectionCache = class {
 };
 
 // packages/host-runtime/src/app-server-host.ts
-import { createHash as createHash9, randomUUID as randomUUID14 } from "node:crypto";
+import { createHash as createHash9, randomUUID as randomUUID16 } from "node:crypto";
 import os8 from "node:os";
 import path25 from "node:path";
 
@@ -30299,12 +30456,12 @@ import path25 from "node:path";
 import nodePath from "node:path";
 
 // packages/host-runtime/src/external-thread-repository.ts
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID11 } from "node:crypto";
 import os7 from "node:os";
 import path22 from "node:path";
 
 // packages/host-runtime/src/external-subagent-threads.ts
-import { createHash as createHash6, randomUUID as randomUUID9 } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID10 } from "node:crypto";
 function childCreateRequest(parent, nativeRef, id2) {
   const key = createHash6("sha256").update(JSON.stringify([parent.hostThreadId, parent.harnessId, nativeRef.nativeSessionId, id2])).digest("hex");
   return `subagent:${key}`;
@@ -30379,7 +30536,7 @@ function subagentMaterializer(store, parent, previousParent) {
       return rebind(existing, parent);
     }
     const provisional = existing ?? await store.createProvisional({
-      hostThreadId: hostThreadIdSchema.parse(randomUUID9()),
+      hostThreadId: hostThreadIdSchema.parse(randomUUID10()),
       createRequestId,
       harnessId: parent.harnessId,
       cwd: parent.cwd,
@@ -30552,7 +30709,7 @@ var ExternalThreadRepository = class {
         throw new Error("Derived Snapshot identity does not belong to its Native Session");
       }
       return {
-        hostTurnId: hostTurnIdSchema.parse(randomUUID10()),
+        hostTurnId: hostTurnIdSchema.parse(randomUUID11()),
         nativeTurnRef: turn.nativeTurnRef,
         ...turn.checkpoint ? { nativeCheckpointRef: turn.checkpoint } : {}
       };
@@ -30675,14 +30832,14 @@ var ExternalThreadRepository = class {
     const aligned = snapshot2.turns.map((turn) => {
       const existing = mappingsByNative.get(nativeTurnKey2(turn.nativeTurnRef));
       const mapping = existing ?? {
-        hostTurnId: hostTurnIdSchema.parse(randomUUID10()),
+        hostTurnId: hostTurnIdSchema.parse(randomUUID11()),
         nativeTurnRef: turn.nativeTurnRef,
         ...turn.checkpoint ? { nativeCheckpointRef: turn.checkpoint } : {}
       };
       return {
         snapshot: turn,
         mapping: {
-          ...mapping,
+          hostTurnId: mapping.hostTurnId,
           nativeTurnRef: turn.nativeTurnRef,
           ...turn.checkpoint ? { nativeCheckpointRef: turn.checkpoint } : {}
         }
@@ -30702,8 +30859,8 @@ var ExternalThreadRepository = class {
 };
 function createExternalThreadRecordInput(input) {
   return {
-    hostThreadId: input.hostThreadId ?? hostThreadIdSchema.parse(randomUUID10()),
-    createRequestId: input.createRequestId ?? randomUUID10(),
+    hostThreadId: input.hostThreadId ?? hostThreadIdSchema.parse(randomUUID11()),
+    createRequestId: input.createRequestId ?? randomUUID11(),
     harnessId: input.harnessId,
     cwd: input.cwd,
     ...input.title ? { title: input.title } : {},
@@ -30821,6 +30978,15 @@ async function executeExternalThreadFork(input) {
     boundaryIndex = mappings.length - 1;
   }
   const boundary = mappings[boundaryIndex];
+  if (boundary && source.steeredTurnIds.has(boundary.hostTurnId)) {
+    return {
+      ok: false,
+      error: {
+        code: -32080,
+        message: "This Turn took steered input; reopen the Thread before forking from it"
+      }
+    };
+  }
   if (boundaryIndex < 0 || !boundary?.nativeCheckpointRef) {
     return {
       ok: false,
@@ -30877,6 +31043,7 @@ async function executeExternalThreadFork(input) {
     return { ok: false, error: mapExternalThreadHarnessError(opened.error, "fork") };
   }
   const session = opened.value;
+  await inheritSourceModel(source, session);
   const inheritedPermissionModeId = await inheritSourcePermissionMode(source, session);
   try {
     const derivedNativeRef = session.initialState.nativeRef;
@@ -30894,7 +31061,7 @@ async function executeExternalThreadFork(input) {
       source.harnessId,
       provisional.transportModelId
     );
-    if (effectiveModel && selection?.model && selection.model.id !== effectiveModel.id) {
+    if (effectiveModel && selection && selection.model?.id !== effectiveModel.id) {
       const transportModelId = encodeExternalTransportSelection(source.harnessId, {
         ...selection,
         model: effectiveModel
@@ -30939,6 +31106,22 @@ async function executeExternalThreadFork(input) {
     };
   }
 }
+async function inheritSourceModel(source, session) {
+  let persisted;
+  try {
+    persisted = decodeExternalTransportSelection(source.harnessId, source.transportModelId)?.model;
+  } catch {
+    persisted = void 0;
+  }
+  const sourceModel = source.stateObserver.state.effectiveModel ?? source.requestedModel ?? persisted;
+  if (!sourceModel || !session.capabilities.configuration.selectModel || session.initialState.effectiveModel !== void 0) {
+    return;
+  }
+  try {
+    await session.execute({ type: "model.select", model: sourceModel });
+  } catch {
+  }
+}
 async function inheritSourcePermissionMode(source, session) {
   const sourceModeId = source.stateObserver.state.effectivePermissionModeId ?? source.requestedPermissionModeId;
   if (!sourceModeId) return void 0;
@@ -31560,6 +31743,16 @@ async function executeExternalThreadRollback(input) {
   if (derived.running) {
     return { ok: false, error: { code: -32072, message: "External Thread has an active Turn" } };
   }
+  const undone = derived.record.turnMappings.slice(-rollback.numTurns);
+  if (undone.some((mapping) => derived.steeredTurnIds.has(mapping.hostTurnId))) {
+    return {
+      ok: false,
+      error: {
+        code: -32080,
+        message: "A Turn here took steered input; reopen the Thread before undoing Turns"
+      }
+    };
+  }
   const refreshError = await runtime.refresh(derived);
   if (refreshError) return { ok: false, error: refreshError };
   if (expectedLastTurnId !== void 0 && derived.record.turnMappings.at(-1)?.hostTurnId !== expectedLastTurnId) {
@@ -32359,6 +32552,7 @@ var ExternalThreadRuntime = class {
   #repository;
   #lifecycle = new ExternalThreadLifecycle();
   #hasRunningDescendants;
+  #steeredTurnIds = /* @__PURE__ */ new Map();
   #subagentRunning;
   #threads = /* @__PURE__ */ new Map();
   constructor(input) {
@@ -32372,7 +32566,8 @@ var ExternalThreadRuntime = class {
     this.idleRelease = new ExternalThreadIdleRelease({
       threads: () => this.values(),
       get: (id2) => this.get(id2),
-      remove: (id2) => this.remove(id2),
+      // Idle release detaches only the Native Session. Host Thread state survives restoration.
+      remove: (id2) => this.#detach(id2),
       queue: input.idleRelease?.queue ?? new DesktopRequestQueue(),
       canRelease: (thread) => !thread.sessionUnavailable && !this.#lifecycle.busy(thread.id) && (input.idleRelease?.canRelease(thread) ?? false),
       ...input.idleRelease?.onClosed ? { onClosed: input.idleRelease.onClosed } : {},
@@ -32382,14 +32577,21 @@ var ExternalThreadRuntime = class {
   get(threadId2) {
     return this.#threads.get(threadId2);
   }
+  #detach(threadId2) {
+    const thread = this.#threads.get(threadId2);
+    this.#threads.delete(threadId2);
+    if (!thread || thread.steeredTurnIds.size === 0) this.#steeredTurnIds.delete(threadId2);
+  }
   values() {
     return [...this.#threads.values()];
   }
   remove(threadId2) {
     this.#threads.delete(threadId2);
+    this.#steeredTurnIds.delete(threadId2);
   }
   clear() {
     this.#threads.clear();
+    this.#steeredTurnIds.clear();
   }
   drain() {
     return this.#lifecycle.drain();
@@ -32446,6 +32648,11 @@ var ExternalThreadRuntime = class {
       ...effectivePermissionModeId ? { effectivePermissionModeId } : {}
     };
     const running = this.#subagentRunning(input.record.hostThreadId);
+    let steeredTurnIds = this.#steeredTurnIds.get(input.record.hostThreadId);
+    if (!steeredTurnIds) {
+      steeredTurnIds = /* @__PURE__ */ new Set();
+      this.#steeredTurnIds.set(input.record.hostThreadId, steeredTurnIds);
+    }
     const externalThread = {
       id: input.record.hostThreadId,
       cwd: input.record.cwd,
@@ -32470,11 +32677,13 @@ var ExternalThreadRuntime = class {
       usageTurnId: null,
       projectedTurns: /* @__PURE__ */ new Map(),
       responseGates: /* @__PURE__ */ new Map(),
+      pendingSteerProjections: /* @__PURE__ */ new Set(),
       ephemeralTurnIds: /* @__PURE__ */ new Set(),
       persistenceError: null,
       projectedTerminalTurnId: null,
       ignoredInteractionIds: /* @__PURE__ */ new Set(),
-      sessionUnavailable: false
+      sessionUnavailable: false,
+      steeredTurnIds
     };
     this.idleRelease.touch(externalThread);
     externalThread.outputTask = this.#consumeOutputs(externalThread);
@@ -32531,13 +32740,13 @@ var ExternalThreadRuntime = class {
       const retire = async () => {
         if (this.#threads.get(parentId) !== parent || this.#threads.get(child.id) !== child) return;
         if (bestEffort) {
-          this.#threads.delete(child.id);
+          this.remove(child.id);
           await child.session.close();
           await child.outputTask;
         } else {
           child.sessionUnavailable = true;
           await this.#lifecycle.release(child.id, child.session, child.outputTask);
-          if (this.#threads.get(child.id) === child) this.#threads.delete(child.id);
+          if (this.#threads.get(child.id) === child) this.remove(child.id);
         }
       };
       if (bestEffort) await retire().catch(this.#diagnose);
@@ -32910,6 +33119,71 @@ var ExternalThreadRuntime = class {
 };
 
 // packages/host-runtime/src/external-turn-steering.ts
+import { randomUUID as randomUUID12 } from "node:crypto";
+
+// packages/host-runtime/src/external-command-routing.ts
+var ExternalCommandError = class extends Error {
+  constructor(code, message2) {
+    super(message2);
+    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 {
+    descriptor: matched,
+    ...argumentText.length > 0 ? { arguments: { text: argumentText } } : {}
+  };
+}
+
+// packages/host-runtime/src/external-turn-steering.ts
+function isHarnessCommand(thread, text) {
+  return thread.session.commands !== void 0 && isExternalCommandCandidate(restoreHarnessCommandMentions(text));
+}
+function externalSteeringDelivery(thread, text) {
+  if (text !== void 0 && isHarnessCommand(thread, text)) return "newTurn";
+  if (thread.session.readCapabilities) {
+    return thread.session.readCapabilities().then((capabilities) => capabilities.steer === true ? "activeTurn" : "newTurn");
+  }
+  return thread.session.capabilities.steer === true ? "activeTurn" : "newTurn";
+}
 var ExternalSteerError = class extends Error {
   constructor(code, message2) {
     super(message2);
@@ -32917,6 +33191,11 @@ var ExternalSteerError = class extends Error {
   }
   code;
 };
+var ExternalSteerNotTakenError = class extends ExternalSteerError {
+  constructor(message2) {
+    super(-32074, message2);
+  }
+};
 function parseInput(params) {
   if (typeof params.expectedTurnId !== "string" || !params.expectedTurnId.trim()) {
     throw new ExternalSteerError(-32602, "External steering requires expectedTurnId");
@@ -32933,12 +33212,47 @@ function parseInput(params) {
   if (clientUserMessageId != null && (typeof clientUserMessageId !== "string" || !clientUserMessageId.trim())) {
     throw new ExternalSteerError(-32602, "External steering message identity is invalid");
   }
+  const delivery = params[THREAD_STEER_DELIVERY_PARAM];
+  const parsedDelivery = delivery == null ? void 0 : threadSteerDeliverySchema.safeParse(delivery);
+  if (parsedDelivery && !parsedDelivery.success) {
+    throw new ExternalSteerError(-32602, "External steering delivery is invalid");
+  }
   return {
     expectedTurnId: params.expectedTurnId,
     text,
-    ...typeof clientUserMessageId === "string" ? { clientUserMessageId } : {}
+    ...typeof clientUserMessageId === "string" ? { clientUserMessageId } : {},
+    ...parsedDelivery ? { delivery: parsedDelivery.data } : {}
   };
 }
+async function insertNativeSteer(thread, input, host) {
+  const restored = restoreHarnessCommandMentions(input.text);
+  const steered = [{ type: "text", text: rewriteDelegationMentionText(restored) }];
+  const displayed = [{ type: "text", text: restored }];
+  const projectionDone = Promise.withResolvers();
+  thread.pendingSteerProjections.add(projectionDone.promise);
+  try {
+    const result = await thread.session.execute({
+      type: "turn.steer",
+      turnId: input.turnId,
+      input: steered
+    });
+    if (!result.ok) throw new ExternalSteerNotTakenError(result.error.message);
+    thread.steeredTurnIds.add(input.turnId);
+    const item = {
+      type: "userMessage",
+      itemId: hostItemIdSchema.parse(randomUUID12()),
+      input: displayed
+    };
+    try {
+      await host.project(input.turnId, item, input.clientUserMessageId);
+    } catch (error51) {
+      host.diagnose(error51);
+    }
+  } finally {
+    projectionDone.resolve(void 0);
+    thread.pendingSteerProjections.delete(projectionDone.promise);
+  }
+}
 var ExternalTurnSteering = class {
   constructor(timeoutMs = 2e4) {
     this.timeoutMs = timeoutMs;
@@ -32950,7 +33264,7 @@ var ExternalTurnSteering = class {
   hasPending(threadId2) {
     return threadId2 === void 0 ? this.#pending.size > 0 : this.#pending.has(threadId2);
   }
-  run(thread, params, start) {
+  run(thread, params, start, insert) {
     try {
       const input = parseInput(params);
       if (this.#closed)
@@ -32972,7 +33286,7 @@ var ExternalTurnSteering = class {
       if (!thread.running || thread.activeTurnId !== input.expectedTurnId) {
         throw new ExternalSteerError(-32074, "External steering must reference the active Turn");
       }
-      const result = this.#replace(thread, input, start);
+      const result = this.#deliver(thread, input, start, insert);
       if (key) {
         const receipt2 = { fingerprint, result, settled: false };
         this.#receipts.set(key, receipt2);
@@ -32995,6 +33309,56 @@ var ExternalTurnSteering = class {
       return Promise.reject(error51);
     }
   }
+  /**
+   * A Renderer that already presented a delivery gets exactly that one. Otherwise native delivery
+   * is tried only when the Session can take the input now, and input the Harness did not take
+   * falls back to stopping and restarting, so no case is worse than the stop-then-start path.
+   */
+  #deliver(thread, input, start, insert) {
+    const delivery = input.delivery === "newTurn" || isHarnessCommand(thread, input.text) ? "newTurn" : input.delivery ?? externalSteeringDelivery(thread);
+    const deliver = (mode) => {
+      if (this.#closed || !thread.running || thread.activeTurnId !== input.expectedTurnId) {
+        throw new ExternalSteerError(-32074, "External steering target is no longer active");
+      }
+      if (this.hasPending(thread.id))
+        throw new ExternalSteerError(-32072, "External Thread is already changing direction");
+      if (mode === "newTurn") return this.#replace(thread, input, start);
+      const native = insert({
+        turnId: thread.activeTurnId,
+        text: input.text,
+        ...input.clientUserMessageId ? { clientUserMessageId: input.clientUserMessageId } : {}
+      }).then((admitted) => ({ ...admitted, delivery: "activeTurn" }));
+      if (input.delivery === "activeTurn") return native;
+      return native.catch(async (error51) => {
+        if (!(error51 instanceof ExternalSteerNotTakenError)) throw error51;
+        if (thread.running || thread.activeTurnId) return deliver("newTurn");
+        const assertActive = () => {
+          if (this.#closed)
+            throw new ExternalSteerError(-32074, "External steering connection is closed");
+        };
+        return { ...await start(input.text, assertActive), delivery: "newTurn" };
+      });
+    };
+    if (typeof delivery === "string") return deliver(delivery);
+    const failure = Promise.withResolvers();
+    let failureReason = null;
+    const pending = {
+      turnId: input.expectedTurnId,
+      resolve: () => void 0,
+      reject(error51) {
+        failureReason ??= error51;
+        failure.reject(error51);
+      }
+    };
+    this.#pending.set(thread.id, pending);
+    return Promise.race([delivery, failure.promise]).then((mode) => {
+      if (failureReason) throw failureReason;
+      if (this.#pending.get(thread.id) === pending) this.#pending.delete(thread.id);
+      return deliver(mode);
+    }).finally(() => {
+      if (this.#pending.get(thread.id) === pending) this.#pending.delete(thread.id);
+    });
+  }
   terminal(threadId2, turnId, outcome) {
     const pending = this.#pending.get(threadId2);
     if (pending?.turnId === turnId) pending.resolve(outcome);
@@ -33049,7 +33413,9 @@ var ExternalTurnSteering = class {
         thread.session.execute({ type: "turn.cancel", turnId }),
         failure.promise
       ]);
-      if (!cancelled.ok) throw new ExternalSteerError(-32074, cancelled.error.message);
+      if (!cancelled.ok && cancelled.error.code !== "invalidState") {
+        throw new ExternalSteerError(-32074, cancelled.error.message);
+      }
       const outcome = await Promise.race([terminal3.promise, failure.promise]);
       clearTimeout(timeout);
       const assertActive = () => {
@@ -33067,7 +33433,7 @@ var ExternalTurnSteering = class {
       if (thread.running || thread.activeTurnId) {
         throw new ExternalSteerError(-32072, "Another External Turn started before replacement");
       }
-      return await start(input.text, assertActive);
+      return { ...await start(input.text, assertActive), delivery: "newTurn" };
     } finally {
       clearTimeout(timeout);
       if (this.#pending.get(thread.id) === pending) this.#pending.delete(thread.id);
@@ -33075,58 +33441,6 @@ var ExternalTurnSteering = class {
   }
 };
 
-// packages/host-runtime/src/external-command-routing.ts
-var ExternalCommandError = class extends Error {
-  constructor(code, message2) {
-    super(message2);
-    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 {
-    descriptor: matched,
-    ...argumentText.length > 0 ? { arguments: { text: argumentText } } : {}
-  };
-}
-
 // packages/host-runtime/src/live-command-catalog-cache.ts
 import path23 from "node:path";
 var MAX_ENTRIES = 64;
@@ -33158,7 +33472,7 @@ function sameWorkspace(left, right) {
 }
 
 // packages/host-runtime/src/harness-delegation-coordinator.ts
-import { createHash as createHash8, randomUUID as randomUUID11 } from "node:crypto";
+import { createHash as createHash8, randomUUID as randomUUID13 } from "node:crypto";
 import path24 from "node:path";
 
 // packages/host-runtime/src/delegation-snapshot.ts
@@ -33304,6 +33618,15 @@ function projectDelegationThreadSnapshot(input) {
 // packages/host-runtime/src/harness-delegation-coordinator.ts
 var IMPLICIT_DEDUPLICATION_MS = 3e4;
 var NATIVE_REF_TIMEOUT_MS = 1e4;
+function truncateTitle(value2, length) {
+  return value2.slice(0, length).replace(/[\uD800-\uDBFF]$/u, "");
+}
+function delegationTitle(parentTitle, input) {
+  const taskName = (input.taskName ?? input.task.trim().split(/\r?\n/u)[0] ?? input.task).replace(/\s+/gu, " ").trim();
+  const subtask = truncateTitle(taskName, 120);
+  const parent = (parentTitle?.trim() || "Untitled Thread").replace(/\s+/gu, " ");
+  return `${subtask} · ${truncateTitle(parent, 200 - subtask.length - 3)}`;
+}
 function delay3(milliseconds) {
   return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
@@ -33330,6 +33653,12 @@ function statusFromThread(thread, busy) {
 function validateStart(input) {
   if (typeof input.task !== "string" || !input.task.trim())
     throw new DelegationControlError("INVALID_ARGUMENT", "Task must not be empty");
+  if (input.taskName !== void 0 && (typeof input.taskName !== "string" || !input.taskName.trim() || input.taskName.length > 120)) {
+    throw new DelegationControlError(
+      "INVALID_ARGUMENT",
+      "Task name must contain 1 to 120 characters"
+    );
+  }
   if (input.cwd !== void 0 && (typeof input.cwd !== "string" || !input.cwd.trim()))
     throw new DelegationControlError("INVALID_ARGUMENT", "cwd must not be empty");
   if (input.requestId !== void 0 && (typeof input.requestId !== "string" || !input.requestId.trim())) {
@@ -33350,7 +33679,7 @@ var HarnessDelegationCoordinator = class {
   #cancelOfficial;
   #startOfficial;
   #listOfficial;
-  #officialThreadCwd;
+  #officialThreadMetadata;
   #activeOfficialParents;
   #externalThreadBusy;
   constructor(input) {
@@ -33367,7 +33696,7 @@ var HarnessDelegationCoordinator = class {
     this.#cancelOfficial = input.cancelOfficial;
     this.#startOfficial = input.startOfficial;
     this.#listOfficial = input.listOfficial;
-    this.#officialThreadCwd = input.officialThreadCwd;
+    this.#officialThreadMetadata = input.officialThreadMetadata;
     this.#activeOfficialParents = input.activeOfficialParents;
     this.#externalThreadBusy = input.externalThreadBusy;
   }
@@ -33397,8 +33726,14 @@ var HarnessDelegationCoordinator = class {
     const parentThreadId = await this.#resolveParent(input.parentThreadId);
     const parent = await this.#parentMetadata(parentThreadId);
     const selectedCwd = input.cwd ?? parent.cwd ?? process.cwd();
+    const title = delegationTitle(parent.title, input);
     if (input.harnessId === "codex") {
-      const result = await this.#startOfficial({ ...input, parentThreadId, cwd: selectedCwd });
+      const result = await this.#startOfficial({
+        ...input,
+        parentThreadId,
+        cwd: selectedCwd,
+        title
+      });
       return { ...result, parentThreadId, cwd: result.cwd ?? selectedCwd };
     }
     const startInput = { ...input, parentThreadId, cwd: path24.resolve(selectedCwd) };
@@ -33441,17 +33776,17 @@ var HarnessDelegationCoordinator = class {
       });
       this.#validateConfiguration(inspected.inspection, input.model, input.thinkingOptionId);
     }
-    const delegationId = hostThreadIdSchema.parse(randomUUID11());
-    const childThreadId = hostThreadIdSchema.parse(randomUUID11());
-    const turnId = hostTurnIdSchema.parse(randomUUID11());
-    const createRequestId = input.requestId ? `delegation:${input.requestId}` : randomUUID11();
+    const delegationId = hostThreadIdSchema.parse(randomUUID13());
+    const childThreadId = hostThreadIdSchema.parse(randomUUID13());
+    const turnId = hostTurnIdSchema.parse(randomUUID13());
+    const createRequestId = input.requestId ? `delegation:${input.requestId}` : randomUUID13();
     let record4 = await this.#repository.createProvisional(
       createExternalThreadRecordInput({
         hostThreadId: childThreadId,
         createRequestId,
         harnessId: harnessIdSchema.parse(targetHarnessId),
         cwd: startInput.cwd,
-        title: input.task.trim().slice(0, 120),
+        title,
         transportModelId: input.model || input.thinkingOptionId ? encodeExternalTransportSelection(targetHarnessId, {
           ...input.model ? { model: input.model } : {},
           ...input.thinkingOptionId ? { thinkingOptionId: input.thinkingOptionId } : {}
@@ -33598,7 +33933,7 @@ var HarnessDelegationCoordinator = class {
     if (this.#externalThreadBusy(thread) || thread.activeTurnId) {
       throw new DelegationControlError("THREAD_BUSY", "Thread already has an active Turn");
     }
-    const turnId = hostTurnIdSchema.parse(randomUUID11());
+    const turnId = hostTurnIdSchema.parse(randomUUID13());
     try {
       await this.#startExternalTurn(thread, input.message, turnId);
     } catch (error51) {
@@ -33812,9 +34147,14 @@ var HarnessDelegationCoordinator = class {
   }
   async #parentMetadata(parentThreadId) {
     const record4 = await this.#repository.find(parentThreadId);
-    if (record4) return { harnessId: record4.harnessId, cwd: record4.cwd };
-    const cwd = await this.#officialThreadCwd(parentThreadId).catch(() => void 0);
-    return { harnessId: "codex", ...cwd ? { cwd } : {} };
+    if (record4)
+      return {
+        harnessId: record4.harnessId,
+        cwd: record4.cwd,
+        title: record4.title
+      };
+    const metadata = await this.#officialThreadMetadata(parentThreadId).catch(() => ({}));
+    return { harnessId: "codex", ...metadata };
   }
   async #existingResult(delegation) {
     const record4 = await this.#repository.find(delegation.childHostThreadId);
@@ -36243,10 +36583,10 @@ var SingleNativeCodexAccount = class {
 };
 
 // packages/host-runtime/src/codex-runtime/official-runtime-owner.ts
-import { randomUUID as randomUUID13 } from "node:crypto";
+import { randomUUID as randomUUID15 } from "node:crypto";
 
 // packages/host-runtime/src/official-request-broker.ts
-import { randomUUID as randomUUID12 } from "node:crypto";
+import { randomUUID as randomUUID14 } from "node:crypto";
 var INTERNAL_REQUEST_PREFIX = "codexhost:official:";
 var MAX_RETIRED_IDS = 1024;
 function isRecord15(value2) {
@@ -36262,7 +36602,7 @@ var OfficialRequestBroker = class {
   constructor(input) {
     this.#send = input.send;
     this.#timeoutMs = input.timeoutMs ?? 3e4;
-    this.#nextId = input.nextId ?? (() => `${INTERNAL_REQUEST_PREFIX}${randomUUID12()}`);
+    this.#nextId = input.nextId ?? (() => `${INTERNAL_REQUEST_PREFIX}${randomUUID14()}`);
   }
   get pendingCount() {
     return this.#pending.size;
@@ -36616,7 +36956,7 @@ var OfficialRuntimeOwner = class {
   }
   #attach(role, output, onBackendStopped) {
     const client = {
-      id: randomUUID13(),
+      id: randomUUID15(),
       role,
       output,
       ...onBackendStopped ? { onBackendStopped } : {},
@@ -36774,7 +37114,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}:${randomUUID13()}`;
+        const id2 = `codexhost:server:${client.id}:${event.generation}:${randomUUID15()}`;
         client.serverRequests.set(id2, value2.id);
         const projected = { ...value2, id: id2 };
         return client.output({
@@ -36950,16 +37290,16 @@ var OfficialRuntimeScope = class {
   #scheduleRecovery() {
     if (!this.#recovery || this.#closed || this.#recoveryTimer || this.#starting) return;
     const { delaysMs } = this.#recovery;
-    const delay6 = delaysMs[Math.min(this.#recoveryAttempt, delaysMs.length - 1)] ?? 0;
+    const delay7 = delaysMs[Math.min(this.#recoveryAttempt, delaysMs.length - 1)] ?? 0;
     this.#recoveryAttempt++;
     this.#diagnosticOutput.write(
-      `codexhost: official Codex is unavailable; restarting in ${String(delay6)}ms
+      `codexhost: official Codex is unavailable; restarting in ${String(delay7)}ms
 `
     );
     const timer = setTimeout(() => {
       this.#recoveryTimer = void 0;
       this.start().catch(() => void 0);
-    }, delay6);
+    }, delay7);
     timer.unref();
     this.#recoveryTimer = timer;
   }
@@ -38054,6 +38394,7 @@ var AppServerHost = class {
   #plugins;
   #launchSettings;
   #accountInspections = new HarnessAccountInspectionCache();
+  #installationTasks = new HarnessInstallationTasks();
   #externalRuntime;
   #executionHosts = /* @__PURE__ */ new WeakMap();
   #externalPrewarms = new ExternalThreadPrewarms();
@@ -38084,7 +38425,7 @@ var AppServerHost = class {
   #sectionMoves = Promise.resolve();
   #writer;
   /** Console requests share Desktop handling; their replies return to the console. */
-  #consoleRequestPrefix = `codexhost-console:${randomUUID14()}:`;
+  #consoleRequestPrefix = `codexhost-console:${randomUUID16()}:`;
   #consoleReplies = /* @__PURE__ */ new Map();
   #nextConsoleRequest = 0;
   #subagentThreadStatuses = /* @__PURE__ */ new Map();
@@ -38222,7 +38563,7 @@ var AppServerHost = class {
       cancelOfficial: (input) => this.#cancelOfficialDelegationThread(input),
       startOfficial: (input) => this.#startOfficialDelegation(input),
       listOfficial: (input) => this.#listDelegationThreads(input),
-      officialThreadCwd: (threadId2) => this.#readOfficialThreadCwd(threadId2),
+      officialThreadMetadata: (threadId2) => this.#readOfficialThreadMetadata(threadId2),
       activeOfficialParents: () => [...this.#activeOfficialTurns.keys()],
       externalThreadBusy: (thread) => this.#externalThreadBusy(thread)
     });
@@ -38868,11 +39209,11 @@ var AppServerHost = class {
       this.#dispatchDesktopReply(request, () => this.#inspectHarness(request));
       return;
     }
-    if (request.method === HARNESS_INSTALLATION_METHOD) {
+    if (request.method === HARNESS_INSTALLATION_METHOD || request.method === HARNESS_INSTALLATION_START_METHOD || request.method === HARNESS_INSTALLATION_STATUS_METHOD) {
       this.#dispatchDesktopReply(request, async () => {
-        await this.#waitForPlugins();
         try {
-          const result = await handleHarnessInstallation(request.params, this.#externalAdapters);
+          if (request.method !== HARNESS_INSTALLATION_STATUS_METHOD) await this.#waitForPlugins();
+          const result = request.method === HARNESS_INSTALLATION_START_METHOD ? this.#installationTasks.start(request.params, this.#externalAdapters) : request.method === HARNESS_INSTALLATION_STATUS_METHOD ? this.#installationTasks.status(request.params) : await handleHarnessInstallation(request.params, this.#externalAdapters);
           await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(result) }));
         } catch (error51) {
           await this.#writer.json(
@@ -38957,6 +39298,10 @@ var AppServerHost = class {
       await this.#listThreadOwnership(request);
       return;
     }
+    if (request.method === "codexhost/thread/steering/inspect") {
+      await this.#inspectThreadSteering(request);
+      return;
+    }
     if (request.method === "codexhost/thread/model/select") {
       await this.#selectThreadModel(request);
       return;
@@ -39534,12 +39879,17 @@ var AppServerHost = class {
     ]);
     return thread !== null || childDelegation !== null || delegation !== null;
   }
-  async #readOfficialThreadCwd(threadId2) {
-    const response = await this.#requestOfficial("thread/read", { threadId: threadId2 });
-    if (isRecord18(response.error)) return void 0;
+  async #readOfficialThreadMetadata(threadId2) {
+    const response = await this.#requestOfficial("thread/read", { threadId: threadId2, includeTurns: false });
+    if (isRecord18(response.error)) return {};
     const result = isRecord18(response.result) ? response.result : null;
     const thread = result && isRecord18(result.thread) ? result.thread : null;
-    return thread && typeof thread.cwd === "string" && thread.cwd.trim() ? thread.cwd : void 0;
+    if (!thread) return {};
+    const title = typeof thread.name === "string" && thread.name.trim() ? thread.name : thread.preview;
+    return {
+      ...typeof thread.cwd === "string" && thread.cwd.trim() ? { cwd: thread.cwd } : {},
+      ...typeof title === "string" && title.trim() ? { title } : {}
+    };
   }
   async #inspectOfficialDelegationTarget(input) {
     const response = await this.#requestOfficial("model/list", {});
@@ -39692,6 +40042,9 @@ var AppServerHost = class {
     this.#pendingOfficialDelegationThreads.add(threadId2);
     let turnId;
     try {
+      await this.#requestOfficial("thread/name/set", { threadId: threadId2, name: input.title }).catch(
+        () => void 0
+      );
       const turn = await this.#requestOfficial("turn/start", {
         threadId: threadId2,
         input: [{ type: "text", text: input.task }],
@@ -39710,7 +40063,7 @@ var AppServerHost = class {
       throw error51;
     }
     this.#activeOfficialTurns.set(threadId2, turnId);
-    const delegationId = hostThreadIdSchema.parse(randomUUID14());
+    const delegationId = hostThreadIdSchema.parse(randomUUID16());
     try {
       const source = await this.#repository.find(input.parentThreadId);
       const pendingTerminal = this.#pendingOfficialTerminalStatuses.get(threadId2);
@@ -39898,7 +40251,7 @@ var AppServerHost = class {
   async #listDelegationThreads(input) {
     const [sortKey, sortDirection2] = input.sort.split("-");
     const request = {
-      id: `codexhost:delegation-list:${randomUUID14()}`,
+      id: `codexhost:delegation-list:${randomUUID16()}`,
       method: "thread/list",
       params: {
         cwd: input.cwd ? [input.cwd] : null,
@@ -40247,7 +40600,8 @@ var AppServerHost = class {
     try {
       inspection = await adapter.inspect({
         ...params.data.cwd ? { cwd: params.data.cwd } : {},
-        ...params.data.refresh !== void 0 ? { refresh: params.data.refresh } : {}
+        ...params.data.refresh !== void 0 ? { refresh: params.data.refresh } : {},
+        ...params.data.purpose ? { purpose: params.data.purpose } : {}
       });
     } catch (error51) {
       await this.#writer.json(
@@ -40440,6 +40794,28 @@ var AppServerHost = class {
       );
     }
   }
+  /** Read the same delivery decision that Desktop `turn/steer` will follow. */
+  async #inspectThreadSteering(request) {
+    const params = threadSteeringInspectParamsSchema.safeParse(request.params);
+    if (!params.success) {
+      await this.#writer.json(rpcError(request, -32602, "Invalid Thread steering params"));
+      return;
+    }
+    let delivery;
+    try {
+      const location = await this.#locateExternalThread(params.data.threadId);
+      if (await this.#writeResolutionError(request, location)) return;
+      const thread = location.kind === "external" ? this.#externalRuntime.get(params.data.threadId) : void 0;
+      delivery = location.kind !== "external" ? "official" : thread ? await externalSteeringDelivery(thread, params.data.text) : "newTurn";
+    } catch {
+      await this.#writer.json(
+        rpcError(request, -32081, "Thread steering metadata could not be read")
+      );
+      return;
+    }
+    const result = threadSteeringInspectResultSchema.parse({ delivery });
+    await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(result) }));
+  }
   async #inspectThreadCommands(request) {
     const params = threadCommandsInspectParamsSchema.safeParse(request.params);
     if (!params.success) {
@@ -40603,7 +40979,7 @@ var AppServerHost = class {
     if (thread.running || thread.activeTurnId) {
       throw new ExternalCommandError(-32072, "External Thread already has an active operation");
     }
-    const turnId = requestedTurnId ?? hostTurnIdSchema.parse(randomUUID14());
+    const turnId = requestedTurnId ?? hostTurnIdSchema.parse(randomUUID16());
     const projection = {
       projector: new CodexTurnProjector({
         threadId: thread.id,
@@ -40691,6 +41067,26 @@ var AppServerHost = class {
       if (!projected.effectiveModel) {
         throw new Error("Harness Session did not report an effective Model");
       }
+      const transportModelId = encodeExternalTransportSelection(thread.harnessId, {
+        ...decodeExternalTransportSelection(thread.harnessId, thread.transportModelId) ?? {},
+        model: projected.effectiveModel
+      });
+      thread.transportModelId = transportModelId;
+      thread.requestedModel = projected.effectiveModel;
+      try {
+        thread.record = await this.#repository.setTransportModelId(
+          thread.record.hostThreadId,
+          transportModelId
+        );
+      } catch (error51) {
+        this.#diagnose(error51);
+      }
+      thread.thread = externalThreadValue({
+        record: { ...thread.record, transportModelId },
+        turns: thread.turns,
+        sessionId: thread.sessionId,
+        running: thread.running
+      });
       await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(projected) }));
     } catch (error51) {
       await this.#writer.json(
@@ -41020,9 +41416,20 @@ var AppServerHost = class {
     await this.#writer.json(rpcError(request, resolution.error.code, resolution.error.message));
     return true;
   }
+  /** Refresh history before Desktop acts on native Turn boundaries. */
   #refreshExternalThread(thread) {
     return this.#externalRuntime.refresh(thread);
   }
+  #markExternalHistoryRead(thread, turns) {
+    if (!thread.historyHydrated) return;
+    for (const turnId of thread.steeredTurnIds) {
+      if (turnId !== thread.activeTurnId && turns.some(
+        (turn) => turn.id === turnId && (turn.status === "completed" || turn.status === "failed" || turn.status === "interrupted")
+      )) {
+        thread.steeredTurnIds.delete(turnId);
+      }
+    }
+  }
   #persistTerminalIdentity(thread, event) {
     return this.#externalRuntime.persistTerminalIdentity(thread, event);
   }
@@ -41224,17 +41631,19 @@ var AppServerHost = class {
         return;
       }
     }
+    const readTurns = includeTurns ? [...this.#externalHistoryTurns(thread)] : [];
     await this.#writer.json(
       rpcEnvelope(request, {
         result: {
           thread: {
             ...thread.thread,
             ...await this.#externalSectionFields(thread.record.hostThreadId),
-            turns: includeTurns ? this.#externalHistoryTurns(thread) : []
+            turns: readTurns
           }
         }
       })
     );
+    if (includeTurns) this.#markExternalHistoryRead(thread, readTurns);
     await this.#replayExternalUsage(thread);
   }
   async #listExternalHistory(request, thread, params, historyFresh) {
@@ -41251,6 +41660,9 @@ var AppServerHost = class {
       const turns = this.#externalHistoryTurns(thread);
       const result = request.method === "thread/turns/list" ? listExternalTurns(turns, params) : listExternalItems(turns, params);
       await this.#writer.json(rpcEnvelope(request, { result }));
+      if (request.method === "thread/turns/list") {
+        this.#markExternalHistoryRead(thread, result.data);
+      }
     } catch (error51) {
       await this.#writer.json(
         rpcError(
@@ -41269,7 +41681,7 @@ var AppServerHost = class {
         return;
       }
     }
-    const turns = this.#externalHistoryTurns(thread);
+    const turns = [...this.#externalHistoryTurns(thread)];
     const responseThread = {
       ...await this.#withExternalSection(thread.thread),
       turns: params.excludeTurns === true ? [] : turns
@@ -41301,6 +41713,8 @@ var AppServerHost = class {
           }
         })
       );
+      if (params.excludeTurns !== true) this.#markExternalHistoryRead(thread, turns);
+      else if (initialTurnsPage) this.#markExternalHistoryRead(thread, initialTurnsPage.data);
     } catch (error51) {
       await this.#writer.json(
         rpcError(
@@ -41443,10 +41857,15 @@ var AppServerHost = class {
           assertActive,
           typeof requestObject(request).clientUserMessageId === "string" ? requestObject(request).clientUserMessageId : void 0,
           requestObject(request)[THREAD_REFERENCE_SOURCE_HOST_PARAM]
-        )
+        ),
+        (input) => this.#insertExternalInput(thread, input)
       );
       try {
-        await this.#writer.json(rpcEnvelope(request, { result: { turnId: started.turnId } }));
+        await this.#writer.json(
+          rpcEnvelope(request, {
+            result: { turnId: started.turnId, delivery: started.delivery }
+          })
+        );
       } finally {
         started.gate.resolve();
       }
@@ -41462,6 +41881,34 @@ var AppServerHost = class {
       this.#signalActiveWorkChanged();
     }
   }
+  /** Native same-Turn input; `insertNativeSteer` owns the delivery and its fallback signal. */
+  async #insertExternalInput(thread, input) {
+    await insertNativeSteer(thread, input, {
+      project: async (turnId, item, clientUserMessageId) => {
+        const projection = this.#projectedTurn(thread, turnId);
+        if (clientUserMessageId) {
+          projection.projector.bindUserMessageClientId(item.itemId, clientUserMessageId);
+        }
+        await this.#projectHarnessOutput(thread, {
+          kind: "event",
+          event: { type: "item.started", turnId, item }
+        });
+        await this.#projectHarnessOutput(thread, {
+          kind: "event",
+          event: {
+            type: "item.completed",
+            turnId,
+            snapshot: { item, outcome: { status: "succeeded" } }
+          }
+        });
+      },
+      diagnose: (error51) => this.#diagnose(error51)
+    });
+    return {
+      turnId: input.turnId,
+      gate: { promise: Promise.resolve(), resolve: () => void 0 }
+    };
+  }
   /** Keep command restoration and dispatch identical for start and steer submissions. */
   async #beginExternalInputTurn(thread, inputText, assertActive, clientUserMessageId, sourceHostId) {
     const text = restoreHarnessCommandMentions(inputText);
@@ -41519,7 +41966,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(randomUUID14());
+    const turnId = hostTurnIdSchema.parse(randomUUID16());
     const startedAtMs = Date.now();
     const projection = {
       projector: new CodexTurnProjector({
@@ -41814,6 +42261,9 @@ var AppServerHost = class {
       }
       return;
     }
+    if (event.type === "turn.completed" && thread.pendingSteerProjections.size > 0) {
+      await Promise.allSettled([...thread.pendingSteerProjections]);
+    }
     const projection = this.#projectedTurn(thread, event.turnId);
     await this.#waitForTurnResponse(thread, event.turnId);
     if (event.type === "interaction.closed" && thread.ignoredInteractionIds.delete(event.interactionId)) {
@@ -41863,6 +42313,7 @@ var AppServerHost = class {
       thread.activeTurnId = null;
       if (!projection.projector.hasOpenDetachedItems) thread.projectedTurns.delete(event.turnId);
       thread.responseGates.delete(event.turnId);
+      thread.pendingSteerProjections.clear();
       this.#signalActiveWorkChanged();
       const delegation = await this.#repository.getDelegationByChild(thread.record.hostThreadId);
       if (delegation) {
@@ -42153,7 +42604,7 @@ var AppServerHost = class {
     try {
       result = projection.projector.projectQuestion(
         interaction,
-        hostItemIdSchema.parse(randomUUID14())
+        hostItemIdSchema.parse(randomUUID16())
       );
     } catch (error51) {
       this.#diagnose(error51);
@@ -42392,7 +42843,7 @@ 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 randomUUID15 } from "node:crypto";
+import { randomUUID as randomUUID17 } from "node:crypto";
 import { chmod as chmod3, lstat as lstat5, mkdir as mkdir12, open as open9, readFile as readFile16, readdir as readdir5, rename as rename11, rm as rm11 } from "node:fs/promises";
 import { uptime } from "node:os";
 import path26 from "node:path";
@@ -42518,7 +42969,7 @@ async function preparePrivateLockDirectory(lockDirectory) {
   await chmod3(lockDirectory, 448);
 }
 async function writeLockRecordAtomic(lockDirectory, entryPath, record4) {
-  const temporary = path26.join(lockDirectory, `.tmp-${record4.ownerToken}-${randomUUID15()}`);
+  const temporary = path26.join(lockDirectory, `.tmp-${record4.ownerToken}-${randomUUID17()}`);
   const handle = await open9(temporary, "wx", 384);
   try {
     await handle.writeFile(`${JSON.stringify(record4)}
@@ -42593,7 +43044,7 @@ async function withRemoteAppServerSocketInitializationLock(socketPath, action) {
   const legacyPath = `${socketPath}.initializing`;
   const lockDirectory = `${socketPath}.initializers`;
   await preparePrivateLockDirectory(lockDirectory);
-  const ownerToken = randomUUID15();
+  const ownerToken = randomUUID17();
   const entryPath = path26.join(lockDirectory, lockEntryName(ownerToken));
   const baseRecord = {
     version: 2,
@@ -43104,12 +43555,12 @@ function createRemoteAppServerWebSocketListener(input) {
 
 // packages/host-runtime/src/remote-official-app-server.ts
 import { spawn as spawn5 } from "node:child_process";
-import { randomUUID as randomUUID16 } from "node:crypto";
+import { randomUUID as randomUUID18 } from "node:crypto";
 import { lstat as lstat7, rm as rm13, stat as stat7 } from "node:fs/promises";
 import path28 from "node:path";
 var DEFAULT_CLOSE_TIMEOUT_MS = 2e3;
 var DEFAULT_LISTEN_TIMEOUT_MS = 1e4;
-function remoteOfficialAppServerSocketPath(desktopControlSocketPath, token = randomUUID16()) {
+function remoteOfficialAppServerSocketPath(desktopControlSocketPath, token = randomUUID18()) {
   if (!path28.posix.isAbsolute(desktopControlSocketPath)) {
     throw new Error("Desktop control socket path must be absolute");
   }
@@ -44328,11 +44779,11 @@ async function readRemoteDelegationThread(environment, input) {
 }
 
 // packages/host-runtime/src/shared-thread-owner.ts
-import { randomUUID as randomUUID18 } from "node:crypto";
+import { randomUUID as randomUUID20 } from "node:crypto";
 import { PassThrough as PassThrough3 } from "node:stream";
 
 // packages/host-runtime/src/shared-thread-peer.ts
-import { randomUUID as randomUUID17 } from "node:crypto";
+import { randomUUID as randomUUID19 } from "node:crypto";
 function object5(value2) {
   return value2 !== null && typeof value2 === "object" && !Array.isArray(value2);
 }
@@ -44346,7 +44797,7 @@ var StreamThreadPeer = class {
   input;
   output;
   stop;
-  #prefix = `shared:${randomUUID17()}:`;
+  #prefix = `shared:${randomUUID19()}:`;
   #pending = /* @__PURE__ */ new Map();
   #listeners = /* @__PURE__ */ new Set();
   #ended = Promise.withResolvers();
@@ -44424,7 +44875,7 @@ var SharedThreadOwner = class {
   input = new PassThrough3();
   output = new PassThrough3();
   #peer = new StreamThreadPeer(this.output, this.input, () => this.input.end());
-  #prefix = `shared-interaction:${randomUUID18()}:`;
+  #prefix = `shared-interaction:${randomUUID20()}:`;
   #interactions = /* @__PURE__ */ new Map();
   #listeners = /* @__PURE__ */ new Set();
   #receipts = /* @__PURE__ */ new Map();
@@ -44734,7 +45185,7 @@ var SharedThreadBridge = class {
 };
 
 // packages/host-runtime/src/remote-control-app-server.ts
-import { randomUUID as randomUUID19 } from "node:crypto";
+import { randomUUID as randomUUID21 } from "node:crypto";
 import { mkdir as mkdir15, open as open10, rename as rename12, rm as rm14 } from "node:fs/promises";
 import path33 from "node:path";
 var REMOTE_CONTROL_BRIDGE_PIPE_ENV = "CODEXHOST_REMOTE_CONTROL_BRIDGE_PIPE";
@@ -44755,7 +45206,7 @@ function nodeCompatibleWindowsPath(value2) {
   if (value2.startsWith("\\\\?\\")) return value2.slice(4);
   return value2;
 }
-function remoteControlBridgePipePath(processId = process.pid, instanceId = randomUUID19()) {
+function remoteControlBridgePipePath(processId = process.pid, instanceId = randomUUID21()) {
   const safeInstance = instanceId.replaceAll(/[^a-zA-Z0-9-]/gu, "");
   if (!safeInstance) throw new Error("Remote Control bridge instance ID is invalid");
   return `\\\\.\\pipe\\codexhost-remote-control-${processId}-${safeInstance}`;
@@ -44770,7 +45221,7 @@ async function publishRemoteControlAppServerDescriptor(plan) {
   await mkdir15(directory, { recursive: true, mode: 448 });
   const temporaryPath = path33.join(
     directory,
-    `.${REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE}.${plan.descriptor.ownerPid}.${randomUUID19()}.tmp`
+    `.${REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE}.${plan.descriptor.ownerPid}.${randomUUID21()}.tmp`
   );
   const handle = await open10(temporaryPath, "wx", 384);
   try {
@@ -45292,12 +45743,19 @@ function createHostUpdateCoordinator(options2) {
 }
 
 // packages/host-runtime/src/usage-statistics.ts
-import { randomUUID as randomUUID20 } from "node:crypto";
+import { randomUUID as randomUUID22 } from "node:crypto";
 import { mkdir as mkdir17, readFile as readFile17, readdir as readdir6, rename as rename14, rm as rm16, writeFile as writeFile10 } from "node:fs/promises";
 import path36 from "node:path";
 import { setImmediate as yieldToEventLoop } from "node:timers/promises";
 
 // packages/harness-adapter/dist/usage-statistics.js
+var HarnessUsageSourceChangedError = class extends Error {
+  code = "HARNESS_USAGE_SOURCE_CHANGED";
+  /** Plugins may bundle their own copy of this contract, so instanceof is insufficient. */
+  static is(error51) {
+    return typeof error51 === "object" && error51 !== null && "code" in error51 && error51.code === "HARNESS_USAGE_SOURCE_CHANGED";
+  }
+};
 var MAX_SESSION_ID_LENGTH = 512;
 var MAX_CWD_LENGTH = 4096;
 var MAX_SESSION_TITLE_LENGTH = 200;
@@ -45309,10 +45767,13 @@ function usageSessionTitle(value2) {
     return void 0;
   if (normalized.length <= MAX_SESSION_TITLE_LENGTH)
     return normalized;
-  const characters = [...normalized];
-  if (characters.length <= MAX_SESSION_TITLE_LENGTH)
-    return normalized;
-  return `${characters.slice(0, MAX_SESSION_TITLE_LENGTH - 1).join("").trimEnd()}…`;
+  let title = "";
+  for (const character of normalized) {
+    if (title.length + character.length >= MAX_SESSION_TITLE_LENGTH)
+      break;
+    title += character;
+  }
+  return `${title.trimEnd()}…`;
 }
 function sessionIdOk(value2) {
   return typeof value2 === "string" && value2.length > 0 && value2.length <= MAX_SESSION_ID_LENGTH;
@@ -45397,6 +45858,95 @@ function withHostSessionTitles(result, records) {
   };
 }
 
+// packages/host-runtime/src/usage-statistics-sources.ts
+import { setTimeout as delay6 } from "node:timers/promises";
+async function* readUsageStatisticsSources(capability, sources, signal) {
+  let pending = sources;
+  for (let attempt = 0; ; attempt++) {
+    const changed = [];
+    for (const source of pending) {
+      signal.throwIfAborted();
+      try {
+        const entries = (await capability.readSource(source.id, signal)).map(parseHarnessUsageEntry).filter((entry) => entry !== null);
+        yield { source, entries };
+      } catch (error51) {
+        signal.throwIfAborted();
+        if (HarnessUsageSourceChangedError.is(error51) && attempt < 2) changed.push(source);
+        else yield { source, error: error51 };
+      }
+    }
+    if (!changed.length) return;
+    await delay6(50 * (attempt + 1), void 0, { signal });
+    let current;
+    try {
+      current = new Map(
+        (await capability.listSources(signal)).map((source) => [source.id, source])
+      );
+    } catch (error51) {
+      signal.throwIfAborted();
+      for (const source of changed) yield { source, error: error51 };
+      return;
+    }
+    const next = [];
+    for (const source of changed) {
+      const fresh = current.get(source.id);
+      if (fresh) next.push(fresh);
+      else yield { source, removed: true };
+    }
+    pending = next;
+  }
+}
+
+// packages/host-runtime/src/usage-statistics-calendar.ts
+function dateKey(year, month, day) {
+  return `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+}
+function createUsageStatisticsCalendar(timeZone) {
+  const localZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const zone = timeZone ?? localZone;
+  if (zone === localZone) {
+    return {
+      timeZone: zone,
+      at(ms) {
+        const date5 = new Date(ms);
+        return {
+          date: dateKey(date5.getFullYear(), date5.getMonth() + 1, date5.getDate()),
+          weekday: date5.getDay(),
+          hour: date5.getHours()
+        };
+      }
+    };
+  }
+  const format = new Intl.DateTimeFormat("en-US", {
+    timeZone: zone,
+    calendar: "gregory",
+    numberingSystem: "latn",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    hourCycle: "h23"
+  });
+  return {
+    timeZone: zone,
+    at(ms) {
+      const parts = format.formatToParts(ms);
+      const part = (type) => Number(parts.find((value2) => value2.type === type)?.value);
+      const year = part("year"), month = part("month"), day = part("day");
+      return {
+        date: dateKey(year, month, day),
+        weekday: new Date(Date.UTC(year, month - 1, day)).getUTCDay(),
+        hour: part("hour")
+      };
+    }
+  };
+}
+function shiftUsageDate(date5, days) {
+  const value2 = /* @__PURE__ */ new Date(`${date5}T12:00:00Z`);
+  value2.setUTCDate(value2.getUTCDate() + days);
+  return dateKey(value2.getUTCFullYear(), value2.getUTCMonth() + 1, value2.getUTCDate());
+}
+
 // packages/host-runtime/src/usage-statistics.ts
 var CACHE_VERSION = 7;
 var STALE_AFTER_MS = 1e4;
@@ -45457,17 +46007,6 @@ function expand(value2, intern) {
 function message(error51) {
   return error51 instanceof Error ? error51.message : String(error51);
 }
-function localDate2(ms) {
-  const date5 = new Date(ms);
-  const month = String(date5.getMonth() + 1).padStart(2, "0");
-  const day = String(date5.getDate()).padStart(2, "0");
-  return `${date5.getFullYear()}-${month}-${day}`;
-}
-function shiftDate(date5, days) {
-  const value2 = /* @__PURE__ */ new Date(`${date5}T12:00:00`);
-  value2.setDate(value2.getDate() + days);
-  return localDate2(value2.getTime());
-}
 var SESSIONS_PER_MEASURE = 50;
 var MODELS_PER_SESSION = 16;
 function emptyTotals() {
@@ -45654,23 +46193,27 @@ var UsageStatistics = class {
     }
     for (const { harness: harness2, capability, ids } of listed) {
       const cache = this.#cache(harness2);
-      const present = /* @__PURE__ */ new Set();
+      const present = new Set(ids.map(({ id: id2 }) => id2));
       let failed = null;
-      for (const { id: id2, fingerprint } of ids) {
-        present.add(id2);
-        if (cache.sources.get(id2)?.fingerprint !== fingerprint) {
-          try {
-            const entries = (await capability.readSource(id2, signal)).map(parseHarnessUsageEntry).filter((entry) => entry !== null);
-            cache.sources.set(id2, { fingerprint, entries });
+      const pending = ids.filter(
+        ({ id: id2, fingerprint }) => cache.sources.get(id2)?.fingerprint !== fingerprint
+      );
+      this.#progress.read += ids.length - pending.length;
+      try {
+        for await (const result of readUsageStatisticsSources(capability, pending, signal)) {
+          const { id: id2, fingerprint } = result.source;
+          if ("entries" in result) {
+            cache.sources.set(id2, { fingerprint, entries: result.entries });
             cache.dirty = true;
             this.#generation += 1;
-          } catch (error51) {
-            if (signal.aborted) return;
-            failed ??= message(error51);
-          }
+          } else if ("error" in result) failed ??= message(result.error);
+          else present.delete(id2);
+          this.#progress.read += 1;
           await yieldToEventLoop();
         }
-        this.#progress.read += 1;
+      } catch (error51) {
+        if (signal.aborted) return;
+        throw error51;
       }
       for (const id2 of cache.sources.keys()) {
         if (!present.has(id2)) {
@@ -45735,7 +46278,7 @@ var UsageStatistics = class {
   async #persist(harness2, cache) {
     if (!cache.dirty || this.#now() - cache.persistedAtMs < PERSIST_INTERVAL_MS) return;
     const file2 = this.#file(harness2);
-    const temporary = `${file2}.${randomUUID20()}.tmp`;
+    const temporary = `${file2}.${randomUUID22()}.tmp`;
     try {
       await mkdir17(this.#directory, { recursive: true });
       const sources = [...cache.sources].map(([id2, source]) => [
@@ -45753,9 +46296,10 @@ var UsageStatistics = class {
       await rm16(temporary, { force: true });
     }
   }
-  /** Every request once, per Harness in source order, with its local date and hour. */
-  #indexed() {
-    if (this.#index?.generation === this.#generation) return this.#index.entries;
+  /** Every request once, per Harness in source order, in the requested calendar. */
+  #indexed(calendar) {
+    if (this.#index?.generation === this.#generation && this.#index.timeZone === calendar.timeZone)
+      return this.#index.entries;
     const entries = [];
     for (const [harness2, cache] of this.#caches) {
       const seen = /* @__PURE__ */ new Set();
@@ -45763,26 +46307,20 @@ var UsageStatistics = class {
         for (const entry of parsed2) {
           if (seen.has(entry.id)) continue;
           seen.add(entry.id);
-          const at = new Date(entry.occurredAtMs);
-          entries.push({
-            harness: harness2,
-            entry,
-            date: localDate2(entry.occurredAtMs),
-            weekday: at.getDay(),
-            hour: at.getHours()
-          });
+          entries.push({ harness: harness2, entry, ...calendar.at(entry.occurredAtMs) });
         }
       }
     }
-    this.#index = { generation: this.#generation, entries };
+    this.#index = { generation: this.#generation, timeZone: calendar.timeZone, entries };
     return entries;
   }
   #aggregate(params, now, lookup) {
     const { range } = params;
     const days = RANGE_DAYS[range];
-    const to = localDate2(now);
+    const calendar = createUsageStatisticsCalendar(params.timeZone);
+    const to = calendar.at(now).date;
     let from = null;
-    if (days !== null) from = shiftDate(to, -days + 1);
+    if (days !== null) from = shiftUsageDate(to, -days + 1);
     const inRange = (date5) => (from === null || date5 >= from) && date5 <= to;
     const day = params.date !== void 0 && inRange(params.date) ? params.date : null;
     const harnessFilter = params.harness ?? null;
@@ -45823,7 +46361,7 @@ var UsageStatistics = class {
     const harnessPriced = /* @__PURE__ */ new Map();
     const byProject = /* @__PURE__ */ new Map();
     const sessions = /* @__PURE__ */ new Map();
-    for (const indexed of this.#indexed()) {
+    for (const indexed of this.#indexed(calendar)) {
       const { harness: harness2, entry, date: date5 } = indexed;
       if (!inRange(date5)) continue;
       const model2 = entry.model ?? null;
@@ -46351,7 +46889,7 @@ async function runHostRuntime(input) {
 }
 
 // packages/host-runtime/src/remote-host-install.ts
-import { createHash as createHash11, randomUUID as randomUUID21 } from "node:crypto";
+import { createHash as createHash11, randomUUID as randomUUID23 } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
 import {
   access as access3,
@@ -46450,7 +46988,7 @@ async function writeAtomic(filePath, contents, mode) {
   await mkdir18(path38.dirname(filePath), { recursive: true, mode: 448 });
   const temporary = path38.join(
     path38.dirname(filePath),
-    `.${path38.basename(filePath)}.${process.pid}.${randomUUID21()}.tmp`
+    `.${path38.basename(filePath)}.${process.pid}.${randomUUID23()}.tmp`
   );
   try {
     if (typeof contents === "string") {
@@ -46474,7 +47012,7 @@ async function writeAtomicExecutable(filePath, sourcePath) {
   await mkdir18(path38.dirname(filePath), { recursive: true, mode: 448 });
   const temporary = path38.join(
     path38.dirname(filePath),
-    `.${path38.basename(filePath)}.${process.pid}.${randomUUID21()}.tmp`
+    `.${path38.basename(filePath)}.${process.pid}.${randomUUID23()}.tmp`
   );
   try {
     await copyFile4(sourcePath, temporary);
@@ -47215,6 +47753,7 @@ var harnessBrokerMethodSchema = external_exports.enum([
   "adapter.open",
   "adapter.subagent.readSnapshot",
   "session.readSnapshot",
+  "session.readCapabilities",
   "session.refreshUsage",
   "session.execute",
   "session.commands.list",
@@ -47397,6 +47936,11 @@ var turnStartSchema = external_exports.object({
   turnId: hostTurnIdSchema,
   input: external_exports.array(textInputSchema)
 }).strict();
+var turnSteerSchema = external_exports.object({
+  type: external_exports.literal("turn.steer"),
+  turnId: hostTurnIdSchema,
+  input: external_exports.array(textInputSchema)
+}).strict();
 var turnCancelSchema = external_exports.object({ type: external_exports.literal("turn.cancel"), turnId: hostTurnIdSchema }).strict();
 var interactionResponseSchema = external_exports.union([
   external_exports.object({
@@ -47422,6 +47966,7 @@ var permissionSelectSchema = external_exports.object({
 }).strict();
 var brokerHostCommandSchema = external_exports.discriminatedUnion("type", [
   turnStartSchema,
+  turnSteerSchema,
   turnCancelSchema,
   interactionRespondSchema,
   modelSelectSchema,
@@ -47556,7 +48101,7 @@ var harnessOutputSchema = external_exports.custom((value2) => {
 });
 
 // packages/harness-broker/dist/server.js
-import { randomBytes as randomBytes5, randomUUID as randomUUID22 } from "node:crypto";
+import { randomBytes as randomBytes5, randomUUID as randomUUID24 } from "node:crypto";
 import { chmod as chmod6, lstat as lstat10, mkdir as mkdir19, open as open11, readFile as readFile19, rename as rename16, rm as rm18 } from "node:fs/promises";
 import net4, {} from "node:net";
 import path41 from "node:path";
@@ -47615,7 +48160,7 @@ async function assertNoLiveDescriptor(descriptorPath) {
   }
 }
 async function publishDescriptor(descriptorPath, descriptor) {
-  const temporary = `${descriptorPath}.${process.pid}.${randomUUID22()}.tmp`;
+  const temporary = `${descriptorPath}.${process.pid}.${randomUUID24()}.tmp`;
   const handle = await open11(temporary, "wx", 384);
   try {
     await handle.writeFile(`${JSON.stringify(descriptor)}
@@ -47640,6 +48185,7 @@ function sessionMetadata(record4) {
     sessionId: record4.id,
     sessionGeneration: record4.generation,
     capabilities: record4.session.capabilities,
+    readCapabilities: true,
     initialState: {
       ...initialState,
       ...record4.nativeRef ? { nativeRef: record4.nativeRef } : {},
@@ -47692,7 +48238,7 @@ async function startHarnessBrokerServer(input) {
   await assertNoLiveDescriptor(input.descriptorPath);
   if (process.platform !== "win32")
     await prepareUnixSocketPath(input.socketPath);
-  const generation = input.generation ?? randomUUID22();
+  const generation = input.generation ?? randomUUID24();
   const token = input.token ?? randomBytes5(32).toString("hex");
   const descriptor = {
     schemaVersion: 1,
@@ -47733,7 +48279,7 @@ async function startHarnessBrokerServer(input) {
   };
   const server = net4.createServer((socket) => {
     const state = {
-      id: randomUUID22(),
+      id: randomUUID24(),
       socket,
       authenticated: false,
       inputSequence: 0,
@@ -47971,7 +48517,7 @@ async function startHarnessBrokerServer(input) {
             }
           };
         }
-        const openReservation = randomUUID22();
+        const openReservation = randomUUID24();
         if (sourceKey)
           nativeWriters.set(sourceKey, openReservation);
         const provisionalReservation = openInput.kind === "create" ? openReservation : void 0;
@@ -48115,6 +48661,8 @@ async function startHarnessBrokerServer(input) {
         let result;
         if (command.type === "turn.start")
           result = await record5.session.execute(command);
+        else if (command.type === "turn.steer")
+          result = await record5.session.execute(command);
         else if (command.type === "turn.cancel")
           result = await record5.session.execute(command);
         else if (command.type === "interaction.respond") {
@@ -48146,6 +48694,10 @@ async function startHarnessBrokerServer(input) {
         }
         return result;
       }
+      if (request.method === "session.readCapabilities") {
+        const session = requireSession(request.params).session;
+        return session.readCapabilities ? session.readCapabilities() : session.capabilities;
+      }
       if (request.method === "session.readSnapshot") {
         return requireSession(request.params).session.readSnapshot();
       }
@@ -48272,7 +48824,7 @@ async function startHarnessBrokerServer(input) {
           }
           state.authenticated = true;
           state.inputSequence = 1;
-          await send({ kind: "response", id: randomUUID22(), ok: true, value: { ready: true } });
+          await send({ kind: "response", id: randomUUID24(), ok: true, value: { ready: true } });
           return;
         }
         const parsed2 = harnessBrokerRequestSchema.safeParse(raw);