@liberseek/boft-cli-win32-arm64 0.6.8 → 0.6.9

package/app/plugins/hermes/plugin.mjs

@@ -5,6 +5,9 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// dist/hermes-adapter.js
+import { createHash } from "node:crypto";
+
 // ../../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -14642,12 +14645,21 @@ var harnessAccountSnapshotSchema = external_exports.object({
   plan: external_exports.string().trim().min(1).max(128).optional(),
   credits: accountCreditsSnapshotSchema
 }).strict();
-var harnessAccountListParamsSchema = external_exports.object({}).strict();
+var harnessAccountIdentityShape = {
+  harnessId: harnessIdSchema,
+  harnessName: external_exports.string().trim().min(1).max(128)
+};
+var harnessAccountSourceSchema = external_exports.object(harnessAccountIdentityShape).strict();
+var harnessAccountSourceListParamsSchema = external_exports.object({}).strict();
+var harnessAccountSourceListResultSchema = external_exports.object({ sources: external_exports.array(harnessAccountSourceSchema).max(128) }).strict();
+var harnessAccountInspectParamsSchema = external_exports.object({ harnessId: harnessIdSchema, refresh: external_exports.boolean().optional() }).strict();
+var harnessAccountInspectResultSchema = external_exports.object({
+  ...harnessAccountIdentityShape,
+  account: harnessAccountSnapshotSchema.nullable()
+}).strict();
+var harnessAccountListParamsSchema = external_exports.object({ refresh: external_exports.boolean().optional() }).strict();
 var harnessAccountListResultSchema = external_exports.object({
-  accounts: external_exports.array(harnessAccountSnapshotSchema.extend({
-    harnessId: harnessIdSchema,
-    harnessName: external_exports.string().min(1)
-  })).max(128)
+  accounts: external_exports.array(harnessAccountSnapshotSchema.extend(harnessAccountIdentityShape)).max(128)
 }).strict();
 
 // ../../shared-contracts/dist/json-value.js
@@ -14943,7 +14955,6 @@ var threadInspectionParamsSchema = external_exports.object({
 }).strict();
 var codexThreadInspectionSchema = external_exports.object({
   owner: external_exports.literal("codex"),
-  accountId: nonBlankTextSchema2.optional(),
   locked: external_exports.literal(true)
 }).strict();
 var externalThreadInspectionSchema = external_exports.object({
@@ -15085,53 +15096,25 @@ var codexAccountSchema = external_exports.object({
   label: nonBlankTextSchema3.max(256),
   email: external_exports.string().email().max(320).optional(),
   planType: codexAccountPlanTypeSchema.optional(),
-  codexHome: nonBlankTextSchema3.max(16384),
-  active: external_exports.boolean(),
-  isDefault: external_exports.boolean(),
   authKind: codexAccountAuthKindSchema.optional(),
   authIdentity: nonBlankTextSchema3.max(256).optional()
 }).strict();
-var codexAccountListResultSchema = external_exports.object({ accounts: external_exports.array(codexAccountSchema).max(128) }).strict();
-var codexAccountCreateParamsSchema = external_exports.object({ label: nonBlankTextSchema3.max(256).optional() }).strict();
-var codexAccountActivateParamsSchema = external_exports.object({ accountId: accountIdSchema }).strict();
-var codexAccountDeleteParamsSchema = external_exports.object({ accountId: accountIdSchema }).strict();
-var codexAccountDeleteResultSchema = external_exports.object({ deletedAccountId: accountIdSchema }).strict();
-var codexAccountMutationResultSchema = external_exports.object({ account: codexAccountSchema }).strict();
-var codexAccountLoginStartParamsSchema = external_exports.object({ accountId: accountIdSchema }).strict();
-var codexAccountLoginStartResultSchema = external_exports.object({
-  accountId: accountIdSchema,
-  loginId: nonBlankTextSchema3.max(1024),
-  verificationUrl: external_exports.string().url().max(16384),
-  userCode: nonBlankTextSchema3.max(1024)
+var codexAccountPhaseSchema = external_exports.enum(["ready", "unavailable"]);
+var codexAccountListResultSchema = external_exports.object({
+  version: external_exports.literal(2),
+  currentAccountId: accountIdSchema.nullable(),
+  phase: codexAccountPhaseSchema,
+  revision: external_exports.number().int().nonnegative(),
+  instanceId: nonBlankTextSchema3.max(1024).optional(),
+  accounts: external_exports.array(codexAccountSchema).max(1)
 }).strict();
-var codexAccountLoginCancelParamsSchema = external_exports.object({ accountId: accountIdSchema.optional(), loginId: nonBlankTextSchema3.max(1024) }).strict();
-var codexAccountLoginCancelResultSchema = external_exports.object({ cancelled: external_exports.boolean() }).strict();
-var codexAccountLoginCompletedSchema = external_exports.object({
-  accountId: accountIdSchema,
-  loginId: nonBlankTextSchema3.max(1024),
-  success: external_exports.boolean(),
-  error: external_exports.string().max(4096).nullable()
-}).strict();
-var codexAccountUsageParamsSchema = external_exports.object({ accountId: accountIdSchema }).strict();
+var codexAccountUsageParamsSchema = external_exports.object({ accountId: accountIdSchema, refresh: external_exports.boolean().optional() }).strict();
 var codexAccountUsageResultSchema = external_exports.object({
   accountId: accountIdSchema,
   usage: threadUsageSnapshotSchema.nullable(),
-  accountCredits: accountCreditsSnapshotSchema.optional()
-}).strict();
-var codexAccountResetCreditConsumeParamsSchema = external_exports.object({
-  accountId: accountIdSchema,
-  idempotencyKey: external_exports.string().uuid().optional()
-}).strict();
-var codexAccountResetCreditConsumeOutcomeSchema = external_exports.enum([
-  "reset",
-  "nothingToReset",
-  "noCredit",
-  "alreadyRedeemed"
-]);
-var codexAccountResetCreditConsumeResultSchema = external_exports.object({
-  accountId: accountIdSchema,
-  outcome: codexAccountResetCreditConsumeOutcomeSchema,
-  accountCredits: accountCreditsSnapshotSchema.optional()
+  accountCredits: accountCreditsSnapshotSchema.optional(),
+  freshness: external_exports.enum(["live", "cached"]),
+  observedAt: external_exports.string().datetime().nullable()
 }).strict();
 
 // ../../shared-contracts/dist/harness-session-import.js
@@ -20061,6 +20044,19 @@ var HermesAcpTransport = class {
   get stderrTail() {
     return this.#stderrTail;
   }
+  /**
+   * Point subsequent session creation at a different working directory.
+   * The spawn cwd is process-launch state and cannot change after the fact,
+   * but Hermes derives all session cwd behavior from the session/new
+   * parameter (agent.session_cwd, task env overrides, turn-time session
+   * vars), never from the process cwd — so a warm transport spawned in one
+   * directory can safely host a Session for another.
+   */
+  retarget(cwd) {
+    if (this.#sessionId)
+      throw new Error("Hermes ACP Transport cannot retarget an open Session");
+    this.#options = { ...this.#options, cwd };
+  }
   async inspect() {
     if (this.#sessionId)
       throw new Error("Hermes ACP inspection cannot reuse an open Session");
@@ -20345,6 +20341,9 @@ function decodeHermesModelRefId(modelRefId) {
     return null;
   }
 }
+function catalogAlignedModelLabel(name) {
+  return name.replace(/\s+·\s+/g, " / ");
+}
 function projectHermesModelState(models) {
   if (!models || models.availableModels.length === 0) {
     return { effectiveModel: null, resolvedModelLabel: null };
@@ -20354,12 +20353,13 @@ function projectHermesModelState(models) {
     return { effectiveModel: null, resolvedModelLabel: null };
   return {
     effectiveModel: encodeHermesModelRef(current.modelId),
-    resolvedModelLabel: current.name
+    resolvedModelLabel: catalogAlignedModelLabel(current.name)
   };
 }
 
 // dist/hermes-inventory.js
-var VENV_PYTHON_SHIM_PATTERN = /exec\s+"([^"]+?venv\/bin\/python)"/;
+var POSIX_VENV_PYTHON_SHIM_PATTERN = /exec\s+"([^"]+?venv\/bin\/python)"/;
+var WINDOWS_VENV_HERMES_SHIM_PATTERN = /"([^"]+?[\\/]venv[\\/]Scripts[\\/]hermes\.exe)"/i;
 var INVENTORY_PROBE_SCRIPT = `
 import json
 from hermes_cli.inventory import build_models_payload, load_picker_context
@@ -20430,11 +20430,14 @@ print(json.dumps({"models": rows, "currentModelId": current_model_id}))
 `;
 var HermesInventoryError = class extends Error {
 };
-async function venvPythonFromShim(hermesExecutable) {
+async function venvPythonFromShim(hermesExecutable, platform = process.platform) {
   try {
     const shim = await readFile(hermesExecutable, "utf8");
-    const match = VENV_PYTHON_SHIM_PATTERN.exec(shim);
-    return match?.[1] ?? null;
+    if (platform === "win32") {
+      const target = WINDOWS_VENV_HERMES_SHIM_PATTERN.exec(shim)?.[1];
+      return target ? path4.win32.join(path4.win32.dirname(target), "python.exe") : null;
+    }
+    return POSIX_VENV_PYTHON_SHIM_PATTERN.exec(shim)?.[1] ?? null;
   } catch {
     return null;
   }
@@ -20447,15 +20450,17 @@ function inventoryPythonCandidates(hermesExecutable, platform = process.platform
   if (environmentDirectory === "scripts") {
     candidates.push(pathApi.join(executableDirectory, "python.exe"));
   } else if (environmentDirectory === "bin") {
-    candidates.push(pathApi.join(executableDirectory, "python"));
+    candidates.push(pathApi.join(executableDirectory, platform === "win32" ? "python.exe" : "python"));
   }
-  const agentDir = pathApi.resolve(executableDirectory, "../../.hermes/hermes-agent");
-  candidates.push(pathApi.join(agentDir, platform === "win32" ? "venv/Scripts/python.exe" : "venv/bin/python"));
+  const relativePython = platform === "win32" ? "venv/Scripts/python.exe" : "venv/bin/python";
+  candidates.push(pathApi.resolve(executableDirectory, "../hermes-agent", relativePython));
+  candidates.push(pathApi.resolve(executableDirectory, "../../.hermes/hermes-agent", relativePython));
   return [...new Set(candidates)];
 }
 function runProbe(pythonExecutable, timeoutMs, environment) {
   return new Promise((resolve, reject) => {
-    const child = spawn2(pythonExecutable, ["-c", INVENTORY_PROBE_SCRIPT], {
+    const child = spawn2(pythonExecutable, ["-I", "-c", INVENTORY_PROBE_SCRIPT], {
+      cwd: path4.dirname(pythonExecutable),
       env: { ...process.env, ...environment },
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -20495,11 +20500,12 @@ function runProbe(pythonExecutable, timeoutMs, environment) {
   });
 }
 async function readHermesModelInventory(hermesExecutable, timeoutMs = 2e4, options = {}) {
+  const platform = options.platform ?? process.platform;
   const candidates = [
-    ...options.platform === "win32" ? [] : [await venvPythonFromShim(hermesExecutable) ?? ""],
-    ...inventoryPythonCandidates(hermesExecutable, options.platform)
+    await venvPythonFromShim(hermesExecutable, platform) ?? "",
+    ...inventoryPythonCandidates(hermesExecutable, platform)
   ].filter((candidate, index, all) => candidate.length > 0 && all.indexOf(candidate) === index);
-  let pythonExecutable = candidates[0];
+  let pythonExecutable = null;
   for (const candidate of candidates) {
     try {
       await access(candidate);
@@ -20508,8 +20514,9 @@ async function readHermesModelInventory(hermesExecutable, timeoutMs = 2e4, optio
     } catch {
     }
   }
-  if (!pythonExecutable)
-    throw new HermesInventoryError("Hermes inventory interpreter not found");
+  if (!pythonExecutable) {
+    throw new HermesInventoryError(`Hermes inventory interpreter not found (searched: ${candidates.join(", ")})`);
+  }
   return runProbe(pythonExecutable, timeoutMs, options.environment);
 }
 function catalogModelsFromInventory(inventory) {
@@ -20659,6 +20666,7 @@ var ActiveTurn = class {
   #currentText = null;
   #toolItems = /* @__PURE__ */ new Map();
   #finishedItems = [];
+  #emittedTerminalItemIds = /* @__PURE__ */ new Set();
   constructor(turnId, turnKey, input) {
     this.turnId = hostTurnIdSchema.parse(turnId);
     this.turnKey = turnKey;
@@ -20681,23 +20689,42 @@ var ActiveTurn = class {
     this.#currentText = { kind, item: appended };
     return { startedItem: item, item: appended };
   }
+  completeCurrentText() {
+    if (!this.#currentText)
+      return null;
+    const snapshot = {
+      item: this.#currentText.item,
+      outcome: { status: "succeeded" }
+    };
+    this.#currentText = null;
+    this.#finishedItems.push(snapshot);
+    this.#emittedTerminalItemIds.add(snapshot.item.itemId);
+    return snapshot;
+  }
   addToolItem(toolCallId, entry) {
     this.#toolItems.set(toolCallId, entry);
   }
   getToolItem(toolCallId) {
     return this.#toolItems.get(toolCallId);
   }
+  updateToolOutput(toolCallId, output) {
+    const entry = this.#toolItems.get(toolCallId);
+    if (entry)
+      entry.output = output;
+  }
   completeToolItem(toolCallId, output, failed) {
     const entry = this.#toolItems.get(toolCallId);
     if (!entry)
       return null;
     this.#toolItems.delete(toolCallId);
     const outcome = failed ? { status: "failed", error: harnessError("nativeFailure", "Tool execution failed") } : { status: "succeeded" };
+    const finalOutput = output ?? entry.output;
     const snapshot = {
-      item: { ...entry.item, ...output ? { output } : {} },
+      item: { ...entry.item, ...finalOutput ? { output: finalOutput } : {} },
       outcome
     };
     this.#finishedItems.push(snapshot);
+    this.#emittedTerminalItemIds.add(snapshot.item.itemId);
     return snapshot;
   }
   finish() {
@@ -20710,14 +20737,17 @@ var ActiveTurn = class {
     }
     for (const [, entry] of this.#toolItems) {
       this.#finishedItems.push({
-        item: entry.item,
+        item: { ...entry.item, ...entry.output ? { output: entry.output } : {} },
         outcome: { status: "cancelled", reason: "Turn ended" }
       });
     }
     this.#toolItems.clear();
   }
   drainPendingItems() {
-    return this.#finishedItems.splice(0);
+    const pending = this.#finishedItems.filter((snapshot) => !this.#emittedTerminalItemIds.has(snapshot.item.itemId));
+    this.#finishedItems = [];
+    this.#emittedTerminalItemIds.clear();
+    return pending;
   }
   toSnapshot(nativeTurnRef, outcome, includeItems) {
     return {
@@ -20749,6 +20779,7 @@ function toolOutputFromUpdate(update) {
 function historyTurnsFromReplay(replay, nativeRef, knownTurnRefs = []) {
   const turns = [];
   let current = null;
+  let toolItemIndexes = /* @__PURE__ */ new Map();
   const closeTurn = () => {
     if (!current || current.items.length === 0) {
       current = null;
@@ -20765,9 +20796,13 @@ function historyTurnsFromReplay(replay, nativeRef, knownTurnRefs = []) {
       nativeTurnRef,
       input: [{ type: "text", text: current.inputText }],
       items: current.items,
-      outcome: { status: "succeeded" }
+      outcome: {
+        status: "unknown",
+        reason: "Hermes replay does not include terminal Turn outcome metadata"
+      }
     });
     current = null;
+    toolItemIndexes = /* @__PURE__ */ new Map();
   };
   const pushText = (kind, text) => {
     if (!current)
@@ -20789,8 +20824,12 @@ function historyTurnsFromReplay(replay, nativeRef, knownTurnRefs = []) {
   for (const event of replay) {
     switch (event.type) {
       case "user.text": {
-        closeTurn();
-        current = { inputText: event.text, items: [], turnKey: `history-${turns.length + 1}` };
+        if (current && current.items.length === 0) {
+          current.inputText += event.text;
+        } else {
+          closeTurn();
+          current = { inputText: event.text, items: [], turnKey: `history-${turns.length + 1}` };
+        }
         break;
       }
       case "agent.thought":
@@ -20803,16 +20842,42 @@ function historyTurnsFromReplay(replay, nativeRef, knownTurnRefs = []) {
         if (!current)
           current = { inputText: "(resumed)", items: [], turnKey: `history-${turns.length + 1}` };
         const update = event.update;
+        const output = toolOutputFromUpdate(update);
         const toolName = typeof update.title === "string" && update.title.trim() || typeof update.name === "string" && update.name.trim() || event.toolCallId;
         current.items.push({
           item: {
             type: "toolExecution",
             itemId: hostItemIdSchema.parse(randomUUID()),
             toolName,
-            arguments: isPlainObjectOrArray(update.rawInput) ? update.rawInput : null
+            arguments: isPlainObjectOrArray(update.rawInput) ? update.rawInput : null,
+            ...output ? { output } : {}
           },
-          outcome: { status: "succeeded" }
+          outcome: update.status === "completed" ? { status: "succeeded" } : update.status === "failed" ? {
+            status: "failed",
+            error: harnessError("nativeFailure", "Tool execution failed")
+          } : { status: "cancelled", reason: "Turn ended before terminal tool update" }
         });
+        toolItemIndexes.set(event.toolCallId, current.items.length - 1);
+        break;
+      }
+      case "tool.update": {
+        if (!current)
+          break;
+        const itemIndex = toolItemIndexes.get(event.toolCallId);
+        if (itemIndex === void 0)
+          break;
+        const prior = current.items[itemIndex];
+        if (!prior || prior.item.type !== "toolExecution")
+          break;
+        const update = event.update;
+        const output = toolOutputFromUpdate(update);
+        current.items[itemIndex] = {
+          item: { ...prior.item, ...output ? { output } : {} },
+          outcome: update.status === "completed" ? { status: "succeeded" } : update.status === "failed" ? {
+            status: "failed",
+            error: harnessError("nativeFailure", "Tool execution failed")
+          } : prior.outcome
+        };
         break;
       }
       default:
@@ -20858,10 +20923,12 @@ var HermesSession = class {
   #state;
   #faulted = null;
   #closed = false;
+  #availableModels = [];
   #activeTurn = null;
   #activeTurnId = null;
   #completedTurns = [];
   #historyTurns;
+  #latestUsage;
   #approvalWaiters = /* @__PURE__ */ new Map();
   constructor(options) {
     this.#transport = options.transport;
@@ -20869,6 +20936,7 @@ var HermesSession = class {
     this.#onSettle = options.onSettle;
     const projected = projectHermesModelState(options.open.session.models);
     const modes = options.open.session.modes;
+    this.#availableModels = options.open.session.models?.availableModels ?? [];
     this.#state = {
       nativeRef: this.#nativeRef,
       ...projected.effectiveModel ? { effectiveModel: projected.effectiveModel } : {},
@@ -20878,6 +20946,7 @@ var HermesSession = class {
     this.initialState = { ...this.#state };
     this.#historyTurns = historyTurnsFromReplay(options.open.replay, this.#nativeRef, options.knownTurnRefs);
     this.initialUsage = lastUsageFromReplay(options.open.replay);
+    this.#latestUsage = this.initialUsage;
     this.outputs = this.#channel.outputs;
     this.#transport.onFault = (error51) => this.#fault(transportErrorToHarness(error51));
   }
@@ -20924,8 +20993,14 @@ var HermesSession = class {
     this.#onSettle(this);
   }
   #cancelApprovalWaiters() {
-    for (const waiter of this.#approvalWaiters.values()) {
+    for (const [interactionId, waiter] of this.#approvalWaiters) {
       waiter.resolve({ outcome: { outcome: "cancelled" } });
+      this.#emit({
+        type: "interaction.closed",
+        interactionId,
+        turnId: waiter.turnId,
+        reason: "cancelled"
+      });
     }
     this.#approvalWaiters.clear();
   }
@@ -20934,8 +21009,9 @@ var HermesSession = class {
       return;
     this.#faulted = error51;
     this.#cancelApprovalWaiters();
-    this.#activeTurn = null;
-    this.#activeTurnId = null;
+    if (this.#activeTurn) {
+      this.#completeActiveTurn(this.#activeTurn, { status: "failed", error: error51 });
+    }
     this.#emit({ type: "session.faulted", error: error51 });
     this.#channel.end();
     this.#onSettle(this);
@@ -20950,8 +21026,8 @@ var HermesSession = class {
     if (this.#activeTurn) {
       return err("sessionBusy", "Hermes Session already has an active Turn", true);
     }
-    const text = command.input.filter((chunk) => chunk.type === "text").map((chunk) => chunk.text).join("\n").trim();
-    if (text.length === 0) {
+    const text = command.input.flatMap((chunk) => chunk.type === "text" ? [chunk.text] : []).join("\n");
+    if (text.trim().length === 0) {
       return err("invalidRequest", "turn.start requires non-empty text input");
     }
     const turnKey = randomUUID();
@@ -20973,9 +21049,6 @@ var HermesSession = class {
     if (this.#activeTurn !== active) {
       return;
     }
-    this.#activeTurn = null;
-    this.#activeTurnId = null;
-    active.finish();
     let outcome;
     if (failure2) {
       outcome = { status: "failed", error: failure2 };
@@ -20989,6 +21062,16 @@ var HermesSession = class {
     } else {
       outcome = { status: "succeeded" };
     }
+    const terminalUsage = promptResponse ? usageFromPromptResponse(promptResponse.usage) : null;
+    const usage = terminalUsage ? this.#mergeUsage(terminalUsage) : null;
+    this.#completeActiveTurn(active, outcome, usage);
+  }
+  #completeActiveTurn(active, outcome, usage = null) {
+    if (this.#activeTurn !== active)
+      return;
+    this.#activeTurn = null;
+    this.#activeTurnId = null;
+    active.finish();
     const nativeTurnRef = nativeTurnRefSchema.parse({
       harnessId: this.#nativeRef.harnessId,
       nativeSessionId: this.#nativeRef.nativeSessionId,
@@ -20999,7 +21082,6 @@ var HermesSession = class {
     for (const pending of active.drainPendingItems()) {
       this.#emit({ type: "item.completed", turnId: active.turnId, snapshot: pending });
     }
-    const usage = promptResponse ? usageFromPromptResponse(promptResponse.usage) : null;
     if (usage) {
       this.#emit({ type: "session.usage.changed", usage, observedForTurnId: active.turnId });
     }
@@ -21012,9 +21094,10 @@ var HermesSession = class {
         const usage = usageFromContext(event.used, event.size);
         if (!usage)
           return;
+        const mergedUsage = this.#mergeUsage(usage);
         this.#emit({
           type: "session.usage.changed",
-          usage,
+          usage: mergedUsage,
           observedForTurnId: active.turnId
         });
         return;
@@ -21028,6 +21111,7 @@ var HermesSession = class {
       case "tool.call": {
         const update = event.update;
         this.#startToolItem(active, event.toolCallId, typeof update.title === "string" ? update.title : null, typeof update.name === "string" ? update.name : null, update.rawInput);
+        this.#updateToolItem(active, update);
         return;
       }
       case "tool.update":
@@ -21052,6 +21136,10 @@ var HermesSession = class {
     });
   }
   #startToolItem(active, toolCallId, title, name, rawInput) {
+    const completedText = active.completeCurrentText();
+    if (completedText) {
+      this.#emit({ type: "item.completed", turnId: active.turnId, snapshot: completedText });
+    }
     const item = {
       type: "toolExecution",
       itemId: hostItemIdSchema.parse(randomUUID()),
@@ -21061,12 +21149,18 @@ var HermesSession = class {
     active.addToolItem(toolCallId, { item, startedAt: Date.now() });
     this.#emit({ type: "item.started", turnId: active.turnId, item });
   }
+  #mergeUsage(usage) {
+    const merged = { ...this.#latestUsage ?? {}, ...usage };
+    this.#latestUsage = merged;
+    return merged;
+  }
   #updateToolItem(active, update) {
     const entry = active.getToolItem(update.toolCallId);
     if (!entry)
       return;
     const output = toolOutputFromUpdate(update);
     if (output && output.content.length > 0) {
+      active.updateToolOutput(update.toolCallId, output);
       this.#emit({
         type: "item.updated",
         turnId: active.turnId,
@@ -21178,10 +21272,14 @@ var HermesSession = class {
       }
       return err("nativeFailure", error51 instanceof Error ? error51.message : "Hermes rejected Model selection");
     }
+    const projectedAfterSelect = projectHermesModelState({
+      availableModels: this.#availableModels,
+      currentModelId: native
+    });
     this.#state = {
       ...this.#state,
       effectiveModel: command.model,
-      resolvedModelLabel: native
+      resolvedModelLabel: projectedAfterSelect.resolvedModelLabel ?? catalogAlignedModelLabel(native)
     };
     this.#emit({ type: "session.state.changed", state: { ...this.#state } });
     return ok({ completed: true });
@@ -21213,6 +21311,7 @@ var HermesSession = class {
 // dist/hermes-adapter.js
 var hermesHarnessId = harnessIdSchema.parse("hermes");
 var IMPORT_TIMEOUT_MS = 2e4;
+var HERMES_THREAD_ID_ENV = "CODEXHOST_THREAD_ID";
 var HermesAdapter = class {
   harnessId = hermesHarnessId;
   sessionImport = {
@@ -21223,6 +21322,7 @@ var HermesAdapter = class {
   #inspectionCache = null;
   #inspectionCacheScope = null;
   #sessions = /* @__PURE__ */ new Set();
+  #warmTransports = /* @__PURE__ */ new Map();
   #transports = /* @__PURE__ */ new Set();
   #closed = false;
   constructor(options = {}) {
@@ -21233,7 +21333,9 @@ var HermesAdapter = class {
     if (!input.refresh && this.#inspectionCache && this.#inspectionCacheScope === cwd) {
       return this.#inspectionCache;
     }
-    const transport = this.#createTransport(cwd);
+    const environment = this.#effectiveEnvironment();
+    const transport = await this.#takeTransport(cwd, environment);
+    let retainedForOpen = false;
     try {
       await transport.inspect();
       const inventory = await this.#readInventory();
@@ -21265,11 +21367,14 @@ var HermesAdapter = class {
       };
       this.#inspectionCache = inspection;
       this.#inspectionCacheScope = cwd;
+      this.#keepWarmTransport(cwd, environment, transport);
+      retainedForOpen = true;
       return inspection;
     } catch (error51) {
       return inspectionFromTransportError(error51);
     } finally {
-      await this.#releaseTransport(transport);
+      if (!retainedForOpen)
+        await this.#releaseTransport(transport);
     }
   }
   async #readInventory() {
@@ -21290,9 +21395,18 @@ var HermesAdapter = class {
       return failure("invalidRequest", "open requires a cwd");
     }
     let transportOpen;
+    let permissionModeId;
     if (input.kind === "create") {
       transportOpen = { kind: "create" };
+      permissionModeId = input.permissionModeId;
+      if (input.executionPolicy === "unattended-full-access") {
+        if (permissionModeId && permissionModeId !== HERMES_MODE_DONT_ASK) {
+          return failure("invalidRequest", "unattended-full-access requires the Hermes dont_ask Permission Mode");
+        }
+        permissionModeId = harnessPermissionModeIdSchema.parse(HERMES_MODE_DONT_ASK);
+      }
     } else if (input.kind === "resume") {
+      permissionModeId = input.permissionModeId;
       if (!input.nativeRef || input.nativeRef.harnessId !== this.harnessId) {
         return failure("invalidRequest", "Native Ref does not belong to Hermes");
       }
@@ -21300,7 +21414,11 @@ var HermesAdapter = class {
     } else {
       return failure("unsupported", `Hermes does not support ${input.kind}`);
     }
-    const transport = this.#createTransport(cwd);
+    if (permissionModeId && !isHermesModeId(permissionModeId)) {
+      return failure("invalidRequest", "Permission Mode does not belong to Hermes");
+    }
+    const environment = this.#effectiveEnvironment(input.environment);
+    const transport = await this.#takeTransport(cwd, environment);
     if (this.#closed) {
       await this.#releaseTransport(transport);
       return failure("invalidState", "Hermes Adapter is closed");
@@ -21330,16 +21448,12 @@ var HermesAdapter = class {
           currentModelId: nativeModelId
         };
       }
-      if (input.permissionModeId) {
-        if (!isHermesModeId(input.permissionModeId)) {
-          await this.#releaseTransport(transport);
-          return failure("invalidRequest", "Permission Mode does not belong to Hermes");
-        }
-        if (open.session.modes?.currentModeId !== input.permissionModeId) {
-          await transport.setPermissionMode(input.permissionModeId);
+      if (permissionModeId) {
+        if (open.session.modes?.currentModeId !== permissionModeId) {
+          await transport.setPermissionMode(permissionModeId);
         }
         open.session.modes = {
-          currentModeId: input.permissionModeId,
+          currentModeId: permissionModeId,
           availableModes: open.session.modes?.availableModes ?? []
         };
       }
@@ -21358,6 +21472,10 @@ var HermesAdapter = class {
         }
       });
       this.#sessions.add(session);
+      const threadSpecificKeys = Object.keys(input.environment ?? {}).filter((key) => key !== HERMES_THREAD_ID_ENV);
+      if (threadSpecificKeys.length === 0) {
+        this.#primeTransport(cwd, environment);
+      }
       return { ok: true, value: session };
     } catch (error51) {
       await this.#releaseTransport(transport);
@@ -21382,11 +21500,69 @@ var HermesAdapter = class {
     this.#inspectionCache = null;
     const sessions = [...this.#sessions];
     this.#sessions.clear();
+    this.#warmTransports.clear();
     await Promise.all(sessions.map((session) => session.close().catch(() => void 0)));
     await Promise.all([...this.#transports].map((transport) => this.#releaseTransport(transport)));
   }
-  #createTransport(cwd) {
-    const { command, environment, commandTimeoutMs, closeTimeoutMs } = this.#options;
+  #effectiveEnvironment(environment) {
+    const merged = { ...this.#options.environment ?? process.env, ...environment ?? {} };
+    return Object.fromEntries(Object.entries(merged).filter(([key]) => key !== HERMES_THREAD_ID_ENV));
+  }
+  #transportScope(_cwd, environment) {
+    const serialized = JSON.stringify(Object.entries(environment).sort(([left], [right]) => left.localeCompare(right)));
+    return createHash("sha256").update(serialized).digest("hex");
+  }
+  async #takeTransport(cwd, environment) {
+    const scope = this.#transportScope(cwd, environment);
+    const pending = this.#warmTransports.get(scope);
+    if (!pending)
+      return this.#createTransport(cwd, environment);
+    this.#warmTransports.delete(scope);
+    const warmed = await pending;
+    if (!warmed)
+      return this.#createTransport(cwd, environment);
+    warmed.retarget(cwd);
+    return warmed;
+  }
+  #keepWarmTransport(cwd, environment, transport) {
+    if (this.#closed) {
+      void this.#releaseTransport(transport);
+      return;
+    }
+    const scope = this.#transportScope(cwd, environment);
+    const previous = this.#warmTransports.get(scope);
+    const entry = Promise.resolve(transport);
+    this.#watchWarmTransport(scope, entry, transport);
+    this.#warmTransports.set(scope, entry);
+    if (previous) {
+      void previous.then((losing) => {
+        if (losing && losing !== transport)
+          return this.#releaseTransport(losing);
+      });
+    }
+  }
+  #primeTransport(cwd, environment) {
+    const scope = this.#transportScope(cwd, environment);
+    if (this.#closed || this.#warmTransports.has(scope))
+      return;
+    const transport = this.#createTransport(cwd, environment);
+    const pending = transport.inspect().then(() => transport).catch(async () => {
+      await this.#releaseTransport(transport);
+      return null;
+    });
+    this.#watchWarmTransport(scope, pending, transport);
+    this.#warmTransports.set(scope, pending);
+  }
+  #watchWarmTransport(scope, entry, transport) {
+    transport.onFault = () => {
+      if (this.#warmTransports.get(scope) !== entry)
+        return;
+      this.#warmTransports.delete(scope);
+      void this.#releaseTransport(transport);
+    };
+  }
+  #createTransport(cwd, environment = this.#effectiveEnvironment()) {
+    const { command, commandTimeoutMs, closeTimeoutMs } = this.#options;
     const transport = new HermesAcpTransport({
       cwd,
       ...command !== void 0 && command.length > 0 ? { command } : {},