@karlorz/codexhost-cli-darwin-x64 0.13.3-6 → 0.13.3-7

package/app/plugins/omp/plugin.mjs

@@ -424,10 +424,13 @@ function usageSessionTitle(value) {
     return void 0;
   if (normalized.length <= MAX_SESSION_TITLE_LENGTH)
     return normalized;
-  const characters = [...normalized];
-  if (characters.length <= MAX_SESSION_TITLE_LENGTH)
-    return normalized;
-  return `${characters.slice(0, MAX_SESSION_TITLE_LENGTH - 1).join("").trimEnd()}…`;
+  let title = "";
+  for (const character of normalized) {
+    if (title.length + character.length >= MAX_SESSION_TITLE_LENGTH)
+      break;
+    title += character;
+  }
+  return `${title.trimEnd()}…`;
 }
 function sessionIdOk(value) {
   return typeof value === "string" && value.length > 0 && value.length <= MAX_SESSION_ID_LENGTH;
@@ -15374,6 +15377,8 @@ var CONSOLE_HOST_METHODS = Object.freeze([
   "codexhost/harness/installation",
   "codexhost/harness/launch-settings/get",
   "codexhost/harness/launch-settings/set",
+  "codexhost/harness/grok-computer-use/get",
+  "codexhost/harness/grok-computer-use/set",
   "codexhost/harness/web-ui/open",
   "codexhost/harness/accounts/sources",
   "codexhost/harness/accounts/list",
@@ -15902,7 +15907,9 @@ var harnessInspectionSchema = external_exports.union([
 var harnessInspectParamsSchema = external_exports.object({
   harnessId: harnessIdSchema,
   cwd: nonBlankTextSchema2.max(16384).optional(),
-  refresh: external_exports.boolean().optional()
+  refresh: external_exports.boolean().optional(),
+  /** `availability` asks only whether the Harness can run; see `InspectHarnessInput.purpose`. */
+  purpose: external_exports.literal("availability").optional()
 }).strict();
 var harnessWebUiOpenParamsSchema = external_exports.object({
   harnessId: harnessIdSchema
@@ -16076,6 +16083,26 @@ var harnessLaunchSettingsSchema = external_exports.object({
   restartRequired: external_exports.boolean()
 }).strict();
 
+// ../../shared-contracts/dist/grok-computer-use.js
+var grokComputerUseGetSchema = external_exports.object({}).strict();
+var grokComputerUseSetSchema = external_exports.object({
+  enabled: external_exports.boolean().optional(),
+  browser: external_exports.boolean().optional()
+}).strict().refine((value) => value.enabled !== void 0 || value.browser !== void 0, {
+  message: "Expected enabled or browser"
+});
+var grokComputerUseSettingsSchema = external_exports.object({
+  enabled: external_exports.boolean(),
+  available: external_exports.boolean(),
+  unavailableReason: external_exports.string().min(1).max(500).optional(),
+  browser: external_exports.boolean().optional(),
+  browserFilesPresent: external_exports.boolean().optional(),
+  browserAvailable: external_exports.boolean().optional(),
+  browserUnavailableReason: external_exports.string().min(1).max(500).optional(),
+  applyFailed: external_exports.boolean().optional(),
+  applyError: external_exports.string().min(1).max(500).optional()
+}).strict();
+
 // ../../shared-contracts/dist/harness-installation.js
 var harnessInstallationParamsSchema = external_exports.object({
   harnessId: harnessIdSchema,
@@ -17788,2256 +17815,2348 @@ function createOmpUsageStatistics(environment) {
   });
 }
 
-// ../../../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);
+// dist/omp-model-list.js
+import { spawn as spawn2 } from "node:child_process";
+
+// dist/command.js
+var ompDiscoverySpec = {
+  id: "omp",
+  command: "omp",
+  commandEnvironmentVariable: "OMP_COMMAND",
+  installRoots: {
+    posix: [
+      "~/.npm-global/bin",
+      "~/.local/bin",
+      VERSION_MANAGER_ROOTS,
+      "/opt/homebrew/bin",
+      "/usr/local/bin"
+    ],
+    windows: ["${APPDATA}/npm", "~/.local/bin", VERSION_MANAGER_ROOTS]
   }
-  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;
+};
+function resolveOmpExecutable(input, dependencies = {}) {
+  const resolution = resolveHarnessExecutable(ompDiscoverySpec, {
+    ...input.command ? { command: input.command } : {},
+    environment: input.environment,
+    ...dependencies.platform ? { platform: dependencies.platform } : {},
+    ...dependencies.homeDirectory ? { homeDirectory: dependencies.homeDirectory } : {}
+  }, { ...dependencies.isExecutable ? { isExecutable: dependencies.isExecutable } : {} });
+  return resolution?.executable ?? input.command ?? input.environment.OMP_COMMAND ?? "omp";
+}
+
+// dist/omp-rpc-session.js
+import { spawn, spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import path6 from "node:path";
+
+// dist/omp-slash-commands.js
+var OMP_LIVE_COMMAND_ID_PREFIX = "omp.slash.";
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseOmpAvailableCommands(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((entry) => {
+    if (!isRecord6(entry))
+      return [];
+    const name = typeof entry.name === "string" ? entry.name.trim().replace(/^\//u, "") : "";
+    if (!name)
+      return [];
+    return [
+      {
+        name,
+        description: typeof entry.description === "string" ? entry.description : "",
+        source: typeof entry.source === "string" ? entry.source : null
       }
-    };
-    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);
-          }
-        }
+    ];
+  });
+}
+function ompLiveCommands(native) {
+  return native.filter(({ source, name }) => source !== "builtin" || name === "context").map((command) => ({
+    name: command.name,
+    description: command.description,
+    kind: command.source === "skill" ? "skill" : "command"
+  }));
+}
+
+// dist/omp-session-file.js
+import { createReadStream as createReadStream3 } from "node:fs";
+import { open, realpath as realpath2 } from "node:fs/promises";
+import readline from "node:readline";
+var MAX_SESSION_HEADER_BYTES = 64 * 1024;
+var utf8Decoder = new TextDecoder("utf-8", { fatal: true });
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function historyEntry(value) {
+  if (!isRecord7(value) || value.type === "title" || value.type === "session" || typeof value.id !== "string" || value.id.length === 0 || value.parentId !== null && typeof value.parentId !== "string" || typeof value.type !== "string") {
+    return null;
+  }
+  return value;
+}
+async function readOmpSessionHistory(sessionFile, maxBytes) {
+  const entries = [];
+  let leafId = null;
+  let incomplete = false;
+  const lines = readline.createInterface({
+    input: createReadStream3(sessionFile, {
+      encoding: "utf8",
+      ...maxBytes === void 0 ? {} : { end: maxBytes - 1 }
+    }),
+    crlfDelay: Number.POSITIVE_INFINITY
+  });
+  try {
+    for await (const line of lines) {
+      if (line.length === 0)
+        continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        incomplete = true;
+        continue;
       }
-      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;
+      const entry = historyEntry(parsed);
+      if (!entry) {
+        if (!isRecord7(parsed) || parsed.type !== "title" && parsed.type !== "session") {
+          incomplete = true;
         }
+        continue;
       }
+      entries.push(entry);
+      leafId = entry.id;
     }
+  } finally {
+    lines.close();
   }
-  addToPath(path9, added, removed, oldPosInc, options) {
-    const last = path9.lastComponent;
-    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
-      return {
-        oldPos: path9.oldPos + oldPosInc,
-        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
-      };
-    } else {
-      return {
-        oldPos: path9.oldPos + oldPosInc,
-        lastComponent: { count: 1, added, removed, previousComponent: last }
-      };
+  return { entries, leafId, ...incomplete ? { incomplete: true } : {} };
+}
+async function readOmpSessionHeader(sessionFile) {
+  const handle = await open(sessionFile, "r");
+  try {
+    const buffer = Buffer.allocUnsafe(MAX_SESSION_HEADER_BYTES);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    const contents = buffer.subarray(0, bytesRead);
+    const newline = contents.indexOf(10);
+    if (newline < 0 && bytesRead === buffer.length) {
+      throw new Error("Omp Session header exceeds the supported size");
     }
-  }
-  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 };
+    const contentsText = utf8Decoder.decode(contents);
+    for (const line of contentsText.split("\n")) {
+      if (line.length === 0)
+        continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!isRecord7(parsed) || parsed.type !== "session")
+        continue;
+      if (typeof parsed.id !== "string" || parsed.id.length === 0 || typeof parsed.cwd !== "string" || parsed.cwd.length === 0) {
+        throw new Error("Omp Session header is invalid");
       }
+      return { type: "session", id: parsed.id, cwd: parsed.cwd };
     }
-    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("");
+    throw new Error("Omp Session header is invalid");
+  } finally {
+    await handle.close();
   }
-  postProcess(changeObjects, options) {
-    return changeObjects;
+}
+async function verifyOmpSessionCwd(input) {
+  if (!input.sessionFile)
+    throw new Error("Omp Fork Session has no persisted Session file");
+  const header = await readOmpSessionHeader(input.sessionFile);
+  if (header.id !== input.sessionId) {
+    throw new Error("Omp Fork Session header identity does not match RPC state");
   }
-  get useLongestToken() {
-    return false;
+  const [actualCwd, expectedCwd] = await Promise.all([
+    realpath2(header.cwd),
+    realpath2(input.expectedCwd)
+  ]);
+  if (actualCwd !== expectedCwd) {
+    throw new Error("Omp Fork Session did not bind the requested cwd");
   }
-  buildValues(lastComponent, newTokens, oldTokens) {
-    const components = [];
-    let nextComponent;
-    while (lastComponent) {
-      components.push(lastComponent);
-      nextComponent = lastComponent.previousComponent;
-      delete lastComponent.previousComponent;
-      lastComponent = nextComponent;
+}
+
+// dist/omp-protocol.js
+var MAX_FRAME_BYTES = 1024 * 1024;
+var MAX_REASSEMBLED_BYTES = 64 * 1024 * 1024;
+var MAX_CHUNK_BYTES = 256 * 1024;
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var OmpFrameDecoder = class {
+  #pending = null;
+  push(value) {
+    if (!isObject2(value))
+      throw new Error("OMP RPC frame must be a JSON object");
+    if (value.type !== "rpc_chunk") {
+      if (this.#pending)
+        throw new Error("OMP RPC chunk sequence was interrupted");
+      return value;
     }
-    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;
-      }
+    const chunkId = value.chunkId;
+    const index = value.index;
+    const count2 = value.count;
+    const byteLength = value.byteLength;
+    const data = value.data;
+    if (typeof chunkId !== "string" || chunkId.length === 0 || chunkId.length > 128 || !Number.isInteger(index) || !Number.isInteger(count2) || !Number.isInteger(byteLength) || index < 0 || count2 < 2 || index >= count2 || byteLength < MAX_FRAME_BYTES || byteLength > MAX_REASSEMBLED_BYTES || typeof data !== "string" || data.length === 0)
+      throw new Error("Invalid OMP RPC chunk metadata");
+    let bytes;
+    try {
+      bytes = Buffer.from(data, "base64");
+    } catch {
+      throw new Error("Invalid OMP RPC chunk data");
     }
-    return components;
+    if (bytes.length === 0 || bytes.length > MAX_CHUNK_BYTES || bytes.toString("base64") !== data) {
+      throw new Error("Invalid OMP RPC chunk data");
+    }
+    const chunkIndex = index;
+    const chunkCount = count2;
+    const declaredByteLength = byteLength;
+    if (!this.#pending) {
+      if (chunkIndex !== 0)
+        throw new Error("OMP RPC chunk sequence must start at index 0");
+      this.#pending = {
+        chunkId,
+        count: chunkCount,
+        byteLength: declaredByteLength,
+        nextIndex: 0,
+        chunks: [],
+        received: 0
+      };
+    }
+    const pending = this.#pending;
+    if (!pending)
+      throw new Error("OMP RPC chunk state was lost");
+    if (pending.chunkId !== chunkId || pending.count !== chunkCount || pending.byteLength !== declaredByteLength || pending.nextIndex !== chunkIndex) {
+      throw new Error("OMP RPC chunk sequence mismatch");
+    }
+    pending.chunks.push(bytes);
+    pending.received += bytes.length;
+    pending.nextIndex += 1;
+    if (pending.received > pending.byteLength)
+      throw new Error("OMP RPC chunk sequence exceeds its declared length");
+    if (pending.nextIndex < pending.count)
+      return null;
+    if (pending.received !== pending.byteLength)
+      throw new Error("OMP RPC chunk sequence length mismatch");
+    this.#pending = null;
+    let decoded;
+    try {
+      decoded = JSON.parse(Buffer.concat(pending.chunks).toString("utf8"));
+    } catch {
+      throw new Error("Failed to decode reassembled OMP RPC frame");
+    }
+    if (!isObject2(decoded))
+      throw new Error("Reassembled OMP RPC frame must be an object");
+    return decoded;
   }
 };
 
-// ../../../node_modules/diff/libesm/diff/line.js
-var LineDiff = class extends Diff {
-  constructor() {
-    super(...arguments);
-    this.tokenize = tokenize;
+// dist/omp-rpc-session.js
+var OmpRpcFaultError = class extends Error {
+  kind;
+  diagnostic;
+  constructor(kind, message3, diagnostic) {
+    super(message3);
+    this.kind = kind;
+    this.diagnostic = diagnostic;
+    this.name = "OmpRpcFaultError";
   }
-  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 OmpRpcUnsupportedCommandError = class extends Error {
+  command;
+  constructor(command) {
+    super(`Omp RPC does not support '${command}'`);
+    this.command = command;
+    this.name = "OmpRpcUnsupportedCommandError";
   }
 };
-var lineDiff = new LineDiff();
-function diffLines(oldStr, newStr, options) {
-  return lineDiff.diff(oldStr, newStr, options);
+var textDecoder = new TextDecoder("utf-8", { fatal: true });
+function isRecord8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function tokenize(value, options) {
-  if (options.stripTrailingCr) {
-    value = value.replace(/\r\n/g, "\n");
+function message2(value) {
+  return value instanceof Error ? value.message : String(value);
+}
+function nonBlankString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function parseNativeModel(value, context) {
+  if (value === null || value === void 0)
+    return null;
+  if (!isRecord8(value) || !nonBlankString(value.provider) || !nonBlankString(value.id)) {
+    throw new OmpRpcFaultError("protocolError", `Omp RPC returned an invalid ${context} Model`);
   }
-  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
-  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
-    linesAndNewlines.pop();
+  return { provider: value.provider, id: value.id };
+}
+function sessionStateData(response) {
+  const data = isRecord8(response.data) ? response.data : null;
+  if (!data)
+    throw new OmpRpcFaultError("protocolError", "Omp RPC state response has no data");
+  return data;
+}
+function parseSessionState(response) {
+  const data = sessionStateData(response);
+  const model2 = parseNativeModel(data.model, "state");
+  if (!nonBlankString(data.sessionId)) {
+    throw new OmpRpcFaultError("protocolError", "Omp RPC state has no stable Session identity");
   }
-  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);
-    }
+  const thinkingLevel = data.thinkingLevel === void 0 ? null : harnessThinkingOptionIdSchema.safeParse(data.thinkingLevel);
+  if (thinkingLevel !== null && !thinkingLevel.success) {
+    throw new OmpRpcFaultError("protocolError", "Omp RPC state has an invalid Thinking level");
   }
-  return retLines;
+  const thinking = isRecord8(data.model) && isRecord8(data.model.thinking) ? data.model.thinking : null;
+  const availableThinkingLevels = thinking && Array.isArray(thinking.efforts) ? thinking.efforts.flatMap((level) => {
+    const parsed = harnessThinkingOptionIdSchema.safeParse(level);
+    return parsed.success ? [parsed.data] : [];
+  }) : null;
+  return {
+    sessionId: data.sessionId,
+    sessionFile: typeof data.sessionFile === "string" ? data.sessionFile : null,
+    provider: model2?.provider ?? null,
+    modelId: model2?.id ?? null,
+    thinkingLevel: thinkingLevel?.data ?? null,
+    contextUsage: optionalOmpStateContextUsage(data.contextUsage),
+    availableThinkingLevels
+  };
 }
-
-// ../../../node_modules/diff/libesm/patch/parse.js
-function parsePatch(uniDiff) {
-  const diffstr = uniDiff.split(/\n/), list = [];
-  let i = 0;
-  function parseIndex() {
-    const index = {};
-    list.push(index);
-    while (i < diffstr.length) {
-      const line = diffstr[i];
-      if (/^(---|\+\+\+|@@)\s/.test(line)) {
-        break;
-      }
-      const header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line);
-      if (header) {
-        index.index = header[1];
-      }
-      i++;
-    }
-    parseFileHeader(index);
-    parseFileHeader(index);
-    index.hunks = [];
-    while (i < diffstr.length) {
-      const line = diffstr[i];
-      if (/^(Index:\s|diff\s|---\s|\+\+\+\s|===================================================================)/.test(line)) {
-        break;
-      } else if (/^@@/.test(line)) {
-        index.hunks.push(parseHunk());
-      } else if (line) {
-        throw new Error("Unknown line " + (i + 1) + " " + JSON.stringify(line));
-      } else {
-        i++;
-      }
-    }
+function parseSessionStreaming(response) {
+  const isStreaming = sessionStateData(response).isStreaming;
+  if (typeof isStreaming !== "boolean") {
+    throw new OmpRpcFaultError("protocolError", "Omp RPC state has no Streaming status");
   }
-  function parseFileHeader(index) {
-    const fileHeader = /^(---|\+\+\+)\s+(.*)\r?$/.exec(diffstr[i]);
-    if (fileHeader) {
-      const data = fileHeader[2].split("	", 2), header = (data[1] || "").trim();
-      let fileName = data[0].replace(/\\\\/g, "\\");
-      if (/^".*"$/.test(fileName)) {
-        fileName = fileName.substr(1, fileName.length - 2);
-      }
-      if (fileHeader[1] === "---") {
-        index.oldFileName = fileName;
-        index.oldHeader = header;
-      } else {
-        index.newFileName = fileName;
-        index.newHeader = header;
-      }
-      i++;
-    }
+  return isStreaming;
+}
+function cancellationSettled(response, terminalEnd) {
+  const data = sessionStateData(response);
+  return !parseSessionStreaming(response) && (data.isSettled === true || data.isSettled === void 0 && terminalEnd) && data.isCompacting !== true && data.hasPendingAsyncWork !== true && !(typeof data.queuedMessageCount === "number" && data.queuedMessageCount > 0);
+}
+function parseAvailableModels(response) {
+  const data = isRecord8(response.data) ? response.data : null;
+  if (!data || !Array.isArray(data.models)) {
+    throw new OmpRpcFaultError("protocolError", "Omp RPC Model catalog response has no models");
   }
-  function parseHunk() {
-    var _a3;
-    const chunkHeaderIndex = i, chunkHeaderLine = diffstr[i++], chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
-    const hunk = {
-      oldStart: +chunkHeader[1],
-      oldLines: typeof chunkHeader[2] === "undefined" ? 1 : +chunkHeader[2],
-      newStart: +chunkHeader[3],
-      newLines: typeof chunkHeader[4] === "undefined" ? 1 : +chunkHeader[4],
-      lines: []
-    };
-    if (hunk.oldLines === 0) {
-      hunk.oldStart += 1;
-    }
-    if (hunk.newLines === 0) {
-      hunk.newStart += 1;
-    }
-    let addCount = 0, removeCount = 0;
-    for (; i < diffstr.length && (removeCount < hunk.oldLines || addCount < hunk.newLines || ((_a3 = diffstr[i]) === null || _a3 === void 0 ? void 0 : _a3.startsWith("\\"))); i++) {
-      const operation = diffstr[i].length == 0 && i != diffstr.length - 1 ? " " : diffstr[i][0];
-      if (operation === "+" || operation === "-" || operation === " " || operation === "\\") {
-        hunk.lines.push(diffstr[i]);
-        if (operation === "+") {
-          addCount++;
-        } else if (operation === "-") {
-          removeCount++;
-        } else if (operation === " ") {
-          addCount++;
-          removeCount++;
-        }
-      } else {
-        throw new Error(`Hunk at line ${chunkHeaderIndex + 1} contained invalid line ${diffstr[i]}`);
-      }
-    }
-    if (!addCount && hunk.newLines === 1) {
-      hunk.newLines = 0;
-    }
-    if (!removeCount && hunk.oldLines === 1) {
-      hunk.oldLines = 0;
-    }
-    if (addCount !== hunk.newLines) {
-      throw new Error("Added line count did not match for hunk at line " + (chunkHeaderIndex + 1));
-    }
-    if (removeCount !== hunk.oldLines) {
-      throw new Error("Removed line count did not match for hunk at line " + (chunkHeaderIndex + 1));
+  return data.models.map((model2) => {
+    const parsed = parseNativeModel(model2, "catalog");
+    if (!parsed || !isRecord8(model2) || typeof model2.reasoning !== "boolean") {
+      throw new OmpRpcFaultError("protocolError", "Omp RPC catalog contains a Model without reasoning capability");
     }
-    return hunk;
+    return { ...parsed, reasoning: model2.reasoning };
+  });
+}
+function parseSubagentMessages(response) {
+  const data = isRecord8(response.data) ? response.data : null;
+  if (!data || !nonBlankString(data.sessionFile) || !Number.isSafeInteger(data.fromByte) || !Number.isSafeInteger(data.nextByte) || data.fromByte < 0 || data.nextByte < data.fromByte || typeof data.reset !== "boolean" || !Array.isArray(data.entries) || !Array.isArray(data.messages)) {
+    throw new OmpRpcFaultError("protocolError", "Omp RPC Subagent transcript response is invalid");
   }
-  while (i < diffstr.length) {
-    parseIndex();
+  const entries = data.entries.flatMap((value) => isRecord8(value) ? [value] : []);
+  const messages = data.messages.flatMap((value) => isRecord8(value) ? [value] : []);
+  if (entries.length !== data.entries.length || messages.length !== data.messages.length) {
+    throw new OmpRpcFaultError("protocolError", "Omp RPC Subagent transcript contains invalid data");
   }
-  return list;
+  return {
+    sessionFile: data.sessionFile,
+    fromByte: data.fromByte,
+    nextByte: data.nextByte,
+    reset: data.reset,
+    entries,
+    messages
+  };
 }
-
-// ../../../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;
+function subagentStatus(value) {
+  if (value === "pending" || value === "running" || value === "completed")
+    return value;
+  if (value === "failed" || value === "aborted" || value === "interrupted")
+    return "failed";
+  throw new OmpRpcFaultError("protocolError", "Omp RPC Subagent status is invalid");
+}
+function assistantText(value) {
+  if (!isRecord8(value) || value.role !== "assistant" || !Array.isArray(value.content))
+    return null;
+  return value.content.filter((content) => isRecord8(content) && content.type === "text" && typeof content.text === "string").map((content) => content.text).join("");
+}
+function assistantMessageId(value) {
+  if (!isRecord8(value) || value.role !== "assistant")
+    return null;
+  return nonBlankString(value.responseId) ? value.responseId : null;
+}
+function extractReasoningText(content) {
+  if (!isRecord8(content))
+    return null;
+  const type = String(content.type ?? "");
+  if (type === "thinking" || type === "reasoning" || type === "thought") {
+    const text = content.thinking ?? content.reasoning ?? content.text ?? content.delta;
+    return typeof text === "string" ? text : null;
   }
-  if (typeof optionsObj.context === "undefined") {
-    optionsObj.context = 4;
+  return null;
+}
+function assistantReasoning(value) {
+  if (!isRecord8(value) || value.role !== "assistant" || !Array.isArray(value.content))
+    return null;
+  return value.content.map(extractReasoningText).filter((text) => typeof text === "string").join("");
+}
+function assistantFailure(value) {
+  if (!isRecord8(value) || value.role !== "assistant")
+    return void 0;
+  if (value.stopReason !== "error" && value.stopReason !== "aborted")
+    return null;
+  const fallback = value.stopReason === "aborted" ? "Omp assistant message was aborted" : "Omp assistant message failed";
+  return new Error(nonBlankString(value.errorMessage) ? value.errorMessage : fallback);
+}
+function signalProcessTree(child, signal) {
+  if (!child.pid)
+    return;
+  if (process.platform === "win32") {
+    spawnSync("taskkill.exe", ["/pid", String(child.pid), "/t", "/f"], {
+      stdio: "ignore",
+      windowsHide: true
+    });
+    return;
   }
-  const context = optionsObj.context;
-  if (optionsObj.newlineIsToken) {
-    throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
+  try {
+    process.kill(-child.pid, signal);
+  } catch (error51) {
+    if (!isRecord8(error51) || error51.code !== "ESRCH")
+      throw error51;
   }
-  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 waitForExit(child, timeoutMs) {
+  if (child.exitCode !== null || child.signalCode !== null)
+    return Promise.resolve(true);
+  return Promise.race([
+    new Promise((resolve) => child.once("exit", () => resolve(true))),
+    new Promise((resolve) => setTimeout(() => resolve(false), timeoutMs))
+  ]);
+}
+function ompRpcProcessCommand(options, dependencies = {}) {
+  if (options.sessionFile && options.forkSessionFile) {
+    throw new Error("Omp RPC cannot combine Session resume and Fork startup");
   }
-  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;
-      }
+  if (options.model && (options.sessionFile || options.forkSessionFile)) {
+    throw new Error("Omp RPC cannot combine a startup Model with Session restore or Fork");
+  }
+  const platform = dependencies.platform ?? process.platform;
+  const command = resolveOmpExecutable({
+    ...options.command ? { command: options.command } : {},
+    environment: options.environment
+  }, {
+    platform,
+    ...dependencies.homeDirectory ? { homeDirectory: dependencies.homeDirectory } : {},
+    ...dependencies.isExecutable ? { isExecutable: dependencies.isExecutable } : {}
+  });
+  const sessionArguments = options.forkSessionFile ? ["--fork", options.forkSessionFile] : options.sessionFile ? ["--resume", options.sessionFile] : [];
+  const modelArguments = options.model ? ["--provider", options.model.provider, "--model", options.model.id] : [];
+  const permissionArguments = options.permissionMode ? ["--approval-mode", options.permissionMode] : [];
+  const arguments_ = [
+    "--mode",
+    // OMP only creates ask and connects its tool UI in rpc-ui mode.
+    "rpc-ui",
+    ...permissionArguments,
+    ...modelArguments,
+    ...sessionArguments
+  ];
+  const extension = path6.win32.extname(command).toLowerCase();
+  if (platform !== "win32" || ![".cmd", ".bat"].includes(extension)) {
+    return { command, arguments: arguments_, windowsVerbatimArguments: false };
+  }
+  const quote = (value) => `"${value.replaceAll("%", "%%").replaceAll('"', '""')}"`;
+  const commandLine = [command, ...arguments_].map(quote).join(" ");
+  return {
+    command: options.environment?.ComSpec ?? options.environment?.COMSPEC ?? "cmd.exe",
+    arguments: ["/d", "/v:off", "/s", "/c", `"${commandLine}"`],
+    windowsVerbatimArguments: true
+  };
+}
+var nodeProcessAdapter = {
+  spawn(options) {
+    const invocation = ompRpcProcessCommand(options);
+    return spawn(invocation.command, invocation.arguments, {
+      cwd: options.cwd,
+      env: options.environment,
+      detached: process.platform !== "win32",
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true,
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments
+    });
+  }
+};
+var OmpRpcSession = class {
+  #options;
+  #processAdapter;
+  #activeTurn = null;
+  #buffer = Buffer.alloc(0);
+  #child = null;
+  #closed = false;
+  #closePromise = null;
+  #compactionActive = false;
+  #compactionTurn = null;
+  #compactionTimeout = null;
+  #failed = false;
+  #pending = /* @__PURE__ */ new Map();
+  #state = null;
+  #availableCommands = null;
+  #latestCacheHitRatePercent;
+  #manualCompaction = null;
+  #usageRequestStartedAtMs = null;
+  #stderrTail = "";
+  #frameDecoder = new OmpFrameDecoder();
+  #startupFaultResolve = null;
+  #startupFault = new Promise((resolve) => {
+    this.#startupFaultResolve = resolve;
+  });
+  #readyResolve = null;
+  #ready = new Promise((resolve) => {
+    this.#readyResolve = resolve;
+  });
+  constructor(options, processAdapter = nodeProcessAdapter) {
+    if (options.sessionFile && options.forkSessionFile) {
+      throw new Error("Omp RPC cannot combine Session resume and Fork startup");
     }
-    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++;
-        }
-      }
+    if (options.model && (options.sessionFile || options.forkSessionFile)) {
+      throw new Error("Omp RPC cannot combine a startup Model with Session restore or Fork");
     }
-    return {
-      oldFileName,
-      newFileName,
-      oldHeader,
-      newHeader,
-      hunks
+    this.#options = {
+      commandTimeoutMs: 3e4,
+      compactionTimeoutMs: 3e5,
+      // Native Abort waits for tools, persistence and deferred work to unwind.
+      // Stable cancellation must outlast the Host's 20s steering wait.
+      cancelTimeoutMs: 3e4,
+      closeTimeoutMs: 2e3,
+      ...options
     };
+    this.#processAdapter = processAdapter;
   }
-}
-function formatPatch(patch) {
-  if (Array.isArray(patch)) {
-    return patch.map(formatPatch).join("\n");
+  get state() {
+    if (!this.#state)
+      throw new Error("Omp RPC Session has not started");
+    return this.#state;
   }
-  const ret = [];
-  if (patch.oldFileName == patch.newFileName) {
-    ret.push("Index: " + patch.oldFileName);
+  get stderrTail() {
+    return this.#stderrTail;
   }
-  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;
+  async start() {
+    if (this.#child || this.#closed)
+      throw new Error("Omp RPC Session cannot be started twice");
+    const child = this.#processAdapter.spawn({
+      cwd: this.#options.cwd,
+      ...this.#options.command ? { command: this.#options.command } : {},
+      environment: withNodeRuntimeOnPath({
+        ...process.env,
+        ...this.#options.environment,
+        OMP_SKIP_VERSION_CHECK: "1",
+        OMP_TELEMETRY: "0"
+      }),
+      ...this.#options.sessionFile ? { sessionFile: this.#options.sessionFile } : {},
+      ...this.#options.forkSessionFile ? { forkSessionFile: this.#options.forkSessionFile } : {},
+      ...this.#options.model ? { model: this.#options.model } : {},
+      ...this.#options.permissionMode ? { permissionMode: this.#options.permissionMode } : {}
+    });
+    this.#child = child;
+    child.stdout.on("data", (chunk) => this.#push(chunk));
+    child.stdout.on("end", () => {
+      if (this.#buffer.length !== 0) {
+        this.#fail(new OmpRpcFaultError("protocolError", "Omp RPC stdout ended mid-frame"));
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      this.#stderrTail = sanitizeDiagnosticTail(`${this.#stderrTail}${chunk.toString()}`);
+    });
+    child.once("error", (error51) => {
+      const kind = isRecord8(error51) && error51.code === "ENOENT" ? "notInstalled" : "unavailable";
+      this.#fail(new OmpRpcFaultError(kind, `Omp RPC failed to start: ${error51.message}`, this.stderrTail));
+    });
+    child.once("exit", (code, signal) => {
+      if (!this.#closed) {
+        this.#fail(new OmpRpcFaultError("processExited", `Omp RPC exited (code=${code}, signal=${signal})`, this.stderrTail));
+      }
+    });
+    await Promise.race([
+      new Promise((resolve, reject) => {
+        child.once("spawn", resolve);
+        child.once("error", reject);
+      }),
+      new Promise((_resolve, reject) => setTimeout(() => reject(new Error("Omp RPC start timed out")), this.#options.commandTimeoutMs))
+    ]);
+    let readyTimeout;
+    try {
+      await Promise.race([
+        this.#ready,
+        this.#startupFault.then((error51) => {
+          throw error51;
+        }),
+        new Promise((_resolve, reject) => {
+          readyTimeout = setTimeout(() => reject(new Error("Omp RPC ready signal timed out")), this.#options.commandTimeoutMs);
+        })
+      ]);
+    } finally {
+      clearTimeout(readyTimeout);
     }
-    ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@");
-    for (const line of hunk.lines) {
-      ret.push(line);
+    await this.#send("negotiate_protocol", { protocolVersion: 2 }).catch(() => void 0);
+    if (this.#options.subscribeSubagentEvents !== false) {
+      await this.#send("set_subagent_subscription", { level: "events" }).catch(() => void 0);
     }
-  }
-  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;
+    try {
+      this.#state = parseSessionState(await this.#send("get_state", {}));
+    } catch (error51) {
+      const fault = error51 instanceof OmpRpcFaultError ? error51 : new OmpRpcFaultError("unavailable", `Omp RPC state unavailable: ${message2(error51)}`);
+      this.#fail(fault);
+      throw fault;
     }
-    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(text) {
-  const hasTrailingNl = text.endsWith("\n");
-  const result = text.split("\n").map((line) => line + "\n");
-  if (hasTrailingNl) {
-    result.pop();
-  } else {
-    result.push(result.pop().slice(0, -1));
+    return this;
   }
-  return result;
-}
-
-// dist/omp-adapter.js
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { realpath as realpath3, stat as stat2 } from "node:fs/promises";
-import path7 from "node:path";
-
-// dist/omp-slash-commands.js
-var OMP_LIVE_COMMAND_ID_PREFIX = "omp.slash.";
-function isRecord6(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function parseOmpAvailableCommands(value) {
-  if (!Array.isArray(value))
-    return [];
-  return value.flatMap((entry) => {
-    if (!isRecord6(entry))
-      return [];
-    const name = typeof entry.name === "string" ? entry.name.trim().replace(/^\//u, "") : "";
-    if (!name)
-      return [];
-    return [
-      {
-        name,
-        description: typeof entry.description === "string" ? entry.description : "",
-        source: typeof entry.source === "string" ? entry.source : null
+  async getEntries() {
+    try {
+      if (this.state.sessionFile) {
+        try {
+          return await readOmpSessionHistory(this.state.sessionFile);
+        } catch (error51) {
+          if (!isRecord8(error51) || error51.code !== "ENOENT" || this.#options.sessionFile || this.#options.forkSessionFile)
+            throw error51;
+          const response2 = await this.#send("get_messages", {});
+          const data2 = isRecord8(response2.data) ? response2.data : null;
+          if (data2 && Array.isArray(data2.messages) && data2.messages.length === 0) {
+            return { entries: [], leafId: null };
+          }
+          throw error51;
+        }
       }
-    ];
-  });
-}
-function ompLiveCommands(native) {
-  return native.filter(({ source, name }) => source !== "builtin" || name === "context").map((command) => ({
-    name: command.name,
-    description: command.description,
-    kind: command.source === "skill" ? "skill" : "command"
-  }));
-}
-
-// dist/omp-session-file.js
-import { createReadStream as createReadStream3 } from "node:fs";
-import { open, realpath as realpath2 } from "node:fs/promises";
-import readline from "node:readline";
-var MAX_SESSION_HEADER_BYTES = 64 * 1024;
-var utf8Decoder = new TextDecoder("utf-8", { fatal: true });
-function isRecord7(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function historyEntry(value) {
-  if (!isRecord7(value) || value.type === "title" || value.type === "session" || typeof value.id !== "string" || value.id.length === 0 || value.parentId !== null && typeof value.parentId !== "string" || typeof value.type !== "string") {
-    return null;
-  }
-  return value;
-}
-async function readOmpSessionHistory(sessionFile, maxBytes) {
-  const entries = [];
-  let leafId = null;
-  let incomplete = false;
-  const lines = readline.createInterface({
-    input: createReadStream3(sessionFile, {
-      encoding: "utf8",
-      ...maxBytes === void 0 ? {} : { end: maxBytes - 1 }
-    }),
-    crlfDelay: Number.POSITIVE_INFINITY
-  });
-  try {
-    for await (const line of lines) {
-      if (line.length === 0)
-        continue;
-      let parsed;
-      try {
-        parsed = JSON.parse(line);
-      } catch {
-        incomplete = true;
-        continue;
+      const response = await this.#send("get_messages", {});
+      const data = isRecord8(response.data) ? response.data : null;
+      if (!data || !Array.isArray(data.messages)) {
+        throw new OmpRpcFaultError("protocolError", "Omp RPC messages response has no messages");
       }
-      const entry = historyEntry(parsed);
-      if (!entry) {
-        if (!isRecord7(parsed) || parsed.type !== "title" && parsed.type !== "session") {
-          incomplete = true;
+      let branchEntryIds = null;
+      try {
+        const branchResponse = await this.#send("get_branch_messages", {});
+        const branchData = isRecord8(branchResponse.data) ? branchResponse.data : null;
+        if (branchData && Array.isArray(branchData.messages)) {
+          const parsed = branchData.messages.flatMap((entry) => {
+            if (!isRecord8(entry) || !nonBlankString(entry.entryId))
+              return [];
+            return [entry.entryId];
+          });
+          if (parsed.length === branchData.messages.length)
+            branchEntryIds = parsed;
         }
-        continue;
+      } catch (error51) {
+        if (!(error51 instanceof OmpRpcUnsupportedCommandError))
+          throw error51;
       }
-      entries.push(entry);
-      leafId = entry.id;
+      let userIndex = 0;
+      let parentId = null;
+      const entries = data.messages.map((nativeMessage, index) => {
+        const role = isRecord8(nativeMessage) ? nativeMessage.role : void 0;
+        const branchId = role === "user" ? branchEntryIds?.[userIndex] : void 0;
+        if (branchId)
+          userIndex += 1;
+        const id = branchId ?? (isRecord8(nativeMessage) && nonBlankString(nativeMessage.id) ? nativeMessage.id : `omp-message-${index}`);
+        const entry = { id, parentId, type: "message", message: nativeMessage };
+        parentId = id;
+        return entry;
+      });
+      return { entries, leafId: parentId };
+    } catch (error51) {
+      if (error51 instanceof OmpRpcFaultError)
+        this.#fail(error51);
+      throw error51;
     }
-  } finally {
-    lines.close();
   }
-  return { entries, leafId, ...incomplete ? { incomplete: true } : {} };
-}
-async function readOmpSessionHeader(sessionFile) {
-  const handle = await open(sessionFile, "r");
-  try {
-    const buffer = Buffer.allocUnsafe(MAX_SESSION_HEADER_BYTES);
-    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
-    const contents = buffer.subarray(0, bytesRead);
-    const newline = contents.indexOf(10);
-    if (newline < 0 && bytesRead === buffer.length) {
-      throw new Error("Omp Session header exceeds the supported size");
+  async getSubagentMessages(input) {
+    if ((input.subagentId === void 0 || !nonBlankString(input.subagentId)) && (input.sessionFile === void 0 || !nonBlankString(input.sessionFile))) {
+      throw new Error("Omp Subagent transcript requires a Subagent ID or Session file");
     }
-    const contentsText = utf8Decoder.decode(contents);
-    for (const line of contentsText.split("\n")) {
-      if (line.length === 0)
-        continue;
-      let parsed;
-      try {
-        parsed = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      if (!isRecord7(parsed) || parsed.type !== "session")
-        continue;
-      if (typeof parsed.id !== "string" || parsed.id.length === 0 || typeof parsed.cwd !== "string" || parsed.cwd.length === 0) {
-        throw new Error("Omp Session header is invalid");
-      }
-      return { type: "session", id: parsed.id, cwd: parsed.cwd };
+    if (input.fromByte !== void 0 && (!Number.isSafeInteger(input.fromByte) || input.fromByte < 0)) {
+      throw new Error("Omp Subagent transcript offset is invalid");
     }
-    throw new Error("Omp Session header is invalid");
-  } finally {
-    await handle.close();
+    const response = await this.#send("get_subagent_messages", {
+      ...input.subagentId ? { subagentId: input.subagentId } : {},
+      ...input.sessionFile ? { sessionFile: input.sessionFile } : {},
+      ...input.fromByte !== void 0 ? { fromByte: input.fromByte } : {}
+    });
+    return parseSubagentMessages(response);
   }
-}
-async function verifyOmpSessionCwd(input) {
-  if (!input.sessionFile)
-    throw new Error("Omp Fork Session has no persisted Session file");
-  const header = await readOmpSessionHeader(input.sessionFile);
-  if (header.id !== input.sessionId) {
-    throw new Error("Omp Fork Session header identity does not match RPC state");
+  async compact(customInstructions, onEvent) {
+    if (!this.#child || !this.#state || this.#closed || this.#failed) {
+      throw new Error("Omp RPC Session is unavailable");
+    }
+    if (this.#activeTurn || this.#manualCompaction || this.#compactionActive) {
+      throw new Error("Omp RPC Session already has an active operation");
+    }
+    const result = new Promise((resolve, reject) => {
+      this.#manualCompaction = { onEvent, resolve, reject };
+    });
+    try {
+      await this.#send("compact", customInstructions ? { customInstructions } : {});
+    } catch (error51) {
+      const pending = this.#manualCompaction;
+      this.#manualCompaction = null;
+      pending?.reject(error51 instanceof Error ? error51 : new Error(message2(error51)));
+    }
+    return result;
   }
-  const [actualCwd, expectedCwd] = await Promise.all([
-    realpath2(header.cwd),
-    realpath2(input.expectedCwd)
-  ]);
-  if (actualCwd !== expectedCwd) {
-    throw new Error("Omp Fork Session did not bind the requested cwd");
+  async getSessionUsage() {
+    try {
+      const usage = parseOmpSessionUsage(await this.#send("get_session_stats", {}));
+      await this.#ensureLatestCacheHitRate();
+      return this.#withLatestCacheHitRate(usage);
+    } catch (error51) {
+      if (!(error51 instanceof OmpRpcUnsupportedCommandError))
+        throw error51;
+      const response = await this.#send("get_state", {});
+      const observedState = parseSessionState(response);
+      if (!this.#state || observedState.sessionId !== this.#state.sessionId || observedState.provider !== this.#state.provider || observedState.modelId !== this.#state.modelId) {
+        throw new Error("Omp RPC Usage fallback does not match the confirmed Session state");
+      }
+      await this.#ensureLatestCacheHitRate();
+      const usage = parseOmpStateContextUsage(response);
+      return usage ? this.#withLatestCacheHitRate(usage) : null;
+    }
   }
-}
-
-// dist/omp-last-turn-rollback.js
-function modelFromState(state) {
-  if (state.provider === null && state.modelId === null)
-    return null;
-  if (state.provider === null || state.modelId === null) {
-    throw new Error("Omp state contains a partial Model identity");
+  async #ensureLatestCacheHitRate() {
+    if (this.#latestCacheHitRatePercent !== void 0)
+      return;
+    try {
+      this.#latestCacheHitRatePercent = latestOmpCacheHitRatePercent(await this.getEntries());
+    } catch {
+      this.#latestCacheHitRatePercent = null;
+    }
   }
-  return { provider: state.provider, id: state.modelId };
-}
-async function rollbackOmpLastTurn(transport, sourceSessionId, cwd) {
-  const startupState = transport.state;
-  const startupSessionId = startupState.sessionId;
-  const currentModel = modelFromState(startupState);
-  const currentThinking = startupState.thinkingLevel;
-  const copiedHistory = await transport.getEntries();
-  const boundary = resolveOmpLastTurnBoundary(copiedHistory);
-  if (!boundary)
-    return { ok: false, reason: "empty" };
-  const sourceSnapshot = mapOmpSnapshot(copiedHistory, {
-    sessionId: startupSessionId,
-    model: currentModel
-  });
-  let state = await transport.fork(boundary.lastUserEntryId);
-  if (state.sessionId === sourceSessionId || state.sessionId === startupSessionId) {
-    throw new Error("Omp last-Turn rollback did not create a distinct Native Session");
+  #withLatestCacheHitRate(usage) {
+    return this.#latestCacheHitRatePercent === null || this.#latestCacheHitRatePercent === void 0 ? usage : parseHostUsage({ ...usage, cacheHitRatePercent: this.#latestCacheHitRatePercent });
   }
-  if (!sameOmpModel(modelFromState(state), currentModel)) {
-    if (!currentModel)
-      throw new Error("Omp last-Turn rollback changed the current Model");
-    state = await transport.selectModel(currentModel);
+  async fork(entryId) {
+    if (!nonBlankString(entryId))
+      throw new Error("Omp RPC Fork requires an Entry identity");
+    try {
+      const response = await this.#send("branch", { entryId });
+      const data = isRecord8(response.data) ? response.data : null;
+      if (!data || data.cancelled === true) {
+        throw new OmpRpcFaultError("unavailable", "Omp RPC Fork was cancelled");
+      }
+      this.#state = parseSessionState(await this.#send("get_state", {}));
+      return this.#state;
+    } catch (error51) {
+      if (error51 instanceof OmpRpcFaultError)
+        this.#fail(error51);
+      throw error51;
+    }
   }
-  if (state.thinkingLevel !== currentThinking) {
-    if (!currentThinking)
-      throw new Error("Omp last-Turn rollback changed current Thinking");
-    state = await transport.selectThinkingOption(currentThinking);
+  verifySessionCwd(expectedCwd) {
+    return verifyOmpSessionCwd({
+      sessionFile: this.state.sessionFile,
+      sessionId: this.state.sessionId,
+      expectedCwd
+    });
   }
-  if (!sameOmpModel(modelFromState(state), currentModel) || state.thinkingLevel !== currentThinking) {
-    throw new Error("Omp last-Turn rollback could not restore current Model and Thinking");
+  async getAvailableModels() {
+    try {
+      return parseAvailableModels(await this.#send("get_available_models", {}));
+    } catch (error51) {
+      if (error51 instanceof OmpRpcFaultError)
+        this.#fail(error51);
+      throw error51;
+    }
   }
-  const snapshot = mapOmpSnapshot(await transport.getEntries(), {
-    sessionId: state.sessionId,
-    model: modelFromState(state)
-  });
-  const expectedTurnKeys = sourceSnapshot.turns.slice(0, -1).map((turn) => turn.nativeTurnRef.nativeTurnKey);
-  const actualTurnKeys = snapshot.turns.map((turn) => turn.nativeTurnRef.nativeTurnKey);
-  if (snapshot.turns.length !== boundary.sourceTurnCount - 1 || actualTurnKeys.some((key, index) => key !== expectedTurnKeys[index])) {
-    throw new Error("Omp last-Turn rollback did not produce the exact retained history prefix");
+  async getAvailableThinkingLevels() {
+    return this.state.availableThinkingLevels;
   }
-  await transport.verifySessionCwd(cwd);
-  return { ok: true };
-}
-
-// dist/omp-rpc-session.js
-import { spawn, spawnSync } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import path6 from "node:path";
-
-// dist/command.js
-var ompDiscoverySpec = {
-  id: "omp",
-  command: "omp",
-  commandEnvironmentVariable: "OMP_COMMAND",
-  installRoots: {
-    posix: [
-      "~/.npm-global/bin",
-      "~/.local/bin",
-      VERSION_MANAGER_ROOTS,
-      "/opt/homebrew/bin",
-      "/usr/local/bin"
-    ],
-    windows: ["${APPDATA}/npm", "~/.local/bin", VERSION_MANAGER_ROOTS]
+  async selectModel(model2) {
+    await this.#send("set_model", { provider: model2.provider, modelId: model2.id });
+    return this.#refreshState("Model");
   }
-};
-function resolveOmpExecutable(input, dependencies = {}) {
-  const resolution = resolveHarnessExecutable(ompDiscoverySpec, {
-    ...input.command ? { command: input.command } : {},
-    environment: input.environment,
-    ...dependencies.platform ? { platform: dependencies.platform } : {},
-    ...dependencies.homeDirectory ? { homeDirectory: dependencies.homeDirectory } : {}
-  }, { ...dependencies.isExecutable ? { isExecutable: dependencies.isExecutable } : {} });
-  return resolution?.executable ?? input.command ?? input.environment.OMP_COMMAND ?? "omp";
-}
-
-// dist/omp-protocol.js
-var MAX_FRAME_BYTES = 1024 * 1024;
-var MAX_REASSEMBLED_BYTES = 64 * 1024 * 1024;
-var MAX_CHUNK_BYTES = 256 * 1024;
-function isObject2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var OmpFrameDecoder = class {
-  #pending = null;
-  push(value) {
-    if (!isObject2(value))
-      throw new Error("OMP RPC frame must be a JSON object");
-    if (value.type !== "rpc_chunk") {
-      if (this.#pending)
-        throw new Error("OMP RPC chunk sequence was interrupted");
-      return value;
-    }
-    const chunkId = value.chunkId;
-    const index = value.index;
-    const count2 = value.count;
-    const byteLength = value.byteLength;
-    const data = value.data;
-    if (typeof chunkId !== "string" || chunkId.length === 0 || chunkId.length > 128 || !Number.isInteger(index) || !Number.isInteger(count2) || !Number.isInteger(byteLength) || index < 0 || count2 < 2 || index >= count2 || byteLength < MAX_FRAME_BYTES || byteLength > MAX_REASSEMBLED_BYTES || typeof data !== "string" || data.length === 0)
-      throw new Error("Invalid OMP RPC chunk metadata");
-    let bytes;
+  async selectThinkingOption(thinkingOptionId) {
+    const level = harnessThinkingOptionIdSchema.parse(thinkingOptionId);
+    await this.#send("set_thinking_level", { level });
+    return this.#refreshState("Thinking");
+  }
+  async #refreshState(operation) {
     try {
-      bytes = Buffer.from(data, "base64");
-    } catch {
-      throw new Error("Invalid OMP RPC chunk data");
+      this.#state = parseSessionState(await this.#send("get_state", {}));
+      return this.#state;
+    } catch (error51) {
+      const fault = error51 instanceof OmpRpcFaultError ? error51 : new OmpRpcFaultError("protocolError", `Omp RPC ${operation} state could not be confirmed: ${message2(error51)}`);
+      this.#fail(fault);
+      throw fault;
     }
-    if (bytes.length === 0 || bytes.length > MAX_CHUNK_BYTES || bytes.toString("base64") !== data) {
-      throw new Error("Invalid OMP RPC chunk data");
+  }
+  async runTurn(text, onEvent) {
+    if (!this.#child || !this.#state || this.#closed || this.#failed) {
+      throw new Error("Omp RPC Session is unavailable");
     }
-    const chunkIndex = index;
-    const chunkCount = count2;
-    const declaredByteLength = byteLength;
-    if (!this.#pending) {
-      if (chunkIndex !== 0)
-        throw new Error("OMP RPC chunk sequence must start at index 0");
-      this.#pending = {
-        chunkId,
-        count: chunkCount,
-        byteLength: declaredByteLength,
-        nextIndex: 0,
-        chunks: [],
-        received: 0
+    if (this.#activeTurn)
+      throw new Error("Omp RPC Session already has an active Turn");
+    if (text.length === 0)
+      throw new Error("Omp text Turn must not be empty");
+    const promptId = `codexhost-${randomUUID()}`;
+    const settled = new Promise((resolve, reject) => {
+      this.#activeTurn = {
+        promptId,
+        localResult: null,
+        text: "",
+        assistantMessageId: null,
+        sawStreamedMessageText: false,
+        sawStreamedMessageReasoning: false,
+        lastFinalizedMessageText: null,
+        lastFinalizedMessageReasoning: null,
+        reasoningMessageOpen: false,
+        onEvent,
+        resolve,
+        reject,
+        failure: null,
+        sawTool: false,
+        tools: /* @__PURE__ */ new Map(),
+        interactions: /* @__PURE__ */ new Map(),
+        settlement: "pending",
+        terminalEnd: false,
+        cancellation: "none",
+        cancellationTimeout: null,
+        cancellationRecheck: null,
+        cancellationChecking: false,
+        cancellationReloaded: false,
+        abortPromise: null
       };
+    });
+    try {
+      await this.#send("prompt", { message: text }, promptId);
+    } catch (error51) {
+      this.#rejectActiveTurn(error51 instanceof Error ? error51 : new Error(message2(error51)));
     }
-    const pending = this.#pending;
-    if (!pending)
-      throw new Error("OMP RPC chunk state was lost");
-    if (pending.chunkId !== chunkId || pending.count !== chunkCount || pending.byteLength !== declaredByteLength || pending.nextIndex !== chunkIndex) {
-      throw new Error("OMP RPC chunk sequence mismatch");
+    return settled;
+  }
+  respondToInteraction(response) {
+    return this.#resolveInteraction(response, "cancelled" in response ? "cancelled" : "responded");
+  }
+  async #resolveInteraction(response, reason) {
+    const active = this.#activeTurn;
+    const pending = active?.interactions.get(response.requestId);
+    if (!active || !pending || this.#closed || this.#failed) {
+      throw new Error("Omp RPC interaction is not pending");
     }
-    pending.chunks.push(bytes);
-    pending.received += bytes.length;
-    pending.nextIndex += 1;
-    if (pending.received > pending.byteLength)
-      throw new Error("OMP RPC chunk sequence exceeds its declared length");
-    if (pending.nextIndex < pending.count)
-      return null;
-    if (pending.received !== pending.byteLength)
-      throw new Error("OMP RPC chunk sequence length mismatch");
-    this.#pending = null;
-    let decoded;
+    if ("value" in response && !["select", "input", "editor"].includes(pending.request.method)) {
+      throw new Error("Omp RPC interaction response type does not match the request");
+    }
+    if ("confirmed" in response && pending.request.method !== "confirm") {
+      throw new Error("Omp RPC confirmation does not match the request");
+    }
+    const frame = "cancelled" in response ? {
+      type: "extension_ui_response",
+      id: response.requestId,
+      cancelled: true,
+      ...reason === "expired" ? { timedOut: true } : {}
+    } : "confirmed" in response ? { type: "extension_ui_response", id: response.requestId, confirmed: response.confirmed } : { type: "extension_ui_response", id: response.requestId, value: response.value };
+    if (!active.interactions.delete(response.requestId)) {
+      throw new Error("Omp RPC interaction is not pending");
+    }
+    if (pending.timeout)
+      clearTimeout(pending.timeout);
+    active.onEvent({ type: "interaction.closed", requestId: response.requestId, reason });
     try {
-      decoded = JSON.parse(Buffer.concat(pending.chunks).toString("utf8"));
-    } catch {
-      throw new Error("Failed to decode reassembled OMP RPC frame");
+      await this.#write(frame);
+    } catch (error51) {
+      const fault = new OmpRpcFaultError("protocolError", `Omp RPC interaction response failed: ${message2(error51)}`);
+      this.#fail(fault);
+      throw fault;
     }
-    if (!isObject2(decoded))
-      throw new Error("Reassembled OMP RPC frame must be an object");
-    return decoded;
   }
-};
-
-// dist/omp-rpc-session.js
-var OmpRpcFaultError = class extends Error {
-  kind;
-  diagnostic;
-  constructor(kind, message3, diagnostic) {
-    super(message3);
-    this.kind = kind;
-    this.diagnostic = diagnostic;
-    this.name = "OmpRpcFaultError";
-  }
-};
-var OmpRpcUnsupportedCommandError = class extends Error {
-  command;
-  constructor(command) {
-    super(`Omp RPC does not support '${command}'`);
-    this.command = command;
-    this.name = "OmpRpcUnsupportedCommandError";
-  }
-};
-var textDecoder = new TextDecoder("utf-8", { fatal: true });
-function isRecord8(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function message2(value) {
-  return value instanceof Error ? value.message : String(value);
-}
-function nonBlankString(value) {
-  return typeof value === "string" && value.trim().length > 0;
-}
-function parseNativeModel(value, context) {
-  if (value === null || value === void 0)
-    return null;
-  if (!isRecord8(value) || !nonBlankString(value.provider) || !nonBlankString(value.id)) {
-    throw new OmpRpcFaultError("protocolError", `Omp RPC returned an invalid ${context} Model`);
-  }
-  return { provider: value.provider, id: value.id };
-}
-function sessionStateData(response) {
-  const data = isRecord8(response.data) ? response.data : null;
-  if (!data)
-    throw new OmpRpcFaultError("protocolError", "Omp RPC state response has no data");
-  return data;
-}
-function parseSessionState(response) {
-  const data = sessionStateData(response);
-  const model2 = parseNativeModel(data.model, "state");
-  if (!nonBlankString(data.sessionId)) {
-    throw new OmpRpcFaultError("protocolError", "Omp RPC state has no stable Session identity");
-  }
-  const thinkingLevel = data.thinkingLevel === void 0 ? null : harnessThinkingOptionIdSchema.safeParse(data.thinkingLevel);
-  if (thinkingLevel !== null && !thinkingLevel.success) {
-    throw new OmpRpcFaultError("protocolError", "Omp RPC state has an invalid Thinking level");
-  }
-  const thinking = isRecord8(data.model) && isRecord8(data.model.thinking) ? data.model.thinking : null;
-  const availableThinkingLevels = thinking && Array.isArray(thinking.efforts) ? thinking.efforts.flatMap((level) => {
-    const parsed = harnessThinkingOptionIdSchema.safeParse(level);
-    return parsed.success ? [parsed.data] : [];
-  }) : null;
-  return {
-    sessionId: data.sessionId,
-    sessionFile: typeof data.sessionFile === "string" ? data.sessionFile : null,
-    provider: model2?.provider ?? null,
-    modelId: model2?.id ?? null,
-    thinkingLevel: thinkingLevel?.data ?? null,
-    contextUsage: optionalOmpStateContextUsage(data.contextUsage),
-    availableThinkingLevels
-  };
-}
-function parseSessionStreaming(response) {
-  const isStreaming = sessionStateData(response).isStreaming;
-  if (typeof isStreaming !== "boolean") {
-    throw new OmpRpcFaultError("protocolError", "Omp RPC state has no Streaming status");
-  }
-  return isStreaming;
-}
-function cancellationSettled(response, terminalEnd) {
-  const data = sessionStateData(response);
-  return !parseSessionStreaming(response) && (data.isSettled === true || data.isSettled === void 0 && terminalEnd) && data.isCompacting !== true && data.hasPendingAsyncWork !== true && !(typeof data.queuedMessageCount === "number" && data.queuedMessageCount > 0);
-}
-function parseAvailableModels(response) {
-  const data = isRecord8(response.data) ? response.data : null;
-  if (!data || !Array.isArray(data.models)) {
-    throw new OmpRpcFaultError("protocolError", "Omp RPC Model catalog response has no models");
-  }
-  return data.models.map((model2) => {
-    const parsed = parseNativeModel(model2, "catalog");
-    if (!parsed || !isRecord8(model2) || typeof model2.reasoning !== "boolean") {
-      throw new OmpRpcFaultError("protocolError", "Omp RPC catalog contains a Model without reasoning capability");
+  abort() {
+    const active = this.#activeTurn;
+    if (!active || this.#closed || this.#failed) {
+      return Promise.reject(new Error("Omp RPC Session has no cancellable Turn"));
     }
-    return { ...parsed, reasoning: model2.reasoning };
-  });
-}
-function parseSubagentMessages(response) {
-  const data = isRecord8(response.data) ? response.data : null;
-  if (!data || !nonBlankString(data.sessionFile) || !Number.isSafeInteger(data.fromByte) || !Number.isSafeInteger(data.nextByte) || data.fromByte < 0 || data.nextByte < data.fromByte || typeof data.reset !== "boolean" || !Array.isArray(data.entries) || !Array.isArray(data.messages)) {
-    throw new OmpRpcFaultError("protocolError", "Omp RPC Subagent transcript response is invalid");
-  }
-  const entries = data.entries.flatMap((value) => isRecord8(value) ? [value] : []);
-  const messages = data.messages.flatMap((value) => isRecord8(value) ? [value] : []);
-  if (entries.length !== data.entries.length || messages.length !== data.messages.length) {
-    throw new OmpRpcFaultError("protocolError", "Omp RPC Subagent transcript contains invalid data");
+    if (active.abortPromise)
+      return active.abortPromise;
+    active.cancellation = "requesting";
+    active.cancellationTimeout = setTimeout(() => {
+      this.#terminateFailedCancellation(active, new OmpRpcFaultError("protocolError", "Omp Turn cancellation did not settle within its bound"));
+    }, this.#options.cancelTimeoutMs);
+    const aborting = this.#send("abort", {}).then(async () => {
+      if (this.#activeTurn !== active)
+        return;
+      active.cancellation = "accepted";
+      await this.#confirmCancelledTurn(active);
+    }).catch((error51) => {
+      if (this.#activeTurn !== active)
+        throw error51;
+      const fault = error51 instanceof OmpRpcFaultError ? error51 : new OmpRpcFaultError("protocolError", `Omp RPC Abort failed: ${message2(error51)}`);
+      this.#terminateFailedCancellation(active, fault);
+      throw fault;
+    });
+    active.abortPromise = aborting;
+    return aborting;
   }
-  return {
-    sessionFile: data.sessionFile,
-    fromByte: data.fromByte,
-    nextByte: data.nextByte,
-    reset: data.reset,
-    entries,
-    messages
-  };
-}
-function subagentStatus(value) {
-  if (value === "pending" || value === "running" || value === "completed")
-    return value;
-  if (value === "failed" || value === "aborted" || value === "interrupted")
-    return "failed";
-  throw new OmpRpcFaultError("protocolError", "Omp RPC Subagent status is invalid");
-}
-function assistantText(value) {
-  if (!isRecord8(value) || value.role !== "assistant" || !Array.isArray(value.content))
-    return null;
-  return value.content.filter((content) => isRecord8(content) && content.type === "text" && typeof content.text === "string").map((content) => content.text).join("");
-}
-function assistantMessageId(value) {
-  if (!isRecord8(value) || value.role !== "assistant")
-    return null;
-  return nonBlankString(value.responseId) ? value.responseId : null;
-}
-function extractReasoningText(content) {
-  if (!isRecord8(content))
-    return null;
-  const type = String(content.type ?? "");
-  if (type === "thinking" || type === "reasoning" || type === "thought") {
-    const text = content.thinking ?? content.reasoning ?? content.text ?? content.delta;
-    return typeof text === "string" ? text : null;
+  #terminateFailedCancellation(active, fault) {
+    if (this.#activeTurn !== active)
+      return;
+    if (active.cancellationTimeout)
+      clearTimeout(active.cancellationTimeout);
+    active.cancellationTimeout = null;
+    this.#fail(fault);
+    void this.close().catch(() => void 0);
   }
-  return null;
-}
-function assistantReasoning(value) {
-  if (!isRecord8(value) || value.role !== "assistant" || !Array.isArray(value.content))
-    return null;
-  return value.content.map(extractReasoningText).filter((text) => typeof text === "string").join("");
-}
-function assistantFailure(value) {
-  if (!isRecord8(value) || value.role !== "assistant")
-    return void 0;
-  if (value.stopReason !== "error" && value.stopReason !== "aborted")
-    return null;
-  const fallback = value.stopReason === "aborted" ? "Omp assistant message was aborted" : "Omp assistant message failed";
-  return new Error(nonBlankString(value.errorMessage) ? value.errorMessage : fallback);
-}
-function signalProcessTree(child, signal) {
-  if (!child.pid)
-    return;
-  if (process.platform === "win32") {
-    spawnSync("taskkill.exe", ["/pid", String(child.pid), "/t", "/f"], {
-      stdio: "ignore",
-      windowsHide: true
-    });
-    return;
+  close() {
+    if (!this.#closed) {
+      this.#closed = true;
+      this.#rejectAll(new Error("Omp RPC Session closed"));
+    }
+    this.#closePromise ??= this.#stopProcess();
+    return this.#closePromise;
   }
-  try {
-    process.kill(-child.pid, signal);
-  } catch (error51) {
-    if (!isRecord8(error51) || error51.code !== "ESRCH")
-      throw error51;
+  async #stopProcess() {
+    const child = this.#child;
+    if (!child)
+      return;
+    if (child.stdin.writable)
+      child.stdin.end();
+    if (await waitForExit(child, this.#options.closeTimeoutMs))
+      return;
+    signalProcessTree(child, "SIGTERM");
+    if (await waitForExit(child, this.#options.closeTimeoutMs))
+      return;
+    signalProcessTree(child, "SIGKILL");
+    if (!await waitForExit(child, this.#options.closeTimeoutMs)) {
+      throw new Error("Omp RPC process tree did not exit within cleanup bounds");
+    }
   }
-}
-function waitForExit(child, timeoutMs) {
-  if (child.exitCode !== null || child.signalCode !== null)
-    return Promise.resolve(true);
-  return Promise.race([
-    new Promise((resolve) => child.once("exit", () => resolve(true))),
-    new Promise((resolve) => setTimeout(() => resolve(false), timeoutMs))
-  ]);
-}
-function ompRpcProcessCommand(options, dependencies = {}) {
-  if (options.sessionFile && options.forkSessionFile) {
-    throw new Error("Omp RPC cannot combine Session resume and Fork startup");
+  #push(chunk) {
+    this.#buffer = this.#buffer.length === 0 ? chunk : Buffer.concat([this.#buffer, chunk]);
+    let newline = this.#buffer.indexOf(10);
+    while (newline >= 0) {
+      const frame = this.#buffer.subarray(0, newline);
+      this.#buffer = this.#buffer.subarray(newline + 1);
+      let parsed;
+      try {
+        parsed = JSON.parse(textDecoder.decode(frame));
+      } catch (error51) {
+        this.#fail(new OmpRpcFaultError("protocolError", `Omp RPC returned invalid JSONL: ${message2(error51)}`));
+        newline = this.#buffer.indexOf(10);
+        continue;
+      }
+      try {
+        const decoded = this.#frameDecoder.push(parsed);
+        if (decoded === null) {
+          newline = this.#buffer.indexOf(10);
+          continue;
+        }
+        const value = decoded;
+        if (!isRecord8(value) || typeof value.type !== "string") {
+          throw new OmpRpcFaultError("protocolError", "Omp RPC returned an invalid envelope");
+        }
+        this.#handle(value);
+      } catch (error51) {
+        this.#fail(error51 instanceof OmpRpcFaultError ? error51 : new OmpRpcFaultError("protocolError", `Omp RPC frame handling failed: ${message2(error51)}`));
+      }
+      newline = this.#buffer.indexOf(10);
+    }
   }
-  if (options.model && (options.sessionFile || options.forkSessionFile)) {
-    throw new Error("Omp RPC cannot combine a startup Model with Session restore or Fork");
+  /** Latest `available_commands_update` of the running process, if any. */
+  get availableCommands() {
+    return this.#availableCommands;
   }
-  const platform = dependencies.platform ?? process.platform;
-  const command = resolveOmpExecutable({
-    ...options.command ? { command: options.command } : {},
-    environment: options.environment
-  }, {
-    platform,
-    ...dependencies.homeDirectory ? { homeDirectory: dependencies.homeDirectory } : {},
-    ...dependencies.isExecutable ? { isExecutable: dependencies.isExecutable } : {}
-  });
-  const sessionArguments = options.forkSessionFile ? ["--fork", options.forkSessionFile] : options.sessionFile ? ["--resume", options.sessionFile] : [];
-  const modelArguments = options.model ? ["--provider", options.model.provider, "--model", options.model.id] : [];
-  const permissionArguments = options.permissionMode ? ["--approval-mode", options.permissionMode] : [];
-  const arguments_ = [
-    "--mode",
-    // OMP only creates ask and connects its tool UI in rpc-ui mode.
-    "rpc-ui",
-    ...permissionArguments,
-    ...modelArguments,
-    ...sessionArguments
-  ];
-  const extension = path6.win32.extname(command).toLowerCase();
-  if (platform !== "win32" || ![".cmd", ".bat"].includes(extension)) {
-    return { command, arguments: arguments_, windowsVerbatimArguments: false };
-  }
-  const quote = (value) => `"${value.replaceAll("%", "%%").replaceAll('"', '""')}"`;
-  const commandLine = [command, ...arguments_].map(quote).join(" ");
-  return {
-    command: options.environment?.ComSpec ?? options.environment?.COMSPEC ?? "cmd.exe",
-    arguments: ["/d", "/v:off", "/s", "/c", `"${commandLine}"`],
-    windowsVerbatimArguments: true
-  };
-}
-var nodeProcessAdapter = {
-  spawn(options) {
-    const invocation = ompRpcProcessCommand(options);
-    return spawn(invocation.command, invocation.arguments, {
-      cwd: options.cwd,
-      env: options.environment,
-      detached: process.platform !== "win32",
-      stdio: ["pipe", "pipe", "pipe"],
-      windowsHide: true,
-      windowsVerbatimArguments: invocation.windowsVerbatimArguments
-    });
-  }
-};
-var OmpRpcSession = class {
-  #options;
-  #processAdapter;
-  #activeTurn = null;
-  #buffer = Buffer.alloc(0);
-  #child = null;
-  #closed = false;
-  #closePromise = null;
-  #compactionActive = false;
-  #compactionTurn = null;
-  #compactionTimeout = null;
-  #failed = false;
-  #pending = /* @__PURE__ */ new Map();
-  #state = null;
-  #availableCommands = null;
-  #latestCacheHitRatePercent;
-  #manualCompaction = null;
-  #usageRequestStartedAtMs = null;
-  #stderrTail = "";
-  #frameDecoder = new OmpFrameDecoder();
-  #startupFaultResolve = null;
-  #startupFault = new Promise((resolve) => {
-    this.#startupFaultResolve = resolve;
-  });
-  #readyResolve = null;
-  #ready = new Promise((resolve) => {
-    this.#readyResolve = resolve;
-  });
-  constructor(options, processAdapter = nodeProcessAdapter) {
-    if (options.sessionFile && options.forkSessionFile) {
-      throw new Error("Omp RPC cannot combine Session resume and Fork startup");
+  #handle(value) {
+    if (this.#closed || this.#failed)
+      return;
+    if (value.type === "available_commands_update") {
+      this.#availableCommands = parseOmpAvailableCommands(value.commands);
+      return;
     }
-    if (options.model && (options.sessionFile || options.forkSessionFile)) {
-      throw new Error("Omp RPC cannot combine a startup Model with Session restore or Fork");
+    if (value.type === "ready") {
+      this.#readyResolve?.();
+      this.#readyResolve = null;
+      return;
     }
-    this.#options = {
-      commandTimeoutMs: 3e4,
-      compactionTimeoutMs: 3e5,
-      // Native Abort waits for tools, persistence and deferred work to unwind.
-      // Stable cancellation must outlast the Host's 20s steering wait.
-      cancelTimeoutMs: 3e4,
-      closeTimeoutMs: 2e3,
-      ...options
-    };
-    this.#processAdapter = processAdapter;
-  }
-  get state() {
-    if (!this.#state)
-      throw new Error("Omp RPC Session has not started");
-    return this.#state;
-  }
-  get stderrTail() {
-    return this.#stderrTail;
-  }
-  async start() {
-    if (this.#child || this.#closed)
-      throw new Error("Omp RPC Session cannot be started twice");
-    const child = this.#processAdapter.spawn({
-      cwd: this.#options.cwd,
-      ...this.#options.command ? { command: this.#options.command } : {},
-      environment: withNodeRuntimeOnPath({
-        ...process.env,
-        ...this.#options.environment,
-        OMP_SKIP_VERSION_CHECK: "1",
-        OMP_TELEMETRY: "0"
-      }),
-      ...this.#options.sessionFile ? { sessionFile: this.#options.sessionFile } : {},
-      ...this.#options.forkSessionFile ? { forkSessionFile: this.#options.forkSessionFile } : {},
-      ...this.#options.model ? { model: this.#options.model } : {},
-      ...this.#options.permissionMode ? { permissionMode: this.#options.permissionMode } : {}
-    });
-    this.#child = child;
-    child.stdout.on("data", (chunk) => this.#push(chunk));
-    child.stdout.on("end", () => {
-      if (this.#buffer.length !== 0) {
-        this.#fail(new OmpRpcFaultError("protocolError", "Omp RPC stdout ended mid-frame"));
+    if (value.type === "response") {
+      this.#handleResponse(value);
+      return;
+    }
+    if (value.type === "auto_compaction_start" || value.type === "compaction_start") {
+      this.#compactionActive = true;
+      this.#compactionTurn = this.#activeTurn;
+      this.#compactionTimeout ??= setTimeout(() => {
+        this.#compactionTimeout = null;
+        this.#fail(new OmpRpcFaultError("protocolError", `Omp RPC compaction timed out after ${this.#options.compactionTimeoutMs}ms`));
+      }, this.#options.compactionTimeoutMs);
+      const onEvent = this.#activeTurn?.onEvent ?? this.#manualCompaction?.onEvent;
+      onEvent?.({ type: "compaction.started" });
+      for (const pending of this.#pending.values()) {
+        if (pending.command !== "prompt" && pending.command !== "compact" || !pending.timeout)
+          continue;
+        clearTimeout(pending.timeout);
+        pending.timeout = null;
       }
-    });
-    child.stderr.on("data", (chunk) => {
-      this.#stderrTail = sanitizeDiagnosticTail(`${this.#stderrTail}${chunk.toString()}`);
-    });
-    child.once("error", (error51) => {
-      const kind = isRecord8(error51) && error51.code === "ENOENT" ? "notInstalled" : "unavailable";
-      this.#fail(new OmpRpcFaultError(kind, `Omp RPC failed to start: ${error51.message}`, this.stderrTail));
-    });
-    child.once("exit", (code, signal) => {
-      if (!this.#closed) {
-        this.#fail(new OmpRpcFaultError("processExited", `Omp RPC exited (code=${code}, signal=${signal})`, this.stderrTail));
+      return;
+    }
+    if (value.type === "auto_compaction_end" || value.type === "compaction_end") {
+      this.#compactionActive = false;
+      if (this.#compactionTimeout)
+        clearTimeout(this.#compactionTimeout);
+      this.#compactionTimeout = null;
+      const compactionTurn = this.#compactionTurn;
+      this.#compactionTurn = null;
+      for (const [id, pending] of this.#pending) {
+        if (pending.command === "prompt" || pending.command === "compact") {
+          this.#armCommandTimeout(id, pending);
+        }
       }
-    });
-    await Promise.race([
-      new Promise((resolve, reject) => {
-        child.once("spawn", resolve);
-        child.once("error", reject);
-      }),
-      new Promise((_resolve, reject) => setTimeout(() => reject(new Error("Omp RPC start timed out")), this.#options.commandTimeoutMs))
-    ]);
-    let readyTimeout;
-    try {
-      await Promise.race([
-        this.#ready,
-        this.#startupFault.then((error51) => {
-          throw error51;
-        }),
-        new Promise((_resolve, reject) => {
-          readyTimeout = setTimeout(() => reject(new Error("Omp RPC ready signal timed out")), this.#options.commandTimeoutMs);
-        })
-      ]);
-    } finally {
-      clearTimeout(readyTimeout);
+      const outcome = value.aborted === true ? "cancelled" : isRecord8(value.result) ? "succeeded" : "failed";
+      const event = {
+        type: "compaction.completed",
+        outcome,
+        ...nonBlankString(value.errorMessage) ? { errorMessage: value.errorMessage } : {}
+      };
+      compactionTurn?.onEvent(event);
+      const manual = this.#manualCompaction;
+      this.#manualCompaction = null;
+      manual?.onEvent(event);
+      manual?.resolve({
+        outcome,
+        ...event.errorMessage ? { errorMessage: event.errorMessage } : {}
+      });
+      return;
     }
-    await this.#send("negotiate_protocol", { protocolVersion: 2 }).catch(() => void 0);
-    if (this.#options.subscribeSubagentEvents !== false) {
-      await this.#send("set_subagent_subscription", { level: "events" }).catch(() => void 0);
+    const active = this.#activeTurn;
+    if (this.#handleSubagentFrame(active, value))
+      return;
+    this.#observeUsage(value);
+    if (value.type === "agent_start" && active)
+      active.terminalEnd = false;
+    if ((value.type === "session_settled" || value.type === "agent_start") && active?.cancellation === "accepted") {
+      void this.#confirmCancelledTurn(active);
+      return;
+    }
+    if (!active) {
+      if (value.type === "extension_ui_request" && this.#isBlockingInteraction(value)) {
+        this.#fail(new OmpRpcFaultError("protocolError", "Omp RPC requested blocking Extension UI outside an active Turn"));
+      }
+      return;
+    }
+    if (value.type === "command_output") {
+      if (active.settlement !== "pending")
+        return;
+      if (typeof value.text !== "string") {
+        throw new OmpRpcFaultError("protocolError", "Omp RPC returned invalid command output");
+      }
+      active.text += value.text;
+      active.onEvent({ type: "text.delta", messageId: active.promptId, delta: value.text });
+      return;
+    }
+    if (value.type === "prompt_result") {
+      if (value.id !== active.promptId || value.agentInvoked !== false)
+        return;
+      if (value.status === "completed" || value.status === "aborted") {
+        this.#settleLocalTurn(active, { cancelled: value.status === "aborted" });
+      } else if (value.status === "error" && isRecord8(value.error) && typeof value.error.message === "string") {
+        this.#settleLocalTurn(active, { cancelled: false, error: value.error.message });
+      } else {
+        throw new OmpRpcFaultError("protocolError", "Omp RPC returned an invalid local prompt result");
+      }
+      return;
+    }
+    if (value.type === "extension_ui_request") {
+      this.#startInteraction(active, value);
+      return;
+    }
+    if (value.type === "message_start" && assistantText(value.message) !== null) {
+      this.#startAssistantMessage(active, value.message);
+      return;
+    }
+    if (value.type === "message_update" && isRecord8(value.assistantMessageEvent)) {
+      const event = value.assistantMessageEvent;
+      const eventType = String(event.type ?? "");
+      const isThinking = eventType === "thinking_delta" || eventType === "reasoning_delta" || eventType === "thought_delta" || eventType === "thinking" || eventType === "reasoning";
+      const isText = eventType === "text_delta" || eventType === "text" || eventType === "content_block_delta";
+      const delta = typeof event.delta === "string" ? event.delta : typeof event.thinking === "string" ? event.thinking : typeof event.reasoning === "string" ? event.reasoning : typeof event.text === "string" ? event.text : isRecord8(event.delta) && typeof event.delta.thinking === "string" ? event.delta.thinking : isRecord8(event.delta) && typeof event.delta.text === "string" ? event.delta.text : null;
+      if (isThinking && delta !== null && delta.length > 0) {
+        const messageId = this.#ensureAssistantMessage(active, value.message);
+        active.reasoningMessageOpen = true;
+        active.sawStreamedMessageReasoning = true;
+        active.onEvent({ type: "reasoning.delta", messageId, delta });
+      } else if (isText && delta !== null && delta.length > 0) {
+        const messageId = this.#ensureAssistantMessage(active, value.message);
+        active.text += delta;
+        active.sawStreamedMessageText = true;
+        active.onEvent({ type: "text.delta", messageId, delta });
+      } else if (event.type === "error") {
+        this.#ensureAssistantMessage(active, value.message);
+        active.failure = assistantFailure(event.error) ?? assistantFailure(value.message) ?? new Error("Omp assistant message failed");
+      }
+      return;
+    }
+    if (value.type === "message_end") {
+      this.#finalizeAssistantMessage(active, value.message);
+      return;
+    }
+    if (value.type === "turn_end") {
+      this.#finalizeAssistantMessage(active, value.message);
+      return;
+    }
+    if (value.type === "tool_execution_start") {
+      this.#startTool(active, value);
+      return;
+    }
+    if (value.type === "tool_execution_update") {
+      this.#updateTool(active, value);
+      return;
+    }
+    if (value.type === "tool_execution_end") {
+      this.#completeTool(active, value);
+      return;
+    }
+    if (value.type === "agent_end" && Array.isArray(value.messages)) {
+      for (let index = value.messages.length - 1; index >= 0; index -= 1) {
+        const message3 = value.messages[index];
+        if (!isRecord8(message3) || message3.role !== "assistant")
+          continue;
+        this.#finalizeAssistantMessage(active, message3);
+        break;
+      }
+    }
+    if (value.type === "agent_end" && value.isTerminal !== false) {
+      active.terminalEnd = true;
+      if (active.cancellation !== "none") {
+        if (active.cancellation === "accepted")
+          void this.#confirmCancelledTurn(active);
+        return;
+      }
+      if (active.settlement !== "pending")
+        return;
+      active.settlement = "confirming";
+      void this.#confirmSettledTurn(active);
+    }
+  }
+  /** Every finished assistant message is one model request, with or without an active Turn. */
+  #observeUsage(value) {
+    if (value.type === "message_start") {
+      this.#usageRequestStartedAtMs = null;
+      return;
+    }
+    if (value.type === "message_update") {
+      const event = value.assistantMessageEvent;
+      if (this.#usageRequestStartedAtMs === null && isRecord8(event) && typeof event.type === "string" && /^(text|thinking|reasoning|thought|toolcall)_(start|delta)$/u.test(event.type)) {
+        this.#usageRequestStartedAtMs = Date.now();
+      }
+      return;
     }
-    try {
-      this.#state = parseSessionState(await this.#send("get_state", {}));
-    } catch (error51) {
-      const fault = error51 instanceof OmpRpcFaultError ? error51 : new OmpRpcFaultError("unavailable", `Omp RPC state unavailable: ${message2(error51)}`);
-      this.#fail(fault);
-      throw fault;
+    if (value.type === "message_end" && isRecord8(value.message)) {
+      if (value.message.role !== "assistant")
+        return;
+      const startedAtMs = this.#usageRequestStartedAtMs;
+      this.#usageRequestStartedAtMs = null;
+      this.#options.onUsage?.({
+        message: value.message,
+        startedAtMs,
+        completedAtMs: Date.now()
+      });
     }
-    return this;
   }
-  async getEntries() {
-    try {
-      if (this.state.sessionFile) {
-        try {
-          return await readOmpSessionHistory(this.state.sessionFile);
-        } catch (error51) {
-          if (!isRecord8(error51) || error51.code !== "ENOENT" || this.#options.sessionFile || this.#options.forkSessionFile)
-            throw error51;
-          const response2 = await this.#send("get_messages", {});
-          const data2 = isRecord8(response2.data) ? response2.data : null;
-          if (data2 && Array.isArray(data2.messages) && data2.messages.length === 0) {
-            return { entries: [], leafId: null };
-          }
-          throw error51;
-        }
-      }
-      const response = await this.#send("get_messages", {});
-      const data = isRecord8(response.data) ? response.data : null;
-      if (!data || !Array.isArray(data.messages)) {
-        throw new OmpRpcFaultError("protocolError", "Omp RPC messages response has no messages");
+  #handleSubagentFrame(active, value) {
+    if (value.type !== "subagent_lifecycle" && value.type !== "subagent_progress" && value.type !== "subagent_event") {
+      return false;
+    }
+    const payload = isRecord8(value.payload) ? value.payload : null;
+    const progressPayload = value.type === "subagent_progress" && payload && isRecord8(payload.progress) ? payload.progress : null;
+    const nativeIdValue = progressPayload?.id ?? payload?.id;
+    if (!payload || !nonBlankString(nativeIdValue)) {
+      throw new OmpRpcFaultError("protocolError", "Omp RPC Subagent frame has no stable ID");
+    }
+    const nativeSubagentId = nativeIdValue;
+    const callId = nativeSubagentId;
+    const emit = active?.onEvent ?? this.#options.onSubagentEvent;
+    if (value.type === "subagent_event") {
+      emit?.({ type: "subagent.transcript.changed", callId, nativeSubagentId });
+      return true;
+    }
+    if (value.type === "subagent_lifecycle") {
+      const status2 = payload.status;
+      if (status2 === "started") {
+        const description = nonBlankString(payload.description) ? payload.description : nonBlankString(payload.agent) ? `${payload.agent} delegation` : "Subagent delegation";
+        emit?.({
+          type: "subagent.started",
+          callId,
+          nativeSubagentId,
+          description,
+          ...nonBlankString(payload.agent) ? { role: payload.agent } : {},
+          ...nonBlankString(payload.task) ? { prompt: payload.task } : {},
+          background: payload.detached === true,
+          ...typeof payload.sessionFile === "string" ? { sessionFile: payload.sessionFile } : {}
+        });
+        return true;
       }
-      let branchEntryIds = null;
-      try {
-        const branchResponse = await this.#send("get_branch_messages", {});
-        const branchData = isRecord8(branchResponse.data) ? branchResponse.data : null;
-        if (branchData && Array.isArray(branchData.messages)) {
-          const parsed = branchData.messages.flatMap((entry) => {
-            if (!isRecord8(entry) || !nonBlankString(entry.entryId))
-              return [];
-            return [entry.entryId];
-          });
-          if (parsed.length === branchData.messages.length)
-            branchEntryIds = parsed;
-        }
-      } catch (error51) {
-        if (!(error51 instanceof OmpRpcUnsupportedCommandError))
-          throw error51;
+      if (status2 !== "completed" && status2 !== "failed" && status2 !== "aborted") {
+        throw new OmpRpcFaultError("protocolError", "Omp RPC Subagent lifecycle status is invalid");
       }
-      let userIndex = 0;
-      let parentId = null;
-      const entries = data.messages.map((nativeMessage, index) => {
-        const role = isRecord8(nativeMessage) ? nativeMessage.role : void 0;
-        const branchId = role === "user" ? branchEntryIds?.[userIndex] : void 0;
-        if (branchId)
-          userIndex += 1;
-        const id = branchId ?? (isRecord8(nativeMessage) && nonBlankString(nativeMessage.id) ? nativeMessage.id : `omp-message-${index}`);
-        const entry = { id, parentId, type: "message", message: nativeMessage };
-        parentId = id;
-        return entry;
+      emit?.({
+        type: "subagent.completed",
+        callId,
+        nativeSubagentId,
+        isError: status2 !== "completed",
+        ...nonBlankString(payload.resultSummary) ? { resultSummary: payload.resultSummary } : {},
+        ...typeof payload.sessionFile === "string" ? { sessionFile: payload.sessionFile } : {}
       });
-      return { entries, leafId: parentId };
-    } catch (error51) {
-      if (error51 instanceof OmpRpcFaultError)
-        this.#fail(error51);
-      throw error51;
-    }
-  }
-  async getSubagentMessages(input) {
-    if ((input.subagentId === void 0 || !nonBlankString(input.subagentId)) && (input.sessionFile === void 0 || !nonBlankString(input.sessionFile))) {
-      throw new Error("Omp Subagent transcript requires a Subagent ID or Session file");
+      return true;
     }
-    if (input.fromByte !== void 0 && (!Number.isSafeInteger(input.fromByte) || input.fromByte < 0)) {
-      throw new Error("Omp Subagent transcript offset is invalid");
+    const progress = progressPayload;
+    if (!progress || !nonBlankString(progress.id) || progress.id !== nativeSubagentId) {
+      throw new OmpRpcFaultError("protocolError", "Omp RPC Subagent progress is invalid");
     }
-    const response = await this.#send("get_subagent_messages", {
-      ...input.subagentId ? { subagentId: input.subagentId } : {},
-      ...input.sessionFile ? { sessionFile: input.sessionFile } : {},
-      ...input.fromByte !== void 0 ? { fromByte: input.fromByte } : {}
+    const status = subagentStatus(progress.status);
+    const recentOutput = Array.isArray(progress.recentOutput) ? progress.recentOutput.filter((item) => typeof item === "string") : [];
+    const resultSummary = recentOutput.at(-1);
+    emit?.({
+      type: "subagent.updated",
+      callId,
+      nativeSubagentId,
+      status,
+      ...nonBlankString(progress.description) ? { description: progress.description } : nonBlankString(payload.task) ? { description: payload.task } : {},
+      ...resultSummary !== void 0 ? { resultSummary } : {},
+      ...typeof payload.sessionFile === "string" ? { sessionFile: payload.sessionFile } : {}
     });
-    return parseSubagentMessages(response);
+    return true;
   }
-  async compact(customInstructions, onEvent) {
-    if (!this.#child || !this.#state || this.#closed || this.#failed) {
-      throw new Error("Omp RPC Session is unavailable");
+  #isBlockingInteraction(value) {
+    return ["select", "confirm", "input", "editor"].includes(String(value.method));
+  }
+  #startInteraction(active, value) {
+    if (!this.#isBlockingInteraction(value))
+      return;
+    const requestId2 = value.id;
+    const method = value.method;
+    const title = value.title;
+    const timeoutMs = value.timeout;
+    if (typeof requestId2 !== "string" || requestId2.length === 0 || typeof method !== "string" || typeof title !== "string" || title.length === 0 || timeoutMs !== void 0 && (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs < 0) || active.interactions.has(requestId2)) {
+      throw new OmpRpcFaultError("protocolError", "Omp RPC returned an invalid Interaction request");
     }
-    if (this.#activeTurn || this.#manualCompaction || this.#compactionActive) {
-      throw new Error("Omp RPC Session already has an active operation");
+    let request;
+    if (method === "select") {
+      if (!Array.isArray(value.options) || value.options.length === 0 || !value.options.every((option) => typeof option === "string" && option.length > 0)) {
+        throw new OmpRpcFaultError("protocolError", "Omp RPC select request has invalid options");
+      }
+      let optionDetails;
+      if (value.optionDetails !== void 0) {
+        if (!Array.isArray(value.optionDetails) || value.optionDetails.length !== value.options.length || !value.optionDetails.every((detail) => typeof detail === "object" && detail !== null && !Array.isArray(detail) && (detail.description === void 0 || typeof detail.description === "string"))) {
+          throw new OmpRpcFaultError("protocolError", "Omp RPC select option details are invalid");
+        }
+        optionDetails = value.optionDetails.map(({ description }) => description === void 0 ? {} : { description });
+      }
+      request = {
+        requestId: requestId2,
+        method,
+        title,
+        options: [...value.options],
+        ...optionDetails ? { optionDetails } : {},
+        ...typeof timeoutMs === "number" ? { timeoutMs } : {}
+      };
+    } else if (method === "confirm") {
+      if (typeof value.message !== "string") {
+        throw new OmpRpcFaultError("protocolError", "Omp RPC confirm request has no message");
+      }
+      request = {
+        requestId: requestId2,
+        method,
+        title,
+        message: value.message,
+        ...typeof timeoutMs === "number" ? { timeoutMs } : {}
+      };
+    } else if (method === "input") {
+      if (value.placeholder !== void 0 && typeof value.placeholder !== "string") {
+        throw new OmpRpcFaultError("protocolError", "Omp RPC input placeholder is invalid");
+      }
+      request = {
+        requestId: requestId2,
+        method,
+        title,
+        ...typeof value.placeholder === "string" ? { placeholder: value.placeholder } : {},
+        ...typeof timeoutMs === "number" ? { timeoutMs } : {}
+      };
+    } else {
+      if (value.prefill !== void 0 && typeof value.prefill !== "string") {
+        throw new OmpRpcFaultError("protocolError", "Omp RPC editor prefill is invalid");
+      }
+      request = {
+        requestId: requestId2,
+        method: "editor",
+        title,
+        ...typeof value.prefill === "string" ? { prefill: value.prefill } : {},
+        ...typeof timeoutMs === "number" ? { timeoutMs } : {}
+      };
     }
-    const result = new Promise((resolve, reject) => {
-      this.#manualCompaction = { onEvent, resolve, reject };
-    });
-    try {
-      await this.#send("compact", customInstructions ? { customInstructions } : {});
-    } catch (error51) {
-      const pending = this.#manualCompaction;
-      this.#manualCompaction = null;
-      pending?.reject(error51 instanceof Error ? error51 : new Error(message2(error51)));
+    const pending = { request, timeout: null };
+    if (request.timeoutMs !== void 0) {
+      pending.timeout = setTimeout(() => {
+        if (this.#activeTurn !== active || !active.interactions.has(requestId2))
+          return;
+        void this.#resolveInteraction({ requestId: requestId2, cancelled: true }, "expired").catch((error51) => {
+          if (this.#closed || this.#failed)
+            return;
+          this.#fail(new OmpRpcFaultError("protocolError", `Omp RPC Interaction timeout handling failed: ${message2(error51)}`));
+        });
+      }, request.timeoutMs);
     }
-    return result;
+    active.interactions.set(requestId2, pending);
+    active.onEvent({ type: "interaction.requested", request });
   }
-  async getSessionUsage() {
-    try {
-      const usage = parseOmpSessionUsage(await this.#send("get_session_stats", {}));
-      await this.#ensureLatestCacheHitRate();
-      return this.#withLatestCacheHitRate(usage);
-    } catch (error51) {
-      if (!(error51 instanceof OmpRpcUnsupportedCommandError))
-        throw error51;
-      const response = await this.#send("get_state", {});
-      const observedState = parseSessionState(response);
-      if (!this.#state || observedState.sessionId !== this.#state.sessionId || observedState.provider !== this.#state.provider || observedState.modelId !== this.#state.modelId) {
-        throw new Error("Omp RPC Usage fallback does not match the confirmed Session state");
-      }
-      await this.#ensureLatestCacheHitRate();
-      const usage = parseOmpStateContextUsage(response);
-      return usage ? this.#withLatestCacheHitRate(usage) : null;
+  #handleResponse(value) {
+    const id = value.id;
+    if (typeof id !== "string") {
+      this.#fail(new OmpRpcFaultError("protocolError", "Omp RPC response has no id"));
+      return;
     }
-  }
-  async #ensureLatestCacheHitRate() {
-    if (this.#latestCacheHitRatePercent !== void 0)
+    const pending = this.#pending.get(id);
+    const active = this.#activeTurn;
+    if (!pending) {
+      if (active?.promptId === id && value.command === "prompt" && value.success === false) {
+        active.failure = new Error(typeof value.error === "string" ? value.error : "Omp RPC command failed");
+        return;
+      }
+      this.#fail(new OmpRpcFaultError("protocolError", "Omp RPC response id is not pending"));
       return;
-    try {
-      this.#latestCacheHitRatePercent = latestOmpCacheHitRatePercent(await this.getEntries());
-    } catch {
-      this.#latestCacheHitRatePercent = null;
     }
-  }
-  #withLatestCacheHitRate(usage) {
-    return this.#latestCacheHitRatePercent === null || this.#latestCacheHitRatePercent === void 0 ? usage : parseHostUsage({ ...usage, cacheHitRatePercent: this.#latestCacheHitRatePercent });
-  }
-  async fork(entryId) {
-    if (!nonBlankString(entryId))
-      throw new Error("Omp RPC Fork requires an Entry identity");
-    try {
-      const response = await this.#send("branch", { entryId });
-      const data = isRecord8(response.data) ? response.data : null;
-      if (!data || data.cancelled === true) {
-        throw new OmpRpcFaultError("unavailable", "Omp RPC Fork was cancelled");
+    if (pending.timeout)
+      clearTimeout(pending.timeout);
+    this.#pending.delete(id);
+    if (value.success === true) {
+      if (pending.command === "prompt" && active?.promptId === id && isRecord8(value.data) && value.data.agentInvoked === false) {
+        this.#settleLocalTurn(active, { cancelled: false });
+      }
+      pending.resolve(value);
+    } else {
+      const error51 = typeof value.error === "string" ? value.error : "Omp RPC command failed";
+      if (value.command === pending.command && error51 === `Unknown command: ${pending.command}`) {
+        pending.reject(new OmpRpcUnsupportedCommandError(pending.command));
+      } else {
+        pending.reject(new Error(error51));
       }
-      this.#state = parseSessionState(await this.#send("get_state", {}));
-      return this.#state;
-    } catch (error51) {
-      if (error51 instanceof OmpRpcFaultError)
-        this.#fail(error51);
-      throw error51;
     }
   }
-  verifySessionCwd(expectedCwd) {
-    return verifyOmpSessionCwd({
-      sessionFile: this.state.sessionFile,
-      sessionId: this.state.sessionId,
-      expectedCwd
+  #startTool(active, value) {
+    const callId = value.toolCallId;
+    const toolName = value.toolName;
+    const argumentsResult = jsonValueSchema.safeParse(value.args);
+    if (typeof callId !== "string" || callId.length === 0 || typeof toolName !== "string" || toolName.length === 0 || !argumentsResult.success || active.tools.has(callId)) {
+      throw new OmpRpcFaultError("protocolError", "Omp RPC returned an invalid Tool start");
+    }
+    active.sawTool = true;
+    active.tools.set(callId, toolName);
+    active.onEvent({
+      type: "tool.started",
+      callId,
+      toolName,
+      arguments: argumentsResult.data
     });
   }
-  async getAvailableModels() {
-    try {
-      return parseAvailableModels(await this.#send("get_available_models", {}));
-    } catch (error51) {
-      if (error51 instanceof OmpRpcFaultError)
-        this.#fail(error51);
-      throw error51;
+  #updateTool(active, value) {
+    const callId = value.toolCallId;
+    if (typeof callId !== "string" || callId.length === 0) {
+      throw new OmpRpcFaultError("protocolError", "Omp RPC returned an invalid Tool update");
     }
-  }
-  async getAvailableThinkingLevels() {
-    return this.state.availableThinkingLevels;
-  }
-  async selectModel(model2) {
-    await this.#send("set_model", { provider: model2.provider, modelId: model2.id });
-    return this.#refreshState("Model");
-  }
-  async selectThinkingOption(thinkingOptionId) {
-    const level = harnessThinkingOptionIdSchema.parse(thinkingOptionId);
-    await this.#send("set_thinking_level", { level });
-    return this.#refreshState("Thinking");
-  }
-  async #refreshState(operation) {
-    try {
-      this.#state = parseSessionState(await this.#send("get_state", {}));
-      return this.#state;
-    } catch (error51) {
-      const fault = error51 instanceof OmpRpcFaultError ? error51 : new OmpRpcFaultError("protocolError", `Omp RPC ${operation} state could not be confirmed: ${message2(error51)}`);
-      this.#fail(fault);
-      throw fault;
+    if (!active.tools.has(callId))
+      return;
+    const outputResult = jsonValueSchema.safeParse(value.partialResult ?? null);
+    if (!outputResult.success) {
+      throw new OmpRpcFaultError("protocolError", "Omp RPC returned an invalid Tool update");
     }
+    active.onEvent({ type: "tool.updated", callId, output: outputResult.data });
   }
-  async runTurn(text, onEvent) {
-    if (!this.#child || !this.#state || this.#closed || this.#failed) {
-      throw new Error("Omp RPC Session is unavailable");
+  #completeTool(active, value) {
+    const callId = value.toolCallId;
+    const toolName = value.toolName;
+    if (typeof callId !== "string" || callId.length === 0) {
+      throw new OmpRpcFaultError("protocolError", "Omp RPC returned an invalid Tool end");
     }
-    if (this.#activeTurn)
-      throw new Error("Omp RPC Session already has an active Turn");
-    if (text.length === 0)
-      throw new Error("Omp text Turn must not be empty");
-    const promptId = `codexhost-${randomUUID()}`;
-    const settled = new Promise((resolve, reject) => {
-      this.#activeTurn = {
-        promptId,
-        localResult: null,
-        text: "",
-        assistantMessageId: null,
-        sawStreamedMessageText: false,
-        sawStreamedMessageReasoning: false,
-        lastFinalizedMessageText: null,
-        lastFinalizedMessageReasoning: null,
-        reasoningMessageOpen: false,
-        onEvent,
-        resolve,
-        reject,
-        failure: null,
-        sawTool: false,
-        tools: /* @__PURE__ */ new Map(),
-        interactions: /* @__PURE__ */ new Map(),
-        settlement: "pending",
-        terminalEnd: false,
-        cancellation: "none",
-        cancellationTimeout: null,
-        cancellationRecheck: null,
-        cancellationChecking: false,
-        cancellationReloaded: false,
-        abortPromise: null
-      };
-    });
-    try {
-      await this.#send("prompt", { message: text }, promptId);
-    } catch (error51) {
-      this.#rejectActiveTurn(error51 instanceof Error ? error51 : new Error(message2(error51)));
+    const expectedName = active.tools.get(callId);
+    if (expectedName === void 0)
+      return;
+    const result = jsonValueSchema.safeParse(value.result);
+    if (typeof toolName !== "string" || expectedName !== toolName || value.isError !== void 0 && typeof value.isError !== "boolean" || !result.success) {
+      throw new OmpRpcFaultError("protocolError", "Omp RPC returned an invalid Tool end");
     }
-    return settled;
-  }
-  respondToInteraction(response) {
-    return this.#resolveInteraction(response, "cancelled" in response ? "cancelled" : "responded");
+    active.tools.delete(callId);
+    active.onEvent({
+      type: "tool.completed",
+      callId,
+      toolName,
+      result: result.data,
+      isError: value.isError === true
+    });
   }
-  async #resolveInteraction(response, reason) {
-    const active = this.#activeTurn;
-    const pending = active?.interactions.get(response.requestId);
-    if (!active || !pending || this.#closed || this.#failed) {
-      throw new Error("Omp RPC interaction is not pending");
-    }
-    if ("value" in response && !["select", "input", "editor"].includes(pending.request.method)) {
-      throw new Error("Omp RPC interaction response type does not match the request");
-    }
-    if ("confirmed" in response && pending.request.method !== "confirm") {
-      throw new Error("Omp RPC confirmation does not match the request");
-    }
-    const frame = "cancelled" in response ? {
-      type: "extension_ui_response",
-      id: response.requestId,
-      cancelled: true,
-      ...reason === "expired" ? { timedOut: true } : {}
-    } : "confirmed" in response ? { type: "extension_ui_response", id: response.requestId, confirmed: response.confirmed } : { type: "extension_ui_response", id: response.requestId, value: response.value };
-    if (!active.interactions.delete(response.requestId)) {
-      throw new Error("Omp RPC interaction is not pending");
-    }
-    if (pending.timeout)
-      clearTimeout(pending.timeout);
-    active.onEvent({ type: "interaction.closed", requestId: response.requestId, reason });
+  async #confirmCancelledTurn(active) {
+    if (this.#activeTurn !== active || active.cancellation !== "accepted" || active.settlement === "confirming" || active.cancellationChecking)
+      return;
+    active.cancellationChecking = true;
+    if (active.cancellationRecheck)
+      clearTimeout(active.cancellationRecheck);
+    active.cancellationRecheck = null;
     try {
-      await this.#write(frame);
+      let response = await this.#send("get_state", {});
+      if (this.#activeTurn !== active)
+        return;
+      if (parseSessionStreaming(response)) {
+        await this.#send("abort", {});
+        if (this.#activeTurn !== active)
+          return;
+        response = await this.#send("get_state", {});
+      }
+      let state = parseSessionState(response);
+      if (this.#activeTurn !== active || active.cancellation !== "accepted")
+        return;
+      const data = sessionStateData(response);
+      if (!active.cancellationReloaded && state.sessionFile && state.sessionId === this.state.sessionId && state.sessionFile === this.state.sessionFile && data.isStreaming === false && data.isCompacting === false && data.queuedMessageCount === 0 && data.hasPendingAsyncWork === true && active.tools.size === 0) {
+        await this.verifySessionCwd(this.#options.cwd);
+        if (this.#activeTurn !== active)
+          return;
+        active.cancellationReloaded = true;
+        const reset = await this.#send("new_session", {});
+        if (this.#activeTurn !== active)
+          return;
+        if (!isRecord8(reset.data) || reset.data.cancelled !== false) {
+          throw new OmpRpcFaultError("unavailable", "Omp cancelled Session reset was refused");
+        }
+        const reloaded = await this.#send("switch_session", { sessionPath: state.sessionFile });
+        if (this.#activeTurn !== active)
+          return;
+        if (!isRecord8(reloaded.data) || reloaded.data.cancelled !== false) {
+          throw new OmpRpcFaultError("unavailable", "Omp cancelled Session reload was refused");
+        }
+        const previous = state;
+        response = await this.#send("get_state", {});
+        state = parseSessionState(response);
+        if (state.sessionId !== previous.sessionId || state.sessionFile !== previous.sessionFile) {
+          throw new OmpRpcFaultError("protocolError", "Omp cancelled Session reload changed its identity");
+        }
+        if (state.provider !== previous.provider || state.modelId !== previous.modelId) {
+          if (!previous.provider || !previous.modelId) {
+            throw new OmpRpcFaultError("protocolError", "Omp cancelled Session has no restorable Model");
+          }
+          await this.#send("set_model", { provider: previous.provider, modelId: previous.modelId });
+        }
+        if (previous.thinkingLevel && state.thinkingLevel !== previous.thinkingLevel) {
+          await this.#send("set_thinking_level", { level: previous.thinkingLevel });
+        }
+        response = await this.#send("get_state", {});
+        state = parseSessionState(response);
+        if (state.sessionId !== previous.sessionId || state.sessionFile !== previous.sessionFile || state.provider !== previous.provider || state.modelId !== previous.modelId || previous.thinkingLevel !== null && state.thinkingLevel !== previous.thinkingLevel) {
+          throw new OmpRpcFaultError("protocolError", "Omp cancelled Session reload changed its identity or configuration");
+        }
+      }
+      if (!cancellationSettled(response, active.terminalEnd)) {
+        active.settlement = "pending";
+        active.cancellationRecheck = setTimeout(() => {
+          active.cancellationRecheck = null;
+          void this.#confirmCancelledTurn(active);
+        }, 250);
+        return;
+      }
+      this.#state = state;
+      active.settlement = "confirmed";
+      this.#finishSettledTurn(active);
     } catch (error51) {
-      const fault = new OmpRpcFaultError("protocolError", `Omp RPC interaction response failed: ${message2(error51)}`);
-      this.#fail(fault);
-      throw fault;
+      if (this.#activeTurn !== active)
+        return;
+      const fault = error51 instanceof OmpRpcFaultError ? error51 : new OmpRpcFaultError("protocolError", `Omp RPC cancelled Turn state could not be confirmed: ${message2(error51)}`);
+      this.#terminateFailedCancellation(active, fault);
+    } finally {
+      active.cancellationChecking = false;
     }
   }
-  abort() {
-    const active = this.#activeTurn;
-    if (!active || this.#closed || this.#failed) {
-      return Promise.reject(new Error("Omp RPC Session has no cancellable Turn"));
-    }
-    if (active.abortPromise)
-      return active.abortPromise;
-    active.cancellation = "requesting";
-    active.cancellationTimeout = setTimeout(() => {
-      this.#terminateFailedCancellation(active, new OmpRpcFaultError("protocolError", "Omp Turn cancellation did not settle within its bound"));
-    }, this.#options.cancelTimeoutMs);
-    const aborting = this.#send("abort", {}).then(async () => {
+  #settleLocalTurn(active, result) {
+    if (this.#activeTurn !== active || active.settlement !== "pending")
+      return;
+    active.localResult = result;
+    active.settlement = "confirming";
+    void this.#confirmSettledTurn(active);
+  }
+  async #confirmSettledTurn(active) {
+    try {
+      const response = await this.#send("get_state", {});
+      const state = parseSessionState(response);
       if (this.#activeTurn !== active)
         return;
-      active.cancellation = "accepted";
-      await this.#confirmCancelledTurn(active);
-    }).catch((error51) => {
+      if (active.cancellation !== "none") {
+        active.settlement = "pending";
+        if (active.cancellation === "accepted")
+          void this.#confirmCancelledTurn(active);
+        return;
+      }
+      if (parseSessionStreaming(response)) {
+        throw new OmpRpcFaultError("protocolError", "Omp RPC completed Turn state is still Streaming");
+      }
+      this.#state = state;
+      active.settlement = "confirmed";
+      this.#finishSettledTurn(active);
+    } catch (error51) {
       if (this.#activeTurn !== active)
-        throw error51;
-      const fault = error51 instanceof OmpRpcFaultError ? error51 : new OmpRpcFaultError("protocolError", `Omp RPC Abort failed: ${message2(error51)}`);
-      this.#terminateFailedCancellation(active, fault);
-      throw fault;
-    });
-    active.abortPromise = aborting;
-    return aborting;
+        return;
+      const fault = error51 instanceof OmpRpcFaultError ? error51 : new OmpRpcFaultError("protocolError", `Omp RPC stable Turn state could not be confirmed: ${message2(error51)}`);
+      this.#fail(fault);
+    }
   }
-  #terminateFailedCancellation(active, fault) {
-    if (this.#activeTurn !== active)
+  #finishSettledTurn(active) {
+    if (this.#activeTurn !== active || active.settlement !== "confirmed" || active.cancellation === "requesting") {
       return;
+    }
     if (active.cancellationTimeout)
       clearTimeout(active.cancellationTimeout);
     active.cancellationTimeout = null;
-    this.#fail(fault);
-    void this.close().catch(() => void 0);
-  }
-  close() {
-    if (!this.#closed) {
-      this.#closed = true;
-      this.#rejectAll(new Error("Omp RPC Session closed"));
-    }
-    this.#closePromise ??= this.#stopProcess();
-    return this.#closePromise;
-  }
-  async #stopProcess() {
-    const child = this.#child;
-    if (!child)
-      return;
-    if (child.stdin.writable)
-      child.stdin.end();
-    if (await waitForExit(child, this.#options.closeTimeoutMs))
-      return;
-    signalProcessTree(child, "SIGTERM");
-    if (await waitForExit(child, this.#options.closeTimeoutMs))
+    if (active.cancellationRecheck)
+      clearTimeout(active.cancellationRecheck);
+    active.cancellationRecheck = null;
+    this.#closeInteractions(active, active.cancellation === "accepted" ? "cancelled" : "superseded");
+    if (active.tools.size > 0) {
+      this.#fail(new OmpRpcFaultError("protocolError", "Omp RPC settled with active Tool executions"));
       return;
-    signalProcessTree(child, "SIGKILL");
-    if (!await waitForExit(child, this.#options.closeTimeoutMs)) {
-      throw new Error("Omp RPC process tree did not exit within cleanup bounds");
+    }
+    this.#activeTurn = null;
+    if (active.localResult) {
+      active.resolve({
+        text: active.text,
+        agentInvoked: false,
+        ...active.localResult,
+        cancelled: active.localResult.cancelled || active.cancellation === "accepted"
+      });
+    } else if (active.cancellation === "accepted") {
+      active.resolve({ text: active.text, cancelled: true, agentInvoked: true });
+    } else if (active.failure) {
+      active.reject(active.failure);
+    } else if (active.text.trim().length === 0 && !active.sawTool) {
+      active.reject(new Error("Omp RPC settled without displayable output"));
+    } else {
+      active.resolve({ text: active.text, cancelled: false, agentInvoked: true });
     }
   }
-  #push(chunk) {
-    this.#buffer = this.#buffer.length === 0 ? chunk : Buffer.concat([this.#buffer, chunk]);
-    let newline = this.#buffer.indexOf(10);
-    while (newline >= 0) {
-      const frame = this.#buffer.subarray(0, newline);
-      this.#buffer = this.#buffer.subarray(newline + 1);
-      let parsed;
-      try {
-        parsed = JSON.parse(textDecoder.decode(frame));
-      } catch (error51) {
-        this.#fail(new OmpRpcFaultError("protocolError", `Omp RPC returned invalid JSONL: ${message2(error51)}`));
-        newline = this.#buffer.indexOf(10);
-        continue;
-      }
-      try {
-        const decoded = this.#frameDecoder.push(parsed);
-        if (decoded === null) {
-          newline = this.#buffer.indexOf(10);
-          continue;
-        }
-        const value = decoded;
-        if (!isRecord8(value) || typeof value.type !== "string") {
-          throw new OmpRpcFaultError("protocolError", "Omp RPC returned an invalid envelope");
-        }
-        this.#handle(value);
-      } catch (error51) {
-        this.#fail(error51 instanceof OmpRpcFaultError ? error51 : new OmpRpcFaultError("protocolError", `Omp RPC frame handling failed: ${message2(error51)}`));
-      }
-      newline = this.#buffer.indexOf(10);
+  #startAssistantMessage(active, value) {
+    if (active.assistantMessageId !== null && active.reasoningMessageOpen) {
+      active.onEvent({ type: "reasoning.completed", messageId: active.assistantMessageId });
     }
+    const messageId = assistantMessageId(value) ?? randomUUID();
+    active.assistantMessageId = messageId;
+    active.sawStreamedMessageText = false;
+    active.sawStreamedMessageReasoning = false;
+    active.reasoningMessageOpen = false;
+    return messageId;
   }
-  /** Latest `available_commands_update` of the running process, if any. */
-  get availableCommands() {
-    return this.#availableCommands;
+  #ensureAssistantMessage(active, value) {
+    return active.assistantMessageId ?? this.#startAssistantMessage(active, value);
   }
-  #handle(value) {
-    if (this.#closed || this.#failed)
+  #finalizeAssistantMessage(active, value) {
+    const finalText = assistantText(value);
+    const finalReasoning = assistantReasoning(value);
+    const failure = assistantFailure(value);
+    const cacheHitRatePercent = optionalOmpCacheHitRatePercent(value);
+    if (finalText === null || finalReasoning === null || failure === void 0)
       return;
-    if (value.type === "available_commands_update") {
-      this.#availableCommands = parseOmpAvailableCommands(value.commands);
+    if (active.assistantMessageId === null && finalText === active.lastFinalizedMessageText && finalReasoning === active.lastFinalizedMessageReasoning && !active.sawStreamedMessageText && !active.sawStreamedMessageReasoning) {
       return;
     }
-    if (value.type === "ready") {
-      this.#readyResolve?.();
-      this.#readyResolve = null;
-      return;
+    active.failure = failure;
+    this.#latestCacheHitRatePercent = cacheHitRatePercent;
+    const messageId = this.#ensureAssistantMessage(active, value);
+    if (!active.sawStreamedMessageReasoning && finalReasoning.length > 0) {
+      active.reasoningMessageOpen = true;
+      active.onEvent({ type: "reasoning.delta", messageId, delta: finalReasoning });
     }
-    if (value.type === "response") {
-      this.#handleResponse(value);
-      return;
+    if (active.reasoningMessageOpen && active.failure === null) {
+      active.onEvent({ type: "reasoning.completed", messageId });
     }
-    if (value.type === "auto_compaction_start" || value.type === "compaction_start") {
-      this.#compactionActive = true;
-      this.#compactionTurn = this.#activeTurn;
-      this.#compactionTimeout ??= setTimeout(() => {
-        this.#compactionTimeout = null;
-        this.#fail(new OmpRpcFaultError("protocolError", `Omp RPC compaction timed out after ${this.#options.compactionTimeoutMs}ms`));
-      }, this.#options.compactionTimeoutMs);
-      const onEvent = this.#activeTurn?.onEvent ?? this.#manualCompaction?.onEvent;
-      onEvent?.({ type: "compaction.started" });
-      for (const pending of this.#pending.values()) {
-        if (pending.command !== "prompt" && pending.command !== "compact" || !pending.timeout)
-          continue;
-        clearTimeout(pending.timeout);
-        pending.timeout = null;
-      }
-      return;
+    if (!active.sawStreamedMessageText && finalText.length > 0) {
+      active.text += finalText;
+      active.onEvent({ type: "text.delta", messageId, delta: finalText });
     }
-    if (value.type === "auto_compaction_end" || value.type === "compaction_end") {
-      this.#compactionActive = false;
-      if (this.#compactionTimeout)
-        clearTimeout(this.#compactionTimeout);
-      this.#compactionTimeout = null;
-      const compactionTurn = this.#compactionTurn;
-      this.#compactionTurn = null;
-      for (const [id, pending] of this.#pending) {
-        if (pending.command === "prompt" || pending.command === "compact") {
-          this.#armCommandTimeout(id, pending);
-        }
-      }
-      const outcome = value.aborted === true ? "cancelled" : isRecord8(value.result) ? "succeeded" : "failed";
-      const event = {
-        type: "compaction.completed",
-        outcome,
-        ...nonBlankString(value.errorMessage) ? { errorMessage: value.errorMessage } : {}
-      };
-      compactionTurn?.onEvent(event);
-      const manual = this.#manualCompaction;
-      this.#manualCompaction = null;
-      manual?.onEvent(event);
-      manual?.resolve({
-        outcome,
-        ...event.errorMessage ? { errorMessage: event.errorMessage } : {}
-      });
-      return;
+    active.assistantMessageId = null;
+    active.sawStreamedMessageText = false;
+    active.sawStreamedMessageReasoning = false;
+    active.reasoningMessageOpen = false;
+    active.lastFinalizedMessageText = finalText;
+    active.lastFinalizedMessageReasoning = finalReasoning;
+    active.onEvent({ type: "message.completed", messageId });
+  }
+  #write(value) {
+    const child = this.#child;
+    if (!child?.stdin.writable || this.#closed || this.#failed) {
+      return Promise.reject(new Error("Omp RPC stdin is unavailable"));
     }
-    const active = this.#activeTurn;
-    if (this.#handleSubagentFrame(active, value))
-      return;
-    this.#observeUsage(value);
-    if (value.type === "agent_start" && active)
-      active.terminalEnd = false;
-    if ((value.type === "session_settled" || value.type === "agent_start") && active?.cancellation === "accepted") {
-      void this.#confirmCancelledTurn(active);
-      return;
+    return new Promise((resolve, reject) => {
+      const frame = Buffer.from(`${JSON.stringify(value)}
+`, "utf8");
+      child.stdin.write(frame, (error51) => error51 ? reject(error51) : resolve());
+    });
+  }
+  #send(type, payload, id = `codexhost-${randomUUID()}`) {
+    const child = this.#child;
+    if (!child?.stdin.writable || this.#closed || this.#failed) {
+      return Promise.reject(new Error("Omp RPC stdin is unavailable"));
     }
-    if (!active) {
-      if (value.type === "extension_ui_request" && this.#isBlockingInteraction(value)) {
-        this.#fail(new OmpRpcFaultError("protocolError", "Omp RPC requested blocking Extension UI outside an active Turn"));
-      }
+    return new Promise((resolve, reject) => {
+      const pending = {
+        command: type,
+        resolve,
+        reject,
+        timeout: null
+      };
+      this.#pending.set(id, pending);
+      this.#armCommandTimeout(id, pending);
+      const frame = Buffer.from(`${JSON.stringify({ id, type, ...payload })}
+`, "utf8");
+      child.stdin.write(frame, (error51) => {
+        if (error51) {
+          if (pending.timeout)
+            clearTimeout(pending.timeout);
+          this.#pending.delete(id);
+          reject(error51);
+        }
+      });
+    });
+  }
+  #armCommandTimeout(id, pending) {
+    if (pending.timeout || this.#pending.get(id) !== pending || (pending.command === "prompt" || pending.command === "compact") && this.#compactionActive) {
       return;
     }
-    if (value.type === "command_output") {
-      if (active.settlement !== "pending")
+    pending.timeout = setTimeout(() => {
+      if (this.#pending.get(id) !== pending)
         return;
-      if (typeof value.text !== "string") {
-        throw new OmpRpcFaultError("protocolError", "Omp RPC returned invalid command output");
-      }
-      active.text += value.text;
-      active.onEvent({ type: "text.delta", messageId: active.promptId, delta: value.text });
-      return;
-    }
-    if (value.type === "prompt_result") {
-      if (value.id !== active.promptId || value.agentInvoked !== false)
+      pending.timeout = null;
+      const error51 = new Error(`Omp RPC '${pending.command}' command timed out`);
+      if (pending.command !== "prompt") {
+        this.#pending.delete(id);
+        pending.reject(error51);
         return;
-      if (value.status === "completed" || value.status === "aborted") {
-        this.#settleLocalTurn(active, { cancelled: value.status === "aborted" });
-      } else if (value.status === "error" && isRecord8(value.error) && typeof value.error.message === "string") {
-        this.#settleLocalTurn(active, { cancelled: false, error: value.error.message });
-      } else {
-        throw new OmpRpcFaultError("protocolError", "Omp RPC returned an invalid local prompt result");
       }
+      const fault = new OmpRpcFaultError("protocolError", error51.message);
+      void this.#terminateTimedOutPrompt(fault);
+    }, this.#options.commandTimeoutMs);
+  }
+  async #terminateTimedOutPrompt(fault) {
+    if (this.#closed || this.#failed)
       return;
+    this.#failed = true;
+    this.#closed = true;
+    for (const pending of this.#pending.values()) {
+      if (pending.timeout)
+        clearTimeout(pending.timeout);
+      pending.timeout = null;
     }
-    if (value.type === "extension_ui_request") {
-      this.#startInteraction(active, value);
-      return;
-    }
-    if (value.type === "message_start" && assistantText(value.message) !== null) {
-      this.#startAssistantMessage(active, value.message);
-      return;
+    let finalFault = fault;
+    try {
+      await this.close();
+    } catch (error51) {
+      finalFault = new OmpRpcFaultError("processExited", `Omp RPC timed-out Prompt cleanup failed: ${message2(error51)}`);
     }
-    if (value.type === "message_update" && isRecord8(value.assistantMessageEvent)) {
-      const event = value.assistantMessageEvent;
-      const eventType = String(event.type ?? "");
-      const isThinking = eventType === "thinking_delta" || eventType === "reasoning_delta" || eventType === "thought_delta" || eventType === "thinking" || eventType === "reasoning";
-      const isText = eventType === "text_delta" || eventType === "text" || eventType === "content_block_delta";
-      const delta = typeof event.delta === "string" ? event.delta : typeof event.thinking === "string" ? event.thinking : typeof event.reasoning === "string" ? event.reasoning : typeof event.text === "string" ? event.text : isRecord8(event.delta) && typeof event.delta.thinking === "string" ? event.delta.thinking : isRecord8(event.delta) && typeof event.delta.text === "string" ? event.delta.text : null;
-      if (isThinking && delta !== null && delta.length > 0) {
-        const messageId = this.#ensureAssistantMessage(active, value.message);
-        active.reasoningMessageOpen = true;
-        active.sawStreamedMessageReasoning = true;
-        active.onEvent({ type: "reasoning.delta", messageId, delta });
-      } else if (isText && delta !== null && delta.length > 0) {
-        const messageId = this.#ensureAssistantMessage(active, value.message);
-        active.text += delta;
-        active.sawStreamedMessageText = true;
-        active.onEvent({ type: "text.delta", messageId, delta });
-      } else if (event.type === "error") {
-        this.#ensureAssistantMessage(active, value.message);
-        active.failure = assistantFailure(event.error) ?? assistantFailure(value.message) ?? new Error("Omp assistant message failed");
-      }
-      return;
+    this.#rejectAll(finalFault);
+    this.#options.onFault?.(finalFault);
+  }
+  #closeInteractions(active, reason) {
+    for (const [requestId2, pending] of active.interactions) {
+      active.interactions.delete(requestId2);
+      if (pending.timeout)
+        clearTimeout(pending.timeout);
+      active.onEvent({ type: "interaction.closed", requestId: requestId2, reason });
     }
-    if (value.type === "message_end") {
-      this.#finalizeAssistantMessage(active, value.message);
+  }
+  #rejectActiveTurn(error51) {
+    const active = this.#activeTurn;
+    if (!active)
       return;
+    if (active.cancellationTimeout)
+      clearTimeout(active.cancellationTimeout);
+    if (active.cancellationRecheck)
+      clearTimeout(active.cancellationRecheck);
+    this.#closeInteractions(active, "cancelled");
+    this.#activeTurn = null;
+    active.reject(error51);
+  }
+  #rejectAll(error51) {
+    if (this.#compactionTimeout)
+      clearTimeout(this.#compactionTimeout);
+    this.#compactionTimeout = null;
+    for (const pending of this.#pending.values()) {
+      if (pending.timeout)
+        clearTimeout(pending.timeout);
+      pending.reject(error51);
     }
-    if (value.type === "turn_end") {
-      this.#finalizeAssistantMessage(active, value.message);
+    this.#pending.clear();
+    const manual = this.#manualCompaction;
+    this.#manualCompaction = null;
+    manual?.reject(error51);
+    this.#rejectActiveTurn(error51);
+  }
+  #fail(error51) {
+    if (this.#closed || this.#failed)
       return;
+    this.#failed = true;
+    this.#startupFaultResolve?.(error51);
+    this.#startupFaultResolve = null;
+    this.#rejectAll(error51);
+    this.#options.onFault?.(error51);
+  }
+};
+
+// dist/omp-model-list.js
+var OMP_MODEL_LIST_TIMEOUT_MS = 15e3;
+var OMP_MODEL_LIST_OUTPUT_LIMIT = 4 * 1024 * 1024;
+function listOmpModels(input) {
+  const environment = withNodeRuntimeOnPath({
+    ...process.env,
+    ...input.environment,
+    OMP_SKIP_VERSION_CHECK: "1",
+    OMP_TELEMETRY: "0"
+  });
+  const executable = resolveOmpExecutable({
+    ...input.command ? { command: input.command } : {},
+    environment
+  });
+  const invocation = commandInvocation(executable, ["models", "--json"], environment);
+  return new Promise((resolve) => {
+    if (input.signal?.aborted)
+      return resolve({ kind: "unanswered" });
+    const child = spawn2(invocation.command, invocation.arguments, {
+      cwd: input.cwd,
+      env: environment,
+      // A process group lets a stop reach OMP and its descendants, not only a launcher shim.
+      detached: process.platform !== "win32",
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true,
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments
+    });
+    let settled = false;
+    let stdout = "";
+    const finish = (result, stop = false) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      input.signal?.removeEventListener("abort", onAbort);
+      child.stdout.removeAllListeners("data");
+      if (stop) {
+        child.stdout.destroy();
+        try {
+          signalProcessTree(child, "SIGKILL");
+        } catch {
+        }
+      }
+      resolve(result);
+    };
+    const onAbort = () => finish({ kind: "unanswered" }, true);
+    input.signal?.addEventListener("abort", onAbort, { once: true });
+    const timer = setTimeout(() => finish({ kind: "timedOut" }, true), input.timeoutMs ?? OMP_MODEL_LIST_TIMEOUT_MS);
+    child.stdout.setEncoding("utf8").on("data", (chunk) => {
+      stdout += chunk;
+      if (stdout.length > OMP_MODEL_LIST_OUTPUT_LIMIT)
+        finish({ kind: "unanswered" }, true);
+    });
+    child.once("error", (error51) => {
+      finish(error51.code === "ENOENT" ? { kind: "notInstalled", message: "Oh My Pi (omp) is not installed" } : { kind: "unanswered" });
+    });
+    child.once("close", (code) => {
+      if (code !== 0)
+        return finish({ kind: "unanswered" });
+      const models = parseOmpModelList(stdout);
+      finish(models ? { kind: "models", models } : { kind: "unanswered" });
+    });
+  });
+}
+function parseOmpModelList(output) {
+  let parsed;
+  try {
+    parsed = JSON.parse(output);
+  } catch {
+    return null;
+  }
+  if (!isRecord9(parsed) || !Array.isArray(parsed.models))
+    return null;
+  const models = [];
+  for (const model2 of parsed.models) {
+    if (!isRecord9(model2) || !nonBlankString2(model2.provider) || !nonBlankString2(model2.id) || typeof model2.reasoning !== "boolean") {
+      return null;
     }
-    if (value.type === "tool_execution_start") {
-      this.#startTool(active, value);
-      return;
+    models.push({ provider: model2.provider, id: model2.id, reasoning: model2.reasoning });
+  }
+  return models;
+}
+function isRecord9(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonBlankString2(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+// ../../../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;
     }
-    if (value.type === "tool_execution_update") {
-      this.#updateTool(active, value);
-      return;
+    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);
     }
-    if (value.type === "tool_execution_end") {
-      this.#completeTool(active, value);
-      return;
+    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));
     }
-    if (value.type === "agent_end" && Array.isArray(value.messages)) {
-      for (let index = value.messages.length - 1; index >= 0; index -= 1) {
-        const message3 = value.messages[index];
-        if (!isRecord8(message3) || message3.role !== "assistant")
+    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;
-        this.#finalizeAssistantMessage(active, message3);
-        break;
+        }
+        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);
+          }
+        }
       }
-    }
-    if (value.type === "agent_end" && value.isTerminal !== false) {
-      active.terminalEnd = true;
-      if (active.cancellation !== "none") {
-        if (active.cancellation === "accepted")
-          void this.#confirmCancelledTurn(active);
-        return;
+      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;
+        }
       }
-      if (active.settlement !== "pending")
-        return;
-      active.settlement = "confirming";
-      void this.#confirmSettledTurn(active);
     }
   }
-  /** Every finished assistant message is one model request, with or without an active Turn. */
-  #observeUsage(value) {
-    if (value.type === "message_start") {
-      this.#usageRequestStartedAtMs = null;
-      return;
+  addToPath(path9, added, removed, oldPosInc, options) {
+    const last = path9.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path9.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path9.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
     }
-    if (value.type === "message_update") {
-      const event = value.assistantMessageEvent;
-      if (this.#usageRequestStartedAtMs === null && isRecord8(event) && typeof event.type === "string" && /^(text|thinking|reasoning|thought|toolcall)_(start|delta)$/u.test(event.type)) {
-        this.#usageRequestStartedAtMs = Date.now();
+  }
+  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 };
       }
-      return;
     }
-    if (value.type === "message_end" && isRecord8(value.message)) {
-      if (value.message.role !== "assistant")
-        return;
-      const startedAtMs = this.#usageRequestStartedAtMs;
-      this.#usageRequestStartedAtMs = null;
-      this.#options.onUsage?.({
-        message: value.message,
-        startedAtMs,
-        completedAtMs: Date.now()
-      });
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
     }
+    basePath.oldPos = oldPos;
+    return newPos;
   }
-  #handleSubagentFrame(active, value) {
-    if (value.type !== "subagent_lifecycle" && value.type !== "subagent_progress" && value.type !== "subagent_event") {
-      return false;
-    }
-    const payload = isRecord8(value.payload) ? value.payload : null;
-    const progressPayload = value.type === "subagent_progress" && payload && isRecord8(payload.progress) ? payload.progress : null;
-    const nativeIdValue = progressPayload?.id ?? payload?.id;
-    if (!payload || !nonBlankString(nativeIdValue)) {
-      throw new OmpRpcFaultError("protocolError", "Omp RPC Subagent frame has no stable ID");
-    }
-    const nativeSubagentId = nativeIdValue;
-    const callId = nativeSubagentId;
-    const emit = active?.onEvent ?? this.#options.onSubagentEvent;
-    if (value.type === "subagent_event") {
-      emit?.({ type: "subagent.transcript.changed", callId, nativeSubagentId });
-      return true;
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
     }
-    if (value.type === "subagent_lifecycle") {
-      const status2 = payload.status;
-      if (status2 === "started") {
-        const description = nonBlankString(payload.description) ? payload.description : nonBlankString(payload.agent) ? `${payload.agent} delegation` : "Subagent delegation";
-        emit?.({
-          type: "subagent.started",
-          callId,
-          nativeSubagentId,
-          description,
-          ...nonBlankString(payload.agent) ? { role: payload.agent } : {},
-          ...nonBlankString(payload.task) ? { prompt: payload.task } : {},
-          background: payload.detached === true,
-          ...typeof payload.sessionFile === "string" ? { sessionFile: payload.sessionFile } : {}
-        });
-        return true;
-      }
-      if (status2 !== "completed" && status2 !== "failed" && status2 !== "aborted") {
-        throw new OmpRpcFaultError("protocolError", "Omp RPC Subagent lifecycle status is invalid");
+  }
+  removeEmpty(array2) {
+    const ret = [];
+    for (let i = 0; i < array2.length; i++) {
+      if (array2[i]) {
+        ret.push(array2[i]);
       }
-      emit?.({
-        type: "subagent.completed",
-        callId,
-        nativeSubagentId,
-        isError: status2 !== "completed",
-        ...nonBlankString(payload.resultSummary) ? { resultSummary: payload.resultSummary } : {},
-        ...typeof payload.sessionFile === "string" ? { sessionFile: payload.sessionFile } : {}
-      });
-      return true;
     }
-    const progress = progressPayload;
-    if (!progress || !nonBlankString(progress.id) || progress.id !== nativeSubagentId) {
-      throw new OmpRpcFaultError("protocolError", "Omp RPC Subagent progress is invalid");
-    }
-    const status = subagentStatus(progress.status);
-    const recentOutput = Array.isArray(progress.recentOutput) ? progress.recentOutput.filter((item) => typeof item === "string") : [];
-    const resultSummary = recentOutput.at(-1);
-    emit?.({
-      type: "subagent.updated",
-      callId,
-      nativeSubagentId,
-      status,
-      ...nonBlankString(progress.description) ? { description: progress.description } : nonBlankString(payload.task) ? { description: payload.task } : {},
-      ...resultSummary !== void 0 ? { resultSummary } : {},
-      ...typeof payload.sessionFile === "string" ? { sessionFile: payload.sessionFile } : {}
-    });
-    return true;
+    return ret;
   }
-  #isBlockingInteraction(value) {
-    return ["select", "confirm", "input", "editor"].includes(String(value.method));
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  castInput(value, options) {
+    return value;
   }
-  #startInteraction(active, value) {
-    if (!this.#isBlockingInteraction(value))
-      return;
-    const requestId2 = value.id;
-    const method = value.method;
-    const title = value.title;
-    const timeoutMs = value.timeout;
-    if (typeof requestId2 !== "string" || requestId2.length === 0 || typeof method !== "string" || typeof title !== "string" || title.length === 0 || timeoutMs !== void 0 && (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs < 0) || active.interactions.has(requestId2)) {
-      throw new OmpRpcFaultError("protocolError", "Omp RPC returned an invalid Interaction request");
+  // 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;
     }
-    let request;
-    if (method === "select") {
-      if (!Array.isArray(value.options) || value.options.length === 0 || !value.options.every((option) => typeof option === "string" && option.length > 0)) {
-        throw new OmpRpcFaultError("protocolError", "Omp RPC select request has invalid options");
-      }
-      let optionDetails;
-      if (value.optionDetails !== void 0) {
-        if (!Array.isArray(value.optionDetails) || value.optionDetails.length !== value.options.length || !value.optionDetails.every((detail) => typeof detail === "object" && detail !== null && !Array.isArray(detail) && (detail.description === void 0 || typeof detail.description === "string"))) {
-          throw new OmpRpcFaultError("protocolError", "Omp RPC select option details are invalid");
+    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));
         }
-        optionDetails = value.optionDetails.map(({ description }) => description === void 0 ? {} : { description });
-      }
-      request = {
-        requestId: requestId2,
-        method,
-        title,
-        options: [...value.options],
-        ...optionDetails ? { optionDetails } : {},
-        ...typeof timeoutMs === "number" ? { timeoutMs } : {}
-      };
-    } else if (method === "confirm") {
-      if (typeof value.message !== "string") {
-        throw new OmpRpcFaultError("protocolError", "Omp RPC confirm request has no message");
-      }
-      request = {
-        requestId: requestId2,
-        method,
-        title,
-        message: value.message,
-        ...typeof timeoutMs === "number" ? { timeoutMs } : {}
-      };
-    } else if (method === "input") {
-      if (value.placeholder !== void 0 && typeof value.placeholder !== "string") {
-        throw new OmpRpcFaultError("protocolError", "Omp RPC input placeholder is invalid");
-      }
-      request = {
-        requestId: requestId2,
-        method,
-        title,
-        ...typeof value.placeholder === "string" ? { placeholder: value.placeholder } : {},
-        ...typeof timeoutMs === "number" ? { timeoutMs } : {}
-      };
-    } else {
-      if (value.prefill !== void 0 && typeof value.prefill !== "string") {
-        throw new OmpRpcFaultError("protocolError", "Omp RPC editor prefill is invalid");
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
       }
-      request = {
-        requestId: requestId2,
-        method: "editor",
-        title,
-        ...typeof value.prefill === "string" ? { prefill: value.prefill } : {},
-        ...typeof timeoutMs === "number" ? { timeoutMs } : {}
-      };
-    }
-    const pending = { request, timeout: null };
-    if (request.timeoutMs !== void 0) {
-      pending.timeout = setTimeout(() => {
-        if (this.#activeTurn !== active || !active.interactions.has(requestId2))
-          return;
-        void this.#resolveInteraction({ requestId: requestId2, cancelled: true }, "expired").catch((error51) => {
-          if (this.#closed || this.#failed)
-            return;
-          this.#fail(new OmpRpcFaultError("protocolError", `Omp RPC Interaction timeout handling failed: ${message2(error51)}`));
-        });
-      }, request.timeoutMs);
     }
-    active.interactions.set(requestId2, pending);
-    active.onEvent({ type: "interaction.requested", request });
+    return components;
   }
-  #handleResponse(value) {
-    const id = value.id;
-    if (typeof id !== "string") {
-      this.#fail(new OmpRpcFaultError("protocolError", "Omp RPC response has no id"));
-      return;
-    }
-    const pending = this.#pending.get(id);
-    const active = this.#activeTurn;
-    if (!pending) {
-      if (active?.promptId === id && value.command === "prompt" && value.success === false) {
-        active.failure = new Error(typeof value.error === "string" ? value.error : "Omp RPC command failed");
-        return;
+};
+
+// ../../../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();
       }
-      this.#fail(new OmpRpcFaultError("protocolError", "Omp RPC response id is not pending"));
-      return;
-    }
-    if (pending.timeout)
-      clearTimeout(pending.timeout);
-    this.#pending.delete(id);
-    if (value.success === true) {
-      if (pending.command === "prompt" && active?.promptId === id && isRecord8(value.data) && value.data.agentInvoked === false) {
-        this.#settleLocalTurn(active, { cancelled: false });
+      if (!options.newlineIsToken || !right.includes("\n")) {
+        right = right.trim();
       }
-      pending.resolve(value);
-    } else {
-      const error51 = typeof value.error === "string" ? value.error : "Omp RPC command failed";
-      if (value.command === pending.command && error51 === `Unknown command: ${pending.command}`) {
-        pending.reject(new OmpRpcUnsupportedCommandError(pending.command));
-      } else {
-        pending.reject(new Error(error51));
+    } 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);
   }
-  #startTool(active, value) {
-    const callId = value.toolCallId;
-    const toolName = value.toolName;
-    const argumentsResult = jsonValueSchema.safeParse(value.args);
-    if (typeof callId !== "string" || callId.length === 0 || typeof toolName !== "string" || toolName.length === 0 || !argumentsResult.success || active.tools.has(callId)) {
-      throw new OmpRpcFaultError("protocolError", "Omp RPC returned an invalid Tool start");
-    }
-    active.sawTool = true;
-    active.tools.set(callId, toolName);
-    active.onEvent({
-      type: "tool.started",
-      callId,
-      toolName,
-      arguments: argumentsResult.data
-    });
+};
+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");
   }
-  #updateTool(active, value) {
-    const callId = value.toolCallId;
-    if (typeof callId !== "string" || callId.length === 0) {
-      throw new OmpRpcFaultError("protocolError", "Omp RPC returned an invalid Tool update");
-    }
-    if (!active.tools.has(callId))
-      return;
-    const outputResult = jsonValueSchema.safeParse(value.partialResult ?? null);
-    if (!outputResult.success) {
-      throw new OmpRpcFaultError("protocolError", "Omp RPC returned an invalid Tool update");
-    }
-    active.onEvent({ type: "tool.updated", callId, output: outputResult.data });
+  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
   }
-  #completeTool(active, value) {
-    const callId = value.toolCallId;
-    const toolName = value.toolName;
-    if (typeof callId !== "string" || callId.length === 0) {
-      throw new OmpRpcFaultError("protocolError", "Omp RPC returned an invalid Tool end");
-    }
-    const expectedName = active.tools.get(callId);
-    if (expectedName === void 0)
-      return;
-    const result = jsonValueSchema.safeParse(value.result);
-    if (typeof toolName !== "string" || expectedName !== toolName || value.isError !== void 0 && typeof value.isError !== "boolean" || !result.success) {
-      throw new OmpRpcFaultError("protocolError", "Omp RPC returned an invalid Tool end");
+  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);
     }
-    active.tools.delete(callId);
-    active.onEvent({
-      type: "tool.completed",
-      callId,
-      toolName,
-      result: result.data,
-      isError: value.isError === true
-    });
   }
-  async #confirmCancelledTurn(active) {
-    if (this.#activeTurn !== active || active.cancellation !== "accepted" || active.settlement === "confirming" || active.cancellationChecking)
-      return;
-    active.cancellationChecking = true;
-    if (active.cancellationRecheck)
-      clearTimeout(active.cancellationRecheck);
-    active.cancellationRecheck = null;
-    try {
-      let response = await this.#send("get_state", {});
-      if (this.#activeTurn !== active)
-        return;
-      if (parseSessionStreaming(response)) {
-        await this.#send("abort", {});
-        if (this.#activeTurn !== active)
-          return;
-        response = await this.#send("get_state", {});
-      }
-      let state = parseSessionState(response);
-      if (this.#activeTurn !== active || active.cancellation !== "accepted")
-        return;
-      const data = sessionStateData(response);
-      if (!active.cancellationReloaded && state.sessionFile && state.sessionId === this.state.sessionId && state.sessionFile === this.state.sessionFile && data.isStreaming === false && data.isCompacting === false && data.queuedMessageCount === 0 && data.hasPendingAsyncWork === true && active.tools.size === 0) {
-        await this.verifySessionCwd(this.#options.cwd);
-        if (this.#activeTurn !== active)
-          return;
-        active.cancellationReloaded = true;
-        const reset = await this.#send("new_session", {});
-        if (this.#activeTurn !== active)
-          return;
-        if (!isRecord8(reset.data) || reset.data.cancelled !== false) {
-          throw new OmpRpcFaultError("unavailable", "Omp cancelled Session reset was refused");
-        }
-        const reloaded = await this.#send("switch_session", { sessionPath: state.sessionFile });
-        if (this.#activeTurn !== active)
-          return;
-        if (!isRecord8(reloaded.data) || reloaded.data.cancelled !== false) {
-          throw new OmpRpcFaultError("unavailable", "Omp cancelled Session reload was refused");
-        }
-        const previous = state;
-        response = await this.#send("get_state", {});
-        state = parseSessionState(response);
-        if (state.sessionId !== previous.sessionId || state.sessionFile !== previous.sessionFile) {
-          throw new OmpRpcFaultError("protocolError", "Omp cancelled Session reload changed its identity");
-        }
-        if (state.provider !== previous.provider || state.modelId !== previous.modelId) {
-          if (!previous.provider || !previous.modelId) {
-            throw new OmpRpcFaultError("protocolError", "Omp cancelled Session has no restorable Model");
-          }
-          await this.#send("set_model", { provider: previous.provider, modelId: previous.modelId });
-        }
-        if (previous.thinkingLevel && state.thinkingLevel !== previous.thinkingLevel) {
-          await this.#send("set_thinking_level", { level: previous.thinkingLevel });
-        }
-        response = await this.#send("get_state", {});
-        state = parseSessionState(response);
-        if (state.sessionId !== previous.sessionId || state.sessionFile !== previous.sessionFile || state.provider !== previous.provider || state.modelId !== previous.modelId || previous.thinkingLevel !== null && state.thinkingLevel !== previous.thinkingLevel) {
-          throw new OmpRpcFaultError("protocolError", "Omp cancelled Session reload changed its identity or configuration");
-        }
+  return retLines;
+}
+
+// ../../../node_modules/diff/libesm/patch/parse.js
+function parsePatch(uniDiff) {
+  const diffstr = uniDiff.split(/\n/), list = [];
+  let i = 0;
+  function parseIndex() {
+    const index = {};
+    list.push(index);
+    while (i < diffstr.length) {
+      const line = diffstr[i];
+      if (/^(---|\+\+\+|@@)\s/.test(line)) {
+        break;
       }
-      if (!cancellationSettled(response, active.terminalEnd)) {
-        active.settlement = "pending";
-        active.cancellationRecheck = setTimeout(() => {
-          active.cancellationRecheck = null;
-          void this.#confirmCancelledTurn(active);
-        }, 250);
-        return;
+      const header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line);
+      if (header) {
+        index.index = header[1];
+      }
+      i++;
+    }
+    parseFileHeader(index);
+    parseFileHeader(index);
+    index.hunks = [];
+    while (i < diffstr.length) {
+      const line = diffstr[i];
+      if (/^(Index:\s|diff\s|---\s|\+\+\+\s|===================================================================)/.test(line)) {
+        break;
+      } else if (/^@@/.test(line)) {
+        index.hunks.push(parseHunk());
+      } else if (line) {
+        throw new Error("Unknown line " + (i + 1) + " " + JSON.stringify(line));
+      } else {
+        i++;
       }
-      this.#state = state;
-      active.settlement = "confirmed";
-      this.#finishSettledTurn(active);
-    } catch (error51) {
-      if (this.#activeTurn !== active)
-        return;
-      const fault = error51 instanceof OmpRpcFaultError ? error51 : new OmpRpcFaultError("protocolError", `Omp RPC cancelled Turn state could not be confirmed: ${message2(error51)}`);
-      this.#terminateFailedCancellation(active, fault);
-    } finally {
-      active.cancellationChecking = false;
     }
   }
-  #settleLocalTurn(active, result) {
-    if (this.#activeTurn !== active || active.settlement !== "pending")
-      return;
-    active.localResult = result;
-    active.settlement = "confirming";
-    void this.#confirmSettledTurn(active);
-  }
-  async #confirmSettledTurn(active) {
-    try {
-      const response = await this.#send("get_state", {});
-      const state = parseSessionState(response);
-      if (this.#activeTurn !== active)
-        return;
-      if (active.cancellation !== "none") {
-        active.settlement = "pending";
-        if (active.cancellation === "accepted")
-          void this.#confirmCancelledTurn(active);
-        return;
+  function parseFileHeader(index) {
+    const fileHeader = /^(---|\+\+\+)\s+(.*)\r?$/.exec(diffstr[i]);
+    if (fileHeader) {
+      const data = fileHeader[2].split("	", 2), header = (data[1] || "").trim();
+      let fileName = data[0].replace(/\\\\/g, "\\");
+      if (/^".*"$/.test(fileName)) {
+        fileName = fileName.substr(1, fileName.length - 2);
       }
-      if (parseSessionStreaming(response)) {
-        throw new OmpRpcFaultError("protocolError", "Omp RPC completed Turn state is still Streaming");
+      if (fileHeader[1] === "---") {
+        index.oldFileName = fileName;
+        index.oldHeader = header;
+      } else {
+        index.newFileName = fileName;
+        index.newHeader = header;
       }
-      this.#state = state;
-      active.settlement = "confirmed";
-      this.#finishSettledTurn(active);
-    } catch (error51) {
-      if (this.#activeTurn !== active)
-        return;
-      const fault = error51 instanceof OmpRpcFaultError ? error51 : new OmpRpcFaultError("protocolError", `Omp RPC stable Turn state could not be confirmed: ${message2(error51)}`);
-      this.#fail(fault);
+      i++;
     }
   }
-  #finishSettledTurn(active) {
-    if (this.#activeTurn !== active || active.settlement !== "confirmed" || active.cancellation === "requesting") {
-      return;
+  function parseHunk() {
+    var _a3;
+    const chunkHeaderIndex = i, chunkHeaderLine = diffstr[i++], chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+    const hunk = {
+      oldStart: +chunkHeader[1],
+      oldLines: typeof chunkHeader[2] === "undefined" ? 1 : +chunkHeader[2],
+      newStart: +chunkHeader[3],
+      newLines: typeof chunkHeader[4] === "undefined" ? 1 : +chunkHeader[4],
+      lines: []
+    };
+    if (hunk.oldLines === 0) {
+      hunk.oldStart += 1;
     }
-    if (active.cancellationTimeout)
-      clearTimeout(active.cancellationTimeout);
-    active.cancellationTimeout = null;
-    if (active.cancellationRecheck)
-      clearTimeout(active.cancellationRecheck);
-    active.cancellationRecheck = null;
-    this.#closeInteractions(active, active.cancellation === "accepted" ? "cancelled" : "superseded");
-    if (active.tools.size > 0) {
-      this.#fail(new OmpRpcFaultError("protocolError", "Omp RPC settled with active Tool executions"));
-      return;
+    if (hunk.newLines === 0) {
+      hunk.newStart += 1;
     }
-    this.#activeTurn = null;
-    if (active.localResult) {
-      active.resolve({
-        text: active.text,
-        agentInvoked: false,
-        ...active.localResult,
-        cancelled: active.localResult.cancelled || active.cancellation === "accepted"
-      });
-    } else if (active.cancellation === "accepted") {
-      active.resolve({ text: active.text, cancelled: true, agentInvoked: true });
-    } else if (active.failure) {
-      active.reject(active.failure);
-    } else if (active.text.trim().length === 0 && !active.sawTool) {
-      active.reject(new Error("Omp RPC settled without displayable output"));
-    } else {
-      active.resolve({ text: active.text, cancelled: false, agentInvoked: true });
+    let addCount = 0, removeCount = 0;
+    for (; i < diffstr.length && (removeCount < hunk.oldLines || addCount < hunk.newLines || ((_a3 = diffstr[i]) === null || _a3 === void 0 ? void 0 : _a3.startsWith("\\"))); i++) {
+      const operation = diffstr[i].length == 0 && i != diffstr.length - 1 ? " " : diffstr[i][0];
+      if (operation === "+" || operation === "-" || operation === " " || operation === "\\") {
+        hunk.lines.push(diffstr[i]);
+        if (operation === "+") {
+          addCount++;
+        } else if (operation === "-") {
+          removeCount++;
+        } else if (operation === " ") {
+          addCount++;
+          removeCount++;
+        }
+      } else {
+        throw new Error(`Hunk at line ${chunkHeaderIndex + 1} contained invalid line ${diffstr[i]}`);
+      }
     }
-  }
-  #startAssistantMessage(active, value) {
-    if (active.assistantMessageId !== null && active.reasoningMessageOpen) {
-      active.onEvent({ type: "reasoning.completed", messageId: active.assistantMessageId });
+    if (!addCount && hunk.newLines === 1) {
+      hunk.newLines = 0;
     }
-    const messageId = assistantMessageId(value) ?? randomUUID();
-    active.assistantMessageId = messageId;
-    active.sawStreamedMessageText = false;
-    active.sawStreamedMessageReasoning = false;
-    active.reasoningMessageOpen = false;
-    return messageId;
+    if (!removeCount && hunk.oldLines === 1) {
+      hunk.oldLines = 0;
+    }
+    if (addCount !== hunk.newLines) {
+      throw new Error("Added line count did not match for hunk at line " + (chunkHeaderIndex + 1));
+    }
+    if (removeCount !== hunk.oldLines) {
+      throw new Error("Removed line count did not match for hunk at line " + (chunkHeaderIndex + 1));
+    }
+    return hunk;
   }
-  #ensureAssistantMessage(active, value) {
-    return active.assistantMessageId ?? this.#startAssistantMessage(active, value);
+  while (i < diffstr.length) {
+    parseIndex();
   }
-  #finalizeAssistantMessage(active, value) {
-    const finalText = assistantText(value);
-    const finalReasoning = assistantReasoning(value);
-    const failure = assistantFailure(value);
-    const cacheHitRatePercent = optionalOmpCacheHitRatePercent(value);
-    if (finalText === null || finalReasoning === null || failure === void 0)
-      return;
-    if (active.assistantMessageId === null && finalText === active.lastFinalizedMessageText && finalReasoning === active.lastFinalizedMessageReasoning && !active.sawStreamedMessageText && !active.sawStreamedMessageReasoning) {
+  return list;
+}
+
+// ../../../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;
     }
-    active.failure = failure;
-    this.#latestCacheHitRatePercent = cacheHitRatePercent;
-    const messageId = this.#ensureAssistantMessage(active, value);
-    if (!active.sawStreamedMessageReasoning && finalReasoning.length > 0) {
-      active.reasoningMessageOpen = true;
-      active.onEvent({ type: "reasoning.delta", messageId, delta: finalReasoning });
+    diff.push({ value: "", lines: [] });
+    function contextLines(lines) {
+      return lines.map(function(entry) {
+        return " " + entry;
+      });
     }
-    if (active.reasoningMessageOpen && active.failure === null) {
-      active.onEvent({ type: "reasoning.completed", messageId });
+    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 (!active.sawStreamedMessageText && finalText.length > 0) {
-      active.text += finalText;
-      active.onEvent({ type: "text.delta", messageId, delta: finalText });
+    if (hunk.newLines === 0) {
+      hunk.newStart -= 1;
     }
-    active.assistantMessageId = null;
-    active.sawStreamedMessageText = false;
-    active.sawStreamedMessageReasoning = false;
-    active.reasoningMessageOpen = false;
-    active.lastFinalizedMessageText = finalText;
-    active.lastFinalizedMessageReasoning = finalReasoning;
-    active.onEvent({ type: "message.completed", messageId });
-  }
-  #write(value) {
-    const child = this.#child;
-    if (!child?.stdin.writable || this.#closed || this.#failed) {
-      return Promise.reject(new Error("Omp RPC stdin is unavailable"));
+    ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@");
+    for (const line of hunk.lines) {
+      ret.push(line);
     }
-    return new Promise((resolve, reject) => {
-      const frame = Buffer.from(`${JSON.stringify(value)}
-`, "utf8");
-      child.stdin.write(frame, (error51) => error51 ? reject(error51) : resolve());
-    });
   }
-  #send(type, payload, id = `codexhost-${randomUUID()}`) {
-    const child = this.#child;
-    if (!child?.stdin.writable || this.#closed || this.#failed) {
-      return Promise.reject(new Error("Omp RPC stdin is unavailable"));
-    }
-    return new Promise((resolve, reject) => {
-      const pending = {
-        command: type,
-        resolve,
-        reject,
-        timeout: null
-      };
-      this.#pending.set(id, pending);
-      this.#armCommandTimeout(id, pending);
-      const frame = Buffer.from(`${JSON.stringify({ id, type, ...payload })}
-`, "utf8");
-      child.stdin.write(frame, (error51) => {
-        if (error51) {
-          if (pending.timeout)
-            clearTimeout(pending.timeout);
-          this.#pending.delete(id);
-          reject(error51);
-        }
-      });
-    });
+  return ret.join("\n") + "\n";
+}
+function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  if (typeof options === "function") {
+    options = { callback: options };
   }
-  #armCommandTimeout(id, pending) {
-    if (pending.timeout || this.#pending.get(id) !== pending || (pending.command === "prompt" || pending.command === "compact") && this.#compactionActive) {
+  if (!(options === null || options === void 0 ? void 0 : options.callback)) {
+    const patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
+    if (!patchObj) {
       return;
     }
-    pending.timeout = setTimeout(() => {
-      if (this.#pending.get(id) !== pending)
-        return;
-      pending.timeout = null;
-      const error51 = new Error(`Omp RPC '${pending.command}' command timed out`);
-      if (pending.command !== "prompt") {
-        this.#pending.delete(id);
-        pending.reject(error51);
-        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));
       }
-      const fault = new OmpRpcFaultError("protocolError", error51.message);
-      void this.#terminateTimedOutPrompt(fault);
-    }, this.#options.commandTimeoutMs);
+    } }));
   }
-  async #terminateTimedOutPrompt(fault) {
-    if (this.#closed || this.#failed)
-      return;
-    this.#failed = true;
-    this.#closed = true;
-    for (const pending of this.#pending.values()) {
-      if (pending.timeout)
-        clearTimeout(pending.timeout);
-      pending.timeout = null;
-    }
-    let finalFault = fault;
-    try {
-      await this.close();
-    } catch (error51) {
-      finalFault = new OmpRpcFaultError("processExited", `Omp RPC timed-out Prompt cleanup failed: ${message2(error51)}`);
-    }
-    this.#rejectAll(finalFault);
-    this.#options.onFault?.(finalFault);
+}
+function splitLines(text) {
+  const hasTrailingNl = text.endsWith("\n");
+  const result = text.split("\n").map((line) => line + "\n");
+  if (hasTrailingNl) {
+    result.pop();
+  } else {
+    result.push(result.pop().slice(0, -1));
   }
-  #closeInteractions(active, reason) {
-    for (const [requestId2, pending] of active.interactions) {
-      active.interactions.delete(requestId2);
-      if (pending.timeout)
-        clearTimeout(pending.timeout);
-      active.onEvent({ type: "interaction.closed", requestId: requestId2, reason });
-    }
+  return result;
+}
+
+// dist/omp-adapter.js
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { realpath as realpath3, stat as stat2 } from "node:fs/promises";
+import path7 from "node:path";
+
+// dist/omp-last-turn-rollback.js
+function modelFromState(state) {
+  if (state.provider === null && state.modelId === null)
+    return null;
+  if (state.provider === null || state.modelId === null) {
+    throw new Error("Omp state contains a partial Model identity");
   }
-  #rejectActiveTurn(error51) {
-    const active = this.#activeTurn;
-    if (!active)
-      return;
-    if (active.cancellationTimeout)
-      clearTimeout(active.cancellationTimeout);
-    if (active.cancellationRecheck)
-      clearTimeout(active.cancellationRecheck);
-    this.#closeInteractions(active, "cancelled");
-    this.#activeTurn = null;
-    active.reject(error51);
+  return { provider: state.provider, id: state.modelId };
+}
+async function rollbackOmpLastTurn(transport, sourceSessionId, cwd) {
+  const startupState = transport.state;
+  const startupSessionId = startupState.sessionId;
+  const currentModel = modelFromState(startupState);
+  const currentThinking = startupState.thinkingLevel;
+  const copiedHistory = await transport.getEntries();
+  const boundary = resolveOmpLastTurnBoundary(copiedHistory);
+  if (!boundary)
+    return { ok: false, reason: "empty" };
+  const sourceSnapshot = mapOmpSnapshot(copiedHistory, {
+    sessionId: startupSessionId,
+    model: currentModel
+  });
+  let state = await transport.fork(boundary.lastUserEntryId);
+  if (state.sessionId === sourceSessionId || state.sessionId === startupSessionId) {
+    throw new Error("Omp last-Turn rollback did not create a distinct Native Session");
   }
-  #rejectAll(error51) {
-    if (this.#compactionTimeout)
-      clearTimeout(this.#compactionTimeout);
-    this.#compactionTimeout = null;
-    for (const pending of this.#pending.values()) {
-      if (pending.timeout)
-        clearTimeout(pending.timeout);
-      pending.reject(error51);
-    }
-    this.#pending.clear();
-    const manual = this.#manualCompaction;
-    this.#manualCompaction = null;
-    manual?.reject(error51);
-    this.#rejectActiveTurn(error51);
+  if (!sameOmpModel(modelFromState(state), currentModel)) {
+    if (!currentModel)
+      throw new Error("Omp last-Turn rollback changed the current Model");
+    state = await transport.selectModel(currentModel);
   }
-  #fail(error51) {
-    if (this.#closed || this.#failed)
-      return;
-    this.#failed = true;
-    this.#startupFaultResolve?.(error51);
-    this.#startupFaultResolve = null;
-    this.#rejectAll(error51);
-    this.#options.onFault?.(error51);
+  if (state.thinkingLevel !== currentThinking) {
+    if (!currentThinking)
+      throw new Error("Omp last-Turn rollback changed current Thinking");
+    state = await transport.selectThinkingOption(currentThinking);
   }
-};
+  if (!sameOmpModel(modelFromState(state), currentModel) || state.thinkingLevel !== currentThinking) {
+    throw new Error("Omp last-Turn rollback could not restore current Model and Thinking");
+  }
+  const snapshot = mapOmpSnapshot(await transport.getEntries(), {
+    sessionId: state.sessionId,
+    model: modelFromState(state)
+  });
+  const expectedTurnKeys = sourceSnapshot.turns.slice(0, -1).map((turn) => turn.nativeTurnRef.nativeTurnKey);
+  const actualTurnKeys = snapshot.turns.map((turn) => turn.nativeTurnRef.nativeTurnKey);
+  if (snapshot.turns.length !== boundary.sourceTurnCount - 1 || actualTurnKeys.some((key, index) => key !== expectedTurnKeys[index])) {
+    throw new Error("Omp last-Turn rollback did not produce the exact retained history prefix");
+  }
+  await transport.verifySessionCwd(cwd);
+  return { ok: true };
+}
 
 // dist/omp-permission-modes.js
 var nativePermissionModes = /* @__PURE__ */ new Set(["always-ask", "write", "yolo"]);
@@ -20190,6 +20309,24 @@ var OmpSubagentLifecycle = class {
 };
 
 // dist/omp-adapter.js
+function closedInspection() {
+  return {
+    status: "unavailable",
+    error: { code: "invalidState", message: "Omp Adapter is closed", retryable: false }
+  };
+}
+function ompInspectionCapabilities(selectThinkingOption) {
+  return {
+    configuration: {
+      selectModel: true,
+      selectThinkingOption,
+      selectPermissionMode: true,
+      permissionModeScope: "live"
+    },
+    history: { fork: true, forkAcrossCwd: true, rollbackLastTurn: true },
+    subagents: { observe: true, readTranscript: true }
+  };
+}
 var ompHarnessId2 = harnessIdSchema.parse("omp");
 var ompCommandCatalog = harnessCommandCatalogSchema.parse({
   commands: [
@@ -20204,7 +20341,7 @@ var ompCommandCatalog = harnessCommandCatalogSchema.parse({
   ]
 });
 var DEFAULT_TOOL_OUTPUT_LIMIT = 64e3;
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function errorMessage(error51) {
@@ -20219,7 +20356,7 @@ var OmpAdapterFaultError = class extends Error {
   }
 };
 function normalizedError(error51, fallbackCode) {
-  if (isRecord9(error51) && error51.code === "ENOENT") {
+  if (isRecord10(error51) && error51.code === "ENOENT") {
     return { code: "notInstalled", message: errorMessage(error51), retryable: false };
   }
   if (error51 instanceof OmpAdapterFaultError)
@@ -20296,7 +20433,7 @@ function nativeModelForHistory(state) {
   return nativeModelFromState(state);
 }
 function sessionFileFromRef(ref) {
-  if (ref.harnessId !== ompHarnessId2 || !isRecord9(ref.locator) || typeof ref.locator.sessionFile !== "string" || ref.locator.sessionFile.length === 0) {
+  if (ref.harnessId !== ompHarnessId2 || !isRecord10(ref.locator) || typeof ref.locator.sessionFile !== "string" || ref.locator.sessionFile.length === 0) {
     throw new Error("Omp Native Session Ref has no resumable Session file");
   }
   return ref.locator.sessionFile;
@@ -20351,9 +20488,9 @@ function toolFailure(toolName) {
 function nativeText(value) {
   if (typeof value === "string")
     return value;
-  if (!isRecord9(value) || !Array.isArray(value.content))
+  if (!isRecord10(value) || !Array.isArray(value.content))
     return "";
-  return value.content.filter((content) => isRecord9(content) && content.type === "text" && typeof content.text === "string").map(({ text }) => text).join("");
+  return value.content.filter((content) => isRecord10(content) && content.type === "text" && typeof content.text === "string").map(({ text }) => text).join("");
 }
 function boundedOutput(value, limit) {
   const text = nativeText(value);
@@ -20369,17 +20506,17 @@ function outputText(output) {
   return output?.content.filter((content) => content.type === "text").map(({ text }) => text).join("") ?? "";
 }
 function stringField2(value, key) {
-  if (!isRecord9(value))
+  if (!isRecord10(value))
     return void 0;
   const field = value[key];
   if (typeof field === "string" && field.length > 0)
     return field;
-  if (isRecord9(value.input)) {
+  if (isRecord10(value.input)) {
     const nested = value.input[key];
     if (typeof nested === "string" && nested.length > 0)
       return nested;
   }
-  if (isRecord9(value.arguments)) {
+  if (isRecord10(value.arguments)) {
     const nested = value.arguments[key];
     if (typeof nested === "string" && nested.length > 0)
       return nested;
@@ -20387,7 +20524,7 @@ function stringField2(value, key) {
   return void 0;
 }
 function numberField(value, key) {
-  if (!isRecord9(value))
+  if (!isRecord10(value))
     return void 0;
   const field = value[key];
   return typeof field === "number" || field === null ? field : void 0;
@@ -20426,7 +20563,7 @@ function fileMutatingKind(toolName) {
   return null;
 }
 function nestedToolString(value, keys) {
-  if (!isRecord9(value))
+  if (!isRecord10(value))
     return void 0;
   for (const key of keys) {
     const field = value[key];
@@ -20441,14 +20578,14 @@ function nestedToolString(value, keys) {
   return void 0;
 }
 function patchFromResult(result) {
-  if (!isRecord9(result))
+  if (!isRecord10(result))
     return void 0;
   for (const key of ["patch", "diff", "unifiedDiff"]) {
     const field = result[key];
     if (typeof field === "string" && field.length > 0)
       return field;
   }
-  if (isRecord9(result.details)) {
+  if (isRecord10(result.details)) {
     for (const key of ["patch", "diff", "unifiedDiff"]) {
       const field = result.details[key];
       if (typeof field === "string" && field.length > 0)
@@ -22023,6 +22160,9 @@ var OmpAdapter = class {
   #inspectionCache = /* @__PURE__ */ new Map();
   #inspectionInFlight = /* @__PURE__ */ new Map();
   #inspections = /* @__PURE__ */ new Set();
+  #availabilityInFlight = /* @__PURE__ */ new Map();
+  #availabilityListings = /* @__PURE__ */ new Set();
+  #listModels;
   #sessions = /* @__PURE__ */ new Set();
   #toolOutputLimit;
   #closePromise = null;
@@ -22031,22 +22171,21 @@ var OmpAdapter = class {
     createTransport: (sessionOptions) => new OmpRpcSession({ ...options, ...sessionOptions })
   }) {
     this.#createTransport = dependencies.createTransport;
+    const listModels = dependencies.listModels ?? listOmpModels;
+    this.#listModels = ({ cwd, signal }) => listModels({
+      cwd,
+      signal,
+      ...options.command ? { command: options.command } : {},
+      ...options.environment ? { environment: options.environment } : {}
+    });
     this.sessionImport = new OmpSessionImport({ ...process.env, ...options.environment });
     this.usageStatistics = createOmpUsageStatistics({ ...process.env, ...options.environment });
     this.#closeTimeoutMs = options.closeTimeoutMs ?? 2e3;
     this.#toolOutputLimit = options.toolOutputLimit ?? DEFAULT_TOOL_OUTPUT_LIMIT;
   }
   async inspect(input = {}) {
-    if (this.#closePromise) {
-      return {
-        status: "unavailable",
-        error: {
-          code: "invalidState",
-          message: "Omp Adapter is closed",
-          retryable: false
-        }
-      };
-    }
+    if (this.#closePromise)
+      return closedInspection();
     const cwd = input.cwd ?? process.cwd();
     const inFlight = this.#inspectionInFlight.get(cwd);
     if (inFlight)
@@ -22056,6 +22195,37 @@ var OmpAdapter = class {
       if (cached2)
         return cached2;
     }
+    if (input.purpose === "availability")
+      return this.#inspectAvailability(cwd, input.refresh);
+    return this.#startFullInspection(cwd);
+  }
+  /**
+   * Availability without a Session: a Session startup runs OMP's own startup work, including
+   * Provider connection prewarm, for a Harness the user may never select. The listed result
+   * carries no native default Model or Thinking option, so it is neither cached nor used to
+   * update `#thinkingSelectionSupported`. When the list cannot answer, a full inspection answers
+   * instead, reusing one that is in flight or finished meanwhile.
+   */
+  async #inspectAvailability(cwd, refresh = false) {
+    if (refresh)
+      this.#inspectionCache.delete(cwd);
+    let pending = this.#availabilityInFlight.get(cwd);
+    if (!pending) {
+      const listing = this.#listAvailability(cwd);
+      pending = listing.finally(() => {
+        if (this.#availabilityInFlight.get(cwd) === pending)
+          this.#availabilityInFlight.delete(cwd);
+      });
+      this.#availabilityInFlight.set(cwd, pending);
+    }
+    const listed = await pending;
+    if (listed)
+      return listed;
+    if (this.#closePromise)
+      return closedInspection();
+    return this.#inspectionInFlight.get(cwd) ?? this.#inspectionCache.get(cwd) ?? this.#startFullInspection(cwd);
+  }
+  #startFullInspection(cwd) {
     const inspection = this.#inspectCwd(cwd).then((result) => {
       if (result.status === "ready")
         this.#inspectionCache.set(cwd, result);
@@ -22068,6 +22238,59 @@ var OmpAdapter = class {
       }
     });
   }
+  /** Returns null when a Session must answer: this OMP cannot list Models, or lists none. */
+  async #listAvailability(cwd) {
+    const startedAt = Date.now();
+    const stage = "model-list";
+    const controller = new AbortController();
+    this.#availabilityListings.add(controller);
+    let listed;
+    try {
+      listed = await this.#listModels({ cwd, signal: controller.signal });
+    } finally {
+      this.#availabilityListings.delete(controller);
+    }
+    if (listed.kind === "unanswered")
+      return null;
+    if (listed.kind === "notInstalled") {
+      return {
+        status: "notInstalled",
+        error: {
+          code: "notInstalled",
+          message: listed.message,
+          retryable: false,
+          stage,
+          durationMs: Date.now() - startedAt
+        }
+      };
+    }
+    if (listed.kind === "timedOut") {
+      return {
+        status: "error",
+        error: {
+          code: "unavailable",
+          message: "Oh My Pi did not list its models in time",
+          retryable: true,
+          stage,
+          durationMs: Date.now() - startedAt
+        }
+      };
+    }
+    if (listed.models.length === 0)
+      return null;
+    let catalog;
+    try {
+      catalog = normalizeOmpModelCatalog(listed.models, null, null, null);
+    } catch {
+      return null;
+    }
+    return {
+      status: "ready",
+      catalog,
+      permissionModes: OMP_PERMISSION_MODE_CATALOG,
+      capabilities: ompInspectionCapabilities(false)
+    };
+  }
   async #inspectCwd(cwd) {
     const startedAt = Date.now();
     let stage = "spawn";
@@ -22091,16 +22314,7 @@ var OmpAdapter = class {
         status: "ready",
         catalog,
         permissionModes: OMP_PERMISSION_MODE_CATALOG,
-        capabilities: {
-          configuration: {
-            selectModel: true,
-            selectThinkingOption: thinkingLevels !== null,
-            selectPermissionMode: true,
-            permissionModeScope: "live"
-          },
-          history: { fork: true, forkAcrossCwd: true, rollbackLastTurn: true },
-          subagents: { observe: true, readTranscript: true }
-        }
+        capabilities: ompInspectionCapabilities(thinkingLevels !== null)
       };
     } catch (error51) {
       await transport.close().catch(() => void 0);
@@ -22311,6 +22525,8 @@ var OmpAdapter = class {
   }
   close() {
     if (!this.#closePromise) {
+      for (const listing of this.#availabilityListings)
+        listing.abort();
       this.#closePromise = Promise.all([
         this.sessionImport.close(),
         ...[...this.#inspections].map((transport) => transport.close()),