@codexhost/cli-darwin-x64 0.16.1 → 0.17.0

package/app/plugins/hermes/plugin.mjs

@@ -1138,10 +1138,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path9) {
-  if (!path9)
+function getElementAtPath(obj, path8) {
+  if (!path8)
     return obj;
-  return path9.reduce((acc, key) => acc?.[key], obj);
+  return path8.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1550,11 +1550,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path9, issues) {
+function prefixIssues(path8, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path9);
+    iss.path.unshift(path8);
     return iss;
   });
 }
@@ -1701,16 +1701,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path9 = []) => {
+  const processError = (error52, path8 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path9, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path8, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
       } else {
-        const fullpath = [...path9, ...issue2.path];
+        const fullpath = [...path8, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1737,17 +1737,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path9 = []) => {
+  const processError = (error52, path8 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path9, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path8, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
       } else {
-        const fullpath = [...path9, ...issue2.path];
+        const fullpath = [...path8, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1779,8 +1779,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path9 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path9) {
+  const path8 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path8) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14472,13 +14472,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path9 = ref.slice(1).split("/").filter(Boolean);
-  if (path9.length === 0) {
+  const path8 = ref.slice(1).split("/").filter(Boolean);
+  if (path8.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path9[0] === defsKey) {
-    const key = path9[1];
+  if (path8[0] === defsKey) {
+    const key = path8[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -16620,7 +16620,35 @@ import path4 from "node:path";
 
 // dist/hermes-runtime.js
 import { execFile as execFile2 } from "node:child_process";
+import { statSync } from "node:fs";
 import { promisify } from "node:util";
+var launcherPrefixCache = /* @__PURE__ */ new Map();
+function launcherCacheKey(launcher, environment) {
+  let stat;
+  try {
+    stat = statSync(launcher);
+  } catch {
+    return null;
+  }
+  return [
+    launcher,
+    stat.mtimeMs,
+    stat.size,
+    environment.HERMES_HOME ?? "",
+    environment.PATH ?? ""
+  ].join("\0");
+}
+function timeitPassthrough(script) {
+  return [
+    "-n",
+    "1",
+    "-r",
+    "1",
+    "-s",
+    `exec(${JSON.stringify(script)}, {}); import sys, io; sys.stdout = io.StringIO()`,
+    "pass"
+  ];
+}
 function legacyHermesPythonCommand(python, script) {
   return {
     command: python,
@@ -16636,22 +16664,12 @@ ${script}`
   };
 }
 async function nativeHermesPythonCommand(launcher, script, environment, timeoutMs = 2e4, platform = process.platform) {
-  const invocation = commandInvocation(launcher, [
-    "--print-runtime-command",
-    "--module",
-    "timeit",
-    "--",
-    "-n",
-    "1",
-    "-r",
-    "1",
-    "-s",
-    // timeit is a stdlib entry point supported by the native launcher. After
-    // the operation returns, redirect its timing footer, preserving normal
-    // native cleanup and exit status without contaminating JSON/RPC stdout.
-    `exec(${JSON.stringify(script)}, {}); import sys, io; sys.stdout = io.StringIO()`,
-    "pass"
-  ], environment, platform);
+  const passthrough = timeitPassthrough(script);
+  const cacheKey = launcherCacheKey(launcher, environment);
+  const cached2 = cacheKey !== null ? launcherPrefixCache.get(cacheKey) : void 0;
+  if (cached2 !== void 0 && cached2.length > 0 && cached2[0])
+    return { command: cached2[0], arguments: [...cached2.slice(1), ...passthrough] };
+  const invocation = commandInvocation(launcher, ["--print-runtime-command", "--module", "timeit", "--", ...passthrough], environment, platform);
   let stdout;
   try {
     ({ stdout } = await promisify(execFile2)(invocation.command, invocation.arguments, {
@@ -16671,6 +16689,9 @@ async function nativeHermesPythonCommand(launcher, script, environment, timeoutM
   if (!Array.isArray(value) || value.length === 0 || !value.every((arg) => typeof arg === "string") || !value[0]) {
     throw new Error("Hermes launcher returned an invalid runtime command");
   }
+  const passthroughStart = value.length - passthrough.length;
+  if (cacheKey !== null && passthroughStart >= 1 && value.slice(passthroughStart).every((arg, index) => arg === passthrough[index]))
+    launcherPrefixCache.set(cacheKey, value.slice(0, passthroughStart));
   return { command: value[0], arguments: value.slice(1) };
 }
 async function hermesPythonCommand(runtime, script, environment, timeoutMs = 2e4) {
@@ -16983,9 +17004,6 @@ function catalogModelsFromInventory(inventory) {
 }
 
 // dist/gateway-delegation.js
-import { mkdtemp as mkdtemp2, writeFile as writeFile2, rm as rm2 } from "node:fs/promises";
-import os2 from "node:os";
-import path5 from "node:path";
 var HERMES_DELEGATION_GUIDANCE = `This Session runs inside codexhost.
 When the user authorizes cross-Harness delegation, discover the executable named by CODEXHOST_CLI_PATH through your native terminal tool. Read its --help and harness list, then use delegate start and thread send/read/wait/cancel as documented. Prefer --format compact. Preserve CODEXHOST_RUNTIME_ENDPOINT, CODEXHOST_RUNTIME_TOKEN and CODEXHOST_THREAD_ID in these calls: they identify the Runtime and parent Thread. Never print their values or substitute another executable. Native Hermes delegate_task remains available for Hermes subagents.`;
 var required2 = [
@@ -16996,48 +17014,40 @@ var required2 = [
 ];
 async function prepareGatewayDelegation(environment) {
   if (!required2.every((key) => environment[key]))
-    return { environment, bootstrap: "", dispose: async () => {
+    return { environment, bootstrap: "", guidance: null, dispose: async () => {
     } };
-  const directory = await mkdtemp2(path5.join(os2.tmpdir(), "codexhost-hermes-delegation-"));
-  const file2 = path5.join(directory, "SKILL.md");
-  try {
-    await writeFile2(file2, `---
-name: delegation
-description: Discover authorized codexhost agent collaboration.
----
-
-${HERMES_DELEGATION_GUIDANCE}
-`, { mode: 384 });
-    return {
-      environment: {
-        ...environment,
-        HERMES_TUI_SKILLS: [environment.HERMES_TUI_SKILLS, "codexhost-runtime:delegation"].filter(Boolean).join(",")
-      },
-      // Reserve RPC stdout before native plugin imports. The registration is
-      // process-local; no plugin is installed and no user config is changed.
-      //
-      // ``hermes_bootstrap`` must run before ``tui_gateway.server`` is imported:
-      // the gateway spawn uses ``python -I``, so PYTHONPATH and the launcher's
-      // activation are stripped. Hermes's own entry point (``tui_gateway/entry.py``)
-      // imports this module first to put the selected dependency environment on
-      // ``sys.path``; skipping it makes bare third-party imports (e.g.
-      // ``hermes_yaml`` -> ``ruamel``) fail on interpreters whose site-packages
-      // do not already carry Hermes's dependencies. ``hermes_bootstrap`` is
-      // import-safe here for the same reason entry.py relies on it: stdlib-only
-      // at import time, so nothing can shadow it from the launch directory.
-      bootstrap: `import hermes_bootstrap
+  return {
+    environment,
+    // Reserve RPC stdout before native plugin imports.
+    //
+    // ``hermes_bootstrap`` must run before ``tui_gateway.server`` is imported:
+    // the gateway spawn uses ``python -I``, so PYTHONPATH and the launcher's
+    // activation are stripped. Hermes's own entry point (``tui_gateway/entry.py``)
+    // imports this module first to put the selected dependency environment on
+    // ``sys.path``; skipping it makes bare third-party imports (e.g.
+    // ``hermes_yaml`` -> ``ruamel``) fail on interpreters whose site-packages
+    // do not already carry Hermes's dependencies. ``hermes_bootstrap`` is
+    // import-safe here for the same reason entry.py relies on it: stdlib-only
+    // at import time, so nothing can shadow it from the launch directory.
+    bootstrap: `import sys
+import hermes_bootstrap
+_stdout = sys.stdout  # tui_gateway.server redirects sys.stdout to sys.stderr at import (stdio-entry protection); this bridge owns stdout as its RPC channel to the host
 from tui_gateway import server
-from pathlib import Path
-from hermes_cli.plugins import PluginContext, PluginManifest, get_plugin_manager
-PluginContext(PluginManifest(name="codexhost-runtime"), get_plugin_manager()).register_skill(
-    "delegation", Path(${JSON.stringify(file2)}))
+sys.stdout = _stdout
 `,
-      dispose: () => rm2(directory, { recursive: true, force: true })
-    };
-  } catch (error51) {
-    await rm2(directory, { recursive: true, force: true });
-    throw error51;
-  }
+    guidance: `${HERMES_DELEGATION_GUIDANCE}
+
+Runtime identity for this Thread:
+
+- CODEXHOST_CLI_PATH: ${environment.CODEXHOST_CLI_PATH}
+- CODEXHOST_RUNTIME_ENDPOINT: ${environment.CODEXHOST_RUNTIME_ENDPOINT}
+- CODEXHOST_RUNTIME_TOKEN: ${environment.CODEXHOST_RUNTIME_TOKEN}
+- CODEXHOST_THREAD_ID: ${environment.CODEXHOST_THREAD_ID}
+
+(end of codexhost delegation note; the user's message follows)`,
+    dispose: async () => {
+    }
+  };
 }
 
 // dist/hermes-transport.js
@@ -17071,8 +17081,87 @@ function gatewayRecord(value) {
 function gatewayString(value) {
   return typeof value === "string" ? value : "";
 }
-var GATEWAY_LAUNCH = `import runpy
-runpy.run_module('tui_gateway.entry', run_name='__main__')`;
+var GATEWAY_LAUNCH = `import asyncio
+import sys
+
+
+async def _bridge():
+    from hermes_constants import get_hermes_home
+    from hermes_cli.gateway_client import _session_ticket, gateway_ws_target
+    from hermes_cli.gateway_runtime import (
+        attachable,
+        ensure_gateway_runtime,
+        gateway_profile_home,
+    )
+    from gateway.session_contract import CANONICAL_GATEWAY_PROTOCOL
+    from websockets.asyncio.client import connect
+
+    home = gateway_profile_home(get_hermes_home())
+    result = await asyncio.to_thread(ensure_gateway_runtime, home, idle_exit=True)
+    if not attachable(result):
+        detail = f" ({result.detail})" if result.detail else ""
+        raise SystemExit(
+            f"[bridge-exit] gateway not attachable: {result.state} "
+            f"{result.reason_code or 'not ready'}{detail}"
+        )
+    endpoint = result.endpoint
+    ticket = await asyncio.to_thread(_session_ticket, home, endpoint)
+    url, protocols = gateway_ws_target(endpoint, ticket)
+
+    async with connect(
+        url, subprotocols=protocols, open_timeout=10, max_size=8 * 1024 * 1024, proxy=None
+    ) as ws:
+        if protocols and ws.subprotocol != CANONICAL_GATEWAY_PROTOCOL:
+            raise SystemExit("[bridge-exit] gateway protocol mismatch; update/restart required")
+
+        loop = asyncio.get_running_loop()
+        # A full prompt rides on ONE JSON-RPC line; StreamReader's default 64 KiB
+        # line limit aborts the bridge on large pastes (LimitOverrunError), so the
+        # stdin side matches the WebSocket side's 8 MiB frame ceiling.
+        reader = asyncio.StreamReader(limit=8 * 1024 * 1024)
+        await loop.connect_read_pipe(
+            lambda: asyncio.StreamReaderProtocol(reader), sys.stdin
+        )
+
+        async def pump_in():
+            async for raw in reader:
+                line = raw.decode("utf-8", "replace").strip()
+                if line:
+                    await ws.send(line)
+
+        async def pump_out():
+            async for raw in ws:
+                if isinstance(raw, bytes):
+                    raw = raw.decode("utf-8", "replace")
+                sys.stdout.write(raw + "\\n")
+                sys.stdout.flush()
+
+        pump_out_task = asyncio.create_task(pump_out())
+        pump_in_task = asyncio.create_task(pump_in())
+        # stdin EOF (host closed us) or socket close (gateway went away): end both.
+        done, _pending = await asyncio.wait(
+            {pump_in_task, pump_out_task}, return_when=asyncio.FIRST_COMPLETED
+        )
+        for task in (pump_in_task, pump_out_task):
+            task.cancel()
+        for task in done:
+            if task.cancelled():
+                continue
+            exc = task.exception()
+            if exc is not None:
+                raise exc
+
+
+# No __main__ guard: the native launcher spawns this through exec(script, {})
+# whose fresh globals lack __name__; top-level code runs in both the legacy
+# (-c) and native (exec) spawn forms.
+try:
+    asyncio.run(_bridge())
+except SystemExit:
+    raise
+except Exception as exc:
+    raise SystemExit(f"[bridge-exit] bridge failed: {type(exc).__name__}: {exc}")
+`;
 var HermesGatewayTransport = class _HermesGatewayTransport {
   runtime;
   cwd;
@@ -17099,6 +17188,18 @@ var HermesGatewayTransport = class _HermesGatewayTransport {
     this.environment = environment;
     this.timeoutMs = timeoutMs;
   }
+  /** Model-facing delegation guidance for this Thread, or null without delegation. */
+  get delegationGuidance() {
+    return this.#delegation?.guidance ?? null;
+  }
+  /** Whether start() already ran (a warm transport skips prepare/start on reuse). */
+  get started() {
+    return this.#startRequested;
+  }
+  /** Whether the bridge child is gone; a closed transport cannot be reused. */
+  get closed() {
+    return this.#closed;
+  }
   static async probe(executable, cwd, environment) {
     const override = environment.CODEXHOST_HERMES_GATEWAY_PYTHON;
     if (override) {
@@ -17611,7 +17712,7 @@ async function resolveHermesSessionCandidate(input) {
 }
 
 // dist/command.js
-import path6 from "node:path";
+import path5 from "node:path";
 var HermesExecutableError = class extends Error {
   code = "HERMES_NOT_FOUND";
 };
@@ -17634,7 +17735,62 @@ function resolveHermesExecutable(input = {}) {
   });
   if (!resolution)
     throw new HermesExecutableError("Hermes CLI is not installed");
-  return targetPath(platform).isAbsolute(resolution.executable) ? resolution.executable : path6.resolve(resolution.executable);
+  return targetPath(platform).isAbsolute(resolution.executable) ? resolution.executable : path5.resolve(resolution.executable);
+}
+
+// dist/gateway-transport-pool.js
+function sameRuntime(a, b) {
+  if (typeof a === "string" || typeof b === "string")
+    return a === b;
+  return a.launcher === b.launcher;
+}
+var ENVIRONMENT_IDENTITY_KEYS = ["HERMES_HOME", "HERMES_TUI_SKILLS"];
+function environmentIdentity(environment) {
+  return ENVIRONMENT_IDENTITY_KEYS.map((key) => `${key}=${environment[key] ?? ""}`).join("\0");
+}
+function sameBridge(transport, runtime, cwd, environment) {
+  return sameRuntime(transport.runtime, runtime) && transport.cwd === cwd && environmentIdentity(transport.environment) === environmentIdentity(environment);
+}
+var GatewayTransportPool = class {
+  #idle = [];
+  #capacity;
+  #closed = false;
+  constructor(capacity = 2) {
+    this.#capacity = Math.max(1, capacity);
+  }
+  /** A healthy started bridge equivalent to a fresh spawn for these inputs, or null. */
+  acquire(runtime, cwd, environment) {
+    while (this.#idle.length > 0) {
+      const index = this.#idle.findIndex((transport2) => sameBridge(transport2, runtime, cwd, environment));
+      const transport = index >= 0 ? this.#idle.splice(index, 1)[0] : void 0;
+      if (transport === void 0)
+        return null;
+      if (!transport.closed && transport.started)
+        return transport;
+      void transport.close().catch(() => void 0);
+    }
+    return null;
+  }
+  /** Return a bridge after its session settled; unhealthy or late ones are discarded. */
+  release(transport) {
+    if (transport.closed || this.#closed || this.#idle.length >= this.#capacity) {
+      void transport.close().catch(() => void 0);
+      return;
+    }
+    this.#idle.push(transport);
+  }
+  async close() {
+    this.#closed = true;
+    const transports = this.#idle;
+    this.#idle = [];
+    await Promise.all(transports.map((transport) => transport.close().catch(() => void 0)));
+  }
+};
+async function startGatewayTransport(runtime, cwd, environment, timeoutMs) {
+  const transport = new HermesGatewayTransport(runtime, cwd, environment, timeoutMs);
+  await transport.prepareSession();
+  await transport.start();
+  return transport;
 }
 
 // dist/gateway-history.js
@@ -17724,21 +17880,24 @@ def capture(db):
             boundaries[str(row['id'])] = {'count': end, 'digest': digest(active[:end])}
     return exported, {'rows': rows, 'derivable': derivable, 'boundaries': boundaries, 'physicalSessionId': sid}
 
+def ensure_session_row(db):
+    if db.get_session(sid) is None:
+        from hermes_constants import parse_reasoning_effort
+        initial = {}
+        if isinstance(p.get('provider'), str) and p['provider']: initial['provider'] = p['provider']
+        if isinstance(p.get('model'), str) and p['model']: initial['model'] = p['model']
+        if isinstance(p.get('reasoningEffort'), str):
+            reasoning = parse_reasoning_effort(p['reasoningEffort'])
+            if reasoning is not None: initial['reasoning_config'] = reasoning
+        if isinstance(p.get('yolo'), bool): initial['yolo_mode'] = p['yolo']
+        db.create_session(session_id=sid, source='cli', cwd=p['cwd'], model=p.get('model'), model_config=initial)
+    return {'created': True}
+
 try:
     if p['operation'] == 'ensure':
         db = SessionDB()
         try:
-            if db.get_session(sid) is None:
-                from hermes_constants import parse_reasoning_effort
-                initial = {}
-                if isinstance(p.get('provider'), str) and p['provider']: initial['provider'] = p['provider']
-                if isinstance(p.get('model'), str) and p['model']: initial['model'] = p['model']
-                if isinstance(p.get('reasoningEffort'), str):
-                    reasoning = parse_reasoning_effort(p['reasoningEffort'])
-                    if reasoning is not None: initial['reasoning_config'] = reasoning
-                if isinstance(p.get('yolo'), bool): initial['yolo_mode'] = p['yolo']
-                db.create_session(session_id=sid, source='cli', cwd=p['cwd'], model=p.get('model'), model_config=initial)
-            result = {'created': True}
+            result = ensure_session_row(db)
         finally: db.close()
     elif p['operation'] == 'discard':
         child = p['derivedSessionId']
@@ -18106,28 +18265,6 @@ var HermesUsage = class {
   }
 };
 
-// dist/gateway-configuration.js
-import { execFile as execFile4 } from "node:child_process";
-import { promisify as promisify3 } from "node:util";
-async function resolveGatewayModel(transport, modelId) {
-  if (/\s/u.test(modelId) || modelId.startsWith("-"))
-    throw new Error("Invalid Hermes Model identifier");
-  const command = await hermesPythonCommand(transport.runtime, `import json
-from hermes_cli.models import parse_model_input
-p,m=parse_model_input(${JSON.stringify(modelId)}, '')
-print(json.dumps({'provider':p,'model':m}))`, { ...process.env, ...transport.environment });
-  const result = await promisify3(execFile4)(command.command, command.arguments, {
-    cwd: transport.cwd,
-    env: { ...process.env, ...transport.environment },
-    timeout: 2e4,
-    maxBuffer: 1024 * 1024
-  });
-  const value = JSON.parse(result.stdout.trim());
-  if (!value || typeof value !== "object" || !("provider" in value) || !("model" in value) || typeof value.provider !== "string" || typeof value.model !== "string")
-    throw new Error("Hermes returned an invalid Model choice");
-  return { provider: value.provider, model: value.model };
-}
-
 // dist/gateway-session-transport.js
 var hermesGatewayThinkingOptions = [
   "none",
@@ -18159,14 +18296,14 @@ function gatewayDiff(text2) {
   if (!text2 || text2.length > 1024 * 1024)
     return [];
   const result = [];
-  let path9 = "";
+  let path8 = "";
   let inHunk = false;
   let oldLines = [], newLines = [];
   const flush = () => {
-    if (path9)
+    if (path8)
       result.push({
         type: "diff",
-        path: path9,
+        path: path8,
         oldText: oldLines.join("\n"),
         newText: newLines.join("\n")
       });
@@ -18179,24 +18316,24 @@ function gatewayDiff(text2) {
     if (header) {
       flush();
       inHunk = false;
-      path9 = (header[2] === "/dev/null" ? header[1] ?? "" : header[2] ?? "").replace(/^[ab]\//u, "");
+      path8 = (header[2] === "/dev/null" ? header[1] ?? "" : header[2] ?? "").replace(/^[ab]\//u, "");
       continue;
     }
     if (line.startsWith("--- ") && !inHunk) {
       flush();
-      path9 = line.slice(4).replace(/^a\//u, "");
+      path8 = line.slice(4).replace(/^a\//u, "");
     } else if (line.startsWith("+++ ") && !inHunk) {
       const next = line.slice(4);
       if (next !== "/dev/null")
-        path9 = next.replace(/^b\//u, "");
+        path8 = next.replace(/^b\//u, "");
     } else if (line.startsWith("@@")) {
       inHunk = true;
       continue;
-    } else if (path9 && line.startsWith("-"))
+    } else if (path8 && line.startsWith("-"))
       oldLines.push(line.slice(1));
-    else if (path9 && line.startsWith("+"))
+    else if (path8 && line.startsWith("+"))
       newLines.push(line.slice(1));
-    else if (path9 && line.startsWith(" ")) {
+    else if (path8 && line.startsWith(" ")) {
       oldLines.push(line.slice(1));
       newLines.push(line.slice(1));
     }
@@ -18220,7 +18357,7 @@ var HermesGatewaySessionTransport = class {
     return this.#commands;
   }
   async getCommands() {
-    const params = { session_id: this.sessionId, cwd: this.transport.cwd };
+    const params = { session_id: this.sessionId };
     const [response, catalog] = await Promise.all([
       this.transport.request("complete.slash", { ...params, text: "/" }, this.transport.timeoutMs, false),
       this.transport.request("commands.catalog", params, this.transport.timeoutMs, false)
@@ -18245,13 +18382,29 @@ var HermesGatewaySessionTransport = class {
   history;
   #active = null;
   #requests = /* @__PURE__ */ new Map();
+  /** Open approval server requests by their payload request_id, for approval.cancelled. */
+  #approvalRequests = /* @__PURE__ */ new Map();
+  /** Pending approval prompts adopted from the create/resume snapshot. */
+  #adoptedPrompts = [];
   #closed = false;
   #info;
-  constructor(transport, sessionId, nativeSessionId, info) {
+  #revision = null;
+  #generation = null;
+  #subscriptionId = null;
+  /** Thread's delegation guidance, injected as api_text on the first turn only. */
+  #delegationGuidance;
+  constructor(transport, sessionId, nativeSessionId, info, bookkeeping = {}, delegationGuidance = null) {
     this.transport = transport;
     this.sessionId = sessionId;
     this.nativeSessionId = nativeSessionId;
     this.#info = info;
+    this.#delegationGuidance = delegationGuidance;
+    if (typeof bookkeeping.revision === "number")
+      this.#revision = bookkeeping.revision;
+    if (typeof bookkeeping.generation === "number")
+      this.#generation = bookkeeping.generation;
+    if (typeof bookkeeping.subscriptionId === "string")
+      this.#subscriptionId = bookkeeping.subscriptionId;
     this.history = new HermesGatewayHistory({
       python: transport.runtime,
       cwd: transport.cwd,
@@ -18312,17 +18465,24 @@ var HermesGatewaySessionTransport = class {
     return optionId;
   }
   async setModel(modelId) {
-    const choice = await resolveGatewayModel(this.transport, modelId);
-    const result = await this.transport.request("config.set", {
-      key: "model",
-      value: choice.provider ? `${choice.model} --provider ${choice.provider}` : modelId,
-      scope: "session",
-      session_id: this.sessionId
+    const revision = this.#revision;
+    const generation = this.#generation;
+    if (revision === null || generation === null)
+      throw new Error("Hermes gateway Session revision is not known yet");
+    const result = await this.transport.request("session.mutate", {
+      session_id: this.sessionId,
+      request_id: `codexhost-model-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      expected_revision: revision,
+      expected_generation: generation,
+      operation: "model",
+      payload: { model: modelId }
     });
-    if (result.confirm_required === true)
-      throw new Error(gatewayString(result.confirm_message) || "Hermes requires confirmation for this Model");
-    const actualModel = gatewayString(this.#info.model);
-    const actualProvider = gatewayString(this.#info.provider);
+    if (typeof result.revision === "number")
+      this.#revision = result.revision;
+    if (typeof result.execution_generation === "number")
+      this.#generation = result.execution_generation;
+    const actualModel = gatewayString(result.model);
+    const actualProvider = gatewayString(result.provider);
     if (modelId !== actualModel && modelId !== `${actualProvider}:${actualModel}`)
       throw new Error("Hermes did not confirm the requested Model");
   }
@@ -18332,11 +18492,11 @@ var HermesGatewaySessionTransport = class {
     const result = await this.transport.request("config.set", {
       key: "yolo",
       value: modeId === "dont_ask" ? "on" : "off",
-      scope: "session",
       session_id: this.sessionId
     });
-    if (result.value !== (modeId === "dont_ask" ? "1" : "0") || this.#info.yolo !== (modeId === "dont_ask"))
+    if (result.value !== (modeId === "dont_ask" ? "1" : "0"))
       throw new Error("Hermes effective approval policy differs from the requested mode; check native global approvals policy");
+    this.#info = { ...this.#info, yolo: modeId === "dont_ask" };
   }
   nativeCommandName(text2) {
     return hermesGatewayCommandName(text2, this.#commands);
@@ -18359,9 +18519,11 @@ var HermesGatewaySessionTransport = class {
       reject: rejectResult,
       streamed: "",
       reasoning: "",
-      toolIds: /* @__PURE__ */ new Set()
+      toolIds: /* @__PURE__ */ new Set(),
+      admissionId: null
     };
     this.#active = active;
+    void this.#adoptedPrompts.splice(0).map((prompt) => void this.#respondAdoptedApproval(prompt, active).catch(() => void 0));
     const commandText = text2.trim();
     const nativeCommand = this.nativeCommandName(text2);
     try {
@@ -18400,12 +18562,21 @@ var HermesGatewaySessionTransport = class {
         emit({ type: "agent.text", text: response.output });
         active.resolve({ stopReason: "end_turn" });
       } else {
+        const guidance = this.#delegationGuidance;
+        this.#delegationGuidance = null;
         const submitted = await this.transport.request("prompt.submit", {
           session_id: this.sessionId,
-          text: text2
+          text: text2,
+          submission_id: `codexhost-turn-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+          clarify_batch: true,
+          ...guidance ? { api_text: `${guidance}
+
+${text2}` } : {}
         });
-        if (submitted.status !== "streaming")
-          this.#fault(new Error(`Hermes did not start an exclusive turn (${String(submitted.status)})`));
+        if (submitted.status !== "queued" && submitted.status !== "started")
+          this.#fault(new Error(`Hermes did not accept the turn (${String(submitted.status)})`));
+        else if (active.admissionId === null && typeof submitted.admission_id === "string")
+          active.admissionId = submitted.admission_id;
       }
     } catch (error51) {
       active.reject(error51 instanceof Error ? error51 : new Error(String(error51)));
@@ -18421,7 +18592,12 @@ var HermesGatewaySessionTransport = class {
     }
   }
   async cancel() {
-    await this.transport.request("session.interrupt", { session_id: this.sessionId });
+    if (this.#generation === null)
+      return;
+    await this.transport.request("session.interrupt", {
+      session_id: this.sessionId,
+      execution_generation: this.#generation
+    });
   }
   async close() {
     if (this.#closed)
@@ -18432,10 +18608,13 @@ var HermesGatewaySessionTransport = class {
     this.#requests.clear();
     this.#active?.reject(new Error("Hermes gateway Session closed"));
     try {
-      await this.transport.request("session.close", { session_id: this.sessionId });
+      if (this.#subscriptionId !== null)
+        await this.transport.request("session.detach", {
+          session_id: this.sessionId,
+          subscription_id: this.#subscriptionId
+        });
     } catch {
     }
-    await this.transport.close();
   }
   #fault(error51) {
     if (this.#closed)
@@ -18455,6 +18634,10 @@ var HermesGatewaySessionTransport = class {
     const payload = gatewayRecord(event.payload);
     if (event.type === "session.info") {
       this.#info = payload;
+      if (typeof payload.revision === "number")
+        this.#revision = payload.revision;
+      if (typeof payload.execution_generation === "number")
+        this.#generation = payload.execution_generation;
       return;
     }
     if (event.type === "session.usage") {
@@ -18466,12 +18649,26 @@ var HermesGatewaySessionTransport = class {
       controller?.abort(payload.reason === "timeout" ? "expired" : "cancelled");
       return;
     }
+    if (event.type === "approval.cancelled") {
+      const ids = Array.isArray(payload.request_ids) ? payload.request_ids.filter((id) => typeof id === "string") : [];
+      for (const id of ids) {
+        this.#approvalRequests.get(id)?.abort("cancelled");
+        this.#approvalRequests.delete(id);
+      }
+      return;
+    }
     const active = this.#active;
     if (!active) {
       if (event.type === "error")
         this.#fault(new Error(gatewayString(payload.message)));
       return;
     }
+    const eventAdmission = gatewayString(event.admission_id);
+    const eventType = gatewayString(event.type);
+    if (eventAdmission && active.admissionId && eventAdmission !== active.admissionId) {
+      if (eventType.startsWith("message.") || eventType.startsWith("reasoning."))
+        return;
+    }
     const text2 = gatewayString(payload.text);
     if (event.type === "message.delta") {
       active.streamed += text2;
@@ -18602,27 +18799,80 @@ var HermesGatewaySessionTransport = class {
             label: choice === "session" ? "Allow for this session" : "Always allow"
           }
         ] : choice === "deny" ? [{ id: "deny", effect: "deny", label: "Deny" }] : []);
-        const response = await active.permission({
-          signal: controller.signal,
-          title: gatewayString(params.description) || gatewayString(params.command),
-          description: gatewayString(params.command) || gatewayString(params.description),
-          options
-        });
-        if (!controller.signal.aborted)
-          this.transport.respond(id, {
-            choice: response ?? "deny"
+        const payloadRequestId = gatewayString(params.request_id);
+        if (payloadRequestId)
+          this.#approvalRequests.set(payloadRequestId, controller);
+        try {
+          const response = await active.permission({
+            signal: controller.signal,
+            title: gatewayString(params.description) || gatewayString(params.command),
+            description: gatewayString(params.command) || gatewayString(params.description),
+            options
           });
+          if (!controller.signal.aborted)
+            this.transport.respond(id, {
+              choice: response ?? "deny"
+            });
+        } finally {
+          if (payloadRequestId)
+            this.#approvalRequests.delete(payloadRequestId);
+        }
       } else
         this.transport.rejectRequest(id);
     } finally {
       this.#requests.delete(id);
     }
   }
+  /** Keep approval prompts from the create/resume snapshot for the next turn. */
+  adoptPendingPrompts(prompts) {
+    if (!Array.isArray(prompts))
+      return;
+    for (const entry of prompts) {
+      const prompt = gatewayRecord(entry);
+      if (gatewayString(prompt.kind) === "approval" && gatewayString(prompt.prompt_id))
+        this.#adoptedPrompts.push(prompt);
+    }
+  }
+  /**
+   * Answer a snapshot-adopted approval through canonical `approval.respond`.
+   * Clarify prompts are deliberately not answered here: a live clarify
+   * question is served by the `clarify` server request (batch mode), and the
+   * gateway re-issues still-open server requests to an attaching client.
+   */
+  async #respondAdoptedApproval(prompt, active) {
+    if (this.#closed)
+      return;
+    const promptId = gatewayString(prompt.prompt_id);
+    const generation = prompt.execution_generation;
+    const choices = Array.isArray(prompt.choices) ? prompt.choices.filter((choice) => typeof choice === "string") : ["once", "deny"];
+    const options = choices.flatMap((choice) => choice === "once" ? [{ id: "once", effect: "allowOnce", label: "Allow once" }] : choice === "session" || choice === "always" ? [
+      {
+        id: choice,
+        effect: choice === "session" ? "allowForSession" : "allowAlways",
+        label: choice === "session" ? "Allow for this session" : "Always allow"
+      }
+    ] : choice === "deny" ? [{ id: "deny", effect: "deny", label: "Deny" }] : []);
+    const response = await active.permission({
+      signal: new AbortController().signal,
+      title: gatewayString(prompt.description) || gatewayString(prompt.command) || "Hermes approval requested before this Session attached",
+      description: gatewayString(prompt.command) || gatewayString(prompt.description),
+      options
+    });
+    if (this.#closed)
+      return;
+    if (typeof generation === "number")
+      await this.transport.request("approval.respond", {
+        session_id: this.sessionId,
+        execution_generation: generation,
+        prompt_id: promptId,
+        choice: response ?? "deny"
+      }, this.transport.timeoutMs, false);
+  }
 };
 
 // dist/usage-statistics.js
-import os3 from "node:os";
-import path7 from "node:path";
+import os2 from "node:os";
+import path6 from "node:path";
 import { lstat } from "node:fs/promises";
 
 // ../../harness-adapter/dist/usage-statistics.js
@@ -18682,9 +18932,9 @@ function usageEntryFromRequest(request, occurredAtMs) {
 
 // dist/usage-statistics.js
 function hermesStateDatabasePath(environment) {
-  const home = environment.HOME || environment.USERPROFILE || os3.homedir();
+  const home = environment.HOME || environment.USERPROFILE || os2.homedir();
   const configured = environment.HERMES_HOME;
-  return path7.resolve(configured ? path7.join(configured, "state.db") : path7.join(home, ".hermes", "state.db"));
+  return path6.resolve(configured ? path6.join(configured, "state.db") : path6.join(home, ".hermes", "state.db"));
 }
 async function fingerprint(file2) {
   const info = await lstat(file2).catch(() => null);
@@ -18766,7 +19016,7 @@ function createHermesUsageStatistics(environment) {
 }
 
 // dist/gateway-open.js
-import path8 from "node:path";
+import path7 from "node:path";
 import { realpath } from "node:fs/promises";
 
 // dist/hermes-session.js
@@ -18976,16 +19226,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path9, added, removed, oldPosInc, options) {
-    const last = path9.lastComponent;
+  addToPath(path8, added, removed, oldPosInc, options) {
+    const last = path8.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path9.oldPos + oldPosInc,
+        oldPos: path8.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path9.oldPos + oldPosInc,
+        oldPos: path8.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -19300,8 +19550,8 @@ function hermesFileChanges(update) {
   for (const block of update.content ?? []) {
     if (block.type !== "diff")
       continue;
-    const { path: path9, oldText, newText } = block;
-    if (!path9.trim() || /[\0\r\n]/u.test(path9) || typeof newText !== "string")
+    const { path: path8, oldText, newText } = block;
+    if (!path8.trim() || /[\0\r\n]/u.test(path8) || typeof newText !== "string")
       continue;
     if (oldText === newText)
       continue;
@@ -19309,10 +19559,10 @@ function hermesFileChanges(update) {
     if (bytes > MAX_DIFF_BYTES || changes.length === MAX_DIFFS)
       return [];
     changes.push({
-      path: path9,
+      path: path8,
       kind: "update",
       diffScope: "fragment",
-      unifiedDiff: createTwoFilesPatch(path9, path9, oldText ?? "", newText, "", "", {
+      unifiedDiff: createTwoFilesPatch(path8, path8, oldText ?? "", newText, "", "", {
         context: 3
       })
     });
@@ -20117,7 +20367,7 @@ ${reason}` }
 
 // dist/gateway-open.js
 async function sameDirectory(left, right) {
-  return await realpath(left).catch(() => path8.resolve(left)) === await realpath(right).catch(() => path8.resolve(right));
+  return await realpath(left).catch(() => path7.resolve(left)) === await realpath(right).catch(() => path7.resolve(right));
 }
 var gatewayCapabilities = {
   configuration: {
@@ -20179,8 +20429,10 @@ async function openGatewaySession(input, transport, onSettle, inheritedPermissio
   let nativeRef = source;
   let sourceHistory;
   try {
-    await transport.prepareSession();
-    await transport.start();
+    if (!transport.started) {
+      await transport.prepareSession();
+      await transport.start();
+    }
     if (source && (input.kind === "fork" || input.kind === "rollbackLastTurn")) {
       sourceHistory = new HermesGatewayHistory({
         python: transport.runtime,
@@ -20190,34 +20442,33 @@ async function openGatewaySession(input, transport, onSettle, inheritedPermissio
       });
       nativeRef = await sourceHistory.derive(input.kind === "fork" ? { checkpoint: input.checkpoint } : { rollbackLastTurn: true });
     }
-    const choice = model2 ? await resolveGatewayModel(transport, model2) : null;
-    const response = await transport.request(nativeRef ? "session.resume" : "session.create", nativeRef ? { session_id: nativeRef.nativeSessionId, eager_build: true, omit_messages: true } : {
-      cwd: input.cwd,
-      close_on_disconnect: true,
-      ...choice ? choice : {},
-      ...input.kind === "create" && input.thinkingOptionId ? { reasoning_effort: input.thinkingOptionId } : {}
-    });
+    const response = await transport.request(
+      nativeRef ? "session.resume" : "session.create",
+      // Canonical wire (hermes-gateway-v1, CanonicalCreateParams/CanonicalResumeParams):
+      // no close_on_disconnect / eager_build keys, and the effort key is "reasoning".
+      nativeRef ? { session_id: nativeRef.nativeSessionId, omit_messages: true } : {
+        cwd: input.cwd,
+        ...model2 ? { model: model2 } : {},
+        ...input.kind === "create" && input.thinkingOptionId ? { reasoning: input.thinkingOptionId } : {}
+      }
+    );
     const runtimeId = gatewayString(response.session_id);
     const storedId = nativeRef?.nativeSessionId || gatewayString(response.stored_session_id);
     if (!runtimeId || !storedId)
       throw new Error("Hermes gateway did not return Session identity");
-    let info = gatewayRecord(response.info);
-    if (info.lazy === true)
-      info = await transport.waitForSession(runtimeId);
+    const info = gatewayRecord(response.info);
     const nativeCwd = gatewayString(info.cwd);
     if (nativeCwd && !await sameDirectory(nativeCwd, input.cwd))
       throw new HermesGatewayHistoryError("unsupported", "Hermes resumed a different native working directory");
-    const bridge = new HermesGatewaySessionTransport(transport, runtimeId, storedId, info);
-    if (!nativeRef)
-      await bridge.history.ensureCreated({
-        cwd: input.cwd,
-        model: gatewayString(info.model),
-        provider: gatewayString(info.provider),
-        reasoningEffort: gatewayString(info.reasoning_effort)
-      });
-    const physicalId = await bridge.history.resolvePhysicalSessionId();
-    if (gatewayString(info.stored_session_id) !== physicalId)
-      throw new Error("Hermes live Session and persisted history identities differ");
+    const bridge = new HermesGatewaySessionTransport(transport, runtimeId, storedId, info, {
+      revision: response.revision,
+      generation: response.execution_generation,
+      subscriptionId: response.subscription_id
+    }, transport.delegationGuidance);
+    bridge.adoptPendingPrompts(response.prompts);
+    if (nativeRef) {
+      await bridge.history.resolvePhysicalSessionId();
+    }
     if (model2)
       await bridge.setModel(model2);
     if (input.kind !== "fork" && input.thinkingOptionId)
@@ -20269,6 +20520,7 @@ var HermesAdapter = class {
   #importReads = /* @__PURE__ */ new Map();
   #closed = false;
   #gatewayTransports = /* @__PURE__ */ new Set();
+  #gatewayPool = new GatewayTransportPool(2);
   #gatewayProbes = /* @__PURE__ */ new Map();
   #openingNativeIds = /* @__PURE__ */ new Set();
   usageStatistics;
@@ -20384,9 +20636,10 @@ var HermesAdapter = class {
       return failure("sessionBusy", "This Hermes Session already has an owner", true);
     if (ref)
       this.#openingNativeIds.add(ref.nativeSessionId);
-    const transport = new HermesGatewayTransport(runtime, input.cwd, environment, this.#options.commandTimeoutMs);
-    this.#gatewayTransports.add(transport);
+    let transport;
     try {
+      transport = this.#gatewayPool.acquire(runtime, input.cwd, environment) ?? await startGatewayTransport(runtime, input.cwd, environment, this.#options.commandTimeoutMs);
+      this.#gatewayTransports.add(transport);
       let inheritedMode;
       if (input.kind === "fork") {
         const source = [...this.#sessions].find((s) => s.initialState.nativeRef?.nativeSessionId === input.sourceRef.nativeSessionId);
@@ -20397,6 +20650,7 @@ var HermesAdapter = class {
       const session = await openGatewaySession(input, transport, (settled) => {
         this.#sessions.delete(settled);
         this.#gatewayTransports.delete(transport);
+        this.#gatewayPool.release(transport);
       }, inheritedMode);
       if (this.#closed) {
         await session.close();
@@ -20405,8 +20659,10 @@ var HermesAdapter = class {
       this.#sessions.add(session);
       return { ok: true, value: session };
     } catch (error51) {
-      await transport.close().catch(() => void 0);
-      this.#gatewayTransports.delete(transport);
+      if (transport) {
+        await transport.close().catch(() => void 0);
+        this.#gatewayTransports.delete(transport);
+      }
       return failure(error51 instanceof HermesGatewayHistoryError ? error51.code : "nativeFailure", error51 instanceof Error ? error51.message : "Hermes gateway open failed");
     } finally {
       if (ref)
@@ -20430,6 +20686,7 @@ var HermesAdapter = class {
     await Promise.all(sessions.map((session) => session.close().catch(() => void 0)));
     await Promise.all([...this.#gatewayTransports].map((transport) => transport.close()));
     this.#gatewayTransports.clear();
+    await this.#gatewayPool.close();
   }
   #effectiveEnvironment(environment) {
     return { ...this.#options.environment ?? process.env, ...environment ?? {} };