@codexhost/cli-linux-arm64 0.14.0 → 0.16.0

package/app/host-runtime.mjs

@@ -5369,7 +5369,8 @@ function createBackgroundUpdateManager(dependencies2 = {}) {
           kind: "npm",
           node_path: await requireRegularFile(options2.nodePath, "npm Node.js executable"),
           npm_cli_path: await requireRegularFile(options2.npmCliPath, "npm CLI"),
-          npm_launcher_path: await requireRegularFile(options2.npmLauncherPath, "npm codexhost launcher")
+          npm_launcher_path: await requireRegularFile(options2.npmLauncherPath, "npm codexhost launcher"),
+          npm_package_root: requireAbsolutePath(options2.packageRoot, "npm platform package root")
         });
       } catch (error51) {
         await writeFailedStatus(common.statusPath, common.version, "npm", error51);
@@ -8461,10 +8462,10 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     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);
       }
     }
@@ -20114,6 +20115,8 @@ var usageStatisticsTotalsSchema = external_exports.strictObject({
   cachedInputTokens: count,
   cacheWriteInputTokens: count,
   cacheKnownInputTokens: count,
+  cacheHitCachedInputTokens: count,
+  cacheHitInputTokens: count,
   outputTokens: count,
   reasoningOutputTokens: count,
   /** USD at the public price, summed over the priced requests only. */
@@ -20223,6 +20226,53 @@ var THREAD_PREWARM_DISCARD_METHOD = "codexhost/thread/prewarm/discard";
 var threadPrewarmDiscardParamsSchema = external_exports.object({ threadId: hostThreadIdSchema });
 var threadPrewarmDiscardResultSchema = external_exports.object({ discarded: external_exports.boolean() });
 
+// packages/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) });
+
 // packages/shared-contracts/dist/console.js
 var consoleAnnouncementSchema = external_exports.strictObject({
   title: external_exports.string().trim().min(1).max(200),
@@ -22447,8 +22497,110 @@ function retainRendererHostResponses(client, hostId2, target) {
   };
 }
 
+// packages/desktop-control/dist/renderer-prewarm-consumption.js
+function isolateRendererPrewarmConsumption(manager, discardExternal) {
+  const record4 = (value2) => value2 !== null && typeof value2 === "object";
+  if (!record4(manager) || !record4(manager.threadCreation))
+    return null;
+  const creation = manager.threadCreation;
+  const originalStart = manager.startConversation;
+  const original = creation.createConversation;
+  const params = creation.params;
+  if (typeof originalStart !== "function" || typeof original !== "function" || !record4(params))
+    return null;
+  const prototype = Object.getPrototypeOf(creation);
+  if (!record4(prototype) || typeof prototype.constructor !== "function")
+    return null;
+  if (Object.keys(creation).some((key) => key !== "params" && typeof creation[key] !== "function") || /#[A-Za-z_$]/u.test(Function.prototype.toString.call(prototype.constructor)))
+    return null;
+  const pool = params.prewarmedThreadManager;
+  if (!record4(pool) || typeof pool.hasPrewarmedThread !== "function" || typeof pool.consumePrewarmedThread !== "function" || typeof pool.deletePrewarmedThread !== "function")
+    return null;
+  const consume = pool.consumePrewarmedThread;
+  const hasPrewarm = pool.hasPrewarmedThread;
+  const draftModels = /* @__PURE__ */ new Map();
+  const draftIdentity = /* @__PURE__ */ Symbol("codexhost draft creation");
+  const external = (model2) => typeof model2 === "string" && model2.startsWith("codexhost/");
+  const routedStart = function(input, options2, ...args) {
+    const draftId = record4(options2) ? options2.clientThreadId : null;
+    const mode = record4(input) && record4(input.collaborationMode) ? input.collaborationMode : null;
+    const origin = mode ? Reflect.get(mode, draftIdentity) : void 0;
+    if (mode && record4(mode.settings) && external(mode.settings.model))
+      return originalStart.call(this, input, options2, ...args);
+    const model2 = (typeof draftId === "string" ? draftModels.get(draftId) : void 0) ?? (typeof origin === "string" ? draftModels.get(origin) : void 0);
+    if (!model2)
+      return originalStart.call(this, input, options2, ...args);
+    if (!record4(input) || !record4(input.collaborationMode) || !record4(input.collaborationMode.settings))
+      throw new Error("External draft creation is missing its native Model settings");
+    const routed = {
+      ...input,
+      collaborationMode: {
+        ...input.collaborationMode,
+        settings: { ...input.collaborationMode.settings, model: model2 }
+      }
+    };
+    return originalStart.call(this, routed, options2, ...args);
+  };
+  const wrapped = function(input, ...args) {
+    const mode = record4(input) && record4(input.collaborationMode) ? input.collaborationMode : null;
+    const expected = mode && record4(mode.settings) ? mode.settings.model : null;
+    const scopedPool = Object.create(pool);
+    scopedPool.hasPrewarmedThread = (...parameters) => hasPrewarm.apply(pool, parameters);
+    scopedPool.consumePrewarmedThread = async (...consumeArgs) => {
+      const warmed = await consume.apply(pool, consumeArgs);
+      if (!record4(warmed) || !record4(warmed.response))
+        return warmed;
+      const response = warmed.response;
+      if (!external(expected) && !external(response.model))
+        return warmed;
+      if (external(expected) && expected === response.model)
+        return warmed;
+      if (record4(response.thread) && typeof response.thread.id === "string") {
+        const threadId2 = response.thread.id;
+        if (external(response.model))
+          discardExternal(threadId2);
+        else
+          void Promise.resolve().then(() => pool.deletePrewarmedThread(threadId2)).catch(() => void 0);
+      }
+      return null;
+    };
+    const invocation = Object.create(creation);
+    invocation.params = { ...params, prewarmedThreadManager: scopedPool };
+    return original.call(invocation, input, ...args);
+  };
+  creation.createConversation = wrapped;
+  manager.startConversation = routedStart;
+  return {
+    selectDraft(draftId, model2, creationModes = []) {
+      if (draftId === void 0) {
+        if (model2 === null)
+          draftModels.clear();
+      } else if (model2 === null)
+        draftModels.delete(draftId);
+      else {
+        if (!draftId.startsWith("client-new-thread:") || !external(model2))
+          throw new Error("External draft route is missing its client Thread identity");
+        draftModels.set(draftId, model2);
+        for (const mode of creationModes)
+          Object.defineProperty(mode, draftIdentity, {
+            configurable: true,
+            enumerable: true,
+            value: draftId
+          });
+      }
+    },
+    dispose() {
+      draftModels.clear();
+      if (manager.startConversation === routedStart)
+        manager.startConversation = originalStart;
+      if (creation.createConversation === wrapped)
+        creation.createConversation = original;
+    }
+  };
+}
+
 // packages/desktop-control/dist/renderer-draft-prewarm-runtime.js
-function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewarmedThreadManager, isCurrentManager, retainResponses = retainRendererHostResponses) {
+function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewarmedThreadManager, isCurrentManager, retainResponses = retainRendererHostResponses, isolateConsumption = isolateRendererPrewarmConsumption) {
   let disposed = false;
   const originalSend = bridge.sendRequest;
   const originalPrewarm = bridge.prewarmThreadStart;
@@ -22838,25 +22990,15 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
       return false;
     return selectedModel !== null && (method.startsWith("thread/") || method.startsWith("turn/") || method.startsWith("review/"));
   };
-  const routeThreadStart = (parameters) => {
-    if (!isRecord19(parameters) || parameters.ephemeral === true) {
-      return parameters;
-    }
-    return {
-      ...parameters,
-      ...selectedModel === null ? {} : { model: selectedModel }
-    };
-  };
   const routedSend = (method, parameters, options2) => {
     if (method === "turn/start" || method === "thread/resume" || method === "codexhost/thread/command/execute") {
       const threadId2 = threadIdFromParameters(parameters);
       if (threadId2)
         externalPrewarms.delete(threadId2);
     }
-    const routedParameters = method === "thread/start" ? routeThreadStart(parameters) : parameters;
-    const sendBridged = () => initializeBridge().then(() => enqueueBridgeRequest(method, routedParameters, options2));
-    const sendDirect = () => options2 === void 0 ? originalSend.call(bridge, method, routedParameters) : originalSend.call(bridge, method, routedParameters, options2);
-    const unresolvedThreadId = shouldResolveThreadOwnership(method, routedParameters);
+    const sendBridged = () => initializeBridge().then(() => enqueueBridgeRequest(method, parameters, options2));
+    const sendDirect = () => options2 === void 0 ? originalSend.call(bridge, method, parameters) : originalSend.call(bridge, method, parameters, options2);
+    const unresolvedThreadId = shouldResolveThreadOwnership(method, parameters);
     if (unresolvedThreadId) {
       return resolveThreadOwnership(unresolvedThreadId).then((owner) => owner === "external" ? sendBridged() : sendDirect(), (error51) => {
         if ((method === "thread/read" || method === "thread/resume") && isUnsupportedPosixBridgeSpawn(error51)) {
@@ -22869,7 +23011,7 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
         throw error51;
       });
     }
-    return shouldUseBridge(method, routedParameters) ? sendBridged() : sendDirect();
+    return shouldUseBridge(method, parameters) ? sendBridged() : sendDirect();
   };
   const publishDraftWorkspace = (parameters) => {
     if (!isRecord19(parameters) || parameters.ephemeral === true)
@@ -22898,10 +23040,10 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
     for (const threadId2 of externalPrewarms)
       discardExternalPrewarm(threadId2);
   };
+  const restoreConsumption = isolateConsumption(manager, discardExternalPrewarm);
   const routedPrewarm = (parameters, options2) => {
-    const routed = routeThreadStart(parameters);
-    const external = isRecord19(routed) && routed.ephemeral !== true && typeof routed.model === "string" && routed.model.startsWith("codexhost/");
-    const routedParameters = external ? { ...routed, codexhostPrewarm: true } : routed;
+    const external = isRecord19(parameters) && parameters.ephemeral !== true && typeof parameters.model === "string" && parameters.model.startsWith("codexhost/");
+    const routedParameters = external ? { ...parameters, codexhostPrewarm: true } : parameters;
     const generation = prewarmGeneration;
     publishDraftWorkspace(routedParameters);
     const pending = shouldUseBridge("thread/start", routedParameters) ? routedSend("thread/start", routedParameters, options2) : options2 === void 0 ? originalPrewarm.call(bridge, routedParameters) : originalPrewarm.call(bridge, routedParameters, options2);
@@ -22957,6 +23099,7 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
   const policy = Object.freeze({
     state: "ready",
     hostId: hostId2,
+    scopedCreation: restoreConsumption !== null,
     owns(candidateManager, candidate, candidateHostId, candidatePrewarmedThreadManager, requiresCurrentManager) {
       return !disposed && candidateManager === manager && candidate === bridge && candidateHostId === hostId2 && candidatePrewarmedThreadManager === prewarmedThreadManager && requiresCurrentManager === !!isCurrentManager;
     },
@@ -22965,12 +23108,13 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
         throw new Error("Renderer request manager is retired");
       return manager;
     },
-    select(model2) {
+    select(model2, draftId, creationModes) {
       if (disposed || isCurrentManager && !isCurrentManager())
         throw new Error("Renderer request manager is retired");
       if (model2 !== null && (typeof model2 !== "string" || !model2.startsWith("codexhost/"))) {
         throw new Error("Draft route Model must be a codexhost transport carrier");
       }
+      restoreConsumption?.selectDraft(draftId, model2, creationModes);
       if (selectedModel === model2)
         return false;
       selectedModel = model2;
@@ -22993,6 +23137,7 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
       disposed = true;
       prewarmGeneration += 1;
       retireResponses();
+      restoreConsumption?.dispose();
       if (bridge.sendRequest === routedSend)
         bridge.sendRequest = originalSend;
       if (bridge.prewarmThreadStart === routedPrewarm) {
@@ -23252,12 +23397,14 @@ function directRendererInstaller() {
     const resolveRendererHostManager = ${resolveRendererHostManager.toString()};
     const retainRendererHostResponses = ${retainRendererHostResponses.toString()};
     const createDraftPrewarmPolicyBridge = ${createDraftPrewarmPolicyBridge.toString()};
+    const isolateRendererPrewarmConsumption = ${isolateRendererPrewarmConsumption.toString()};
     const routing = (${installRendererHostRouting.toString()})(
       document, window,
       (root) => discoverRendererHosts(root, committedReactAncestors, requestManagerFromHookState),
       (discovery, hostId) => resolveRendererHostManager(discovery, hostId, requestManagerFromHookState),
       (manager, bridge, hostId, target, prewarmed, isCurrent) => createDraftPrewarmPolicyBridge(
         manager, bridge, hostId, target, prewarmed, isCurrent, retainRendererHostResponses,
+        isolateRendererPrewarmConsumption,
       ),
     );
     // Publish a default draft policy only when its Host is unambiguous. Host
@@ -24474,9 +24621,9 @@ function parseModelPriceOverrides(value2) {
     if (key.length === 0 || !isRecord3(entry)) {
       throw new Error(`Price override '${key}' is invalid`);
     }
-    for (const field of Object.keys(entry)) {
-      if (!["input", "output", "cacheRead", "cacheWrite", "cacheWrite1h"].includes(field)) {
-        throw new Error(`Price override '${key}' contains unknown field '${field}'`);
+    for (const field2 of Object.keys(entry)) {
+      if (!["input", "output", "cacheRead", "cacheWrite", "cacheWrite1h"].includes(field2)) {
+        throw new Error(`Price override '${key}' contains unknown field '${field2}'`);
       }
     }
     const input = price(entry.input);
@@ -24485,11 +24632,11 @@ function parseModelPriceOverrides(value2) {
       throw new Error(`Price override '${key}' needs non-negative 'input' and 'output'`);
     }
     const resolved = { input, output };
-    for (const field of ["cacheRead", "cacheWrite", "cacheWrite1h"]) {
-      if (entry[field] === void 0) continue;
-      const candidate = price(entry[field]);
-      if (candidate === null) throw new Error(`Price override '${key}' has invalid '${field}'`);
-      resolved[field] = candidate;
+    for (const field2 of ["cacheRead", "cacheWrite", "cacheWrite1h"]) {
+      if (entry[field2] === void 0) continue;
+      const candidate = price(entry[field2]);
+      if (candidate === null) throw new Error(`Price override '${key}' has invalid '${field2}'`);
+      resolved[field2] = candidate;
     }
     overrides.set(key, resolved);
   }
@@ -25180,6 +25327,42 @@ function parseHarnessAccountCredits(value2) {
   return parsed2.success ? parsed2.data : null;
 }
 
+// packages/harness-adapter/dist/question.js
+function invalidRequest(message2) {
+  return { code: "invalidRequest", message: message2, retryable: false };
+}
+function validateHostQuestionResponse(interaction, response) {
+  const questionIds = new Set(interaction.questions.map(({ id: id2 }) => id2));
+  if (response.cancelled) {
+    return Object.keys(response.answers).length === 0 ? null : invalidRequest("Cancelled Question Response must not contain answers");
+  }
+  for (const answerId of Object.keys(response.answers)) {
+    if (!questionIds.has(answerId)) {
+      return invalidRequest("Question Response contains an unknown Question ID");
+    }
+  }
+  for (const question of interaction.questions) {
+    const answers = response.answers[question.id] ?? [];
+    if (!question.optional && answers.length === 0) {
+      return invalidRequest("Question Response omits a required answer");
+    }
+    if (question.type === "text") {
+      if (answers.length > 1) {
+        return invalidRequest("Text Question accepts at most one answer");
+      }
+      continue;
+    }
+    if (!question.multiple && answers.length > 1) {
+      return invalidRequest("Single-choice Question accepts at most one answer");
+    }
+    const declared = new Set(question.options.map(({ value: value2 }) => value2));
+    if (!question.allowOther && answers.some((answer) => !declared.has(answer))) {
+      return invalidRequest("Question Response contains an undeclared choice");
+    }
+  }
+  return null;
+}
+
 // packages/harness-adapter/dist/output-channel.js
 var HarnessOutputChannel = class {
   outputs;
@@ -25286,26 +25469,26 @@ function parseHostUsage(value2) {
     }
   }
   const indicators = value2.composerIndicators === void 0 ? {} : { composerIndicators: composerIndicatorsSchema.parse(value2.composerIndicators) };
-  for (const field of [
+  for (const field2 of [
     "totalCredits",
     "contextUsagePercent",
     "apiOutputTokensPerSecond"
   ]) {
-    const candidate = value2[field];
+    const candidate = value2[field2];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0)) {
-      throw new Error(`Harness Usage '${field}' must be a finite non-negative number`);
+      throw new Error(`Harness Usage '${field2}' must be a finite non-negative number`);
     }
   }
-  for (const field of tokenFields) {
-    const candidate = value2[field];
+  for (const field2 of tokenFields) {
+    const candidate = value2[field2];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
-      throw new Error(`Harness Usage '${field}' must be a non-negative safe integer`);
+      throw new Error(`Harness Usage '${field2}' must be a non-negative safe integer`);
     }
   }
-  for (const field of safeIntegerFields) {
-    const candidate = value2[field];
+  for (const field2 of safeIntegerFields) {
+    const candidate = value2[field2];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
-      throw new Error(`Harness Usage '${field}' must be a non-negative safe integer`);
+      throw new Error(`Harness Usage '${field2}' must be a non-negative safe integer`);
     }
   }
   if (value2.outputTokensPerSecond !== void 0 && (typeof value2.outputTokensPerSecond !== "number" || !Number.isFinite(value2.outputTokensPerSecond) || value2.outputTokensPerSecond < 0)) {
@@ -25314,10 +25497,10 @@ function parseHostUsage(value2) {
   if (value2.totalCostUsd !== void 0 && (typeof value2.totalCostUsd !== "number" || !Number.isFinite(value2.totalCostUsd) || value2.totalCostUsd < 0)) {
     throw new Error("Harness Usage 'totalCostUsd' must be a finite non-negative number");
   }
-  for (const field of percentFields) {
-    const candidate = value2[field];
+  for (const field2 of percentFields) {
+    const candidate = value2[field2];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0 || candidate > 100)) {
-      throw new Error(`Harness Usage '${field}' must be between 0 and 100`);
+      throw new Error(`Harness Usage '${field2}' must be between 0 and 100`);
     }
   }
   if (value2.sessionCacheUsage !== void 0) {
@@ -25388,19 +25571,19 @@ function parseHostUsageRequest(value2) {
   if (typeof value2.requestId !== "string" || value2.requestId.length === 0) {
     throw new Error("Harness Usage request 'requestId' must be a non-empty string");
   }
-  for (const field of ["model", "provider"]) {
-    const candidate = value2[field];
+  for (const field2 of ["model", "provider"]) {
+    const candidate = value2[field2];
     if (candidate !== void 0 && (typeof candidate !== "string" || candidate.length === 0)) {
-      throw new Error(`Harness Usage request '${field}' must be a non-empty string`);
+      throw new Error(`Harness Usage request '${field2}' must be a non-empty string`);
     }
   }
   if (value2.historical !== void 0 && typeof value2.historical !== "boolean") {
     throw new Error("Harness Usage request 'historical' must be a boolean");
   }
-  for (const field of requestTokenFields) {
-    const candidate = value2[field];
+  for (const field2 of requestTokenFields) {
+    const candidate = value2[field2];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
-      throw new Error(`Harness Usage request '${field}' must be a non-negative safe integer`);
+      throw new Error(`Harness Usage request '${field2}' must be a non-negative safe integer`);
     }
   }
   if (value2.inputTokens === void 0 || value2.outputTokens === void 0) {
@@ -25916,10 +26099,15 @@ function processIdentity(pid) {
     }
     const query = [
       "$ErrorActionPreference = 'Stop'",
-      `$process = Get-Process -Id ${pid}`,
-      "$process | Select-Object Path, StartTime | ConvertTo-Json -Compress"
+      `$process = Get-CimInstance -ClassName Win32_Process -Filter 'ProcessId = ${pid}'`,
+      "if ($null -ne $process) { [pscustomobject]@{ Path = $process.ExecutablePath; StartTime = $(if ($null -ne $process.CreationDate) { $process.CreationDate.ToUniversalTime().ToString('o', [Globalization.CultureInfo]::InvariantCulture) } else { $null }) } | ConvertTo-Json -Compress }"
     ].join("; ");
-    const result = execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", query], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], windowsHide: true }).trim();
+    const result = execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", query], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true,
+      timeout: 5e3
+    }).trim();
     if (!result)
       return { executablePath: null, startedAt: null };
     const parsed2 = JSON.parse(result);
@@ -26435,13 +26623,17 @@ var MappingStore = class {
     await this.#enqueue(() => this.#remove(hostThreadId));
   }
   async #remove(hostThreadId) {
-    if (!this.#records.has(hostThreadId))
+    const current = this.#records.get(hostThreadId);
+    if (!current)
       return;
-    await Promise.all([
-      rm10(this.#recordPath(hostThreadId), { force: true }),
-      rm10(this.#backupPath(hostThreadId), { force: true }),
-      rm10(this.#metadataPath(hostThreadId), { force: true })
-    ]);
+    await rm10(this.#recordPath(hostThreadId), { force: true });
+    try {
+      await rm10(this.#backupPath(hostThreadId), { force: true });
+      await rm10(this.#metadataPath(hostThreadId), { force: true });
+    } catch (error51) {
+      await this.#replaceFile(this.#recordPath(hostThreadId), current, false);
+      throw error51;
+    }
     this.#records.delete(hostThreadId);
     this.#rebuildIndexes();
   }
@@ -26790,17 +26982,17 @@ var ELLIPSIS = "…";
 function isRecord7(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
-function boundedText(value2, field, maxLength) {
+function boundedText(value2, field2, maxLength) {
   const text = value2.trim();
   if (text.length === 0 || text.length > maxLength) {
-    throw new Error(`Host Approval ${field} must contain 1 to ${maxLength} characters`);
+    throw new Error(`Host Approval ${field2} must contain 1 to ${maxLength} characters`);
   }
   return text;
 }
-function clampedText(value2, field, maxLength) {
+function clampedText(value2, field2, maxLength) {
   const text = value2.trim();
   if (text.length === 0) {
-    throw new Error(`Host Approval ${field} must contain at least 1 character`);
+    throw new Error(`Host Approval ${field2} must contain at least 1 character`);
   }
   const characters = [...text];
   if (characters.length <= maxLength)
@@ -28015,9 +28207,9 @@ function nestedString(value2, keys, preserveText = false) {
   if (!isRecord10(value2))
     return void 0;
   for (const key of keys) {
-    const field = value2[key];
-    if (typeof field === "string" && (preserveText || field.trim().length > 0))
-      return preserveText ? field : field.trim();
+    const field2 = value2[key];
+    if (typeof field2 === "string" && (preserveText || field2.trim().length > 0))
+      return preserveText ? field2 : field2.trim();
   }
   for (const wrapper of ["input", "arguments", "params"]) {
     const nested = nestedString(value2[wrapper], keys, preserveText);
@@ -31410,6 +31602,22 @@ var SessionImportRequests = class {
   }
 };
 
+// packages/host-runtime/src/shared-question.ts
+function usesSharedQuestionCard(interaction) {
+  return interaction.questions.some((question) => question.type === "choice" && question.multiple);
+}
+function sharedQuestion(interaction) {
+  return threadQuestionSchema.parse(interaction);
+}
+function validateSharedQuestionResponse(interaction, response) {
+  const error51 = validateHostQuestionResponse(interaction, response);
+  if (error51) throw new Error(error51.message);
+  for (const values of Object.values(response.answers)) {
+    if (new Set(values).size !== values.length) throw new Error("Duplicate Question answers");
+    if (values.some((value2) => !value2.trim())) throw new Error("Empty Question answer");
+  }
+}
+
 // packages/host-runtime/src/external-thread-history.ts
 var DEFAULT_PAGE_SIZE2 = 25;
 var MAX_PAGE_SIZE2 = 100;
@@ -32367,7 +32575,7 @@ var UsageMeter = class {
   derive(native, prices) {
     const usage = Object.fromEntries(
       Object.entries(native ?? {}).filter(
-        ([field]) => !hostDerivedUsageFields.includes(field)
+        ([field2]) => !hostDerivedUsageFields.includes(field2)
       )
     );
     const sessionCacheUsage = usage.sessionCacheUsage;
@@ -32589,6 +32797,19 @@ var ExternalThreadRuntime = class {
     this.#threads.delete(threadId2);
     this.#steeredTurnIds.delete(threadId2);
   }
+  /** Confirm release before forgetting either the Session owner or its persisted mapping. */
+  async deleteThread(hostThreadId) {
+    await this.#withLifecycle(hostThreadId, async () => {
+      const thread = this.#threads.get(hostThreadId);
+      if (thread) {
+        thread.sessionUnavailable = true;
+        thread.stateObserver.fault(new Error("External Thread is being deleted"));
+        await this.#lifecycle.release(hostThreadId, thread.session, thread.outputTask);
+      }
+      this.remove(hostThreadId);
+      await this.#repository.removeThread(hostThreadId);
+    });
+  }
   clear() {
     this.#threads.clear();
     this.#steeredTurnIds.clear();
@@ -34059,10 +34280,10 @@ var HarnessDelegationCoordinator = class {
         }
       };
     });
-    const [field, direction] = input.sort.split("-");
+    const [field2, direction] = input.sort.split("-");
     rows.sort((left, right) => {
-      const leftTimestamp = field === "created" ? left.createdAt : left.updatedAt;
-      const rightTimestamp = field === "created" ? right.createdAt : right.updatedAt;
+      const leftTimestamp = field2 === "created" ? left.createdAt : left.updatedAt;
+      const rightTimestamp = field2 === "created" ? right.createdAt : right.updatedAt;
       const leftTime = Date.parse(leftTimestamp ?? "");
       const rightTime = Date.parse(rightTimestamp ?? "");
       return direction === "asc" ? leftTime - rightTime : rightTime - leftTime;
@@ -37461,9 +37682,9 @@ var RequestRouteObservationTracker = class {
 };
 
 // packages/host-runtime/src/external-thread-list.ts
-function unixTimestamp(value2, field) {
+function unixTimestamp(value2, field2) {
   const parsed2 = Date.parse(value2);
-  if (!Number.isFinite(parsed2)) throw new Error(`External Thread ${field} is invalid`);
+  if (!Number.isFinite(parsed2)) throw new Error(`External Thread ${field2} is invalid`);
   return Math.floor(parsed2 / 1e3);
 }
 function threadId(thread) {
@@ -37473,11 +37694,11 @@ function threadId(thread) {
   return thread.id;
 }
 function threadListTimestamp(thread, sortKey) {
-  const field = sortKey === "created_at" ? thread.createdAt : sortKey === "updated_at" ? thread.updatedAt : thread.recencyAt ?? thread.updatedAt;
-  if (!Number.isSafeInteger(field)) {
+  const field2 = sortKey === "created_at" ? thread.createdAt : sortKey === "updated_at" ? thread.updatedAt : thread.recencyAt ?? thread.updatedAt;
+  if (!Number.isSafeInteger(field2)) {
     throw new Error(`Thread list row has no valid ${sortKey} timestamp`);
   }
-  return field;
+  return field2;
 }
 function compareTimestamp(left, right, direction) {
   if (left === right) return 0;
@@ -38534,16 +38755,7 @@ var AppServerHost = class {
       hasRunningDescendants: (threadId2) => this.#hasRunningSubagents(threadId2),
       idleRelease: {
         queue: this.#desktopRequests,
-        onClosed: async (thread) => {
-          for (const pending of [...this.#pendingDesktopApprovals.values()]) {
-            if (pending.thread === thread)
-              await this.#resolveDesktopApproval(pending.interaction.interactionId);
-          }
-          for (const pending of [...this.#pendingDesktopQuestions.values()]) {
-            if (pending.thread === thread)
-              await this.#resolveDesktopQuestion(pending.interaction.interactionId);
-          }
-        },
+        onClosed: (thread) => this.#resolveThreadInteractions(thread),
         canRelease: (thread) => !this.#hasRunningSubagents(thread.id) && !thread.session.hasBackgroundWork?.() && !this.#externalSteering.hasPending(thread.id) && !this.#pendingExternalCommandRequests.has(thread.id) && ![...this.#pendingDesktopApprovals.values()].some(
           (pending) => pending.thread === thread
         ) && ![...this.#pendingDesktopQuestions.values()].some((pending) => pending.thread === thread)
@@ -38733,12 +38945,12 @@ var AppServerHost = class {
       await this.#closeAdapters();
       await this.#externalRuntime.drain();
       for (const pending of [...this.#pendingDesktopApprovals.values()]) {
-        await this.#resolveDesktopApproval(pending.interaction.interactionId).catch(
+        await this.#resolveDesktopApproval(pending.interaction.interactionId, pending.thread).catch(
           () => void 0
         );
       }
       for (const pending of [...this.#pendingDesktopQuestions.values()]) {
-        await this.#resolveDesktopQuestion(pending.interaction.interactionId).catch(
+        await this.#resolveDesktopQuestion(pending.interaction.interactionId, pending.thread).catch(
           () => void 0
         );
       }
@@ -39298,6 +39510,15 @@ var AppServerHost = class {
       await this.#listThreadOwnership(request);
       return;
     }
+    if (request.method === THREAD_QUESTIONS_LIST_METHOD || request.method === THREAD_QUESTION_RESPOND_METHOD) {
+      const threadId2 = requestObject(request).threadId;
+      this.#dispatchDesktopReply(
+        request,
+        () => this.#handleSharedQuestionRequest(request),
+        request.method === THREAD_QUESTION_RESPOND_METHOD && typeof threadId2 === "string" ? threadId2 : void 0
+      );
+      return;
+    }
     if (request.method === "codexhost/thread/steering/inspect") {
       await this.#inspectThreadSteering(request);
       return;
@@ -41575,29 +41796,23 @@ var AppServerHost = class {
     });
   }
   async #deleteExternalThread(request, location) {
-    const thread = location.thread;
-    try {
-      await this.#repository.removeThread(location.record.hostThreadId);
-    } catch {
-      await this.#writer.json(rpcError(request, -32081, "External Thread could not be removed"));
-      return;
-    }
-    this.#externalRuntime.remove(location.record.hostThreadId);
-    this.#routeObservationTracker.forgetThread(location.record.hostThreadId);
-    if (!thread) {
-      await this.#writer.json(rpcEnvelope(request, { result: {} }));
-      return;
-    }
-    thread.stateObserver.fault(new Error("External Thread was deleted"));
     try {
-      await thread.session.close();
-      await thread.outputTask;
-      await this.#writer.json(rpcEnvelope(request, { result: {} }));
+      await this.#externalRuntime.deleteThread(location.record.hostThreadId);
     } catch (error51) {
+      if (!(error51 instanceof ExternalSessionReleaseError) && location.thread)
+        await this.#resolveThreadInteractions(location.thread);
       await this.#writer.json(
-        rpcError(request, -32075, `External Thread could not close: ${errorMessage4(error51)}`)
+        error51 instanceof ExternalSessionReleaseError ? rpcError(request, -32075, error51.message) : rpcError(request, -32081, "External Thread could not be removed")
       );
+      return;
     }
+    if (location.thread) await this.#resolveThreadInteractions(location.thread);
+    this.#routeObservationTracker.forgetThread(location.record.hostThreadId);
+    await this.#writer.json(rpcEnvelope(request, { result: {} }));
+    await this.#writer.json({
+      method: "thread/deleted",
+      params: { threadId: location.record.hostThreadId }
+    });
   }
   async #readExternalThreadMetadata(request, location) {
     try {
@@ -42226,6 +42441,10 @@ var AppServerHost = class {
       return;
     }
     if (event.type === "session.faulted") {
+      for (const pending of [...this.#pendingDesktopQuestions.values()]) {
+        if (pending.shared && pending.thread === thread)
+          this.#retireDesktopQuestion(pending.interaction.interactionId, thread);
+      }
       this.#externalSteering.fault(thread.id, new Error(event.error.message));
       thread.stateObserver.fault(new Error(event.error.message));
       this.#externalRuntime.markSessionUnavailable(thread);
@@ -42269,9 +42488,15 @@ var AppServerHost = class {
     if (event.type === "interaction.closed" && thread.ignoredInteractionIds.delete(event.interactionId)) {
       return;
     }
+    if (event.type === "turn.completed") {
+      for (const pending of [...this.#pendingDesktopQuestions.values()]) {
+        if (pending.shared && pending.thread === thread && pending.interaction.turnId === event.turnId)
+          this.#retireDesktopQuestion(pending.interaction.interactionId, thread);
+      }
+    }
     if (event.type === "interaction.closed") {
-      await this.#resolveDesktopApproval(event.interactionId);
-      await this.#resolveDesktopQuestion(event.interactionId);
+      await this.#resolveDesktopApproval(event.interactionId, thread);
+      await this.#resolveDesktopQuestion(event.interactionId, thread);
     }
     const ephemeralTurn = event.type === "turn.completed" && (event.ephemeral === true || thread.ephemeralTurnIds.has(event.turnId));
     if (event.type === "turn.completed" && !ephemeralTurn) {
@@ -42528,7 +42753,7 @@ var AppServerHost = class {
       if (this.#externalRuntime.get(pending.thread.id) !== pending.thread || this.#externalRuntime.idleRelease.failure(pending.thread))
         return true;
       if (this.#options.externalOnly)
-        await this.#resolveDesktopApproval(pending.interaction.interactionId);
+        await this.#resolveDesktopApproval(pending.interaction.interactionId, pending.thread);
       else this.#pendingDesktopApprovals.delete(requestId);
       let response;
       try {
@@ -42579,9 +42804,20 @@ var AppServerHost = class {
     }
     return denied.ok;
   }
-  async #resolveDesktopApproval(interactionId) {
+  async #resolveThreadInteractions(thread) {
+    for (const pending of [...this.#pendingDesktopApprovals.values()]) {
+      if (pending.thread === thread)
+        await this.#resolveDesktopApproval(pending.interaction.interactionId, thread);
+    }
+    for (const pending of [...this.#pendingDesktopQuestions.values()]) {
+      if (pending.thread === thread)
+        await this.#resolveDesktopQuestion(pending.interaction.interactionId, thread);
+    }
+  }
+  async #resolveDesktopApproval(interactionId, thread) {
     for (const [requestId, pending] of this.#pendingDesktopApprovals) {
-      if (pending.interaction.interactionId !== interactionId) continue;
+      if (pending.thread !== thread || pending.interaction.interactionId !== interactionId)
+        continue;
       this.#pendingDesktopApprovals.delete(requestId);
       await this.#writer.json({
         method: "serverRequest/resolved",
@@ -42597,11 +42833,72 @@ var AppServerHost = class {
     this.#nextApprovalRequestId -= 1;
     return requestId;
   }
+  async #handleSharedQuestionRequest(request) {
+    const responding = request.method === THREAD_QUESTION_RESPOND_METHOD;
+    const parsed2 = (responding ? threadQuestionRespondParamsSchema : threadQuestionsListParamsSchema).safeParse(request.params);
+    if (!parsed2.success) {
+      await this.#writer.json(rpcError(request, -32602, "Invalid Question params"));
+      return;
+    }
+    const { threadId: threadId2 } = parsed2.data;
+    const thread = this.#externalRuntime.get(threadId2);
+    const pendingQuestions = () => [...this.#pendingDesktopQuestions.values()].filter(
+      (pending) => pending.shared && pending.thread === thread && pending.interaction.turnId === thread?.activeTurnId && (!Number.isFinite(Date.parse(pending.interaction.expiresAt ?? "")) || Date.parse(pending.interaction.expiresAt ?? "") > Date.now())
+    );
+    if (!responding) {
+      const questions = thread && !thread.sessionUnavailable && !this.#externalRuntime.idleRelease.failure(thread) ? pendingQuestions().map((pending) => sharedQuestion(pending.interaction)) : [];
+      await this.#writer.json(
+        rpcEnvelope(request, { result: jsonValueSchema.parse({ questions }) })
+      );
+      return;
+    }
+    const params = threadQuestionRespondParamsSchema.parse(parsed2.data);
+    try {
+      await this.#externalRuntime.idleRelease.runOperation(threadId2, async () => {
+        const pending = pendingQuestions().find(
+          ({ interaction }) => interaction.interactionId === params.interactionId && interaction.turnId === params.turnId
+        );
+        if (!thread || this.#externalRuntime.get(threadId2) !== thread || thread.sessionUnavailable || this.#externalRuntime.idleRelease.failure(thread) || !pending || pending.responding) {
+          throw new Error("Question is no longer pending on this Thread and Turn");
+        }
+        const response = {
+          type: "question",
+          answers: params.answers,
+          cancelled: params.cancelled
+        };
+        validateSharedQuestionResponse(pending.interaction, response);
+        pending.responding = true;
+        let result;
+        try {
+          result = await thread.session.execute({
+            type: "interaction.respond",
+            interactionId: pending.interaction.interactionId,
+            response
+          });
+        } catch (error51) {
+          this.#retireDesktopQuestion(pending.interaction.interactionId, thread);
+          throw error51;
+        }
+        if (!result.ok) {
+          pending.responding = false;
+          if (result.error.code === "invalidState")
+            this.#retireDesktopQuestion(pending.interaction.interactionId, thread);
+          throw new Error(result.error.message);
+        }
+        this.#retireDesktopQuestion(pending.interaction.interactionId, thread);
+        await this.#writer.json(rpcEnvelope(request, { result: { accepted: true } }));
+      });
+    } catch (error51) {
+      await this.#writer.json(rpcError(request, -32602, errorMessage4(error51)));
+    }
+  }
   async #projectQuestion(thread, interaction) {
     const projection = this.#projectedTurn(thread, interaction.turnId);
     await this.#waitForTurnResponse(thread, interaction.turnId);
     let result;
+    const shared = usesSharedQuestionCard(interaction);
     try {
+      if (shared) sharedQuestion(interaction);
       result = projection.projector.projectQuestion(
         interaction,
         hostItemIdSchema.parse(randomUUID16())
@@ -42625,6 +42922,8 @@ var AppServerHost = class {
     const expiresAtMs = interaction.expiresAt ? Date.parse(interaction.expiresAt) : Number.NaN;
     const timeoutMs = Number.isFinite(expiresAtMs) ? Math.max(0, expiresAtMs - Date.now()) : null;
     const pending = {
+      shared,
+      responding: false,
       thread,
       interaction,
       projection: result.questionRequest,
@@ -42636,10 +42935,11 @@ var AppServerHost = class {
       }, timeoutMs);
     }
     this.#pendingDesktopQuestions.set(requestId, pending);
+    if (shared) return;
     try {
       await this.#writer.json({ id: requestId, ...result.questionRequest.request });
     } catch (error51) {
-      this.#retireDesktopQuestion(interaction.interactionId);
+      this.#retireDesktopQuestion(interaction.interactionId, thread);
       await thread.session.execute({
         type: "interaction.respond",
         interactionId: interaction.interactionId,
@@ -42652,12 +42952,12 @@ var AppServerHost = class {
     if (!isRecord18(value2) || !isHostQuestionRequestId(value2.id)) return false;
     const requestId = value2.id;
     const pending = this.#pendingDesktopQuestions.get(requestId);
-    if (!pending) return true;
+    if (!pending || pending.shared) return true;
     return this.#externalRuntime.idleRelease.runOperation(pending.thread.id, async () => {
       if (this.#externalRuntime.get(pending.thread.id) !== pending.thread || this.#externalRuntime.idleRelease.failure(pending.thread))
         return true;
       if (this.#options.externalOnly)
-        await this.#resolveDesktopQuestion(pending.interaction.interactionId);
+        await this.#resolveDesktopQuestion(pending.interaction.interactionId, pending.thread);
       else this.#pendingDesktopQuestions.delete(requestId);
       if (pending.timeout) clearTimeout(pending.timeout);
       let response;
@@ -42684,7 +42984,8 @@ var AppServerHost = class {
     await this.#externalRuntime.idleRelease.runOperation(pending.thread.id, async () => {
       if (this.#externalRuntime.get(pending.thread.id) !== pending.thread || this.#externalRuntime.idleRelease.failure(pending.thread))
         return;
-      await this.#resolveDesktopQuestion(pending.interaction.interactionId);
+      await this.#resolveDesktopQuestion(pending.interaction.interactionId, pending.thread);
+      if (pending.responding) return;
       const result = await pending.thread.session.execute({
         type: "interaction.respond",
         interactionId: pending.interaction.interactionId,
@@ -42695,18 +42996,21 @@ var AppServerHost = class {
       }
     });
   }
-  #retireDesktopQuestion(interactionId) {
+  #retireDesktopQuestion(interactionId, thread) {
     for (const [requestId, pending] of this.#pendingDesktopQuestions) {
-      if (pending.interaction.interactionId !== interactionId) continue;
+      if (pending.thread !== thread || pending.interaction.interactionId !== interactionId)
+        continue;
       if (pending.timeout) clearTimeout(pending.timeout);
       this.#pendingDesktopQuestions.delete(requestId);
     }
   }
-  async #resolveDesktopQuestion(interactionId) {
+  async #resolveDesktopQuestion(interactionId, thread) {
     for (const [requestId, pending] of this.#pendingDesktopQuestions) {
-      if (pending.interaction.interactionId !== interactionId) continue;
+      if (pending.thread !== thread || pending.interaction.interactionId !== interactionId)
+        continue;
       if (pending.timeout) clearTimeout(pending.timeout);
       this.#pendingDesktopQuestions.delete(requestId);
+      if (pending.shared) continue;
       await this.#writer.json({
         method: "serverRequest/resolved",
         params: { threadId: pending.thread.id, requestId }
@@ -44486,10 +44790,10 @@ var DelegationControlRegistry = class {
     );
   }
   #compareThreads(left, right, sort) {
-    const field = sort.startsWith("created") ? "createdAt" : "updatedAt";
+    const field2 = sort.startsWith("created") ? "createdAt" : "updatedAt";
     const direction = sort.endsWith("asc") ? 1 : -1;
-    const leftValue = left[field] ? Date.parse(left[field]) : 0;
-    const rightValue = right[field] ? Date.parse(right[field]) : 0;
+    const leftValue = left[field2] ? Date.parse(left[field2]) : 0;
+    const rightValue = right[field2] ? Date.parse(right[field2]) : 0;
     return (leftValue - rightValue) * direction || left.threadId.localeCompare(right.threadId);
   }
   async #matching(predicate) {
@@ -45714,7 +46018,7 @@ function createHostUpdateCoordinator(options2) {
                 onPrepared
               });
             }
-            if (platform !== "darwin") await manager.start(prepared2);
+            if (platform !== "darwin" && platform !== "win32") await manager.start(prepared2);
           } catch (error51) {
             await lock.release();
             rejectPrepared(error51);
@@ -45797,13 +46101,13 @@ function parseHarnessUsageEntry(value2) {
   }
   if (!tokenCount(entry.inputTokens) || !tokenCount(entry.outputTokens))
     return null;
-  for (const field of [
+  for (const field2 of [
     "cachedInputTokens",
     "cacheWriteInputTokens",
     "cacheWrite1hInputTokens",
     "reasoningOutputTokens"
   ]) {
-    if (entry[field] !== void 0 && !tokenCount(entry[field]))
+    if (entry[field2] !== void 0 && !tokenCount(entry[field2]))
       return null;
   }
   const cached2 = entry.cachedInputTokens ?? 0;
@@ -46016,6 +46320,8 @@ function emptyTotals() {
     cachedInputTokens: 0,
     cacheWriteInputTokens: 0,
     cacheKnownInputTokens: 0,
+    cacheHitCachedInputTokens: 0,
+    cacheHitInputTokens: 0,
     outputTokens: 0,
     reasoningOutputTokens: 0,
     costUsd: 0,
@@ -46032,6 +46338,10 @@ function addEntry(totals2, entry, cost) {
   totals2.inputTokens += entry.inputTokens;
   totals2.outputTokens += entry.outputTokens;
   totals2.reasoningOutputTokens += entry.reasoningOutputTokens ?? 0;
+  if (entry.cachedInputTokens !== void 0) {
+    totals2.cacheHitCachedInputTokens += entry.cachedInputTokens;
+    totals2.cacheHitInputTokens += entry.inputTokens;
+  }
   if (entry.cachedInputTokens !== void 0 && entry.cacheWriteInputTokens !== void 0) {
     totals2.cachedInputTokens += entry.cachedInputTokens;
     totals2.cacheWriteInputTokens += entry.cacheWriteInputTokens;
@@ -47744,6 +48054,7 @@ async function runRemoteHostCli(input) {
 var HARNESS_BROKER_PROTOCOL_VERSION = 1;
 var HARNESS_BROKER_MAX_FRAME_BYTES = 8 * 1024 * 1024;
 var HARNESS_BROKER_MAX_PENDING_REQUESTS = 32;
+var HARNESS_BROKER_SESSION_IMPORT_PAGE_SIZE = 100;
 var HARNESS_BROKER_IDLE_TIMEOUT_MS = 60 * 60 * 1e3;
 var HARNESS_BROKER_RETIRING_ERROR_CODE = "brokerRetiring";
 var harnessBrokerMethodSchema = external_exports.enum([
@@ -47751,6 +48062,8 @@ var harnessBrokerMethodSchema = external_exports.enum([
   "adapter.inspectAccount",
   "adapter.credits",
   "adapter.open",
+  "adapter.sessionImport.list",
+  "adapter.sessionImport.resolve",
   "adapter.subagent.readSnapshot",
   "session.readSnapshot",
   "session.readCapabilities",
@@ -47856,29 +48169,6 @@ function consumeBrokerFrames(socket, onFrame, onError) {
   });
 }
 
-// packages/harness-broker/dist/paths.js
-import os11 from "node:os";
-import path40 from "node:path";
-var HARNESS_BROKER_DESCRIPTOR_ENV = "CODEXHOST_CLAUDE_BROKER_DESCRIPTOR";
-var HARNESS_BROKER_DESCRIPTOR_FILE = "claude-code-broker-v1.json";
-var HARNESS_BROKER_SOCKET_FILE = "claude-code-broker-v1.sock";
-function defaultHarnessBrokerDirectory(environment = process.env) {
-  const home = environment.HOME || os11.homedir();
-  return path40.join(home, ".codexhost", "harness-broker");
-}
-function defaultHarnessBrokerDescriptorPath(environment = process.env, harnessId = "claude-code") {
-  harnessPluginIdSchema.parse(harnessId);
-  if (harnessId !== "claude-code")
-    return path40.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.json`);
-  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path40.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
-}
-function defaultHarnessBrokerSocketPath(environment = process.env, harnessId = "claude-code") {
-  harnessPluginIdSchema.parse(harnessId);
-  if (harnessId !== "claude-code")
-    return path40.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.sock`);
-  return path40.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_SOCKET_FILE);
-}
-
 // packages/harness-broker/dist/validation.js
 var cwdSchema = external_exports.string().min(1).max(16384);
 var brokerEnvironmentSchema = external_exports.object({
@@ -47929,7 +48219,31 @@ var brokerOpenInputSchema = external_exports.discriminatedUnion("kind", [
   forkSchema,
   rollbackSchema
 ]);
-var brokerInspectInputSchema = external_exports.object({ cwd: cwdSchema.optional(), refresh: external_exports.boolean().optional() }).strict();
+var brokerInspectInputSchema = external_exports.object({
+  cwd: cwdSchema.optional(),
+  refresh: external_exports.boolean().optional(),
+  purpose: external_exports.literal("availability").optional()
+}).strict();
+var brokerSessionImportListParamsSchema = external_exports.object({
+  offset: external_exports.number().int().nonnegative().safe(),
+  limit: external_exports.number().int().min(1).max(HARNESS_BROKER_SESSION_IMPORT_PAGE_SIZE)
+}).strict();
+var brokerSessionImportResolveParamsSchema = external_exports.object({ nativeSessionId: harnessSessionImportIdSchema }).strict();
+var brokerSessionImportPageSchema = external_exports.object({
+  candidates: external_exports.array(harnessSessionImportCandidateSchema).max(HARNESS_BROKER_SESSION_IMPORT_PAGE_SIZE),
+  total: external_exports.number().int().nonnegative().safe()
+}).strict();
+var brokerSessionImportSourceSchema = external_exports.object({
+  candidate: harnessSessionImportCandidateSchema,
+  nativeRef: nativeSessionRefSchema
+}).strict().superRefine((source, context) => {
+  if (source.nativeRef.nativeSessionId !== source.candidate.nativeSessionId) {
+    context.addIssue({
+      code: "custom",
+      message: "Session import source identity does not match"
+    });
+  }
+});
 var textInputSchema = external_exports.object({ type: external_exports.literal("text"), text: external_exports.string().max(4e6) }).strict();
 var turnStartSchema = external_exports.object({
   type: external_exports.literal("turn.start"),
@@ -48100,6 +48414,29 @@ var harnessOutputSchema = external_exports.custom((value2) => {
   return false;
 });
 
+// packages/harness-broker/dist/paths.js
+import os11 from "node:os";
+import path40 from "node:path";
+var HARNESS_BROKER_DESCRIPTOR_ENV = "CODEXHOST_CLAUDE_BROKER_DESCRIPTOR";
+var HARNESS_BROKER_DESCRIPTOR_FILE = "claude-code-broker-v1.json";
+var HARNESS_BROKER_SOCKET_FILE = "claude-code-broker-v1.sock";
+function defaultHarnessBrokerDirectory(environment = process.env) {
+  const home = environment.HOME || os11.homedir();
+  return path40.join(home, ".codexhost", "harness-broker");
+}
+function defaultHarnessBrokerDescriptorPath(environment = process.env, harnessId = "claude-code") {
+  harnessPluginIdSchema.parse(harnessId);
+  if (harnessId !== "claude-code")
+    return path40.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.json`);
+  return environment[HARNESS_BROKER_DESCRIPTOR_ENV] ?? path40.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_DESCRIPTOR_FILE);
+}
+function defaultHarnessBrokerSocketPath(environment = process.env, harnessId = "claude-code") {
+  harnessPluginIdSchema.parse(harnessId);
+  if (harnessId !== "claude-code")
+    return path40.join(defaultHarnessBrokerDirectory(environment), `${harnessId}-broker-v1.sock`);
+  return path40.join(defaultHarnessBrokerDirectory(environment), HARNESS_BROKER_SOCKET_FILE);
+}
+
 // packages/harness-broker/dist/server.js
 import { randomBytes as randomBytes5, randomUUID as randomUUID24 } from "node:crypto";
 import { chmod as chmod6, lstat as lstat10, mkdir as mkdir19, open as open11, readFile as readFile19, rename as rename16, rm as rm18 } from "node:fs/promises";
@@ -48470,11 +48807,74 @@ async function startHarnessBrokerServer(input) {
         const parsed2 = brokerInspectInputSchema.parse(request.params);
         const inspection = await input.adapter.inspect({
           ...parsed2.cwd ? { cwd: parsed2.cwd } : {},
-          ...parsed2.refresh !== void 0 ? { refresh: parsed2.refresh } : {}
+          ...parsed2.refresh !== void 0 ? { refresh: parsed2.refresh } : {},
+          ...parsed2.purpose !== void 0 ? { purpose: parsed2.purpose } : {}
         });
         retireWhenIdle = inspection.status !== "ready";
         return inspection;
       }
+      if (request.method === "adapter.sessionImport.list") {
+        const { limit, offset } = brokerSessionImportListParamsSchema.parse(request.params);
+        const capability = input.adapter.sessionImport;
+        if (!capability?.resolveCandidate) {
+          return {
+            ok: false,
+            error: {
+              code: "unsupported",
+              message: "Harness Session import is unavailable",
+              retryable: false
+            }
+          };
+        }
+        if (offset === 0) {
+          delete state.sessionImportCandidates;
+          const result = await capability.listCandidates();
+          if (!result.ok)
+            return result;
+          state.sessionImportCandidates = result.value.map((candidate) => harnessSessionImportCandidateSchema.parse(candidate));
+        }
+        const candidates = state.sessionImportCandidates;
+        if (!candidates) {
+          return {
+            ok: false,
+            error: {
+              code: "invalidState",
+              message: "Session import snapshot is unavailable; refresh the list",
+              retryable: true
+            }
+          };
+        }
+        const page = candidates.slice(offset, offset + limit);
+        const total = candidates.length;
+        if (offset + page.length >= total)
+          delete state.sessionImportCandidates;
+        return { ok: true, value: { candidates: page, total } };
+      }
+      if (request.method === "adapter.sessionImport.resolve") {
+        const { nativeSessionId } = brokerSessionImportResolveParamsSchema.parse(request.params);
+        const capability = input.adapter.sessionImport;
+        if (!capability?.resolveCandidate) {
+          return {
+            ok: false,
+            error: {
+              code: "unsupported",
+              message: "Harness Session import is unavailable",
+              retryable: false
+            }
+          };
+        }
+        const result = await capability.resolveCandidate(nativeSessionId);
+        if (!result.ok)
+          return result;
+        const source = brokerSessionImportSourceSchema.safeParse(result.value);
+        if (!source.success || source.data.nativeRef.harnessId !== input.adapter.harnessId || source.data.candidate.nativeSessionId !== nativeSessionId) {
+          return {
+            ok: false,
+            error: protocolError("Session import source identity does not match")
+          };
+        }
+        return { ok: true, value: source.data };
+      }
       if (request.method === "adapter.subagent.readSnapshot") {
         const subagents = input.adapter.subagents;
         if (!subagents)