@codexhost/cli-darwin-x64 0.9.1-test.2 → 0.9.2

package/app/plugins/hermes/plugin.mjs

@@ -5,9 +5,6 @@ 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, {
@@ -774,10 +771,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path5) {
-  if (!path5)
+function getElementAtPath(obj, path7) {
+  if (!path7)
     return obj;
-  return path5.reduce((acc, key) => acc?.[key], obj);
+  return path7.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1186,11 +1183,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path5, issues) {
+function prefixIssues(path7, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path5);
+    iss.path.unshift(path7);
     return iss;
   });
 }
@@ -1337,16 +1334,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path5 = []) => {
+  const processError = (error52, path7 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path5, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else {
-        const fullpath = [...path5, ...issue2.path];
+        const fullpath = [...path7, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1373,17 +1370,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path5 = []) => {
+  const processError = (error52, path7 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path5, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else {
-        const fullpath = [...path5, ...issue2.path];
+        const fullpath = [...path7, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1415,8 +1412,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path5 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path5) {
+  const path7 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path7) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -7646,8 +7643,8 @@ function ko_default() {
 }
 
 // ../../../node_modules/zod/v4/locales/lt.js
-var capitalizeFirstCharacter = (text) => {
-  return text.charAt(0).toUpperCase() + text.slice(1);
+var capitalizeFirstCharacter = (text2) => {
+  return text2.charAt(0).toUpperCase() + text2.slice(1);
 };
 function getUnitTypeFromNumber(number4) {
   const abs = Math.abs(number4);
@@ -14108,13 +14105,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path5 = ref.slice(1).split("/").filter(Boolean);
-  if (path5.length === 0) {
+  const path7 = ref.slice(1).split("/").filter(Boolean);
+  if (path7.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path5[0] === defsKey) {
-    const key = path5[1];
+  if (path7[0] === defsKey) {
+    const key = path7[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14522,6 +14519,61 @@ function date4(params) {
 // ../../../node_modules/zod/v4/classic/external.js
 config(en_default());
 
+// ../../shared-contracts/dist/credential-imports.js
+var credentialSourceSchema = external_exports.object({
+  id: external_exports.string().min(1).max(256),
+  harnessId: external_exports.string().min(1),
+  label: external_exports.string().min(1).max(512),
+  provider: external_exports.enum(["openai-codex", "xai"])
+}).strict();
+var credentialImportNameSchema = external_exports.string().regex(/^[a-z][a-z0-9-]{0,47}$/);
+var credentialImportRecordSchema = external_exports.object({
+  name: credentialImportNameSchema,
+  source: credentialSourceSchema,
+  importedAt: external_exports.string()
+}).strict();
+var credentialImportsRequestSchema = external_exports.discriminatedUnion("action", [
+  external_exports.object({ action: external_exports.literal("list") }).strict(),
+  external_exports.object({
+    action: external_exports.literal("import"),
+    sourceId: external_exports.string().min(1).max(256),
+    name: credentialImportNameSchema,
+    confirmed: external_exports.literal(true)
+  }).strict(),
+  external_exports.object({
+    action: external_exports.literal("reimport"),
+    sourceId: external_exports.string().min(1).max(256),
+    name: credentialImportNameSchema,
+    confirmed: external_exports.literal(true)
+  }).strict(),
+  external_exports.object({
+    action: external_exports.literal("remove"),
+    name: credentialImportNameSchema,
+    confirmed: external_exports.literal(true)
+  }).strict()
+]);
+var credentialOtherLoginSchema = external_exports.object({
+  provider: external_exports.string().min(1).max(128),
+  type: external_exports.enum(["oauth", "api_key", "unknown"]),
+  /** Best-effort account label (e.g. the email in a Codex token), derived locally when present. */
+  label: external_exports.string().min(1).max(512).optional(),
+  /** Recognized credential vendor, derived from the OAuth token issuer. Absent when unknown. */
+  vendor: external_exports.enum(["openai-codex", "xai"]).optional()
+}).strict();
+var credentialImportsResultSchema = external_exports.object({
+  sources: external_exports.array(credentialSourceSchema),
+  targets: external_exports.array(external_exports.object({
+    harnessId: external_exports.string(),
+    providers: external_exports.array(external_exports.enum(["openai-codex", "xai"])),
+    imports: external_exports.array(credentialImportRecordSchema),
+    others: external_exports.array(credentialOtherLoginSchema).default([])
+  }).strict())
+}).strict();
+var credentialImportsParamsSchema = external_exports.object({
+  targetHarnessId: external_exports.string().min(1).max(128).optional(),
+  request: credentialImportsRequestSchema
+}).strict();
+
 // ../../shared-contracts/dist/version.js
 var WORKSPACE_CONTRACT_VERSION = 1;
 
@@ -15050,6 +15102,8 @@ var pluginPresentationShape = {
   id: harnessPluginIdSchema,
   name: external_exports.string().trim().min(1).max(128),
   version: external_exports.string().min(1).max(128),
+  /** The factory accepts a persisted local entrypoint through its construction context. */
+  launchCommand: external_exports.literal(true).optional(),
   links: external_exports.object({
     documentation: documentationUrlSchema.optional(),
     installation: documentationUrlSchema.optional()
@@ -15087,6 +15141,19 @@ var harnessPluginRouteSchema = external_exports.object({
   permissionModeId: harnessPermissionModeIdSchema.optional()
 }).strict();
 
+// ../../shared-contracts/dist/harness-launch-settings.js
+var harnessLaunchPathSchema = external_exports.string().trim().min(1).max(4096).refine((value) => !/[\u0000\r\n]/u.test(value), "Invalid entrypoint path");
+var harnessLaunchSettingsGetSchema = external_exports.object({
+  harnessId: harnessPluginIdSchema
+}).strict();
+var harnessLaunchSettingsSetSchema = harnessLaunchSettingsGetSchema.extend({
+  path: harnessLaunchPathSchema.nullable()
+});
+var harnessLaunchSettingsSchema = external_exports.object({
+  path: harnessLaunchPathSchema.nullable(),
+  restartRequired: external_exports.boolean()
+}).strict();
+
 // ../../shared-contracts/dist/codex-accounts.js
 var accountIdSchema = external_exports.string().min(1).max(256).regex(/^[A-Za-z0-9._~-]+$/u);
 var nonBlankTextSchema3 = external_exports.string().trim().min(1);
@@ -15317,6 +15384,8 @@ var nativeCheckpointRefV1RuntimeSchema = external_exports.strictObject({
   locator: jsonValueSchema.optional(),
   formatVersion: external_exports.literal(1)
 }).superRefine(rejectExplicitUndefined(["locator"]));
+var nativeCheckpointRefV1Schema = nativeCheckpointRefV1RuntimeSchema;
+var nativeCheckpointRefSchema = nativeCheckpointRefV1Schema;
 
 // ../../shared-contracts/dist/updates.js
 var UPDATE_ERROR_MAX_LENGTH = 500;
@@ -15372,6 +15441,62 @@ var updateStatusResultSchema = external_exports.strictObject({
 // ../../shared-contracts/dist/index.js
 var workspaceContractVersionSchema = external_exports.literal(WORKSPACE_CONTRACT_VERSION);
 
+// dist/hermes-commands.js
+var SUPPORTED_COMMANDS = /* @__PURE__ */ new Set(["help", "tools", "context", "compress", "version"]);
+function hermesCommandCatalog(commands) {
+  return harnessCommandCatalogSchema.parse({
+    commands: commands.filter((command) => SUPPORTED_COMMANDS.has(command.name)).map((command) => ({
+      id: `hermes.${command.name}`,
+      invocation: `/${command.name}`,
+      label: `/${command.name}`,
+      description: command.description.slice(0, 512) || `Hermes /${command.name}`,
+      argumentMode: command.input ? "text" : "none"
+    }))
+  });
+}
+var HERMES_GATEWAY_COMMANDS = [
+  ...["help", "tools", "context", "version"].map((name) => ({
+    name,
+    description: `Hermes /${name}`
+  })),
+  {
+    name: "compress",
+    description: "Compress conversation context",
+    input: { hint: "Optional compression focus" }
+  }
+];
+var HERMES_COMMAND_CATALOG = hermesCommandCatalog(HERMES_GATEWAY_COMMANDS);
+function hermesCommandText(command, catalog) {
+  const descriptor = catalog.commands.find((entry) => entry.id === command.commandId);
+  if (!descriptor)
+    return {
+      ok: false,
+      error: {
+        code: "unsupported",
+        message: "Hermes did not advertise this command",
+        retryable: false
+      }
+    };
+  const args = command.arguments ?? {};
+  if (Object.keys(args).some((key) => key !== "text") || args.text !== void 0 && typeof args.text !== "string" || descriptor.argumentMode === "none" && typeof args.text === "string" && args.text.trim()) {
+    return {
+      ok: false,
+      error: {
+        code: "invalidRequest",
+        message: "Invalid Hermes command arguments",
+        retryable: false
+      }
+    };
+  }
+  return {
+    ok: true,
+    value: `${descriptor.invocation}${typeof args.text === "string" && args.text.trim() ? ` ${args.text.trim()}` : ""}`
+  };
+}
+
+// dist/hermes-adapter.js
+import { createHash } from "node:crypto";
+
 // dist/acp-transport.js
 import { spawn, spawnSync } from "node:child_process";
 import { Readable, Writable } from "node:stream";
@@ -15384,6 +15509,42 @@ function validateHostApprovalResponse(interaction, response) {
   return interaction.actions.some(({ id }) => id === response.actionId) ? null : invalidRequest("Approval Response contains an undeclared action ID");
 }
 
+// ../../harness-adapter/dist/question.js
+function invalidRequest2(message) {
+  return { code: "invalidRequest", message, retryable: false };
+}
+function validateHostQuestionResponse(interaction, response) {
+  const questionIds = new Set(interaction.questions.map(({ id }) => id));
+  if (response.cancelled) {
+    return Object.keys(response.answers).length === 0 ? null : invalidRequest2("Cancelled Question Response must not contain answers");
+  }
+  for (const answerId of Object.keys(response.answers)) {
+    if (!questionIds.has(answerId)) {
+      return invalidRequest2("Question Response contains an unknown Question ID");
+    }
+  }
+  for (const question2 of interaction.questions) {
+    const answers = response.answers[question2.id] ?? [];
+    if (!question2.optional && answers.length === 0) {
+      return invalidRequest2("Question Response omits a required answer");
+    }
+    if (question2.type === "text") {
+      if (answers.length > 1) {
+        return invalidRequest2("Text Question accepts at most one answer");
+      }
+      continue;
+    }
+    if (!question2.multiple && answers.length > 1) {
+      return invalidRequest2("Single-choice Question accepts at most one answer");
+    }
+    const declared = new Set(question2.options.map(({ value }) => value));
+    if (!question2.allowOther && answers.some((answer) => !declared.has(answer))) {
+      return invalidRequest2("Question Response contains an undeclared choice");
+    }
+  }
+  return null;
+}
+
 // ../../harness-adapter/dist/output-channel.js
 var HarnessOutputChannel = class {
   outputs;
@@ -19960,8 +20121,8 @@ function classifyStartupError(error51) {
     return new HermesTransportError("notInstalled", error51.message, { cause: error51 });
   }
   const detail = errorDetails2(error51);
-  const text = detail.toLowerCase();
-  if (text.includes("auth_required") || text.includes("authentication") || text.includes("not configured") || text.includes("no provider") || text.includes("no llm provider")) {
+  const text2 = detail.toLowerCase();
+  if (text2.includes("auth_required") || text2.includes("authentication") || text2.includes("not configured") || text2.includes("no provider") || text2.includes("no llm provider")) {
     return new HermesTransportError("authenticationRequired", detail, {
       cause: error51,
       diagnostic: detail
@@ -20041,6 +20202,10 @@ var HermesAcpTransport = class {
   #replay = null;
   #sessionId = null;
   #stderrTail = "";
+  #availableCommands = [];
+  get availableCommands() {
+    return this.#availableCommands;
+  }
   /** Late binding: the Session registers its fault consumer on construction. */
   onFault = () => void 0;
   constructor(options) {
@@ -20179,7 +20344,7 @@ var HermesAcpTransport = class {
       throw classifyStartupError(error51);
     }
   }
-  async runTurn(text, onEvent, onPermission) {
+  async runTurn(text2, onEvent, onPermission) {
     const connection = this.#connection;
     if (!connection || !this.#sessionId || this.#closed || this.#closing) {
       throw new HermesTransportError("unavailable", "Hermes ACP Session is unavailable");
@@ -20191,7 +20356,7 @@ var HermesAcpTransport = class {
     try {
       return await connection.prompt({
         sessionId: this.#sessionId,
-        prompt: [{ type: "text", text }]
+        prompt: [{ type: "text", text: text2 }]
       });
     } finally {
       if (this.#activePrompt === active)
@@ -20230,6 +20395,10 @@ var HermesAcpTransport = class {
   #handleUpdate(notification) {
     if (this.#sessionId && notification.sessionId !== this.#sessionId)
       return;
+    if (notification.update.sessionUpdate === "available_commands_update") {
+      this.#availableCommands = notification.update.availableCommands;
+      return;
+    }
     const event = transportEvent(notification.update);
     if (!event)
       return;
@@ -20292,9 +20461,6 @@ var HermesAcpTransport = class {
       clientCapabilities: {},
       clientInfo: { name: "codexhost", version: "0.1.0" }
     }), this.#options.commandTimeoutMs, "Hermes ACP initialize");
-    if (initialize.protocolVersion !== PROTOCOL_VERSION) {
-      throw new HermesTransportError("protocolError", `Hermes ACP negotiated unsupported protocol version ${initialize.protocolVersion}`);
-    }
     this.#initialize = initialize;
     return initialize;
   }
@@ -20433,8 +20599,28 @@ for row in payload.get("providers") or []:
         )
         if slug and model_id:
             available = slug.lower() != "moa" or bool(moa_availability.get(model_id, False))
+            aliases = [
+                alias.strip()
+                for alias in row.get("aliases") or []
+                if isinstance(alias, str) and alias.strip()
+            ]
+            # Hermes names configured custom endpoints as custom:<key>.
+            # The inventory row slug is the bare config key (pi-openai),
+            # which is useful for display but is not a valid native model route.
+            # Prefer the native custom identity for the actual model ref and
+            # retain the bare slug as an alias for matching older snapshots.
+            native_slug = next(
+                (alias for alias in aliases if alias.lower().startswith("custom:")),
+                slug,
+            )
+            native_model_id = native_slug + ":" + model_id
             rows.append({
-                "modelId": slug + ":" + model_id,
+                "modelId": native_model_id,
+                "modelIdAliases": [
+                    alias + ":" + model_id
+                    for alias in aliases
+                    if alias + ":" + model_id != native_model_id
+                ],
                 "label": model_id,
                 "provider": provider,
                 "available": available,
@@ -20446,6 +20632,11 @@ print(json.dumps({"models": rows, "currentModelId": current_model_id}))
 `;
 var HermesInventoryError = class extends Error {
 };
+var HermesInventoryTimeoutError = class extends HermesInventoryError {
+  constructor() {
+    super("Hermes model inventory probe timed out");
+  }
+};
 async function venvPythonFromShim(hermesExecutable, platform = process.platform) {
   try {
     const shim = await readFile(hermesExecutable, "utf8");
@@ -20484,7 +20675,7 @@ function runProbe(pythonExecutable, timeoutMs, environment) {
     let stderr = "";
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      reject(new HermesInventoryError("Hermes model inventory probe timed out"));
+      reject(new HermesInventoryTimeoutError());
     }, timeoutMs);
     child.stdout.on("data", (chunk) => {
       stdout += chunk.toString("utf8");
@@ -20503,11 +20694,11 @@ function runProbe(pythonExecutable, timeoutMs, environment) {
         return;
       }
       try {
-        const parsed = JSON.parse(stdout.trim());
-        const models = (parsed.models ?? []).filter((model) => typeof model?.modelId === "string" && model.modelId.length > 0);
+        const parsed2 = JSON.parse(stdout.trim());
+        const models = (parsed2.models ?? []).filter((model) => typeof model?.modelId === "string" && model.modelId.length > 0);
         resolve({
           models,
-          currentModelId: typeof parsed.currentModelId === "string" && parsed.currentModelId.length > 0 ? parsed.currentModelId : null
+          currentModelId: typeof parsed2.currentModelId === "string" && parsed2.currentModelId.length > 0 ? parsed2.currentModelId : null
         });
       } catch {
         reject(new HermesInventoryError("Hermes inventory probe returned malformed output"));
@@ -20541,10 +20732,11 @@ function catalogModelsFromInventory(inventory) {
   for (const model of inventory.models) {
     if (model.available === false)
       continue;
-    const ref = encodeHermesModelRef(model.modelId);
+    const nativeModelId = model.modelIdAliases?.find((alias) => alias.toLowerCase().startsWith("custom:")) ?? model.modelId;
+    const ref = encodeHermesModelRef(nativeModelId);
     if (!ref)
       continue;
-    if (inventory.currentModelId && model.modelId === inventory.currentModelId) {
+    if (inventory.currentModelId && (model.modelId === inventory.currentModelId || nativeModelId === inventory.currentModelId || model.modelIdAliases?.includes(inventory.currentModelId))) {
       defaultModel = ref;
     }
     models.push({
@@ -20604,7 +20796,558 @@ async function resolveHermesSessionCandidate(input) {
 }
 
 // dist/hermes-session.js
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// dist/hermes-questions.js
 import { randomUUID } from "node:crypto";
+var HermesQuestions = class {
+  emit;
+  #waiters = /* @__PURE__ */ new Map();
+  constructor(emit) {
+    this.emit = emit;
+  }
+  open(turnId, request) {
+    const interactionId = hostInteractionIdSchema.parse(randomUUID());
+    const interaction = {
+      type: "question",
+      interactionId,
+      turnId,
+      questions: request.questions,
+      ...request.title ? { title: request.title } : {}
+    };
+    const pending = new Promise((resolve) => this.#waiters.set(interactionId, { interaction, resolve }));
+    const abort = () => this.#cancel(interactionId, request.signal?.reason === "expired" ? "expired" : "cancelled");
+    request.signal?.addEventListener("abort", abort, { once: true });
+    this.emit({ kind: "interaction", interaction });
+    if (request.signal?.aborted)
+      abort();
+    return pending.finally(() => request.signal?.removeEventListener("abort", abort));
+  }
+  respond(command) {
+    const waiter = this.#waiters.get(command.interactionId);
+    if (!waiter || command.response.type !== "question")
+      return {
+        ok: false,
+        error: { code: "invalidRequest", message: "No pending Hermes question", retryable: false }
+      };
+    const error51 = validateHostQuestionResponse(waiter.interaction, command.response);
+    if (error51)
+      return { ok: false, error: { ...error51, retryable: false } };
+    this.#waiters.delete(command.interactionId);
+    waiter.resolve(command.response);
+    this.emit({
+      kind: "event",
+      event: {
+        type: "interaction.closed",
+        interactionId: command.interactionId,
+        turnId: waiter.interaction.turnId,
+        reason: command.response.cancelled ? "cancelled" : "responded"
+      }
+    });
+    return { ok: true, value: { accepted: true } };
+  }
+  cancel(turnId) {
+    for (const [id, waiter] of this.#waiters)
+      if (!turnId || waiter.interaction.turnId === turnId)
+        this.#cancel(id, "cancelled");
+  }
+  #cancel(id, reason) {
+    const waiter = this.#waiters.get(id);
+    if (!waiter)
+      return;
+    this.#waiters.delete(id);
+    waiter.resolve({ type: "question", answers: {}, cancelled: true });
+    this.emit({
+      kind: "event",
+      event: {
+        type: "interaction.closed",
+        interactionId: waiter.interaction.interactionId,
+        turnId: waiter.interaction.turnId,
+        reason
+      }
+    });
+  }
+};
+
+// ../../../node_modules/diff/libesm/diff/base.js
+var Diff = class {
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    } else if ("callback" in options) {
+      callback = options.callback;
+    }
+    const oldString = this.castInput(oldStr, options);
+    const newString = this.castInput(newStr, options);
+    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+    const newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+  }
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a3;
+    const done = (value) => {
+      value = this.postProcess(value, options);
+      if (callback) {
+        setTimeout(function() {
+          callback(value);
+        }, 0);
+        return void 0;
+      } else {
+        return value;
+      }
+    };
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let editLength = 1;
+    let maxEditLength = newLen + oldLen;
+    if (options.maxEditLength != null) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    const maxExecutionTime = (_a3 = options.timeout) !== null && _a3 !== void 0 ? _a3 : Infinity;
+    const abortAfterTimestamp = Date.now() + maxExecutionTime;
+    const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
+    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    }
+    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    const execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = void 0;
+        }
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = void 0;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = this.addToPath(addPath, true, false, 0, options);
+        } else {
+          basePath = this.addToPath(removePath, false, true, 1, options);
+        }
+        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    };
+    if (callback) {
+      (function exec() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(void 0);
+          }
+          if (!execEditLength()) {
+            exec();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  }
+  addToPath(path7, added, removed, oldPosInc, options) {
+    const last = path7.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path7.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path7.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
+    }
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+      if (options.oneChangePerToken) {
+        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+    }
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  }
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  }
+  removeEmpty(array2) {
+    const ret = [];
+    for (let i = 0; i < array2.length; i++) {
+      if (array2[i]) {
+        ret.push(array2[i]);
+      }
+    }
+    return ret;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  castInput(value, options) {
+    return value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  tokenize(value, options) {
+    return Array.from(value);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return false;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (; componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i) {
+            const oldValue = oldTokens[oldPos + i];
+            return oldValue.length > value2.length ? oldValue : value2;
+          });
+          component.value = this.join(value);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
+      }
+    }
+    return components;
+  }
+};
+
+// ../../../node_modules/diff/libesm/diff/line.js
+var LineDiff = class extends Diff {
+  constructor() {
+    super(...arguments);
+    this.tokenize = tokenize;
+  }
+  equals(left, right, options) {
+    if (options.ignoreWhitespace) {
+      if (!options.newlineIsToken || !left.includes("\n")) {
+        left = left.trim();
+      }
+      if (!options.newlineIsToken || !right.includes("\n")) {
+        right = right.trim();
+      }
+    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+      if (left.endsWith("\n")) {
+        left = left.slice(0, -1);
+      }
+      if (right.endsWith("\n")) {
+        right = right.slice(0, -1);
+      }
+    }
+    return super.equals(left, right, options);
+  }
+};
+var lineDiff = new LineDiff();
+function diffLines(oldStr, newStr, options) {
+  return lineDiff.diff(oldStr, newStr, options);
+}
+function tokenize(value, options) {
+  if (options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, "\n");
+  }
+  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (let i = 0; i < linesAndNewlines.length; i++) {
+    const line = linesAndNewlines[i];
+    if (i % 2 && !options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
+    }
+  }
+  return retLines;
+}
+
+// ../../../node_modules/diff/libesm/patch/create.js
+function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  let optionsObj;
+  if (!options) {
+    optionsObj = {};
+  } else if (typeof options === "function") {
+    optionsObj = { callback: options };
+  } else {
+    optionsObj = options;
+  }
+  if (typeof optionsObj.context === "undefined") {
+    optionsObj.context = 4;
+  }
+  const context = optionsObj.context;
+  if (optionsObj.newlineIsToken) {
+    throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
+  }
+  if (!optionsObj.callback) {
+    return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
+  } else {
+    const { callback } = optionsObj;
+    diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
+      const patch = diffLinesResultToPatch(diff);
+      callback(patch);
+    } }));
+  }
+  function diffLinesResultToPatch(diff) {
+    if (!diff) {
+      return;
+    }
+    diff.push({ value: "", lines: [] });
+    function contextLines(lines) {
+      return lines.map(function(entry) {
+        return " " + entry;
+      });
+    }
+    const hunks = [];
+    let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
+    for (let i = 0; i < diff.length; i++) {
+      const current = diff[i], lines = current.lines || splitLines(current.value);
+      current.lines = lines;
+      if (current.added || current.removed) {
+        if (!oldRangeStart) {
+          const prev = diff[i - 1];
+          oldRangeStart = oldLine;
+          newRangeStart = newLine;
+          if (prev) {
+            curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
+            oldRangeStart -= curRange.length;
+            newRangeStart -= curRange.length;
+          }
+        }
+        for (const line of lines) {
+          curRange.push((current.added ? "+" : "-") + line);
+        }
+        if (current.added) {
+          newLine += lines.length;
+        } else {
+          oldLine += lines.length;
+        }
+      } else {
+        if (oldRangeStart) {
+          if (lines.length <= context * 2 && i < diff.length - 2) {
+            for (const line of contextLines(lines)) {
+              curRange.push(line);
+            }
+          } else {
+            const contextSize = Math.min(lines.length, context);
+            for (const line of contextLines(lines.slice(0, contextSize))) {
+              curRange.push(line);
+            }
+            const hunk = {
+              oldStart: oldRangeStart,
+              oldLines: oldLine - oldRangeStart + contextSize,
+              newStart: newRangeStart,
+              newLines: newLine - newRangeStart + contextSize,
+              lines: curRange
+            };
+            hunks.push(hunk);
+            oldRangeStart = 0;
+            newRangeStart = 0;
+            curRange = [];
+          }
+        }
+        oldLine += lines.length;
+        newLine += lines.length;
+      }
+    }
+    for (const hunk of hunks) {
+      for (let i = 0; i < hunk.lines.length; i++) {
+        if (hunk.lines[i].endsWith("\n")) {
+          hunk.lines[i] = hunk.lines[i].slice(0, -1);
+        } else {
+          hunk.lines.splice(i + 1, 0, "\");
+          i++;
+        }
+      }
+    }
+    return {
+      oldFileName,
+      newFileName,
+      oldHeader,
+      newHeader,
+      hunks
+    };
+  }
+}
+function formatPatch(patch) {
+  if (Array.isArray(patch)) {
+    return patch.map(formatPatch).join("\n");
+  }
+  const ret = [];
+  if (patch.oldFileName == patch.newFileName) {
+    ret.push("Index: " + patch.oldFileName);
+  }
+  ret.push("===================================================================");
+  ret.push("--- " + patch.oldFileName + (typeof patch.oldHeader === "undefined" ? "" : "	" + patch.oldHeader));
+  ret.push("+++ " + patch.newFileName + (typeof patch.newHeader === "undefined" ? "" : "	" + patch.newHeader));
+  for (let i = 0; i < patch.hunks.length; i++) {
+    const hunk = patch.hunks[i];
+    if (hunk.oldLines === 0) {
+      hunk.oldStart -= 1;
+    }
+    if (hunk.newLines === 0) {
+      hunk.newStart -= 1;
+    }
+    ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@");
+    for (const line of hunk.lines) {
+      ret.push(line);
+    }
+  }
+  return ret.join("\n") + "\n";
+}
+function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  if (typeof options === "function") {
+    options = { callback: options };
+  }
+  if (!(options === null || options === void 0 ? void 0 : options.callback)) {
+    const patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
+    if (!patchObj) {
+      return;
+    }
+    return formatPatch(patchObj);
+  } else {
+    const { callback } = options;
+    structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, Object.assign(Object.assign({}, options), { callback: (patchObj) => {
+      if (!patchObj) {
+        callback(void 0);
+      } else {
+        callback(formatPatch(patchObj));
+      }
+    } }));
+  }
+}
+function splitLines(text2) {
+  const hasTrailingNl = text2.endsWith("\n");
+  const result = text2.split("\n").map((line) => line + "\n");
+  if (hasTrailingNl) {
+    result.pop();
+  } else {
+    result.push(result.pop().slice(0, -1));
+  }
+  return result;
+}
+
+// dist/hermes-file-changes.js
+var MAX_DIFF_BYTES = 1024 * 1024;
+var MAX_DIFFS = 32;
+function hermesFileChanges(update) {
+  const changes = [];
+  let bytes = 0;
+  for (const block of update.content ?? []) {
+    if (block.type !== "diff")
+      continue;
+    const { path: path7, oldText, newText } = block;
+    if (!path7.trim() || /[\0\r\n]/u.test(path7) || typeof newText !== "string")
+      continue;
+    if (oldText === newText)
+      continue;
+    bytes += Buffer.byteLength(oldText ?? "") + Buffer.byteLength(newText);
+    if (bytes > MAX_DIFF_BYTES || changes.length === MAX_DIFFS)
+      return [];
+    changes.push({
+      path: path7,
+      kind: "update",
+      diffScope: "fragment",
+      unifiedDiff: createTwoFilesPatch(path7, path7, oldText ?? "", newText, "", "", {
+        context: 3
+      })
+    });
+  }
+  return changes;
+}
+function hermesToolOutput(update) {
+  const content = [];
+  for (const block of update.content ?? []) {
+    if (block.type !== "content")
+      continue;
+    if (block.content.type === "text" && block.content.text) {
+      content.push({ type: "text", text: block.content.text });
+    } else if (block.content.type === "image") {
+      content.push({
+        type: "image",
+        mimeType: block.content.mimeType,
+        base64Data: block.content.data
+      });
+    }
+  }
+  if (!content.length && typeof update.rawOutput === "string" && update.rawOutput) {
+    content.push({ type: "text", text: update.rawOutput });
+  }
+  return content.length ? { content } : null;
+}
+
+// dist/hermes-compaction.js
+function hermesCompactionOutcome(outcome, nativeText) {
+  if (outcome.status !== "succeeded")
+    return outcome;
+  const text2 = nativeText.trim();
+  if (/^Context compressed: \d+ -> \d+ messages\n~[\d,]+ -> ~[\d,]+ tokens$/u.test(text2)) {
+    return { status: "succeeded" };
+  }
+  if (/^(?:Compression failed:|Error executing \/compress:|Context compression not available)/u.test(text2)) {
+    return { status: "failed", error: { code: "nativeFailure", message: text2, retryable: false } };
+  }
+  return { status: "cancelled", reason: text2 || "Hermes did not confirm context compression" };
+}
+
+// dist/hermes-session.js
 var HOST_ERROR_CODES = {
   notInstalled: "notInstalled",
   authenticationRequired: "authenticationRequired",
@@ -20647,7 +21390,7 @@ function usageFromContext(used, size) {
     ...used !== void 0 ? { contextUsedTokens: used } : {}
   };
 }
-function projectPermissionOptions(options) {
+function projectPermissionOptions(options, effects) {
   const actionEffects = {
     allow_once: "allowOnce",
     allow_always: "allowAlways",
@@ -20663,7 +21406,7 @@ function projectPermissionOptions(options) {
   const actions = [];
   const optionIdByAction = /* @__PURE__ */ new Map();
   for (const option of options) {
-    const effect = actionEffects[option.kind];
+    const effect = effects?.[option.optionId] ?? actionEffects[option.kind];
     if (!effect)
       continue;
     actions.push({
@@ -20679,18 +21422,47 @@ var ActiveTurn = class {
   turnId;
   turnKey;
   input;
+  persistsHistory;
+  compactionItem;
+  compactionText = "";
+  nativeCompactionOutcome;
+  nativeTurnSnapshot;
   #currentText = null;
   #toolItems = /* @__PURE__ */ new Map();
   #finishedItems = [];
+  #toolChanges = /* @__PURE__ */ new Map();
   #emittedTerminalItemIds = /* @__PURE__ */ new Set();
-  constructor(turnId, turnKey, input) {
+  rememberFileChanges(toolCallId, update) {
+    const changes = hermesFileChanges(update);
+    if (update.content?.some((block) => block.type === "diff"))
+      this.#toolChanges.set(toolCallId, changes);
+  }
+  completeFileChanges(toolCallId, sourceItemId) {
+    const changes = this.#toolChanges.get(toolCallId);
+    this.#toolChanges.delete(toolCallId);
+    if (!changes?.length)
+      return null;
+    const item = {
+      type: "fileChange",
+      itemId: hostItemIdSchema.parse(randomUUID2()),
+      changes,
+      sourceItemIds: [sourceItemId]
+    };
+    const snapshot = { item, outcome: { status: "succeeded" } };
+    this.#finishedItems.push(snapshot);
+    this.#emittedTerminalItemIds.add(item.itemId);
+    return snapshot;
+  }
+  constructor(turnId, turnKey, input, persistsHistory, compaction) {
     this.turnId = hostTurnIdSchema.parse(turnId);
     this.turnKey = turnKey;
     this.input = input;
+    this.persistsHistory = persistsHistory;
+    this.compactionItem = compaction ? { type: "contextCompaction", itemId: hostItemIdSchema.parse(randomUUID2()) } : null;
   }
-  appendText(kind, text) {
+  appendText(kind, text2) {
     if (this.#currentText && this.#currentText.kind === kind) {
-      const item2 = { ...this.#currentText.item, text: this.#currentText.item.text + text };
+      const item2 = { ...this.#currentText.item, text: this.#currentText.item.text + text2 };
       this.#currentText = { kind, item: item2 };
       return { startedItem: null, item: item2 };
     }
@@ -20700,8 +21472,8 @@ var ActiveTurn = class {
         outcome: { status: "succeeded" }
       });
     }
-    const item = kind === "reasoning" ? { type: "reasoning", itemId: hostItemIdSchema.parse(randomUUID()), text: "" } : { type: "agentMessage", itemId: hostItemIdSchema.parse(randomUUID()), text: "" };
-    const appended = { ...item, text };
+    const item = kind === "reasoning" ? { type: "reasoning", itemId: hostItemIdSchema.parse(randomUUID2()), text: "" } : { type: "agentMessage", itemId: hostItemIdSchema.parse(randomUUID2()), text: "" };
+    const appended = { ...item, text: text2 };
     this.#currentText = { kind, item: appended };
     return { startedItem: item, item: appended };
   }
@@ -20759,6 +21531,13 @@ var ActiveTurn = class {
     }
     this.#toolItems.clear();
   }
+  finishCompaction(outcome) {
+    if (!this.compactionItem)
+      return null;
+    const itemOutcome = outcome.status === "succeeded" && this.nativeCompactionOutcome ? this.nativeCompactionOutcome : hermesCompactionOutcome(outcome, this.compactionText);
+    this.#finishedItems.push({ item: this.compactionItem, outcome: itemOutcome });
+    return itemOutcome;
+  }
   drainPendingItems() {
     const pending = this.#finishedItems.filter((snapshot) => !this.#emittedTerminalItemIds.has(snapshot.item.itemId));
     this.#finishedItems = [];
@@ -20777,25 +21556,30 @@ var ActiveTurn = class {
 function isPlainObjectOrArray(value) {
   return typeof value === "object" && value !== null;
 }
-function toolOutputFromUpdate(update) {
-  const content = [];
-  if (Array.isArray(update.content)) {
-    for (const block of update.content) {
-      const candidate = block;
-      if (candidate?.type === "text" && typeof candidate.text === "string" && candidate.text.length > 0) {
-        content.push({ type: "text", text: candidate.text });
-      }
-    }
-  }
-  if (content.length === 0 && typeof update.rawOutput === "string" && update.rawOutput.length > 0) {
-    content.push({ type: "text", text: update.rawOutput });
-  }
-  return content.length > 0 ? { content } : null;
-}
 function historyTurnsFromReplay(replay, nativeRef, knownTurnRefs = []) {
   const turns = [];
   let current = null;
   let toolItemIndexes = /* @__PURE__ */ new Map();
+  const toolChanges = /* @__PURE__ */ new Map();
+  const appendFileChanges = (toolCallId, update, sourceItemId) => {
+    const changes = hermesFileChanges(update);
+    if (update.content?.some((block) => block.type === "diff"))
+      toolChanges.set(toolCallId, changes);
+    const confirmedChanges = toolChanges.get(toolCallId);
+    if (current && update.status === "completed" && confirmedChanges?.length) {
+      current.items.push({
+        item: {
+          type: "fileChange",
+          itemId: hostItemIdSchema.parse(randomUUID2()),
+          changes: confirmedChanges,
+          sourceItemIds: [sourceItemId]
+        },
+        outcome: { status: "succeeded" }
+      });
+    }
+    if (update.status === "completed" || update.status === "failed")
+      toolChanges.delete(toolCallId);
+  };
   const closeTurn = () => {
     if (!current || current.items.length === 0) {
       current = null;
@@ -20819,21 +21603,22 @@ function historyTurnsFromReplay(replay, nativeRef, knownTurnRefs = []) {
     });
     current = null;
     toolItemIndexes = /* @__PURE__ */ new Map();
+    toolChanges.clear();
   };
-  const pushText = (kind, text) => {
+  const pushText = (kind, text2) => {
     if (!current)
       current = { inputText: "(resumed)", items: [], turnKey: `history-${turns.length + 1}` };
     const last = current.items.at(-1);
     if (last && last.item.type === kind) {
       if (kind === "reasoning") {
-        last.item.text += text;
+        last.item.text += text2;
       } else {
-        last.item.text += text;
+        last.item.text += text2;
       }
       return;
     }
     current.items.push({
-      item: kind === "reasoning" ? { type: "reasoning", itemId: hostItemIdSchema.parse(randomUUID()), text } : { type: "agentMessage", itemId: hostItemIdSchema.parse(randomUUID()), text },
+      item: kind === "reasoning" ? { type: "reasoning", itemId: hostItemIdSchema.parse(randomUUID2()), text: text2 } : { type: "agentMessage", itemId: hostItemIdSchema.parse(randomUUID2()), text: text2 },
       outcome: { status: "succeeded" }
     });
   };
@@ -20858,12 +21643,12 @@ 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 output = hermesToolOutput(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()),
+            itemId: hostItemIdSchema.parse(randomUUID2()),
             toolName,
             arguments: isPlainObjectOrArray(update.rawInput) ? update.rawInput : null,
             ...output ? { output } : {}
@@ -20874,6 +21659,9 @@ function historyTurnsFromReplay(replay, nativeRef, knownTurnRefs = []) {
           } : { status: "cancelled", reason: "Turn ended before terminal tool update" }
         });
         toolItemIndexes.set(event.toolCallId, current.items.length - 1);
+        const sourceItemId = current.items.at(-1)?.item.itemId;
+        if (sourceItemId)
+          appendFileChanges(event.toolCallId, update, sourceItemId);
         break;
       }
       case "tool.update": {
@@ -20886,7 +21674,7 @@ function historyTurnsFromReplay(replay, nativeRef, knownTurnRefs = []) {
         if (!prior || prior.item.type !== "toolExecution")
           break;
         const update = event.update;
-        const output = toolOutputFromUpdate(update);
+        const output = hermesToolOutput(update);
         current.items[itemIndex] = {
           item: { ...prior.item, ...output ? { output } : {} },
           outcome: update.status === "completed" ? { status: "succeeded" } : update.status === "failed" ? {
@@ -20894,6 +21682,7 @@ function historyTurnsFromReplay(replay, nativeRef, knownTurnRefs = []) {
             error: harnessError("nativeFailure", "Tool execution failed")
           } : prior.outcome
         };
+        appendFileChanges(event.toolCallId, update, prior.item.itemId);
         break;
       }
       default:
@@ -20932,6 +21721,7 @@ var HermesSession = class {
   initialState;
   initialUsage;
   outputs;
+  commands;
   #channel = new HarnessOutputChannel();
   #transport;
   #nativeRef;
@@ -20945,16 +21735,37 @@ var HermesSession = class {
   #completedTurns = [];
   #historyTurns;
   #latestUsage;
+  #questions = new HermesQuestions((output) => this.#channel.emit(output));
   #approvalWaiters = /* @__PURE__ */ new Map();
   constructor(options) {
     this.#transport = options.transport;
+    this.capabilities.history.fork = options.supportsDerivation === true;
+    this.capabilities.history.rollbackLastTurn = options.supportsDerivation === true;
+    this.commands = {
+      list: async () => this.#closed || this.#faulted ? err("invalidState", "Hermes Session is unavailable") : ok(hermesCommandCatalog(this.#transport.availableCommands ?? [])),
+      execute: async (command) => {
+        const text2 = hermesCommandText(command, hermesCommandCatalog(this.#transport.availableCommands ?? []));
+        if (!text2.ok)
+          return text2;
+        return this.execute({
+          type: "turn.start",
+          turnId: command.turnId,
+          input: [{ type: "text", text: text2.value }]
+        });
+      }
+    };
     this.#nativeRef = options.nativeRef;
     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.capabilities.configuration.selectThinkingOption = !!this.#transport.setThinking;
     this.#state = {
       nativeRef: this.#nativeRef,
+      ...options.open.session.thinkingOptions ? { availableThinkingOptions: options.open.session.thinkingOptions } : {},
+      ...options.open.session.currentThinkingOptionId ? {
+        effectiveThinkingOptionId: harnessThinkingOptionIdSchema.parse(options.open.session.currentThinkingOptionId)
+      } : {},
       ...projected.effectiveModel ? { effectiveModel: projected.effectiveModel } : {},
       ...projected.resolvedModelLabel ? { resolvedModelLabel: projected.resolvedModelLabel } : {},
       ...modes ? { effectivePermissionModeId: harnessPermissionModeIdSchema.parse(modes.currentModeId) } : {}
@@ -20966,9 +21777,19 @@ var HermesSession = class {
     this.outputs = this.#channel.outputs;
     this.#transport.onFault = (error51) => this.#fault(transportErrorToHarness(error51));
   }
+  get busy() {
+    return this.#activeTurn !== null;
+  }
   async readSnapshot() {
     if (this.#closed)
       return err("invalidState", "Hermes Session is closed");
+    if (this.#transport.readNativeSnapshot) {
+      try {
+        return ok({ ...await this.#transport.readNativeSnapshot(), state: { ...this.#state } });
+      } catch (error51) {
+        return err("nativeFailure", error51 instanceof Error ? error51.message : String(error51));
+      }
+    }
     return ok({
       turns: [...this.#historyTurns, ...this.#completedTurns],
       state: { ...this.#state }
@@ -20984,11 +21805,11 @@ var HermesSession = class {
       case "turn.cancel":
         return this.#cancelTurn(command);
       case "interaction.respond":
-        return Promise.resolve(this.#respondToApproval(command));
+        return Promise.resolve(command.response.type === "question" ? this.#questions.respond(command) : this.#respondToApproval(command));
       case "model.select":
         return this.#selectModel(command);
       case "thinking.select":
-        return err("unsupported", "Hermes does not expose Thinking options");
+        return this.#selectThinking(command);
       case "permissionMode.select":
         return this.#selectPermissionMode(command);
       default: {
@@ -21002,13 +21823,14 @@ var HermesSession = class {
       return;
     this.#closed = true;
     this.#cancelApprovalWaiters();
-    this.#activeTurn = null;
-    this.#activeTurnId = null;
+    if (this.#activeTurn)
+      this.#completeActiveTurn(this.#activeTurn, { status: "cancelled", reason: "Session closed" });
     await this.#transport.close().catch(() => void 0);
     this.#channel.end();
     this.#onSettle(this);
   }
   #cancelApprovalWaiters() {
+    this.#questions.cancel();
     for (const [interactionId, waiter] of this.#approvalWaiters) {
       waiter.resolve({ outcome: { outcome: "cancelled" } });
       this.#emit({
@@ -21042,23 +21864,31 @@ var HermesSession = class {
     if (this.#activeTurn) {
       return err("sessionBusy", "Hermes Session already has an active Turn", true);
     }
-    const text = command.input.map((chunk) => chunk.text).join("\n");
-    if (text.trim().length === 0) {
+    const text2 = command.input.map((chunk) => chunk.text).join("\n");
+    if (text2.trim().length === 0) {
       return err("invalidRequest", "turn.start requires non-empty text input");
     }
-    const turnKey = randomUUID();
-    const active = new ActiveTurn(command.turnId, turnKey, command.input);
+    const turnKey = randomUUID2();
+    const firstToken = text2.trim().split(/\s/u)[0]?.replace(/^\/+/u, "").toLowerCase();
+    const nativeCommand = this.#transport.nativeCommandName ? this.#transport.nativeCommandName(text2) : text2.trimStart().startsWith("/") && (this.#transport.availableCommands ?? []).some((entry) => entry.name === firstToken) ? firstToken : null;
+    const isNativeCommand = nativeCommand != null;
+    const active = new ActiveTurn(command.turnId, turnKey, command.input, !isNativeCommand, isNativeCommand && nativeCommand === "compress");
     this.#activeTurn = active;
     this.#activeTurnId = active.turnId;
-    void this.#runTurn(active, text);
+    void this.#runTurn(active, text2);
     return ok({ turnId: active.turnId });
   }
-  async #runTurn(active, text) {
+  async #runTurn(active, text2) {
     this.#emit({ type: "turn.started", turnId: active.turnId });
+    if (active.compactionItem)
+      this.#emit({ type: "item.started", turnId: active.turnId, item: active.compactionItem });
     let promptResponse = null;
     let failure2 = null;
+    let previousNativeTurnKey;
     try {
-      promptResponse = await this.#transport.runTurn(text, (event) => this.#handleTransportEvent(active, event), (request) => this.#handlePermissionRequest(active, request));
+      if (active.persistsHistory && this.#transport.readNativeSnapshot)
+        previousNativeTurnKey = (await this.#transport.readNativeSnapshot()).turns.at(-1)?.nativeTurnRef.nativeTurnKey;
+      promptResponse = await this.#transport.runTurn(text2, (event) => this.#handleTransportEvent(active, event), (request) => this.#handlePermissionRequest(active, request), (request) => this.#handleQuestionRequest(active, request));
     } catch (error51) {
       failure2 = error51 instanceof HermesTransportError ? transportErrorToHarness(error51) : harnessError("nativeFailure", error51 instanceof Error ? error51.message : String(error51));
     }
@@ -21078,6 +21908,19 @@ var HermesSession = class {
     } else {
       outcome = { status: "succeeded" };
     }
+    active.nativeCompactionOutcome = promptResponse?.compactionOutcome;
+    if (active.persistsHistory && this.#transport.readNativeSnapshot) {
+      try {
+        const latest = (await this.#transport.readNativeSnapshot()).turns.at(-1);
+        if (latest?.nativeTurnRef.nativeTurnKey !== previousNativeTurnKey)
+          active.nativeTurnSnapshot = latest;
+      } catch (error51) {
+        outcome = {
+          status: "failed",
+          error: harnessError("nativeFailure", error51 instanceof Error ? error51.message : String(error51))
+        };
+      }
+    }
     const terminalUsage = promptResponse ? usageFromPromptResponse(promptResponse.usage) : null;
     const usage = terminalUsage ? this.#mergeUsage(terminalUsage) : null;
     this.#completeActiveTurn(active, outcome, usage);
@@ -21085,10 +21928,17 @@ var HermesSession = class {
   #completeActiveTurn(active, outcome, usage = null) {
     if (this.#activeTurn !== active)
       return;
+    this.#cancelApprovalWaiters();
     this.#activeTurn = null;
     this.#activeTurnId = null;
     active.finish();
-    const nativeTurnRef = nativeTurnRefSchema.parse({
+    const compactionOutcome = active.finishCompaction(outcome);
+    if (outcome.status === "succeeded" && compactionOutcome?.status === "failed") {
+      outcome = { status: "failed", error: compactionOutcome.error };
+    }
+    if (active.nativeTurnSnapshot?.checkpoint)
+      outcome = { ...outcome, checkpoint: active.nativeTurnSnapshot.checkpoint };
+    const nativeTurnRef = active.nativeTurnSnapshot?.nativeTurnRef ?? nativeTurnRefSchema.parse({
       harnessId: this.#nativeRef.harnessId,
       nativeSessionId: this.#nativeRef.nativeSessionId,
       nativeTurnKey: active.turnKey,
@@ -21101,10 +21951,18 @@ var HermesSession = class {
     if (usage) {
       this.#emit({ type: "session.usage.changed", usage, observedForTurnId: active.turnId });
     }
-    this.#emit({ type: "turn.completed", turnId: active.turnId, nativeTurnRef, outcome });
-    this.#completedTurns.push(turnSnapshot);
+    this.#emit({
+      type: "turn.completed",
+      turnId: active.turnId,
+      ...active.persistsHistory && (!this.#transport.readNativeSnapshot || active.nativeTurnSnapshot) ? { nativeTurnRef } : {},
+      outcome
+    });
+    if (active.persistsHistory)
+      this.#completedTurns.push(turnSnapshot);
   }
   #handleTransportEvent(active, event) {
+    if (this.#activeTurn !== active)
+      return;
     switch (event.type) {
       case "usage": {
         const usage = usageFromContext(event.used, event.size);
@@ -21122,6 +21980,8 @@ var HermesSession = class {
         this.#appendTextItem(active, "reasoning", event.text);
         return;
       case "agent.text":
+        if (active.compactionItem)
+          active.compactionText += event.text;
         this.#appendTextItem(active, "agentMessage", event.text);
         return;
       case "tool.call": {
@@ -21137,8 +21997,8 @@ var HermesSession = class {
         return;
     }
   }
-  #appendTextItem(active, kind, text) {
-    const appended = active.appendText(kind, text);
+  #appendTextItem(active, kind, text2) {
+    const appended = active.appendText(kind, text2);
     if (!appended)
       return;
     if (appended.startedItem) {
@@ -21148,7 +22008,7 @@ var HermesSession = class {
       type: "item.updated",
       turnId: active.turnId,
       itemId: appended.item.itemId,
-      update: { type: "text.append", text }
+      update: { type: "text.append", text: text2 }
     });
   }
   #startToolItem(active, toolCallId, title, name, rawInput) {
@@ -21158,7 +22018,7 @@ var HermesSession = class {
     }
     const item = {
       type: "toolExecution",
-      itemId: hostItemIdSchema.parse(randomUUID()),
+      itemId: hostItemIdSchema.parse(randomUUID2()),
       toolName: (name ?? title ?? "").trim() || toolCallId,
       arguments: isPlainObjectOrArray(rawInput) ? rawInput : null
     };
@@ -21174,7 +22034,8 @@ var HermesSession = class {
     const entry = active.getToolItem(update.toolCallId);
     if (!entry)
       return;
-    const output = toolOutputFromUpdate(update);
+    active.rememberFileChanges(update.toolCallId, update);
+    const output = hermesToolOutput(update);
     if (output && output.content.length > 0) {
       active.updateToolOutput(update.toolCallId, output);
       this.#emit({
@@ -21188,32 +22049,57 @@ var HermesSession = class {
       const completed = active.completeToolItem(update.toolCallId, output, update.status === "failed");
       if (completed) {
         this.#emit({ type: "item.completed", turnId: active.turnId, snapshot: completed });
+        if (update.status === "completed") {
+          const fileChange = active.completeFileChanges(update.toolCallId, completed.item.itemId);
+          if (fileChange) {
+            this.#emit({ type: "item.started", turnId: active.turnId, item: fileChange.item });
+            this.#emit({ type: "item.completed", turnId: active.turnId, snapshot: fileChange });
+          }
+        }
       }
     }
   }
   #handlePermissionRequest(active, request) {
-    const projected = projectPermissionOptions(request.options);
+    const projected = projectPermissionOptions(request.options, request.effects);
     if (projected.actions.length === 0) {
       return Promise.resolve({ outcome: { outcome: "cancelled" } });
     }
-    const interactionId = hostInteractionIdSchema.parse(randomUUID());
+    const interactionId = hostInteractionIdSchema.parse(randomUUID2());
     const interaction = {
       type: "approval",
       interactionId,
       turnId: active.turnId,
-      title: request.request.options?.[0]?.name?.slice(0, 200) ?? "Hermes 请求批准",
+      title: request.request.toolCall.title?.slice(0, 200) ?? "Hermes 请求批准",
+      ...request.description ? { description: request.description } : {},
       subject: { type: "nativeAction" },
       actions: projected.actions
     };
     this.#emitInteraction(interaction);
-    return new Promise((resolve) => {
+    let abort = () => {
+    };
+    const pending = new Promise((resolve) => {
       this.#approvalWaiters.set(interactionId, {
         interaction,
         turnId: active.turnId,
         optionIdByAction: projected.optionIdByAction,
         resolve
       });
+      abort = () => {
+        if (!this.#approvalWaiters.delete(interactionId))
+          return;
+        resolve({ outcome: { outcome: "cancelled" } });
+        this.#emit({
+          type: "interaction.closed",
+          interactionId,
+          turnId: active.turnId,
+          reason: request.signal?.reason === "expired" ? "expired" : "cancelled"
+        });
+      };
+      request.signal?.addEventListener("abort", abort, { once: true });
+      if (request.signal?.aborted)
+        abort();
     });
+    return pending.finally(() => request.signal?.removeEventListener("abort", abort));
   }
   #respondToApproval(command) {
     if (this.#faulted) {
@@ -21254,6 +22140,7 @@ var HermesSession = class {
     }
     try {
       await this.#transport.cancel();
+      this.#questions.cancel(command.turnId);
       for (const [interactionId, waiter] of this.#approvalWaiters) {
         if (waiter.turnId !== command.turnId)
           continue;
@@ -21272,6 +22159,28 @@ var HermesSession = class {
       return { ok: false, error: failure2 };
     }
   }
+  #handleQuestionRequest(active, request) {
+    if (this.#activeTurn !== active)
+      return Promise.resolve({ type: "question", answers: {}, cancelled: true });
+    return this.#questions.open(active.turnId, request);
+  }
+  async #selectThinking(command) {
+    if (!this.#transport.setThinking)
+      return err("unsupported", "Hermes does not expose Thinking options");
+    if (!this.#state.availableThinkingOptions?.some(({ id }) => id === command.thinkingOptionId))
+      return err("invalidRequest", "Unknown Hermes Thinking option");
+    try {
+      const selected = await this.#transport.setThinking(command.thinkingOptionId);
+      this.#state = {
+        ...this.#state,
+        effectiveThinkingOptionId: harnessThinkingOptionIdSchema.parse(selected)
+      };
+      this.#emit({ type: "session.state.changed", state: { ...this.#state } });
+      return ok({ completed: true });
+    } catch (error51) {
+      return err("nativeFailure", error51 instanceof Error ? error51.message : String(error51));
+    }
+  }
   async #selectModel(command) {
     const native = decodeHermesModelRefId(command.model.id);
     if (!native) {
@@ -21312,8 +22221,16 @@ var HermesSession = class {
       }
       return err("nativeFailure", error51 instanceof Error ? error51.message : "Hermes rejected Permission Mode selection");
     }
+    const locator = this.#nativeRef.locator;
+    if (locator && typeof locator === "object" && !Array.isArray(locator) && locator.transport === "gateway") {
+      this.#nativeRef = {
+        ...this.#nativeRef,
+        locator: { ...locator, permissionModeId: command.permissionModeId }
+      };
+    }
     this.#state = {
       ...this.#state,
+      nativeRef: this.#nativeRef,
       effectivePermissionModeId: harnessPermissionModeIdSchema.parse(command.permissionModeId)
     };
     this.#emit({ type: "session.state.changed", state: { ...this.#state } });
@@ -21321,11 +22238,1323 @@ var HermesSession = class {
   }
 };
 
+// dist/gateway-transport.js
+import { spawn as spawn3, spawnSync as spawnSync2 } from "node:child_process";
+import { access as access2 } from "node:fs/promises";
+import { createInterface } from "node:readline";
+
+// dist/gateway-delegation.js
+import { mkdtemp, writeFile, rm } 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 = [
+  "CODEXHOST_CLI_PATH",
+  "CODEXHOST_RUNTIME_ENDPOINT",
+  "CODEXHOST_RUNTIME_TOKEN",
+  "CODEXHOST_THREAD_ID"
+];
+async function prepareGatewayDelegation(environment) {
+  if (!required2.every((key) => environment[key]))
+    return { environment, bootstrap: "", dispose: async () => {
+    } };
+  const directory = await mkdtemp(path5.join(os2.tmpdir(), "codexhost-hermes-delegation-"));
+  const file2 = path5.join(directory, "SKILL.md");
+  try {
+    await writeFile(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.
+      bootstrap: `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)}))
+`,
+      dispose: () => rm(directory, { recursive: true, force: true })
+    };
+  } catch (error51) {
+    await rm(directory, { recursive: true, force: true });
+    throw error51;
+  }
+}
+
+// dist/gateway-transport.js
+function gatewayRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function gatewayString(value) {
+  return typeof value === "string" ? value : "";
+}
+var GATEWAY_LAUNCH = `import runpy
+runpy.run_module('tui_gateway.entry', run_name='__main__')`;
+var HermesGatewayTransport = class _HermesGatewayTransport {
+  python;
+  cwd;
+  environment;
+  timeoutMs;
+  onEvent = () => void 0;
+  onRequest = (id) => this.rejectRequest(id);
+  onFault = () => void 0;
+  #child = null;
+  #nextId = 0;
+  #pending = /* @__PURE__ */ new Map();
+  #closed = false;
+  #closePromise = null;
+  #processClosed = Promise.resolve();
+  #sessionErrors = /* @__PURE__ */ new Map();
+  #sessionReady = /* @__PURE__ */ new Map();
+  #sessionWaiters = /* @__PURE__ */ new Map();
+  #stderr = "";
+  #delegation;
+  constructor(python, cwd, environment, timeoutMs = 3e4) {
+    this.python = python;
+    this.cwd = cwd;
+    this.environment = environment;
+    this.timeoutMs = timeoutMs;
+  }
+  static async probe(executable, cwd, environment) {
+    const shim = await venvPythonFromShim(executable);
+    const candidates = [
+      ...new Set([
+        environment.CODEXHOST_HERMES_GATEWAY_PYTHON,
+        shim,
+        ...inventoryPythonCandidates(executable)
+      ].filter((candidate) => !!candidate))
+    ];
+    for (const candidate of candidates) {
+      try {
+        await access2(candidate);
+      } catch {
+        continue;
+      }
+      const transport = new _HermesGatewayTransport(candidate, cwd, environment, 2e4);
+      try {
+        await transport.start();
+        return candidate;
+      } catch {
+      } finally {
+        await transport.close();
+      }
+    }
+    return null;
+  }
+  async prepareSession() {
+    if (this.#child || this.#closed)
+      throw new Error("Hermes gateway Session cannot be prepared after start");
+    const prepared = await prepareGatewayDelegation(this.environment);
+    if (this.#closed) {
+      await prepared.dispose();
+      throw new Error("Hermes gateway closed during Session preparation");
+    }
+    this.#delegation = prepared;
+  }
+  async start() {
+    if (this.#child || this.#closed)
+      throw new Error("Hermes gateway cannot be started twice");
+    const child = spawn3(this.python, ["-I", "-u", "-c", (this.#delegation?.bootstrap ?? "") + GATEWAY_LAUNCH], {
+      cwd: this.cwd,
+      env: {
+        ...process.env,
+        ...this.#delegation?.environment ?? this.environment,
+        HERMES_TUI_TOOL_PROGRESS: "all"
+      },
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true,
+      detached: process.platform !== "win32"
+    });
+    this.#child = child;
+    this.#processClosed = new Promise((resolve) => child.once("close", () => resolve()));
+    child.stderr.on("data", (data) => {
+      this.#stderr = sanitizeDiagnosticTail(this.#stderr + data.toString());
+    });
+    child.stdin.on("error", (error51) => this.#fault(error51));
+    child.once("error", (error51) => this.#fault(error51));
+    child.once("exit", () => {
+      if (!this.#closed)
+        this.#fault(new Error(`Hermes gateway exited: ${this.#stderr}`));
+    });
+    createInterface({ input: child.stdout }).on("line", (line) => {
+      try {
+        this.#frame(gatewayRecord(JSON.parse(line)));
+      } catch (error51) {
+        this.#fault(error51 instanceof Error ? error51 : new Error(String(error51)));
+      }
+    });
+    const capabilities = await this.request("gateway.capabilities", {});
+    if (capabilities.per_session_exclusive_submit !== true)
+      throw new Error("Hermes gateway does not enforce exclusive turns");
+  }
+  async waitForSession(sessionId) {
+    const error51 = this.#sessionErrors.get(sessionId);
+    if (error51)
+      throw error51;
+    const ready = this.#sessionReady.get(sessionId);
+    if (ready)
+      return ready;
+    const result = new Promise((resolve, reject) => this.#sessionWaiters.set(sessionId, { resolve, reject }));
+    try {
+      return await withTimeout(result, this.timeoutMs, "Hermes gateway agent initialization");
+    } finally {
+      this.#sessionWaiters.delete(sessionId);
+    }
+  }
+  async request(method, params, timeoutMs = this.timeoutMs) {
+    if (this.#closed || !this.#child)
+      throw new Error("Hermes gateway is closed");
+    const id = `codexhost-${++this.#nextId}`;
+    const response = new Promise((resolve, reject) => {
+      this.#pending.set(id, { resolve, reject });
+      this.#send({ jsonrpc: "2.0", id, method, params });
+    });
+    try {
+      return await withTimeout(response, timeoutMs, `Hermes ${method}`);
+    } catch (error51) {
+      if (error51 instanceof HermesTransportError)
+        this.#fault(error51);
+      throw error51;
+    } finally {
+      this.#pending.delete(id);
+    }
+  }
+  respond(id, result) {
+    this.#send({ jsonrpc: "2.0", id, result });
+  }
+  rejectRequest(id) {
+    this.#send({
+      jsonrpc: "2.0",
+      id,
+      error: { code: -32601, message: "Unsupported Host interaction" }
+    });
+  }
+  #send(frame) {
+    if (!this.#child?.stdin.writable)
+      throw new Error("Hermes gateway input is closed");
+    this.#child.stdin.write(JSON.stringify(frame) + "\n");
+  }
+  #frame(frame) {
+    if (frame.method === "event") {
+      const event = gatewayRecord(frame.params);
+      const sessionId = gatewayString(event.session_id);
+      const payload = gatewayRecord(event.payload);
+      if (event.type === "session.info" && payload.lazy !== true) {
+        this.#sessionReady.set(sessionId, payload);
+        this.#sessionWaiters.get(sessionId)?.resolve(payload);
+      } else if (event.type === "error") {
+        const error51 = new Error(gatewayString(payload.message));
+        this.#sessionErrors.set(sessionId, error51);
+        this.#sessionWaiters.get(sessionId)?.reject(error51);
+      }
+      this.onEvent(event);
+      return;
+    }
+    if (typeof frame.method === "string" && typeof frame.id === "string") {
+      this.onRequest(frame.id, frame.method, gatewayRecord(frame.params));
+      return;
+    }
+    const id = gatewayString(frame.id);
+    const pending = this.#pending.get(id);
+    if (!pending)
+      return;
+    this.#pending.delete(id);
+    if (frame.error)
+      pending.reject(new Error(gatewayString(gatewayRecord(frame.error).message) || "Hermes gateway request failed"));
+    else
+      pending.resolve(gatewayRecord(frame.result));
+  }
+  #fault(error51) {
+    for (const pending of this.#pending.values())
+      pending.reject(error51);
+    for (const waiter of this.#sessionWaiters.values())
+      waiter.reject(error51);
+    this.#sessionWaiters.clear();
+    this.#pending.clear();
+    if (!this.#closed) {
+      this.onFault(error51);
+      void this.close();
+    }
+  }
+  #signal(signal) {
+    const pid = this.#child?.pid;
+    if (!pid)
+      return;
+    if (process.platform === "win32") {
+      spawnSync2("taskkill.exe", ["/pid", String(pid), "/t", "/f"], {
+        stdio: "ignore",
+        windowsHide: true
+      });
+      return;
+    }
+    try {
+      process.kill(-pid, signal);
+    } catch (error51) {
+      if (gatewayRecord(error51).code !== "ESRCH")
+        throw error51;
+    }
+  }
+  close() {
+    return this.#closePromise ??= this.#close().finally(() => this.#delegation?.dispose());
+  }
+  async #close() {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    this.#fault(new Error("Hermes gateway closed"));
+    const child = this.#child;
+    if (!child)
+      return;
+    if (child.exitCode !== null || child.signalCode !== null) {
+      this.#signal("SIGKILL");
+      return;
+    }
+    const exit = this.#processClosed;
+    child.stdin.end();
+    try {
+      await withTimeout(exit, 2e3, "Hermes gateway close");
+    } catch {
+      this.#signal("SIGTERM");
+      try {
+        await withTimeout(exit, 2e3, "Hermes gateway exit");
+      } catch {
+        this.#signal("SIGKILL");
+        await withTimeout(exit, 2e3, "Hermes gateway killed").catch(() => void 0);
+      }
+    }
+  }
+};
+
+// dist/gateway-history.js
+import { spawn as spawn4 } from "node:child_process";
+
+// dist/gateway-history-script.js
+var GATEWAY_HISTORY_SCRIPT = String.raw`
+import sys
+output = sys.stdout
+sys.stdout = sys.stderr
+import hashlib, json, sqlite3
+from pathlib import Path
+from urllib.parse import quote
+from tui_gateway.server import _history_to_messages
+from agent.context_compressor import user_originated_turn_view
+from hermes_state import SessionDB
+from hermes_state_ids import new_session_id
+p = json.load(sys.stdin)
+sid = p['sessionId']
+public_sid = sid
+
+class HistoryFailure(Exception):
+    def __init__(self, code, message):
+        super().__init__(message)
+        self.code = code
+
+def digest(rows):
+    return hashlib.sha256(json.dumps(rows, sort_keys=True, ensure_ascii=True, separators=(',', ':')).encode()).hexdigest()
+
+def config(value):
+    return json.loads(value) if isinstance(value, str) else dict(value or {})
+
+def user_text(row):
+    view = user_originated_turn_view(row)
+    if view is None: return None
+    # Use the original display kind for native /steer and skill rendering; the
+    # origin predicate above separately excludes synthetic continuation turns.
+    projected = _history_to_messages([row])
+    if not projected: return None
+    return projected[0].get('text')
+
+def capture(db):
+    exported = db.export_session(sid)
+    if exported is None:
+        raise RuntimeError('Hermes session is not persisted')
+    active = exported['messages']
+    lineage = db.get_compression_lineage(sid)
+    if not lineage: raise RuntimeError('Hermes session lineage is missing')
+    _, display = db.get_resume_conversations(sid)
+    # get_resume_conversations preserves tool relations but sanitizes display text.
+    # Read the same native rows verbatim and native display identities through a
+    # separate mode=ro connection; MIN(id) preserves identity across tail cloning.
+    uri = 'file:' + quote(str(Path(db.db_path).resolve()), safe='/') + '?mode=ro'
+    with sqlite3.connect(uri, uri=True) as conn:
+        conn.row_factory = sqlite3.Row
+        rows = []
+        native_rows = {}
+        for msg in display:
+            row = conn.execute('SELECT * FROM messages WHERE id = ?', (msg['_row_id'],)).fetchone()
+            if row is None:
+                raise RuntimeError('Hermes history changed while reading')
+            owner = row['session_id']
+            if owner not in native_rows:
+                native_rows[owner] = {r['id']: r for r in db.get_messages(owner, include_inactive=True)}
+            raw = dict(native_rows[owner][row['id']])
+            original = row['id']
+            if row['display_identity'] is not None:
+                original = conn.execute('SELECT MIN(id) FROM messages WHERE session_id IN (' + ','.join('?' for _ in lineage) + ') AND display_identity = ?',
+                    (*lineage, row['display_identity'])).fetchone()[0] or row['id']
+            raw['original_id'] = original
+            if raw['role'] == 'user': raw['user_text'] = user_text(raw)
+            elif raw['role'] == 'assistant':
+                visible = _history_to_messages([raw])
+                raw['display_text'] = visible[0].get('text', '') if visible else ''
+                raw['display_visible'] = bool(visible)
+            rows.append(raw)
+        compressed = conn.execute('SELECT 1 FROM messages WHERE session_id = ? AND (compacted = 1 OR _compressed_summary = 1) LIMIT 1', (sid,)).fetchone() is not None
+    current = db.export_session(sid)
+    if current is None or digest(current['messages']) != digest(active):
+        raise RuntimeError('Hermes history changed while reading')
+    derivable = sid == public_sid and len(lineage) == 1 and not compressed and [r['id'] for r in rows] == [r['id'] for r in active]
+    boundaries = {}
+    if derivable:
+        for i, row in enumerate(active):
+            if user_text(row) is None: continue
+            end = next((j for j in range(i + 1, len(active)) if user_text(active[j]) is not None), len(active))
+            boundaries[str(row['id'])] = {'count': end, 'digest': digest(active[:end])}
+    return exported, {'rows': rows, 'derivable': derivable, 'boundaries': boundaries, 'physicalSessionId': sid}
+
+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}
+        finally: db.close()
+    elif p['operation'] == 'discard':
+        child = p['derivedSessionId']
+        result = {'deleted': False}
+        if child == sid: raise HistoryFailure('invalidState', 'Cannot delete the source Hermes session')
+        db = SessionDB()
+        try:
+            row = db.get_session(child)
+            if (row is not None and row.get('parent_session_id') == sid
+                    and config(row.get('model_config')).get('_branched_from') == sid
+                    and digest(db.get_messages(child)) == p['expectedDigest']):
+                result['deleted'] = db.delete_session(child, expected_delete_ids=[child])
+        finally: db.close()
+    else:
+        db = SessionDB(read_only=True)
+        try:
+            sid = db.resolve_resume_session_id(public_sid)
+            exported, snapshot = capture(db)
+        finally: db.close()
+        if p['operation'] in ('read', 'resolve'):
+            result = snapshot
+        elif p['operation'] == 'derive':
+            if not snapshot['derivable']:
+                raise HistoryFailure('unsupported', 'Hermes cannot losslessly derive compacted or inherited history')
+            messages = exported['messages']
+            if p.get('rollbackLastTurn'):
+                users = [i for i, row in enumerate(messages) if user_text(row) is not None]
+                if not users: raise HistoryFailure('invalidState', 'Hermes session has no user turn to roll back')
+                messages = messages[:users[-1]]
+            elif p.get('checkpoint'):
+                checkpoint = p['checkpoint']
+                boundary = snapshot['boundaries'].get(checkpoint['checkpointId'])
+                if boundary is None or boundary != checkpoint.get('locator'):
+                    raise HistoryFailure('checkpointNotFound', 'Hermes checkpoint no longer matches native history')
+                messages = messages[:boundary['count']]
+            child = new_session_id()
+            model_config = config(exported.get('model_config'))
+            model_config['_branched_from'] = sid
+            payload = {**exported, 'id': child, 'parent_session_id': sid, 'model_config': model_config,
+                'messages': messages, 'title': None, 'ended_at': None, 'end_reason': None, 'archived': False}
+            db = SessionDB()
+            imported = False
+            try:
+                result = db.import_sessions([payload])
+                if result.get('imported_ids') != [child]:
+                    raise RuntimeError('Hermes native import did not create the derived session')
+                imported = True
+                # Native import resets ownership. Fill this NEW row only through the
+                # native COALESCE upsert, preserving source profile and working dir.
+                db.create_session(session_id=child, source=exported.get('source') or 'cli',
+                    cwd=exported.get('cwd'), profile_name=exported.get('profile_name'), parent_session_id=sid)
+                tools = exported.get('tool_names')
+                if isinstance(tools, str): tools = json.loads(tools)
+                if tools is not None: db.update_session_tool_names(child, tools)
+                copied = db.get_messages(child)
+                def payload_rows(rows):
+                    ignored = {'id', 'session_id', 'active', 'compacted', '_row_id'}
+                    result = []
+                    for row in rows:
+                        row = {k: v for k, v in row.items() if k not in ignored}
+                        for key in ('reasoning_details', 'codex_reasoning_items', 'codex_message_items'):
+                            if isinstance(row.get(key), str): row[key] = json.loads(row[key])
+                        result.append(row)
+                    return result
+                if payload_rows(copied) != payload_rows(messages):
+                    raise RuntimeError('Hermes native import did not preserve the transcript')
+                result = {'sessionId': child, 'digest': digest(copied)}
+            except Exception:
+                if imported: db.delete_session(child, expected_delete_ids=[child])
+                raise
+            finally: db.close()
+        else: raise RuntimeError('Unknown Hermes history operation')
+except HistoryFailure as exc:
+    result = {'error': {'code': exc.code, 'message': str(exc)}}
+print(json.dumps(result, ensure_ascii=True), file=output)
+`;
+
+// dist/gateway-history.js
+function record2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function text(value) {
+  if (typeof value === "string")
+    return value;
+  if (Array.isArray(value))
+    return value.map((part) => text(record2(part).text)).join("\n");
+  return "";
+}
+function parsed(value) {
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  return value ?? null;
+}
+function projectGatewayHistory(sessionId, data) {
+  const turns = [];
+  let turn;
+  const tools = /* @__PURE__ */ new Map();
+  for (const row of data.rows) {
+    if (!Number.isSafeInteger(row.id) || !Number.isSafeInteger(row.original_id))
+      throw new Error("Hermes history has no durable message identity");
+    const id = String(row.original_id);
+    if (row.role === "user") {
+      if (typeof row.user_text !== "string")
+        continue;
+      tools.clear();
+      const boundary = data.derivable ? data.boundaries[String(row.id)] : void 0;
+      turn = {
+        nativeTurnRef: nativeTurnRefSchema.parse({
+          harnessId: "hermes",
+          nativeSessionId: sessionId,
+          nativeTurnKey: id,
+          formatVersion: 1
+        }),
+        ...boundary ? {
+          checkpoint: nativeCheckpointRefSchema.parse({
+            harnessId: "hermes",
+            nativeSessionId: sessionId,
+            checkpointId: String(row.id),
+            formatVersion: 1,
+            locator: boundary
+          })
+        } : {},
+        input: [{ type: "text", text: row.user_text }],
+        items: [],
+        outcome: {
+          status: "unknown",
+          reason: "Hermes persisted history does not record a turn outcome"
+        },
+        ...typeof row.timestamp === "number" ? { startedAtMs: Math.trunc(row.timestamp * 1e3) } : {}
+      };
+      turns.push(turn);
+      continue;
+    }
+    if (!turn)
+      continue;
+    const itemId = (suffix) => hostItemIdSchema.parse(`hermes:${id}:${suffix}`);
+    if (row.role === "assistant") {
+      const reasoning = row.display_visible === false ? "" : text(row.reasoning_content) || text(row.reasoning);
+      if (reasoning)
+        turn.items.push({
+          item: { type: "reasoning", itemId: itemId("reasoning"), text: reasoning },
+          outcome: { status: "succeeded" }
+        });
+      const content = typeof row.display_text === "string" ? row.display_text : text(row.content);
+      if (content)
+        turn.items.push({
+          item: { type: "agentMessage", itemId: itemId("message"), text: content },
+          outcome: { status: "succeeded" }
+        });
+      if (Array.isArray(row.tool_calls))
+        for (const value of row.tool_calls) {
+          const call = record2(value);
+          const fn = record2(call.function);
+          if (typeof call.id !== "string" || typeof fn.name !== "string")
+            continue;
+          tools.set(call.id, {
+            item: {
+              type: "toolExecution",
+              itemId: itemId(`tool:${call.id}`),
+              toolName: fn.name,
+              arguments: parsed(fn.arguments)
+            },
+            outcome: { status: "succeeded" }
+          });
+        }
+    } else if (row.role === "tool" && typeof row.tool_call_id === "string") {
+      const tool = tools.get(row.tool_call_id);
+      if (!tool || tool.item.type !== "toolExecution")
+        continue;
+      const output = typeof row.content === "string" ? row.content : JSON.stringify(row.content ?? "");
+      tool.item.output = { content: [{ type: "text", text: output }] };
+      const result = record2(parsed(row.content));
+      if (result.is_error === true || result.isError === true || result.error)
+        tool.outcome = {
+          status: "failed",
+          error: {
+            code: "nativeFailure",
+            message: typeof result.error === "string" ? result.error : "Hermes tool reported an error",
+            retryable: false
+          }
+        };
+      turn.items.push(tool);
+      tools.delete(row.tool_call_id);
+    }
+  }
+  return { turns };
+}
+var HermesGatewayHistoryError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+var HermesGatewayHistory = class {
+  options;
+  #derived = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.options = options;
+  }
+  async readSnapshot() {
+    const data = await this.#run({ operation: "read" });
+    if (!Array.isArray(data.rows) || typeof data.derivable !== "boolean" || !data.boundaries)
+      throw new Error("Malformed Hermes native history response");
+    return projectGatewayHistory(this.options.nativeSessionId, data);
+  }
+  async resolvePhysicalSessionId() {
+    const data = await this.#run({ operation: "resolve" });
+    if (typeof data.physicalSessionId !== "string")
+      throw new Error("Missing Hermes storage identity");
+    return data.physicalSessionId;
+  }
+  async ensureCreated(input) {
+    await this.#run({ operation: "ensure", ...input });
+  }
+  async derive(input = {}) {
+    if (input.checkpoint && input.rollbackLastTurn)
+      throw new Error("Conflicting Hermes derivation boundaries");
+    if (input.checkpoint && (input.checkpoint.harnessId !== "hermes" || input.checkpoint.nativeSessionId !== this.options.nativeSessionId))
+      throw new Error("Hermes checkpoint belongs to another session");
+    const data = await this.#run({ operation: "derive", ...input });
+    const ref = nativeSessionRefSchema.parse({
+      harnessId: "hermes",
+      nativeSessionId: data.sessionId,
+      formatVersion: 1,
+      locator: { transport: "gateway" }
+    });
+    if (typeof data.digest !== "string")
+      throw new Error("Missing Hermes derived-history proof");
+    this.#derived.set(ref.nativeSessionId, data.digest);
+    return ref;
+  }
+  async discardDerived(ref) {
+    const expectedDigest = this.#derived.get(ref.nativeSessionId);
+    if (ref.harnessId !== "hermes" || ref.nativeSessionId === this.options.nativeSessionId || !expectedDigest)
+      throw new HermesGatewayHistoryError("invalidRequest", "This history reader did not create the derived Hermes session");
+    const result = await this.#run({
+      operation: "discard",
+      derivedSessionId: ref.nativeSessionId,
+      expectedDigest
+    });
+    if (result.deleted === true)
+      this.#derived.delete(ref.nativeSessionId);
+    return result.deleted === true;
+  }
+  #run(input) {
+    return new Promise((resolve, reject) => {
+      const child = spawn4(this.options.python, ["-I", "-u", "-c", GATEWAY_HISTORY_SCRIPT], {
+        cwd: this.options.cwd,
+        env: { ...process.env, ...this.options.environment },
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true
+      });
+      let stdout = "";
+      const timer = setTimeout(() => {
+        child.kill();
+        reject(new Error("Hermes history operation timed out"));
+      }, 3e4);
+      child.on("error", () => {
+        clearTimeout(timer);
+        reject(new Error("Cannot start Hermes native history reader"));
+      });
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk.toString();
+        if (stdout.length > 32 * 1024 * 1024) {
+          child.kill();
+          reject(new Error("Hermes native history exceeds the supported size"));
+        }
+      });
+      child.stderr.resume();
+      child.stdin.on("error", () => void 0);
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        if (code !== 0)
+          return reject(new Error("Hermes native history operation failed; source history was not modified"));
+        try {
+          const value = record2(JSON.parse(stdout.trim()));
+          const error51 = record2(value.error);
+          if (["unsupported", "checkpointNotFound", "invalidState"].includes(String(error51.code))) {
+            reject(new HermesGatewayHistoryError(error51.code, String(error51.message)));
+          } else
+            resolve(value);
+        } catch {
+          reject(new Error("Malformed Hermes native history response"));
+        }
+      });
+      child.stdin.end(JSON.stringify({ ...input, sessionId: this.options.nativeSessionId }));
+    });
+  }
+};
+
+// dist/gateway-session-transport.js
+var hermesGatewayThinkingOptions = [
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+  "ultra"
+].map((id) => ({ id: harnessThinkingOptionIdSchema.parse(id), label: id }));
+function question(entry, fallbackId) {
+  const id = gatewayString(entry.qid) || fallbackId;
+  const prompt = gatewayString(entry.question);
+  if (!prompt)
+    throw new Error("Hermes clarify request has no question");
+  const choices = Array.isArray(entry.choices) ? entry.choices.filter((choice) => typeof choice === "string") : [];
+  return choices.length ? {
+    id,
+    type: "choice",
+    prompt,
+    options: choices.map((value) => ({ value, label: value })),
+    multiple: entry.multi_select === true,
+    allowOther: true,
+    optional: false
+  } : { id, type: "text", prompt, multiline: true, secret: false, optional: false };
+}
+function gatewayDiff(text2) {
+  if (!text2 || text2.length > 1024 * 1024)
+    return [];
+  const result = [];
+  let path7 = "";
+  let inHunk = false;
+  let oldLines = [], newLines = [];
+  const flush = () => {
+    if (path7)
+      result.push({
+        type: "diff",
+        path: path7,
+        oldText: oldLines.join("\n"),
+        newText: newLines.join("\n")
+      });
+    oldLines = [];
+    newLines = [];
+  };
+  for (const raw of text2.split("\n")) {
+    const line = raw.replace(/\u001b\[[0-9;]*m/gu, "");
+    const header = /^(a\/.+|\/dev\/null) → (b\/.+|\/dev\/null)$/u.exec(line);
+    if (header) {
+      flush();
+      inHunk = false;
+      path7 = (header[2] === "/dev/null" ? header[1] ?? "" : header[2] ?? "").replace(/^[ab]\//u, "");
+      continue;
+    }
+    if (line.startsWith("--- ") && !inHunk) {
+      flush();
+      path7 = line.slice(4).replace(/^a\//u, "");
+    } else if (line.startsWith("+++ ") && !inHunk) {
+      const next = line.slice(4);
+      if (next !== "/dev/null")
+        path7 = next.replace(/^b\//u, "");
+    } else if (line.startsWith("@@")) {
+      inHunk = true;
+      continue;
+    } else if (path7 && line.startsWith("-"))
+      oldLines.push(line.slice(1));
+    else if (path7 && line.startsWith("+"))
+      newLines.push(line.slice(1));
+    else if (path7 && line.startsWith(" ")) {
+      oldLines.push(line.slice(1));
+      newLines.push(line.slice(1));
+    }
+  }
+  flush();
+  return result;
+}
+var HermesGatewaySessionTransport = class {
+  transport;
+  sessionId;
+  nativeSessionId;
+  onFault = () => void 0;
+  availableCommands = HERMES_GATEWAY_COMMANDS;
+  history;
+  #active = null;
+  #requests = /* @__PURE__ */ new Map();
+  #closed = false;
+  #info;
+  constructor(transport, sessionId, nativeSessionId, info) {
+    this.transport = transport;
+    this.sessionId = sessionId;
+    this.nativeSessionId = nativeSessionId;
+    this.#info = info;
+    this.history = new HermesGatewayHistory({
+      python: transport.python,
+      cwd: transport.cwd,
+      environment: transport.environment,
+      nativeSessionId
+    });
+    transport.onEvent = (event) => this.#event(event);
+    transport.onRequest = (id, method, params) => {
+      void this.#request(id, method, params).catch((error51) => this.#fault(error51));
+    };
+    transport.onFault = (error51) => this.#fault(error51);
+  }
+  async openResult() {
+    const reasoning = await this.transport.request("config.get", {
+      key: "reasoning",
+      session_id: this.sessionId
+    });
+    const currentThinkingOptionId = gatewayString(reasoning.value);
+    const model = gatewayString(this.#info.model);
+    const provider = gatewayString(this.#info.provider);
+    const currentModelId = provider ? `${provider}:${model}` : model;
+    return {
+      initialize: { protocolVersion: 1 },
+      sessionId: this.nativeSessionId,
+      replay: [],
+      session: {
+        sessionId: this.nativeSessionId,
+        models: currentModelId ? {
+          currentModelId,
+          availableModels: [
+            { modelId: currentModelId, name: provider ? `${provider} / ${model}` : model }
+          ]
+        } : null,
+        modes: {
+          currentModeId: this.#info.yolo === true ? "dont_ask" : "default",
+          availableModes: [
+            { id: "default", name: "Native approval policy" },
+            { id: "dont_ask", name: "Session YOLO" }
+          ]
+        },
+        thinkingOptions: hermesGatewayThinkingOptions,
+        ...hermesGatewayThinkingOptions.some(({ id }) => id === currentThinkingOptionId) ? { currentThinkingOptionId } : {}
+      }
+    };
+  }
+  async readNativeSnapshot() {
+    return this.history.readSnapshot();
+  }
+  async setThinking(optionId) {
+    if (!hermesGatewayThinkingOptions.some(({ id }) => id === optionId))
+      throw new Error("Unsupported Hermes reasoning effort");
+    const result = await this.transport.request("config.set", {
+      key: "reasoning",
+      value: optionId,
+      scope: "session",
+      session_id: this.sessionId
+    });
+    if (result.value !== optionId || (await this.transport.request("config.get", { key: "reasoning", session_id: this.sessionId })).value !== optionId)
+      throw new Error("Hermes did not confirm reasoning selection");
+    return optionId;
+  }
+  async setModel(modelId) {
+    if (/\s/u.test(modelId) || modelId.startsWith("-"))
+      throw new Error("Invalid Hermes Model identifier");
+    const result = await this.transport.request("config.set", {
+      key: "model",
+      value: modelId,
+      scope: "session",
+      session_id: this.sessionId
+    });
+    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 (modelId !== actualModel && modelId !== `${actualProvider}:${actualModel}`)
+      throw new Error("Hermes did not confirm the requested Model");
+  }
+  async setPermissionMode(modeId) {
+    if (modeId !== "default" && modeId !== "dont_ask")
+      throw new Error("Hermes gateway has no accept_edits mode");
+    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"))
+      throw new Error("Hermes effective approval policy differs from the requested mode; check native global approvals policy");
+  }
+  nativeCommandName(text2) {
+    const commandText = text2.trim();
+    if (/^\/compress(?:\s|$)/iu.test(commandText))
+      return "compress";
+    return /^\/(help|tools|context|version)$/iu.exec(commandText)?.[1]?.toLowerCase() ?? null;
+  }
+  async runTurn(text2, emit, permission, question2) {
+    if (this.#active || this.#closed)
+      throw new Error("Hermes gateway Session is unavailable");
+    let resolveResult = () => void 0;
+    let rejectResult = () => void 0;
+    const result = new Promise((resolve, reject) => {
+      resolveResult = resolve;
+      rejectResult = reject;
+    });
+    void result.catch(() => void 0);
+    const active = {
+      emit,
+      permission,
+      ...question2 ? { question: question2 } : {},
+      resolve: resolveResult,
+      reject: rejectResult,
+      streamed: "",
+      reasoning: "",
+      toolIds: /* @__PURE__ */ new Set()
+    };
+    this.#active = active;
+    const commandText = text2.trim();
+    const nativeCommand = this.nativeCommandName(text2);
+    try {
+      if (nativeCommand === "compress") {
+        const compact = await this.transport.request("session.compress", { session_id: this.sessionId, focus_topic: commandText.slice(9).trim() }, 3e5);
+        const summary = gatewayRecord(compact.summary);
+        const explanation = [summary.headline, summary.token_line, summary.note, compact.message].filter((value) => typeof value === "string" && !!value).join("\n");
+        if (explanation)
+          emit({ type: "agent.text", text: explanation });
+        if (compact.status === "pending") {
+          this.#fault(new Error("Hermes compression remains pending; Session closed to prevent overlapping native work"));
+          return await result;
+        }
+        if (!["compressed", "aborted"].includes(String(compact.status)) && compact.lock_held !== true)
+          throw new Error("Hermes returned an unrecognized compression outcome");
+        this.#usage(gatewayRecord(compact.usage));
+        const succeeded = compact.status === "compressed" && summary.noop !== true;
+        active.resolve({
+          stopReason: "end_turn",
+          compactionOutcome: compact.status === "aborted" || summary.aborted === true ? {
+            status: "failed",
+            error: {
+              code: "nativeFailure",
+              message: explanation || "Hermes summary generation failed",
+              retryable: true
+            }
+          } : succeeded ? { status: "succeeded" } : { status: "cancelled", reason: explanation || "Hermes did not compact context" }
+        });
+      } else if (nativeCommand) {
+        const response = await this.transport.request("slash.exec", {
+          session_id: this.sessionId,
+          command: `/${nativeCommand}`
+        });
+        emit({ type: "agent.text", text: gatewayString(response.output) });
+        active.resolve({ stopReason: "end_turn" });
+      } else {
+        const submitted = await this.transport.request("prompt.submit", {
+          session_id: this.sessionId,
+          text: text2
+        });
+        if (submitted.status !== "streaming")
+          this.#fault(new Error(`Hermes did not start an exclusive turn (${String(submitted.status)})`));
+      }
+    } catch (error51) {
+      active.reject(error51 instanceof Error ? error51 : new Error(String(error51)));
+    }
+    try {
+      return await result;
+    } finally {
+      if (this.#active === active)
+        this.#active = null;
+      for (const controller of this.#requests.values())
+        controller.abort("cancelled");
+      this.#requests.clear();
+    }
+  }
+  async cancel() {
+    await this.transport.request("session.interrupt", { session_id: this.sessionId });
+  }
+  async close() {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    for (const controller of this.#requests.values())
+      controller.abort("cancelled");
+    this.#requests.clear();
+    this.#active?.reject(new Error("Hermes gateway Session closed"));
+    try {
+      await this.transport.request("session.close", { session_id: this.sessionId });
+    } catch {
+    }
+    await this.transport.close();
+  }
+  #fault(error51) {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    for (const controller of this.#requests.values())
+      controller.abort("cancelled");
+    this.#requests.clear();
+    const fault = new HermesTransportError("protocolError", error51 instanceof Error ? error51.message : String(error51));
+    this.#active?.reject(fault);
+    this.onFault(fault);
+    void this.transport.close();
+  }
+  #event(event) {
+    if (event.session_id !== this.sessionId || this.#closed)
+      return;
+    const payload = gatewayRecord(event.payload);
+    if (event.type === "session.info") {
+      this.#info = payload;
+      return;
+    }
+    if (event.type === "request.cancel") {
+      const controller = this.#requests.get(gatewayString(payload.id));
+      controller?.abort(payload.reason === "timeout" ? "expired" : "cancelled");
+      return;
+    }
+    const active = this.#active;
+    if (!active) {
+      if (event.type === "error")
+        this.#fault(new Error(gatewayString(payload.message)));
+      return;
+    }
+    const text2 = gatewayString(payload.text);
+    if (event.type === "message.delta") {
+      active.streamed += text2;
+      active.emit({ type: "agent.text", text: text2 });
+    } else if (event.type === "reasoning.delta" || event.type === "reasoning.available") {
+      if (event.type === "reasoning.delta" || !active.reasoning) {
+        active.reasoning += text2;
+        active.emit({ type: "agent.thought", text: text2 });
+      }
+    } else if (event.type === "message.interim") {
+      if (payload.already_streamed !== true)
+        active.emit({ type: "agent.text", text: text2 });
+      active.streamed = "";
+      active.reasoning = "";
+    } else if (event.type === "session.usage")
+      this.#usage(gatewayRecord(payload.usage));
+    else if (event.type === "tool.start" || event.type === "tool.complete") {
+      const toolCallId = gatewayString(payload.tool_id);
+      if (!toolCallId)
+        return;
+      const result = gatewayRecord(payload.result);
+      const output = payload.result !== void 0 ? typeof payload.result === "string" ? payload.result : JSON.stringify(payload.result) : gatewayString(payload.result_text) || gatewayString(payload.summary);
+      const content = [
+        ...output ? [{ type: "content", content: { type: "text", text: output } }] : [],
+        ...gatewayDiff(gatewayString(payload.inline_diff))
+      ];
+      if (event.type === "tool.complete" && !active.toolIds.has(toolCallId))
+        active.emit({
+          type: "tool.call",
+          toolCallId,
+          update: {
+            sessionUpdate: "tool_call",
+            toolCallId,
+            title: gatewayString(payload.name),
+            rawInput: payload.args,
+            status: "in_progress"
+          }
+        });
+      active.toolIds.add(toolCallId);
+      active.emit(event.type === "tool.start" ? {
+        type: "tool.call",
+        toolCallId,
+        update: {
+          sessionUpdate: "tool_call",
+          toolCallId,
+          title: gatewayString(payload.name),
+          rawInput: payload.args,
+          status: "in_progress"
+        }
+      } : {
+        type: "tool.update",
+        toolCallId,
+        update: {
+          sessionUpdate: "tool_call_update",
+          toolCallId,
+          status: result.error || result.is_error === true || result.success === false ? "failed" : "completed",
+          content
+        }
+      });
+    } else if (event.type === "message.complete") {
+      if (!active.streamed)
+        active.emit({ type: "agent.text", text: text2 });
+      else if (text2.startsWith(active.streamed) && text2.length > active.streamed.length)
+        active.emit({ type: "agent.text", text: text2.slice(active.streamed.length) });
+      const reasoning = gatewayString(payload.reasoning);
+      if (reasoning && !active.reasoning)
+        active.emit({ type: "agent.thought", text: reasoning });
+      else if (reasoning.startsWith(active.reasoning) && reasoning.length > active.reasoning.length)
+        active.emit({ type: "agent.thought", text: reasoning.slice(active.reasoning.length) });
+      const usage = gatewayRecord(payload.usage);
+      this.#usage(usage);
+      if (payload.status === "error")
+        active.reject(new Error(gatewayString(payload.error) || gatewayString(payload.failure_reason) || "Hermes turn failed"));
+      else
+        active.resolve({
+          stopReason: payload.status === "interrupted" ? "cancelled" : "end_turn",
+          usage: {
+            inputTokens: Number(usage.input) || 0,
+            outputTokens: Number(usage.output) || 0,
+            totalTokens: Number(usage.total) || 0,
+            ...typeof usage.reasoning === "number" ? { thoughtTokens: usage.reasoning } : {}
+          }
+        });
+    } else if (event.type === "error")
+      active.reject(new Error(gatewayString(payload.message) || "Hermes gateway failed"));
+  }
+  #usage(usage) {
+    this.#active?.emit({
+      type: "usage",
+      ...typeof usage.context_used === "number" ? { used: usage.context_used } : {},
+      ...typeof usage.context_max === "number" ? { size: usage.context_max } : {}
+    });
+  }
+  async #request(id, method, params) {
+    const active = this.#active;
+    if (!active || params.session_id !== this.sessionId || !["clarify", "approval"].includes(method)) {
+      this.transport.rejectRequest(id);
+      return;
+    }
+    const controller = new AbortController();
+    this.#requests.set(id, controller);
+    try {
+      if (method === "clarify" && active.question) {
+        const batch = Array.isArray(params.questions);
+        const questions = batch ? params.questions.map((value, index) => question(gatewayRecord(value), String(index))) : [question(params, "answer")];
+        const response = await active.question({
+          title: "Hermes",
+          questions,
+          signal: controller.signal
+        });
+        if (!controller.signal.aborted) {
+          const answers = Object.fromEntries(Object.entries(response.answers).map(([key, values]) => {
+            const q = questions.find((entry) => entry.id === key);
+            return [
+              key,
+              q?.type === "choice" && q.multiple ? JSON.stringify(values) : values[0] ?? ""
+            ];
+          }));
+          this.transport.respond(id, response.cancelled ? {} : batch ? { answers } : { answer: answers.answer ?? "" });
+        }
+      } else if (method === "approval") {
+        const choices = Array.isArray(params.choices) ? params.choices : ["once", "deny"];
+        const options = choices.flatMap((choice) => choice === "once" ? [{ optionId: "once", kind: "allow_once", name: "Allow once" }] : choice === "session" || choice === "always" ? [
+          {
+            optionId: choice,
+            kind: "allow_always",
+            name: choice === "session" ? "Allow for this session" : "Always allow"
+          }
+        ] : choice === "deny" ? [{ optionId: "deny", kind: "reject_once", name: "Deny" }] : []);
+        const response = await active.permission({
+          signal: controller.signal,
+          effects: { session: "allowForSession", always: "allowAlways" },
+          description: gatewayString(params.command) || gatewayString(params.description),
+          request: {
+            sessionId: this.nativeSessionId,
+            toolCall: {
+              toolCallId: gatewayString(params.request_id),
+              title: gatewayString(params.description) || gatewayString(params.command)
+            },
+            options
+          },
+          options
+        });
+        if (!controller.signal.aborted)
+          this.transport.respond(id, {
+            choice: response.outcome.outcome === "selected" ? response.outcome.optionId : "deny"
+          });
+      } else
+        this.transport.rejectRequest(id);
+    } finally {
+      this.#requests.delete(id);
+    }
+  }
+};
+
+// dist/gateway-open.js
+import path6 from "node:path";
+import { realpath } from "node:fs/promises";
+
+// dist/gateway-configuration.js
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+async function resolveGatewayModel(transport, modelId) {
+  if (/\s/u.test(modelId) || modelId.startsWith("-"))
+    throw new Error("Invalid Hermes Model identifier");
+  const result = await promisify(execFile)(transport.python, [
+    "-I",
+    "-c",
+    "import json,sys\nfrom hermes_cli.models import parse_model_input\np,m=parse_model_input(sys.argv[1], '')\nprint(json.dumps({'provider':p,'model':m}))",
+    modelId
+  ], {
+    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-open.js
+async function sameDirectory(left, right) {
+  return await realpath(left).catch(() => path6.resolve(left)) === await realpath(right).catch(() => path6.resolve(right));
+}
+var gatewayCapabilities = {
+  configuration: {
+    selectModel: true,
+    selectThinkingOption: true,
+    selectPermissionMode: true,
+    permissionModeScope: "live"
+  },
+  history: { fork: true, forkAcrossCwd: false, rollbackLastTurn: true }
+};
+function gatewayPermissionModes() {
+  return harnessPermissionModeCatalogSchema.parse({
+    modes: [
+      {
+        id: "default",
+        label: "原生审批策略",
+        description: "遵循 Hermes 全局审批策略，关闭本会话 YOLO。"
+      },
+      {
+        id: "dont_ask",
+        label: "会话 YOLO",
+        description: "本会话自动批准 Hermes 工具操作。",
+        dangerous: true
+      }
+    ],
+    defaultModeId: "default"
+  });
+}
+function isGatewayRef(ref) {
+  return ref.harnessId === "hermes" && gatewayRecord(ref.locator).transport === "gateway";
+}
+async function openGatewaySession(input, transport, onSettle, inheritedPermissionMode) {
+  const source = input.kind === "create" ? null : input.kind === "resume" ? input.nativeRef : input.sourceRef;
+  if (source && !isGatewayRef(source))
+    throw new HermesGatewayHistoryError("unsupported", "This Hermes native reference is not a supported gateway Session");
+  const savedMode = source ? gatewayRecord(source.locator).permissionModeId : void 0;
+  const mode = (input.kind === "fork" ? inheritedPermissionMode : input.permissionModeId) ?? (typeof savedMode === "string" ? savedMode : void 0);
+  if (mode && mode !== "default" && mode !== "dont_ask")
+    throw new HermesGatewayHistoryError("unsupported", "Hermes gateway supports native policy and session YOLO; accept_edits remains ACP-only");
+  if (input.kind === "create" && input.executionPolicy === "unattended-full-access" && mode && mode !== "dont_ask")
+    throw new HermesGatewayHistoryError("invalidRequest", "unattended-full-access requires dont_ask");
+  const model = input.kind !== "fork" && input.model ? decodeHermesModelRefId(input.model.id) : null;
+  if (input.kind !== "fork" && input.model && !model)
+    throw new HermesGatewayHistoryError("invalidRequest", "Model Ref does not belong to Hermes");
+  if (source && gatewayRecord(source.locator).cwd && !await sameDirectory(String(gatewayRecord(source?.locator).cwd), input.cwd))
+    throw new HermesGatewayHistoryError("unsupported", "Hermes gateway preserves the native Session working directory");
+  let nativeRef = source;
+  let sourceHistory;
+  try {
+    await transport.prepareSession();
+    await transport.start();
+    if (source && (input.kind === "fork" || input.kind === "rollbackLastTurn")) {
+      sourceHistory = new HermesGatewayHistory({
+        python: transport.python,
+        cwd: transport.cwd,
+        environment: transport.environment,
+        nativeSessionId: source.nativeSessionId
+      });
+      nativeRef = await sourceHistory.derive(input.kind === "fork" ? { checkpoint: input.checkpoint } : { rollbackLastTurn: true });
+    }
+    const choice = model ? await resolveGatewayModel(transport, model) : 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 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 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");
+    if (model)
+      await bridge.setModel(model);
+    if (input.kind !== "fork" && input.thinkingOptionId)
+      await bridge.setThinking(input.thinkingOptionId);
+    const desiredMode = input.kind === "create" && input.executionPolicy === "unattended-full-access" ? "dont_ask" : mode;
+    if (desiredMode)
+      await bridge.setPermissionMode(desiredMode);
+    const open = await bridge.openResult();
+    return new HermesSession({
+      nativeRef: nativeSessionRefSchema.parse({
+        harnessId: "hermes",
+        nativeSessionId: storedId,
+        formatVersion: 1,
+        locator: {
+          transport: "gateway",
+          cwd: input.cwd,
+          permissionModeId: open.session.modes?.currentModeId
+        }
+      }),
+      transport: bridge,
+      open,
+      supportsDerivation: true,
+      onSettle
+    });
+  } catch (error51) {
+    await transport.close().catch(() => void 0);
+    if (sourceHistory && nativeRef)
+      await sourceHistory.discardDerived(nativeRef).catch(() => false);
+    throw error51;
+  }
+}
+
 // 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 {
+  commandCatalog = HERMES_COMMAND_CATALOG;
   harnessId = hermesHarnessId;
   sessionImport = {
     listCandidates: () => this.#listImportCandidates(),
@@ -21333,11 +23562,16 @@ var HermesAdapter = class {
   };
   #options;
   #inspectionCache = null;
+  #lastInventory = null;
+  #inventoryRead = null;
   #inspectionCacheScope = null;
   #sessions = /* @__PURE__ */ new Set();
   #warmTransports = /* @__PURE__ */ new Map();
   #transports = /* @__PURE__ */ new Set();
   #closed = false;
+  #gatewayTransports = /* @__PURE__ */ new Set();
+  #gatewayProbes = /* @__PURE__ */ new Map();
+  #openingNativeIds = /* @__PURE__ */ new Set();
   constructor(options = {}) {
     this.#options = options;
   }
@@ -21347,6 +23581,29 @@ var HermesAdapter = class {
       return this.#inspectionCache;
     }
     const environment = this.#effectiveEnvironment();
+    if (input.refresh)
+      this.#gatewayProbes.clear();
+    const gatewayPython = await this.#gatewayPython(cwd, environment);
+    if (gatewayPython) {
+      try {
+        const catalog = catalogModelsFromInventory(await this.#readInventory());
+        const inspection = {
+          status: "ready",
+          catalog: {
+            models: catalog.models.map(({ ref, label }) => ({ ref, label })),
+            thinkingOptions: hermesGatewayThinkingOptions,
+            ...catalog.defaultModel ? { defaultModel: catalog.defaultModel } : {}
+          },
+          permissionModes: gatewayPermissionModes(),
+          capabilities: gatewayCapabilities
+        };
+        this.#inspectionCache = inspection;
+        this.#inspectionCacheScope = cwd;
+        return inspection;
+      } catch (error51) {
+        return inspectionFromTransportError(error51);
+      }
+    }
     const transport = await this.#takeTransport(cwd, environment);
     let retainedForOpen = false;
     try {
@@ -21391,13 +23648,26 @@ var HermesAdapter = class {
     }
   }
   async #readInventory() {
+    if (this.#inventoryRead)
+      return this.#inventoryRead;
     const executable = resolveHermesExecutable({
       ...this.#options.command ? { command: this.#options.command } : {},
       ...this.#options.environment ? { environment: this.#options.environment } : {}
     });
-    return readHermesModelInventory(executable, 2e4, {
+    this.#inventoryRead = readHermesModelInventory(executable, 2e4, {
       ...this.#options.environment ? { environment: this.#options.environment } : {}
+    }).then((inventory) => {
+      if (!this.#closed)
+        this.#lastInventory = inventory;
+      return inventory;
+    }).catch((error51) => {
+      if (error51 instanceof HermesInventoryTimeoutError && this.#lastInventory)
+        return this.#lastInventory;
+      throw error51;
+    }).finally(() => {
+      this.#inventoryRead = null;
     });
+    return this.#inventoryRead;
   }
   async open(input) {
     if (this.#closed) {
@@ -21407,6 +23677,23 @@ var HermesAdapter = class {
     if (typeof cwd !== "string" || cwd.trim().length === 0) {
       return failure("invalidRequest", "open requires a cwd");
     }
+    const nativeRef = input.kind === "create" ? null : input.kind === "resume" ? input.nativeRef : input.sourceRef;
+    const gatewayEnvironment = {
+      ...this.#options.environment ?? process.env,
+      ...input.environment ?? {}
+    };
+    const environment = this.#effectiveEnvironment(input.environment);
+    if (input.kind === "resume" && (this.#openingNativeIds.has(input.nativeRef.nativeSessionId) || [...this.#sessions].some((s) => s.initialState.nativeRef?.nativeSessionId === input.nativeRef.nativeSessionId)))
+      return failure("sessionBusy", "This Hermes Session already has an owner", true);
+    if (!nativeRef || isGatewayRef(nativeRef)) {
+      const python = await this.#gatewayPython(cwd, gatewayEnvironment);
+      if (this.#closed)
+        return failure("invalidState", "Hermes Adapter is closed");
+      if (python)
+        return this.#openGateway(input, python, gatewayEnvironment);
+      if (nativeRef)
+        return failure("unavailable", "Hermes gateway Session requires an available gateway with exclusive turn support");
+    }
     let transportOpen;
     let permissionModeId;
     if (input.kind === "create") {
@@ -21430,7 +23717,6 @@ var HermesAdapter = class {
     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);
@@ -21506,16 +23792,80 @@ var HermesAdapter = class {
       return failure("nativeFailure", error51 instanceof Error ? error51.message : "Hermes Session open failed");
     }
   }
+  async #gatewayPython(cwd, environment) {
+    const key = `${cwd}:${this.#transportScope(cwd, environment)}`;
+    let pending = this.#gatewayProbes.get(key);
+    if (!pending) {
+      pending = (async () => {
+        try {
+          return await HermesGatewayTransport.probe(resolveHermesExecutable({
+            ...this.#options.command ? { command: this.#options.command } : {},
+            environment
+          }), cwd, environment);
+        } catch {
+          return null;
+        }
+      })();
+      this.#gatewayProbes.set(key, pending);
+    }
+    return pending;
+  }
+  async #openGateway(input, python, environment) {
+    if (this.#closed)
+      return failure("invalidState", "Hermes Adapter is closed");
+    const ref = input.kind === "resume" ? input.nativeRef : null;
+    if (input.kind === "fork" || input.kind === "rollbackLastTurn") {
+      const source = [...this.#sessions].find((s) => s.initialState.nativeRef?.nativeSessionId === input.sourceRef.nativeSessionId);
+      if (source?.busy)
+        return failure("sessionBusy", "Cannot derive a Hermes Session while its source Turn is active", true);
+    }
+    const owned = (id) => this.#openingNativeIds.has(id) || [...this.#sessions].some((session) => session.initialState.nativeRef?.nativeSessionId === id);
+    if (ref && owned(ref.nativeSessionId))
+      return failure("sessionBusy", "This Hermes Session already has an owner", true);
+    if (ref)
+      this.#openingNativeIds.add(ref.nativeSessionId);
+    const transport = new HermesGatewayTransport(python, input.cwd, environment, this.#options.commandTimeoutMs);
+    this.#gatewayTransports.add(transport);
+    try {
+      let inheritedMode;
+      if (input.kind === "fork") {
+        const source = [...this.#sessions].find((s) => s.initialState.nativeRef?.nativeSessionId === input.sourceRef.nativeSessionId);
+        const snapshot = await source?.readSnapshot();
+        if (snapshot?.ok)
+          inheritedMode = snapshot.value.state?.effectivePermissionModeId;
+      }
+      const session = await openGatewaySession(input, transport, (settled) => {
+        this.#sessions.delete(settled);
+        this.#gatewayTransports.delete(transport);
+      }, inheritedMode);
+      if (this.#closed) {
+        await session.close();
+        return failure("invalidState", "Hermes Adapter is closed");
+      }
+      this.#sessions.add(session);
+      return { ok: true, value: session };
+    } catch (error51) {
+      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)
+        this.#openingNativeIds.delete(ref.nativeSessionId);
+    }
+  }
   async close() {
     if (this.#closed)
       return;
     this.#closed = true;
     this.#inspectionCache = null;
+    this.#lastInventory = 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)));
+    await Promise.all([...this.#gatewayTransports].map((transport) => transport.close()));
+    this.#gatewayTransports.clear();
   }
   #effectiveEnvironment(environment) {
     const merged = { ...this.#options.environment ?? process.env, ...environment ?? {} };