@karlorz/codexhost-cli-win32-x64 0.13.3-7 → 0.14.0-0

package/app/host-runtime.mjs

@@ -6155,9 +6155,9 @@ function floatSafeRemainder(val, step) {
   return ratio - roundedRatio;
 }
 var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
-function defineLazy(object9, key, getter) {
+function defineLazy(object10, key, getter) {
   let value2 = void 0;
-  Object.defineProperty(object9, key, {
+  Object.defineProperty(object10, key, {
     get() {
       if (value2 === EVALUATING) {
         return void 0;
@@ -6169,7 +6169,7 @@ function defineLazy(object9, key, getter) {
       return value2;
     },
     set(v) {
-      Object.defineProperty(object9, key, {
+      Object.defineProperty(object10, key, {
         value: v
         // configurable: true,
       });
@@ -20094,10 +20094,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({
@@ -20133,7 +20142,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. */
@@ -20173,7 +20182,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),
@@ -20286,6 +20295,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/grok-computer-use/get",
@@ -20369,7 +20380,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(),
@@ -20785,7 +20807,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(),
@@ -20918,6 +20942,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;
@@ -21060,6 +21094,8 @@ var grokComputerUseSettingsSchema = 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"])
@@ -21069,6 +21105,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(),
@@ -21076,6 +21116,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);
@@ -23918,9 +23972,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 = [
@@ -23956,7 +24014,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;
@@ -23972,7 +24030,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;
 }
@@ -25091,6 +25155,36 @@ var ExternalVoice = class {
   }
 };
 
+// packages/host-runtime/src/external-voice-presentation.ts
+var INLINE_MARKDOWN = "::codex-realtime-inline{}\n";
+var inlineMarker = /^::codex-realtime-inline\{\}\r?\n/u;
+function externalVoiceContentText(text) {
+  return text.replace(inlineMarker, "");
+}
+function object5(value2) {
+  return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
+}
+function presentItem(item) {
+  if (!object5(item) || item.type !== "agentMessage" || typeof item.text !== "string") return item;
+  if (!item.text.trim() || inlineMarker.test(item.text)) return item;
+  return { ...item, text: INLINE_MARKDOWN + item.text };
+}
+function presentExternalVoiceTurn(turn) {
+  if (!Array.isArray(turn.items)) return turn;
+  return { ...turn, items: turn.items.map(presentItem) };
+}
+function presentExternalVoiceMessage(message2) {
+  const params = message2.params;
+  if (!object5(params)) return message2;
+  if ((message2.method === "item/started" || message2.method === "item/completed") && params.item) {
+    return { ...message2, params: { ...params, item: presentItem(params.item) } };
+  }
+  if ((message2.method === "turn/started" || message2.method === "turn/completed") && object5(params.turn)) {
+    return { ...message2, params: { ...params, turn: presentExternalVoiceTurn(params.turn) } };
+  }
+  return message2;
+}
+
 // packages/host-runtime/src/external-voice-session-input.ts
 var MAX_MESSAGES = 32;
 var MAX_MESSAGE_CHARS = 2e3;
@@ -25129,7 +25223,7 @@ function voiceSessionInputFromTurns(turns) {
         const text = userMessageText(item);
         if (text) messages.push(liveMessage("user", text));
       } else if (item.type === "agentMessage" && item.phase !== "commentary") {
-        const text = typeof item.text === "string" ? item.text.trim() : "";
+        const text = typeof item.text === "string" ? externalVoiceContentText(item.text).trim() : "";
         if (text) messages.push(liveMessage("assistant", text));
       }
     }
@@ -25159,7 +25253,7 @@ function speakableFromProjectedTurn(turn) {
 function speakableFromItems(items) {
   const values = [...items];
   const finals = values.filter((item) => item.phase === "final_answer");
-  const text = (finals.length ? finals : values.filter((item) => item.phase !== "commentary").slice(-1)).map((item) => item.text).join("\n").trim();
+  const text = (finals.length ? finals : values.filter((item) => item.phase !== "commentary").slice(-1)).map((item) => externalVoiceContentText(item.text)).join("\n").trim();
   return text.length > 0 ? text : void 0;
 }
 var ExternalVoiceResults = class {
@@ -25259,7 +25353,7 @@ var import_websocket_server = __toESM(require_websocket_server(), 1);
 var wrapper_default = import_websocket.default;
 
 // packages/host-runtime/src/external-voice-gateway.ts
-function object5(value2) {
+function object6(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function configuredExternalVoiceGateway(environment) {
@@ -25342,7 +25436,7 @@ function configuredExternalVoiceGateway(environment) {
             if (closed || input.signal.aborted) return;
             try {
               const event = JSON.parse(String(raw));
-              if (object5(event) && typeof event.type === "string")
+              if (object6(event) && typeof event.type === "string")
                 input.onEvent(event);
             } catch {
               input.onError();
@@ -25962,6 +26056,64 @@ async function handleHarnessInstallation(params, adapters) {
   }
 }
 
+// packages/host-runtime/src/harness-installation-tasks.ts
+import { randomUUID as randomUUID5 } 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 = randomUUID5();
+    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 readFile10 } from "node:fs/promises";
@@ -26054,7 +26206,7 @@ async function listOthers(adapter) {
 }
 
 // packages/host-runtime/src/harness-display-settings.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { link, mkdir as mkdir8, readFile as readFile11, rename as rename5, rm as rm7, writeFile as writeFile7 } from "node:fs/promises";
 import os5 from "node:os";
 import path16 from "node:path";
@@ -26079,7 +26231,7 @@ var HarnessDisplaySettingsStore = class {
   async set(input) {
     const entries = harnessDisplayEntriesSchema.parse(input.entries);
     await mkdir8(path16.dirname(this.#file), { recursive: true, mode: 448 });
-    const temporary = `${this.#file}.${randomUUID5()}.tmp`;
+    const temporary = `${this.#file}.${randomUUID6()}.tmp`;
     try {
       await writeFile7(temporary, `${JSON.stringify(entries)}
 `, { mode: 384, flag: "wx" });
@@ -26100,7 +26252,7 @@ var HarnessDisplaySettingsStore = class {
 };
 
 // packages/host-runtime/src/model-price-overrides-file.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 import { mkdir as mkdir10, readFile as readFile13, rename as rename7, rm as rm8, writeFile as writeFile9 } from "node:fs/promises";
 import path18 from "node:path";
 
@@ -26675,7 +26827,7 @@ async function updateModelPriceOverridesFile(file2, change) {
   const updated = { ...document, models: next };
   parseModelPriceOverrides(updated);
   await mkdir10(path18.dirname(file2), { recursive: true });
-  const temporary = `${file2}.${randomUUID6()}.tmp`;
+  const temporary = `${file2}.${randomUUID7()}.tmp`;
   try {
     await writeFile9(temporary, `${JSON.stringify(updated, null, 2)}
 `, { flag: "wx" });
@@ -26711,7 +26863,7 @@ async function handleModelPriceOverridesRequest(catalog, method, params) {
 }
 
 // packages/host-runtime/src/delegation-skill.ts
-import { createHash as createHash4, randomUUID as randomUUID7 } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID8 } from "node:crypto";
 import { mkdir as mkdir11, open as open4, readFile as readFile14, rename as rename8, rm as rm9, stat as stat5 } from "node:fs/promises";
 import os7 from "node:os";
 import path19 from "node:path";
@@ -26811,7 +26963,7 @@ async function readOptional(filePath) {
 }
 async function atomicWrite(filePath, content) {
   await mkdir11(path19.dirname(filePath), { recursive: true, mode: 448 });
-  const temporaryPath = path19.join(path19.dirname(filePath), `.SKILL.md.${randomUUID7()}.tmp`);
+  const temporaryPath = path19.join(path19.dirname(filePath), `.SKILL.md.${randomUUID8()}.tmp`);
   const handle = await open4(temporaryPath, "wx", 384);
   try {
     await handle.writeFile(content, "utf8");
@@ -27048,6 +27200,7 @@ var usageFields = /* @__PURE__ */ new Set([
   ...safeIntegerFields,
   ...percentFields,
   "sessionCacheUsage",
+  "composerIndicators",
   "totalCostUsd",
   "totalCredits",
   "contextUsagePercent",
@@ -27070,6 +27223,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",
@@ -27140,9 +27294,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",
@@ -27293,7 +27447,7 @@ var packageMetadata = {
 
 // packages/mapping-store/dist/mapping-store.js
 import { execFileSync } from "node:child_process";
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID11 } from "node:crypto";
 import { constants as constants3 } from "node:fs";
 import { copyFile as copyFile3, mkdir as mkdir13, open as open7, readFile as readFile17, readdir as readdir4, rename as rename11, rm as rm12, stat as stat6 } from "node:fs/promises";
 import path21 from "node:path";
@@ -27309,7 +27463,9 @@ var isoDateSchema = external_exports.string().refine((value2) => !Number.isNaN(D
 var storedTurnMappingV1Schema = external_exports.object({
   hostTurnId: hostTurnIdSchema,
   nativeTurnRef: nativeTurnRefSchema,
-  nativeCheckpointRef: nativeCheckpointRefSchema.optional()
+  nativeCheckpointRef: nativeCheckpointRefSchema.optional(),
+  /** Desktop presentation for work completed during an external voice call. */
+  realtimeInline: external_exports.literal(true).optional()
 }).strict();
 var storedGitInfoV1Schema = external_exports.object({
   branch: nonBlankTextSchema6.max(4096).optional(),
@@ -27449,7 +27605,7 @@ var storedDelegationRecordV1Schema = external_exports.object({
 });
 
 // packages/mapping-store/dist/section-placements.js
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 import { constants } from "node:fs";
 import { open as open5, readFile as readFile15, rename as rename9, rm as rm10 } from "node:fs/promises";
 var threadIdSchema = external_exports.string().min(1).max(1024);
@@ -27501,7 +27657,7 @@ async function readSectionPlacementsFile(file2) {
 }
 async function writeSectionPlacementsFile(file2, placements) {
   const parsed2 = parseSectionPlacements({ formatVersion: 1, placements });
-  const temp = `${file2}.tmp-${randomUUID8()}`;
+  const temp = `${file2}.tmp-${randomUUID9()}`;
   let handle = null;
   try {
     handle = await open5(temp, "wx", constants.S_IRUSR | constants.S_IWUSR);
@@ -27520,7 +27676,7 @@ async function writeSectionPlacementsFile(file2, placements) {
 }
 
 // packages/mapping-store/dist/superseded-sessions.js
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 import { constants as constants2 } from "node:fs";
 import { mkdir as mkdir12, open as open6, readFile as readFile16, rename as rename10, rm as rm11 } from "node:fs/promises";
 import path20 from "node:path";
@@ -27555,7 +27711,7 @@ async function writeSupersededSessionsFile(file2, sessions) {
     formatVersion: 1,
     sessions: sessions.slice(-SUPERSEDED_SESSIONS_MAX)
   }).sessions;
-  const temp = `${file2}.tmp-${randomUUID9()}`;
+  const temp = `${file2}.tmp-${randomUUID10()}`;
   let handle = null;
   try {
     await mkdir12(path20.dirname(file2), { recursive: true });
@@ -27810,7 +27966,7 @@ var MappingStore = class {
     this.#sectionsDirectory = path21.join(this.#directory, "sections");
     this.#metadataDirectory = path21.join(this.#directory, "thread-metadata");
     this.#lockPath = path21.join(this.#directory, "store.lock");
-    this.#instanceId = options2.instanceId ?? randomUUID10();
+    this.#instanceId = options2.instanceId ?? randomUUID11();
     this.#now = options2.now ?? (() => /* @__PURE__ */ new Date());
     this.#beforeReplace = options2.beforeReplace;
   }
@@ -28318,6 +28474,8 @@ var MappingStore = class {
         if (!hostMatch.nativeCheckpointRef && update.nativeCheckpointRef) {
           hostMatch.nativeCheckpointRef = update.nativeCheckpointRef;
         }
+        if (update.realtimeInline)
+          hostMatch.realtimeInline = true;
         continue;
       }
       const added = { ...update };
@@ -28334,7 +28492,7 @@ var MappingStore = class {
     this.#rebuildIndexes();
   }
   async #replaceFile(target, record4, preserveBackup) {
-    const temp = `${target}.tmp-${randomUUID10()}`;
+    const temp = `${target}.tmp-${randomUUID11()}`;
     let handle = null;
     try {
       await this.#beforeReplace?.(cloneRecord(record4));
@@ -28361,7 +28519,7 @@ var MappingStore = class {
   /** Atomically patches owned metadata fields, retaining unknown fields on disk. */
   async #writeMetadataFile(hostThreadId, metadata) {
     const target = this.#metadataPath(hostThreadId);
-    const temp = `${target}.tmp-${randomUUID10()}`;
+    const temp = `${target}.tmp-${randomUUID11()}`;
     let handle = null;
     try {
       const retained = Object.fromEntries(Object.entries(await this.#readMetadata(hostThreadId) ?? {}).filter(([name]) => !["formatVersion", "hostThreadId", ...THREAD_METADATA_FIELDS].includes(name)));
@@ -28408,7 +28566,7 @@ var MappingStore = class {
   }
   async #replaceDelegationFile(record4) {
     const target = this.#delegationPath(record4.delegationId);
-    const temp = `${target}.tmp-${randomUUID10()}`;
+    const temp = `${target}.tmp-${randomUUID11()}`;
     let handle = null;
     try {
       handle = await open7(temp, "wx", constants3.S_IRUSR | constants3.S_IWUSR);
@@ -30100,8 +30258,18 @@ function projectSubagentActivities(item) {
     ];
   });
 }
+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) {
   switch (item.type) {
+    case "userMessage":
+      return projectUserMessage(item, null);
     case "agentMessage":
       return {
         id: item.itemId,
@@ -30307,6 +30475,7 @@ var CodexTurnProjector = class {
   #interactions = /* @__PURE__ */ new Map();
   #items = /* @__PURE__ */ new Map();
   #wireItemOrder = [];
+  #userMessageClientIds = /* @__PURE__ */ new Map();
   #startedAt;
   #startedAtMs;
   #threadId;
@@ -30348,6 +30517,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,
@@ -30358,6 +30531,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)];
           }
@@ -30690,7 +30865,7 @@ var CodexTurnProjector = class {
       };
     }
     const messages = [
-      completedItem(projectItem(projected.item, projected.outcome, this.#cwd, !projected.streamedCommandOutput))
+      completedItem(this.#projectItem(projected.item, projected.outcome, !projected.streamedCommandOutput))
     ];
     if (projected.item.type === "reasoning") {
       const reasoning = projected.item;
@@ -30755,6 +30930,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)];
           }
@@ -30853,10 +31030,13 @@ var CodexTurnProjector = class {
         threadId: this.#threadId,
         turnId: this.#turnId,
         startedAtMs,
-        item: projectItem(item, null, this.#cwd)
+        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);
+  }
   #startReasoningTranscript(item, startedAtMs) {
     return {
       method: "item/started",
@@ -32008,7 +32188,7 @@ var AccountRateLimits = class {
 };
 
 // packages/host-runtime/src/native-account-observer.ts
-var object6 = (value2) => typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
+var object7 = (value2) => typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 var NativeAccountObserver = class {
   constructor(input) {
     this.input = input;
@@ -32031,7 +32211,7 @@ var NativeAccountObserver = class {
   }
   /** Called after forwarding the native frame. Identity read failure cannot alter its outcome. */
   observe(value2) {
-    if (!object6(value2) || value2.method !== "account/updated" && value2.method !== "account/login/completed" || !this.input.control.refresh || !this.#ready())
+    if (!object7(value2) || value2.method !== "account/updated" && value2.method !== "account/login/completed" || !this.input.control.refresh || !this.#ready())
       return;
     this.#collectRequested = true;
     if (this.#collecting) return;
@@ -32070,13 +32250,13 @@ var NativeAccountObserver = class {
     const generation = scope.owner.generation;
     this.#lastGeneration = generation;
     const response = await scope.owner.controlRequest("account/read", { refreshToken: false });
-    if (response.error || !object6(response.result))
+    if (response.error || !object7(response.result))
       throw new Error("Invalid native Account response");
     const account = response.result.account;
     let params;
     if (account === null) params = { authMode: null, planType: null };
     else {
-      if (!object6(account) || account.type !== "chatgpt")
+      if (!object7(account) || account.type !== "chatgpt")
         throw new Error("Invalid native Account response");
       params = {
         authMode: "chatgpt",
@@ -32248,7 +32428,7 @@ var HarnessAccountInspectionCache = class {
 };
 
 // packages/host-runtime/src/app-server-host.ts
-import { createHash as createHash9, randomUUID as randomUUID16 } from "node:crypto";
+import { createHash as createHash9, randomUUID as randomUUID18 } from "node:crypto";
 import os9 from "node:os";
 import path28 from "node:path";
 
@@ -32256,12 +32436,12 @@ import path28 from "node:path";
 import nodePath from "node:path";
 
 // packages/host-runtime/src/external-thread-repository.ts
-import { randomUUID as randomUUID12 } from "node:crypto";
+import { randomUUID as randomUUID13 } from "node:crypto";
 import os8 from "node:os";
 import path25 from "node:path";
 
 // packages/host-runtime/src/external-subagent-threads.ts
-import { createHash as createHash6, randomUUID as randomUUID11 } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID12 } 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}`;
@@ -32343,7 +32523,7 @@ function subagentMaterializer(store, parent, previousParent) {
       return configured(await rebind(existing, parent));
     }
     const provisional = existing ?? await store.createProvisional({
-      hostThreadId: hostThreadIdSchema.parse(randomUUID11()),
+      hostThreadId: hostThreadIdSchema.parse(randomUUID12()),
       createRequestId,
       harnessId: parent.harnessId,
       cwd: parent.cwd,
@@ -32386,14 +32566,13 @@ async function projectExternalSnapshot(store, record4, snapshot2, previousParent
         return { ...entry, item: { ...entry.item, subagents } };
       })
     );
-    turns.push(
-      projectHistoricalTurn({
-        threadId: record4.hostThreadId,
-        turnId: mapping.hostTurnId,
-        cwd: record4.cwd,
-        snapshot: { ...turn, items }
-      })
-    );
+    const projected = projectHistoricalTurn({
+      threadId: record4.hostThreadId,
+      turnId: mapping.hostTurnId,
+      cwd: record4.cwd,
+      snapshot: { ...turn, items }
+    });
+    turns.push(mapping.realtimeInline ? presentExternalVoiceTurn(projected) : projected);
   }
   return turns;
 }
@@ -32497,7 +32676,7 @@ var ExternalThreadRepository = class {
   removeThread(hostThreadId) {
     return this.store.removeThread(hostThreadId);
   }
-  async persistTurn(record4, hostTurnId, nativeTurnRef, nativeCheckpointRef) {
+  async persistTurn(record4, hostTurnId, nativeTurnRef, nativeCheckpointRef, realtimeInline) {
     if (record4.state !== "ready" || !record4.nativeSessionRef || nativeTurnRef.harnessId !== record4.harnessId || nativeTurnRef.nativeSessionId !== record4.nativeSessionRef.nativeSessionId || nativeCheckpointRef && (nativeCheckpointRef.harnessId !== record4.harnessId || nativeCheckpointRef.nativeSessionId !== record4.nativeSessionRef.nativeSessionId)) {
       throw new Error("Live Turn identity does not belong to the stored Thread");
     }
@@ -32505,7 +32684,8 @@ var ExternalThreadRepository = class {
       {
         hostTurnId,
         nativeTurnRef,
-        ...nativeCheckpointRef ? { nativeCheckpointRef } : {}
+        ...nativeCheckpointRef ? { nativeCheckpointRef } : {},
+        ...realtimeInline ? { realtimeInline } : {}
       }
     ]);
   }
@@ -32518,7 +32698,7 @@ var ExternalThreadRepository = class {
         throw new Error("Derived Snapshot identity does not belong to its Native Session");
       }
       return {
-        hostTurnId: hostTurnIdSchema.parse(randomUUID12()),
+        hostTurnId: hostTurnIdSchema.parse(randomUUID13()),
         nativeTurnRef: turn.nativeTurnRef,
         ...turn.checkpoint ? { nativeCheckpointRef: turn.checkpoint } : {}
       };
@@ -32558,6 +32738,7 @@ var ExternalThreadRepository = class {
       }
       return {
         hostTurnId: previous.hostTurnId,
+        ...previous.realtimeInline ? { realtimeInline: true } : {},
         nativeTurnRef: turn.nativeTurnRef,
         ...turn.checkpoint ? { nativeCheckpointRef: turn.checkpoint } : {}
       };
@@ -32589,6 +32770,7 @@ var ExternalThreadRepository = class {
       }
       return {
         hostTurnId: previous.hostTurnId,
+        ...previous.realtimeInline ? { realtimeInline: true } : {},
         nativeTurnRef: turn.nativeTurnRef,
         ...turn.checkpoint ? { nativeCheckpointRef: turn.checkpoint } : {}
       };
@@ -32641,14 +32823,15 @@ var ExternalThreadRepository = class {
     const aligned = snapshot2.turns.map((turn) => {
       const existing = mappingsByNative.get(nativeTurnKey2(turn.nativeTurnRef));
       const mapping = existing ?? {
-        hostTurnId: hostTurnIdSchema.parse(randomUUID12()),
+        hostTurnId: hostTurnIdSchema.parse(randomUUID13()),
         nativeTurnRef: turn.nativeTurnRef,
         ...turn.checkpoint ? { nativeCheckpointRef: turn.checkpoint } : {}
       };
       return {
         snapshot: turn,
         mapping: {
-          ...mapping,
+          hostTurnId: mapping.hostTurnId,
+          ...mapping.realtimeInline ? { realtimeInline: true } : {},
           nativeTurnRef: turn.nativeTurnRef,
           ...turn.checkpoint ? { nativeCheckpointRef: turn.checkpoint } : {}
         }
@@ -32668,8 +32851,8 @@ var ExternalThreadRepository = class {
 };
 function createExternalThreadRecordInput(input) {
   return {
-    hostThreadId: input.hostThreadId ?? hostThreadIdSchema.parse(randomUUID12()),
-    createRequestId: input.createRequestId ?? randomUUID12(),
+    hostThreadId: input.hostThreadId ?? hostThreadIdSchema.parse(randomUUID13()),
+    createRequestId: input.createRequestId ?? randomUUID13(),
     harnessId: input.harnessId,
     cwd: input.cwd,
     ...input.title ? { title: input.title } : {},
@@ -32791,6 +32974,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,
@@ -33547,6 +33739,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) {
@@ -34346,6 +34548,7 @@ var ExternalThreadRuntime = class {
   #repository;
   #lifecycle = new ExternalThreadLifecycle();
   #hasRunningDescendants;
+  #steeredTurnIds = /* @__PURE__ */ new Map();
   #subagentRunning;
   #threads = /* @__PURE__ */ new Map();
   constructor(input) {
@@ -34359,7 +34562,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 } : {},
@@ -34369,14 +34573,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();
@@ -34433,6 +34644,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,
@@ -34457,11 +34673,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);
@@ -34518,13 +34736,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);
@@ -34761,7 +34979,8 @@ var ExternalThreadRuntime = class {
         thread.record,
         event.turnId,
         event.nativeTurnRef,
-        event.outcome.checkpoint
+        event.outcome.checkpoint,
+        thread.projectedTurns.get(event.turnId)?.realtimeInline
       );
       return null;
     } catch (error51) {
@@ -34897,6 +35116,71 @@ var ExternalThreadRuntime = class {
 };
 
 // packages/host-runtime/src/external-turn-steering.ts
+import { randomUUID as randomUUID14 } 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);
@@ -34904,6 +35188,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");
@@ -34920,12 +35209,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(randomUUID14()),
+      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;
@@ -34937,7 +35261,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)
@@ -34959,7 +35283,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);
@@ -34982,6 +35306,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);
@@ -35036,7 +35410,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 = () => {
@@ -35054,7 +35430,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);
@@ -35062,58 +35438,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 path26 from "node:path";
 var MAX_ENTRIES = 64;
@@ -35145,7 +35469,7 @@ function sameWorkspace(left, right) {
 }
 
 // packages/host-runtime/src/harness-delegation-coordinator.ts
-import { createHash as createHash8, randomUUID as randomUUID13 } from "node:crypto";
+import { createHash as createHash8, randomUUID as randomUUID15 } from "node:crypto";
 import path27 from "node:path";
 
 // packages/host-runtime/src/delegation-snapshot.ts
@@ -35449,10 +35773,10 @@ var HarnessDelegationCoordinator = class {
       });
       this.#validateConfiguration(inspected.inspection, input.model, input.thinkingOptionId);
     }
-    const delegationId = hostThreadIdSchema.parse(randomUUID13());
-    const childThreadId = hostThreadIdSchema.parse(randomUUID13());
-    const turnId = hostTurnIdSchema.parse(randomUUID13());
-    const createRequestId = input.requestId ? `delegation:${input.requestId}` : randomUUID13();
+    const delegationId = hostThreadIdSchema.parse(randomUUID15());
+    const childThreadId = hostThreadIdSchema.parse(randomUUID15());
+    const turnId = hostTurnIdSchema.parse(randomUUID15());
+    const createRequestId = input.requestId ? `delegation:${input.requestId}` : randomUUID15();
     let record4 = await this.#repository.createProvisional(
       createExternalThreadRecordInput({
         hostThreadId: childThreadId,
@@ -35606,7 +35930,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(randomUUID13());
+    const turnId = hostTurnIdSchema.parse(randomUUID15());
     try {
       await this.#startExternalTurn(thread, input.message, turnId);
     } catch (error51) {
@@ -35880,8 +36204,8 @@ import { pathToFileURL } from "node:url";
 function isNullable(value2) {
   return value2 === null || value2 === void 0;
 }
-function defineProperty(object9, key, value2) {
-  return Object.defineProperty(object9, key, {
+function defineProperty(object10, key, value2) {
+  return Object.defineProperty(object10, key, {
     writable: true,
     value: value2,
     enumerable: false
@@ -37420,8 +37744,8 @@ var Fiber = class {
     });
   }
 };
-function isApplicable(object9) {
-  return object9 && typeof object9 === "object" && typeof object9.apply === "function";
+function isApplicable(object10) {
+  return object10 && typeof object10 === "object" && typeof object10.apply === "function";
 }
 function Inject(name, config2) {
   return function(value2, decorator) {
@@ -38256,10 +38580,10 @@ var SingleNativeCodexAccount = class {
 };
 
 // packages/host-runtime/src/codex-runtime/official-runtime-owner.ts
-import { randomUUID as randomUUID15 } from "node:crypto";
+import { randomUUID as randomUUID17 } from "node:crypto";
 
 // packages/host-runtime/src/official-request-broker.ts
-import { randomUUID as randomUUID14 } from "node:crypto";
+import { randomUUID as randomUUID16 } from "node:crypto";
 var INTERNAL_REQUEST_PREFIX = "codexhost:official:";
 var MAX_RETIRED_IDS = 1024;
 function isRecord17(value2) {
@@ -38275,7 +38599,7 @@ var OfficialRequestBroker = class {
   constructor(input) {
     this.#send = input.send;
     this.#timeoutMs = input.timeoutMs ?? 3e4;
-    this.#nextId = input.nextId ?? (() => `${INTERNAL_REQUEST_PREFIX}${randomUUID14()}`);
+    this.#nextId = input.nextId ?? (() => `${INTERNAL_REQUEST_PREFIX}${randomUUID16()}`);
   }
   get pendingCount() {
     return this.#pending.size;
@@ -38484,7 +38808,7 @@ var OfficialWorkGate = class {
 };
 
 // packages/host-runtime/src/codex-runtime/official-runtime-owner.ts
-var object7 = (value2) => typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
+var object8 = (value2) => typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 var requestKey = (id2) => JSON.stringify([typeof id2, id2]);
 var RESUME_FIELDS = /* @__PURE__ */ new Set([
   "model",
@@ -38629,7 +38953,7 @@ var OfficialRuntimeOwner = class {
   }
   #attach(role, output, onBackendStopped) {
     const client = {
-      id: randomUUID15(),
+      id: randomUUID17(),
       role,
       output,
       ...onBackendStopped ? { onBackendStopped } : {},
@@ -38749,7 +39073,7 @@ var OfficialRuntimeOwner = class {
     if (value2.method === "initialized") return;
     if (typeof value2.id !== "string" && typeof value2.id !== "number")
       throw new Error("Official methods require a request ID");
-    const params = object7(value2.params) ? value2.params : {};
+    const params = object8(value2.params) ? value2.params : {};
     this.#checkMethod(value2.method);
     const finish = this.gate.admit();
     let pendingKey;
@@ -38784,10 +39108,10 @@ var OfficialRuntimeOwner = class {
     if (!this.#clients.has(client) || event.generation !== this.#generation || !["running", "starting"].includes(this.#phase))
       return;
     const value2 = event.value;
-    if (!object7(value2)) return client.output(event);
+    if (!object8(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}:${randomUUID15()}`;
+        const id2 = `codexhost:server:${client.id}:${event.generation}:${randomUUID17()}`;
         client.serverRequests.set(id2, value2.id);
         const projected = { ...value2, id: id2 };
         return client.output({
@@ -38810,7 +39134,7 @@ var OfficialRuntimeOwner = class {
     if (response.error) return;
     if (["thread/archive", "thread/unsubscribe"].includes(method) && typeof params.threadId === "string")
       client.threads.delete(params.threadId);
-    if (!["thread/start", "thread/resume", "thread/fork"].includes(method) || !object7(response.result) || !object7(response.result.thread))
+    if (!["thread/start", "thread/resume", "thread/fork"].includes(method) || !object8(response.result) || !object8(response.result.thread))
       return;
     const id2 = response.result.thread.id;
     if (typeof id2 !== "string") return;
@@ -38832,7 +39156,7 @@ var OfficialRuntimeOwner = class {
     const restoring = (async () => {
       const resume = subscription.params;
       const response = await runtime.request("thread/resume", resume);
-      if (response.error || !object7(response.result) || !object7(response.result.thread) || response.result.thread.id !== params.threadId)
+      if (response.error || !object8(response.result) || !object8(response.result.thread) || response.result.thread.id !== params.threadId)
         throw new Error("Official Thread restoration failed");
       if (client.runtime !== runtime || runtime.generation !== this.#generation)
         throw new OfficialAdmissionError("unavailable");
@@ -38980,16 +39304,16 @@ var OfficialRuntimeScope = class {
   #scheduleRecovery() {
     if (!this.#recovery || this.#closed || this.#recoveryTimer || this.#starting) return;
     const { delaysMs } = this.#recovery;
-    const delay7 = delaysMs[Math.min(this.#recoveryAttempt, delaysMs.length - 1)] ?? 0;
+    const delay8 = delaysMs[Math.min(this.#recoveryAttempt, delaysMs.length - 1)] ?? 0;
     this.#recoveryAttempt++;
     this.#diagnosticOutput.write(
-      `codexhost: official Codex is unavailable; restarting in ${String(delay7)}ms
+      `codexhost: official Codex is unavailable; restarting in ${String(delay8)}ms
 `
     );
     const timer = setTimeout(() => {
       this.#recoveryTimer = void 0;
       this.start().catch(() => void 0);
-    }, delay7);
+    }, delay8);
     timer.unref();
     this.#recoveryTimer = timer;
   }
@@ -40075,6 +40399,7 @@ var AppServerHost = class {
   #plugins;
   #launchSettings;
   #accountInspections = new HarnessAccountInspectionCache();
+  #installationTasks = new HarnessInstallationTasks();
   #externalRuntime;
   #executionHosts = /* @__PURE__ */ new WeakMap();
   #externalPrewarms = new ExternalThreadPrewarms();
@@ -40110,7 +40435,7 @@ var AppServerHost = class {
   #sectionMoves = Promise.resolve();
   #writer;
   /** Console requests share Desktop handling; their replies return to the console. */
-  #consoleRequestPrefix = `codexhost-console:${randomUUID16()}:`;
+  #consoleRequestPrefix = `codexhost-console:${randomUUID18()}:`;
   #consoleReplies = /* @__PURE__ */ new Map();
   #nextConsoleRequest = 0;
   #subagentThreadStatuses = /* @__PURE__ */ new Map();
@@ -40948,11 +41273,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(
@@ -41057,6 +41382,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;
@@ -41830,7 +42159,7 @@ var AppServerHost = class {
       throw error51;
     }
     this.#activeOfficialTurns.set(threadId2, turnId);
-    const delegationId = hostThreadIdSchema.parse(randomUUID16());
+    const delegationId = hostThreadIdSchema.parse(randomUUID18());
     try {
       const source = await this.#repository.find(input.parentThreadId);
       const pendingTerminal = this.#pendingOfficialTerminalStatuses.get(threadId2);
@@ -42018,7 +42347,7 @@ var AppServerHost = class {
   async #listDelegationThreads(input) {
     const [sortKey, sortDirection2] = input.sort.split("-");
     const request = {
-      id: `codexhost:delegation-list:${randomUUID16()}`,
+      id: `codexhost:delegation-list:${randomUUID18()}`,
       method: "thread/list",
       params: {
         cwd: input.cwd ? [input.cwd] : null,
@@ -42561,6 +42890,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) {
@@ -42724,7 +43075,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(randomUUID16());
+    const turnId = requestedTurnId ?? hostTurnIdSchema.parse(randomUUID18());
     const projection = {
       projector: new CodexTurnProjector({
         threadId: thread.id,
@@ -43161,9 +43512,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);
   }
@@ -43363,17 +43725,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) {
@@ -43390,6 +43754,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(
@@ -43408,7 +43775,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
@@ -43442,6 +43809,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(
@@ -43630,10 +43999,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();
       }
@@ -43649,6 +44023,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);
@@ -43706,7 +44108,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(randomUUID16());
+    const turnId = hostTurnIdSchema.parse(randomUUID18());
     const startedAtMs = Date.now();
     const projection = {
       projector: new CodexTurnProjector({
@@ -44000,8 +44402,14 @@ 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 === "item.completed" && event.snapshot.item.type === "agentMessage" && this.#externalVoice.has(thread.id)) {
+      projection.realtimeInline = true;
+    }
     if (event.type === "interaction.closed" && thread.ignoredInteractionIds.delete(event.interactionId)) {
       return;
     }
@@ -44041,7 +44449,9 @@ var AppServerHost = class {
         thread.ephemeralTurnIds.delete(event.turnId);
         this.#manualCompactionTurns.delete(thread);
       } else {
-        thread.turns.push(result.completedTurn);
+        thread.turns.push(
+          projection.realtimeInline ? presentExternalVoiceTurn(result.completedTurn) : result.completedTurn
+        );
         thread.projectedTerminalTurnId = event.turnId;
         thread.thread.updatedAt = completedAt;
         thread.thread.recencyAt = completedAt;
@@ -44051,6 +44461,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) {
@@ -44067,7 +44478,11 @@ var AppServerHost = class {
     if (event.type === "item.completed" && projection.projector.completed && !projection.projector.hasOpenDetachedItems) {
       thread.projectedTurns.delete(event.turnId);
     }
-    for (const message2 of result.messages) await this.#writer.json(message2);
+    for (const message2 of result.messages) {
+      await this.#writer.json(
+        projection.realtimeInline ? presentExternalVoiceMessage(message2) : message2
+      );
+    }
     this.#externalVoiceResults.observe(
       thread.id,
       event,
@@ -44355,7 +44770,7 @@ var AppServerHost = class {
     try {
       result = projection.projector.projectQuestion(
         interaction,
-        hostItemIdSchema.parse(randomUUID16())
+        hostItemIdSchema.parse(randomUUID18())
       );
     } catch (error51) {
       this.#diagnose(error51);
@@ -44583,7 +44998,7 @@ import path30 from "node:path";
 import { PassThrough } from "node:stream";
 
 // packages/host-runtime/src/remote-socket-lock.ts
-import { randomUUID as randomUUID17 } from "node:crypto";
+import { randomUUID as randomUUID19 } from "node:crypto";
 import { chmod as chmod3, lstat as lstat5, mkdir as mkdir14, open as open9, readFile as readFile18, readdir as readdir5, rename as rename12, rm as rm13 } from "node:fs/promises";
 import { uptime } from "node:os";
 import path29 from "node:path";
@@ -44709,7 +45124,7 @@ async function preparePrivateLockDirectory(lockDirectory) {
   await chmod3(lockDirectory, 448);
 }
 async function writeLockRecordAtomic(lockDirectory, entryPath, record4) {
-  const temporary = path29.join(lockDirectory, `.tmp-${record4.ownerToken}-${randomUUID17()}`);
+  const temporary = path29.join(lockDirectory, `.tmp-${record4.ownerToken}-${randomUUID19()}`);
   const handle = await open9(temporary, "wx", 384);
   try {
     await handle.writeFile(`${JSON.stringify(record4)}
@@ -44784,7 +45199,7 @@ async function withRemoteAppServerSocketInitializationLock(socketPath, action) {
   const legacyPath = `${socketPath}.initializing`;
   const lockDirectory = `${socketPath}.initializers`;
   await preparePrivateLockDirectory(lockDirectory);
-  const ownerToken = randomUUID17();
+  const ownerToken = randomUUID19();
   const entryPath = path29.join(lockDirectory, lockEntryName(ownerToken));
   const baseRecord = {
     version: 2,
@@ -45295,12 +45710,12 @@ function createRemoteAppServerWebSocketListener(input) {
 
 // packages/host-runtime/src/remote-official-app-server.ts
 import { spawn as spawn5 } from "node:child_process";
-import { randomUUID as randomUUID18 } from "node:crypto";
+import { randomUUID as randomUUID20 } from "node:crypto";
 import { lstat as lstat7, rm as rm15, stat as stat7 } from "node:fs/promises";
 import path31 from "node:path";
 var DEFAULT_CLOSE_TIMEOUT_MS = 2e3;
 var DEFAULT_LISTEN_TIMEOUT_MS = 1e4;
-function remoteOfficialAppServerSocketPath(desktopControlSocketPath, token = randomUUID18()) {
+function remoteOfficialAppServerSocketPath(desktopControlSocketPath, token = randomUUID20()) {
   if (!path31.posix.isAbsolute(desktopControlSocketPath)) {
     throw new Error("Desktop control socket path must be absolute");
   }
@@ -46586,12 +47001,12 @@ async function readRemoteDelegationThread(environment, input) {
 }
 
 // packages/host-runtime/src/shared-thread-owner.ts
-import { randomUUID as randomUUID20 } from "node:crypto";
+import { randomUUID as randomUUID22 } from "node:crypto";
 import { PassThrough as PassThrough3 } from "node:stream";
 
 // packages/host-runtime/src/shared-thread-peer.ts
-import { randomUUID as randomUUID19 } from "node:crypto";
-function object8(value2) {
+import { randomUUID as randomUUID21 } from "node:crypto";
+function object9(value2) {
   return value2 !== null && typeof value2 === "object" && !Array.isArray(value2);
 }
 var StreamThreadPeer = class {
@@ -46604,7 +47019,7 @@ var StreamThreadPeer = class {
   input;
   output;
   stop;
-  #prefix = `shared:${randomUUID19()}:`;
+  #prefix = `shared:${randomUUID21()}:`;
   #pending = /* @__PURE__ */ new Map();
   #listeners = /* @__PURE__ */ new Set();
   #ended = Promise.withResolvers();
@@ -46647,7 +47062,7 @@ var StreamThreadPeer = class {
   async #read() {
     for await (const frame of readLfFrames(this.input)) {
       const message2 = parseJsonFrame(frame);
-      if (!object8(message2)) throw new Error("Invalid shared Thread response");
+      if (!object9(message2)) throw new Error("Invalid shared Thread response");
       if (typeof message2.method !== "string") {
         const pending = typeof message2.id === "string" ? this.#pending.get(message2.id) : void 0;
         if (pending) {
@@ -46682,7 +47097,7 @@ var SharedThreadOwner = class {
   input = new PassThrough3();
   output = new PassThrough3();
   #peer = new StreamThreadPeer(this.output, this.input, () => this.input.end());
-  #prefix = `shared-interaction:${randomUUID20()}:`;
+  #prefix = `shared-interaction:${randomUUID22()}:`;
   #interactions = /* @__PURE__ */ new Map();
   #listeners = /* @__PURE__ */ new Set();
   #receipts = /* @__PURE__ */ new Map();
@@ -46693,7 +47108,7 @@ var SharedThreadOwner = class {
         const id2 = `${this.#prefix}${message2.id}`;
         event = { ...message2, id: id2 };
         this.#interactions.set(id2, { nativeId: message2.id, message: event });
-      } else if (message2.method === "serverRequest/resolved" && object8(message2.params)) {
+      } else if (message2.method === "serverRequest/resolved" && object9(message2.params)) {
         const id2 = `${this.#prefix}${message2.params.requestId}`;
         this.#interactions.delete(id2);
         event = { ...message2, params: { ...message2.params, requestId: id2 } };
@@ -46788,7 +47203,7 @@ var SharedThreadOwner = class {
             const parsed2 = jsonRpcRequestSchema.safeParse(message2);
             if (parsed2.success) {
               const request = parsed2.data;
-              void peer.request(request.method, object8(request.params) ? request.params : {}).then(
+              void peer.request(request.method, object9(request.params) ? request.params : {}).then(
                 (reply2) => send({ ...reply2, id: request.id }),
                 () => send({
                   id: request.id,
@@ -46798,7 +47213,7 @@ var SharedThreadOwner = class {
                   }
                 })
               );
-            } else if (object8(message2) && rpcId(message2.id)) {
+            } else if (object9(message2) && rpcId(message2.id)) {
               await peer.respond(message2);
             }
           }
@@ -46883,8 +47298,8 @@ var SharedThreadBridge = class {
       }
       this.#peer = peer;
       peer.subscribe((message2) => {
-        const params = object8(message2.params) ? message2.params : {};
-        if (object8(params.thread) && params.thread.modelProvider === "codexhost" && typeof params.thread.id === "string") {
+        const params = object9(message2.params) ? message2.params : {};
+        if (object9(params.thread) && params.thread.modelProvider === "codexhost" && typeof params.thread.id === "string") {
           this.#known.add(params.thread.id);
         }
         this.#publish(message2);
@@ -46928,7 +47343,7 @@ var SharedThreadBridge = class {
     return owners;
   }
   async route(request) {
-    const params = object8(request.params) ? request.params : {};
+    const params = object9(request.params) ? request.params : {};
     const create = this.options.delegateCreates ? classifyCreateRequestRoute(request) : null;
     let shared = create !== null && create.selectedHarness !== "codex";
     if (!shared && typeof params.threadId === "string") {
@@ -46945,10 +47360,10 @@ var SharedThreadBridge = class {
     const seen = /* @__PURE__ */ new Set();
     do {
       const reply2 = await peer.request("thread/list", { ...params, cursor, limit: 200 });
-      if (!object8(reply2.result) || !Array.isArray(reply2.result.data))
+      if (!object9(reply2.result) || !Array.isArray(reply2.result.data))
         throw new Error("Shared Thread list failed");
       for (const row of reply2.result.data) {
-        if (!object8(row) || typeof row.id !== "string")
+        if (!object9(row) || typeof row.id !== "string")
           throw new Error("Invalid shared Thread row");
         rows.push(row);
         this.#known.add(row.id);
@@ -46977,7 +47392,7 @@ var SharedThreadBridge = class {
     return storedSectionPlacementV1Schema.array().parse(reply2.result);
   }
   async respond(message2) {
-    if (!object8(message2) || typeof message2.method === "string" || typeof message2.id !== "string" || !message2.id.startsWith("shared-interaction:"))
+    if (!object9(message2) || typeof message2.method === "string" || typeof message2.id !== "string" || !message2.id.startsWith("shared-interaction:"))
       return false;
     if (!this.#peer) throw new Error("Shared Thread Host is disconnected");
     await this.#peer.respond(message2);
@@ -46992,7 +47407,7 @@ var SharedThreadBridge = class {
 };
 
 // packages/host-runtime/src/remote-control-app-server.ts
-import { randomUUID as randomUUID21 } from "node:crypto";
+import { randomUUID as randomUUID23 } from "node:crypto";
 import { mkdir as mkdir17, open as open10, rename as rename13, rm as rm17 } from "node:fs/promises";
 import path37 from "node:path";
 var REMOTE_CONTROL_BRIDGE_PIPE_ENV = "CODEXHOST_REMOTE_CONTROL_BRIDGE_PIPE";
@@ -47013,7 +47428,7 @@ function nodeCompatibleWindowsPath(value2) {
   if (value2.startsWith("\\\\?\\")) return value2.slice(4);
   return value2;
 }
-function remoteControlBridgePipePath(processId = process.pid, instanceId = randomUUID21()) {
+function remoteControlBridgePipePath(processId = process.pid, instanceId = randomUUID23()) {
   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}`;
@@ -47028,7 +47443,7 @@ async function publishRemoteControlAppServerDescriptor(plan) {
   await mkdir17(directory, { recursive: true, mode: 448 });
   const temporaryPath = path37.join(
     directory,
-    `.${REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE}.${plan.descriptor.ownerPid}.${randomUUID21()}.tmp`
+    `.${REMOTE_CONTROL_BRIDGE_DESCRIPTOR_FILE}.${plan.descriptor.ownerPid}.${randomUUID23()}.tmp`
   );
   const handle = await open10(temporaryPath, "wx", 384);
   try {
@@ -47569,12 +47984,19 @@ function createHostUpdateCoordinator(options2) {
 }
 
 // packages/host-runtime/src/usage-statistics.ts
-import { randomUUID as randomUUID22 } from "node:crypto";
+import { randomUUID as randomUUID24 } from "node:crypto";
 import { mkdir as mkdir19, readFile as readFile20, readdir as readdir6, rename as rename15, rm as rm19, writeFile as writeFile11 } from "node:fs/promises";
 import path40 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;
@@ -47677,6 +48099,95 @@ function withHostSessionTitles(result, records) {
   };
 }
 
+// packages/host-runtime/src/usage-statistics-sources.ts
+import { setTimeout as delay7 } 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 delay7(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;
@@ -47737,17 +48248,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() {
@@ -47934,23 +48434,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)) {
@@ -48015,7 +48519,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}.${randomUUID22()}.tmp`;
+    const temporary = `${file2}.${randomUUID24()}.tmp`;
     try {
       await mkdir19(this.#directory, { recursive: true });
       const sources = [...cache.sources].map(([id2, source]) => [
@@ -48033,9 +48537,10 @@ var UsageStatistics = class {
       await rm19(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();
@@ -48043,26 +48548,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;
@@ -48103,7 +48602,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;
@@ -48636,7 +49135,7 @@ async function runHostRuntime(input) {
 }
 
 // packages/host-runtime/src/remote-host-install.ts
-import { createHash as createHash12, randomUUID as randomUUID23 } from "node:crypto";
+import { createHash as createHash12, randomUUID as randomUUID25 } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
 import {
   access as access4,
@@ -48735,7 +49234,7 @@ async function writeAtomic(filePath, contents, mode) {
   await mkdir20(path42.dirname(filePath), { recursive: true, mode: 448 });
   const temporary = path42.join(
     path42.dirname(filePath),
-    `.${path42.basename(filePath)}.${process.pid}.${randomUUID23()}.tmp`
+    `.${path42.basename(filePath)}.${process.pid}.${randomUUID25()}.tmp`
   );
   try {
     if (typeof contents === "string") {
@@ -48759,7 +49258,7 @@ async function writeAtomicExecutable(filePath, sourcePath) {
   await mkdir20(path42.dirname(filePath), { recursive: true, mode: 448 });
   const temporary = path42.join(
     path42.dirname(filePath),
-    `.${path42.basename(filePath)}.${process.pid}.${randomUUID23()}.tmp`
+    `.${path42.basename(filePath)}.${process.pid}.${randomUUID25()}.tmp`
   );
   try {
     await copyFile4(sourcePath, temporary);
@@ -49500,6 +49999,7 @@ var harnessBrokerMethodSchema = external_exports.enum([
   "adapter.open",
   "adapter.subagent.readSnapshot",
   "session.readSnapshot",
+  "session.readCapabilities",
   "session.refreshUsage",
   "session.execute",
   "session.commands.list",
@@ -49682,6 +50182,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({
@@ -49707,6 +50212,7 @@ var permissionSelectSchema = external_exports.object({
 }).strict();
 var brokerHostCommandSchema = external_exports.discriminatedUnion("type", [
   turnStartSchema,
+  turnSteerSchema,
   turnCancelSchema,
   interactionRespondSchema,
   modelSelectSchema,
@@ -49841,7 +50347,7 @@ var harnessOutputSchema = external_exports.custom((value2) => {
 });
 
 // packages/harness-broker/dist/server.js
-import { randomBytes as randomBytes5, randomUUID as randomUUID24 } from "node:crypto";
+import { randomBytes as randomBytes5, randomUUID as randomUUID26 } from "node:crypto";
 import { chmod as chmod6, lstat as lstat10, mkdir as mkdir21, open as open11, readFile as readFile22, rename as rename17, rm as rm21 } from "node:fs/promises";
 import net4, {} from "node:net";
 import path45 from "node:path";
@@ -49900,7 +50406,7 @@ async function assertNoLiveDescriptor(descriptorPath) {
   }
 }
 async function publishDescriptor(descriptorPath, descriptor) {
-  const temporary = `${descriptorPath}.${process.pid}.${randomUUID24()}.tmp`;
+  const temporary = `${descriptorPath}.${process.pid}.${randomUUID26()}.tmp`;
   const handle = await open11(temporary, "wx", 384);
   try {
     await handle.writeFile(`${JSON.stringify(descriptor)}
@@ -49925,6 +50431,7 @@ function sessionMetadata(record4) {
     sessionId: record4.id,
     sessionGeneration: record4.generation,
     capabilities: record4.session.capabilities,
+    readCapabilities: true,
     initialState: {
       ...initialState,
       ...record4.nativeRef ? { nativeRef: record4.nativeRef } : {},
@@ -49977,7 +50484,7 @@ async function startHarnessBrokerServer(input) {
   await assertNoLiveDescriptor(input.descriptorPath);
   if (process.platform !== "win32")
     await prepareUnixSocketPath(input.socketPath);
-  const generation = input.generation ?? randomUUID24();
+  const generation = input.generation ?? randomUUID26();
   const token = input.token ?? randomBytes5(32).toString("hex");
   const descriptor = {
     schemaVersion: 1,
@@ -50018,7 +50525,7 @@ async function startHarnessBrokerServer(input) {
   };
   const server = net4.createServer((socket) => {
     const state = {
-      id: randomUUID24(),
+      id: randomUUID26(),
       socket,
       authenticated: false,
       inputSequence: 0,
@@ -50256,7 +50763,7 @@ async function startHarnessBrokerServer(input) {
             }
           };
         }
-        const openReservation = randomUUID24();
+        const openReservation = randomUUID26();
         if (sourceKey)
           nativeWriters.set(sourceKey, openReservation);
         const provisionalReservation = openInput.kind === "create" ? openReservation : void 0;
@@ -50400,6 +50907,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") {
@@ -50431,6 +50940,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();
       }
@@ -50557,7 +51070,7 @@ async function startHarnessBrokerServer(input) {
           }
           state.authenticated = true;
           state.inputSequence = 1;
-          await send({ kind: "response", id: randomUUID24(), ok: true, value: { ready: true } });
+          await send({ kind: "response", id: randomUUID26(), ok: true, value: { ready: true } });
           return;
         }
         const parsed2 = harnessBrokerRequestSchema.safeParse(raw);