@codexhost/cli-darwin-x64 0.14.0 → 0.15.0

package/app/renderer-extension.js

@@ -3266,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);
         }
       }
@@ -15059,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),
@@ -16309,6 +16356,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     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 {
@@ -16316,11 +16364,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       } catch {
         continue;
       }
-      const matches = new Set(Object.values(module).filter(matchesServices));
+      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");
-      if (matches.size === 1) return [...matches][0] ?? null;
     }
-    return null;
+    return [...matches][0] ?? null;
   }
 
   // src/codex-ssh-services.ts
@@ -16588,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) {
@@ -16917,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 = [
     [
@@ -17257,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" }],
@@ -18966,12 +19510,13 @@ ${messages.harnessVersionLatest}: ${harnessVersionLabel(version2.state, messages
     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.",
@@ -18979,7 +19524,7 @@ ${messages.harnessVersionLatest}: ${harnessVersionLabel(version2.state, messages
     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",
@@ -19246,12 +19791,13 @@ ${messages.harnessVersionLatest}: ${harnessVersionLabel(version2.state, messages
     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",
@@ -19259,7 +19805,7 @@ ${messages.harnessVersionLatest}: ${harnessVersionLabel(version2.state, messages
     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",
@@ -20087,6 +20633,8 @@ ${messages.harnessVersionLatest}: ${harnessVersionLabel(version2.state, messages
   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)";
@@ -20116,6 +20664,23 @@ ${messages.harnessVersionLatest}: ${harnessVersionLabel(version2.state, messages
     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");
@@ -20154,10 +20719,55 @@ ${messages.harnessVersionLatest}: ${harnessVersionLabel(version2.state, messages
       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",
@@ -20511,13 +21121,19 @@ ${messages.harnessVersionLatest}: ${harnessVersionLabel(version2.state, messages
     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");
@@ -21383,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";
@@ -21828,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" }],
@@ -21945,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";
@@ -21955,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;
@@ -22670,6 +23289,21 @@ Codex Fast mode prioritizes requests and may increase usage.`
     };
   }
 
+  // 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";
@@ -22831,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) {
@@ -22877,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);
@@ -23001,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;
@@ -23015,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);
@@ -23185,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) {
@@ -23256,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,
@@ -23840,38 +24480,6 @@ Codex Fast mode prioritizes requests and may increase usage.`
     return task.result;
   }
 
-  // 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-native-thread.ts
   function isRecord4(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -26342,14 +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);
   }
@@ -26371,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) {
@@ -26393,95 +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 (request.kind !== "locale-info" && 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
-      };
       void (async () => {
-        if (request.kind === "locale-info") {
-          const native = await loadCodexNativeServices(ownerWindow, isNativeLocaleServices);
-          if (settled) return;
-          if (native) {
-            const response = await native.appInfo.getLocaleInfo();
-            settle(() => resolve(response));
-            return;
-          }
-        }
-        if (typeof bridge?.sendMessageFromView !== "function") {
-          throw new Error("Codex locale bridge is unavailable");
-        }
-        await bridge.sendMessageFromView(message2);
+        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;
@@ -26490,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({
@@ -26841,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 };
   }
@@ -26852,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: {
@@ -26883,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) {
@@ -26951,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
@@ -27774,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)));
@@ -28138,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) {
@@ -28555,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,
@@ -28570,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) {
@@ -29771,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;
@@ -29785,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
@@ -29870,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");
@@ -29890,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",
@@ -29905,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"
@@ -29914,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"
@@ -30831,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");
@@ -30891,6 +31502,7 @@ ${detail}` : ""}`
         const listControls = createSessionImportListControls(document2, messages, () => load());
         context.content.append(
           header,
+          hostLabel,
           harness2,
           description,
           availabilityNote,
@@ -30900,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) {
@@ -30923,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;
@@ -30948,7 +31565,7 @@ ${detail}` : ""}`
             status.focus();
           }
         };
-        const renderOpenRecovery = (candidate, threadId) => {
+        const renderOpenRecovery = (candidate, threadId, hostId2) => {
           if (!openImportedThread) return;
           actions = [];
           refresh.disabled = false;
@@ -31001,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;
@@ -31015,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);
               }
             });
           });
@@ -31097,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;
@@ -31115,7 +31733,7 @@ ${detail}` : ""}`
                   });
                   committedThreadId = result.threadId;
                   if (!signal.aborted && openImportedThread)
-                    await openImportedThread(result.threadId, signal);
+                    await openImportedThread(result.threadId, signal, client.hostId);
                 },
                 {
                   success() {
@@ -31133,7 +31751,7 @@ ${detail}` : ""}`
                     updateImportActions();
                     refresh.disabled = false;
                     if (committedThreadId) {
-                      renderOpenRecovery(candidate, committedThreadId);
+                      renderOpenRecovery(candidate, committedThreadId, client.hostId);
                     } else {
                       renderFailure(error51, "import");
                     }
@@ -31151,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)
@@ -31185,6 +31802,7 @@ ${detail}` : ""}`
             },
             {
               success(result) {
+                loadedClient = client;
                 listControls.setBusy(false);
                 if (listControls.setTotal(result.total)) {
                   load();
@@ -31197,6 +31815,7 @@ ${detail}` : ""}`
                 else renderCandidates();
               },
               failure(error51) {
+                loadedClient = null;
                 listControls.setBusy(false);
                 candidates = [];
                 refresh.disabled = false;
@@ -31206,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;
@@ -31346,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);
@@ -31374,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));
@@ -34363,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;
@@ -34719,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);
@@ -39015,11 +39683,11 @@ ${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),
@@ -40033,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(
@@ -40139,19 +40811,22 @@ ${usage_default}`;
       getLoadedSessionsClient: () => modelClientForHost("local"),
       requestUsageStatistics: usageStatistics.request,
       usageStatisticsHosts: usageStatistics.hosts,
-      getSessionImportClient: () => {
-        const client = modelClientForHost("local");
+      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);
       }
@@ -40222,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) => {
@@ -41617,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);
@@ -41715,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,
@@ -41732,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);
@@ -41781,6 +42456,7 @@ ${usage_default}`;
         void refreshHarnessAvailability();
       }
       pendingReplacements.clear();
+      questions.refreshContext();
     };
     const scheduleScan = (refreshTargets = false) => {
       refreshTargetsOnNextScan ||= refreshTargets;
@@ -41964,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
@@ -42061,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() {
@@ -42152,6 +42843,7 @@ ${usage_default}`;
       dispose() {
         if (disposed) return;
         disposed = true;
+        questions.dispose();
         usageNotificationDispose();
         adapterDispose?.();
         adapterDispose = null;
@@ -42232,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:
@@ -42267,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: