@codexhost/cli-linux-arm64 0.13.3 → 0.14.0

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;
@@ -15202,10 +15205,19 @@ var model = external_exports.string().min(1).max(512);
 var project = external_exports.string().min(1).max(4096);
 var usageStatisticsParamsSchema = external_exports.strictObject({
   range: external_exports.enum(USAGE_STATISTICS_RANGES),
+  /** Display timezone for ranges, dates and hourly buckets; omitted means the Host's local zone. */
+  timeZone: external_exports.string().min(1).max(128).refine((value) => {
+    try {
+      new Intl.DateTimeFormat("en", { timeZone: value });
+      return true;
+    } catch {
+      return false;
+    }
+  }, "Unsupported usage statistics timezone").optional(),
   harness: harness.optional(),
   model: model.nullable().optional(),
   project: project.nullable().optional(),
-  /** One local date inside the range. */
+  /** One date in the query timezone inside the range. */
   date: localDate.optional()
 });
 var usageStatisticsTotalsSchema = external_exports.strictObject({
@@ -15241,7 +15253,7 @@ var usageStatisticsSessionSchema = external_exports.strictObject({
 });
 var usageStatisticsResultSchema = external_exports.strictObject({
   range: external_exports.enum(USAGE_STATISTICS_RANGES),
-  /** First local date of the range; null for all time. */
+  /** First date in the query timezone (Host local when omitted); null for all time. */
   from: localDate.nullable(),
   to: localDate,
   /** The filters these figures apply, echoed so a late answer to older filters is recognised. */
@@ -15281,7 +15293,7 @@ var usageStatisticsResultSchema = external_exports.strictObject({
   totals: usageStatisticsTotalsSchema,
   /** Each date and Harness of the range: every filter except the day. */
   daily: external_exports.array(external_exports.strictObject({ date: localDate, harness, ...totals })).max(2e5),
-  /** Local weekday (0 = Sunday) and hour, all filters applied. */
+  /** Weekday (0 = Sunday) and hour in the query timezone, all filters applied. */
   hourly: external_exports.array(external_exports.strictObject({
     weekday: external_exports.number().int().min(0).max(6),
     hour: external_exports.number().int().min(0).max(23),
@@ -15341,6 +15353,8 @@ var CONSOLE_HOST_METHODS = Object.freeze([
   "codexhost/harness/display-settings/set",
   "codexhost/harness/inspect",
   "codexhost/harness/installation",
+  "codexhost/harness/installation/start",
+  "codexhost/harness/installation/status",
   "codexhost/harness/launch-settings/get",
   "codexhost/harness/launch-settings/set",
   "codexhost/harness/web-ui/open",
@@ -15416,7 +15430,18 @@ var threadManualCompactionStartedSchema = external_exports.strictObject({
 var nonNegativeSafeIntegerSchema = external_exports.number().int().safe().nonnegative();
 var finiteNonNegativeNumberSchema = external_exports.number().finite().nonnegative();
 var cacheHitRatePercentSchema = external_exports.number().finite().min(0).max(100);
+var indicatorTextSchema = (maximum) => harnessLocalizedTextSchema.refine((entries) => Object.values(entries).every((text) => text.length <= maximum));
+var composerIndicatorsSchema = external_exports.array(external_exports.object({
+  kind: external_exports.literal("countdown"),
+  id: external_exports.string().min(1).max(64),
+  expiresAtUnix: nonNegativeSafeIntegerSchema,
+  label: indicatorTextSchema(256).optional(),
+  tooltip: indicatorTextSchema(1024).optional()
+}).strict()).max(2).refine((entries) => new Set(entries.map(({ id }) => id)).size === entries.length, {
+  message: "Composer indicator IDs must be unique"
+});
 var threadUsageSnapshotSchema = external_exports.object({
+  composerIndicators: composerIndicatorsSchema.optional(),
   inputTokens: nonNegativeSafeIntegerSchema.optional(),
   cachedInputTokens: nonNegativeSafeIntegerSchema.optional(),
   cacheWriteInputTokens: nonNegativeSafeIntegerSchema.optional(),
@@ -15824,7 +15849,9 @@ var harnessSessionCapabilitiesSchema = external_exports.object({
   }).strict().optional(),
   autonomousTurns: external_exports.object({
     observe: external_exports.boolean()
-  }).strict().optional()
+  }).strict().optional(),
+  /** True only when `turn.steer` delivers input into the active Turn through a native primitive. */
+  steer: external_exports.boolean().optional()
 }).strict();
 var harnessConfigurationStateSchema = external_exports.object({
   effectiveModel: harnessModelRefSchema.optional(),
@@ -15871,7 +15898,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
@@ -15954,6 +15983,15 @@ var threadOwnershipListResultSchema = external_exports.object({
     seen.add(thread.threadId);
   }
 });
+var threadSteeringInspectParamsSchema = external_exports.object({
+  threadId: hostThreadIdSchema,
+  /** The text about to be steered; a Harness command always stops and restarts. */
+  text: external_exports.string().optional()
+}).strict();
+var threadSteerDeliverySchema = external_exports.enum(["activeTurn", "newTurn"]);
+var threadSteeringInspectResultSchema = external_exports.object({
+  delivery: external_exports.enum(["official", "activeTurn", "newTurn"])
+}).strict();
 
 // ../../shared-contracts/dist/harness-plugins.js
 var HARNESS_PLUGIN_MANIFEST_MAX_BYTES = 32 * 1024;
@@ -16055,6 +16093,10 @@ var harnessInstallationStateSchema = external_exports.object({
   latestVersion: external_exports.string().min(1).max(128),
   updateAvailable: external_exports.boolean(),
   canUpdate: external_exports.boolean(),
+  /** Defaults to CLI; some Harnesses ship only inside a desktop application. */
+  versionKind: external_exports.enum(["cli", "application"]).optional(),
+  /** Official download opened by the user; does not imply an automatic installation. */
+  manualUpdateUrl: external_exports.url().max(2048).refine((value) => /^https:\/\/[^/?#@]+(?:[/?#]|$)/iu.test(value), "Manual updates require a credential-free HTTPS URL").optional(),
   // Adapter-owned diagnostic text; UI uses messageCode rather than displaying it verbatim.
   message: external_exports.string().max(2048).optional(),
   messageCode: external_exports.string().min(1).max(128).optional(),
@@ -16062,6 +16104,20 @@ var harnessInstallationStateSchema = external_exports.object({
   notice: harnessLocalizedTextSchema.optional(),
   latestVersionKind: external_exports.enum(["unknown", "tracking-branch"]).optional()
 }).strict();
+var harnessInstallationTaskParamsSchema = external_exports.object({ taskId: external_exports.string().uuid() }).strict();
+var harnessInstallationTaskSchema = external_exports.discriminatedUnion("status", [
+  external_exports.object({ taskId: external_exports.string().uuid(), status: external_exports.literal("running") }).strict(),
+  external_exports.object({
+    taskId: external_exports.string().uuid(),
+    status: external_exports.literal("succeeded"),
+    result: harnessInstallationStateSchema
+  }).strict(),
+  external_exports.object({
+    taskId: external_exports.string().uuid(),
+    status: external_exports.literal("failed"),
+    error: external_exports.object({ code: external_exports.number().int(), message: external_exports.string().min(1).max(2048) }).strict()
+  }).strict()
+]);
 
 // ../../shared-contracts/dist/codex-accounts.js
 var accountIdSchema = external_exports.string().min(1).max(256).regex(/^[A-Za-z0-9._~-]+$/u);
@@ -16863,6 +16919,18 @@ function sanitizeDiagnosticTail(value) {
   return redacted.length <= DIAGNOSTIC_TAIL_MAX_LENGTH ? redacted : redacted.slice(-DIAGNOSTIC_TAIL_MAX_LENGTH);
 }
 
+// ../../harness-adapter/dist/steer.js
+function unsupportedSteer(harnessLabel) {
+  return {
+    ok: false,
+    error: {
+      code: "unsupported",
+      message: `${harnessLabel} cannot steer an active Turn natively`,
+      retryable: false
+    }
+  };
+}
+
 // ../../harness-adapter/dist/usage.js
 var tokenFields = [
   "inputTokens",
@@ -16890,6 +16958,7 @@ var usageFields = /* @__PURE__ */ new Set([
   ...safeIntegerFields,
   ...percentFields,
   "sessionCacheUsage",
+  "composerIndicators",
   "totalCostUsd",
   "totalCredits",
   "contextUsagePercent",
@@ -16912,6 +16981,7 @@ function parseHostUsage(value) {
       throw new Error(`Harness Usage contains unknown field '${key}'`);
     }
   }
+  const indicators = value.composerIndicators === void 0 ? {} : { composerIndicators: composerIndicatorsSchema.parse(value.composerIndicators) };
   for (const field of [
     "totalCredits",
     "contextUsagePercent",
@@ -16982,9 +17052,9 @@ function parseHostUsage(value) {
     if (value.costSource !== "publicPrice") {
       throw new Error("Harness Usage 'unpricedModels' must be provided with a 'publicPrice' cost");
     }
-    return { ...value, unpricedModels: [...models] };
+    return { ...value, ...indicators, unpricedModels: [...models] };
   }
-  return { ...value };
+  return { ...value, ...indicators };
 }
 var requestTokenFields = [
   "inputTokens",
@@ -17711,857 +17781,283 @@ 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 (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]);
+      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 };
     }
-    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");
-  }
-  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
-  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
-    linesAndNewlines.pop();
-  }
-  for (let i = 0; i < linesAndNewlines.length; i++) {
-    const line = linesAndNewlines[i];
-    if (i % 2 && !options.newlineIsToken) {
-      retLines[retLines.length - 1] += line;
-    } else {
-      retLines.push(line);
-    }
+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 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;
-      }
-      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 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++;
-    }
-  }
-  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 hunk;
-  }
-  while (i < diffstr.length) {
-    parseIndex();
-  }
-  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;
-    }
-    diff.push({ value: "", lines: [] });
-    function contextLines(lines) {
-      return lines.map(function(entry) {
-        return " " + entry;
-      });
-    }
-    const hunks = [];
-    let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
-    for (let i = 0; i < diff.length; i++) {
-      const current = diff[i], lines = current.lines || splitLines(current.value);
-      current.lines = lines;
-      if (current.added || current.removed) {
-        if (!oldRangeStart) {
-          const prev = diff[i - 1];
-          oldRangeStart = oldLine;
-          newRangeStart = newLine;
-          if (prev) {
-            curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
-            oldRangeStart -= curRange.length;
-            newRangeStart -= curRange.length;
-          }
-        }
-        for (const line of lines) {
-          curRange.push((current.added ? "+" : "-") + line);
-        }
-        if (current.added) {
-          newLine += lines.length;
-        } else {
-          oldLine += lines.length;
-        }
-      } else {
-        if (oldRangeStart) {
-          if (lines.length <= context * 2 && i < diff.length - 2) {
-            for (const line of contextLines(lines)) {
-              curRange.push(line);
-            }
-          } else {
-            const contextSize = Math.min(lines.length, context);
-            for (const line of contextLines(lines.slice(0, contextSize))) {
-              curRange.push(line);
-            }
-            const hunk = {
-              oldStart: oldRangeStart,
-              oldLines: oldLine - oldRangeStart + contextSize,
-              newStart: newRangeStart,
-              newLines: newLine - newRangeStart + contextSize,
-              lines: curRange
-            };
-            hunks.push(hunk);
-            oldRangeStart = 0;
-            newRangeStart = 0;
-            curRange = [];
-          }
-        }
-        oldLine += lines.length;
-        newLine += lines.length;
-      }
-    }
-    for (const hunk of hunks) {
-      for (let i = 0; i < hunk.lines.length; i++) {
-        if (hunk.lines[i].endsWith("\n")) {
-          hunk.lines[i] = hunk.lines[i].slice(0, -1);
-        } else {
-          hunk.lines.splice(i + 1, 0, "\");
-          i++;
-        }
-      }
-    }
-    return {
-      oldFileName,
-      newFileName,
-      oldHeader,
-      newHeader,
-      hunks
-    };
-  }
-}
-function formatPatch(patch) {
-  if (Array.isArray(patch)) {
-    return patch.map(formatPatch).join("\n");
-  }
-  const ret = [];
-  if (patch.oldFileName == patch.newFileName) {
-    ret.push("Index: " + patch.oldFileName);
-  }
-  ret.push("===================================================================");
-  ret.push("--- " + patch.oldFileName + (typeof patch.oldHeader === "undefined" ? "" : "	" + patch.oldHeader));
-  ret.push("+++ " + patch.newFileName + (typeof patch.newHeader === "undefined" ? "" : "	" + patch.newHeader));
-  for (let i = 0; i < patch.hunks.length; i++) {
-    const hunk = patch.hunks[i];
-    if (hunk.oldLines === 0) {
-      hunk.oldStart -= 1;
-    }
-    if (hunk.newLines === 0) {
-      hunk.newStart -= 1;
-    }
-    ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@");
-    for (const line of hunk.lines) {
-      ret.push(line);
-    }
-  }
-  return ret.join("\n") + "\n";
-}
-function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
-  if (typeof options === "function") {
-    options = { callback: options };
-  }
-  if (!(options === null || options === void 0 ? void 0 : options.callback)) {
-    const patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
-    if (!patchObj) {
-      return;
-    }
-    return formatPatch(patchObj);
-  } else {
-    const { callback } = options;
-    structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, Object.assign(Object.assign({}, options), { callback: (patchObj) => {
-      if (!patchObj) {
-        callback(void 0);
-      } else {
-        callback(formatPatch(patchObj));
-      }
-    } }));
-  }
-}
-function splitLines(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 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
-      }
-    ];
-  });
-}
-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 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();
-  }
-  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");
-    }
-    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 };
-    }
-    throw new Error("Omp Session header is invalid");
-  } finally {
-    await handle.close();
-  }
-}
-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");
-  }
-  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");
-  }
-}
-
-// 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");
-  }
-  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");
-  }
-  if (!sameOmpModel(modelFromState(state), currentModel)) {
-    if (!currentModel)
-      throw new Error("Omp last-Turn rollback changed the current Model");
-    state = await transport.selectModel(currentModel);
-  }
-  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-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]
-  }
-};
-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;
-    try {
-      bytes = Buffer.from(data, "base64");
-    } catch {
-      throw new Error("Invalid OMP RPC chunk data");
-    }
-    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;
-  }
-};
-
-// 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 };
+  return { provider: value.provider, id: value.id };
 }
 function sessionStateData(response) {
   const data = isRecord8(response.data) ? response.data : null;
@@ -18789,1178 +18285,1844 @@ var OmpRpcSession = class {
     if (options.model && (options.sessionFile || options.forkSessionFile)) {
       throw new Error("Omp RPC cannot combine a startup Model with Session restore or Fork");
     }
-    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;
+    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"));
+      }
+    });
+    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);
+    }
+    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);
+    }
+    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 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");
+      }
+      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;
+      }
+      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;
+    }
+  }
+  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");
+    }
+    if (input.fromByte !== void 0 && (!Number.isSafeInteger(input.fromByte) || input.fromByte < 0)) {
+      throw new Error("Omp Subagent transcript offset 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 } : {}
+    });
+    return parseSubagentMessages(response);
+  }
+  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;
+  }
+  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;
+    }
   }
-  get state() {
-    if (!this.#state)
-      throw new Error("Omp RPC Session has not started");
-    return this.#state;
+  async #ensureLatestCacheHitRate() {
+    if (this.#latestCacheHitRatePercent !== void 0)
+      return;
+    try {
+      this.#latestCacheHitRatePercent = latestOmpCacheHitRatePercent(await this.getEntries());
+    } catch {
+      this.#latestCacheHitRatePercent = null;
+    }
   }
-  get stderrTail() {
-    return this.#stderrTail;
+  #withLatestCacheHitRate(usage) {
+    return this.#latestCacheHitRatePercent === null || this.#latestCacheHitRatePercent === void 0 ? usage : parseHostUsage({ ...usage, cacheHitRatePercent: this.#latestCacheHitRatePercent });
   }
-  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"));
+  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;
+    }
+  }
+  verifySessionCwd(expectedCwd) {
+    return verifyOmpSessionCwd({
+      sessionFile: this.state.sessionFile,
+      sessionId: this.state.sessionId,
+      expectedCwd
     });
-    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));
-      }
+  }
+  async getAvailableModels() {
+    try {
+      return parseAvailableModels(await this.#send("get_available_models", {}));
+    } catch (error51) {
+      if (error51 instanceof OmpRpcFaultError)
+        this.#fail(error51);
+      throw error51;
+    }
+  }
+  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;
+    }
+  }
+  async runTurn(text, onEvent) {
+    if (!this.#child || !this.#state || this.#closed || this.#failed) {
+      throw new Error("Omp RPC Session is unavailable");
+    }
+    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
+      };
     });
-    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);
+      await this.#send("prompt", { message: text }, promptId);
+    } catch (error51) {
+      this.#rejectActiveTurn(error51 instanceof Error ? error51 : new Error(message2(error51)));
     }
-    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 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");
+    }
+    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 {
-      this.#state = parseSessionState(await this.#send("get_state", {}));
+      await this.#write(frame);
     } catch (error51) {
-      const fault = error51 instanceof OmpRpcFaultError ? error51 : new OmpRpcFaultError("unavailable", `Omp RPC state unavailable: ${message2(error51)}`);
+      const fault = new OmpRpcFaultError("protocolError", `Omp RPC interaction response failed: ${message2(error51)}`);
       this.#fail(fault);
       throw fault;
     }
-    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");
+  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 () => {
+      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;
+  }
+  #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);
+  }
+  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))
+      return;
+    signalProcessTree(child, "SIGKILL");
+    if (!await waitForExit(child, this.#options.closeTimeoutMs)) {
+      throw new Error("Omp RPC process tree did not exit within cleanup bounds");
+    }
+  }
+  #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;
       }
-      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;
+        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) {
-        if (!(error51 instanceof OmpRpcUnsupportedCommandError))
-          throw error51;
+        this.#fail(error51 instanceof OmpRpcFaultError ? error51 : new OmpRpcFaultError("protocolError", `Omp RPC frame handling failed: ${message2(error51)}`));
       }
-      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;
+      newline = this.#buffer.indexOf(10);
     }
   }
-  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");
+  /** Latest `available_commands_update` of the running process, if any. */
+  get availableCommands() {
+    return this.#availableCommands;
+  }
+  #handle(value) {
+    if (this.#closed || this.#failed)
+      return;
+    if (value.type === "available_commands_update") {
+      this.#availableCommands = parseOmpAvailableCommands(value.commands);
+      return;
     }
-    if (input.fromByte !== void 0 && (!Number.isSafeInteger(input.fromByte) || input.fromByte < 0)) {
-      throw new Error("Omp Subagent transcript offset is invalid");
+    if (value.type === "ready") {
+      this.#readyResolve?.();
+      this.#readyResolve = null;
+      return;
+    }
+    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;
+      }
+      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);
+        }
+      }
+      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;
+    }
+    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);
     }
-    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 compact(customInstructions, onEvent) {
-    if (!this.#child || !this.#state || this.#closed || this.#failed) {
-      throw new Error("Omp RPC Session is unavailable");
+  /** 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 (this.#activeTurn || this.#manualCompaction || this.#compactionActive) {
-      throw new Error("Omp RPC Session already has an active operation");
+    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;
     }
-    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)));
+    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 result;
   }
-  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;
+  #handleSubagentFrame(active, value) {
+    if (value.type !== "subagent_lifecycle" && value.type !== "subagent_progress" && value.type !== "subagent_event") {
+      return false;
     }
-  }
-  async #ensureLatestCacheHitRate() {
-    if (this.#latestCacheHitRatePercent !== void 0)
-      return;
-    try {
-      this.#latestCacheHitRatePercent = latestOmpCacheHitRatePercent(await this.getEntries());
-    } catch {
-      this.#latestCacheHitRatePercent = null;
+    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");
     }
-  }
-  #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");
+    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;
       }
-      this.#state = parseSessionState(await this.#send("get_state", {}));
-      return this.#state;
-    } catch (error51) {
-      if (error51 instanceof OmpRpcFaultError)
-        this.#fail(error51);
-      throw error51;
+      if (status2 !== "completed" && status2 !== "failed" && status2 !== "aborted") {
+        throw new OmpRpcFaultError("protocolError", "Omp RPC Subagent lifecycle status is invalid");
+      }
+      emit?.({
+        type: "subagent.completed",
+        callId,
+        nativeSubagentId,
+        isError: status2 !== "completed",
+        ...nonBlankString(payload.resultSummary) ? { resultSummary: payload.resultSummary } : {},
+        ...typeof payload.sessionFile === "string" ? { sessionFile: payload.sessionFile } : {}
+      });
+      return true;
     }
-  }
-  verifySessionCwd(expectedCwd) {
-    return verifyOmpSessionCwd({
-      sessionFile: this.state.sessionFile,
-      sessionId: this.state.sessionId,
-      expectedCwd
-    });
-  }
-  async getAvailableModels() {
-    try {
-      return parseAvailableModels(await this.#send("get_available_models", {}));
-    } catch (error51) {
-      if (error51 instanceof OmpRpcFaultError)
-        this.#fail(error51);
-      throw error51;
+    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;
   }
-  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;
-    }
+  #isBlockingInteraction(value) {
+    return ["select", "confirm", "input", "editor"].includes(String(value.method));
   }
-  async runTurn(text, onEvent) {
-    if (!this.#child || !this.#state || this.#closed || this.#failed) {
-      throw new Error("Omp RPC Session is unavailable");
+  #startInteraction(active, value) {
+    if (!this.#isBlockingInteraction(value))
+      return;
+    const requestId = value.id;
+    const method = value.method;
+    const title = value.title;
+    const timeoutMs = value.timeout;
+    if (typeof requestId !== "string" || requestId.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(requestId)) {
+      throw new OmpRpcFaultError("protocolError", "Omp RPC returned an invalid Interaction request");
     }
-    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
+    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,
+        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,
+        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,
+        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,
+        method: "editor",
+        title,
+        ...typeof value.prefill === "string" ? { prefill: value.prefill } : {},
+        ...typeof timeoutMs === "number" ? { timeoutMs } : {}
       };
-    });
-    try {
-      await this.#send("prompt", { message: text }, promptId);
-    } catch (error51) {
-      this.#rejectActiveTurn(error51 instanceof Error ? error51 : new Error(message2(error51)));
-    }
-    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");
     }
-    if ("value" in response && !["select", "input", "editor"].includes(pending.request.method)) {
-      throw new Error("Omp RPC interaction response type does not match the request");
+    const pending = { request, timeout: null };
+    if (request.timeoutMs !== void 0) {
+      pending.timeout = setTimeout(() => {
+        if (this.#activeTurn !== active || !active.interactions.has(requestId))
+          return;
+        void this.#resolveInteraction({ requestId, 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);
     }
-    if ("confirmed" in response && pending.request.method !== "confirm") {
-      throw new Error("Omp RPC confirmation does not match the request");
+    active.interactions.set(requestId, pending);
+    active.onEvent({ type: "interaction.requested", request });
+  }
+  #handleResponse(value) {
+    const id = value.id;
+    if (typeof id !== "string") {
+      this.#fail(new OmpRpcFaultError("protocolError", "Omp RPC response has no id"));
+      return;
     }
-    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");
+    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;
     }
     if (pending.timeout)
       clearTimeout(pending.timeout);
-    active.onEvent({ type: "interaction.closed", requestId: response.requestId, reason });
-    try {
-      await this.#write(frame);
-    } catch (error51) {
-      const fault = new OmpRpcFaultError("protocolError", `Omp RPC interaction response failed: ${message2(error51)}`);
-      this.#fail(fault);
-      throw fault;
+    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));
+      }
     }
   }
-  abort() {
-    const active = this.#activeTurn;
-    if (!active || this.#closed || this.#failed) {
-      return Promise.reject(new Error("Omp RPC Session has no cancellable Turn"));
+  #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");
     }
-    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.sawTool = true;
+    active.tools.set(callId, toolName);
+    active.onEvent({
+      type: "tool.started",
+      callId,
+      toolName,
+      arguments: argumentsResult.data
     });
-    active.abortPromise = aborting;
-    return aborting;
   }
-  #terminateFailedCancellation(active, fault) {
-    if (this.#activeTurn !== active)
+  #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;
-    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"));
+    const outputResult = jsonValueSchema.safeParse(value.partialResult ?? null);
+    if (!outputResult.success) {
+      throw new OmpRpcFaultError("protocolError", "Omp RPC returned an invalid Tool update");
     }
-    this.#closePromise ??= this.#stopProcess();
-    return this.#closePromise;
+    active.onEvent({ type: "tool.updated", callId, output: outputResult.data });
   }
-  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))
+  #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;
-    signalProcessTree(child, "SIGKILL");
-    if (!await waitForExit(child, this.#options.closeTimeoutMs)) {
-      throw new Error("Omp RPC process tree did not exit within cleanup bounds");
+    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");
     }
+    active.tools.delete(callId);
+    active.onEvent({
+      type: "tool.completed",
+      callId,
+      toolName,
+      result: result.data,
+      isError: value.isError === 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;
+  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", {});
       }
-      try {
-        const decoded = this.#frameDecoder.push(parsed);
-        if (decoded === null) {
-          newline = this.#buffer.indexOf(10);
-          continue;
+      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 });
         }
-        const value = decoded;
-        if (!isRecord8(value) || typeof value.type !== "string") {
-          throw new OmpRpcFaultError("protocolError", "Omp RPC returned an invalid envelope");
+        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");
         }
-        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 (!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) {
+      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;
     }
   }
-  /** Latest `available_commands_update` of the running process, if any. */
-  get availableCommands() {
-    return this.#availableCommands;
-  }
-  #handle(value) {
-    if (this.#closed || this.#failed)
-      return;
-    if (value.type === "available_commands_update") {
-      this.#availableCommands = parseOmpAvailableCommands(value.commands);
-      return;
-    }
-    if (value.type === "ready") {
-      this.#readyResolve?.();
-      this.#readyResolve = null;
-      return;
-    }
-    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;
-      }
+  #settleLocalTurn(active, result) {
+    if (this.#activeTurn !== active || active.settlement !== "pending")
       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);
-        }
+    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;
       }
-      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;
-    }
-    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"));
+      if (parseSessionStreaming(response)) {
+        throw new OmpRpcFaultError("protocolError", "Omp RPC completed Turn state is still Streaming");
       }
-      return;
-    }
-    if (value.type === "command_output") {
-      if (active.settlement !== "pending")
+      this.#state = state;
+      active.settlement = "confirmed";
+      this.#finishSettledTurn(active);
+    } catch (error51) {
+      if (this.#activeTurn !== active)
         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;
+      const fault = error51 instanceof OmpRpcFaultError ? error51 : new OmpRpcFaultError("protocolError", `Omp RPC stable Turn state could not be confirmed: ${message2(error51)}`);
+      this.#fail(fault);
     }
-    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");
-      }
+  }
+  #finishSettledTurn(active) {
+    if (this.#activeTurn !== active || active.settlement !== "confirmed" || active.cancellation === "requesting") {
       return;
     }
-    if (value.type === "extension_ui_request") {
-      this.#startInteraction(active, value);
+    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 (value.type === "message_start" && assistantText(value.message) !== null) {
-      this.#startAssistantMessage(active, value.message);
-      return;
+    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 });
     }
-    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;
+  }
+  #startAssistantMessage(active, value) {
+    if (active.assistantMessageId !== null && active.reasoningMessageOpen) {
+      active.onEvent({ type: "reasoning.completed", messageId: active.assistantMessageId });
     }
-    if (value.type === "message_end") {
-      this.#finalizeAssistantMessage(active, value.message);
+    const messageId = assistantMessageId(value) ?? randomUUID();
+    active.assistantMessageId = messageId;
+    active.sawStreamedMessageText = false;
+    active.sawStreamedMessageReasoning = false;
+    active.reasoningMessageOpen = false;
+    return messageId;
+  }
+  #ensureAssistantMessage(active, value) {
+    return active.assistantMessageId ?? this.#startAssistantMessage(active, value);
+  }
+  #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 === "turn_end") {
-      this.#finalizeAssistantMessage(active, value.message);
+    if (active.assistantMessageId === null && finalText === active.lastFinalizedMessageText && finalReasoning === active.lastFinalizedMessageReasoning && !active.sawStreamedMessageText && !active.sawStreamedMessageReasoning) {
       return;
     }
-    if (value.type === "tool_execution_start") {
-      this.#startTool(active, value);
-      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 === "tool_execution_update") {
-      this.#updateTool(active, value);
-      return;
+    if (active.reasoningMessageOpen && active.failure === null) {
+      active.onEvent({ type: "reasoning.completed", messageId });
     }
-    if (value.type === "tool_execution_end") {
-      this.#completeTool(active, value);
-      return;
+    if (!active.sawStreamedMessageText && finalText.length > 0) {
+      active.text += finalText;
+      active.onEvent({ type: "text.delta", messageId, delta: finalText });
     }
-    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;
-      }
+    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"));
     }
-    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);
+    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);
+        }
+      });
+    });
   }
-  /** Every finished assistant message is one model request, with or without an active Turn. */
-  #observeUsage(value) {
-    if (value.type === "message_start") {
-      this.#usageRequestStartedAtMs = null;
+  #armCommandTimeout(id, pending) {
+    if (pending.timeout || this.#pending.get(id) !== pending || (pending.command === "prompt" || pending.command === "compact") && this.#compactionActive) {
       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();
+    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;
       }
+      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 === "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()
-      });
+    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);
   }
-  #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");
+  #closeInteractions(active, reason) {
+    for (const [requestId, pending] of active.interactions) {
+      active.interactions.delete(requestId);
+      if (pending.timeout)
+        clearTimeout(pending.timeout);
+      active.onEvent({ type: "interaction.closed", requestId, reason });
     }
-    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;
+  }
+  #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 === "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");
+    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 {
+        }
       }
-      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 } : {}
+      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);
     });
-    return 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;
   }
-  #isBlockingInteraction(value) {
-    return ["select", "confirm", "input", "editor"].includes(String(value.method));
+  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;
+    }
+    models.push({ provider: model2.provider, id: model2.id, reasoning: model2.reasoning });
   }
-  #startInteraction(active, value) {
-    if (!this.#isBlockingInteraction(value))
-      return;
-    const requestId = value.id;
-    const method = value.method;
-    const title = value.title;
-    const timeoutMs = value.timeout;
-    if (typeof requestId !== "string" || requestId.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(requestId)) {
-      throw new OmpRpcFaultError("protocolError", "Omp RPC returned an invalid Interaction request");
+  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;
     }
-    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");
+    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;
       }
-      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");
+    };
+    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);
+          }
         }
-        optionDetails = value.optionDetails.map(({ description }) => description === void 0 ? {} : { description });
-      }
-      request = {
-        requestId,
-        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,
-        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");
+      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;
+        }
       }
-      request = {
-        requestId,
-        method,
-        title,
-        ...typeof value.placeholder === "string" ? { placeholder: value.placeholder } : {},
-        ...typeof timeoutMs === "number" ? { timeoutMs } : {}
+    }
+  }
+  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 {
-      if (value.prefill !== void 0 && typeof value.prefill !== "string") {
-        throw new OmpRpcFaultError("protocolError", "Omp RPC editor prefill is invalid");
-      }
-      request = {
-        requestId,
-        method: "editor",
-        title,
-        ...typeof value.prefill === "string" ? { prefill: value.prefill } : {},
-        ...typeof timeoutMs === "number" ? { timeoutMs } : {}
+      return {
+        oldPos: path9.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
-    const pending = { request, timeout: null };
-    if (request.timeoutMs !== void 0) {
-      pending.timeout = setTimeout(() => {
-        if (this.#activeTurn !== active || !active.interactions.has(requestId))
-          return;
-        void this.#resolveInteraction({ requestId, 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);
+  }
+  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 };
+      }
     }
-    active.interactions.set(requestId, pending);
-    active.onEvent({ type: "interaction.requested", request });
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
   }
-  #handleResponse(value) {
-    const id = value.id;
-    if (typeof id !== "string") {
-      this.#fail(new OmpRpcFaultError("protocolError", "Omp RPC response has no id"));
-      return;
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
     }
-    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;
+  }
+  removeEmpty(array2) {
+    const ret = [];
+    for (let i = 0; i < array2.length; i++) {
+      if (array2[i]) {
+        ret.push(array2[i]);
       }
-      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 });
-      }
-      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));
+    return ret;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  castInput(value, options) {
+    return value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  tokenize(value, options) {
+    return Array.from(value);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return false;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (; componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i) {
+            const oldValue = oldTokens[oldPos + i];
+            return oldValue.length > value2.length ? oldValue : value2;
+          });
+          component.value = this.join(value);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
       } else {
-        pending.reject(new Error(error51));
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
       }
     }
+    return components;
   }
-  #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
-    });
+};
+
+// ../../../node_modules/diff/libesm/diff/line.js
+var LineDiff = class extends Diff {
+  constructor() {
+    super(...arguments);
+    this.tokenize = tokenize;
   }
-  #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");
+  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);
+      }
     }
-    active.onEvent({ type: "tool.updated", callId, output: outputResult.data });
+    return super.equals(left, right, options);
   }
-  #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");
+};
+var lineDiff = new LineDiff();
+function diffLines(oldStr, newStr, options) {
+  return lineDiff.diff(oldStr, newStr, options);
+}
+function tokenize(value, options) {
+  if (options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, "\n");
+  }
+  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (let i = 0; i < linesAndNewlines.length; i++) {
+    const line = linesAndNewlines[i];
+    if (i % 2 && !options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
     }
-    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", {});
+  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;
       }
-      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");
-        }
+      const header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line);
+      if (header) {
+        index.index = header[1];
       }
-      if (!cancellationSettled(response, active.terminalEnd)) {
-        active.settlement = "pending";
-        active.cancellationRecheck = setTimeout(() => {
-          active.cancellationRecheck = null;
-          void this.#confirmCancelledTurn(active);
-        }, 250);
-        return;
+      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;
+      }
+      i++;
+    }
+  }
+  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]}`);
       }
-      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);
     }
-  }
-  #finishSettledTurn(active) {
-    if (this.#activeTurn !== active || active.settlement !== "confirmed" || active.cancellation === "requesting") {
-      return;
+    if (!addCount && hunk.newLines === 1) {
+      hunk.newLines = 0;
     }
-    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 (!removeCount && hunk.oldLines === 1) {
+      hunk.oldLines = 0;
     }
-    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 });
+    if (addCount !== hunk.newLines) {
+      throw new Error("Added line count did not match for hunk at line " + (chunkHeaderIndex + 1));
     }
-  }
-  #startAssistantMessage(active, value) {
-    if (active.assistantMessageId !== null && active.reasoningMessageOpen) {
-      active.onEvent({ type: "reasoning.completed", messageId: active.assistantMessageId });
+    if (removeCount !== hunk.oldLines) {
+      throw new Error("Removed line count did not match for hunk at line " + (chunkHeaderIndex + 1));
     }
-    const messageId = assistantMessageId(value) ?? randomUUID();
-    active.assistantMessageId = messageId;
-    active.sawStreamedMessageText = false;
-    active.sawStreamedMessageReasoning = false;
-    active.reasoningMessageOpen = false;
-    return messageId;
+    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;
+      }
     }
-    if (!active.sawStreamedMessageText && finalText.length > 0) {
-      active.text += finalText;
-      active.onEvent({ type: "text.delta", messageId, delta: finalText });
+    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++;
+        }
+      }
     }
-    active.assistantMessageId = null;
-    active.sawStreamedMessageText = false;
-    active.sawStreamedMessageReasoning = false;
-    active.reasoningMessageOpen = false;
-    active.lastFinalizedMessageText = finalText;
-    active.lastFinalizedMessageReasoning = finalReasoning;
-    active.onEvent({ type: "message.completed", messageId });
+    return {
+      oldFileName,
+      newFileName,
+      oldHeader,
+      newHeader,
+      hunks
+    };
   }
-  #write(value) {
-    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 frame = Buffer.from(`${JSON.stringify(value)}
-`, "utf8");
-      child.stdin.write(frame, (error51) => error51 ? reject(error51) : resolve());
-    });
+}
+function formatPatch(patch) {
+  if (Array.isArray(patch)) {
+    return patch.map(formatPatch).join("\n");
   }
-  #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);
-        }
-      });
-    });
+  const ret = [];
+  if (patch.oldFileName == patch.newFileName) {
+    ret.push("Index: " + patch.oldFileName);
+  }
+  ret.push("===================================================================");
+  ret.push("--- " + patch.oldFileName + (typeof patch.oldHeader === "undefined" ? "" : "	" + patch.oldHeader));
+  ret.push("+++ " + patch.newFileName + (typeof patch.newHeader === "undefined" ? "" : "	" + patch.newHeader));
+  for (let i = 0; i < patch.hunks.length; i++) {
+    const hunk = patch.hunks[i];
+    if (hunk.oldLines === 0) {
+      hunk.oldStart -= 1;
+    }
+    if (hunk.newLines === 0) {
+      hunk.newStart -= 1;
+    }
+    ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@");
+    for (const line of hunk.lines) {
+      ret.push(line);
+    }
   }
-  #armCommandTimeout(id, pending) {
-    if (pending.timeout || this.#pending.get(id) !== pending || (pending.command === "prompt" || pending.command === "compact") && this.#compactionActive) {
+  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;
     }
-    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 [requestId, pending] of active.interactions) {
-      active.interactions.delete(requestId);
-      if (pending.timeout)
-        clearTimeout(pending.timeout);
-      active.onEvent({ type: "interaction.closed", requestId, 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"]);
@@ -20113,6 +20275,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: [
@@ -20127,7 +20307,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) {
@@ -20142,7 +20322,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)
@@ -20219,7 +20399,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;
@@ -20274,9 +20454,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);
@@ -20292,17 +20472,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;
@@ -20310,7 +20490,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;
@@ -20349,7 +20529,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];
@@ -20364,14 +20544,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)
@@ -20498,9 +20678,6 @@ var OmpHarnessSession = class {
   #usage;
   #usageGeneration = 0;
   #usageRefreshSequence = 0;
-  #backgroundTurnId = null;
-  #backgroundSubagents = /* @__PURE__ */ new Map();
-  #backgroundTurnFailed = false;
   constructor(cwd, createTransport, onClosed, options) {
     this.#cwd = cwd;
     this.#createTransport = createTransport;
@@ -20558,44 +20735,6 @@ var OmpHarnessSession = class {
   #backgroundStatus(status) {
     return status === "pending" || status === "running" ? "running" : status === "interrupted" ? "interrupted" : status;
   }
-  #ensureBackgroundTurn() {
-    if (this.#backgroundTurnId)
-      return this.#backgroundTurnId;
-    const turnId = hostTurnIdSchema.parse(randomUUID2());
-    this.#backgroundTurnId = turnId;
-    this.#backgroundTurnFailed = false;
-    this.#event({
-      type: "turn.autonomous.started",
-      turnId,
-      input: []
-    });
-    return turnId;
-  }
-  #backgroundDelegationStart(event) {
-    const turnId = this.#ensureBackgroundTurn();
-    const description = event.type === "subagent.started" ? event.description : event.type === "subagent.updated" ? event.description ?? "Background subagent" : "Background subagent";
-    const role = event.type === "subagent.started" ? event.role : void 0;
-    const background = event.type === "subagent.started" ? event.background : true;
-    const state = {
-      subagentId: event.nativeSubagentId,
-      nativeSubagentId: event.nativeSubagentId,
-      description,
-      ...role ? { role } : {},
-      background,
-      status: "running"
-    };
-    const item = {
-      type: "subagentDelegation",
-      itemId: this.#newItemId(),
-      operation: "spawn",
-      ...event.type === "subagent.started" && event.prompt ? { prompt: event.prompt } : {},
-      subagents: [state]
-    };
-    const delegation = { item, turnId };
-    this.#backgroundSubagents.set(event.callId, delegation);
-    this.#event({ type: "item.started", turnId, item });
-    return delegation;
-  }
   #handleBackgroundSubagentEvent(event) {
     if (event.type === "subagent.transcript.changed") {
       this.#event({
@@ -20607,12 +20746,6 @@ var OmpHarnessSession = class {
     if (event.type !== "subagent.started" && event.type !== "subagent.updated" && event.type !== "subagent.completed") {
       return;
     }
-    let delegation = this.#backgroundSubagents.get(event.callId);
-    if (!delegation)
-      delegation = this.#backgroundDelegationStart(event);
-    const current = delegation.item.subagents[0];
-    if (!current)
-      throw new Error("Omp background delegation has no Agent state");
     if (event.type === "subagent.started") {
       this.#event({
         type: "subagent.state.changed",
@@ -20623,19 +20756,6 @@ var OmpHarnessSession = class {
     }
     if (event.type === "subagent.updated") {
       const status2 = this.#backgroundStatus(event.status);
-      const subagent2 = {
-        ...current,
-        status: status2,
-        ...event.description ? { description: event.description } : {},
-        ...event.resultSummary ? { resultSummary: event.resultSummary } : {}
-      };
-      delegation.item = { ...delegation.item, subagents: [subagent2] };
-      this.#event({
-        type: "item.updated",
-        turnId: delegation.turnId,
-        itemId: delegation.item.itemId,
-        update: { type: "subagents.replace", subagents: delegation.item.subagents }
-      });
       this.#event({
         type: "subagent.state.changed",
         nativeSubagentId: event.nativeSubagentId,
@@ -20645,58 +20765,12 @@ var OmpHarnessSession = class {
       return;
     }
     const status = event.isError ? "failed" : "completed";
-    const subagent = {
-      ...current,
-      status,
-      ...event.resultSummary ? { resultSummary: event.resultSummary } : {}
-    };
-    delegation.item = { ...delegation.item, subagents: [subagent] };
-    this.#event({
-      type: "item.updated",
-      turnId: delegation.turnId,
-      itemId: delegation.item.itemId,
-      update: { type: "subagents.replace", subagents: delegation.item.subagents }
-    });
-    this.#event({
-      type: "item.completed",
-      turnId: delegation.turnId,
-      snapshot: {
-        item: delegation.item,
-        outcome: event.isError ? {
-          status: "failed",
-          error: {
-            code: "nativeFailure",
-            message: "Omp background Subagent failed",
-            retryable: false
-          }
-        } : { status: "succeeded" }
-      }
-    });
     this.#event({
       type: "subagent.state.changed",
       nativeSubagentId: event.nativeSubagentId,
       status,
       ...event.resultSummary ? { resultSummary: event.resultSummary } : {}
     });
-    this.#backgroundTurnFailed ||= event.isError;
-    this.#backgroundSubagents.delete(event.callId);
-    if (this.#backgroundSubagents.size === 0 && this.#backgroundTurnId === delegation.turnId) {
-      const turnId = this.#backgroundTurnId;
-      this.#backgroundTurnId = null;
-      this.#event({
-        type: "turn.completed",
-        turnId,
-        outcome: this.#backgroundTurnFailed ? {
-          status: "failed",
-          error: {
-            code: "nativeFailure",
-            message: "Omp background Subagent failed",
-            retryable: false
-          }
-        } : { status: "succeeded" }
-      });
-      this.#backgroundTurnFailed = false;
-    }
   }
   async readSnapshot() {
     if (this.#phase !== "open" && this.#phase !== "faulted") {
@@ -20751,6 +20825,8 @@ var OmpHarnessSession = class {
     }
     if (command.type === "turn.cancel")
       return this.#cancel(command);
+    if (command.type === "turn.steer")
+      return unsupportedSteer("OMP");
     if (command.type === "interaction.respond")
       return this.#respond(command);
     if (command.type === "model.select")
@@ -21946,6 +22022,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;
@@ -21954,22 +22033,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)
@@ -21979,6 +22057,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);
@@ -21991,6 +22100,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";
@@ -22014,16 +22176,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);
@@ -22234,6 +22387,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()),