@codexhost/cli-linux-arm64 0.13.3 → 0.15.0

package/app/renderer-extension.js

@@ -178,9 +178,10 @@
     clearPendingSubmission(composer) {
       this.#pendingSubmissions.delete(this.#state(composer));
     }
+    /** Only a draft's submission creates a Thread, so only it sets the next new-Thread Agent. */
     recordSubmission(composer) {
       const state = this.#state(composer);
-      this.#lastSubmittedAgent = state.agent;
+      if (state.phase === "draft") this.#lastSubmittedAgent = state.agent;
       return state;
     }
     transfer(source, replacement, target = null) {
@@ -3265,10 +3266,10 @@
       const shape = def.shape;
       const propValues = {};
       for (const key in shape) {
-        const field = shape[key]._zod;
-        if (field.values) {
+        const field2 = shape[key]._zod;
+        if (field2.values) {
           propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
-          for (const v of field.values)
+          for (const v of field2.values)
             propValues[key].add(v);
         }
       }
@@ -14930,10 +14931,19 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   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((value) => {
+      try {
+        new Intl.DateTimeFormat("en", { timeZone: value });
+        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({
@@ -14969,7 +14979,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   });
   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. */
@@ -15009,7 +15019,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     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),
@@ -15049,6 +15059,53 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   var threadPrewarmDiscardParamsSchema = external_exports.object({ threadId: hostThreadIdSchema });
   var threadPrewarmDiscardResultSchema = external_exports.object({ discarded: external_exports.boolean() });
 
+  // ../shared-contracts/dist/thread-questions.js
+  var THREAD_QUESTIONS_LIST_METHOD = "codexhost/thread/questions/list";
+  var THREAD_QUESTION_RESPOND_METHOD = "codexhost/thread/question/respond";
+  var field = external_exports.discriminatedUnion("type", [
+    external_exports.object({
+      id: external_exports.string().min(1),
+      type: external_exports.literal("choice"),
+      prompt: external_exports.string(),
+      options: external_exports.array(external_exports.object({
+        value: external_exports.string().min(1),
+        label: external_exports.string(),
+        description: external_exports.string().optional()
+      })).min(1),
+      multiple: external_exports.boolean(),
+      allowOther: external_exports.boolean(),
+      optional: external_exports.boolean()
+    }),
+    external_exports.object({
+      id: external_exports.string().min(1),
+      type: external_exports.literal("text"),
+      prompt: external_exports.string(),
+      multiline: external_exports.boolean(),
+      secret: external_exports.literal(false),
+      optional: external_exports.boolean(),
+      placeholder: external_exports.string().optional(),
+      prefill: external_exports.string().optional()
+    })
+  ]);
+  var threadQuestionSchema = external_exports.object({
+    interactionId: external_exports.string().min(1),
+    turnId: external_exports.string().min(1),
+    title: external_exports.string().optional(),
+    questions: external_exports.array(field).min(1)
+  }).refine(({ questions }) => questions.some((q) => q.type === "choice" && q.multiple), {
+    message: "Shared cards require at least one multi-select question"
+  });
+  var threadQuestionsListParamsSchema = external_exports.strictObject({ threadId: external_exports.string().min(1) });
+  var threadQuestionsResultSchema = external_exports.object({ questions: external_exports.array(threadQuestionSchema) });
+  var threadQuestionRespondParamsSchema = external_exports.strictObject({
+    threadId: external_exports.string().min(1),
+    turnId: external_exports.string().min(1),
+    interactionId: external_exports.string().min(1),
+    answers: external_exports.record(external_exports.string(), external_exports.array(external_exports.string())),
+    cancelled: external_exports.boolean().default(false)
+  });
+  var threadQuestionRespondResultSchema = external_exports.object({ accepted: external_exports.literal(true) });
+
   // ../shared-contracts/dist/console.js
   var consoleAnnouncementSchema = external_exports.strictObject({
     title: external_exports.string().trim().min(1).max(200),
@@ -15070,6 +15127,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     "codexhost/harness/display-settings/set",
     "codexhost/harness/inspect",
     "codexhost/harness/installation",
+    "codexhost/harness/installation/start",
+    "codexhost/harness/installation/status",
     "codexhost/harness/launch-settings/get",
     "codexhost/harness/launch-settings/set",
     "codexhost/harness/web-ui/open",
@@ -15148,7 +15207,18 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   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 }) => id)).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(),
@@ -15564,7 +15634,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }).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(),
@@ -15612,7 +15684,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   var harnessInspectParamsSchema = external_exports.object({
     harnessId: harnessIdSchema,
     cwd: nonBlankTextSchema2.max(16384).optional(),
-    refresh: external_exports.boolean().optional()
+    refresh: external_exports.boolean().optional(),
+    /** `availability` asks only whether the Harness can run; see `InspectHarnessInput.purpose`. */
+    purpose: external_exports.literal("availability").optional()
   }).strict();
   var harnessWebUiOpenParamsSchema = external_exports.object({
     harnessId: harnessIdSchema
@@ -15695,6 +15769,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       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();
 
   // ../shared-contracts/dist/harness-plugins.js
   var HARNESS_PLUGIN_MANIFEST_MAX_BYTES = 32 * 1024;
@@ -15813,7 +15897,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   }).strict();
 
   // ../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"])
@@ -15823,6 +15908,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     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((value) => /^https:\/\/[^/?#@]+(?:[/?#]|$)/iu.test(value), "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(),
@@ -15830,6 +15919,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     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()
+  ]);
 
   // ../shared-contracts/dist/codex-accounts.js
   var accountIdSchema = external_exports.string().min(1).max(256).regex(/^[A-Za-z0-9._~-]+$/u);
@@ -16240,9 +16343,63 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   // ../shared-contracts/dist/index.js
   var workspaceContractVersionSchema = external_exports.literal(WORKSPACE_CONTRACT_VERSION);
 
-  // src/codex-ssh-adapter.ts
+  // src/codex-native-services.ts
+  async function loadCodexNativeServices(ownerWindow, matchesServices, importModule = (url2) => import(url2)) {
+    if (!ownerWindow.document || !ownerWindow.location) return null;
+    const page = new URL(ownerWindow.location.href);
+    const urls = /* @__PURE__ */ new Set();
+    for (const link of ownerWindow.document.querySelectorAll('link[rel="modulepreload"][href]')) {
+      const url2 = new URL(link.getAttribute("href") ?? "", page);
+      if (url2.protocol === page.protocol && url2.host === page.host && url2.pathname.endsWith(".js") && !url2.search && !url2.hash)
+        urls.add(url2.href);
+    }
+    const candidates = [...urls].sort(
+      (a, b) => Number(b.includes("/app-shared-")) - Number(a.includes("/app-shared-"))
+    );
+    const matches = /* @__PURE__ */ new Set();
+    for (const url2 of candidates) {
+      let module;
+      try {
+        module = await importModule(url2);
+      } catch {
+        continue;
+      }
+      for (const value of Object.values(module).filter(matchesServices)) matches.add(value);
+      if (matches.size > 1) throw new Error("Codex native services are unavailable in this window");
+    }
+    return [...matches][0] ?? null;
+  }
+
+  // src/codex-ssh-services.ts
   var record2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  function isSshServices(value) {
+    if (!record2(value) || !Object.hasOwn(value, "sshConnections") || !Object.hasOwn(value, "remoteConnections"))
+      return false;
+    const ssh = value.sshConnections;
+    const remote = value.remoteConnections;
+    return ssh != null && remote != null && typeof ssh.refresh === "function" && typeof ssh.save === "function" && typeof remote.getState === "function" && typeof remote.setAutoConnect === "function";
+  }
+  async function loadCodexSshServices(ownerWindow, importModule) {
+    return loadCodexNativeServices(ownerWindow, isSshServices, importModule);
+  }
+
+  // src/codex-ssh-adapter.ts
+  var record3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
   function createCodexSshClient(ownerWindow) {
+    let nativeServices;
+    function services() {
+      nativeServices ??= loadCodexSshServices(ownerWindow).then(
+        (value) => {
+          if (!value) nativeServices = void 0;
+          return value;
+        },
+        (error51) => {
+          nativeServices = void 0;
+          throw error51;
+        }
+      );
+      return nativeServices;
+    }
     function request(operation, params, signal) {
       const bridge = ownerWindow.electronBridge;
       if (!bridge?.sendMessageFromView)
@@ -16250,7 +16407,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       if (signal?.aborted) return Promise.reject(new DOMException("Aborted", "AbortError"));
       return new Promise((resolve, reject) => {
         const requestId = ownerWindow.crypto.randomUUID();
+        let settled = false;
         const finish = (error51, value) => {
+          if (settled) return;
+          settled = true;
           ownerWindow.clearTimeout(timer);
           ownerWindow.removeEventListener("message", receive);
           signal?.removeEventListener("abort", abort);
@@ -16260,10 +16420,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         const abort = () => finish(new DOMException("Aborted", "AbortError"));
         const receive = (event) => {
           const message2 = event.data;
-          if (!record2(message2) || message2.type !== "fetch-response" || message2.requestId !== requestId)
+          if (!record3(message2) || message2.type !== "fetch-response" || message2.requestId !== requestId)
             return;
           if (message2.responseType !== "success" || typeof message2.status !== "number" || message2.status < 200 || message2.status >= 300 || typeof message2.bodyJsonString !== "string") {
-            finish(new Error("Codex SSH request failed; check the native Connections settings"));
+            const detail = typeof message2.error === "string" ? `: ${message2.error}` : "";
+            finish(
+              new Error(`Codex SSH request failed; check the native Connections settings${detail}`)
+            );
             return;
           }
           try {
@@ -16278,30 +16441,47 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         );
         ownerWindow.addEventListener("message", receive);
         signal?.addEventListener("abort", abort, { once: true });
-        try {
-          Promise.resolve(
-            bridge.sendMessageFromView({
+        void (async () => {
+          const native = await services();
+          if (settled) return;
+          if (native) {
+            let result;
+            switch (operation) {
+              case "refresh-remote-connections":
+                result = await native.sshConnections.refresh();
+                break;
+              case "save-codex-managed-remote-ssh-connections":
+                result = await native.sshConnections.save(params);
+                break;
+              case "set-remote-connection-auto-connect":
+                result = await native.remoteConnections.setAutoConnect(params);
+                break;
+              case "app-server-connection-state":
+                result = await native.remoteConnections.getState(String(params.hostId));
+                break;
+            }
+            finish(null, result);
+          } else {
+            await bridge.sendMessageFromView({
               type: "fetch",
               requestId,
               method: "POST",
               url: `vscode://codex/${operation}`,
               body: JSON.stringify(params),
               reportUploadProgress: false
-            })
-          ).catch((error51) => finish(error51));
-        } catch (error51) {
-          finish(error51);
-        }
+            });
+          }
+        })().catch((error51) => finish(error51));
       });
     }
     async function list(signal) {
       const result = await request("refresh-remote-connections", {}, signal);
-      if (!record2(result) || !Array.isArray(result.remoteConnections))
+      if (!record3(result) || !Array.isArray(result.remoteConnections))
         throw new Error("Invalid Codex SSH connection list");
       return result.remoteConnections.filter(
-        (item) => !(record2(item) && ["wsl", "remote-control"].includes(String(item.source)))
+        (item) => !(record3(item) && ["wsl", "remote-control"].includes(String(item.source)))
       ).map((item) => {
-        if (!record2(item) || typeof item.hostId !== "string" || typeof item.displayName !== "string" || !["codex-managed", "discovered"].includes(String(item.source)) || typeof item.sshHost !== "string" || typeof item.autoConnect !== "boolean" || !(item.sshAlias == null || typeof item.sshAlias === "string") || !(item.identity == null || typeof item.identity === "string") || !(item.sshPort == null || Number.isInteger(item.sshPort) && Number(item.sshPort) > 0 && Number(item.sshPort) <= 65535)) {
+        if (!record3(item) || typeof item.hostId !== "string" || typeof item.displayName !== "string" || !["codex-managed", "discovered"].includes(String(item.source)) || typeof item.sshHost !== "string" || typeof item.autoConnect !== "boolean" || !(item.sshAlias == null || typeof item.sshAlias === "string") || !(item.identity == null || typeof item.identity === "string") || !(item.sshPort == null || Number.isInteger(item.sshPort) && Number(item.sshPort) > 0 && Number(item.sshPort) <= 65535)) {
           throw new Error(
             "This Codex version uses an unsupported SSH configuration; open native settings"
           );
@@ -16373,11 +16553,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       },
       async state(hostId2, signal) {
         const result = await request("app-server-connection-state", { hostId: hostId2 }, signal);
-        if (!record2(result) || typeof result.state !== "string")
+        if (!record3(result) || typeof result.state !== "string")
           throw new Error("Invalid Codex connection state");
         return {
           state: result.state,
-          error: typeof result.error === "string" ? result.error : record2(result.error) && typeof result.error.message === "string" ? result.error.message : null
+          error: typeof result.error === "string" ? result.error : record3(result.error) && typeof result.error.message === "string" ? result.error.message : null
         };
       }
     };
@@ -16455,6 +16635,545 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     return control;
   }
 
+  // ../../node_modules/lucide/dist/esm/defaultAttributes.mjs
+  var defaultAttributes = {
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 24,
+    height: 24,
+    viewBox: "0 0 24 24",
+    fill: "none",
+    stroke: "currentColor",
+    "stroke-width": 2,
+    "stroke-linecap": "round",
+    "stroke-linejoin": "round"
+  };
+
+  // ../../node_modules/lucide/dist/esm/createElement.mjs
+  var createSVGElement = ([tag, attrs, children]) => {
+    const element = document.createElementNS("http://www.w3.org/2000/svg", tag);
+    Object.keys(attrs).forEach((name) => {
+      element.setAttribute(name, String(attrs[name]));
+    });
+    if (children?.length) {
+      children.forEach((child) => {
+        const childElement = createSVGElement(child);
+        element.appendChild(childElement);
+      });
+    }
+    return element;
+  };
+  var createElement = (iconNode, customAttrs = {}) => {
+    const tag = "svg";
+    const attrs = {
+      ...defaultAttributes,
+      ...customAttrs
+    };
+    return createSVGElement([tag, attrs, iconNode]);
+  };
+
+  // ../../node_modules/lucide/dist/esm/icons/check.mjs
+  var Check = [["path", { d: "M20 6 9 17l-5-5" }]];
+
+  // ../../node_modules/lucide/dist/esm/icons/message-circle-question-mark.mjs
+  var MessageCircleQuestionMark = [
+    [
+      "path",
+      {
+        d: "M2.992 16.342a2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 1 0-4.777-4.719"
+      }
+    ],
+    ["path", { d: "M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3" }],
+    ["path", { d: "M12 17h.01" }]
+  ];
+
+  // ../../node_modules/lucide/dist/esm/icons/pencil.mjs
+  var Pencil = [
+    [
+      "path",
+      {
+        d: "M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z"
+      }
+    ],
+    ["path", { d: "m15 5 4 4" }]
+  ];
+
+  // ../../node_modules/lucide/dist/esm/icons/x.mjs
+  var X = [
+    ["path", { d: "M18 6 6 18" }],
+    ["path", { d: "m6 6 12 12" }]
+  ];
+
+  // src/renderer-question-card-style.ts
+  var QUESTION_CARD_CSS = `
+  :host {
+    display: block;
+    min-width: 0;
+    margin: 8px 0;
+    color-scheme: inherit;
+    --question-text: light-dark(#171717, #ececec);
+    --question-muted: light-dark(#737373, #a3a3a3);
+    --question-border: light-dark(rgb(0 0 0 / 8%), rgb(255 255 255 / 8%));
+    --question-selected: light-dark(#e9e9e9, #333333);
+    --question-primary: light-dark(#202020, #ececec);
+    --question-primary-text: light-dark(#fff, #171717);
+  }
+  *, ::before, ::after { box-sizing: border-box; }
+  .card {
+    display: flex;
+    flex-direction: column;
+    max-height: min(60vh, 560px);
+    overflow: hidden;
+    padding: 16px 12px 12px;
+    border: 1px solid var(--question-border);
+    border-radius: 24px;
+    background: light-dark(#f7f7f7, #262626);
+    color: var(--question-text);
+    font: 13px/1.5 system-ui, sans-serif;
+  }
+  .title { display: flex; align-items: center; gap: 10px; flex-shrink: 0; margin: 0 6px 14px; color: var(--question-muted); font-weight: 400; }
+  .question-icon { display: inline-flex; justify-content: center; align-items: center; width: 16px; height: 16px; flex-shrink: 0; }
+  svg { display: block; width: 16px; height: 16px; fill: none; stroke: currentColor; stroke-width: 1.5; stroke-linecap: round; stroke-linejoin: round; }
+  .body { min-height: 0; overflow: auto; }
+  fieldset { min-width: 0; border: 0; padding: 0; margin: 0 0 14px; }
+  fieldset:last-child { margin-bottom: 0; }
+  legend { width: 100%; padding: 0 6px; margin-bottom: 14px; font: inherit; }
+  .hint { color: var(--question-muted); font-size: 12px; margin: -10px 6px 10px; }
+  .option {
+    position: relative;
+    display: flex;
+    align-items: flex-start;
+    gap: 10px;
+    min-height: 34px;
+    padding: 6px;
+    margin: 2px 0;
+    border-radius: 12px;
+    cursor: pointer;
+    background: transparent;
+    overflow-wrap: anywhere;
+  }
+  .option:hover, .option:has(:checked) { background: var(--question-selected); }
+  input[type=checkbox], input[type=radio] {
+    appearance: none;
+    display: block;
+    flex: 0 0 21px;
+    width: 21px;
+    height: 21px;
+    margin: 0;
+    padding: 0;
+    border: 1px solid var(--question-border);
+    border-radius: 5px;
+    background: light-dark(#ededed, #303030);
+    cursor: pointer;
+  }
+  .shortcut { position: absolute; top: 6px; left: 6px; width: 21px; height: 21px; text-align: center; line-height: 21px; color: var(--question-muted); pointer-events: none; font-size: 12px; }
+  .option-copy { flex: 1; min-width: 0; white-space: pre-wrap; }
+  .option-name { display: block; font-weight: 400; }
+  .description { display: block; color: var(--question-muted); font-size: 12px; margin-top: 1px; }
+  .selected-indicator { align-self: center; visibility: hidden; color: var(--question-muted); padding-right: 4px; }
+  :checked ~ .selected-indicator { visibility: visible; }
+  .other { align-items: center; flex: 1; min-width: 0; margin: 0; }
+  .other input[type=checkbox], .other input[type=radio] { background: transparent; border-color: transparent; }
+  .other:has(:checked), .other:focus-within { background: var(--question-selected); }
+  .other:has(:checked) .pencil { color: var(--question-text); }
+  .pencil { display: flex; align-items: center; justify-content: center; }
+  .other-copy { display: flex; flex: 1; min-width: 0; }
+  input:not([type=checkbox]):not([type=radio]), textarea {
+    appearance: none;
+    display: block;
+    min-width: 0;
+    width: 100%;
+    padding: 6px;
+    border: 1px solid var(--question-border);
+    border-radius: 8px;
+    background: transparent;
+    color: var(--question-text);
+    font: inherit;
+  }
+  .other-copy input:not([type=checkbox]):not([type=radio]) { border: 0; padding: 0; }
+  textarea { min-height: 60px; resize: vertical; }
+  input::placeholder, textarea::placeholder { color: var(--question-muted); opacity: .65; }
+  input:focus-visible, textarea:focus-visible, button:focus-visible {
+    outline: 2px solid var(--question-muted);
+    outline-offset: 2px;
+  }
+  .other-copy input:focus-visible { outline: none; }
+  .other:has(input:focus-visible) { outline: 2px solid var(--question-muted); outline-offset: -2px; }
+  .error { flex-shrink: 0; color: light-dark(#b42318, #ffaaa3); font-size: 12px; }
+  .error:not(:empty) { margin: 8px 6px 0; }
+  .footer { display: flex; align-items: center; gap: 8px; flex-shrink: 0; margin-top: 8px; }
+  .actions { display: flex; justify-content: flex-end; gap: 8px; margin-left: auto; flex-shrink: 0; }
+  button {
+    appearance: none;
+    min-height: 28px;
+    padding: 3px 10px;
+    border: 1px solid var(--question-border);
+    border-radius: 999px;
+    background: transparent;
+    color: var(--question-text);
+    font: inherit;
+    font-weight: 400;
+    cursor: pointer;
+  }
+  button:hover { background: var(--question-selected); }
+  button.primary { background: var(--question-primary); color: var(--question-primary-text); border-color: transparent; }
+  button.primary:hover { opacity: .85; }
+  button.dismiss { display: flex; align-items: center; justify-content: center; border: 0; padding: 0; min-height: 24px; width: 24px; margin-left: auto; color: var(--question-muted); }
+  :disabled { cursor: wait; opacity: .5; }
+  @media (max-width: 420px) { .footer { flex-wrap: wrap; } .footer > .other { flex-basis: 100%; } }
+  @media (forced-colors: active) {
+    .card, input, textarea { background: Canvas; color: CanvasText; }
+    button, .card, input[type=checkbox], input[type=radio] { border-color: ButtonBorder; }
+    .option:has(:checked) { outline: 1px solid Highlight; outline-offset: -1px; }
+    button.primary { background: Highlight; color: HighlightText; }
+  }
+`;
+
+  // src/renderer-question-card.ts
+  function createQuestionCard(document2, question, submit, initial = {}) {
+    const icon2 = (node) => document2.adoptNode(
+      createElement(node, {
+        width: 16,
+        height: 16,
+        "aria-hidden": "true",
+        focusable: "false"
+      })
+    );
+    const selectedIndicator = () => {
+      const selected = document2.createElement("span");
+      selected.className = "selected-indicator";
+      selected.setAttribute("aria-hidden", "true");
+      selected.append(icon2(Check));
+      return selected;
+    };
+    const root = document2.createElement("section");
+    root.dataset.codexhostQuestion = question.interactionId;
+    root.setAttribute("aria-label", question.title ?? "Question");
+    root.addEventListener("keydown", (event) => {
+      event.stopPropagation();
+      if (event.key === "Enter" && event.composedPath()[0] instanceof HTMLInputElement)
+        event.preventDefault();
+    });
+    const shadow = root.attachShadow({ mode: "open" });
+    const style = document2.createElement("style");
+    style.textContent = QUESTION_CARD_CSS;
+    const surface = document2.createElement("div");
+    surface.className = "card";
+    shadow.append(style, surface);
+    const title = document2.createElement("div");
+    title.className = "title";
+    const titleIcon = document2.createElement("span");
+    titleIcon.className = "question-icon";
+    titleIcon.append(icon2(MessageCircleQuestionMark));
+    titleIcon.setAttribute("aria-hidden", "true");
+    const titleText = document2.createElement("span");
+    titleText.textContent = question.title?.trim() || "Question";
+    const dismiss = document2.createElement("button");
+    dismiss.type = "button";
+    dismiss.className = "dismiss";
+    dismiss.append(icon2(X));
+    dismiss.setAttribute("aria-label", "Dismiss question");
+    title.append(titleIcon, titleText, dismiss);
+    const body = document2.createElement("div");
+    body.className = "body";
+    surface.append(title, body);
+    const footer = document2.createElement("div");
+    footer.className = "footer";
+    const readers = /* @__PURE__ */ new Map();
+    const controls = [dismiss];
+    const validOther = [];
+    for (const [index, field2] of question.questions.entries()) {
+      const group = document2.createElement("fieldset");
+      const legend = document2.createElement("legend");
+      legend.textContent = field2.prompt;
+      group.append(legend);
+      const saved = initial[field2.id] ?? [];
+      if (field2.type === "text") {
+        const input = document2.createElement(field2.multiline ? "textarea" : "input");
+        input.value = saved[0] ?? field2.prefill ?? "";
+        input.placeholder = field2.placeholder ?? "Your answer";
+        input.setAttribute("aria-label", field2.prompt);
+        controls.push(input);
+        group.append(input);
+        readers.set(field2.id, () => input.value.trim() ? [input.value] : []);
+      } else {
+        const hint = document2.createElement("div");
+        hint.className = "hint";
+        hint.textContent = "Select all that apply";
+        if (field2.multiple) group.append(hint);
+        const inputs = [];
+        const name = `codexhost-${question.interactionId}-${index}`;
+        for (const [optionIndex, option] of field2.options.entries()) {
+          const label = document2.createElement("label");
+          label.className = "option";
+          const input = document2.createElement("input");
+          input.type = field2.multiple ? "checkbox" : "radio";
+          input.name = name;
+          input.value = option.value;
+          input.checked = saved.includes(option.value);
+          const shortcut = document2.createElement("span");
+          shortcut.className = "shortcut";
+          shortcut.setAttribute("aria-hidden", "true");
+          shortcut.textContent = String(optionIndex + 1);
+          const selected = selectedIndicator();
+          const text = document2.createElement("span");
+          text.className = "option-copy";
+          const optionName = document2.createElement("span");
+          optionName.className = "option-name";
+          optionName.textContent = option.label;
+          text.append(optionName);
+          if (option.description) {
+            const description = document2.createElement("span");
+            description.className = "description";
+            description.textContent = option.description;
+            text.append(description);
+          }
+          label.append(input, shortcut, text, selected);
+          group.append(label);
+          inputs.push(input);
+          controls.push(input);
+        }
+        let other;
+        let notes;
+        if (field2.allowOther) {
+          const label = document2.createElement("label");
+          label.className = "option other";
+          other = document2.createElement("input");
+          other.type = field2.multiple ? "checkbox" : "radio";
+          other.name = name;
+          other.setAttribute("aria-label", `Other: ${field2.prompt}`);
+          const unknown2 = saved.find(
+            (value) => !field2.options.some((option) => option.value === value)
+          );
+          other.checked = unknown2 !== void 0;
+          notes = document2.createElement("input");
+          notes.value = unknown2 ?? "";
+          notes.placeholder = "Or write your own response";
+          notes.setAttribute("aria-label", `${field2.prompt}: Other`);
+          const checkbox = other;
+          const otherText = notes;
+          validOther.push(() => !checkbox.checked || otherText.value.trim().length > 0);
+          notes.addEventListener("input", () => {
+            checkbox.checked = true;
+          });
+          const copy = document2.createElement("span");
+          copy.className = "other-copy";
+          copy.append(notes);
+          const pencil = document2.createElement("span");
+          pencil.className = "shortcut pencil";
+          pencil.append(icon2(Pencil));
+          pencil.setAttribute("aria-hidden", "true");
+          const selected = selectedIndicator();
+          label.append(other, pencil, copy, selected);
+          if (question.questions.length === 1) footer.append(label);
+          else group.append(label);
+          controls.push(other, notes);
+        }
+        readers.set(field2.id, () => [
+          ...inputs.filter((input) => input.checked).map((input) => input.value),
+          ...other?.checked && notes?.value.trim() ? [notes.value] : []
+        ]);
+      }
+      body.append(group);
+    }
+    const error51 = document2.createElement("div");
+    error51.setAttribute("role", "alert");
+    error51.className = "error";
+    const actions = document2.createElement("div");
+    actions.className = "actions";
+    const readAnswers = () => Object.fromEntries([...readers].map(([id, read]) => [id, read()]));
+    let busy = false;
+    const send = async (cancelled) => {
+      if (busy) return;
+      const answers = cancelled ? {} : readAnswers();
+      if (!cancelled && validOther.some((valid) => !valid())) {
+        error51.textContent = "Type an answer for each selected Other option.";
+        return;
+      }
+      if (!cancelled && question.questions.some((field2) => !field2.optional && !answers[field2.id]?.length)) {
+        error51.textContent = "Answer each required question before submitting.";
+        return;
+      }
+      busy = true;
+      error51.textContent = "";
+      for (const control of controls) control.disabled = true;
+      try {
+        await submit(answers, cancelled);
+      } catch {
+        error51.textContent = "Could not submit. The question may have closed. Try again if it is still available.";
+      } finally {
+        busy = false;
+        for (const control of controls) control.disabled = false;
+      }
+    };
+    for (const [label, cancelled] of [
+      ["Skip", true],
+      ["Send", false]
+    ]) {
+      const button2 = document2.createElement("button");
+      button2.type = "button";
+      button2.textContent = label;
+      if (!cancelled) button2.className = "primary";
+      button2.addEventListener("click", () => {
+        void send(cancelled);
+      });
+      controls.push(button2);
+      actions.append(button2);
+    }
+    dismiss.addEventListener("click", () => {
+      void send(true);
+    });
+    footer.append(actions);
+    surface.append(error51, footer);
+    return {
+      root,
+      readAnswers,
+      dispose() {
+        root.remove();
+      }
+    };
+  }
+
+  // src/renderer-request-sender.ts
+  var RendererMethodUnavailableError = class extends Error {
+    constructor(method, cause) {
+      super(`${method} is unsupported on this Host connection`, { cause });
+      this.method = method;
+      this.name = "RendererMethodUnavailableError";
+    }
+    method;
+    code = -32601;
+  };
+  function isUnsupportedMethod(error51, method) {
+    if (typeof error51 !== "object" || error51 === null) return false;
+    const code = "code" in error51 ? error51.code : void 0;
+    const message2 = "message" in error51 ? error51.message : void 0;
+    return code === -32601 || code === -32600 && typeof message2 === "string" && message2.startsWith(`Invalid request: unknown variant \`${method}\``);
+  }
+  function createRendererRequestSender(send) {
+    const unsupported = /* @__PURE__ */ new Map();
+    return async (method, params, options) => {
+      const known = unsupported.get(method);
+      if (known) throw known;
+      try {
+        return await (options === void 0 ? send(method, params) : send(method, params, options));
+      } catch (error51) {
+        if (!method.startsWith("codexhost/") || !isUnsupportedMethod(error51, method)) throw error51;
+        const unavailable = new RendererMethodUnavailableError(method, error51);
+        unsupported.set(method, unavailable);
+        throw unavailable;
+      }
+    };
+  }
+
+  // src/renderer-questions.ts
+  function same(a, b) {
+    return a?.hostId === b?.hostId && a?.threadId === b?.threadId && a?.composer === b?.composer && a?.route === b?.route;
+  }
+  function installRendererQuestions(window2, readContext) {
+    let disposed = false;
+    let inFlight = false;
+    let revision = 0;
+    let context = null;
+    let card = null;
+    let cardKey = null;
+    const unsupported = /* @__PURE__ */ new WeakSet();
+    const drafts = /* @__PURE__ */ new Map();
+    const clear = (retain = true) => {
+      if (retain && card && cardKey) {
+        drafts.set(cardKey, card.readAnswers());
+        const oldest = drafts.keys().next().value;
+        if (drafts.size > 50 && oldest !== void 0) drafts.delete(oldest);
+      }
+      card?.dispose();
+      card = null;
+      cardKey = null;
+    };
+    const refresh = async () => {
+      if (disposed) return;
+      const next = readContext();
+      if (!same(context, next)) {
+        clear();
+        context = next;
+        revision++;
+      }
+      const current = context;
+      if (!current || inFlight || unsupported.has(current.route)) return;
+      const startedRevision = revision;
+      inFlight = true;
+      try {
+        const raw = await current.route.sendRequest(
+          THREAD_QUESTIONS_LIST_METHOD,
+          { threadId: current.threadId },
+          { priority: "background", timeoutMs: 5e3 }
+        );
+        if (disposed || revision !== startedRevision || !same(current, readContext())) return;
+        const question = threadQuestionsResultSchema.parse(raw).questions[0];
+        if (!question) {
+          if (cardKey) drafts.delete(cardKey);
+          clear(false);
+          return;
+        }
+        const key = JSON.stringify([
+          current.hostId,
+          current.threadId,
+          question.turnId,
+          question.interactionId
+        ]);
+        if (cardKey === key && card?.root.isConnected) return;
+        clear(cardKey === key);
+        cardKey = key;
+        card = createQuestionCard(
+          current.composer.ownerDocument,
+          question,
+          async (answers, cancelled) => {
+            if (disposed || !same(current, readContext()) || cardKey !== key)
+              throw new Error("Question owner changed");
+            const raw2 = await current.route.sendRequest(
+              THREAD_QUESTION_RESPOND_METHOD,
+              {
+                threadId: current.threadId,
+                turnId: question.turnId,
+                interactionId: question.interactionId,
+                answers,
+                cancelled
+              },
+              { priority: "interactive", timeoutMs: 1e4 }
+            );
+            threadQuestionRespondResultSchema.parse(raw2);
+            drafts.delete(key);
+            if (same(current, context)) {
+              revision++;
+              if (cardKey === key) clear(false);
+            }
+          },
+          drafts.get(key)
+        );
+        current.composer.before(card.root);
+      } catch (error51) {
+        if (isUnsupportedMethod(error51, THREAD_QUESTIONS_LIST_METHOD)) unsupported.add(current.route);
+        if (revision === startedRevision && same(current, context)) clear();
+      } finally {
+        inFlight = false;
+      }
+    };
+    const timer = window2.setInterval(() => {
+      void refresh();
+    }, 750);
+    void refresh();
+    return {
+      refresh,
+      refreshContext() {
+        if (!same(context, readContext()) || card && !card.root.isConnected) void refresh();
+      },
+      dispose() {
+        disposed = true;
+        window2.clearInterval(timer);
+        clear(false);
+        drafts.clear();
+      }
+    };
+  }
+
   // ../desktop-control/dist/renderer-react-ownership.js
   var REACT_FIBER_WALK_LIMIT_EVENT = "codexhost:react-fiber-walk-limit";
   function committedReactAncestors(value) {
@@ -16784,42 +17503,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     return fallback;
   }
 
-  // ../../node_modules/lucide/dist/esm/defaultAttributes.mjs
-  var defaultAttributes = {
-    xmlns: "http://www.w3.org/2000/svg",
-    width: 24,
-    height: 24,
-    viewBox: "0 0 24 24",
-    fill: "none",
-    stroke: "currentColor",
-    "stroke-width": 2,
-    "stroke-linecap": "round",
-    "stroke-linejoin": "round"
-  };
-
-  // ../../node_modules/lucide/dist/esm/createElement.mjs
-  var createSVGElement = ([tag, attrs, children]) => {
-    const element = document.createElementNS("http://www.w3.org/2000/svg", tag);
-    Object.keys(attrs).forEach((name) => {
-      element.setAttribute(name, String(attrs[name]));
-    });
-    if (children?.length) {
-      children.forEach((child) => {
-        const childElement = createSVGElement(child);
-        element.appendChild(childElement);
-      });
-    }
-    return element;
-  };
-  var createElement = (iconNode, customAttrs = {}) => {
-    const tag = "svg";
-    const attrs = {
-      ...defaultAttributes,
-      ...customAttrs
-    };
-    return createSVGElement([tag, attrs, iconNode]);
-  };
-
   // ../../node_modules/lucide/dist/esm/icons/boxes.mjs
   var Boxes = [
     [
@@ -17124,12 +17807,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     ["path", { d: "M12 17h.01" }]
   ];
 
-  // ../../node_modules/lucide/dist/esm/icons/x.mjs
-  var X = [
-    ["path", { d: "M18 6 6 18" }],
-    ["path", { d: "m6 6 12 12" }]
-  ];
-
   // ../../node_modules/lucide/dist/esm/icons/users.mjs
   var Users = [
     ["path", { d: "M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2" }],
@@ -17553,7 +18230,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   }
 
   // src/settings/harness-version-panel.ts
-  function createHarnessVersionPanel(document2, messages, signal, agent, client) {
+  function createHarnessVersionPanel(document2, messages, signal, agent, client, onChange = () => void 0) {
     const panel = document2.createElement("section");
     panel.className = "settings-harness-version";
     panel.dataset.harnessVersion = agent;
@@ -17579,37 +18256,67 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     panel.append(heading, versions, status, actions, note);
     let state;
     let busy = false;
+    let updating = false;
     let unsupported = false;
+    let updatePromise = null;
     const render = () => {
+      heading.textContent = state?.versionKind === "application" ? messages.harnessVersionApplicationTitle : messages.harnessVersionTitle;
       current.textContent = `${messages.harnessVersionCurrent}: ${state?.currentVersion ?? "\u2014"}`;
       latest.textContent = `${messages.harnessVersionLatest}: ${harnessVersionLabel(state, messages.harnessVersion)}`;
       update.disabled = busy || signal.aborted || !state?.canUpdate || !state.updateAvailable;
+      const manualUrl = !state?.canUpdate && state?.updateAvailable ? state.manualUpdateUrl : void 0;
+      actions.replaceChildren(update);
+      update.hidden = !busy && !signal.aborted && Boolean(manualUrl);
+      if (update.hidden && manualUrl) {
+        const download2 = document2.createElement("a");
+        download2.className = "settings-command-button settings-command-button--secondary";
+        download2.dataset.harnessVersionAction = "download-update";
+        download2.textContent = messages.harnessVersionDownloadUpdate;
+        download2.href = manualUrl;
+        download2.target = "_blank";
+        download2.rel = "noopener noreferrer";
+        actions.append(download2);
+      }
       update.textContent = state?.canUpdate && state.latestVersion !== "Unknown" && !state.updateAvailable ? messages.harnessVersionUpToDate : messages.harnessVersionUpdate;
       const detail = harnessVersionNote(state, messages.harnessVersion);
-      note.textContent = detail ? `${detail} ${messages.harnessVersionNote}` : messages.harnessVersionNote;
+      note.textContent = detail ? !state?.canUpdate ? detail : `${detail} ${messages.harnessVersionNote}` : messages.harnessVersionNote;
     };
     const run = async (action) => {
-      if (busy || unsupported || signal.aborted) return;
-      if (action === "update" && (!state?.canUpdate || !state.updateAvailable)) return;
+      if (busy || unsupported || signal.aborted) return false;
+      if (action === "update" && (!state?.canUpdate || !state.updateAvailable)) return false;
       busy = true;
+      updating = action === "update";
+      onChange();
       status.textContent = action === "check" ? messages.harnessVersionChecking : messages.harnessVersionUpdating;
       render();
       try {
         const result = await client.run(action);
-        if (signal.aborted) return;
+        if (signal.aborted) return false;
         state = result;
         status.textContent = !result.canUpdate ? messages.harnessVersionManual : action === "update" ? result.updateAvailable ? messages.harnessVersionFailed : messages.harnessVersionUpdated : "";
+        return result.canUpdate && !result.updateAvailable;
       } catch (error51) {
-        if (signal.aborted) return;
+        if (signal.aborted) return false;
         unsupported = typeof error51 === "object" && error51 !== null && "code" in error51 && (error51.code === -32601 || error51.code === -32078);
         status.textContent = unsupported ? messages.harnessVersionUnsupported : messages.harnessVersionFailed;
         if (state) state = { ...state, canUpdate: false };
+        return false;
       } finally {
         busy = false;
-        if (!signal.aborted) render();
+        updating = false;
+        if (!signal.aborted) {
+          render();
+          onChange();
+        }
       }
     };
-    update.addEventListener("click", () => void run("update"));
+    const updateVersion = () => {
+      updatePromise ??= run("update").finally(() => {
+        updatePromise = null;
+      });
+      return updatePromise;
+    };
+    update.addEventListener("click", () => void updateVersion());
     const owner = document2.defaultView;
     let checkFrame = null;
     let checkTimer = null;
@@ -17636,7 +18343,95 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     } else {
       void run("check");
     }
-    return panel;
+    return {
+      element: panel,
+      get state() {
+        return state;
+      },
+      get updating() {
+        return updating;
+      },
+      update: updateVersion
+    };
+  }
+
+  // src/settings/connection-versions.ts
+  function createConnectionVersions(document2, messages, signal, diagnostics, onChange) {
+    const panels = /* @__PURE__ */ new Map();
+    const installation = diagnostics?.installation?.bind(diagnostics);
+    return {
+      get(hostId2, agent) {
+        if (!installation || signal.aborted) return void 0;
+        const key = JSON.stringify([hostId2, agent]);
+        let panel = panels.get(key);
+        if (!panel) {
+          panel = createHarnessVersionPanel(
+            document2,
+            messages,
+            signal,
+            agent,
+            {
+              run: (action) => installation(hostId2, agent, action)
+            },
+            onChange
+          );
+          panels.set(key, panel);
+        }
+        return panel;
+      }
+    };
+  }
+
+  // src/settings/connection-updates.ts
+  function createConnectionUpdates(document2, messages, signal, onChange) {
+    const batches = /* @__PURE__ */ new Map();
+    const eligible = (panels) => panels.filter((panel) => panel.state?.updateAvailable && panel.state.canUpdate);
+    const start = async (hostId2, panels) => {
+      if (signal.aborted || batches.get(hostId2)?.running) return;
+      const targets = eligible(panels);
+      if (!targets.length) return;
+      const batch = { running: true, total: targets.length, succeeded: 0, failed: 0 };
+      batches.set(hostId2, batch);
+      onChange();
+      await Promise.all(
+        targets.map(async (panel) => {
+          try {
+            if (await panel.update()) batch.succeeded++;
+            else batch.failed++;
+          } catch {
+            batch.failed++;
+          }
+          if (!signal.aborted) onChange();
+        })
+      );
+      batch.running = false;
+      if (!signal.aborted) onChange();
+    };
+    return {
+      createControls(hostId2, panels) {
+        const batch = batches.get(hostId2);
+        const count3 = eligible(panels).length;
+        const button2 = document2.createElement("button");
+        button2.type = "button";
+        button2.className = "settings-command-button settings-command-button--secondary settings-connection-update-all";
+        button2.dataset.connectionAction = "update-all";
+        button2.disabled = signal.aborted || Boolean(batch?.running) || !count3;
+        button2.title = messages.harnessUpdateAllDescription;
+        const label = batch?.running ? `${messages.harnessUpdateAllProgress} ${batch.succeeded + batch.failed}/${batch.total}` : count3 ? `${messages.harnessUpdateAll} (${count3})` : messages.harnessUpdateAll;
+        button2.append(createRendererSettingsIcon("download", 15), label);
+        button2.addEventListener("click", () => {
+          if (!button2.disabled) void start(hostId2, panels);
+        });
+        const result = document2.createElement("p");
+        result.className = "settings-connection-update-result";
+        result.setAttribute("role", "status");
+        result.hidden = !batch || batch.running;
+        if (batch && !batch.running) {
+          result.textContent = messages.harnessUpdateAllResult.replace("{succeeded}", String(batch.succeeded)).replace("{failed}", String(batch.failed));
+        }
+        return { button: button2, result };
+      }
+    };
   }
 
   // src/settings/connections-page.ts
@@ -17804,6 +18599,7 @@ ${error51.stderrTail}`] : []
     status.dataset.connectionTone = connectionStatusTone(item.availability, item.error !== null);
     status.setAttribute("role", "cell");
     status.textContent = item.error?.code === "authenticationRequired" ? messages.connectionLoginRequired : item.error?.code === "configurationRequired" ? messages.connectionConfigurationRequired : connectionStatusLabel(item.availability, messages, item.error !== null);
+    const version2 = item.version;
     const action = document2.createElement("div");
     action.className = "settings-connection-row__action";
     action.setAttribute("role", "cell");
@@ -17833,6 +18629,31 @@ ${error51.stderrTail}`] : []
       });
       action.append(viewError);
     }
+    if (version2?.state?.updateAvailable && !version2.updating) {
+      const available = document2.createElement("span");
+      available.className = "settings-connection-version-available";
+      available.textContent = messages.harnessVersionAvailable;
+      available.title = `${messages.harnessVersionCurrent}: ${version2.state.currentVersion ?? "\u2014"}
+${messages.harnessVersionLatest}: ${harnessVersionLabel(version2.state, messages.harnessVersion)}`;
+      action.append(available);
+    }
+    if (version2?.state?.updateAvailable && version2.state.canUpdate) {
+      const update = document2.createElement("button");
+      update.type = "button";
+      update.className = "settings-connection-install-link";
+      update.dataset.connectionAction = "update";
+      update.disabled = version2.updating;
+      update.title = messages.harnessVersionUpdate;
+      update.setAttribute("aria-label", `${messages.harnessVersionUpdate}: ${item.name}`);
+      update.append(createRendererSettingsIcon("download", 17));
+      update.addEventListener("click", (event) => {
+        event.stopPropagation();
+        if (update.disabled) return;
+        void version2.update();
+        select();
+      });
+      action.append(update);
+    }
     if (group) {
       const toggle = document2.createElement("button");
       toggle.type = "button";
@@ -18124,8 +18945,6 @@ ${error51.stderrTail}`] : []
         let selectedHostId = null;
         let selectedItemKey = null;
         let launchControls = null;
-        const versionPanels = /* @__PURE__ */ new Map();
-        const updatingVersions = /* @__PURE__ */ new Set();
         const hostNames = /* @__PURE__ */ new Map();
         let latestSnapshot = null;
         let disposeHostScroller = () => void 0;
@@ -18154,7 +18973,15 @@ ${error51.stderrTail}`] : []
           renderFrame = null;
         };
         const diagnostics = getDiagnostics();
+        const versions = createConnectionVersions(
+          document2,
+          messages,
+          context.signal,
+          diagnostics,
+          scheduleRender
+        );
         const installs = diagnostics ? harnessInstallStore(diagnostics) : null;
+        const updates = createConnectionUpdates(document2, messages, context.signal, scheduleRender);
         const runRefresh = () => {
           if (pending || !diagnostics) return;
           pending = true;
@@ -18290,10 +19117,13 @@ ${error51.stderrTail}`] : []
               const agent = item.agentSnapshot?.agent;
               if (!agent) return item;
               const state = installs?.get(selectedHost.hostId, agent);
+              const availability = state?.status ?? item.availability;
+              const version2 = item.agentSnapshot?.availability !== "notInstalled" && availability !== "installing" && availability !== "checking" ? versions.get(selectedHost.hostId, agent) : void 0;
               return {
                 ...item,
                 ...state ? { availability: state.status } : {},
-                ...updatingVersions.has(JSON.stringify([selectedHost.hostId, agent])) ? { availability: "updating" } : {},
+                ...version2 ? { version: version2 } : {},
+                ...version2?.updating ? { availability: "updating" } : {},
                 ...state?.error ? { installError: state.error } : {},
                 ...diagnostics?.installation && harnessHasInstallCommands(item.agentSnapshot?.plugin) ? {
                   install: () => {
@@ -18330,30 +19160,7 @@ ${error51.stderrTail}`] : []
               runRefresh
             );
             launchControls = { hostId: selectedHost.hostId, itemKey: item.key, element };
-            const agent = item.agentSnapshot?.agent;
-            const installation = diagnostics?.installation?.bind(diagnostics);
-            if (agent && item.agentSnapshot?.availability !== "notInstalled" && item.availability !== "installing" && item.availability !== "checking" && installation) {
-              const key = JSON.stringify([selectedHost.hostId, agent]);
-              let panel = versionPanels.get(key);
-              if (!panel) {
-                const hostId2 = selectedHost.hostId;
-                panel = createHarnessVersionPanel(document2, messages, context.signal, agent, {
-                  async run(action) {
-                    if (action !== "update") return installation(hostId2, agent, action);
-                    updatingVersions.add(key);
-                    if (diagnostics) render(diagnostics.snapshot());
-                    try {
-                      return await installation(hostId2, agent, action);
-                    } finally {
-                      updatingVersions.delete(key);
-                      if (!context.signal.aborted && diagnostics) render(diagnostics.snapshot());
-                    }
-                  }
-                });
-                versionPanels.set(key, panel);
-              }
-              inspector.append(panel);
-            }
+            if (item.version) inspector.append(item.version.element);
           };
           const pinnedItem = items.find((item) => item.key === "renderer-adapter");
           if (pinnedItem) {
@@ -18509,7 +19316,14 @@ ${error51.stderrTail}`] : []
           }
           const selectedItem = items.find((item) => item.key === selectedItemKey) ?? items[0];
           if (selectedItem) selectItem(selectedItem);
-          list.append(hostStrip, tableHeader, rows);
+          const updateControls = updates.createControls(
+            selectedHost.hostId,
+            items.flatMap((item) => item.version ? [item.version] : [])
+          );
+          const hostHeader = document2.createElement("div");
+          hostHeader.className = "settings-connection-host-header";
+          hostHeader.append(hostStrip, updateControls.button);
+          list.append(hostHeader, updateControls.result, tableHeader, rows);
           layout.append(list, inspector);
           content.replaceChildren(layout);
           disposeHostScroller = configureHostScroller(
@@ -18696,12 +19510,13 @@ ${error51.stderrTail}`] : []
     notAvailable: "Not available",
     runtimeCapabilityNotInstalled: "This runtime capability is not installed yet.",
     sessionImportHarness: "Harness",
+    sessionImportSelectHost: "Select the Host to import sessions from",
     sessionImportDescription: "Sessions keep their original project path. If a folder is not in the Codex sidebar, add it as a project first. Original history remains managed by the Harness.",
-    sessionImportAvailabilityNote: "Available Harnesses come from the local Host. If activity is unknown, close the session in its native client before importing to avoid concurrent writes.",
+    sessionImportAvailabilityNote: "Available Harnesses come from the selected Host. If activity is unknown, close the session in its native client before importing to avoid concurrent writes.",
     sessionImportRefresh: "Refresh",
-    sessionImportRefreshing: "Loading local sessions...",
-    sessionImportUnavailable: "Session import is unavailable for this local Harness or its current protocol. Update the Host/plugin or choose another Harness.",
-    sessionImportEmpty: "No local sessions are available to import.",
+    sessionImportRefreshing: "Loading sessions from the selected Host...",
+    sessionImportUnavailable: "Session import is unavailable for this Harness or the selected Host protocol. Update the Host/plugin or choose another Harness.",
+    sessionImportEmpty: "No sessions are available to import on the selected Host.",
     sessionImportSearch: "Search",
     sessionImportSearchPlaceholder: "Search titles, session IDs or project paths",
     sessionImportNoMatches: "No sessions match your search.",
@@ -18709,7 +19524,7 @@ ${error51.stderrTail}`] : []
     sessionImportPrevious: "Previous",
     sessionImportNext: "Next",
     sessionImportPageSummary: "Page {page} of {pages} \xB7 {total} sessions",
-    sessionImportLoadFailed: "Local sessions could not be loaded. Check directory access or duplicate session IDs, then retry.",
+    sessionImportLoadFailed: "Sessions could not be loaded from the selected Host. Check directory access or duplicate session IDs, then retry.",
     sessionImportFailed: "The session could not be imported.",
     sessionImportUntitled: "Untitled session",
     sessionImportUpdatedAt: "Updated",
@@ -18814,10 +19629,17 @@ ${error51.stderrTail}`] : []
     connectionInstallRunning: "Installing on the selected Host. You can leave this page; login or setup may still be required afterward.",
     harnessVersion: harnessVersionEnglish,
     harnessVersionTitle: "Harness CLI version",
+    harnessVersionApplicationTitle: "Application version",
     harnessVersionCurrent: "Current version",
     harnessVersionLatest: "Latest version",
     harnessVersionChecking: "Checking versions\u2026",
+    harnessVersionAvailable: "Update available",
     harnessVersionUpdate: "Update",
+    harnessVersionDownloadUpdate: "Download update",
+    harnessUpdateAll: "Update all",
+    harnessUpdateAllProgress: "Updating",
+    harnessUpdateAllDescription: "Update all eligible Harnesses on the selected Host.",
+    harnessUpdateAllResult: "Updated {succeeded}; failed {failed}.",
     harnessVersionUpdating: "Updating\u2026",
     harnessVersionUpToDate: "Up to date",
     harnessVersionUpdated: "Update verified. New sessions will use the new version.",
@@ -18969,12 +19791,13 @@ ${error51.stderrTail}`] : []
     notAvailable: "\u6682\u4E0D\u53EF\u7528",
     runtimeCapabilityNotInstalled: "\u8FD0\u884C\u65F6\u5C1A\u672A\u5B89\u88C5\u8BE5\u9879\u80FD\u529B\uFF0C\u56E0\u6B64\u6682\u4E0D\u53EF\u7528\u3002",
     sessionImportHarness: "Harness",
+    sessionImportSelectHost: "\u8BF7\u9009\u62E9\u8981\u5BFC\u5165\u4F1A\u8BDD\u7684 Host",
     sessionImportDescription: "\u4F1A\u8BDD\u5C06\u4FDD\u7559\u539F\u59CB\u9879\u76EE\u8DEF\u5F84\uFF1B\u82E5\u8BE5\u6587\u4EF6\u5939\u5C1A\u672A\u51FA\u73B0\u5728 Codex \u4FA7\u680F\uFF0C\u8BF7\u5148\u5C06\u5176\u6DFB\u52A0\u4E3A\u9879\u76EE\u3002\u539F\u59CB\u5386\u53F2\u4ECD\u7531 Harness \u7BA1\u7406\u3002",
-    sessionImportAvailabilityNote: "\u53EF\u9009 Harness \u6765\u81EA\u672C\u5730 Host\u3002\u8FD0\u884C\u72B6\u6001\u672A\u77E5\u65F6\uFF0C\u8BF7\u5148\u5728\u539F\u751F\u5BA2\u6237\u7AEF\u5173\u95ED\u8BE5\u4F1A\u8BDD\u518D\u5BFC\u5165\uFF0C\u907F\u514D\u540C\u65F6\u5199\u5165\u3002",
+    sessionImportAvailabilityNote: "\u53EF\u9009 Harness \u6765\u81EA\u5F53\u524D Host\u3002\u8FD0\u884C\u72B6\u6001\u672A\u77E5\u65F6\uFF0C\u8BF7\u5148\u5728\u539F\u751F\u5BA2\u6237\u7AEF\u5173\u95ED\u8BE5\u4F1A\u8BDD\u518D\u5BFC\u5165\uFF0C\u907F\u514D\u540C\u65F6\u5199\u5165\u3002",
     sessionImportRefresh: "\u5237\u65B0",
-    sessionImportRefreshing: "\u6B63\u5728\u8BFB\u53D6\u672C\u5730\u4F1A\u8BDD\u2026\u2026",
-    sessionImportUnavailable: "\u672C\u5730 Harness \u6216\u5F53\u524D\u534F\u8BAE\u6682\u4E0D\u652F\u6301\u4F1A\u8BDD\u5BFC\u5165\uFF0C\u8BF7\u66F4\u65B0 Host/\u63D2\u4EF6\u6216\u9009\u62E9\u5176\u4ED6 Harness\u3002",
-    sessionImportEmpty: "\u6CA1\u6709\u53EF\u5BFC\u5165\u7684\u672C\u5730\u4F1A\u8BDD\u3002",
+    sessionImportRefreshing: "\u6B63\u5728\u8BFB\u53D6\u5F53\u524D Host \u4E0A\u7684\u4F1A\u8BDD\u2026\u2026",
+    sessionImportUnavailable: "\u8BE5 Harness \u6216\u5F53\u524D Host \u534F\u8BAE\u6682\u4E0D\u652F\u6301\u4F1A\u8BDD\u5BFC\u5165\uFF0C\u8BF7\u66F4\u65B0 Host/\u63D2\u4EF6\u6216\u9009\u62E9\u5176\u4ED6 Harness\u3002",
+    sessionImportEmpty: "\u5F53\u524D Host \u4E0A\u6CA1\u6709\u53EF\u5BFC\u5165\u7684\u4F1A\u8BDD\u3002",
     sessionImportSearch: "\u641C\u7D22",
     sessionImportSearchPlaceholder: "\u641C\u7D22\u6807\u9898\u3001\u4F1A\u8BDD ID \u6216\u9879\u76EE\u8DEF\u5F84",
     sessionImportNoMatches: "\u6CA1\u6709\u5339\u914D\u7684\u4F1A\u8BDD\u3002",
@@ -18982,7 +19805,7 @@ ${error51.stderrTail}`] : []
     sessionImportPrevious: "\u4E0A\u4E00\u9875",
     sessionImportNext: "\u4E0B\u4E00\u9875",
     sessionImportPageSummary: "\u7B2C {page} / {pages} \u9875 \xB7 \u5171 {total} \u6761",
-    sessionImportLoadFailed: "\u65E0\u6CD5\u8BFB\u53D6\u672C\u5730\u4F1A\u8BDD\uFF0C\u8BF7\u68C0\u67E5\u76EE\u5F55\u8BBF\u95EE\u6743\u9650\u6216\u91CD\u590D\u7684\u4F1A\u8BDD ID \u540E\u91CD\u8BD5\u3002",
+    sessionImportLoadFailed: "\u65E0\u6CD5\u8BFB\u53D6\u5F53\u524D Host \u4E0A\u7684\u4F1A\u8BDD\uFF0C\u8BF7\u68C0\u67E5\u76EE\u5F55\u8BBF\u95EE\u6743\u9650\u6216\u91CD\u590D\u7684\u4F1A\u8BDD ID \u540E\u91CD\u8BD5\u3002",
     sessionImportFailed: "\u65E0\u6CD5\u5BFC\u5165\u8BE5\u4F1A\u8BDD\u3002",
     sessionImportUntitled: "\u672A\u547D\u540D\u4F1A\u8BDD",
     sessionImportUpdatedAt: "\u66F4\u65B0\u65F6\u95F4",
@@ -19087,10 +19910,17 @@ ${error51.stderrTail}`] : []
     connectionInstallRunning: "\u6B63\u5728\u6240\u9009 Host \u4E0A\u5B89\u88C5\uFF0C\u79BB\u5F00\u9875\u9762\u4E0D\u4F1A\u4E2D\u65AD\u3002\u5B89\u88C5\u540E\u53EF\u80FD\u4ECD\u9700\u767B\u5F55\u6216\u914D\u7F6E\u3002",
     harnessVersion: harnessVersionChinese,
     harnessVersionTitle: "Harness CLI \u7248\u672C",
+    harnessVersionApplicationTitle: "\u5E94\u7528\u7248\u672C",
     harnessVersionCurrent: "\u5F53\u524D\u7248\u672C",
     harnessVersionLatest: "\u6700\u65B0\u7248\u672C",
     harnessVersionChecking: "\u6B63\u5728\u68C0\u67E5\u7248\u672C\u2026",
+    harnessVersionAvailable: "\u6709\u66F4\u65B0",
     harnessVersionUpdate: "\u66F4\u65B0",
+    harnessVersionDownloadUpdate: "\u4E0B\u8F7D\u66F4\u65B0",
+    harnessUpdateAll: "\u5168\u90E8\u66F4\u65B0",
+    harnessUpdateAllProgress: "\u66F4\u65B0\u4E2D",
+    harnessUpdateAllDescription: "\u66F4\u65B0\u5F53\u524D Host \u4E0A\u652F\u6301\u81EA\u52A8\u66F4\u65B0\u4E14\u6709\u65B0\u7248\u672C\u7684 Harness\u3002",
+    harnessUpdateAllResult: "\u5DF2\u66F4\u65B0 {succeeded} \u9879\uFF0C{failed} \u9879\u5931\u8D25\u3002",
     harnessVersionUpdating: "\u6B63\u5728\u66F4\u65B0\u2026",
     harnessVersionUpToDate: "\u5DF2\u662F\u6700\u65B0",
     harnessVersionUpdated: "\u5DF2\u786E\u8BA4\u66F4\u65B0\u6210\u529F\uFF0C\u65B0\u4F1A\u8BDD\u5C06\u4F7F\u7528\u65B0\u7248\u672C\u3002",
@@ -19803,6 +20633,8 @@ ${error51.stderrTail}`] : []
   var STYLE_ATTRIBUTE = "data-codexhost-trigger-chip-style";
   var TRIGGER_CHIP_CLASS = "codexhost-trigger-chip";
   var TRIGGER_CHIP_ROOT_CLASS = "codexhost-trigger-chip-root";
+  var COMPACT_COMPOSER_ATTRIBUTE = "data-codexhost-compact-composer";
+  var COMPACT_COMPOSER_WIDTH = 420;
   var TRIGGER_CHIP_SQUEEZE_MIN_WIDTH = "48px";
   function rendererModelTriggerMaxWidth() {
     return "min(200px, 26vw)";
@@ -19832,6 +20664,23 @@ ${error51.stderrTail}`] : []
     trigger.style.maxWidth = "100%";
     trigger.style.overflow = "hidden";
   }
+  function observeRendererCompactComposer(composer) {
+    const update = () => {
+      const width = composer.getBoundingClientRect().width;
+      if (width > 0) {
+        composer.toggleAttribute(COMPACT_COMPOSER_ATTRIBUTE, width <= COMPACT_COMPOSER_WIDTH);
+      }
+    };
+    update();
+    if (typeof ResizeObserver === "undefined")
+      return () => composer.removeAttribute(COMPACT_COMPOSER_ATTRIBUTE);
+    const observer = new ResizeObserver(update);
+    observer.observe(composer, { box: "border-box" });
+    return () => {
+      observer.disconnect();
+      composer.removeAttribute(COMPACT_COMPOSER_ATTRIBUTE);
+    };
+  }
   function ensureRendererTriggerChipStyle(ownerDocument) {
     if (ownerDocument.querySelector(`style[${STYLE_ATTRIBUTE}]`)) return;
     const style = ownerDocument.createElement("style");
@@ -19870,10 +20719,55 @@ ${error51.stderrTail}`] : []
       cursor: not-allowed;
       opacity: 0.4;
     }
+    [${COMPACT_COMPOSER_ATTRIBUTE}] [data-codexhost-model-control] [data-codexhost-model-thinking] {
+      display: none !important;
+    }
+    [${COMPACT_COMPOSER_ATTRIBUTE}] [data-codexhost-permission-mode-control] {
+      min-width: 30px !important;
+      max-width: 30px !important;
+    }
+    [${COMPACT_COMPOSER_ATTRIBUTE}] [data-codexhost-permission-mode-control] .${TRIGGER_CHIP_CLASS} {
+      padding-inline: 6px !important;
+    }
+    [${COMPACT_COMPOSER_ATTRIBUTE}] [data-codexhost-permission-label],
+    [${COMPACT_COMPOSER_ATTRIBUTE}] [data-codexhost-permission-chevron],
+    [${COMPACT_COMPOSER_ATTRIBUTE}] [data-codexhost-credits-label],
+    [${COMPACT_COMPOSER_ATTRIBUTE}] [data-codexhost-usage-label] {
+      display: none !important;
+    }
+    [${COMPACT_COMPOSER_ATTRIBUTE}] [data-codexhost-permission-mode-control]:has([data-codexhost-permission-lock]:not([hidden])) [data-codexhost-permission-shield],
+    [${COMPACT_COMPOSER_ATTRIBUTE}] [data-codexhost-permission-mode-control]:has([data-codexhost-permission-error]:not([hidden])) [data-codexhost-permission-shield] {
+      display: none !important;
+    }
+    [${COMPACT_COMPOSER_ATTRIBUTE}] [data-codexhost-credits-control],
+    [${COMPACT_COMPOSER_ATTRIBUTE}] [data-codexhost-usage-control] {
+      min-width: 28px !important;
+      max-width: 28px !important;
+    }
+    [${COMPACT_COMPOSER_ATTRIBUTE}] [data-codexhost-credits-control] .${TRIGGER_CHIP_CLASS},
+    [${COMPACT_COMPOSER_ATTRIBUTE}] [data-codexhost-usage-control] .${TRIGGER_CHIP_CLASS} {
+      padding-inline: 6px !important;
+    }
+    [${COMPACT_COMPOSER_ATTRIBUTE}] [data-codexhost-usage-icon] {
+      display: inline-flex !important;
+    }
+    [${COMPACT_COMPOSER_ATTRIBUTE}] [data-codexhost-agent-control] {
+      margin-inline: 0 !important;
+    }
   `;
     (ownerDocument.head ?? ownerDocument.documentElement).append(style);
   }
 
+  // ../../node_modules/lucide/dist/esm/icons/activity.mjs
+  var Activity = [
+    [
+      "path",
+      {
+        d: "M22 12h-2.48a2 2 0 0 0-1.93 1.46l-2.35 8.36a.25.25 0 0 1-.48 0L9.24 2.18a.25.25 0 0 0-.48 0l-2.35 8.36A2 2 0 0 1 4.49 12H2"
+      }
+    ]
+  ];
+
   // src/renderer-usage-control.ts
   var ENGLISH_USAGE_MESSAGES = Object.freeze({
     usage: "Usage",
@@ -20227,13 +21121,19 @@ ${error51.stderrTail}`] : []
     trigger.style.lineHeight = "16px";
     trigger.style.fontVariantNumeric = "tabular-nums";
     trigger.style.letterSpacing = "0";
+    const icon2 = document.createElement("span");
+    icon2.dataset.codexhostUsageIcon = "";
+    icon2.style.display = "none";
+    icon2.style.alignItems = "center";
+    icon2.append(createElement(Activity, { width: 16, height: 16, "aria-hidden": "true" }));
     const label = document.createElement("span");
+    label.dataset.codexhostUsageLabel = "";
     label.style.display = "inline-block";
     label.style.maxWidth = "100%";
     label.style.overflow = "hidden";
     label.style.textOverflow = "ellipsis";
     label.style.whiteSpace = "nowrap";
-    trigger.append(label);
+    trigger.append(icon2, label);
     const popover = document.createElement("div");
     popover.id = `${composerId}-usage-popover`;
     popover.setAttribute("role", "dialog");
@@ -21099,6 +21999,7 @@ Codex Fast mode prioritizes requests and may increase usage.`
     label.style.textOverflow = "ellipsis";
     label.style.whiteSpace = "nowrap";
     const thinkingLabel = document.createElement("span");
+    thinkingLabel.dataset.codexhostModelThinking = "";
     thinkingLabel.style.color = "var(--color-text-tertiary, #8f8f8f)";
     thinkingLabel.style.flex = "0 1 auto";
     thinkingLabel.style.maxWidth = "72px";
@@ -21544,9 +22445,6 @@ Codex Fast mode prioritizes requests and may increase usage.`
     syncModelSelectionNotice(control, view, locale);
   }
 
-  // ../../node_modules/lucide/dist/esm/icons/check.mjs
-  var Check = [["path", { d: "M20 6 9 17l-5-5" }]];
-
   // ../../node_modules/lucide/dist/esm/icons/lock.mjs
   var Lock = [
     ["rect", { width: "18", height: "11", x: "3", y: "11", rx: "2", ry: "2" }],
@@ -21661,9 +22559,11 @@ Codex Fast mode prioritizes requests and may increase usage.`
     trigger.className = TRIGGER_CHIP_CLASS;
     applyRendererTriggerChipSqueezeTrigger(trigger);
     const shield = document.createElement("span");
+    shield.dataset.codexhostPermissionShield = "";
     shield.className = "inline-flex shrink-0 items-center";
     shield.append(icon(Shield, 15));
     const label = document.createElement("span");
+    label.dataset.codexhostPermissionLabel = "";
     label.className = "truncate";
     label.style.flex = "1 1 auto";
     label.style.minWidth = "0";
@@ -21671,15 +22571,18 @@ Codex Fast mode prioritizes requests and may increase usage.`
     label.style.textOverflow = "ellipsis";
     label.style.whiteSpace = "nowrap";
     const chevron = document.createElement("span");
+    chevron.dataset.codexhostPermissionChevron = "";
     chevron.className = "inline-flex shrink-0 items-center";
     chevron.style.color = "var(--color-text-tertiary, #8f8f8f)";
     chevron.append(icon(ChevronDown, 14));
     const lockMark = document.createElement("span");
+    lockMark.dataset.codexhostPermissionLock = "";
     lockMark.className = "inline-flex shrink-0 items-center";
     lockMark.style.color = "var(--color-text-tertiary, #8f8f8f)";
     lockMark.hidden = true;
     lockMark.append(icon(Lock, 14));
     const errorMark = document.createElement("span");
+    errorMark.dataset.codexhostPermissionError = "";
     errorMark.className = "inline-flex shrink-0 items-center";
     errorMark.style.color = "var(--color-text-danger, #c2413b)";
     errorMark.hidden = true;
@@ -22236,7 +23139,7 @@ Codex Fast mode prioritizes requests and may increase usage.`
         })
       );
     }
-    if (label) label.textContent = percent2;
+    if (label) label.textContent = `${Math.round(remaining)}%`;
     control.root.style.display = "inline-flex";
     control.trigger.setAttribute("aria-label", title);
     control.trigger.title = title;
@@ -22244,6 +23147,163 @@ Codex Fast mode prioritizes requests and may increase usage.`
     return true;
   }
 
+  // src/renderer-composer-indicators.ts
+  var SHOW_WITHIN_SECONDS = 50 * 60;
+  function mountRendererComposerIndicators(composer) {
+    const doc = composer.ownerDocument;
+    ensureRendererTriggerChipStyle(doc);
+    const root = doc.createElement("div");
+    root.setAttribute("data-codexhost-composer-indicators", "true");
+    applyRendererTriggerChipSqueezeRoot(root, "128px", "0");
+    Object.assign(root.style, { alignItems: "center", gap: "2px", flexShrink: "100000" });
+    let indicators = [];
+    let locale = "en";
+    let timer;
+    let anchor = null;
+    let contentKey = "";
+    let tip = null;
+    const hideTip = () => {
+      tip?.remove();
+      tip = null;
+    };
+    const showTip = (chip, textContent) => {
+      hideTip();
+      const el = doc.createElement("div");
+      el.setAttribute("role", "tooltip");
+      el.textContent = textContent;
+      Object.assign(el.style, {
+        position: "fixed",
+        zIndex: "2147483647",
+        pointerEvents: "none",
+        padding: "4px 8px",
+        borderRadius: "8px",
+        fontSize: "12px",
+        whiteSpace: "nowrap",
+        background: "rgba(30, 30, 30, 0.92)",
+        color: "#fff",
+        visibility: "hidden"
+      });
+      (doc.body ?? doc.documentElement).append(el);
+      const rect = chip.getBoundingClientRect();
+      const width = el.offsetWidth;
+      const left = Math.max(
+        4,
+        Math.min(rect.left + rect.width / 2 - width / 2, window.innerWidth - width - 4)
+      );
+      el.style.left = `${left}px`;
+      el.style.top = `${Math.max(4, rect.top - el.offsetHeight - 6)}px`;
+      el.style.visibility = "visible";
+      tip = el;
+    };
+    const refresh = () => {
+      const now = Date.now() / 1e3;
+      const active = indicators.filter(
+        (indicator) => indicator.expiresAtUnix > now && indicator.expiresAtUnix - now <= SHOW_WITHIN_SECONDS
+      );
+      const nextKey = JSON.stringify([
+        locale,
+        active.map((indicator) => [indicator, Math.ceil((indicator.expiresAtUnix - now) / 60)])
+      ]);
+      if (nextKey !== contentKey) {
+        contentKey = nextKey;
+        hideTip();
+        root.replaceChildren();
+        for (const indicator of active) {
+          const minutes = Math.ceil((indicator.expiresAtUnix - now) / 60);
+          const remaining = locale === "zh-CN" ? `\u5269\u4F59 ${minutes} \u5206\u949F` : `${minutes}m remaining`;
+          const label = indicator.label ? localizeHarnessText(indicator.label, locale) : "";
+          const tooltip = indicator.tooltip ? localizeHarnessText(indicator.tooltip, locale) : "";
+          const chip = doc.createElement("span");
+          chip.className = TRIGGER_CHIP_CLASS;
+          chip.setAttribute("data-indicator-id", indicator.id);
+          const summary = [label, tooltip, remaining].filter(Boolean).join(" \xB7 ");
+          chip.setAttribute("aria-label", summary);
+          chip.addEventListener("mouseenter", () => showTip(chip, summary));
+          chip.addEventListener("mouseleave", hideTip);
+          Object.assign(chip.style, {
+            height: "28px",
+            padding: "0 6px",
+            gap: "4px",
+            fontSize: "12px",
+            cursor: "default",
+            flexShrink: "0"
+          });
+          const icon2 = doc.createElementNS("http://www.w3.org/2000/svg", "svg");
+          icon2.setAttribute("viewBox", "0 0 24 24");
+          icon2.setAttribute("width", "14");
+          icon2.setAttribute("height", "14");
+          icon2.setAttribute("fill", "none");
+          icon2.setAttribute("stroke", "currentColor");
+          icon2.setAttribute("stroke-width", "1.5");
+          icon2.setAttribute("aria-hidden", "true");
+          const path = doc.createElementNS("http://www.w3.org/2000/svg", "path");
+          path.setAttribute("d", "M12 8v4l3 2M21 12a9 9 0 1 1-18 0 9 9 0 0 1 18 0");
+          icon2.append(path);
+          const text = doc.createElement("span");
+          text.textContent = `${minutes}m`;
+          chip.append(icon2, text);
+          root.append(chip);
+        }
+      }
+      const visible = active.length > 0 && anchor !== null;
+      if (root.hidden === visible) root.hidden = !visible;
+      const display = visible ? "inline-flex" : "none";
+      if (root.style.display !== display) root.style.display = display;
+      const visibility = root.scrollWidth > root.clientWidth ? "hidden" : "visible";
+      if (root.style.visibility !== visibility) root.style.visibility = visibility;
+      const pending = indicators.some(({ expiresAtUnix }) => expiresAtUnix > now);
+      if (!pending && timer !== void 0) {
+        clearInterval(timer);
+        timer = void 0;
+      }
+    };
+    const observer = new ResizeObserver(refresh);
+    observer.observe(root);
+    refresh();
+    return {
+      root,
+      place(next) {
+        anchor = next;
+        if (!next?.parentElement) {
+          anchor = null;
+          root.remove();
+        } else if (next.nextElementSibling !== root) {
+          next.parentElement.insertBefore(root, next.nextSibling);
+        }
+        refresh();
+      },
+      render(next, nextLocale) {
+        indicators = next;
+        locale = nextLocale;
+        refresh();
+        if (timer === void 0 && indicators.some(({ expiresAtUnix }) => expiresAtUnix > Date.now() / 1e3)) {
+          timer = setInterval(refresh, 6e4);
+        }
+      },
+      dispose() {
+        observer.disconnect();
+        hideTip();
+        if (timer !== void 0) clearInterval(timer);
+        root.remove();
+      }
+    };
+  }
+
+  // src/renderer-composer-request.ts
+  var NATIVE_COMPOSER_REQUEST_ATTRIBUTES = [
+    "data-codex-composer-request-navigation",
+    "data-codex-composer-request"
+  ];
+  var NATIVE_REQUEST_SELECTOR = NATIVE_COMPOSER_REQUEST_ATTRIBUTES.map(
+    (attribute) => `[${attribute}]`
+  ).join(", ");
+  function isNativeComposerRequest(element) {
+    return element.closest(NATIVE_REQUEST_SELECTOR) !== null;
+  }
+  function hasNativeComposerRequest(composer) {
+    return isNativeComposerRequest(composer) || composer.querySelector(NATIVE_REQUEST_SELECTOR) !== null;
+  }
+
   // src/renderer-harness-command-control.ts
   var CONTROL_ATTRIBUTE2 = "data-codexhost-harness-command-control";
   var SVG_NS2 = "http://www.w3.org/2000/svg";
@@ -22376,7 +23436,7 @@ Codex Fast mode prioritizes requests and may increase usage.`
     return controlDescription(button2);
   }
   function isOwnedRendererControl(element) {
-    return element.hasAttribute(CONTROL_ATTRIBUTE) || element.hasAttribute("data-codexhost-model-control") || element.hasAttribute("data-codexhost-permission-mode-control") || element.hasAttribute("data-codexhost-usage-control") || element.hasAttribute("data-codexhost-credits-control") || element.hasAttribute("data-codexhost-harness-command-control");
+    return element.hasAttribute(CONTROL_ATTRIBUTE) || element.hasAttribute("data-codexhost-model-control") || element.hasAttribute("data-codexhost-permission-mode-control") || element.hasAttribute("data-codexhost-usage-control") || element.hasAttribute("data-codexhost-credits-control") || element.hasAttribute("data-codexhost-composer-indicators") || element.hasAttribute("data-codexhost-harness-command-control");
   }
   function isComposerSubmitButton(button2) {
     if (button2.type === "submit") return true;
@@ -22405,10 +23465,13 @@ Codex Fast mode prioritizes requests and may increase usage.`
     const buttons = [...element.querySelectorAll("button")];
     return buttons.length > 0 && buttons.every((button2) => isComposerTrailingActionButton(button2));
   }
+  function composerButtonsWithin(root) {
+    return [...root.querySelectorAll("button")].filter(
+      (button2) => !isNativeComposerRequest(button2)
+    );
+  }
   function sendButtonWithin(root) {
-    return [...root.querySelectorAll("button")].find(
-      (button2) => isComposerSubmitButton(button2)
-    ) ?? null;
+    return composerButtonsWithin(root).find(isComposerSubmitButton) ?? null;
   }
   function leftmostTrailingSibling(container, before) {
     for (const child of container.children) {
@@ -22451,7 +23514,7 @@ Codex Fast mode prioritizes requests and may increase usage.`
   }
   function composerForElement(element) {
     const composer = element.closest(CODEX_COMPOSER_SELECTOR);
-    return composer && !isOrbitComposer(composer) ? composer : null;
+    return composer && !hasNativeComposerRequest(composer) && !isOrbitComposer(composer) ? composer : null;
   }
   function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -22575,7 +23638,7 @@ Codex Fast mode prioritizes requests and may increase usage.`
     return root?.parentElement ? root : null;
   }
   function lastNativeButtonWithin(composer) {
-    const buttons = [...composer.querySelectorAll("button")];
+    const buttons = composerButtonsWithin(composer);
     for (let index = buttons.length - 1; index >= 0; index -= 1) {
       const button2 = buttons[index];
       if (button2 && !isInsideOwnedRendererControl(button2, composer)) return button2;
@@ -22589,6 +23652,7 @@ Codex Fast mode prioritizes requests and may increase usage.`
     return false;
   }
   function refreshSendButton(control) {
+    if (hasNativeComposerRequest(control.composer)) return null;
     const current = control.sendButton;
     if (current?.isConnected && control.composer.contains(current)) return current;
     const replacement = sendButtonWithin(control.composer) ?? (current && !isComposerSubmitButton(current) ? lastNativeButtonWithin(control.composer) : null);
@@ -22674,6 +23738,9 @@ Codex Fast mode prioritizes requests and may increase usage.`
     refreshTrailingClusterPlacement(control);
     refreshUsagePlacement(control);
     refreshCreditsPlacement(control);
+    control.composerIndicators?.place(
+      control.nativePermissionModeControlVerified ? control.nativePermissionModeControl?.element ?? null : null
+    );
     setNativeControlHidden(control.nativeModelControl, hideModel);
     setNativeControlHidden(control.nativeContextUsageControl, false);
     setNativeControlHidden(control.nativePermissionModeControl, hidePermissionMode);
@@ -22700,6 +23767,7 @@ Codex Fast mode prioritizes requests and may increase usage.`
       onSelectPermissionMode
     );
     const credits = mountRendererCreditsControl(composerId);
+    const composerIndicators = mountRendererComposerIndicators(composer);
     const toolbar = sendButton.parentElement;
     const harnessCommands = mountRendererHarnessCommandControl(
       toolbar ?? composer,
@@ -22746,6 +23814,7 @@ Codex Fast mode prioritizes requests and may increase usage.`
       nativeContextUsageControl,
       nativePermissionModeControlVerified,
       credits,
+      composerIndicators,
       usage: null,
       harnessCommands,
       sendButton,
@@ -22754,6 +23823,7 @@ Codex Fast mode prioritizes requests and may increase usage.`
     refreshTrailingClusterPlacement(control);
     refreshUsagePlacement(control);
     refreshCreditsPlacement(control);
+    control.stopCompactLayout = observeRendererCompactComposer(composer);
     return control;
   }
   function nativeSendDisabled(button2, fallback) {
@@ -22811,6 +23881,10 @@ Codex Fast mode prioritizes requests and may increase usage.`
       permissionModeVisible,
       locale
     );
+    control.composerIndicators?.render(
+      permissionModeVisible ? usage?.composerIndicators ?? [] : [],
+      locale
+    );
     if (control.usage) {
       renderRendererUsageControl(control.usage, usage, locale);
     }
@@ -22821,6 +23895,7 @@ Codex Fast mode prioritizes requests and may increase usage.`
     return state.agent !== "codex" && adapterState === "ready" && !submissionBlocked;
   }
   function disposeComposerAgentControl(control) {
+    control.stopCompactLayout?.();
     if (control.sendDisabledBeforeSwitch !== null) {
       control.sendButton.disabled = nativeSendDisabled(
         control.sendButton,
@@ -22830,6 +23905,7 @@ Codex Fast mode prioritizes requests and may increase usage.`
     restoreNativeControl(control.nativeModelControl);
     restoreNativeControl(control.nativeContextUsageControl);
     restoreNativeControl(control.nativePermissionModeControl);
+    control.composerIndicators?.dispose();
     control.credits.dispose();
     control.usage?.dispose();
     control.usage = null;
@@ -23384,36 +24460,24 @@ Codex Fast mode prioritizes requests and may increase usage.`
     };
   }
 
-  // src/renderer-request-sender.ts
-  var RendererMethodUnavailableError = class extends Error {
-    constructor(method, cause) {
-      super(`${method} is unsupported on this Host connection`, { cause });
-      this.method = method;
-      this.name = "RendererMethodUnavailableError";
+  // src/renderer-installation-client.ts
+  async function runRendererInstallation(send, input) {
+    const params = harnessInstallationParamsSchema.parse(input);
+    const options = { priority: "background", timeoutMs: 15e3 };
+    let task = harnessInstallationTaskSchema.parse(
+      await send(HARNESS_INSTALLATION_START_METHOD, params, options)
+    );
+    const taskId = task.taskId;
+    while (task.status === "running") {
+      await new Promise((resolve) => globalThis.setTimeout(resolve, 500));
+      task = harnessInstallationTaskSchema.parse(
+        await send(HARNESS_INSTALLATION_STATUS_METHOD, { taskId }, options)
+      );
+      if (task.taskId !== taskId) throw new Error("Harness installation task identity changed");
     }
-    method;
-    code = -32601;
-  };
-  function isUnsupportedMethod(error51, method) {
-    if (typeof error51 !== "object" || error51 === null) return false;
-    const code = "code" in error51 ? error51.code : void 0;
-    const message2 = "message" in error51 ? error51.message : void 0;
-    return code === -32601 || code === -32600 && typeof message2 === "string" && message2.startsWith(`Invalid request: unknown variant \`${method}\``);
-  }
-  function createRendererRequestSender(send) {
-    const unsupported = /* @__PURE__ */ new Map();
-    return async (method, params, options) => {
-      const known = unsupported.get(method);
-      if (known) throw known;
-      try {
-        return await (options === void 0 ? send(method, params) : send(method, params, options));
-      } catch (error51) {
-        if (!method.startsWith("codexhost/") || !isUnsupportedMethod(error51, method)) throw error51;
-        const unavailable = new RendererMethodUnavailableError(method, error51);
-        unsupported.set(method, unavailable);
-        throw unavailable;
-      }
-    };
+    if (task.status === "failed")
+      throw Object.assign(new Error(task.error.message), { code: task.error.code });
+    return task.result;
   }
 
   // src/renderer-native-thread.ts
@@ -23573,7 +24637,15 @@ Codex Fast mode prioritizes requests and may increase usage.`
     };
     const inspectHarness = async (input, options) => {
       const params = harnessInspectParamsSchema.parse(input);
-      const result = await manager.sendRequest(HARNESS_INSPECT_METHOD, params, options);
+      let result;
+      try {
+        result = await manager.sendRequest(HARNESS_INSPECT_METHOD, params, options);
+      } catch (error51) {
+        if (!params.purpose || !isInvalidParams(error51)) throw error51;
+        const full = { ...params };
+        delete full.purpose;
+        result = await manager.sendRequest(HARNESS_INSPECT_METHOD, full, options);
+      }
       return harnessInspectionSchema.parse(result);
     };
     const inspectHarnessCommands = async (input) => {
@@ -23613,13 +24685,7 @@ Codex Fast mode prioritizes requests and may increase usage.`
     };
     return Object.freeze({
       async installation(input) {
-        return harnessInstallationStateSchema.parse(
-          await manager.sendRequest(
-            HARNESS_INSTALLATION_METHOD,
-            harnessInstallationParamsSchema.parse(input),
-            { priority: "interactive" }
-          )
-        );
+        return runRendererInstallation(manager.sendRequest, input);
       },
       async getHarnessDisplaySettings() {
         return harnessDisplaySettingsSchema.parse(
@@ -23835,6 +24901,9 @@ Codex Fast mode prioritizes requests and may increase usage.`
       }
     });
   }
+  function isInvalidParams(error51) {
+    return typeof error51 === "object" && error51 !== null && "code" in error51 && error51.code === -32602;
+  }
 
   // src/renderer-external-queue.ts
   function isRecord6(value) {
@@ -23870,6 +24939,7 @@ Codex Fast mode prioritizes requests and may increase usage.`
   }
 
   // src/renderer-external-steering.ts
+  var THREAD_STEERING_INSPECT_METHOD = "codexhost/thread/steering/inspect";
   var THREAD_OWNERSHIP_LIST_METHOD2 = "codexhost/thread/ownership/list";
   function isRecord7(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -23953,6 +25023,7 @@ Codex Fast mode prioritizes requests and may increase usage.`
     const originalSteer = manager.steerTurn;
     const originalSend = manager.sendRequest;
     const routes = /* @__PURE__ */ new Map();
+    const activeTurnSteers = /* @__PURE__ */ new Map();
     const pending = /* @__PURE__ */ new Map();
     let disposed = false;
     const send = function(method, params, options) {
@@ -23968,6 +25039,9 @@ Codex Fast mode prioritizes requests and may increase usage.`
             return originalSend.call(manager, method, input, options);
           });
         }
+        if (method === "turn/steer" && isRecord7(params) && typeof params.threadId === "string" && activeTurnSteers.has(params.threadId)) {
+          params = { ...params, [THREAD_STEER_DELIVERY_PARAM]: "activeTurn" };
+        }
         return originalSend.call(manager, method, params, options);
       }
       if (disposed) return Promise.reject(new Error("External steering binding was disposed"));
@@ -23982,7 +25056,8 @@ Codex Fast mode prioritizes requests and may increase usage.`
             input: params.input,
             additionalContext: params.additionalContext,
             responsesapiClientMetadata: params.responsesapiClientMetadata,
-            ...params[THREAD_REFERENCE_SOURCE_HOST_PARAM] !== void 0 ? { [THREAD_REFERENCE_SOURCE_HOST_PARAM]: params[THREAD_REFERENCE_SOURCE_HOST_PARAM] } : {}
+            ...params[THREAD_REFERENCE_SOURCE_HOST_PARAM] !== void 0 ? { [THREAD_REFERENCE_SOURCE_HOST_PARAM]: params[THREAD_REFERENCE_SOURCE_HOST_PARAM] } : {},
+            [THREAD_STEER_DELIVERY_PARAM]: "newTurn"
           },
           options
         )
@@ -24004,6 +25079,34 @@ Codex Fast mode prioritizes requests and may increase usage.`
         };
       });
     };
+    const inspectDelivery = async (threadId, text) => {
+      try {
+        const response = await originalSend.call(manager, THREAD_STEERING_INSPECT_METHOD, {
+          threadId,
+          ...text !== void 0 ? { text } : {}
+        });
+        return threadSteeringInspectResultSchema.parse(response).delivery;
+      } catch (error51) {
+        if (!isUnsupportedMethod(error51, THREAD_STEERING_INSPECT_METHOD)) throw error51;
+      }
+      let ownershipResponse;
+      try {
+        ownershipResponse = await originalSend.call(manager, THREAD_OWNERSHIP_LIST_METHOD2, {
+          threadIds: [threadId]
+        });
+      } catch (error51) {
+        if (!isUnsupportedMethod(error51, THREAD_OWNERSHIP_LIST_METHOD2)) throw error51;
+        await verifyNativeCodexThread(
+          (method, params) => originalSend.call(manager, method, params),
+          threadId
+        );
+        return "official";
+      }
+      const ownership = threadOwnershipListResultSchema.parse(ownershipResponse);
+      const owner = ownership.threads.find((thread) => thread.threadId === threadId)?.owner;
+      if (!owner) throw new Error("Thread ownership could not be resolved for steering");
+      return owner === "codex" ? "official" : "newTurn";
+    };
     const steer = async function(...args) {
       const [
         threadId,
@@ -24026,25 +25129,20 @@ Codex Fast mode prioritizes requests and may increase usage.`
         expectedTurnId = host.getActiveTurnId(threadId);
       } catch {
       }
-      let ownershipResponse;
-      try {
-        ownershipResponse = await originalSend.call(manager, THREAD_OWNERSHIP_LIST_METHOD2, {
-          threadIds: [threadId]
-        });
-      } catch (error51) {
-        if (!isUnsupportedMethod(error51, THREAD_OWNERSHIP_LIST_METHOD2)) throw error51;
-        await verifyNativeCodexThread(
-          (method, params) => originalSend.call(manager, method, params),
-          threadId
-        );
-        if (disposed) throw new Error("External steering binding was disposed");
-        return originalSteer.apply(manager, args);
-      }
-      const ownership = threadOwnershipListResultSchema.parse(ownershipResponse);
-      const owner = ownership.threads.find((thread) => thread.threadId === threadId)?.owner;
-      if (!owner) throw new Error("Thread ownership could not be resolved for steering");
+      const text = Array.isArray(input) ? input.filter((item) => isRecord7(item) && typeof item.text === "string").map((item) => item.text).join("\n") : void 0;
+      const delivery = await inspectDelivery(threadId, text);
       if (disposed) throw new Error("External steering binding was disposed");
-      if (owner === "codex") return originalSteer.apply(manager, args);
+      if (delivery === "official") return originalSteer.apply(manager, args);
+      if (delivery === "activeTurn") {
+        activeTurnSteers.set(threadId, (activeTurnSteers.get(threadId) ?? 0) + 1);
+        try {
+          return await originalSteer.apply(manager, args);
+        } finally {
+          const remaining = (activeTurnSteers.get(threadId) ?? 1) - 1;
+          if (remaining > 0) activeTurnSteers.set(threadId, remaining);
+          else activeTurnSteers.delete(threadId);
+        }
+      }
       if (!host) throw new Error("Desktop turn submission binding is unavailable");
       const currentRole = manager.getStreamRole?.(threadId);
       if (isRecord7(currentRole) && currentRole.role === "follower")
@@ -24289,9 +25387,9 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
   }
 
   // src/renderer-thread-reference-capability.ts
-  var record3 = (value) => typeof value === "object" && value !== null;
+  var record4 = (value) => typeof value === "object" && value !== null;
   function restoreThreadReferenceCapability(client, manager, isCurrent) {
-    if (!record3(manager) || !record3(manager.storage)) return client;
+    if (!record4(manager) || !record4(manager.storage)) return client;
     const storage = manager.storage;
     const read = storage.readValue;
     const write = storage.writeValue;
@@ -24326,14 +25424,14 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
   }
 
   // src/renderer-thread-reference-context.ts
-  var record4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  var record5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
   function createThreadReferenceContext(manager, hostId2, isCurrent) {
     const prepared = /* @__PURE__ */ new WeakMap();
     return (params) => {
-      if (hostId2 === "local" || !record4(manager) || typeof manager.getConversation !== "function" || !record4(params) || typeof params.threadId !== "string")
+      if (hostId2 === "local" || !record5(manager) || typeof manager.getConversation !== "function" || !record5(params) || typeof params.threadId !== "string")
         return params;
       const conversation = manager.getConversation.call(manager, params.threadId);
-      if (!record4(conversation) || conversation.id !== params.threadId || conversation.modelProvider !== "codexhost")
+      if (!record5(conversation) || conversation.id !== params.threadId || conversation.modelProvider !== "codexhost")
         return params;
       if (!isCurrent()) throw new Error("Thread reference connection is no longer available");
       const cached2 = prepared.get(params);
@@ -25852,9 +26950,17 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
   }
 
   // src/codex-locale-adapter.ts
-  var GET_LOCALE_OVERRIDE_URL = "vscode://codex/get-setting";
-  var GET_LOCALE_INFO_URL = "vscode://codex/locale-info";
   var DEFAULT_LOCALE_REQUEST_TIMEOUT_MS = 750;
+  function isNativeLocaleServices(value) {
+    if (!isRecord14(value) || !Object.hasOwn(value, "appInfo")) return false;
+    const appInfo = value.appInfo;
+    return appInfo != null && typeof appInfo.getLocaleInfo === "function";
+  }
+  function isNativeSettingsServices(value) {
+    if (!isRecord14(value) || !Object.hasOwn(value, "settings")) return false;
+    const settings = value.settings;
+    return typeof settings?.read === "function" && typeof settings?.write === "function";
+  }
   function isRecord14(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
   }
@@ -25876,19 +26982,19 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
   function abortError2() {
     return new DOMException("The operation was aborted", "AbortError");
   }
-  function parseLocaleOverride(value) {
-    if (!isRecord14(value) || !("value" in value)) {
-      throw new Error("Codex locale override response is malformed");
+  function parseLocaleOverride(response) {
+    if (!isRecord14(response) || !Object.hasOwn(response, "effective")) {
+      throw new Error("Codex native locale override response is malformed");
     }
-    if (value.value === null) return { value: null };
-    const locale = canonicalLocale(value.value);
+    if (response.effective === null) return null;
+    const locale = canonicalLocale(response.effective);
     if (!locale) throw new Error("Codex locale override is invalid");
-    return { value: locale };
+    return locale;
   }
-  function optionalLocale(value, field) {
+  function optionalLocale(value, field2) {
     if (value === void 0 || value === null) return void 0;
     const locale = canonicalLocale(value);
-    if (!locale) throw new Error(`Codex ${field} is invalid`);
+    if (!locale) throw new Error(`Codex ${field2} is invalid`);
     return locale;
   }
   function parseLocaleInfo(value) {
@@ -25898,87 +27004,39 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
       systemLocale: optionalLocale(value.systemLocale, "system locale")
     };
   }
-  function sendFixedLocaleRequest(request, ownerWindow, signal, timeoutMs) {
-    const bridge = ownerWindow.electronBridge;
-    if (typeof bridge?.sendMessageFromView !== "function") {
-      return Promise.reject(new Error("Codex locale bridge is unavailable"));
-    }
+  function requestNativeLocale(ownerWindow, signal, timeoutMs, matchesServices, invoke) {
     if (signal?.aborted) return Promise.reject(abortError2());
-    const requestId = ownerWindow.crypto.randomUUID();
     return new Promise((resolve, reject) => {
       let settled = false;
-      const cleanup = () => {
-        ownerWindow.clearTimeout(timer);
-        ownerWindow.removeEventListener("message", onMessage);
-        signal?.removeEventListener("abort", onAbort);
-      };
+      let nativeRequest;
       const settle = (operation) => {
         if (settled) return;
         settled = true;
-        cleanup();
-        operation();
-      };
-      const onAbort = () => settle(() => reject(abortError2()));
-      const onMessage = (event) => {
-        const message3 = event.data;
-        if (!isRecord14(message3) || message3.type !== "fetch-response") return;
-        if (message3.requestId !== requestId) return;
-        if (message3.responseType !== "success" || typeof message3.status !== "number" || message3.status < 200 || message3.status >= 300 || typeof message3.bodyJsonString !== "string") {
-          settle(() => reject(new Error("Codex locale request failed")));
-          return;
-        }
+        ownerWindow.clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
         try {
-          const body = JSON.parse(message3.bodyJsonString);
-          settle(() => resolve(body));
-        } catch {
-          settle(() => reject(new Error("Codex locale response is not valid JSON")));
+          nativeRequest?.[Symbol.dispose]?.();
+          operation();
+        } catch (error51) {
+          reject(error51);
         }
       };
+      const onAbort = () => settle(() => reject(abortError2()));
       const timer = ownerWindow.setTimeout(
         () => settle(() => reject(new Error("Codex locale request timed out"))),
         timeoutMs
       );
-      ownerWindow.addEventListener("message", onMessage);
       signal?.addEventListener("abort", onAbort, { once: true });
-      const message2 = {
-        type: "fetch",
-        requestId,
-        method: "POST",
-        url: request.url,
-        ...request.body === void 0 ? {} : { body: request.body },
-        reportUploadProgress: false
-      };
-      try {
-        Promise.resolve(bridge.sendMessageFromView(message2)).catch((error51) => {
-          settle(() => reject(error51));
-        });
-      } catch (error51) {
-        settle(() => reject(error51));
-      }
+      void (async () => {
+        const native = await loadCodexNativeServices(ownerWindow, matchesServices);
+        if (settled) return;
+        if (!native) throw new Error("Codex native locale services are unavailable");
+        nativeRequest = invoke(native);
+        const response = await nativeRequest;
+        settle(() => resolve(response));
+      })().catch((error51) => settle(() => reject(error51)));
     });
   }
-  async function readLocaleOverride(ownerWindow, signal, timeoutMs) {
-    const response = await sendFixedLocaleRequest(
-      {
-        kind: "locale-override",
-        url: GET_LOCALE_OVERRIDE_URL,
-        body: JSON.stringify({ key: "localeOverride" })
-      },
-      ownerWindow,
-      signal,
-      timeoutMs
-    );
-    return parseLocaleOverride(response);
-  }
-  async function readLocaleInfo(ownerWindow, signal, timeoutMs) {
-    const response = await sendFixedLocaleRequest(
-      { kind: "locale-info", url: GET_LOCALE_INFO_URL },
-      ownerWindow,
-      signal,
-      timeoutMs
-    );
-    return parseLocaleInfo(response);
-  }
   async function readCodexLocaleSettings(options = {}) {
     const ownerWindow = options.ownerWindow ?? window;
     const timeoutMs = options.timeoutMs ?? DEFAULT_LOCALE_REQUEST_TIMEOUT_MS;
@@ -25987,13 +27045,25 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
     }
     if (options.signal?.aborted) throw abortError2();
     const [overrideResult, localeInfoResult] = await Promise.allSettled([
-      readLocaleOverride(ownerWindow, options.signal, timeoutMs),
-      readLocaleInfo(ownerWindow, options.signal, timeoutMs)
+      requestNativeLocale(
+        ownerWindow,
+        options.signal,
+        timeoutMs,
+        isNativeSettingsServices,
+        (native) => native.settings.read("localeOverride")
+      ).then(parseLocaleOverride),
+      requestNativeLocale(
+        ownerWindow,
+        options.signal,
+        timeoutMs,
+        isNativeLocaleServices,
+        (native) => native.appInfo.getLocaleInfo()
+      ).then(parseLocaleInfo)
     ]);
     if (options.signal?.aborted) throw abortError2();
     const navigatorLocale = firstNavigatorLocale(ownerWindow);
     const overrideKnown = overrideResult.status === "fulfilled";
-    const localeOverride = overrideKnown ? overrideResult.value.value : void 0;
+    const localeOverride = overrideKnown ? overrideResult.value : void 0;
     const localeInfo = localeInfoResult.status === "fulfilled" ? localeInfoResult.value : { ideLocale: void 0, systemLocale: void 0 };
     if (typeof localeOverride === "string") {
       return Object.freeze({
@@ -26064,6 +27134,34 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
     return names.size === 1 ? names.values().next().value ?? model2 : model2;
   }
 
+  // src/console/usage/usage-hosts.ts
+  var LOCAL_USAGE_HOST_ID = "local";
+  function usageHostOptions(hosts, localLabel, selected) {
+    const options = [{ key: LOCAL_USAGE_HOST_ID, label: localLabel }];
+    const seen = /* @__PURE__ */ new Set([LOCAL_USAGE_HOST_ID]);
+    const add = (hostId2, label) => {
+      if (hostId2.length === 0 || seen.has(hostId2)) return;
+      seen.add(hostId2);
+      options.push({ key: hostId2, label: label !== void 0 && label.length > 0 ? label : hostId2 });
+    };
+    for (const host of hosts ?? []) add(host.hostId, host.label);
+    if (!seen.has(selected)) add(selected, void 0);
+    return options;
+  }
+  function createLatestKeyGuard() {
+    let generation = 0;
+    let key;
+    return {
+      begin(next) {
+        generation += 1;
+        key = next;
+        const mine = generation;
+        const selected = next;
+        return () => generation === mine && Object.is(key, selected);
+      }
+    };
+  }
+
   // src/console/usage/format.ts
   var MEASURES = ["cost", "tokens"];
   function fill(template, values) {
@@ -26310,7 +27408,7 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
   var DECIMAL = /^(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/iu;
   function modelPriceDraft(key, price) {
     const prices = Object.fromEntries(
-      MODEL_PRICE_FIELDS.map((field) => [field, price?.[field]?.toString() ?? ""])
+      MODEL_PRICE_FIELDS.map((field2) => [field2, price?.[field2]?.toString() ?? ""])
     );
     return { model: key, prices };
   }
@@ -26321,18 +27419,18 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
       return { error: { kind: "duplicate", key } };
     }
     const price = {};
-    for (const field of MODEL_PRICE_FIELDS) {
-      const text = draft.prices[field].trim();
+    for (const field2 of MODEL_PRICE_FIELDS) {
+      const text = draft.prices[field2].trim();
       if (text === "") {
-        if (field === "input" || field === "output")
-          return { error: { kind: "priceRequired", field } };
+        if (field2 === "input" || field2 === "output")
+          return { error: { kind: "priceRequired", field: field2 } };
         continue;
       }
       const value = Number(text);
       if (!DECIMAL.test(text) || !Number.isFinite(value)) {
-        return { error: { kind: "priceInvalid", field } };
+        return { error: { kind: "priceInvalid", field: field2 } };
       }
-      price[field] = value;
+      price[field2] = value;
     }
     return {
       change: {
@@ -26352,7 +27450,7 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
   }
   function formatPrice(messages, price) {
     return MODEL_PRICE_FIELDS.map(
-      (field) => `${messages.fields[field]} ${price[field] ?? messages.unset}`
+      (field2) => `${messages.fields[field2]} ${price[field2] ?? messages.unset}`
     ).join(" \xB7 ");
   }
   function draftErrorText(messages, error51) {
@@ -26420,18 +27518,18 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
     function renderEditor(modelId, view, isCurrent) {
       const existing = view.entries.find((entry) => entry.key === modelId);
       const draft = modelPriceDraft(modelId, existing?.price ?? null);
-      const field = (label, value, placeholder = "") => h(document2, "input", {
+      const field2 = (label, value, placeholder = "") => h(document2, "input", {
         type: "text",
         className: "console-input",
         value,
         placeholder,
         "aria-label": label
       });
-      const model2 = field(messages.model, modelId);
+      const model2 = field2(messages.model, modelId);
       model2.readOnly = true;
       const prices = Object.fromEntries(
         MODEL_PRICE_FIELDS.map((name) => {
-          const input = field(
+          const input = field2(
             messages.fields[name],
             draft.prices[name],
             name === "input" || name === "output" ? messages.required : messages.notSet
@@ -27243,8 +28341,8 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
     for (const cell of options.cells) {
       const key = options.singleDay ? cell.hour : cell.weekday * 24 + cell.hour;
       const totals2 = byHour.get(key) ?? emptyTotals();
-      for (const field of Object.keys(totals2))
-        totals2[field] += cell.totals[field];
+      for (const field2 of Object.keys(totals2))
+        totals2[field2] += cell.totals[field2];
       byHour.set(key, totals2);
     }
     const max = Math.max(0, ...[...byHour.values()].map((totals2) => measured(totals2, measure)));
@@ -27350,6 +28448,7 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
       const range = text("range");
       const measure = text("measure");
       const granularity = text("granularity");
+      const hostId2 = text("hostId");
       const harness2 = text("harness");
       const model2 = text("model");
       const project3 = text("project");
@@ -27358,6 +28457,7 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
         ...range && USAGE_STATISTICS_RANGES.includes(range) ? { range } : {},
         ...measure && MEASURES.includes(measure) ? { measure } : {},
         ...granularity === "day" || granularity === "week" || granularity === "month" ? { granularity } : {},
+        ...hostId2 !== void 0 && hostId2.length > 0 ? { hostId: hostId2 } : {},
         ...harness2 !== void 0 ? { harness: harness2 } : {},
         ...model2 !== void 0 ? { model: model2 } : {},
         ...project3 !== void 0 ? { project: project3 } : {},
@@ -27396,7 +28496,7 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
     day.setDate(day.getDate() - (day.getDay() + 6) % 7);
     return isoDate(day);
   }
-  function createUsageStatisticsPage(consoleMessages2, request, pageLocale) {
+  function createUsageStatisticsPage(consoleMessages2, request, pageLocale, usageHosts) {
     const messages = consoleMessages2.usageStatistics;
     return Object.freeze({
       id: "usage-statistics",
@@ -27405,10 +28505,12 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
       mount(context) {
         const document2 = context.content.ownerDocument;
         const locale = pageLocale ?? (document2.documentElement.lang || "en");
+        const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
         const count3 = (value) => count2(value, locale);
         const tokenCount2 = (totals2, value) => tokenCount(totals2, value, locale);
         const saved = readView();
         const view = {
+          hostId: saved.hostId ?? LOCAL_USAGE_HOST_ID,
           range: saved.range ?? "30d",
           measure: saved.measure ?? "cost",
           granularity: saved.granularity ?? null,
@@ -27439,7 +28541,7 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
         let projectLabel = /* @__PURE__ */ new Map();
         const projectName = (key) => key === UNKNOWN ? messages.unknownProject : projectLabel.get(key) ?? baseName(key);
         const measureLabel = (measure) => measure === "cost" ? messages.cost : messages.tokens;
-        const dateFormat = (options) => new Intl.DateTimeFormat(locale, options);
+        const dateFormat = (options) => new Intl.DateTimeFormat(locale, { ...options, timeZone });
         const shortDate = dateFormat({ month: "short", day: "numeric" });
         const longDate = dateFormat({
           year: "numeric",
@@ -27458,10 +28560,51 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
         const prices = createModelPricesDialog(
           document2,
           consoleMessages2,
-          request,
+          (method, params2) => request(method, params2, view.hostId),
           context.signal,
           load
         );
+        let offeredHosts = usageHosts ? [] : void 0;
+        const hostCombo = new ComboBox(document2, {
+          label: messages.host,
+          searchLabel: messages.search,
+          emptyLabel: messages.noMatches,
+          signal: context.signal,
+          searchable: false,
+          display: (option) => `${messages.host} \xB7 ${option.label}`,
+          onChange: (key) => {
+            if (key === view.hostId) return;
+            view.hostId = key;
+            view.harness = "";
+            view.model = "";
+            view.project = "";
+            date5 = null;
+            unpricedOnly = false;
+            result = null;
+            error51 = null;
+            loadedAt = 0;
+            names.clear();
+            save();
+            hostOptions();
+            render();
+            void refreshHarnessNames();
+            load();
+          }
+        });
+        const hostOptions = () => {
+          const options = usageHostOptions(offeredHosts, messages.localHost, view.hostId);
+          hostCombo.element.hidden = options.length < 2;
+          hostCombo.update(options, view.hostId === LOCAL_USAGE_HOST_ID ? "" : view.hostId);
+        };
+        const offerHosts = () => {
+          if (!usageHosts) return;
+          void usageHosts().then((hosts) => {
+            if (context.signal.aborted) return;
+            offeredHosts = hosts;
+            hostOptions();
+          }).catch(() => void 0);
+        };
+        hostOptions();
         const updated = h(document2, "span", { className: "console-muted console-usage-updated" });
         const refresh = h(
           document2,
@@ -27474,7 +28617,10 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
           },
           createRendererSettingsIcon("refresh", 16)
         );
-        refresh.addEventListener("click", () => load());
+        refresh.addEventListener("click", () => {
+          offerHosts();
+          load();
+        });
         const auto = new ComboBox(document2, {
           label: messages.autoRefresh,
           searchLabel: messages.search,
@@ -27513,6 +28659,7 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
             document2,
             "div",
             { className: "console-usage-toolbar" },
+            hostCombo.element,
             updated,
             refresh,
             auto.element,
@@ -27558,8 +28705,8 @@ ${text.includes("## My request:") ? "" : "\n## My request:\n"}`,
           save();
           load();
         }
-        function toggleFilter(field, key) {
-          view[field] = view[field] === key ? "" : key;
+        function toggleFilter(field2, key) {
+          view[field2] = view[field2] === key ? "" : key;
           changed();
         }
         function selectDate(next) {
@@ -27975,8 +29122,8 @@ ${messages.creditsCoverage}: ${value.reportedRequests} / ${row.requests}` : void
             }
           ];
         }
-        function rowFilter(field, key, label, detail) {
-          const selected = view[field] === key;
+        function rowFilter(field2, key, label, detail) {
+          const selected = view[field2] === key;
           const button2 = focusKey(
             h(
               document2,
@@ -27990,9 +29137,9 @@ ${detail}` : ""}`
               },
               label
             ),
-            `${field}:row:${key}`
+            `${field2}:row:${key}`
           );
-          button2.addEventListener("click", () => toggleFilter(field, key));
+          button2.addEventListener("click", () => toggleFilter(field2, key));
           return button2;
         }
         function panel(title, content, extra = null, wide = false) {
@@ -28151,7 +29298,6 @@ ${detail}` : ""}`
         }
         function hourlyPanel(data) {
           const singleDay = data.filters.date !== null || data.range === "today";
-          const zone = Intl.DateTimeFormat().resolvedOptions().timeZone;
           return panel(
             singleDay ? messages.hourlyDay : messages.hourly,
             hourlyChart(document2, {
@@ -28166,7 +29312,7 @@ ${detail}` : ""}`
               weekStartsOnMonday: !locale.startsWith("en"),
               labels: { cost: messages.cost, tokens: messages.tokens }
             }),
-            h(document2, "span", { className: "console-muted console-usage-zone" }, zone)
+            h(document2, "span", { className: "console-muted console-usage-zone" }, timeZone)
           );
         }
         function sessionsPanel(title, rows, tableKey) {
@@ -28313,6 +29459,7 @@ ${detail}` : ""}`
           const project3 = filterValue(view.project);
           return {
             range: view.range,
+            timeZone,
             ...view.harness ? { harness: view.harness } : {},
             ...model2 !== void 0 ? { model: model2 } : {},
             ...project3 !== void 0 ? { project: project3 } : {},
@@ -28325,10 +29472,26 @@ ${detail}` : ""}`
           if (result && !result.reading.complete) poll = window.setTimeout(load, POLL_MS);
           else if (view.autoRefreshMs > 0) poll = window.setTimeout(load, view.autoRefreshMs);
         }
+        const harnessNamesRead = createLatestKeyGuard();
+        async function refreshHarnessNames() {
+          const hostId2 = view.hostId;
+          const isCurrent = harnessNamesRead.begin(hostId2);
+          names.clear();
+          try {
+            const value = await request(HARNESS_PLUGIN_LIST_METHOD2, {}, hostId2);
+            if (!isCurrent()) return;
+            for (const plugin of harnessPluginListResultSchema.parse(value).plugins) {
+              names.set(plugin.id, plugin.name);
+            }
+          } catch {
+            if (!isCurrent()) return;
+          }
+          if (!context.signal.aborted) render();
+        }
         function load() {
           window.clearTimeout(poll);
           const requested = params();
-          void context.runLatest(() => request(USAGE_STATISTICS_METHOD, requested), {
+          void context.runLatest(() => request(USAGE_STATISTICS_METHOD, requested, view.hostId), {
             success(value) {
               const parsed = usageStatisticsResultSchema.safeParse(value);
               if (parsed.success) {
@@ -28353,12 +29516,8 @@ ${detail}` : ""}`
         }
         context.content.replaceChildren(header, prices.element, filters, notices, body);
         render();
-        void request(HARNESS_PLUGIN_LIST_METHOD2, {}).then((value) => {
-          for (const plugin of harnessPluginListResultSchema.parse(value).plugins) {
-            names.set(plugin.id, plugin.name);
-          }
-          if (!context.signal.aborted) render();
-        }).catch(() => void 0);
+        offerHosts();
+        void refreshHarnessNames();
         load();
         return () => {
           window.clearTimeout(poll);
@@ -28451,6 +29610,8 @@ ${detail}` : ""}`
       harness: "Harness",
       model: "Model",
       project: "Project",
+      host: "Machine",
+      localHost: "This machine",
       filterModel: "Filter by model",
       filterProject: "Filter by project",
       unknownModel: "Unknown model",
@@ -28634,6 +29795,8 @@ ${detail}` : ""}`
       harness: "Harness",
       model: "\u6A21\u578B",
       project: "\u9879\u76EE",
+      host: "\u673A\u5668",
+      localHost: "\u672C\u673A",
       filterModel: "\u6309\u6A21\u578B\u7B5B\u9009",
       filterProject: "\u6309\u9879\u76EE\u7B5B\u9009",
       unknownModel: "\u672A\u77E5\u6A21\u578B",
@@ -29175,8 +30338,8 @@ ${detail}` : ""}`
     return input;
   }
   function createNumberField(document2, input) {
-    const field = document2.createElement("div");
-    field.className = "flex h-8 shrink-0 items-center gap-1.5 rounded-md border border-settings-border bg-settings-surface px-2.5 transition-colors focus-within:border-settings-focus data-[invalid=true]:border-settings-danger";
+    const field2 = document2.createElement("div");
+    field2.className = "flex h-8 shrink-0 items-center gap-1.5 rounded-md border border-settings-border bg-settings-surface px-2.5 transition-colors focus-within:border-settings-focus data-[invalid=true]:border-settings-danger";
     const control = document2.createElement("input");
     control.type = "number";
     control.id = input.id;
@@ -29189,8 +30352,8 @@ ${detail}` : ""}`
     unit.className = "text-xs text-settings-muted";
     unit.setAttribute("aria-hidden", "true");
     unit.textContent = input.unit;
-    field.append(control, unit);
-    return { field, control };
+    field2.append(control, unit);
+    return { field: field2, control };
   }
 
   // src/settings/remote-connections-dialogs.ts
@@ -29274,7 +30437,7 @@ ${detail}` : ""}`
     );
     if (!dialog) return;
     const document2 = options.container.ownerDocument;
-    const field = (label, value, placeholder = "", hint = "") => {
+    const field2 = (label, value, placeholder = "", hint = "") => {
       const wrapper = remoteElement(document2, "div", "settings-credential-dialog__field");
       const input = remoteElement(document2, "input");
       input.id = preferenceId("remote-field");
@@ -29294,13 +30457,13 @@ ${detail}` : ""}`
       dialog.body.append(wrapper);
       return input;
     };
-    const name = field(t("\u540D\u79F0", "Name"), previous?.displayName ?? "");
+    const name = field2(t("\u540D\u79F0", "Name"), previous?.displayName ?? "");
     name.required = true;
     const addressHint = t(
       "user@hostname\uFF0C\u6216 ~/.ssh/config \u4E2D\u7684\u4E3B\u673A\u522B\u540D",
       "user@hostname, or a host alias from ~/.ssh/config"
     );
-    const hostname3 = field(
+    const hostname3 = field2(
       t("SSH \u5730\u5740", "SSH address"),
       previous?.sshHost ?? "",
       "user@hostname",
@@ -29309,7 +30472,7 @@ ${detail}` : ""}`
     hostname3.required = true;
     hostname3.pattern = "[^\\s\\-]\\S*";
     hostname3.title = addressHint;
-    const port = field(
+    const port = field2(
       t("\u7AEF\u53E3\uFF08\u53EF\u9009\uFF09", "Port (optional)"),
       previous?.sshPort?.toString() ?? "",
       "22"
@@ -29318,7 +30481,7 @@ ${detail}` : ""}`
     port.min = "1";
     port.max = "65535";
     port.step = "1";
-    const identity = field(
+    const identity = field2(
       t("\u79C1\u94A5\u8DEF\u5F84\uFF08\u53EF\u9009\uFF09", "Identity file (optional)"),
       previous?.identity ?? "",
       "~/.ssh/id_ed25519"
@@ -30235,6 +31398,50 @@ ${detail}` : ""}`
         };
         setRefreshLabel(false);
         header.append(heading, refresh);
+        let selectedHostId;
+        let availableHostIds = [];
+        let displayedHostId = "";
+        let hostsLocked = false;
+        const hostButtons = [];
+        const hostLabel = document2.createElement("div");
+        hostLabel.className = "settings-session-import-host";
+        const hostCaption = document2.createElement("span");
+        hostCaption.textContent = "Host";
+        const hostOptions = document2.createElement("div");
+        hostOptions.className = "settings-connection-host-tabs";
+        hostOptions.setAttribute("role", "group");
+        hostOptions.setAttribute("aria-label", "Host");
+        hostLabel.append(hostCaption, hostOptions);
+        const lockHosts = (locked) => {
+          hostsLocked = locked;
+          for (const button2 of hostButtons) button2.disabled = locked;
+        };
+        const renderHosts = (client) => {
+          const current = selectedHostId ?? (client ? client.hostId ?? "local" : "");
+          availableHostIds = [
+            .../* @__PURE__ */ new Set([
+              ...getDiagnostics()?.snapshot().hosts.map(({ hostId: hostId2 }) => hostId2) ?? [],
+              ...current ? [current] : []
+            ])
+          ];
+          displayedHostId = current;
+          const scrollLeft = hostOptions.scrollLeft;
+          hostOptions.replaceChildren();
+          hostButtons.length = 0;
+          for (const hostId2 of availableHostIds) {
+            const button2 = document2.createElement("button");
+            button2.type = "button";
+            button2.className = "settings-connection-host-tab";
+            button2.dataset.sessionImportHost = hostId2;
+            button2.textContent = connectionHostName(hostId2, messages);
+            button2.setAttribute("aria-pressed", String(hostId2 === current));
+            button2.disabled = hostsLocked;
+            button2.addEventListener("click", () => selectHost(hostId2));
+            hostButtons.push(button2);
+            hostOptions.append(button2);
+          }
+          hostOptions.scrollLeft = scrollLeft;
+        };
         const harness2 = document2.createElement("div");
         harness2.className = "settings-session-import-harness";
         const harnessLabel = document2.createElement("span");
@@ -30295,6 +31502,7 @@ ${detail}` : ""}`
         const listControls = createSessionImportListControls(document2, messages, () => load());
         context.content.append(
           header,
+          hostLabel,
           harness2,
           description,
           availabilityNote,
@@ -30304,9 +31512,11 @@ ${detail}` : ""}`
           listControls.pagination
         );
         let candidates = [];
+        let loadedClient = null;
         let importingId = null;
         let actions = [];
         const updateImportActions = () => {
+          lockHosts(importingId !== null);
           listControls.setBusy(importingId !== null, importingId !== null);
           for (const button2 of sourceButtons) button2.disabled = importingId !== null;
           for (const { button: button2, candidate } of actions) {
@@ -30327,7 +31537,10 @@ ${detail}` : ""}`
           listControls.setTotal(0);
           candidates = [];
           actions = [];
-          const status = createStatus(document2, messages.sessionImportUnavailable);
+          const status = createStatus(
+            document2,
+            !displayedHostId && availableHostIds.length > 1 ? messages.sessionImportSelectHost : messages.sessionImportUnavailable
+          );
           content.replaceChildren(status);
           if (focus) {
             status.tabIndex = -1;
@@ -30352,7 +31565,7 @@ ${detail}` : ""}`
             status.focus();
           }
         };
-        const renderOpenRecovery = (candidate, threadId) => {
+        const renderOpenRecovery = (candidate, threadId, hostId2) => {
           if (!openImportedThread) return;
           actions = [];
           refresh.disabled = false;
@@ -30405,6 +31618,7 @@ ${detail}` : ""}`
           retry.className = "settings-command-button";
           retry.dataset.sessionImportAction = "retry-open";
           const setRetrying = (pending) => {
+            lockHosts(pending);
             listControls.setBusy(pending, pending);
             for (const button2 of sourceButtons) button2.disabled = pending;
             retry.disabled = pending;
@@ -30419,12 +31633,12 @@ ${detail}` : ""}`
           retry.addEventListener("click", () => {
             if (retry.disabled) return;
             setRetrying(true);
-            void context.runLatest((signal) => openImportedThread(threadId, signal), {
+            void context.runLatest((signal) => openImportedThread(threadId, signal, hostId2), {
               success() {
                 setRetrying(false);
               },
               failure() {
-                renderOpenRecovery(candidate, threadId);
+                renderOpenRecovery(candidate, threadId, hostId2);
               }
             });
           });
@@ -30501,7 +31715,7 @@ ${detail}` : ""}`
               if (candidate.running === true || importingId !== null || selectedHarness === null)
                 return;
               const harnessId = selectedHarness;
-              const client = getClient();
+              const client = loadedClient;
               if (!client) {
                 renderUnavailable(true);
                 return;
@@ -30519,7 +31733,7 @@ ${detail}` : ""}`
                   });
                   committedThreadId = result.threadId;
                   if (!signal.aborted && openImportedThread)
-                    await openImportedThread(result.threadId, signal);
+                    await openImportedThread(result.threadId, signal, client.hostId);
                 },
                 {
                   success() {
@@ -30537,7 +31751,7 @@ ${detail}` : ""}`
                     updateImportActions();
                     refresh.disabled = false;
                     if (committedThreadId) {
-                      renderOpenRecovery(candidate, committedThreadId);
+                      renderOpenRecovery(candidate, committedThreadId, client.hostId);
                     } else {
                       renderFailure(error51, "import");
                     }
@@ -30555,23 +31769,22 @@ ${detail}` : ""}`
         };
         const load = () => {
           if (importingId !== null || context.signal.aborted) return;
-          const client = getClient();
-          if (!client) {
-            refresh.disabled = false;
-            setRefreshLabel(false);
-            renderUnavailable();
-            return;
-          }
-          listControls.setBusy(true);
-          refresh.disabled = true;
-          setRefreshLabel(true);
-          content.replaceChildren(createStatus(document2, messages.sessionImportRefreshing));
+          loadedClient = null;
+          const client = getClient(selectedHostId);
+          renderHosts(client);
+          listControls.setBusy(client !== null);
+          refresh.disabled = client !== null;
+          setRefreshLabel(client !== null);
+          if (client)
+            content.replaceChildren(createStatus(document2, messages.sessionImportRefreshing));
+          else renderUnavailable();
           const requestedHarness = selectedHarness;
           const pageParams = listControls.params();
           void context.runLatest(
             async (signal) => {
+              if (!client) throw new RendererSessionImportUnavailableError();
               const missing = new Set(
-                getDiagnostics()?.snapshot().hosts.find(({ hostId: hostId2 }) => hostId2 === "local")?.agents.filter(({ availability }) => availability === "notInstalled").map(({ agent }) => agent)
+                getDiagnostics()?.snapshot().hosts.find(({ hostId: hostId2 }) => hostId2 === (client.hostId ?? "local"))?.agents.filter(({ availability }) => availability === "notInstalled").map(({ agent }) => agent)
               );
               const harnesses = (await client.listSessionImportSources()).harnesses.filter(
                 ({ harnessId }) => !missing.has(harnessId)
@@ -30589,6 +31802,7 @@ ${detail}` : ""}`
             },
             {
               success(result) {
+                loadedClient = client;
                 listControls.setBusy(false);
                 if (listControls.setTotal(result.total)) {
                   load();
@@ -30601,6 +31815,7 @@ ${detail}` : ""}`
                 else renderCandidates();
               },
               failure(error51) {
+                loadedClient = null;
                 listControls.setBusy(false);
                 candidates = [];
                 refresh.disabled = false;
@@ -30610,6 +31825,19 @@ ${detail}` : ""}`
             }
           );
         };
+        const selectHost = (hostId2) => {
+          if (hostsLocked || !availableHostIds.includes(hostId2) || hostId2 === selectedHostId) return;
+          selectedHostId = hostId2;
+          selectedHarness = null;
+          sources = [];
+          candidates = [];
+          actions = [];
+          importStatus.replaceChildren();
+          listControls.reset();
+          renderHarnessOptions();
+          load();
+          hostButtons.find((button2) => button2.dataset.sessionImportHost === hostId2)?.focus();
+        };
         refresh.addEventListener("click", load);
         load();
         return void 0;
@@ -30750,14 +31978,14 @@ ${detail}` : ""}`
       description: messages.idleReleaseTimeoutDescription,
       controlId: minutesId
     });
-    const { field, control: minutes } = createNumberField(document2, {
+    const { field: field2, control: minutes } = createNumberField(document2, {
       id: minutesId,
       describedBy: timeout.description.id,
       unit: messages.idleReleaseMinutes,
       min: IDLE_RELEASE_TIMEOUT_MINUTES_MIN,
       max: IDLE_RELEASE_TIMEOUT_MINUTES_MAX
     });
-    timeout.item.append(field);
+    timeout.item.append(field2);
     timeout.item.id = preferenceId("idle-release-timeout");
     enabled.setAttribute("aria-controls", timeout.item.id);
     card.append(toggle.item, timeout.item);
@@ -30778,7 +32006,7 @@ ${detail}` : ""}`
       statusText.textContent = value === "applied" ? "" : statusMessages[value];
     };
     const setInvalid = (invalid) => {
-      field.dataset.invalid = String(invalid);
+      field2.dataset.invalid = String(invalid);
       timeout.description.dataset.invalid = String(invalid);
       timeout.description.textContent = invalid ? messages.idleReleaseInvalid : messages.idleReleaseTimeoutDescription;
       minutes.setAttribute("aria-invalid", String(invalid));
@@ -31103,7 +32331,7 @@ ${detail}` : ""}`
   }
   function defaultImportName(source, existing) {
     const base = source.provider === "openai-codex" ? "codex" : "grok";
-    const used = new Set(existing.map((record5) => record5.name));
+    const used = new Set(existing.map((record6) => record6.name));
     const valid = (name) => credentialImportNameSchema.safeParse(name).success;
     if (!used.has(base)) return base;
     const local = source.label.includes("@") ? source.label.split("@")[0] ?? "" : "";
@@ -31126,7 +32354,7 @@ ${detail}` : ""}`
     const shown = (text) => accountDisplayText(text, hideEmails);
     const targetButtons = /* @__PURE__ */ new Map();
     const importedRecords = () => snapshot.targets.find((target) => target.harnessId === TARGET_HARNESS_ID)?.imports ?? [];
-    const sourceOf = (record5) => snapshot.sources.find((source) => source.id === record5.source.id);
+    const sourceOf = (record6) => snapshot.sources.find((source) => source.id === record6.source.id);
     const piTarget = () => snapshot.targets.find((candidate) => candidate.harnessId === TARGET_HARNESS_ID);
     const compatibleSources = () => {
       const target = piTarget();
@@ -31164,7 +32392,7 @@ ${detail}` : ""}`
     sectionImport.addEventListener("click", () => {
       const sources = compatibleSources();
       const free = sources.find(
-        (source2) => !importedRecords().some((record5) => record5.source.id === source2.id)
+        (source2) => !importedRecords().some((record6) => record6.source.id === source2.id)
       );
       const source = free ?? sources[0];
       if (source) openDialog("add", { source, choose: true }, SECTION_IMPORT_KEY);
@@ -31214,30 +32442,30 @@ ${detail}` : ""}`
       mark.append(createRendererAgentIcon(agent ?? "pi", 26, document2, pluginFor(agent ?? "pi")));
       return mark;
     };
-    const renderRow = (record5) => {
+    const renderRow = (record6) => {
       const row = document2.createElement("div");
       row.className = "settings-pi-accounts__row";
       row.tabIndex = -1;
-      row.dataset.importName = record5.name;
-      row.setAttribute("aria-label", shown(record5.source.label));
-      const agent = record5.source.harnessId;
+      row.dataset.importName = record6.name;
+      row.setAttribute("aria-label", shown(record6.source.label));
+      const agent = record6.source.harnessId;
       const mark = createMark(agent);
       const identity = document2.createElement("div");
       identity.className = "settings-pi-accounts__identity";
       const label = document2.createElement("strong");
       label.className = "settings-account-email";
-      label.textContent = shown(record5.source.label);
+      label.textContent = shown(record6.source.label);
       label.title = label.textContent;
       label.translate = false;
       const meta3 = document2.createElement("div");
       meta3.className = "settings-account-metadata";
-      const source = sourceOf(record5);
+      const source = sourceOf(record6);
       const parts = [
         metaPart(rendererAgentLabel(agent, pluginFor(agent)), "settings-pi-accounts__agent"),
-        metaPart(`${record5.name}/\u2026`, void 0, true),
+        metaPart(`${record6.name}/\u2026`, void 0, true),
         metaPart(messages.copied)
       ];
-      const time3 = formatImportedAt(record5.importedAt);
+      const time3 = formatImportedAt(record6.importedAt);
       if (time3) parts.push(metaPart(time3));
       parts.forEach((part, index) => {
         if (index > 0) {
@@ -31254,23 +32482,23 @@ ${detail}` : ""}`
       reimport.type = "button";
       reimport.className = "settings-account-action";
       reimport.textContent = messages.rowReimport;
-      reimport.setAttribute("aria-label", `${messages.reimport}: ${shown(record5.source.label)}`);
+      reimport.setAttribute("aria-label", `${messages.reimport}: ${shown(record6.source.label)}`);
       reimport.disabled = busy || !source;
       reimport.title = messages.reimport;
       reimport.addEventListener("click", () => {
-        if (source) openDialog("reimport", { source, record: record5 }, `row:${record5.name}`);
+        if (source) openDialog("reimport", { source, record: record6 }, `row:${record6.name}`);
       });
       const remove = document2.createElement("button");
       remove.type = "button";
       remove.className = "settings-account-action settings-pi-accounts__remove";
       remove.textContent = messages.rowRemove;
-      remove.setAttribute("aria-label", `${messages.remove}: ${shown(record5.source.label)}`);
+      remove.setAttribute("aria-label", `${messages.remove}: ${shown(record6.source.label)}`);
       remove.disabled = busy;
-      remove.addEventListener("click", () => openDialog("remove", { record: record5 }, `row:${record5.name}`));
+      remove.addEventListener("click", () => openDialog("remove", { record: record6 }, `row:${record6.name}`));
       if (source) actions.append(reimport);
       actions.append(remove);
       row.append(mark, identity, actions);
-      rows.set(record5.name, row);
+      rows.set(record6.name, row);
       return row;
     };
     const loginTypeLabel = (type) => type === "oauth" ? messages.typeOauth : type === "api_key" ? messages.typeApiKey : messages.typeOther;
@@ -31423,7 +32651,7 @@ ${detail}` : ""}`
           const label = document2.createElement("strong");
           label.textContent = shown(choice.label);
           label.translate = false;
-          const existing = importedRecords().find((record5) => record5.source.id === choice.id);
+          const existing = importedRecords().find((record6) => record6.source.id === choice.id);
           const agent = choice.harnessId;
           const detail = document2.createElement("span");
           detail.textContent = [
@@ -31464,7 +32692,7 @@ ${detail}` : ""}`
           const name = request.action === "list" ? void 0 : request.name;
           state = {
             source: state.source,
-            record: importedRecords().find((record5) => record5.name === name) ?? state.record
+            record: importedRecords().find((record6) => record6.name === name) ?? state.record
           };
           show(next);
         } else {
@@ -31478,12 +32706,12 @@ ${detail}` : ""}`
         sourceRadios = [];
         body.replaceChildren();
         controls.replaceChildren();
-        const { source, record: record5 } = state;
+        const { source, record: record6 } = state;
         const close = () => modal.close();
         if (mode === "add" || mode === "reimport") {
           title.textContent = mode === "add" ? messages.add : messages.reimport;
           modal.setAttribute("aria-label", title.textContent);
-          const active = source ?? record5?.source;
+          const active = source ?? record6?.source;
           const choices = mode === "add" && state.choose ? compatibleSources() : [];
           if (choices.length > 1) body.append(sourcePicker(choices));
           else if (active) body.append(line(messages.source, shown(active.label)));
@@ -31492,8 +32720,8 @@ ${detail}` : ""}`
           input.maxLength = 48;
           input.autocomplete = "off";
           input.spellcheck = false;
-          input.value = record5?.name ?? (source ? defaultImportName(source, importedRecords()) : "codex");
-          input.readOnly = Boolean(record5);
+          input.value = record6?.name ?? (source ? defaultImportName(source, importedRecords()) : "codex");
+          input.readOnly = Boolean(record6);
           input.addEventListener("input", () => {
             nameEdited = true;
           });
@@ -31527,7 +32755,7 @@ ${detail}` : ""}`
                   {
                     action: mode === "reimport" ? "reimport" : "import",
                     sourceId: source2.id,
-                    name: record5?.name ?? input.value,
+                    name: record6?.name ?? input.value,
                     confirmed: true
                   },
                   "done"
@@ -31537,16 +32765,16 @@ ${detail}` : ""}`
             )
           );
           (mode === "add" ? input : controls.children[0]).focus();
-        } else if (mode === "remove" && record5) {
+        } else if (mode === "remove" && record6) {
           title.textContent = messages.remove;
           modal.setAttribute("aria-label", title.textContent);
-          body.append(note(messages.removeWarning.replace("{name}", record5.name)));
+          body.append(note(messages.removeWarning.replace("{name}", record6.name)));
           const cancel = command(messages.cancel, close);
           controls.append(
             cancel,
             command(
               messages.remove,
-              () => submit({ action: "remove", name: record5.name, confirmed: true }, null),
+              () => submit({ action: "remove", name: record6.name, confirmed: true }, null),
               "danger"
             )
           );
@@ -31554,7 +32782,7 @@ ${detail}` : ""}`
         } else {
           title.textContent = messages.doneTitle;
           modal.setAttribute("aria-label", title.textContent);
-          const name = record5?.name;
+          const name = record6?.name;
           if (name) body.append(line(messages.entry, `${name}/\u2026`, true));
           body.append(note(messages.done));
           const done = command(messages.close, close, "primary");
@@ -31601,21 +32829,21 @@ ${detail}` : ""}`
           (candidate) => candidate.harnessId === TARGET_HARNESS_ID && source && candidate.providers.includes(source.provider)
         );
         if (!source || !target) return null;
-        const record5 = target.imports.find((candidate) => candidate.source.id === source.id);
+        const record6 = target.imports.find((candidate) => candidate.source.id === source.id);
         const key = `${harnessId}:${accountLabel}:import`;
         const button2 = document2.createElement("button");
         button2.type = "button";
         button2.className = "settings-account-pi-import";
         button2.dataset.accountFocus = key;
         button2.disabled = busy;
-        const hint = record5 ? messages.importedHint.replace("{name}", record5.name) : messages.add;
+        const hint = record6 ? messages.importedHint.replace("{name}", record6.name) : messages.add;
         button2.title = hint;
         button2.setAttribute("aria-label", hint);
         button2.append(createRendererAgentIcon("pi", 12, document2, pluginFor("pi")));
-        if (record5) {
+        if (record6) {
           button2.dataset.state = "imported";
           const name = document2.createElement("code");
-          name.textContent = `${record5.name}/\u2026`;
+          name.textContent = `${record6.name}/\u2026`;
           name.translate = false;
           button2.append(name, createRendererSettingsIcon("check", 12));
         } else {
@@ -31623,7 +32851,7 @@ ${detail}` : ""}`
           button2.append(messages.add);
         }
         button2.addEventListener("click", () => {
-          if (!record5) {
+          if (!record6) {
             openDialog("add", { source }, key);
             return;
           }
@@ -31632,7 +32860,7 @@ ${detail}` : ""}`
             renderSection();
             sectionToggle.setAttribute("aria-expanded", "true");
           }
-          const row = rows.get(record5.name);
+          const row = rows.get(record6.name);
           row?.scrollIntoView({ block: "nearest", behavior: "smooth" });
           row?.focus();
         });
@@ -33177,7 +34405,7 @@ ${detail}` : ""}`
       }
     });
   }
-  function createDefaultRendererSettingsPages(messages = DEFAULT_RENDERER_SETTINGS_MESSAGES, getUpdateClient = () => null, getDiagnostics = () => null, getAccountClient = () => null, getSessionImportClient = () => null, openImportedThread = () => Promise.reject(new Error("Imported Thread navigation is unavailable")), getLoadedSessionsClient = () => null, getRemoteConnections = () => null, requestUsageStatistics = () => Promise.reject(new Error("Local Host connection is unavailable"))) {
+  function createDefaultRendererSettingsPages(messages = DEFAULT_RENDERER_SETTINGS_MESSAGES, getUpdateClient = () => null, getDiagnostics = () => null, getAccountClient = () => null, getSessionImportClient = () => null, openImportedThread = () => Promise.reject(new Error("Imported Thread navigation is unavailable")), getLoadedSessionsClient = () => null, getRemoteConnections = () => null, requestUsageStatistics = () => Promise.reject(new Error("Local Host connection is unavailable")), usageStatisticsHosts) {
     return Object.freeze([
       createConnectionsSettingsPage(messages, getDiagnostics, void 0, getRemoteConnections),
       createRemoteConnectionsPage(messages, getRemoteConnections),
@@ -33191,14 +34419,15 @@ ${detail}` : ""}`
       createUsageStatisticsPage(
         consoleMessages(messages.locale),
         requestUsageStatistics,
-        messages.locale
+        messages.locale,
+        usageStatisticsHosts
       ),
       createAppearanceSettingsPage(messages, getLoadedSessionsClient),
       updatesPage(messages, getUpdateClient),
       aboutPage(messages, getUpdateClient)
     ]);
   }
-  function createDefaultRendererSettingsRegistry(messages = DEFAULT_RENDERER_SETTINGS_MESSAGES, getUpdateClient = () => null, getDiagnostics = () => null, getAccountClient = () => null, getSessionImportClient = () => null, openImportedThread, requestUsageStatistics) {
+  function createDefaultRendererSettingsRegistry(messages = DEFAULT_RENDERER_SETTINGS_MESSAGES, getUpdateClient = () => null, getDiagnostics = () => null, getAccountClient = () => null, getSessionImportClient = () => null, openImportedThread, requestUsageStatistics, usageStatisticsHosts) {
     return createRendererSettingsPageRegistry(
       createDefaultRendererSettingsPages(
         messages,
@@ -33209,7 +34438,8 @@ ${detail}` : ""}`
         openImportedThread,
         void 0,
         void 0,
-        requestUsageStatistics
+        requestUsageStatistics,
+        usageStatisticsHosts
       )
     );
   }
@@ -33765,6 +34995,41 @@ ${detail}` : ""}`
   margin-top: 0;
 }
 
+.settings-session-import-host {
+  display: flex;
+  align-items: center;
+  min-width: 0;
+  gap: 12px;
+  margin: -12px 0 12px;
+  color: var(--settings-muted);
+  font-size: 13px;
+}
+
+.settings-session-import-host > span,
+.settings-session-import-host + .settings-session-import-harness > span {
+  flex: none;
+  min-width: 60px;
+}
+
+.settings-session-import-host > .settings-connection-host-tabs {
+  flex: 1;
+}
+
+.settings-session-import-host .settings-connection-host-tab {
+  height: 34px;
+  padding: 0 12px;
+  font-size: 13px;
+}
+
+.settings-session-import-host .settings-connection-host-tab:disabled {
+  opacity: 0.38;
+  cursor: not-allowed;
+}
+
+.settings-session-import-host + .settings-session-import-harness {
+  margin-top: 0;
+}
+
 .settings-session-import-search,
 .settings-session-import-pagination {
   display: flex;
@@ -33983,6 +35248,20 @@ ${detail}` : ""}`
   gap: 18px;
 }
 
+.settings-connections-content {
+  container: settings-connections / inline-size;
+}
+
+@container settings-connections (max-width: 780px) {
+  .settings-connections-layout {
+    grid-template-columns: minmax(0, 1fr);
+  }
+
+  .settings-connection-inspector {
+    position: static;
+  }
+}
+
 .settings-connection-list,
 .settings-connection-inspector {
   overflow: hidden;
@@ -33991,14 +35270,36 @@ ${detail}` : ""}`
   border-radius: 10px;
 }
 
+.settings-connection-host-header {
+  display: flex;
+  align-items: center;
+  min-width: 0;
+  border-bottom: 1px solid var(--settings-divider);
+}
+
+.settings-connection-update-all {
+  flex: none;
+  margin-right: 10px;
+  white-space: nowrap;
+}
+
+.settings-connection-update-result {
+  margin: 0;
+  padding: 7px 10px;
+  color: var(--settings-muted);
+  font-size: 11px;
+  line-height: 18px;
+  border-bottom: 1px solid var(--settings-divider);
+}
+
 .settings-connection-host-strip {
   display: grid;
+  flex: 1;
   grid-template-columns: 30px minmax(0, 1fr) 30px;
   align-items: center;
   min-width: 0;
   gap: 5px;
   padding: 9px 10px;
-  border-bottom: 1px solid var(--settings-divider);
 }
 
 .settings-connection-host-scroll {
@@ -34085,7 +35386,8 @@ ${detail}` : ""}`
   background: var(--settings-hover);
 }
 
-.settings-connection-host-tab[aria-selected="true"] {
+.settings-connection-host-tab[aria-selected="true"],
+.settings-connection-host-tab[aria-pressed="true"] {
   color: var(--settings-text);
   font-weight: 600;
   background: var(--settings-active);
@@ -34095,7 +35397,7 @@ ${detail}` : ""}`
 .settings-connection-table-header,
 .settings-connection-row {
   display: grid;
-  grid-template-columns: minmax(160px, 1fr) minmax(92px, auto) 108px;
+  grid-template-columns: minmax(160px, 1fr) minmax(92px, auto) minmax(108px, max-content);
   align-items: center;
   min-width: 0;
   gap: 10px;
@@ -34188,6 +35490,14 @@ ${detail}` : ""}`
   line-height: 18px;
 }
 
+.settings-connection-version-available {
+  flex: none;
+  color: var(--settings-muted);
+  font-size: 10px;
+  line-height: 16px;
+  white-space: nowrap;
+}
+
 .settings-connection-row__status::before {
   width: 6px;
   height: 6px;
@@ -34224,6 +35534,7 @@ ${detail}` : ""}`
   justify-content: flex-end;
   min-width: 0;
   gap: 4px;
+  white-space: nowrap;
 }
 
 .settings-connection-row__handle {
@@ -38372,16 +39683,17 @@ ${usage_default}`;
         options.getConnectionDiagnostics ?? (() => null),
         options.getAccountClient ?? (() => null),
         options.getSessionImportClient ?? (() => null),
-        async (threadId, signal) => {
+        async (threadId, signal, hostId2) => {
           if (!options.openImportedThread) {
             throw new Error("Imported Thread navigation is unavailable");
           }
-          await options.openImportedThread(threadId, signal);
+          await options.openImportedThread(threadId, signal, hostId2);
           if (!disposed && !signal.aborted) shell?.close();
         },
         options.getLoadedSessionsClient ?? (() => null),
         options.getRemoteConnections ?? (() => null),
-        options.requestUsageStatistics
+        options.requestUsageStatistics,
+        options.usageStatisticsHosts
       );
       const nextShell = installRendererSettingsShell(definitions, messages, ownerWindow.document, {
         onOpenChange(open) {
@@ -38530,6 +39842,30 @@ ${usage_default}`;
     };
   }
 
+  // src/renderer-usage-statistics-source.ts
+  function createRendererUsageStatisticsSource(options) {
+    return {
+      async request(method, params, hostId2) {
+        const route = options.routing()?.forHost(hostId2);
+        if (options.disposed() || !route) {
+          throw new Error(`Host connection is unavailable (${hostId2})`);
+        }
+        return route.manager.sendRequest(method, params);
+      },
+      async hosts() {
+        const connections = await options.listConnections().catch(() => []);
+        const names = new Map(
+          connections.map((connection) => [connection.hostId, connection.displayName])
+        );
+        const known = options.routing()?.knownHostIds?.() ?? [];
+        return [.../* @__PURE__ */ new Set([...known, ...names.keys()])].map((hostId2) => {
+          const label = names.get(hostId2);
+          return label === void 0 ? { hostId: hostId2 } : { hostId: hostId2, label };
+        });
+      }
+    };
+  }
+
   // src/renderer-native-composer-controller.ts
   var MAX_ELEMENT_DEPTH = 4;
   var MAX_FIBER_DEPTH = 40;
@@ -39365,9 +40701,13 @@ ${usage_default}`;
   function mutationMayAffectComposer(mutation) {
     const target = mutation.target instanceof Element ? mutation.target : mutation.target.parentElement;
     if (!target) return true;
-    if (mutation.type === "attributes" && mutation.attributeName === "data-codex-composer-root")
+    if (mutation.type === "attributes" && (mutation.attributeName === "data-codex-composer-root" || NATIVE_COMPOSER_REQUEST_ATTRIBUTES.some((attribute) => attribute === mutation.attributeName)))
       return true;
-    if (mutation.type !== "attributes" && editorForElement(target)) return false;
+    if (mutation.type !== "attributes" && editorForElement(target)) {
+      return mutation.type === "childList" && [...mutation.addedNodes, ...mutation.removedNodes].some(
+        (node) => node instanceof Element && hasNativeComposerRequest(node)
+      );
+    }
     if (target.closest(CODEX_COMPOSER_SELECTOR)) return true;
     if (mutation.type === "characterData") return false;
     if (!target.closest(
@@ -39458,30 +40798,35 @@ ${usage_default}`;
     });
     let connectionDiagnostics = null;
     const remoteConnections = createRemoteConnectionsControl(window, modelClientForHost);
+    const usageStatistics = createRendererUsageStatisticsSource({
+      routing: () => window.__codexhostHostRoutingV1,
+      listConnections: () => remoteConnections.ssh.list(),
+      disposed: () => disposed
+    });
     const settingsLifecycle = installRendererSettingsLifecycle(window, {
       getRemoteConnections: () => remoteConnections,
       getUpdateClient: () => modelControl,
       getAccountClient: () => modelControl,
       getConnectionDiagnostics: () => connectionDiagnostics,
       getLoadedSessionsClient: () => modelClientForHost("local"),
-      async requestUsageStatistics(method, params) {
-        const route = window.__codexhostHostRoutingV1?.forHost("local");
-        if (disposed || !route) throw new Error("Local Host connection is unavailable");
-        return route.manager.sendRequest(method, params);
-      },
-      getSessionImportClient: () => {
-        const client = modelClientForHost("local");
+      requestUsageStatistics: usageStatistics.request,
+      usageStatisticsHosts: usageStatistics.hosts,
+      getSessionImportClient: (requestedHostId) => {
+        const hostId2 = requestedHostId ?? activeModelHostId();
+        if (!hostId2) return null;
+        const client = modelClientForHost(hostId2);
         const sources = client?.listSessionImportSources;
         const list = client?.listHarnessSessions;
         const importSession = client?.importHarnessSession;
         if (!sources || !list || !importSession) return null;
         return {
+          hostId: hostId2,
           listSessionImportSources: () => sources(),
           listHarnessSessions: (input) => list(input),
           importHarnessSession: (input) => importSession(input)
         };
       },
-      openImportedThread: (threadId, signal) => openRendererThread(threadId, { hostId: "local", signal }),
+      openImportedThread: (threadId, signal, hostId2) => openRendererThread(threadId, { hostId: hostId2 ?? "local", signal }),
       onLocaleChange() {
         for (const mounted of mountedByComposer.values()) renderMounted(mounted);
       }
@@ -39552,7 +40897,7 @@ ${usage_default}`;
     const ownershipRecovery = /* @__PURE__ */ new WeakMap();
     const modelRecovery = /* @__PURE__ */ new WeakMap();
     const isRetainedComposer = (mounted) => mounted.composer.isConnected && mounted.composer.matches(CODEX_COMPOSER_SELECTOR) && mountedByComposer.get(mounted.composer) === mounted;
-    const isMountedComposer = (composer) => composer.isConnected && composer.matches(CODEX_COMPOSER_SELECTOR) && orbitComposerKind(composer) === "codex" && mountedByComposer.has(composer);
+    const isMountedComposer = (composer) => composer.isConnected && composer.matches(CODEX_COMPOSER_SELECTOR) && !hasNativeComposerRequest(composer) && orbitComposerKind(composer) === "codex" && mountedByComposer.has(composer);
     const isCurrentModelRequest = (mounted, generation) => isMountedComposer(mounted.composer) && mountedByComposer.get(mounted.composer) === mounted && controller.isCurrentModelRequest(mounted.composer, generation);
     const isCurrentOwnershipRequest = (mounted, generation) => isMountedComposer(mounted.composer) && mountedByComposer.get(mounted.composer) === mounted && controller.isCurrentOwnershipRequest(mounted.composer, generation);
     const finishModelRequest = (mounted, generation) => {
@@ -39565,9 +40910,10 @@ ${usage_default}`;
     };
     const notifySubmission = (composer, trigger) => {
       const state = controller.recordSubmission(composer);
+      const createsThread = state.phase === "draft";
       const preferenceStorage = rendererNewThreadPreferenceStorage(activeModelHostId(composer));
-      writeNewThreadAgentPreference(state.agent, preferenceStorage);
-      if (state.agent !== "codex") {
+      if (createsThread) writeNewThreadAgentPreference(state.agent, preferenceStorage);
+      if (createsThread && state.agent !== "codex") {
         const model2 = controller.modelForAgent(composer, state.agent);
         if (model2) {
           writeNewThreadExternalConfigurationPreference(
@@ -40706,7 +42052,7 @@ ${usage_default}`;
             let webUiAvailable = false;
             try {
               const inspection = await client.inspectHarness(
-                { harnessId: harnessIdSchema.parse(agent), refresh },
+                { harnessId: harnessIdSchema.parse(agent), refresh, purpose: "availability" },
                 { priority: "background" }
               );
               status = inspection.status === "ready" ? "ready" : inspection.status;
@@ -40946,10 +42292,10 @@ ${usage_default}`;
       }
     };
     const mount = (composer) => {
-      if (mountedByComposer.has(composer) || !composer.isConnected || orbitComposerKind(composer) !== "codex" || !composer.matches(CODEX_COMPOSER_SELECTOR)) {
+      if (mountedByComposer.has(composer) || !composer.isConnected || hasNativeComposerRequest(composer) || orbitComposerKind(composer) !== "codex" || !composer.matches(CODEX_COMPOSER_SELECTOR)) {
         return;
       }
-      const allButtons = [...composer.querySelectorAll("button")];
+      const allButtons = composerButtonsWithin(composer);
       const sendButton = sendButtonWithin(composer) ?? allButtons.at(-1) ?? null;
       if (!sendButton) return;
       const modelTarget = findComposerModelTarget(composer);
@@ -41044,7 +42390,7 @@ ${usage_default}`;
         const sourceState = controller.get(replacement.source.composer);
         const replacementTarget = findComposerModelTarget(target);
         const replacementHostId = activeModelHostId(target);
-        if (orbitComposerKind(target) !== "codex" || !shouldTransferComposerState(
+        if (hasNativeComposerRequest(target) || orbitComposerKind(target) !== "codex" || !shouldTransferComposerState(
           replacement.sourceModelTarget,
           replacementTarget,
           sourceState.phase,
@@ -41061,7 +42407,7 @@ ${usage_default}`;
       }
       for (const [composer, mounted] of mountedByComposer) {
         const kind = orbitComposerKind(composer);
-        if (!composer.isConnected || kind === "orbit" || !composer.matches(CODEX_COMPOSER_SELECTOR) || !mounted.control.root.isConnected) {
+        if (!composer.isConnected || hasNativeComposerRequest(composer) || kind === "orbit" || !composer.matches(CODEX_COMPOSER_SELECTOR) || !mounted.control.root.isConnected) {
           mounted.usageRequestGeneration += 1;
           usageRefreshAttempts.delete(composer);
           const timer = usageRefreshTimers.get(composer);
@@ -41110,6 +42456,7 @@ ${usage_default}`;
         void refreshHarnessAvailability();
       }
       pendingReplacements.clear();
+      questions.refreshContext();
     };
     const scheduleScan = (refreshTargets = false) => {
       refreshTargetsOnNextScan ||= refreshTargets;
@@ -41293,7 +42640,12 @@ ${usage_default}`;
     };
     mutationObserver.observe(document.documentElement, {
       attributes: true,
-      attributeFilter: ["hidden", "aria-hidden", "data-codex-composer-root"],
+      attributeFilter: [
+        "hidden",
+        "aria-hidden",
+        "data-codex-composer-root",
+        ...NATIVE_COMPOSER_REQUEST_ATTRIBUTES
+      ],
       characterData: true,
       childList: true,
       subtree: true
@@ -41390,6 +42742,16 @@ ${usage_default}`;
     const connectedComposers = () => [...mountedByComposer.values()].filter(
       (mounted) => isMountedComposer(mounted.composer) && mounted.control.root.isConnected
     );
+    const questions = installRendererQuestions(window, () => {
+      const visible = connectedComposers().filter(
+        (mounted2) => mounted2.composer.getClientRects().length > 0 && window.getComputedStyle(mounted2.composer).visibility === "visible" && !mounted2.composer.closest('[hidden], [inert], [aria-hidden="true"]') && controller.get(mounted2.composer).agent !== "codex"
+      );
+      const mounted = visible.length === 1 ? visible[0] : void 0;
+      const threadId = mounted ? threadIdFromComposerModelTarget(findComposerModelTarget(mounted.composer)) : null;
+      const hostId2 = mounted?.hostId;
+      const route = hostId2 ? window.__codexhostHostRoutingV1?.forHost(hostId2) : null;
+      return mounted && threadId && hostId2 && route ? { hostId: hostId2, threadId, composer: mounted.composer, route: route.manager } : null;
+    });
     const api = {
       remoteConnections: (request) => handleRemoteConnectionsRequest(remoteConnections, request),
       currentThreadId() {
@@ -41481,6 +42843,7 @@ ${usage_default}`;
       dispose() {
         if (disposed) return;
         disposed = true;
+        questions.dispose();
         usageNotificationDispose();
         adapterDispose?.();
         adapterDispose = null;
@@ -41561,6 +42924,10 @@ ${usage_default}`;
 
 lucide/dist/esm/defaultAttributes.mjs:
 lucide/dist/esm/createElement.mjs:
+lucide/dist/esm/icons/check.mjs:
+lucide/dist/esm/icons/message-circle-question-mark.mjs:
+lucide/dist/esm/icons/pencil.mjs:
+lucide/dist/esm/icons/x.mjs:
 lucide/dist/esm/icons/boxes.mjs:
 lucide/dist/esm/icons/circle-check.mjs:
 lucide/dist/esm/icons/chevron-down.mjs:
@@ -41596,11 +42963,10 @@ lucide/dist/esm/icons/terminal.mjs:
 lucide/dist/esm/icons/scroll-text.mjs:
 lucide/dist/esm/icons/search.mjs:
 lucide/dist/esm/icons/circle-question-mark.mjs:
-lucide/dist/esm/icons/x.mjs:
 lucide/dist/esm/icons/users.mjs:
 lucide/dist/esm/icons/plus.mjs:
 lucide/dist/esm/icons/circle-alert.mjs:
-lucide/dist/esm/icons/check.mjs:
+lucide/dist/esm/icons/activity.mjs:
 lucide/dist/esm/icons/lock.mjs:
 lucide/dist/esm/icons/shield.mjs:
 lucide/dist/esm/icons/shield-alert.mjs: