@codexhost/cli-linux-arm64 0.10.2 → 0.12.0

package/app/plugins/claude-code/plugin.mjs

@@ -776,10 +776,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path14) {
-  if (!path14)
+function getElementAtPath(obj, path17) {
+  if (!path17)
     return obj;
-  return path14.reduce((acc, key) => acc?.[key], obj);
+  return path17.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1188,11 +1188,11 @@ function explicitlyAborted(x2, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path14, issues) {
+function prefixIssues(path17, issues) {
   return issues.map((iss) => {
     var _a4;
     (_a4 = iss).path ?? (_a4.path = []);
-    iss.path.unshift(path14);
+    iss.path.unshift(path17);
     return iss;
   });
 }
@@ -1339,16 +1339,16 @@ function flattenError(error52, mapper = (issue2) => issue2.message) {
 }
 function formatError(error52, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error53, path14 = []) => {
+  const processError = (error53, path17 = []) => {
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path14, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path17, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path17, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path17, ...issue2.path]);
       } else {
-        const fullpath = [...path14, ...issue2.path];
+        const fullpath = [...path17, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1375,17 +1375,17 @@ function formatError(error52, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error52, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error53, path14 = []) => {
+  const processError = (error53, path17 = []) => {
     var _a4, _b2;
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path14, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path17, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path17, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path17, ...issue2.path]);
       } else {
-        const fullpath = [...path14, ...issue2.path];
+        const fullpath = [...path17, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1417,8 +1417,8 @@ function treeifyError(error52, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path14 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path14) {
+  const path17 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path17) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14110,13 +14110,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path14 = ref.slice(1).split("/").filter(Boolean);
-  if (path14.length === 0) {
+  const path17 = ref.slice(1).split("/").filter(Boolean);
+  if (path17.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path14[0] === defsKey) {
-    const key = path14[1];
+  if (path17[0] === defsKey) {
+    const key = path17[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14579,6 +14579,56 @@ var credentialImportsParamsSchema = external_exports.object({
   request: credentialImportsRequestSchema
 }).strict();
 
+// ../../shared-contracts/dist/harness-display-settings.js
+var harnessDisplayEntriesSchema = external_exports.array(external_exports.strictObject({
+  agent: external_exports.string().min(1).max(128),
+  section: external_exports.enum(["main", "more", "auto"])
+})).max(256).refine((entries) => new Set(entries.map((entry) => entry.agent)).size === entries.length, "Duplicate Harness IDs");
+var harnessDisplaySettingsSchema = external_exports.strictObject({
+  entries: harnessDisplayEntriesSchema.nullable()
+});
+var harnessDisplayGetSchema = external_exports.strictObject({});
+var harnessDisplaySetSchema = external_exports.strictObject({
+  entries: harnessDisplayEntriesSchema,
+  /** Import legacy Desktop preferences only if no shared settings exist yet. */
+  initializeOnly: external_exports.boolean().optional()
+});
+
+// ../../shared-contracts/dist/console.js
+var consoleAnnouncementSchema = external_exports.strictObject({
+  title: external_exports.string().trim().min(1).max(200),
+  type: external_exports.enum(["info", "warning", "danger"]),
+  body: external_exports.string().trim().min(1).max(16 * 1024)
+});
+var consoleOpenParamsSchema = external_exports.strictObject({});
+var consoleOpenResultSchema = external_exports.strictObject({
+  /** The console address. */
+  url: external_exports.string().max(2048).regex(/^http:\/\/(?:127\.0\.0\.1|localhost):\d{1,5}\/(?:\?.*)?$/u)
+});
+var CONSOLE_HOST_METHODS = Object.freeze([
+  "codexhost/harness/plugins/list",
+  "codexhost/harness/display-settings/get",
+  "codexhost/harness/display-settings/set",
+  "codexhost/harness/inspect",
+  "codexhost/harness/installation",
+  "codexhost/harness/launch-settings/get",
+  "codexhost/harness/launch-settings/set",
+  "codexhost/harness/web-ui/open",
+  "codexhost/harness/accounts/sources",
+  "codexhost/harness/accounts/list",
+  "codexhost/harness/accounts/inspect",
+  "codexhost/harness/credential-imports",
+  "codexhost/harness/session-import/sources",
+  "codexhost/harness/session-import/list",
+  "codexhost/harness/session-import/import",
+  "codexhost/account/list",
+  "codexhost/account/refresh",
+  "codexhost/account/usage/inspect",
+  "codexhost/update/check",
+  "codexhost/update/start",
+  "codexhost/update/status"
+]);
+
 // ../../shared-contracts/dist/version.js
 var WORKSPACE_CONTRACT_VERSION = 1;
 
@@ -14632,6 +14682,12 @@ var hostTurnIdSchema = opaqueIdSchema.brand();
 var hostItemIdSchema = opaqueIdSchema.brand();
 var hostInteractionIdSchema = opaqueIdSchema.brand();
 
+// ../../shared-contracts/dist/manual-compaction.js
+var threadManualCompactionStartedSchema = external_exports.strictObject({
+  threadId: hostThreadIdSchema,
+  turnId: hostTurnIdSchema
+});
+
 // ../../shared-contracts/dist/thread-usage.js
 var nonNegativeSafeIntegerSchema = external_exports.number().int().safe().nonnegative();
 var finiteNonNegativeNumberSchema = external_exports.number().finite().nonnegative();
@@ -14692,6 +14748,10 @@ var threadUsageSnapshotSchema = external_exports.object({
 var usagePercentSchema = external_exports.number().finite().min(0).max(100);
 var accountCreditsProductUsageSchema = external_exports.object({
   product: external_exports.string().min(1),
+  used: external_exports.number().finite().nonnegative().optional(),
+  // Zero is a real empty cap, not an absent field.
+  limit: external_exports.number().finite().nonnegative().optional(),
+  unit: external_exports.string().min(1).max(32).optional(),
   usagePercent: usagePercentSchema,
   resetsAt: external_exports.string().min(1).optional()
 }).strict();
@@ -14701,6 +14761,10 @@ var accountResetCreditsSchema = external_exports.object({
   expiresAt: external_exports.array(external_exports.string().min(1)).min(1).max(32).optional()
 }).strict();
 var accountCreditsSnapshotSchema = external_exports.object({
+  used: external_exports.number().finite().nonnegative().optional(),
+  // Zero is a real empty cap, not an absent field.
+  limit: external_exports.number().finite().nonnegative().optional(),
+  unit: external_exports.string().min(1).max(32).optional(),
   /** Native label when the primary limit is scoped to a model or product group. */
   label: external_exports.string().min(1).optional(),
   usedPercent: usagePercentSchema,
@@ -14720,12 +14784,27 @@ var threadUsageInspectionSchema = external_exports.object({
 }).strict();
 
 // ../../shared-contracts/dist/harness-accounts.js
-var harnessAccountSnapshotSchema = external_exports.object({
+var accountBalanceSnapshotSchema = external_exports.object({
+  amount: external_exports.number().finite().nonnegative(),
+  /** ISO 4217 code as reported by the Provider, for example `CNY`. */
+  currency: external_exports.string().trim().min(1).max(8),
+  /** Native label when the Harness exposes several Billing Sources. */
+  label: external_exports.string().trim().min(1).max(128).optional()
+}).strict();
+var harnessAccountSnapshotObject = external_exports.object({
   email: external_exports.string().trim().min(1).max(320).optional(),
   label: external_exports.string().trim().min(1).max(256).optional(),
   plan: external_exports.string().trim().min(1).max(128).optional(),
-  credits: accountCreditsSnapshotSchema
+  credits: accountCreditsSnapshotSchema.optional(),
+  balance: accountBalanceSnapshotSchema.optional()
 }).strict();
+function requireReportedQuota(schema) {
+  return schema.refine((value) => {
+    const reported = value;
+    return reported.credits !== void 0 || reported.balance !== void 0;
+  }, { message: "Account must report either credits or a balance" });
+}
+var harnessAccountSnapshotSchema = requireReportedQuota(harnessAccountSnapshotObject);
 var harnessAccountIdentityShape = {
   harnessId: harnessIdSchema,
   harnessName: external_exports.string().trim().min(1).max(128)
@@ -14736,11 +14815,13 @@ var harnessAccountSourceListResultSchema = external_exports.object({ sources: ex
 var harnessAccountInspectParamsSchema = external_exports.object({ harnessId: harnessIdSchema, refresh: external_exports.boolean().optional() }).strict();
 var harnessAccountInspectResultSchema = external_exports.object({
   ...harnessAccountIdentityShape,
-  account: harnessAccountSnapshotSchema.nullable()
+  account: harnessAccountSnapshotSchema.nullable(),
+  /** Every Billing Source from one Harness; `account` remains the first for older clients. */
+  accounts: external_exports.array(harnessAccountSnapshotSchema).max(8).optional()
 }).strict();
 var harnessAccountListParamsSchema = external_exports.object({ refresh: external_exports.boolean().optional() }).strict();
 var harnessAccountListResultSchema = external_exports.object({
-  accounts: external_exports.array(harnessAccountSnapshotSchema.extend(harnessAccountIdentityShape)).max(128)
+  accounts: external_exports.array(requireReportedQuota(harnessAccountSnapshotObject.extend(harnessAccountIdentityShape))).max(128)
 }).strict();
 
 // ../../shared-contracts/dist/json-value.js
@@ -14878,6 +14959,8 @@ var harnessModelSchema = external_exports.object({
   ref: harnessModelRefSchema,
   label: nonBlankTextSchema2.max(HARNESS_MODEL_LABEL_MAX_LENGTH),
   resolvedModelLabel: harnessResolvedModelLabelSchema.optional(),
+  /** Optional opaque selection for this same Model with priority processing enabled. */
+  fastModel: harnessModelRefSchema.optional(),
   supportedThinkingOptionIds: external_exports.array(harnessThinkingOptionIdSchema).optional()
 }).strict();
 var harnessThinkingOptionsSchema = external_exports.array(harnessThinkingOptionSchema).superRefine((options, context) => {
@@ -14910,6 +14993,16 @@ var harnessModelCatalogSchema = external_exports.object({
       });
     }
     refs.add(model.ref.id);
+    if (model.fastModel) {
+      if (refs.has(model.fastModel.id) || catalog.models.some((entry) => entry.ref.id === model.fastModel?.id)) {
+        context.addIssue({
+          code: "custom",
+          message: "Fast Model refs must be distinct and unique",
+          path: ["models", index, "fastModel"]
+        });
+      }
+      refs.add(model.fastModel.id);
+    }
     const supportedThinkingIds = /* @__PURE__ */ new Set();
     for (const [optionIndex, optionId] of (model.supportedThinkingOptionIds ?? []).entries()) {
       if (supportedThinkingIds.has(optionId)) {
@@ -15029,11 +15122,13 @@ var threadThinkingSelectParamsSchema = external_exports.object({
   thinkingOptionId: harnessThinkingOptionIdSchema
 }).strict();
 var threadInspectionParamsSchema = external_exports.object({
-  threadId: hostThreadIdSchema
+  threadId: hostThreadIdSchema,
+  includeReferenceCapability: external_exports.boolean().optional()
 }).strict();
 var codexThreadInspectionSchema = external_exports.object({
   owner: external_exports.literal("codex"),
-  locked: external_exports.literal(true)
+  locked: external_exports.literal(true),
+  supportsThreadReferences: external_exports.literal(true).optional()
 }).strict();
 var externalThreadInspectionSchema = external_exports.object({
   owner: external_exports.literal("external"),
@@ -15159,6 +15254,22 @@ var harnessLaunchSettingsSchema = external_exports.object({
   restartRequired: external_exports.boolean()
 }).strict();
 
+// ../../shared-contracts/dist/harness-installation.js
+var harnessInstallationParamsSchema = external_exports.object({
+  harnessId: harnessIdSchema,
+  action: external_exports.enum(["check", "update", "install"])
+}).strict();
+var harnessInstallationStateSchema = external_exports.object({
+  currentVersion: external_exports.string().min(1).max(128),
+  latestVersion: external_exports.string().min(1).max(128),
+  updateAvailable: external_exports.boolean(),
+  canUpdate: external_exports.boolean(),
+  // 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(),
+  latestVersionKind: external_exports.enum(["unknown", "tracking-branch"]).optional()
+}).strict();
+
 // ../../shared-contracts/dist/codex-accounts.js
 var accountIdSchema = external_exports.string().min(1).max(256).regex(/^[A-Za-z0-9._~-]+$/u);
 var nonBlankTextSchema3 = external_exports.string().trim().min(1);
@@ -15458,6 +15569,38 @@ var updateStatusResultSchema = external_exports.strictObject({
   status: updateStatusSchema.nullable()
 });
 
+// ../../shared-contracts/dist/remote-runtime.js
+var remoteUpdatePhaseSchema = external_exports.enum([
+  "idle",
+  "installing",
+  "restarting",
+  "succeeded",
+  "failed"
+]);
+var runtimeStatusSchema = external_exports.object({
+  runningVersion: external_exports.string().nullable(),
+  installedVersion: external_exports.string().nullable(),
+  restartRequired: external_exports.boolean(),
+  remote: external_exports.boolean(),
+  updateSupported: external_exports.boolean(),
+  update: external_exports.object({
+    phase: remoteUpdatePhaseSchema,
+    targetVersion: external_exports.string().nullable(),
+    error: external_exports.string().nullable()
+  })
+});
+var remoteUpdateParamsSchema = external_exports.object({
+  version: external_exports.string().regex(/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/u)
+}).strict();
+var remoteSshSetupParamsSchema = external_exports.object({
+  hostname: external_exports.string().min(1).max(1024).refine((value) => !value.startsWith("-") && !/\s/u.test(value)),
+  port: external_exports.number().int().min(1).max(65535).nullable(),
+  identity: external_exports.string().max(4096).nullable(),
+  action: external_exports.enum(["inspect", "install", "update", "repair"]),
+  version: external_exports.string().regex(/^\d+\.\d+\.\d+$/u).nullable()
+}).strict();
+var remoteSshSetupResultSchema = external_exports.object({ state: external_exports.enum(["installed", "not-installed"]) }).strict();
+
 // ../../shared-contracts/dist/index.js
 var workspaceContractVersionSchema = external_exports.literal(WORKSPACE_CONTRACT_VERSION);
 
@@ -15901,6 +16044,7 @@ function defaultHarnessBrokerDescriptorPath(environment = process.env, harnessId
 var cwdSchema = external_exports.string().min(1).max(16384);
 var brokerEnvironmentSchema = external_exports.object({
   CODEXHOST_CLI_PATH: external_exports.string().max(16384).optional(),
+  CODEXHOST_CLI_NODE_PATH: external_exports.string().max(16384).optional(),
   CODEXHOST_RUNTIME_ENDPOINT: external_exports.string().max(16384).optional(),
   CODEXHOST_RUNTIME_TOKEN: external_exports.string().max(16384).optional(),
   CODEXHOST_THREAD_ID: external_exports.string().max(256).optional()
@@ -16055,6 +16199,7 @@ var eventKeys = /* @__PURE__ */ new Map([
   ["item.started", /* @__PURE__ */ new Set(["type", "turnId", "item"])],
   ["item.updated", /* @__PURE__ */ new Set(["type", "turnId", "itemId", "update"])],
   ["item.completed", /* @__PURE__ */ new Set(["type", "turnId", "snapshot"])],
+  ["item.detached", /* @__PURE__ */ new Set(["type", "turnId", "itemId"])],
   ["interaction.closed", /* @__PURE__ */ new Set(["type", "interactionId", "turnId", "reason"])],
   ["turn.completed", /* @__PURE__ */ new Set(["type", "turnId", "nativeTurnRef", "outcome"])],
   ["session.faulted", /* @__PURE__ */ new Set(["type", "error"])]
@@ -16623,6 +16768,7 @@ var BrokeredHarnessAdapter = class {
       if (this.#forwardEnvironment && input.environment) {
         const allowed2 = [
           "CODEXHOST_CLI_PATH",
+          "CODEXHOST_CLI_NODE_PATH",
           "CODEXHOST_RUNTIME_ENDPOINT",
           "CODEXHOST_RUNTIME_TOKEN",
           "CODEXHOST_THREAD_ID"
@@ -16680,7 +16826,7 @@ var BrokeredHarnessAdapter = class {
 
 // dist/claude-code-adapter.js
 import { randomUUID as randomUUID3 } from "node:crypto";
-import path12 from "node:path";
+import path14 from "node:path";
 
 // ../../../node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
 import { createRequire as DW } from "node:module";
@@ -42377,32 +42523,109 @@ import { opendir, realpath, stat } from "node:fs/promises";
 import os2 from "node:os";
 import path2 from "node:path";
 import { createInterface } from "node:readline";
-var CLAUDE_SESSION_IMPORT_TITLE_MAX_LENGTH = 120;
-var CLAUDE_INTERNAL_USER_TEXT = /^<(?:local-command-|command-)/u;
-var ClaudeSessionChangedError = class extends Error {
-  constructor() {
-    super("Claude Code Session changed during discovery; refresh and retry");
+
+// ../../harness-adapter/dist/session-import.js
+var SessionImportChangedError = class extends Error {
+  constructor(message = "Native Session changed during discovery; refresh and retry") {
+    super(message);
+    this.name = "SessionImportChangedError";
   }
 };
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function missing(error52) {
-  return isRecord2(error52) && error52.code === "ENOENT";
+function isMissingFileError(error52) {
+  return typeof error52 === "object" && error52 !== null && "code" in error52 && error52.code === "ENOENT";
 }
-function sameFile(left, right) {
-  return left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs && left.ino === right.ino && left.dev === right.dev;
+function sameFileFingerprint(left, right) {
+  return left === null || right === null ? left === right : left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
 }
-function cleanText(value) {
+function sessionImportTitle(value, maxLength = HARNESS_SESSION_IMPORT_TITLE_MAX_LENGTH) {
   if (typeof value !== "string")
     return null;
   const normalized = value.replaceAll("\0", "").replaceAll(/\s+/gu, " ").trim();
   if (!normalized)
     return null;
+  if (normalized.length <= maxLength)
+    return normalized;
   const characters = [...normalized];
-  if (characters.length <= CLAUDE_SESSION_IMPORT_TITLE_MAX_LENGTH)
+  if (characters.length <= maxLength)
     return normalized;
-  return `${characters.slice(0, CLAUDE_SESSION_IMPORT_TITLE_MAX_LENGTH - 1).join("").trimEnd()}…`;
+  return `${characters.slice(0, maxLength - 1).join("").trimEnd()}…`;
+}
+function sessionImportCandidate(input) {
+  const time3 = typeof input.updatedAt === "number" ? input.updatedAt : typeof input.updatedAt === "string" ? Date.parse(input.updatedAt) : Number.NaN;
+  const parsed = harnessSessionImportCandidateSchema.safeParse({
+    nativeSessionId: input.nativeSessionId,
+    cwd: input.cwd,
+    title: typeof input.title === "string" && input.title.trim().length > 0 ? input.title : null,
+    updatedAt: Math.floor(time3),
+    // Unknown must stay unknown; only an explicit boolean is a native statement.
+    running: typeof input.running === "boolean" ? input.running : null
+  });
+  return parsed.success ? parsed.data : null;
+}
+var SessionImportScope = class {
+  #abort = new AbortController();
+  #options;
+  #pending = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.#options = options;
+  }
+  #closed() {
+    return {
+      ok: false,
+      error: { code: "invalidState", message: this.#options.closedMessage, retryable: false }
+    };
+  }
+  read(operation) {
+    const signal = this.#abort.signal;
+    if (signal.aborted)
+      return Promise.resolve(this.#closed());
+    let started;
+    try {
+      started = operation(signal);
+    } catch (error52) {
+      started = Promise.reject(error52 instanceof Error ? error52 : new Error("Session read failed"));
+    }
+    const request = started.then((value) => signal.aborted ? this.#closed() : { ok: true, value }).catch(() => signal.aborted ? this.#closed() : {
+      ok: false,
+      error: {
+        code: "unavailable",
+        message: this.#options.unavailableMessage,
+        retryable: true
+      }
+    }).finally(() => this.#pending.delete(request));
+    this.#pending.add(request);
+    return request;
+  }
+  /** `read` for `resolveCandidate`: a null source is the selected Session having disappeared. */
+  async resolve(operation) {
+    const result = await this.read(operation);
+    if (!result.ok)
+      return result;
+    return result.value ? { ok: true, value: result.value } : {
+      ok: false,
+      error: {
+        code: "sessionNotFound",
+        message: this.#options.notFoundMessage,
+        retryable: false
+      }
+    };
+  }
+  /** Idempotent. Resolves after every started read has settled. */
+  async close() {
+    this.#abort.abort();
+    await Promise.allSettled(this.#pending);
+  }
+};
+
+// dist/claude-session-import.js
+var CLAUDE_SESSION_IMPORT_TITLE_MAX_LENGTH = 120;
+var CLAUDE_INTERNAL_USER_TEXT = /^<(?:local-command-|command-)/u;
+var CLAUDE_SESSION_CHANGED = "Claude Code Session changed during discovery; refresh and retry";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function cleanText(value) {
+  return sessionImportTitle(value, CLAUDE_SESSION_IMPORT_TITLE_MAX_LENGTH);
 }
 function userText(message) {
   if (!isRecord2(message) || message.role !== "user")
@@ -42418,7 +42641,7 @@ function claudeProjectsDirectory(environment) {
 async function sessionFiles(directory, signal) {
   signal.throwIfAborted();
   const projects = await opendir(directory).catch((error52) => {
-    if (missing(error52))
+    if (isMissingFileError(error52))
       return null;
     throw error52;
   });
@@ -42430,7 +42653,7 @@ async function sessionFiles(directory, signal) {
     if (!project.isDirectory())
       continue;
     const entries = await opendir(path2.join(directory, project.name)).catch((error52) => {
-      if (missing(error52))
+      if (isMissingFileError(error52))
         return null;
       throw error52;
     });
@@ -42497,24 +42720,23 @@ async function readCandidate(file2, signal) {
   if (!hasConversation || !cwd)
     return null;
   const after = await stat(file2);
-  if (!sameFile(before, after))
-    throw new ClaudeSessionChangedError();
+  if (!sameFileFingerprint(before, after))
+    throw new SessionImportChangedError(CLAUDE_SESSION_CHANGED);
   const resolvedCwd = await realpath(cwd);
   if (!(await stat(resolvedCwd)).isDirectory())
     return null;
-  const candidate = harnessSessionImportCandidateSchema.safeParse({
+  const candidate = sessionImportCandidate({
     nativeSessionId,
     title: customTitle ?? generatedTitle ?? firstPrompt,
-    updatedAt: Math.floor(before.mtimeMs),
-    cwd: resolvedCwd,
-    running: null
+    updatedAt: before.mtimeMs,
+    cwd: resolvedCwd
   });
   const nativeRef = nativeSessionRefSchema.safeParse({
     harnessId: "claude-code",
     nativeSessionId,
     formatVersion: 1
   });
-  return candidate.success && nativeRef.success ? { candidate: candidate.data, nativeRef: nativeRef.data } : null;
+  return candidate && nativeRef.success ? { candidate, nativeRef: nativeRef.data } : null;
 }
 var ClaudeSessionImportIndex = class {
   #directory;
@@ -42538,7 +42760,7 @@ var ClaudeSessionImportIndex = class {
       try {
         const fingerprint = await stat(file2);
         const cached2 = this.#cache.get(file2);
-        const source = cached2 && sameFile(cached2.fingerprint, fingerprint) ? cached2.source : await readCandidate(file2, signal);
+        const source = cached2 && sameFileFingerprint(cached2.fingerprint, fingerprint) ? cached2.source : await readCandidate(file2, signal);
         if (!source)
           continue;
         if (!(await stat(source.candidate.cwd)).isDirectory())
@@ -42550,7 +42772,7 @@ var ClaudeSessionImportIndex = class {
         next.set(file2, { fingerprint, source });
         sources.push(source);
       } catch (error52) {
-        if (!missing(error52) && !(error52 instanceof ClaudeSessionChangedError))
+        if (!isMissingFileError(error52) && !(error52 instanceof SessionImportChangedError))
           throw error52;
       }
     }
@@ -42575,7 +42797,7 @@ var ClaudeSessionImportIndex = class {
       const source = await readCandidate(selected, signal);
       return source?.candidate.nativeSessionId === nativeSessionId ? source : null;
     } catch (error52) {
-      if (missing(error52))
+      if (isMissingFileError(error52))
         return null;
       throw error52;
     }
@@ -42583,7 +42805,7 @@ var ClaudeSessionImportIndex = class {
 };
 
 // dist/command.js
-import path5 from "node:path";
+import path7 from "node:path";
 
 // ../../harness-discovery/dist/environment.js
 import fs from "node:fs";
@@ -42631,12 +42853,28 @@ function newestFirst(names) {
   return [...names].sort((left, right) => right.localeCompare(left, void 0, { numeric: true }));
 }
 
-// ../../harness-discovery/dist/node-runtime.js
+// ../../harness-discovery/dist/invocation.js
 import path4 from "node:path";
+function commandInvocation(command, arguments_, environment, platform = process.platform) {
+  const extension = path4.win32.extname(command).toLowerCase();
+  if (platform !== "win32" || ![".cmd", ".bat"].includes(extension)) {
+    return { command, arguments: [...arguments_], windowsVerbatimArguments: false };
+  }
+  const quote = (value) => `"${value.replaceAll("%", "%%").replaceAll('"', '""')}"`;
+  const commandLine = [command, ...arguments_].map(quote).join(" ");
+  return {
+    command: environmentValue(environment, "ComSpec") ?? "cmd.exe",
+    arguments: ["/d", "/v:off", "/s", "/c", `"${commandLine}"`],
+    windowsVerbatimArguments: true
+  };
+}
+
+// ../../harness-discovery/dist/node-runtime.js
+import path5 from "node:path";
 function withNodeRuntimeOnPath(environment, runtimeExecutable = process.execPath, platform = process.platform) {
   const pathKey = Object.keys(environment).find((name) => name.toLowerCase() === "path") ?? "PATH";
   const delimiter = platform === "win32" ? ";" : ":";
-  const runtimeDirectory = path4.dirname(runtimeExecutable);
+  const runtimeDirectory = path5.dirname(runtimeExecutable);
   const directories = (environment[pathKey] ?? "").split(delimiter).filter(Boolean);
   const equal = platform === "win32" ? (value) => value.toLowerCase() : (value) => value;
   if (!directories.some((directory) => equal(directory) === equal(runtimeDirectory))) {
@@ -42808,6 +43046,249 @@ function resolveHarnessExecutable(spec, input, dependencies = {}) {
   return void 0;
 }
 
+// ../../harness-discovery/dist/installation.js
+import { execFile } from "node:child_process";
+import { homedir } from "node:os";
+function runInstallationCommand(command, args, environment, timeout = 3e4) {
+  const env = withNodeRuntimeOnPath(environment);
+  const invocation = /\.[cm]?js$/i.test(command) ? commandInvocation(process.execPath, [command, ...args], env) : commandInvocation(command, args, env);
+  return new Promise((resolve2, reject) => {
+    const child = execFile(invocation.command, invocation.arguments, {
+      env,
+      cwd: env.HOME ?? env.USERPROFILE ?? homedir(),
+      encoding: "utf8",
+      timeout,
+      killSignal: "SIGKILL",
+      maxBuffer: 1024 * 1024,
+      windowsHide: true,
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments
+    }, (error52, stdout, stderr) => {
+      if (error52)
+        reject(new Error(error52.killed ? "Harness command timed out" : "Harness command failed; check the native installation and retry"));
+      else
+        resolve2((stdout || stderr).trim());
+    });
+    child.stdin?.end();
+  });
+}
+function installationVersion(value) {
+  if (typeof value !== "string" || !/^v?\d+(?:\.\d+){1,3}(?:-[\w.-]+)?(?:\+[\w.-]+)?$/.test(value.trim()))
+    throw new Error("Harness returned an invalid version");
+  return value.trim().replace(/^v/, "");
+}
+function versionFromOutput(output) {
+  return installationVersion(output.match(/\b\d+(?:\.\d+){1,3}(?:-[\w.-]+)?(?:\+[\w.-]+)?\b/)?.[0]);
+}
+function newerInstallationVersion(current, latest) {
+  const a = installationVersion(current).replace(/\+.*/, "");
+  const b = installationVersion(latest).replace(/\+.*/, "");
+  const coreA = a.replace(/-.*/, "").split(".").map(BigInt);
+  const coreB = b.replace(/-.*/, "").split(".").map(BigInt);
+  for (let i = 0; i < Math.max(coreA.length, coreB.length); i++) {
+    if ((coreA[i] ?? 0n) !== (coreB[i] ?? 0n))
+      return (coreB[i] ?? 0n) > (coreA[i] ?? 0n);
+  }
+  const preA = a.includes("-") ? a.slice(a.indexOf("-") + 1).split(".") : [];
+  const preB = b.includes("-") ? b.slice(b.indexOf("-") + 1).split(".") : [];
+  if (!preA.length || !preB.length)
+    return !!preA.length && !preB.length;
+  for (let i = 0; i < Math.max(preA.length, preB.length); i++) {
+    const x2 = preA[i];
+    const y = preB[i];
+    if (x2 === y)
+      continue;
+    if (x2 === void 0 || y === void 0)
+      return x2 === void 0;
+    const numericX = /^\d+$/.test(x2);
+    const numericY = /^\d+$/.test(y);
+    if (numericX && numericY) {
+      if (BigInt(x2) === BigInt(y))
+        continue;
+      return BigInt(y) > BigInt(x2);
+    }
+    if (numericX !== numericY)
+      return numericX;
+    return y > x2;
+  }
+  return false;
+}
+function createInstallationManager(options) {
+  let checking;
+  let updating;
+  const check2 = () => checking ??= options.check().finally(() => {
+    checking = void 0;
+  });
+  return (action) => {
+    if (updating)
+      return updating;
+    if (action === "check")
+      return check2();
+    updating = (async () => {
+      const before = await check2();
+      if (!before.updateAvailable)
+        return before;
+      if (!before.canUpdate)
+        throw new Error(before.message ?? "This installation cannot be updated automatically");
+      await options.update(before);
+      const after = await check2();
+      if (after.currentVersion === before.currentVersion)
+        throw new Error("The Harness version did not change; check the native updater and retry");
+      return after;
+    })().finally(() => {
+      updating = void 0;
+    });
+    return updating;
+  };
+}
+async function fetchInstallationText(url2) {
+  const request = async () => {
+    const response = await fetch(url2, { signal: AbortSignal.timeout(15e3) });
+    if (!response.ok)
+      throw new Error("Could not check the latest Harness version");
+    return response.text();
+  };
+  try {
+    return await request();
+  } catch (error52) {
+    if (error52 instanceof DOMException && (error52.name === "AbortError" || error52.name === "TimeoutError"))
+      throw error52;
+    return request();
+  }
+}
+
+// ../../harness-discovery/dist/npm-installation.js
+import { readFile as readFile2, realpath as realpath2 } from "node:fs/promises";
+import path6 from "node:path";
+function referencesNpmBin(shim, name, bin) {
+  if (bin.includes(".."))
+    return false;
+  const target = `node_modules/${name}/${bin.replace(/^\.\//, "")}`.toLowerCase();
+  const text = shim.replaceAll("\\", "/").toLowerCase();
+  return text.includes(`%dp0%/${target}"`) || text.includes(`%~dp0/${target}"`);
+}
+async function npmInstallation(command, packages, environment) {
+  let selected = await realpath2(command);
+  if (process.platform === "win32" && /\.(cmd|bat)$/i.test(selected)) {
+    const shim = (await readFile2(selected, "utf8")).replaceAll("\\", "/");
+    const root = path6.dirname(selected);
+    for (const name of packages) {
+      const directory2 = path6.join(root, "node_modules", ...name.split("/"));
+      const metadata = await readFile2(path6.join(directory2, "package.json"), "utf8").then((text) => JSON.parse(text)).catch(() => null);
+      const bins = typeof metadata?.bin === "string" ? [metadata.bin] : Object.values(metadata?.bin ?? {});
+      const bin = bins.find((entry) => referencesNpmBin(shim, name, entry));
+      if (bin) {
+        selected = await realpath2(path6.join(directory2, bin));
+        break;
+      }
+    }
+  }
+  let directory = path6.dirname(selected);
+  for (let depth = 0; depth < 8; depth++) {
+    const metadata = await readFile2(path6.join(directory, "package.json"), "utf8").then((text) => JSON.parse(text)).catch(() => null);
+    if (metadata?.name && packages.includes(metadata.name)) {
+      const name = metadata.name;
+      const currentVersion = installationVersion(metadata.version);
+      const segments = name.split("/");
+      let modules = directory;
+      for (let index = 0; index < segments.length; index++)
+        modules = path6.dirname(modules);
+      const prefix = process.platform === "win32" ? path6.dirname(modules) : path6.dirname(path6.dirname(modules));
+      const globalRoot = process.platform === "win32" ? path6.join(prefix, "node_modules") : path6.join(prefix, "lib", "node_modules");
+      const env = withNodeRuntimeOnPath(environment);
+      const npm = resolveHarnessExecutable({ id: "npm", command: "npm", installRoots: { posix: [], windows: [] } }, { environment: env });
+      let globalInstall = modules === globalRoot;
+      if (process.platform === "win32") {
+        const project = (await Promise.all(["package.json", "package-lock.json", "npm-shrinkwrap.json"].map((file2) => readFile2(path6.join(prefix, file2), "utf8").then(() => true, (error52) => error52.code !== "ENOENT")))).some(Boolean);
+        const bins = typeof metadata.bin === "string" ? { [name.split("/").at(-1) ?? name]: metadata.bin } : metadata.bin ?? {};
+        const launchers = await Promise.all(Object.entries(bins).map(async ([bin, entry]) => {
+          if (path6.basename(bin) !== bin || entry.includes(".."))
+            return false;
+          const target = await realpath2(path6.join(directory, entry)).catch(() => "");
+          if (target.toLowerCase() !== selected.toLowerCase())
+            return false;
+          const shim = await readFile2(path6.join(prefix, `${bin}.cmd`), "utf8").catch(() => "");
+          return referencesNpmBin(shim, name, entry);
+        }));
+        globalInstall = globalInstall && !project && launchers.some(Boolean);
+      }
+      const canUpdate = globalInstall && !!npm;
+      return {
+        prefix,
+        currentVersion,
+        canUpdate,
+        latest: async () => {
+          const data = JSON.parse(await fetchInstallationText(`https://registry.npmjs.org/${encodeURIComponent(name)}/latest`));
+          return installationVersion(data.version);
+        },
+        update: async (version2) => {
+          if (!canUpdate || !npm)
+            throw new Error("Use the original package manager to update this installation");
+          await runInstallationCommand(npm.executable, ["install", "--global", "--prefix", prefix, `${name}@${installationVersion(version2)}`], env, 3e5);
+        }
+      };
+    }
+    const parent = path6.dirname(directory);
+    if (parent === directory)
+      break;
+    directory = parent;
+  }
+  return null;
+}
+
+// ../../harness-discovery/dist/installer.js
+import { mkdtemp, rm as rm2, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join2 } from "node:path";
+function createHarnessInstaller(environment, source) {
+  return async () => {
+    if (!["darwin", "linux", "win32"].includes(process.platform))
+      throw new Error("Unsupported installation platform");
+    const env = withNodeRuntimeOnPath(environment);
+    if ("npm" in source) {
+      const npm = resolveHarnessExecutable({
+        id: "npm",
+        command: "npm",
+        installRoots: {
+          posix: [
+            "~/.npm-global/bin",
+            "~/.local/bin",
+            VERSION_MANAGER_ROOTS,
+            "/opt/homebrew/bin",
+            "/usr/local/bin",
+            "/usr/bin"
+          ],
+          windows: [
+            "${APPDATA}/npm",
+            VERSION_MANAGER_ROOTS,
+            "${ProgramFiles}/nodejs",
+            "${LOCALAPPDATA}/Programs/nodejs"
+          ]
+        }
+      }, { environment: env });
+      if (!npm)
+        throw new Error("Install Node.js and npm first");
+      await runInstallationCommand(npm.executable, ["install", "--global", source.npm], {
+        ...env,
+        ...source.allowScripts ? { npm_config_allow_scripts: source.allowScripts } : {}
+      }, 6e5);
+      return;
+    }
+    const windows = process.platform === "win32";
+    const url2 = windows ? source.windows : source.posix;
+    if (new URL(url2).protocol !== "https:")
+      throw new Error("Installer requires HTTPS");
+    const script = await fetchInstallationText(url2);
+    const directory = await mkdtemp(join2(tmpdir(), "codexhost-installer-"));
+    try {
+      const file2 = join2(directory, windows ? "install.ps1" : "install.sh");
+      await writeFile(file2, script, { mode: 384 });
+      await runInstallationCommand(windows ? "powershell.exe" : source.shell ?? "bash", windows ? ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File", file2] : [file2], env, 6e5);
+    } finally {
+      await rm2(directory, { recursive: true, force: true });
+    }
+  };
+}
+
 // dist/command.js
 var ClaudeCodeExecutableError = class extends Error {
   code = "CLAUDE_NOT_FOUND";
@@ -42854,14 +43335,14 @@ function resolveClaudeCodeExecutable(input = {}, dependencies = {}) {
   }, dependencies);
   if (!resolution)
     throw new ClaudeCodeExecutableError("Claude Code is not installed");
-  return targetPath(platform).isAbsolute(resolution.executable) ? resolution.executable : path5.resolve(resolution.executable);
+  return targetPath(platform).isAbsolute(resolution.executable) ? resolution.executable : path7.resolve(resolution.executable);
 }
 
 // dist/pending-session.js
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { mkdir, open, readFile as readFile2, rename, rm as rm2, stat as stat2, unlink } from "node:fs/promises";
+import { mkdir, open, readFile as readFile3, rename, rm as rm3, stat as stat2, unlink } from "node:fs/promises";
 import os4 from "node:os";
-import path6 from "node:path";
+import path8 from "node:path";
 var reservationSchema = external_exports.strictObject({
   version: external_exports.literal(1),
   sessionId: external_exports.uuid(),
@@ -42874,13 +43355,13 @@ function isPendingClaudeSession(ref) {
 var ClaudePendingSessions = class {
   #directory;
   constructor(environment) {
-    this.#directory = path6.join(path6.resolve(environment.CLAUDE_CONFIG_DIR ?? path6.join(os4.homedir(), ".claude")), "codexhost", "pending-sessions");
+    this.#directory = path8.join(path8.resolve(environment.CLAUDE_CONFIG_DIR ?? path8.join(os4.homedir(), ".claude")), "codexhost", "pending-sessions");
   }
   #path(ref, cwd) {
-    if (ref.harnessId !== "claude-code" || !external_exports.uuid().safeParse(ref.nativeSessionId).success || !external_exports.strictObject({ pendingSession: external_exports.literal(1) }).safeParse(ref.locator).success || !path6.isAbsolute(cwd)) {
+    if (ref.harnessId !== "claude-code" || !external_exports.uuid().safeParse(ref.nativeSessionId).success || !external_exports.strictObject({ pendingSession: external_exports.literal(1) }).safeParse(ref.locator).success || !path8.isAbsolute(cwd)) {
       throw new Error("Claude Code pending Session identity is invalid");
     }
-    return path6.join(this.#directory, ref.nativeSessionId);
+    return path8.join(this.#directory, ref.nativeSessionId);
   }
   async create(cwd, configuration) {
     const ref = nativeSessionRefSchema.parse({
@@ -42899,7 +43380,7 @@ var ClaudePendingSessions = class {
     await mkdir(this.#directory, { recursive: true, mode: 448 });
     await mkdir(directory, { mode: 448 });
     try {
-      const file2 = await open(path6.join(directory, "session.json"), "wx", 384);
+      const file2 = await open(path8.join(directory, "session.json"), "wx", 384);
       try {
         await file2.writeFile(JSON.stringify(reservation));
         await file2.sync();
@@ -42907,7 +43388,7 @@ var ClaudePendingSessions = class {
         await file2.close();
       }
     } catch (error52) {
-      await rm2(directory, { recursive: true, force: true });
+      await rm3(directory, { recursive: true, force: true });
       throw error52;
     }
     await this.#sync(directory);
@@ -42916,13 +43397,13 @@ var ClaudePendingSessions = class {
   }
   async read(ref, cwd) {
     const directory = this.#path(ref, cwd);
-    const reservation = reservationSchema.parse(JSON.parse(await readFile2(path6.join(directory, "session.json"), "utf8")));
+    const reservation = reservationSchema.parse(JSON.parse(await readFile3(path8.join(directory, "session.json"), "utf8")));
     if (reservation.sessionId !== ref.nativeSessionId || reservation.cwd !== cwd) {
       throw new Error("Claude Code pending Session does not belong to this working directory");
     }
     let started = false;
     try {
-      const claim = await stat2(path6.join(directory, "started"));
+      const claim = await stat2(path8.join(directory, "started"));
       if (!claim.isFile())
         throw new Error("Claude Code pending Session claim is invalid");
       started = true;
@@ -42935,7 +43416,7 @@ var ClaudePendingSessions = class {
   async saveConfiguration(ref, cwd, configuration) {
     await this.read(ref, cwd);
     const directory = this.#path(ref, cwd);
-    const temporary = path6.join(directory, `${randomUUID2()}.tmp`);
+    const temporary = path8.join(directory, `${randomUUID2()}.tmp`);
     try {
       const file2 = await open(temporary, "wx", 384);
       try {
@@ -42949,10 +43430,10 @@ var ClaudePendingSessions = class {
       } finally {
         await file2.close();
       }
-      await rename(temporary, path6.join(directory, "session.json"));
+      await rename(temporary, path8.join(directory, "session.json"));
       await this.#sync(directory);
     } finally {
-      await rm2(temporary, { force: true });
+      await rm3(temporary, { force: true });
     }
   }
   async #sync(directory) {
@@ -42967,7 +43448,7 @@ var ClaudePendingSessions = class {
   }
   async claim(ref, cwd) {
     await this.read(ref, cwd);
-    const claim = await open(path6.join(this.#path(ref, cwd), "started"), "wx", 384);
+    const claim = await open(path8.join(this.#path(ref, cwd), "started"), "wx", 384);
     try {
       await claim.sync();
     } finally {
@@ -42977,249 +43458,1009 @@ var ClaudePendingSessions = class {
   }
   /** Only the claim owner may release, after proven close and before submitting any native input. */
   async release(ref, cwd) {
-    await unlink(path6.join(this.#path(ref, cwd), "started"));
+    await unlink(path8.join(this.#path(ref, cwd), "started"));
     await this.#sync(this.#path(ref, cwd));
   }
   async discard(ref, cwd) {
-    await rm2(this.#path(ref, cwd), { recursive: true, force: true });
+    await rm3(this.#path(ref, cwd), { recursive: true, force: true });
   }
 };
 
 // dist/claude-fork.js
-import path7 from "node:path";
+import path10 from "node:path";
 import { isDeepStrictEqual } from "node:util";
 
-// dist/item-identity.js
-function claudeTranscriptItemId(nativeTurnKey, kind, ordinal) {
-  return hostItemIdSchema.parse(`claude-item-v2-${nativeTurnKey}-${kind}-${ordinal}`);
-}
-
-// dist/claude-history.js
-var claudeCodeHarnessId = harnessIdSchema.parse("claude-code");
+// dist/file-change.js
+import path9 from "node:path";
+var hunkSchema = external_exports.object({
+  oldStart: external_exports.number().int().nonnegative(),
+  oldLines: external_exports.number().int().nonnegative(),
+  newStart: external_exports.number().int().nonnegative(),
+  newLines: external_exports.number().int().nonnegative(),
+  lines: external_exports.array(external_exports.string())
+}).strict();
 function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function textParts(value) {
-  if (typeof value === "string")
-    return value.length > 0 ? [value] : [];
-  if (!Array.isArray(value))
-    return [];
-  return value.flatMap((part) => isRecord3(part) && part.type === "text" && typeof part.text === "string" ? [part.text] : []);
+function validNativePath(value) {
+  return typeof value === "string" && value.trim().length > 0 && !value.includes("\0") && !value.includes("\n") && !value.includes("\r");
 }
-function thinkingParts(value) {
-  if (!Array.isArray(value))
-    return [];
-  return value.flatMap((part) => isRecord3(part) && part.type === "thinking" && typeof part.thinking === "string" ? [part.thinking] : []);
+function countLines(lines, prefixes) {
+  return lines.filter((line) => line.length > 0 && prefixes.has(line[0])).length;
 }
-var localCommandRecordPattern = /^\s*<(local-command-(?:stdout|caveat))>[\s\S]*<\/\1>\s*$/u;
-var taskNotificationRecordPattern = /^\s*<task-notification>[\s\S]*<\/task-notification>\s*$/u;
-var commandEnvelopePattern = /^\s*(?:<(command-(?:message|name|args))>[\s\S]*?<\/\1>\s*)+$/u;
-var controlCommandNamePattern = /<command-name>\s*\/(?:model|compact)\s*<\/command-name>/u;
-var recapCommandNamePattern = /<command-name>\s*\/recap\s*<\/command-name>/u;
-var initCommandNamePattern = /<command-name>\s*\/init\s*<\/command-name>/u;
-var localCommandStdoutPattern = /^\s*<local-command-stdout>([\s\S]*)<\/local-command-stdout>\s*$/u;
-function isLocalCommandRecord(text) {
-  return localCommandRecordPattern.test(text);
+function validHunk(value) {
+  const parsed = hunkSchema.safeParse(value);
+  if (!parsed.success)
+    return null;
+  const hunk = parsed.data;
+  if (hunk.lines.some((line) => line.length === 0 || ![" ", "+", "-", "\\"].includes(line[0]))) {
+    return null;
+  }
+  if (countLines(hunk.lines, /* @__PURE__ */ new Set([" ", "-"])) !== hunk.oldLines)
+    return null;
+  if (countLines(hunk.lines, /* @__PURE__ */ new Set([" ", "+"])) !== hunk.newLines)
+    return null;
+  return hunk;
 }
-function isTaskNotificationRecord(text) {
-  return taskNotificationRecordPattern.test(text);
+function parseClaudeNativeFileChange(toolName, value) {
+  if (toolName !== "Edit" && toolName !== "Write" || !isRecord3(value))
+    return null;
+  if (!validNativePath(value.filePath) || !Array.isArray(value.structuredPatch))
+    return null;
+  const hunks = value.structuredPatch.map(validHunk);
+  if (hunks.length === 0 || hunks.some((hunk) => hunk === null))
+    return null;
+  if (toolName === "Write" && value.type !== "create" && value.type !== "update")
+    return null;
+  return {
+    path: value.filePath,
+    kind: toolName === "Write" && value.type === "create" ? "add" : "update",
+    hunks
+  };
 }
-function isControlCommandEnvelope(text) {
-  return commandEnvelopePattern.test(text) && controlCommandNamePattern.test(text);
+function displayPath(nativePath, cwd) {
+  const resolvedCwd = path9.resolve(cwd);
+  const resolvedPath = path9.isAbsolute(nativePath) ? path9.resolve(nativePath) : path9.resolve(cwd, nativePath);
+  const relative = path9.relative(resolvedCwd, resolvedPath);
+  const selected = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path9.sep}`) ? relative : resolvedPath;
+  const normalized = selected.replaceAll("\\", "/");
+  return validNativePath(normalized) && normalized !== "." ? normalized : null;
 }
-function isNamedCommandEnvelope(text, namePattern) {
-  return commandEnvelopePattern.test(text) && namePattern.test(text);
+function projectClaudeFileChange(value, cwd) {
+  const normalizedPath = displayPath(value.path, cwd);
+  if (!normalizedPath)
+    return null;
+  const body = value.hunks.flatMap((hunk) => [
+    `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`,
+    ...hunk.lines
+  ]);
+  const absoluteDisplayPath = path9.posix.isAbsolute(normalizedPath);
+  const oldHeader = value.kind === "add" ? "/dev/null" : absoluteDisplayPath ? normalizedPath : `a/${normalizedPath}`;
+  const newHeader = absoluteDisplayPath ? normalizedPath : `b/${normalizedPath}`;
+  const unifiedDiff = [`--- ${oldHeader}`, `+++ ${newHeader}`, ...body, ""].join("\n");
+  return { path: normalizedPath, kind: value.kind, unifiedDiff };
 }
-function displayedUserText(text) {
-  if (isNamedCommandEnvelope(text, initCommandNamePattern))
-    return "/init";
-  if (isNamedCommandEnvelope(text, recapCommandNamePattern))
-    return "/recap";
-  return text;
+
+// dist/native-message.js
+var ABORTED_TERMINALS = /* @__PURE__ */ new Set(["aborted_streaming", "aborted_tools"]);
+var AUTHENTICATION_ERRORS = /* @__PURE__ */ new Set(["authentication_failed", "oauth_org_not_allowed"]);
+var CLAUDE_SUBAGENT_TOOLS = /* @__PURE__ */ new Set(["Agent", "Task", "SendMessage"]);
+var BACKGROUND_OUTPUT_FILE_PATTERN = /Output is being written to: (.+?\.output)\./u;
+var SUBAGENT_DESCRIPTION_LIMIT = 500;
+var SUBAGENT_SUMMARY_LIMIT = 2e3;
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function localCommandStdoutText(text) {
-  const match = localCommandStdoutPattern.exec(text);
-  if (!match)
+function nativeUuid(message) {
+  return typeof message.uuid === "string" && message.uuid.length > 0 ? message.uuid : null;
+}
+function parentToolUseId(message) {
+  return typeof message.parent_tool_use_id === "string" && message.parent_tool_use_id.length > 0 ? message.parent_tool_use_id : null;
+}
+function assistantNativeMessageId(message) {
+  if (!isRecord4(message.message))
     return null;
-  return match[1] ?? "";
+  return typeof message.message.id === "string" && message.message.id.length > 0 ? message.message.id : null;
 }
-function isTaskNotificationOrigin(value) {
-  return isRecord3(value.origin) && value.origin.kind === "task-notification";
+function assistantContent(message) {
+  if (message.type !== "assistant" || !isRecord4(message.message))
+    return null;
+  return Array.isArray(message.message.content) ? message.message.content : null;
 }
-function visibleUserTextParts(message) {
-  if (message.type !== "user" || message.syntheticUser)
-    return [];
-  const parts = textParts(message.message.content);
-  if (parts.some(isControlCommandEnvelope))
-    return [];
-  return parts.filter((part) => !isLocalCommandRecord(part) && !isTaskNotificationRecord(part));
+function assistantText(message) {
+  const content = assistantContent(message);
+  if (!content)
+    return null;
+  return content.flatMap((block) => isRecord4(block) && block.type === "text" && typeof block.text === "string" ? [block.text] : []).join("");
 }
-function isInterruptionRecord(value, promptId) {
-  if (value.type !== "user" || promptId === null || value.promptId !== promptId || value.promptSource !== void 0 || !isRecord3(value.message))
-    return false;
-  const content = value.message.content;
-  if (!Array.isArray(content) || content.length !== 1)
-    return false;
-  const part = content[0];
-  return isRecord3(part) && part.type === "text" && (part.text === "[Request interrupted by user]" || part.text === "[Request interrupted by user for tool use]");
+function assistantError(message) {
+  return isRecord4(message) && message.type === "assistant" && typeof message.error === "string" ? message.error : null;
 }
-function conversationMessages(values, sessionId) {
-  const messages = [];
-  const ids = /* @__PURE__ */ new Set();
-  let promptId = null;
-  for (const value of values) {
-    if (!isRecord3(value))
-      throw new Error("Claude history contains a malformed message");
-    if (value.type === "system")
-      continue;
-    if (value.type !== "user" && value.type !== "assistant" || typeof value.uuid !== "string" || value.uuid.length === 0 || value.session_id !== sessionId || !isRecord3(value.message) || value.message.role !== value.type) {
-      throw new Error("Claude history contains an invalid message identity");
-    }
-    if (ids.has(value.uuid))
-      throw new Error("Claude history contains duplicate message IDs");
-    ids.add(value.uuid);
-    const interrupted = isInterruptionRecord(value, promptId);
-    const message = {
-      type: value.type,
-      uuid: value.uuid,
-      message: value.message,
-      interrupted,
-      syntheticUser: value.type === "user" && (interrupted || value.isSynthetic === true || value.isMeta === true || isTaskNotificationOrigin(value) || value.toolUseResult !== void 0 && value.toolUseResult !== null)
-    };
-    messages.push(message);
-    if (isHumanUser(message)) {
-      promptId = typeof value.promptId === "string" && value.promptId.length > 0 ? value.promptId : null;
+function boundedString(value, limit) {
+  if (typeof value !== "string")
+    return void 0;
+  const trimmed = value.trim();
+  if (trimmed.length === 0)
+    return void 0;
+  return trimmed.slice(0, limit);
+}
+function subagentDescription(argumentsValue, toolName) {
+  if (!isRecord4(argumentsValue))
+    return `${toolName} delegation`;
+  return boundedString(argumentsValue.description, SUBAGENT_DESCRIPTION_LIMIT) ?? boundedString(argumentsValue.summary, SUBAGENT_DESCRIPTION_LIMIT) ?? boundedString(argumentsValue.name, SUBAGENT_DESCRIPTION_LIMIT) ?? `${toolName} delegation`;
+}
+function subagentPrompt(argumentsValue) {
+  if (!isRecord4(argumentsValue))
+    return void 0;
+  return boundedString(argumentsValue.prompt ?? argumentsValue.message, SUBAGENT_SUMMARY_LIMIT);
+}
+function subagentRole(argumentsValue) {
+  if (!isRecord4(argumentsValue))
+    return void 0;
+  return boundedString(argumentsValue.subagent_type ?? argumentsValue.agent_type, SUBAGENT_DESCRIPTION_LIMIT);
+}
+function subagentBackground(argumentsValue) {
+  return isRecord4(argumentsValue) && argumentsValue.run_in_background === true;
+}
+function targetedSubagentId(argumentsValue) {
+  if (!isRecord4(argumentsValue))
+    return void 0;
+  return boundedString(argumentsValue.to ?? argumentsValue.recipient ?? argumentsValue.agentId, SUBAGENT_DESCRIPTION_LIMIT);
+}
+function includesAuthenticationFailure(errors) {
+  return errors.some((error52) => AUTHENTICATION_ERRORS.has(error52));
+}
+function failure(kind) {
+  return { status: "failed", kind };
+}
+function safeNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function finiteNonNegativeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function parseResultModelUsage(value) {
+  if (!isRecord4(value))
+    return void 0;
+  const usage = [];
+  for (const entry of Object.values(value)) {
+    if (!isRecord4(entry) || !safeNonNegativeInteger(entry.inputTokens) || !safeNonNegativeInteger(entry.outputTokens)) {
+      return void 0;
     }
+    usage.push({ inputTokens: entry.inputTokens, outputTokens: entry.outputTokens });
   }
-  return messages;
+  return usage;
 }
-function isHumanUser(message) {
-  return visibleUserTextParts(message).length > 0;
+function parseLastRequestUsage(value, attribution = {}) {
+  if (!isRecord4(value))
+    return void 0;
+  const inputTokens = value.input_tokens;
+  const outputTokens = value.output_tokens;
+  const cacheCreationInputTokens = value.cache_creation_input_tokens;
+  const cacheReadInputTokens = value.cache_read_input_tokens;
+  if (!safeNonNegativeInteger(inputTokens) || !safeNonNegativeInteger(outputTokens) || !safeNonNegativeInteger(cacheCreationInputTokens) || !safeNonNegativeInteger(cacheReadInputTokens)) {
+    return void 0;
+  }
+  const requestId = boundedString(attribution.requestId, 500);
+  const model = boundedString(attribution.model, 500);
+  const provider = boundedString(attribution.provider, 100);
+  return {
+    ...requestId ? { requestId } : {},
+    ...model ? { model } : {},
+    ...provider ? { provider } : {},
+    inputTokens,
+    outputTokens,
+    cacheCreationInputTokens,
+    cacheReadInputTokens
+  };
 }
-function turnOutcome(messages) {
-  if (messages.some(({ interrupted }) => interrupted))
-    return { status: "cancelled", reason: "Cancelled by user" };
-  const assistants = messages.filter(({ type }) => type === "assistant");
-  const failed = assistants.some(({ message }) => typeof message.error === "string");
-  if (failed) {
-    return {
-      status: "failed",
-      error: {
-        code: "nativeFailure",
-        message: "Claude Assistant failed",
-        retryable: false
-      }
-    };
+function assistantRequestUsage(message, provider) {
+  if (!isRecord4(message.message))
+    return void 0;
+  return parseLastRequestUsage(message.message.usage, {
+    requestId: message.message.id ?? message.request_id,
+    model: message.message.model,
+    provider: message.provider ?? message.message.provider ?? provider
+  });
+}
+function parseResultUsageEvent(message) {
+  const totalCostUsd = finiteNonNegativeNumber(message.total_cost_usd) ? message.total_cost_usd : void 0;
+  const modelUsage = parseResultModelUsage(message.modelUsage);
+  const lastRequestUsage = parseLastRequestUsage(message.usage);
+  if (totalCostUsd === void 0 && modelUsage === void 0 && lastRequestUsage === void 0) {
+    return null;
   }
-  const final = assistants.at(-1);
-  if (!final)
-    return { status: "unknown", reason: "Claude history has no Assistant terminal" };
   return {
-    status: "unknown",
-    reason: "Claude history does not include complete Result terminal evidence"
+    type: "usage.result",
+    ...totalCostUsd !== void 0 ? { totalCostUsd } : {},
+    ...modelUsage !== void 0 ? { modelUsage } : {},
+    ...lastRequestUsage ? { lastRequestUsage } : {}
   };
 }
-function itemOutcome(outcome) {
-  if (outcome.status === "failed")
-    return { status: "failed", error: outcome.error };
-  if (outcome.status === "cancelled") {
-    return {
-      status: "cancelled",
-      ...outcome.reason ? { reason: outcome.reason } : {}
-    };
+function parsePlanLimitWindow(value) {
+  if (!isRecord4(value))
+    return void 0;
+  const utilization = value.utilization;
+  if (typeof utilization !== "number" || !Number.isFinite(utilization) || utilization < 0) {
+    return void 0;
   }
-  return { status: "succeeded" };
+  const utilizationPercent = Math.min(100, Math.max(0, Math.round(utilization * 1e4) / 100));
+  const resetsAt = value.resetsAt;
+  const resetsAtUnix = safeNonNegativeInteger(resetsAt) ? resetsAt : void 0;
+  return { utilizationPercent, ...resetsAtUnix !== void 0 ? { resetsAtUnix } : {} };
 }
-function mapClaudeSnapshot(values, sessionId) {
-  const messages = conversationMessages(values, sessionId);
-  const turns = [];
-  for (let index = 0; index < messages.length; ) {
-    const user = messages[index];
-    if (!user || !isHumanUser(user)) {
-      index += 1;
-      continue;
-    }
-    let end = index + 1;
-    while (end < messages.length && !isHumanUser(messages[end]))
-      end += 1;
-    const turnMessages = messages.slice(index, end);
-    const outcome = turnOutcome(turnMessages);
-    const results = toolResultBlocks(turnMessages);
-    const checkpointMessage = turnMessages.findLast(({ type, interrupted }) => type === "assistant" || interrupted);
-    let agentMessageOrdinal = 0;
-    let reasoningOrdinal = 0;
-    turns.push({
-      nativeTurnRef: nativeTurnRefSchema.parse({
-        harnessId: claudeCodeHarnessId,
-        nativeSessionId: sessionId,
-        nativeTurnKey: user.uuid,
-        formatVersion: 1
-      }),
-      ...checkpointMessage ? {
-        checkpoint: nativeCheckpointRefSchema.parse({
-          harnessId: claudeCodeHarnessId,
-          nativeSessionId: sessionId,
-          checkpointId: checkpointMessage.uuid,
-          formatVersion: 1
-        })
-      } : {},
-      input: visibleUserTextParts(user).map((text) => ({
-        type: "text",
-        text: displayedUserText(text)
-      })),
-      items: turnMessages.flatMap((message) => {
-        if (message.type === "user") {
-          const recapOutput = visibleUserTextParts(user).some((text2) => isNamedCommandEnvelope(text2, recapCommandNamePattern)) ? textParts(message.message.content).map(localCommandStdoutText).find((text2) => text2 !== null && text2.length > 0) : void 0;
-          if (!recapOutput)
-            return [];
-          return [
-            {
-              item: {
-                type: "agentMessage",
-                itemId: claudeTranscriptItemId(user.uuid, "agentMessage", agentMessageOrdinal += 1),
-                text: recapOutput
-              },
-              outcome: itemOutcome(outcome)
-            }
-          ];
-        }
-        if (message.type !== "assistant")
-          return [];
-        const content = message.message.content;
-        const text = textParts(content).join("");
-        const reasoning = thinkingParts(content).join("");
-        if (!Array.isArray(content)) {
-          return text.length > 0 ? [
-            {
-              item: {
-                type: "agentMessage",
-                itemId: claudeTranscriptItemId(user.uuid, "agentMessage", agentMessageOrdinal += 1),
-                text
-              },
-              outcome: itemOutcome(outcome)
-            }
-          ] : [];
-        }
-        const items = [];
-        let projectedReasoning = false;
-        let projectedText = false;
-        for (const [blockIndex, block] of content.entries()) {
-          if (!isRecord3(block))
-            continue;
-          if (block.type === "thinking" && !projectedReasoning && reasoning.length > 0) {
-            items.push({
-              item: {
-                type: "reasoning",
-                itemId: claudeTranscriptItemId(user.uuid, "reasoning", reasoningOrdinal += 1),
-                text: reasoning
-              },
-              outcome: itemOutcome(outcome)
-            });
-            projectedReasoning = true;
-            continue;
-          }
-          if (block.type === "text" && !projectedText && text.length > 0) {
-            items.push({
+function parseClaudePlanLimitEvent(message) {
+  if (!isRecord4(message) || message.type !== "rate_limit_event")
+    return null;
+  const info = message.rate_limit_info;
+  if (!isRecord4(info))
+    return null;
+  const windows = isRecord4(info.unifiedWindows) ? info.unifiedWindows : void 0;
+  let fiveHour = parsePlanLimitWindow(windows?.five_hour);
+  let sevenDay = parsePlanLimitWindow(windows?.seven_day);
+  if (!fiveHour && !sevenDay) {
+    const flatWindow = parsePlanLimitWindow(info);
+    if (flatWindow && info.rateLimitType === "five_hour")
+      fiveHour = flatWindow;
+    else if (flatWindow && info.rateLimitType === "seven_day")
+      sevenDay = flatWindow;
+  }
+  if (!fiveHour && !sevenDay)
+    return null;
+  return {
+    ...fiveHour ? { fiveHour } : {},
+    ...sevenDay ? { sevenDay } : {}
+  };
+}
+function nativeSubagentId(nativeResult, outputText) {
+  if (isRecord4(nativeResult)) {
+    const structured = boundedString(nativeResult.agentId ?? nativeResult.agent_id ?? nativeResult.task_id, SUBAGENT_DESCRIPTION_LIMIT);
+    if (structured)
+      return structured;
+  }
+  return boundedString(/agentId:\s*([A-Za-z0-9_-]+)/u.exec(outputText ?? "")?.[1], SUBAGENT_DESCRIPTION_LIMIT);
+}
+function subagentContinuesInBackground(nativeResult, outputText) {
+  if (isRecord4(nativeResult)) {
+    if (nativeResult.isAsync === true || nativeResult.is_async === true)
+      return true;
+    if (nativeResult.status === "async_launched")
+      return true;
+  }
+  return outputText?.includes("The agent is working in the background.") ?? false;
+}
+function resultText(content, nativeResult) {
+  let text = "";
+  if (typeof content === "string") {
+    text = content;
+  } else if (Array.isArray(content)) {
+    text = content.flatMap((block) => isRecord4(block) && block.type === "text" && typeof block.text === "string" ? [block.text] : []).join("");
+  }
+  if (text.length > 0)
+    return text;
+  if (!isRecord4(nativeResult))
+    return void 0;
+  const stdout = typeof nativeResult.stdout === "string" ? nativeResult.stdout : "";
+  const stderr = typeof nativeResult.stderr === "string" ? nativeResult.stderr : "";
+  const combined = stdout + stderr;
+  return combined.length > 0 ? combined : void 0;
+}
+function userMessageText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return null;
+  const text = content.flatMap((block) => isRecord4(block) && block.type === "text" && typeof block.text === "string" ? [block.text] : []).join("");
+  return text.length > 0 ? text : null;
+}
+function parseClaudeTaskNotification(message) {
+  if (!isRecord4(message) || message.type !== "user" || !isRecord4(message.message))
+    return null;
+  if (isRecord4(message.origin) && message.origin.kind !== "task-notification")
+    return null;
+  const content = userMessageText(message.message.content);
+  if (!content || !content.includes("<task-notification>"))
+    return null;
+  const taskId = content.match(/<task-id>([^<]+)<\/task-id>/u)?.[1]?.trim();
+  if (!taskId)
+    return null;
+  const xmlStatus = content.match(/<status>([^<]+)<\/status>/u)?.[1]?.trim();
+  const status = taskStatus(xmlStatus ?? "completed");
+  if (status !== "completed" && status !== "failed" && status !== "interrupted")
+    return null;
+  const summary = content.match(/<summary>([\s\S]*?)<\/summary>/u)?.[1]?.trim();
+  const callId = content.match(/<tool-use-id>([^<]+)<\/tool-use-id>/u)?.[1]?.trim();
+  const outputFile = content.match(/<output-file>([^<]+)<\/output-file>/u)?.[1]?.trim();
+  return {
+    type: "subagent.settled",
+    nativeSubagentId: taskId,
+    status,
+    ...callId ? { callId } : {},
+    ...summary ? { resultSummary: summary.slice(0, SUBAGENT_SUMMARY_LIMIT) } : {},
+    ...outputFile ? { outputFile } : {}
+  };
+}
+function taskStatus(value) {
+  switch (value) {
+    case "pending":
+      return "pending";
+    case "running":
+      return "running";
+    case "completed":
+      return "completed";
+    case "failed":
+      return "failed";
+    case "killed":
+    case "stopped":
+      return "interrupted";
+    default:
+      return null;
+  }
+}
+var ClaudeNativeTurnAccumulator = class {
+  #provider;
+  #activeRootStreamMessageId = null;
+  #assistantErrors = [];
+  #cancelRequested = false;
+  #compactionState = "idle";
+  #completed = false;
+  #completedToolIds = /* @__PURE__ */ new Set();
+  #messageOrdinal = 0;
+  #messages = /* @__PURE__ */ new Map();
+  #protocolConflict = false;
+  #textConflict = false;
+  #tools = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.#provider = options.provider;
+  }
+  requestCancel() {
+    this.#cancelRequested = true;
+  }
+  consume(message) {
+    if (this.#completed || !isRecord4(message))
+      return { events: [] };
+    const events = [];
+    this.#consumeSegmentLevel(message, events);
+    this.#consumeTaskLifecycle(message, events);
+    const parentCallId = parentToolUseId(message);
+    const nested = parentCallId !== null;
+    if (parentCallId && this.#tools.get(parentCallId)?.subagent === true && (message.type === "assistant" || message.type === "user")) {
+      events.push({ type: "subagent.transcript.changed", callId: parentCallId });
+    }
+    if (!nested) {
+      this.#consumeCompaction(message, events);
+      this.#consumeLocalCommandOutput(message, events);
+    }
+    if (message.type === "stream_event" && isRecord4(message.event)) {
+      if (!nested)
+        this.#consumeStreamEvent(message, events);
+    } else if (message.type === "tool_progress") {
+      this.#consumeToolProgress(message, events);
+    }
+    if (!nested) {
+      const error52 = assistantError(message);
+      if (error52 !== null)
+        this.#assistantErrors.push(error52);
+    }
+    if (message.type === "assistant") {
+      if (!nested)
+        this.#consumeAssistantMessage(message, events);
+    } else if (message.type === "user") {
+      this.#consumeTaskNotification(message, events);
+      this.#consumeToolResults(message, events, nested);
+    }
+    if (message.type !== "result")
+      return { events };
+    const usageEvent = parseResultUsageEvent(message);
+    if (usageEvent)
+      events.push(usageEvent);
+    this.#completed = true;
+    const terminalReason = typeof message.terminal_reason === "string" ? message.terminal_reason : "missing";
+    const nativeSuccess = message.subtype === "success" && message.is_error === false && (terminalReason === "completed" || terminalReason === "missing") && this.#assistantErrors.length === 0;
+    if (nativeSuccess && this.#tools.size > 0)
+      this.#protocolConflict = true;
+    let terminal;
+    if (this.#protocolConflict) {
+      terminal = failure("protocol");
+    } else if (this.#textConflict) {
+      terminal = failure("textConflict");
+    } else if (includesAuthenticationFailure(this.#assistantErrors)) {
+      terminal = failure("authentication");
+    } else if (this.#cancelRequested && ABORTED_TERMINALS.has(terminalReason)) {
+      terminal = { status: "cancelled", reason: terminalReason };
+    } else if (this.#cancelRequested) {
+      terminal = failure("cancellationUnproven");
+    } else if (nativeSuccess) {
+      terminal = { status: "succeeded" };
+    } else {
+      terminal = failure("native");
+    }
+    return { events, terminal };
+  }
+  #consumeCompaction(message, events) {
+    if (message.type !== "system")
+      return;
+    if (message.subtype === "status") {
+      if (message.status === "compacting" && this.#compactionState !== "active") {
+        this.#compactionState = "active";
+        events.push({ type: "compaction.started" });
+      }
+      if (message.compact_result === "success" || message.compact_result === "failed") {
+        if (this.#compactionState === "settled")
+          return;
+        if (this.#compactionState === "idle")
+          events.push({ type: "compaction.started" });
+        this.#compactionState = "settled";
+        events.push({
+          type: "compaction.completed",
+          outcome: message.compact_result === "success" ? "succeeded" : "failed"
+        });
+      }
+      return;
+    }
+    if (message.subtype !== "compact_boundary" || this.#compactionState === "settled")
+      return;
+    if (this.#compactionState === "idle")
+      events.push({ type: "compaction.started" });
+    this.#compactionState = "settled";
+    events.push({ type: "compaction.completed", outcome: "succeeded" });
+  }
+  #consumeLocalCommandOutput(message, events) {
+    if (message.type !== "system" || message.subtype !== "local_command_output")
+      return;
+    if (typeof message.content !== "string" || message.content.length === 0)
+      return;
+    const checkpointId = nativeUuid(message);
+    const messageId = checkpointId ?? this.#nextMessageId();
+    const state = this.#messageState(messageId);
+    if (state.completed)
+      return;
+    state.text += message.content;
+    events.push({ type: "text.delta", messageId, delta: message.content });
+    state.completed = true;
+    events.push({
+      type: "message.completed",
+      messageId,
+      ...checkpointId ? { checkpointId } : {}
+    });
+  }
+  /**
+   * Claude opens one native Segment per Root execution and reports its live
+   * background tasks as a level whose membership replaces the previous set.
+   */
+  #consumeSegmentLevel(message, events) {
+    if (message.type !== "system")
+      return;
+    if (message.subtype === "init") {
+      events.push({ type: "segment.started" });
+      return;
+    }
+    if (message.subtype !== "background_tasks_changed" || !Array.isArray(message.tasks))
+      return;
+    const nativeSubagentIds = message.tasks.flatMap((task) => {
+      if (!isRecord4(task))
+        return [];
+      const taskId = boundedString(task.task_id, SUBAGENT_DESCRIPTION_LIMIT);
+      return taskId ? [taskId] : [];
+    });
+    events.push({ type: "subagents.live", nativeSubagentIds });
+  }
+  #consumeTaskLifecycle(message, events) {
+    if (message.type !== "system")
+      return;
+    if (message.subtype === "task_notification") {
+      const agentId = boundedString(message.task_id, SUBAGENT_DESCRIPTION_LIMIT);
+      const status = taskStatus(message.status);
+      if (!agentId || status !== "completed" && status !== "failed" && status !== "interrupted") {
+        return;
+      }
+      const resultSummary = boundedString(message.summary, SUBAGENT_SUMMARY_LIMIT);
+      const callId2 = boundedString(message.tool_use_id, SUBAGENT_DESCRIPTION_LIMIT);
+      const outputFile = typeof message.output_file === "string" && message.output_file.length > 0 ? message.output_file : void 0;
+      events.push({
+        type: "subagent.settled",
+        nativeSubagentId: agentId,
+        status,
+        ...callId2 ? { callId: callId2 } : {},
+        ...resultSummary ? { resultSummary } : {},
+        ...outputFile ? { outputFile } : {}
+      });
+      return;
+    }
+    const callId = typeof message.tool_use_id === "string" ? message.tool_use_id : null;
+    if (!callId || !this.#tools.get(callId)?.subagent)
+      return;
+    if (message.subtype === "task_started") {
+      const description = boundedString(message.description, SUBAGENT_DESCRIPTION_LIMIT);
+      const role = boundedString(message.subagent_type, SUBAGENT_DESCRIPTION_LIMIT);
+      const agentId = boundedString(message.task_id, SUBAGENT_DESCRIPTION_LIMIT);
+      events.push({
+        type: "subagent.updated",
+        callId,
+        status: "running",
+        ...description ? { description } : {},
+        ...role ? { role } : {},
+        ...agentId ? { nativeSubagentId: agentId } : {}
+      });
+      return;
+    }
+    if (message.subtype === "task_progress") {
+      const description = boundedString(message.description, SUBAGENT_DESCRIPTION_LIMIT);
+      const role = boundedString(message.subagent_type, SUBAGENT_DESCRIPTION_LIMIT);
+      const resultSummary = boundedString(message.summary, SUBAGENT_SUMMARY_LIMIT);
+      const agentId = boundedString(message.task_id, SUBAGENT_DESCRIPTION_LIMIT);
+      events.push({
+        type: "subagent.updated",
+        callId,
+        status: "running",
+        ...description ? { description } : {},
+        ...role ? { role } : {},
+        ...agentId ? { nativeSubagentId: agentId } : {},
+        ...resultSummary ? { resultSummary } : {}
+      });
+      return;
+    }
+    if (message.subtype === "task_updated" && isRecord4(message.patch)) {
+      const status = taskStatus(message.patch.status);
+      if (!status)
+        return;
+      const description = boundedString(message.patch.description, SUBAGENT_DESCRIPTION_LIMIT);
+      const resultSummary = boundedString(message.patch.error, SUBAGENT_SUMMARY_LIMIT);
+      const agentId = boundedString(message.task_id, SUBAGENT_DESCRIPTION_LIMIT);
+      events.push({
+        type: "subagent.updated",
+        callId,
+        status,
+        ...description ? { description } : {},
+        ...agentId ? { nativeSubagentId: agentId } : {},
+        ...resultSummary ? { resultSummary } : {}
+      });
+    }
+  }
+  #consumeStreamEvent(message, events) {
+    const event = message.event;
+    if (!isRecord4(event))
+      return;
+    if (event.type === "message_start" && isRecord4(event.message) && typeof event.message.id === "string" && event.message.id.length > 0) {
+      this.#activeRootStreamMessageId = event.message.id;
+      this.#messageState(event.message.id);
+      return;
+    }
+    if (event.type !== "content_block_delta" || !isRecord4(event.delta))
+      return;
+    const messageId = this.#activeRootStreamMessageId ?? nativeUuid(message) ?? this.#nextMessageId();
+    if (!this.#activeRootStreamMessageId)
+      this.#activeRootStreamMessageId = messageId;
+    const state = this.#messageState(messageId);
+    if (state.completed) {
+      if (event.delta.type === "text_delta")
+        this.#textConflict = true;
+      return;
+    }
+    if (event.delta.type === "text_delta" && typeof event.delta.text === "string") {
+      if (event.delta.text.length === 0)
+        return;
+      state.text += event.delta.text;
+      events.push({ type: "text.delta", messageId, delta: event.delta.text });
+      return;
+    }
+    if (event.delta.type === "thinking_delta" && typeof event.delta.thinking === "string") {
+      if (event.delta.thinking.length === 0)
+        return;
+      state.reasoning += event.delta.thinking;
+      events.push({ type: "reasoning.delta", messageId, delta: event.delta.thinking });
+    }
+  }
+  #consumeAssistantMessage(message, events) {
+    const checkpointId = nativeUuid(message);
+    const nativeMessageId = assistantNativeMessageId(message);
+    const messageId = this.#activeRootStreamMessageId ?? nativeMessageId ?? checkpointId ?? this.#nextMessageId();
+    const state = this.#messageState(messageId);
+    if (state.completed) {
+      this.#consumeToolUseBlocks(message, events, true);
+      const usage = assistantRequestUsage(message, this.#provider);
+      if (usage && !state.usagePublished) {
+        state.usagePublished = true;
+        events.push({
+          type: "message.completed",
+          messageId,
+          ...checkpointId ? { checkpointId } : {},
+          lastRequestUsage: usage
+        });
+      }
+      return;
+    }
+    if (state.reasoning.length > 0) {
+      events.push({ type: "reasoning.completed", messageId });
+    }
+    const completeText = assistantText(message);
+    if (completeText !== null && completeText.length > 0) {
+      if (completeText.startsWith(state.text)) {
+        const suffix = completeText.slice(state.text.length);
+        if (suffix.length > 0) {
+          state.text += suffix;
+          events.push({ type: "text.delta", messageId, delta: suffix });
+        }
+      } else if (completeText !== state.text) {
+        this.#textConflict = true;
+      }
+    }
+    this.#consumeToolUseBlocks(message, events, false);
+    if (!this.#protocolConflict && !this.#textConflict) {
+      const usage = assistantRequestUsage(message, this.#provider);
+      state.usagePublished = usage !== void 0;
+      events.push({
+        type: "message.completed",
+        messageId,
+        ...checkpointId ? { checkpointId } : {},
+        ...usage ? { lastRequestUsage: usage } : {}
+      });
+    }
+    state.completed = true;
+    if (this.#activeRootStreamMessageId === messageId)
+      this.#activeRootStreamMessageId = null;
+  }
+  #consumeToolUseBlocks(message, events, ignoreKnownIds) {
+    for (const block of assistantContent(message) ?? []) {
+      if (!isRecord4(block) || block.type !== "tool_use")
+        continue;
+      const argumentsResult = jsonValueSchema.safeParse(block.input);
+      if (typeof block.id !== "string" || block.id.length === 0 || typeof block.name !== "string" || block.name.length === 0 || !argumentsResult.success) {
+        this.#protocolConflict = true;
+        continue;
+      }
+      if (this.#tools.has(block.id) || this.#completedToolIds.has(block.id)) {
+        if (!ignoreKnownIds)
+          this.#protocolConflict = true;
+        continue;
+      }
+      const subagent = CLAUDE_SUBAGENT_TOOLS.has(block.name);
+      this.#tools.set(block.id, { name: block.name, subagent });
+      if (subagent) {
+        const prompt = subagentPrompt(argumentsResult.data);
+        const role = subagentRole(argumentsResult.data);
+        const agentId = targetedSubagentId(argumentsResult.data);
+        events.push({
+          type: "subagent.started",
+          callId: block.id,
+          operation: block.name === "SendMessage" ? "send" : "spawn",
+          description: subagentDescription(argumentsResult.data, block.name),
+          ...prompt ? { prompt } : {},
+          ...role ? { role } : {},
+          background: block.name === "SendMessage" || subagentBackground(argumentsResult.data),
+          ...agentId ? { nativeSubagentId: agentId } : {}
+        });
+      } else {
+        events.push({
+          type: "tool.started",
+          callId: block.id,
+          toolName: block.name,
+          arguments: argumentsResult.data
+        });
+      }
+    }
+  }
+  #consumeToolProgress(message, events) {
+    const callId = message.tool_use_id;
+    const elapsedSeconds = message.elapsed_time_seconds;
+    if (typeof callId !== "string" || this.#tools.get(callId)?.subagent !== false || typeof elapsedSeconds !== "number" || !Number.isFinite(elapsedSeconds) || elapsedSeconds < 0) {
+      return;
+    }
+    events.push({ type: "tool.progress", callId, elapsedMs: Math.round(elapsedSeconds * 1e3) });
+  }
+  #consumeTaskNotification(message, events) {
+    const settled = parseClaudeTaskNotification(message);
+    if (settled)
+      events.push(settled);
+  }
+  #consumeToolResults(message, events, ignoreUnknown) {
+    if (!isRecord4(message.message) || !Array.isArray(message.message.content))
+      return;
+    const resultBlocks = message.message.content.filter((block) => isRecord4(block) && block.type === "tool_result");
+    if (resultBlocks.length === 0)
+      return;
+    if (resultBlocks.length > 1 && message.tool_use_result !== void 0) {
+      this.#protocolConflict = true;
+    }
+    for (const block of resultBlocks) {
+      const callId = block.tool_use_id;
+      if (typeof callId !== "string" || callId.length === 0) {
+        this.#protocolConflict = true;
+        continue;
+      }
+      const tool = this.#tools.get(callId);
+      if (!tool || this.#completedToolIds.has(callId)) {
+        if (!ignoreUnknown)
+          this.#protocolConflict = true;
+        continue;
+      }
+      if (block.is_error !== void 0 && typeof block.is_error !== "boolean") {
+        this.#protocolConflict = true;
+        continue;
+      }
+      this.#tools.delete(callId);
+      this.#completedToolIds.add(callId);
+      const isError = block.is_error === true;
+      const nativeResult = resultBlocks.length === 1 ? message.tool_use_result ?? message.toolUseResult : void 0;
+      const outputText = resultText(block.content, nativeResult);
+      const structuredResult = tool.name === "TaskCreate" || tool.name === "TaskUpdate" || tool.name === "TaskList" ? jsonValueSchema.safeParse(nativeResult) : null;
+      if (tool.subagent) {
+        const resultSummary = boundedString(outputText, SUBAGENT_SUMMARY_LIMIT);
+        const agentId = nativeSubagentId(nativeResult, outputText);
+        events.push({
+          type: "subagent.completed",
+          callId,
+          isError,
+          ...subagentContinuesInBackground(nativeResult, outputText) ? { continuesInBackground: true } : {},
+          ...agentId ? { nativeSubagentId: agentId } : {},
+          ...resultSummary ? { resultSummary } : {}
+        });
+        continue;
+      }
+      const fileChange = isError ? null : parseClaudeNativeFileChange(tool.name, nativeResult);
+      const backgroundTaskId = tool.name === "Bash" && !isError && isRecord4(nativeResult) && typeof nativeResult.backgroundTaskId === "string" && nativeResult.backgroundTaskId.length > 0 ? nativeResult.backgroundTaskId : void 0;
+      const outputFile = backgroundTaskId !== void 0 ? BACKGROUND_OUTPUT_FILE_PATTERN.exec(outputText ?? "")?.[1] : void 0;
+      const backgroundOutputFile = typeof outputFile === "string" && outputFile.length > 0 ? outputFile : void 0;
+      events.push({
+        type: "tool.completed",
+        callId,
+        toolName: tool.name,
+        ...outputText ? { outputText } : {},
+        ...structuredResult?.success ? { structuredResult: structuredResult.data } : {},
+        isError,
+        ...fileChange ? { fileChange } : {},
+        ...backgroundTaskId ? { backgroundTaskId } : {},
+        ...backgroundOutputFile ? { backgroundOutputFile } : {}
+      });
+    }
+  }
+  #messageState(messageId) {
+    const existing = this.#messages.get(messageId);
+    if (existing)
+      return existing;
+    const created = { completed: false, reasoning: "", text: "", usagePublished: false };
+    this.#messages.set(messageId, created);
+    return created;
+  }
+  #nextMessageId() {
+    this.#messageOrdinal += 1;
+    return `claude-assistant-${this.#messageOrdinal}`;
+  }
+};
+
+// dist/item-identity.js
+function claudeTranscriptItemId(nativeTurnKey, kind, ordinal) {
+  return hostItemIdSchema.parse(`claude-item-v2-${nativeTurnKey}-${kind}-${ordinal}`);
+}
+
+// dist/claude-history.js
+var claudeCodeHarnessId = harnessIdSchema.parse("claude-code");
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function textParts(value) {
+  if (typeof value === "string")
+    return value.length > 0 ? [value] : [];
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((part) => isRecord5(part) && part.type === "text" && typeof part.text === "string" ? [part.text] : []);
+}
+function thinkingParts(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((part) => isRecord5(part) && part.type === "thinking" && typeof part.thinking === "string" ? [part.thinking] : []);
+}
+var localCommandRecordPattern = /^\s*<(local-command-(?:stdout|caveat))>[\s\S]*<\/\1>\s*$/u;
+var taskNotificationRecordPattern = /^\s*<task-notification>[\s\S]*<\/task-notification>\s*$/u;
+var commandEnvelopePattern = /^\s*(?:<(command-(?:message|name|args))>[\s\S]*?<\/\1>\s*)+$/u;
+var controlCommandNamePattern = /<command-name>\s*\/(?:model|compact)\s*<\/command-name>/u;
+var recapCommandNamePattern = /<command-name>\s*\/recap\s*<\/command-name>/u;
+var initCommandNamePattern = /<command-name>\s*\/init\s*<\/command-name>/u;
+var localCommandStdoutPattern = /^\s*<local-command-stdout>([\s\S]*)<\/local-command-stdout>\s*$/u;
+function isLocalCommandRecord(text) {
+  return localCommandRecordPattern.test(text);
+}
+function isTaskNotificationRecord(text) {
+  return taskNotificationRecordPattern.test(text);
+}
+function isControlCommandEnvelope(text) {
+  return commandEnvelopePattern.test(text) && controlCommandNamePattern.test(text);
+}
+function isNamedCommandEnvelope(text, namePattern) {
+  return commandEnvelopePattern.test(text) && namePattern.test(text);
+}
+function displayedUserText(text) {
+  if (isNamedCommandEnvelope(text, initCommandNamePattern))
+    return "/init";
+  if (isNamedCommandEnvelope(text, recapCommandNamePattern))
+    return "/recap";
+  return text;
+}
+function localCommandStdoutText(text) {
+  const match = localCommandStdoutPattern.exec(text);
+  if (!match)
+    return null;
+  return match[1] ?? "";
+}
+function isTaskNotificationOrigin(value) {
+  return isRecord5(value.origin) && value.origin.kind === "task-notification";
+}
+function visibleUserTextParts(message) {
+  if (message.type !== "user" || message.syntheticUser)
+    return [];
+  const parts = textParts(message.message.content);
+  if (parts.some(isControlCommandEnvelope))
+    return [];
+  return parts.filter((part) => !isLocalCommandRecord(part) && !isTaskNotificationRecord(part));
+}
+function isInterruptionRecord(value, promptId) {
+  if (value.type !== "user" || promptId === null || value.promptId !== promptId || value.promptSource !== void 0 || !isRecord5(value.message))
+    return false;
+  const content = value.message.content;
+  if (!Array.isArray(content) || content.length !== 1)
+    return false;
+  const part = content[0];
+  return isRecord5(part) && part.type === "text" && (part.text === "[Request interrupted by user]" || part.text === "[Request interrupted by user for tool use]");
+}
+function conversationMessages(values, sessionId) {
+  const messages = [];
+  const ids = /* @__PURE__ */ new Set();
+  let promptId = null;
+  for (const value of values) {
+    if (!isRecord5(value))
+      throw new Error("Claude history contains a malformed message");
+    if (value.type === "system")
+      continue;
+    if (value.type !== "user" && value.type !== "assistant" || typeof value.uuid !== "string" || value.uuid.length === 0 || value.session_id !== sessionId || !isRecord5(value.message) || value.message.role !== value.type) {
+      throw new Error("Claude history contains an invalid message identity");
+    }
+    if (ids.has(value.uuid))
+      throw new Error("Claude history contains duplicate message IDs");
+    ids.add(value.uuid);
+    const interrupted = isInterruptionRecord(value, promptId);
+    const message = {
+      type: value.type,
+      uuid: value.uuid,
+      message: value.message,
+      nested: typeof value.parent_tool_use_id === "string" && value.parent_tool_use_id.length > 0,
+      interrupted,
+      syntheticUser: value.type === "user" && (interrupted || value.isSynthetic === true || value.isMeta === true || isTaskNotificationOrigin(value) || value.toolUseResult !== void 0 && value.toolUseResult !== null)
+    };
+    messages.push(message);
+    if (isHumanUser(message)) {
+      promptId = typeof value.promptId === "string" && value.promptId.length > 0 ? value.promptId : null;
+    }
+  }
+  return messages;
+}
+function isHumanUser(message) {
+  return visibleUserTextParts(message).length > 0;
+}
+function turnOutcome(messages) {
+  if (messages.some(({ interrupted }) => interrupted))
+    return { status: "cancelled", reason: "Cancelled by user" };
+  const assistants = messages.filter(({ type }) => type === "assistant");
+  const failed = assistants.some(({ message }) => typeof message.error === "string");
+  if (failed) {
+    return {
+      status: "failed",
+      error: {
+        code: "nativeFailure",
+        message: "Claude Assistant failed",
+        retryable: false
+      }
+    };
+  }
+  const final = assistants.at(-1);
+  if (!final)
+    return { status: "unknown", reason: "Claude history has no Assistant terminal" };
+  return {
+    status: "unknown",
+    reason: "Claude history does not include complete Result terminal evidence"
+  };
+}
+function itemOutcome(outcome) {
+  if (outcome.status === "failed")
+    return { status: "failed", error: outcome.error };
+  if (outcome.status === "cancelled") {
+    return {
+      status: "cancelled",
+      ...outcome.reason ? { reason: outcome.reason } : {}
+    };
+  }
+  return { status: "succeeded" };
+}
+function mapClaudeSnapshot(values, sessionId) {
+  const messages = conversationMessages(values, sessionId);
+  const turns = [];
+  for (let index = 0; index < messages.length; ) {
+    const user = messages[index];
+    if (!user || !isHumanUser(user)) {
+      index += 1;
+      continue;
+    }
+    let end = index + 1;
+    while (end < messages.length && !isHumanUser(messages[end]))
+      end += 1;
+    const turnMessages = messages.slice(index, end);
+    const outcome = turnOutcome(turnMessages);
+    const results = toolResultBlocks(turnMessages);
+    const checkpointMessage = turnMessages.findLast(({ type, interrupted }) => type === "assistant" || interrupted);
+    let agentMessageOrdinal = 0;
+    let reasoningOrdinal = 0;
+    let toolOrdinal = 0;
+    turns.push({
+      nativeTurnRef: nativeTurnRefSchema.parse({
+        harnessId: claudeCodeHarnessId,
+        nativeSessionId: sessionId,
+        nativeTurnKey: user.uuid,
+        formatVersion: 1
+      }),
+      ...checkpointMessage ? {
+        checkpoint: nativeCheckpointRefSchema.parse({
+          harnessId: claudeCodeHarnessId,
+          nativeSessionId: sessionId,
+          checkpointId: checkpointMessage.uuid,
+          formatVersion: 1
+        })
+      } : {},
+      input: visibleUserTextParts(user).map((text) => ({
+        type: "text",
+        text: displayedUserText(text)
+      })),
+      items: turnMessages.flatMap((message) => {
+        if (message.type === "user") {
+          const recapOutput = visibleUserTextParts(user).some((text2) => isNamedCommandEnvelope(text2, recapCommandNamePattern)) ? textParts(message.message.content).map(localCommandStdoutText).find((text2) => text2 !== null && text2.length > 0) : void 0;
+          if (!recapOutput)
+            return [];
+          return [
+            {
+              item: {
+                type: "agentMessage",
+                itemId: claudeTranscriptItemId(user.uuid, "agentMessage", agentMessageOrdinal += 1),
+                text: recapOutput
+              },
+              outcome: itemOutcome(outcome)
+            }
+          ];
+        }
+        if (message.type !== "assistant")
+          return [];
+        const content = message.message.content;
+        const text = textParts(content).join("");
+        const reasoning = thinkingParts(content).join("");
+        if (!Array.isArray(content)) {
+          return text.length > 0 ? [
+            {
+              item: {
+                type: "agentMessage",
+                itemId: claudeTranscriptItemId(user.uuid, "agentMessage", agentMessageOrdinal += 1),
+                text
+              },
+              outcome: itemOutcome(outcome)
+            }
+          ] : [];
+        }
+        const items = [];
+        let projectedReasoning = false;
+        let projectedText = false;
+        for (const [blockIndex, block] of content.entries()) {
+          if (!isRecord5(block))
+            continue;
+          if (block.type === "thinking" && !projectedReasoning && reasoning.length > 0) {
+            items.push({
+              item: {
+                type: "reasoning",
+                itemId: claudeTranscriptItemId(user.uuid, "reasoning", reasoningOrdinal += 1),
+                text: reasoning
+              },
+              outcome: itemOutcome(outcome)
+            });
+            projectedReasoning = true;
+            continue;
+          }
+          if (block.type === "text" && !projectedText && text.length > 0) {
+            items.push({
               item: {
                 type: "agentMessage",
                 itemId: claudeTranscriptItemId(user.uuid, "agentMessage", agentMessageOrdinal += 1),
@@ -43233,6 +44474,7 @@ function mapClaudeSnapshot(values, sessionId) {
           if (block.type !== "tool_use" || typeof block.id !== "string" || typeof block.name !== "string") {
             continue;
           }
+          const toolItem = !message.nested && !CLAUDE_SUBAGENT_TOOLS.has(block.name) ? toolOrdinal += 1 : null;
           const result = results.get(block.id);
           if (!result)
             continue;
@@ -43246,8 +44488,8 @@ function mapClaudeSnapshot(values, sessionId) {
               retryable: false
             }
           } : { status: "succeeded" };
-          const itemId = hostItemIdSchema.parse(`claude-item-v1-${message.uuid}-tool-${blockIndex}`);
-          if (block.name === "Bash" && isRecord3(block.input) && typeof block.input.command === "string") {
+          const itemId = toolItem !== null ? claudeTranscriptItemId(user.uuid, "tool", toolItem) : hostItemIdSchema.parse(`claude-item-v1-${message.uuid}-tool-${blockIndex}`);
+          if (block.name === "Bash" && isRecord5(block.input) && typeof block.input.command === "string") {
             items.push({
               item: {
                 type: "commandExecution",
@@ -43285,7 +44527,7 @@ function toolResultBlocks(messages) {
     if (message.type !== "user" || !Array.isArray(message.message.content))
       continue;
     for (const block of message.message.content) {
-      if (isRecord3(block) && block.type === "tool_result" && typeof block.tool_use_id === "string") {
+      if (isRecord5(block) && block.type === "tool_result" && typeof block.tool_use_id === "string") {
         results.set(block.tool_use_id, block);
       }
     }
@@ -43300,7 +44542,7 @@ function toolResultOutput(block) {
 }
 function resultSubagentId(value, block) {
   const nativeResult = value.tool_use_result;
-  if (isRecord3(nativeResult)) {
+  if (isRecord5(nativeResult)) {
     const structured = nativeResult.agentId ?? nativeResult.agent_id ?? nativeResult.task_id;
     if (typeof structured === "string" && structured.length > 0)
       return structured;
@@ -43308,16 +44550,16 @@ function resultSubagentId(value, block) {
   const match = /agentId:\s*([A-Za-z0-9_-]+)/u.exec(textParts(block.content).join(""));
   return match?.[1];
 }
-function subagentPrompt(values, nativeSubagentId2) {
+function subagentPrompt2(values, nativeSubagentId2) {
   const toolUses = /* @__PURE__ */ new Map();
   for (const value of values) {
-    if (!isRecord3(value) || !isRecord3(value.message) || !Array.isArray(value.message.content)) {
+    if (!isRecord5(value) || !isRecord5(value.message) || !Array.isArray(value.message.content)) {
       continue;
     }
     for (const block of value.message.content) {
-      if (!isRecord3(block))
+      if (!isRecord5(block))
         continue;
-      if (block.type === "tool_use" && typeof block.id === "string" && (block.name === "Agent" || block.name === "Task") && isRecord3(block.input) && typeof block.input.prompt === "string" && block.input.prompt.length > 0) {
+      if (block.type === "tool_use" && typeof block.id === "string" && (block.name === "Agent" || block.name === "Task") && isRecord5(block.input) && typeof block.input.prompt === "string" && block.input.prompt.length > 0) {
         toolUses.set(block.id, block.input.prompt);
         continue;
       }
@@ -43331,7 +44573,7 @@ function subagentPrompt(values, nativeSubagentId2) {
   return void 0;
 }
 function mapClaudeSubagentSnapshot(values, parentSessionId, nativeSubagentId2, parentValues = []) {
-  const messages = conversationMessages(values.map((value) => isRecord3(value) ? { ...value, session_id: parentSessionId } : value), parentSessionId);
+  const messages = conversationMessages(values.map((value) => isRecord5(value) ? { ...value, session_id: parentSessionId } : value), parentSessionId);
   const turns = [];
   for (let index = 0; index < messages.length; ) {
     const first = messages[index];
@@ -43358,7 +44600,7 @@ function mapClaudeSubagentSnapshot(values, parentSessionId, nativeSubagentId2, p
       const content = Array.isArray(message.message.content) ? message.message.content : [{ type: "text", text: message.message.content }];
       for (let blockIndex = 0; blockIndex < content.length; blockIndex += 1) {
         const block = content[blockIndex];
-        if (!isRecord3(block))
+        if (!isRecord5(block))
           continue;
         const itemId = hostItemIdSchema.parse(`claude-subagent-item-v2-${nativeSubagentId2}-${message.uuid}-${blockIndex}`);
         if (block.type === "thinking" && typeof block.thinking === "string") {
@@ -43395,7 +44637,7 @@ function mapClaudeSubagentSnapshot(values, parentSessionId, nativeSubagentId2, p
             retryable: false
           }
         } : { status: "succeeded" };
-        if (block.name === "Bash" && isRecord3(block.input) && typeof block.input.command === "string") {
+        if (block.name === "Bash" && isRecord5(block.input) && typeof block.input.command === "string") {
           items.push({
             item: {
               type: "commandExecution",
@@ -43437,7 +44679,7 @@ function mapClaudeSubagentSnapshot(values, parentSessionId, nativeSubagentId2, p
           formatVersion: 1
         })
       } : {},
-      input: user ? visibleUserTextParts(user).map((text) => ({ type: "text", text })) : turns.length === 0 ? [subagentPrompt(parentValues, nativeSubagentId2)].filter((text) => text !== void 0).map((text) => ({ type: "text", text })) : [],
+      input: user ? visibleUserTextParts(user).map((text) => ({ type: "text", text })) : turns.length === 0 ? [subagentPrompt2(parentValues, nativeSubagentId2)].filter((text) => text !== void 0).map((text) => ({ type: "text", text })) : [],
       items,
       outcome
     });
@@ -43525,7 +44767,7 @@ async function forkClaudeSession(input) {
       error: error51("protocolError", "Claude Code Session working directory is unavailable", false)
     };
   }
-  if (path7.resolve(sourceInfo.cwd) !== input.cwd) {
+  if (path10.resolve(sourceInfo.cwd) !== input.cwd) {
     return {
       ok: false,
       error: error51("unsupported", "Claude Code cannot Fork across working directories", false)
@@ -43626,13 +44868,13 @@ async function forkClaudeSession(input) {
 
 // dist/claude-transcript.js
 import os5 from "node:os";
-import path8 from "node:path";
-import { readFile as readFile3, readdir, stat as stat3 } from "node:fs/promises";
+import path11 from "node:path";
+import { readFile as readFile4, readdir, stat as stat3 } from "node:fs/promises";
 function projectDirectoryName(cwd) {
   return cwd.replace(/[^A-Za-z0-9]/gu, "-");
 }
 function configDirectory(environment) {
-  return environment.CLAUDE_CONFIG_DIR ? path8.resolve(environment.CLAUDE_CONFIG_DIR) : path8.join(os5.homedir(), ".claude");
+  return environment.CLAUDE_CONFIG_DIR ? path11.resolve(environment.CLAUDE_CONFIG_DIR) : path11.join(os5.homedir(), ".claude");
 }
 async function existingFile(file2) {
   try {
@@ -43642,9 +44884,9 @@ async function existingFile(file2) {
   }
 }
 async function findTranscript(input) {
-  const projectsDirectory = path8.join(configDirectory(input.environment), "projects");
+  const projectsDirectory = path11.join(configDirectory(input.environment), "projects");
   const name = `${input.sessionId}.jsonl`;
-  const expected = path8.join(projectsDirectory, projectDirectoryName(input.cwd), name);
+  const expected = path11.join(projectsDirectory, projectDirectoryName(input.cwd), name);
   if (await existingFile(expected))
     return expected;
   let projects;
@@ -43654,20 +44896,20 @@ async function findTranscript(input) {
     return null;
   }
   for (const project of projects) {
-    const candidate = path8.join(projectsDirectory, project, name);
+    const candidate = path11.join(projectsDirectory, project, name);
     if (await existingFile(candidate))
       return candidate;
   }
   return null;
 }
-function isRecord4(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function readClaudeTranscript(input) {
   const transcript = await findTranscript(input);
   if (!transcript)
     return null;
-  const contents = await readFile3(transcript, "utf8");
+  const contents = await readFile4(transcript, "utf8");
   const messages = [];
   for (const line of contents.split("\n")) {
     if (line.trim().length === 0)
@@ -43678,7 +44920,7 @@ async function readClaudeTranscript(input) {
     } catch {
       continue;
     }
-    if (!isRecord4(entry) || entry.type !== "user" && entry.type !== "assistant" || typeof entry.uuid !== "string" || !isRecord4(entry.message)) {
+    if (!isRecord6(entry) || entry.type !== "user" && entry.type !== "assistant" || typeof entry.uuid !== "string" || !isRecord6(entry.message)) {
       continue;
     }
     messages.push({ ...entry, session_id: input.sessionId });
@@ -43688,9 +44930,9 @@ async function readClaudeTranscript(input) {
 
 // dist/model-catalog.js
 import { Buffer as Buffer2 } from "node:buffer";
-import { readFile as readFile4 } from "node:fs/promises";
+import { readFile as readFile5 } from "node:fs/promises";
 import os6 from "node:os";
-import path9 from "node:path";
+import path12 from "node:path";
 
 // dist/thinking-options.js
 var option = (id, label) => ({
@@ -43769,1118 +45011,385 @@ function decodeClaudeModelRef(ref) {
   if (encodeClaudeModelRef(value).id !== parsed.id) {
     throw new Error("Claude Code Model Ref is not canonical");
   }
-  return value === "default" ? void 0 : value;
-}
-function resolveClaudeConfigDirectory(environment = process.env) {
-  return path9.resolve(environment.CLAUDE_CONFIG_DIR ?? path9.join(os6.homedir(), ".claude"));
-}
-function parseModelPickerOptions(value) {
-  if (!Array.isArray(value))
-    return [];
-  const options = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const entry of value) {
-    const parsed = modelPickerOptionSchema.safeParse(entry);
-    if (!parsed.success)
-      continue;
-    if (seen.has(parsed.data.model))
-      continue;
-    seen.add(parsed.data.model);
-    options.push({
-      model: parsed.data.model,
-      ...parsed.data.label ? { label: parsed.data.label } : {},
-      ...parsed.data.description ? { description: parsed.data.description } : {},
-      ...parsed.data.behavesAs ? { behavesAs: parsed.data.behavesAs } : {}
-    });
-  }
-  return options;
-}
-function parseClaudeModelPickerSettings(value) {
-  if (value === void 0 || value === null)
-    return void 0;
-  const parsed = modelPickerSettingsSchema.safeParse(value);
-  if (!parsed.success)
-    return void 0;
-  if (parsed.data.options === void 0 && parsed.data.replaceBuiltInOptions === void 0) {
-    return void 0;
-  }
-  const options = parseModelPickerOptions(parsed.data.options);
-  if (Array.isArray(parsed.data.options) && parsed.data.options.length > 0 && options.length === 0) {
-    return void 0;
-  }
-  return {
-    options,
-    replaceBuiltInOptions: parsed.data.replaceBuiltInOptions === true
-  };
-}
-async function readClaudeUserModelPicker(environment = process.env) {
-  const settingsPath = path9.join(resolveClaudeConfigDirectory(environment), "settings.json");
-  let raw;
-  try {
-    raw = await readFile4(settingsPath, "utf8");
-  } catch {
-    return void 0;
-  }
-  let document2;
-  try {
-    document2 = JSON.parse(raw);
-  } catch {
-    return void 0;
-  }
-  if (document2 === null || typeof document2 !== "object" || Array.isArray(document2)) {
-    return void 0;
-  }
-  return parseClaudeModelPickerSettings(document2.modelPicker);
-}
-function optionToModelInfo(option2) {
-  return {
-    value: option2.model,
-    displayName: option2.label ?? option2.model,
-    ...option2.description ? { description: option2.description } : {},
-    ...option2.behavesAs ? { resolvedModel: option2.behavesAs } : {}
-  };
-}
-function readModelValue(row) {
-  if (row === null || typeof row !== "object" || Array.isArray(row))
-    return void 0;
-  const value = row.value;
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
-}
-function mergeOptionOntoSdkRow(sdkRow, option2) {
-  const base = sdkRow !== null && typeof sdkRow === "object" && !Array.isArray(sdkRow) ? { ...sdkRow } : {};
-  const overlay = optionToModelInfo(option2);
-  return { ...base, ...overlay };
-}
-function mergeClaudeModelPickerOptions(sdkModels, modelPicker) {
-  if (!modelPicker)
-    return sdkModels;
-  const sdkRows = Array.isArray(sdkModels) ? [...sdkModels] : [];
-  const sdkByValue = /* @__PURE__ */ new Map();
-  for (const row of sdkRows) {
-    const value = readModelValue(row);
-    if (value && !sdkByValue.has(value))
-      sdkByValue.set(value, row);
-  }
-  if (modelPicker.replaceBuiltInOptions) {
-    const defaultSdk = sdkByValue.get("default");
-    const merged2 = [
-      defaultSdk !== void 0 ? defaultSdk : { value: "default", displayName: "Default" }
-    ];
-    const included2 = /* @__PURE__ */ new Set(["default"]);
-    for (const option2 of modelPicker.options) {
-      if (included2.has(option2.model)) {
-        if (option2.model === "default") {
-          merged2[0] = mergeOptionOntoSdkRow(merged2[0], option2);
-        }
-        continue;
-      }
-      merged2.push(mergeOptionOntoSdkRow(sdkByValue.get(option2.model), option2));
-      included2.add(option2.model);
-    }
-    return merged2;
-  }
-  const merged = [...sdkRows];
-  const included = new Set(sdkRows.flatMap((row) => {
-    const value = readModelValue(row);
-    return value ? [value] : [];
-  }));
-  for (const option2 of modelPicker.options) {
-    if (included.has(option2.model))
-      continue;
-    merged.push(mergeOptionOntoSdkRow(void 0, option2));
-    included.add(option2.model);
-  }
-  return merged;
-}
-function uniqueDisplayLabels(rows) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const group = groups.get(row.displayName) ?? [];
-    group.push(row);
-    groups.set(row.displayName, group);
-  }
-  const labels = /* @__PURE__ */ new Map();
-  for (const [displayName, group] of groups) {
-    const sorted = [...group].sort((left, right) => left.value.localeCompare(right.value));
-    for (const [index, row] of sorted.entries()) {
-      if (sorted.length === 1) {
-        labels.set(row.value, displayName);
-        continue;
-      }
-      const nativeSuffix = ` (${row.value})`;
-      const suffix = displayName.length + nativeSuffix.length <= HARNESS_MODEL_LABEL_MAX_LENGTH ? nativeSuffix : ` (alias ${index + 1})`;
-      labels.set(row.value, `${displayName.slice(0, HARNESS_MODEL_LABEL_MAX_LENGTH - suffix.length)}${suffix}`);
-    }
-  }
-  return labels;
-}
-function normalizeRows(value) {
-  if (!Array.isArray(value))
-    throw new Error("Claude Code Model catalog is not an array");
-  const byValue = /* @__PURE__ */ new Map();
-  for (const nativeRow of value) {
-    const row = modelInfoSchema.parse(nativeRow);
-    const existing = byValue.get(row.value);
-    if (existing && JSON.stringify(existing) !== JSON.stringify(row)) {
-      throw new Error("Claude Code Model catalog contains conflicting selectable values");
-    }
-    if (!existing)
-      byValue.set(row.value, row);
-  }
-  if (byValue.size === 0)
-    throw new Error("Claude Code Model catalog is empty");
-  if (!byValue.has("default")) {
-    byValue.set("default", { value: "default", displayName: "Default" });
-  }
-  return [...byValue.values()];
-}
-function normalizeClaudeModelCatalog(snapshot) {
-  if (!snapshot.canSelectModel)
-    throw new Error("Claude Code Model selection is unavailable");
-  const rows = normalizeRows(snapshot.models);
-  const labels = uniqueDisplayLabels(rows);
-  const models = rows.map((row) => {
-    return {
-      ref: encodeClaudeModelRef(row.value),
-      label: labels.get(row.value) ?? row.displayName,
-      ...row.resolvedModel ? { resolvedModelLabel: row.resolvedModel } : {},
-      supportedThinkingOptionIds: [...CLAUDE_THINKING_OPTION_IDS]
-    };
-  });
-  models.sort((left, right) => {
-    if (left.ref.id === CLAUDE_DEFAULT_MODEL_REF.id)
-      return -1;
-    if (right.ref.id === CLAUDE_DEFAULT_MODEL_REF.id)
-      return 1;
-    return left.label.localeCompare(right.label) || left.ref.id.localeCompare(right.ref.id);
-  });
-  const catalog = harnessModelCatalogSchema.parse({
-    models,
-    defaultModel: CLAUDE_DEFAULT_MODEL_REF,
-    thinkingOptions: [...CLAUDE_THINKING_OPTIONS],
-    defaultThinkingOptionId: CLAUDE_DEFAULT_THINKING_OPTION_ID
-  });
-  return { catalog, defaultModel: CLAUDE_DEFAULT_MODEL_REF };
-}
-
-// dist/permission-modes.js
-var nativePermissionModes = /* @__PURE__ */ new Set([
-  "plan",
-  "default",
-  "acceptEdits",
-  "auto",
-  "bypassPermissions"
-]);
-var CLAUDE_DEFAULT_PERMISSION_MODE_ID = harnessPermissionModeIdSchema.parse("default");
-var claudePermissionModes = [
-  {
-    id: "plan",
-    label: "Plan mode",
-    description: "Explore and prepare a plan; approval exits planning and resumes the previous permission mode."
-  },
-  {
-    id: "default",
-    label: "Default",
-    description: "Ask before edits and other protected actions."
-  },
-  {
-    id: "acceptEdits",
-    label: "Accept edits",
-    description: "Allow file edits and ask for other protected actions."
-  },
-  {
-    id: "auto",
-    label: "Auto mode",
-    description: "Let Claude classify permission requests."
-  },
-  {
-    id: "bypassPermissions",
-    label: "Bypass permissions",
-    description: "Skip Claude Code permission checks.",
-    dangerous: true
-  }
-];
-function createPermissionModeCatalog(includeAuto) {
-  return harnessPermissionModeCatalogSchema.parse({
-    modes: includeAuto ? claudePermissionModes : claudePermissionModes.filter(({ id }) => id !== "auto"),
-    defaultModeId: CLAUDE_DEFAULT_PERMISSION_MODE_ID
-  });
-}
-var CLAUDE_PERMISSION_MODE_CATALOG = createPermissionModeCatalog(true);
-var CLAUDE_PERMISSION_MODE_CATALOG_WITHOUT_AUTO = createPermissionModeCatalog(false);
-var autoModeModelInfoSchema = external_exports.object({ supportsAutoMode: external_exports.literal(true) });
-function claudePermissionModeCatalogForModels(models) {
-  const supportsAutoMode = Array.isArray(models) && models.some((model) => autoModeModelInfoSchema.safeParse(model).success);
-  return supportsAutoMode ? CLAUDE_PERMISSION_MODE_CATALOG : CLAUDE_PERMISSION_MODE_CATALOG_WITHOUT_AUTO;
-}
-function decodeClaudePermissionModeId(permissionModeId) {
-  const parsed = harnessPermissionModeIdSchema.parse(permissionModeId);
-  if (!nativePermissionModes.has(parsed)) {
-    throw new Error("Claude Code Permission Mode belongs to another Adapter");
-  }
-  return parsed;
-}
-function encodeClaudePermissionModeId(permissionMode) {
-  if (!nativePermissionModes.has(permissionMode)) {
-    throw new Error("Claude Code returned an unsupported Permission Mode");
-  }
-  return harnessPermissionModeIdSchema.parse(permissionMode);
-}
-function isClaudePermissionMode(value) {
-  return typeof value === "string" && nativePermissionModes.has(value);
-}
-
-// dist/sdk-transport.js
-import { spawn } from "node:child_process";
-
-// dist/slash-commands.js
-var DYNAMIC_ID_PREFIX = "claude.slash.";
-var CLAUDE_EXCLUDED_COMMANDS = [
-  "advisor",
-  "agents",
-  "design-consent",
-  "design-revoke",
-  "doctor",
-  "extra-usage",
-  "import",
-  "team-onboarding",
-  "ultrareview",
-  "usage-credits",
-  "workflow-launch-exec"
-];
-function parseClaudeSlashCommands(value) {
-  if (!Array.isArray(value))
-    return [];
-  return value.flatMap((entry) => {
-    if (typeof entry !== "object" || entry === null)
-      return [];
-    const record2 = entry;
-    const name = typeof record2.name === "string" ? record2.name.trim().replace(/^\//u, "") : "";
-    if (!name)
-      return [];
-    return [
-      {
-        name,
-        description: typeof record2.description === "string" ? record2.description : "",
-        argumentHint: typeof record2.argumentHint === "string" ? record2.argumentHint : ""
-      }
-    ];
-  });
-}
-function claudeLiveCommandCatalog(builtIns, snapshot) {
-  return mergeLiveHarnessCommands(builtIns, DYNAMIC_ID_PREFIX, snapshot?.commands.map((command) => ({
-    name: command.name,
-    description: command.description,
-    kind: snapshot.skillNames.has(command.name) ? "skill" : "command"
-  })) ?? null, { names: CLAUDE_EXCLUDED_COMMANDS });
-}
-function claudeDynamicCommandPrompt(catalog, commandId, argumentText) {
-  return liveHarnessCommandPrompt(catalog, DYNAMIC_ID_PREFIX, commandId, argumentText);
-}
-
-// dist/account-usage.js
-function projectClaudeAccountUsage(usage, account) {
-  if (!usage.rate_limits_available || !usage.rate_limits)
-    return null;
-  const limits = usage.rate_limits;
-  const windows = [];
-  const add = (product, periodType, value) => {
-    if (!value || typeof value.utilization !== "number" || !Number.isFinite(value.utilization) || value.utilization < 0 || value.utilization > 100)
-      return;
-    windows.push({
-      product,
-      periodType,
-      usagePercent: value.utilization,
-      ...value.resets_at && Number.isFinite(Date.parse(value.resets_at)) ? { resetsAt: value.resets_at } : {}
-    });
-  };
-  add("5-hour window", "five_hour", limits.five_hour);
-  add("7-day window", "seven_day", limits.seven_day);
-  add("OAuth apps · 7-day", "seven_day", limits.seven_day_oauth_apps);
-  add("Opus · 7-day", "seven_day", limits.seven_day_opus);
-  add("Sonnet · 7-day", "seven_day", limits.seven_day_sonnet);
-  for (const window2 of limits.model_scoped ?? [])
-    add(`${window2.display_name} · 7-day`, "seven_day", window2);
-  const [primary, ...others] = windows;
-  if (!primary)
-    return null;
-  const genericPrimary = primary.product === "5-hour window" || primary.product === "7-day window";
-  return {
-    ...account.email ? { email: account.email } : {},
-    ...usage.subscription_type ? { plan: usage.subscription_type } : {},
-    credits: {
-      usedPercent: primary.usagePercent,
-      periodType: primary.periodType,
-      ...!genericPrimary ? { label: primary.product } : {},
-      ...primary.resetsAt ? { resetsAt: primary.resetsAt } : {},
-      ...others.length ? {
-        productUsage: others.map(({ product, usagePercent, resetsAt }) => ({
-          product,
-          usagePercent,
-          ...resetsAt ? { resetsAt } : {}
-        }))
-      } : {}
-    }
-  };
-}
-
-// dist/file-change.js
-import path10 from "node:path";
-var hunkSchema = external_exports.object({
-  oldStart: external_exports.number().int().nonnegative(),
-  oldLines: external_exports.number().int().nonnegative(),
-  newStart: external_exports.number().int().nonnegative(),
-  newLines: external_exports.number().int().nonnegative(),
-  lines: external_exports.array(external_exports.string())
-}).strict();
-function isRecord5(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function validNativePath(value) {
-  return typeof value === "string" && value.trim().length > 0 && !value.includes("\0") && !value.includes("\n") && !value.includes("\r");
-}
-function countLines(lines, prefixes) {
-  return lines.filter((line) => line.length > 0 && prefixes.has(line[0])).length;
-}
-function validHunk(value) {
-  const parsed = hunkSchema.safeParse(value);
-  if (!parsed.success)
-    return null;
-  const hunk = parsed.data;
-  if (hunk.lines.some((line) => line.length === 0 || ![" ", "+", "-", "\\"].includes(line[0]))) {
-    return null;
-  }
-  if (countLines(hunk.lines, /* @__PURE__ */ new Set([" ", "-"])) !== hunk.oldLines)
-    return null;
-  if (countLines(hunk.lines, /* @__PURE__ */ new Set([" ", "+"])) !== hunk.newLines)
-    return null;
-  return hunk;
-}
-function parseClaudeNativeFileChange(toolName, value) {
-  if (toolName !== "Edit" && toolName !== "Write" || !isRecord5(value))
-    return null;
-  if (!validNativePath(value.filePath) || !Array.isArray(value.structuredPatch))
-    return null;
-  const hunks = value.structuredPatch.map(validHunk);
-  if (hunks.length === 0 || hunks.some((hunk) => hunk === null))
-    return null;
-  if (toolName === "Write" && value.type !== "create" && value.type !== "update")
-    return null;
-  return {
-    path: value.filePath,
-    kind: toolName === "Write" && value.type === "create" ? "add" : "update",
-    hunks
-  };
-}
-function displayPath(nativePath, cwd) {
-  const resolvedCwd = path10.resolve(cwd);
-  const resolvedPath = path10.isAbsolute(nativePath) ? path10.resolve(nativePath) : path10.resolve(cwd, nativePath);
-  const relative = path10.relative(resolvedCwd, resolvedPath);
-  const selected = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path10.sep}`) ? relative : resolvedPath;
-  const normalized = selected.replaceAll("\\", "/");
-  return validNativePath(normalized) && normalized !== "." ? normalized : null;
-}
-function projectClaudeFileChange(value, cwd) {
-  const normalizedPath = displayPath(value.path, cwd);
-  if (!normalizedPath)
-    return null;
-  const body = value.hunks.flatMap((hunk) => [
-    `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`,
-    ...hunk.lines
-  ]);
-  const absoluteDisplayPath = path10.posix.isAbsolute(normalizedPath);
-  const oldHeader = value.kind === "add" ? "/dev/null" : absoluteDisplayPath ? normalizedPath : `a/${normalizedPath}`;
-  const newHeader = absoluteDisplayPath ? normalizedPath : `b/${normalizedPath}`;
-  const unifiedDiff = [`--- ${oldHeader}`, `+++ ${newHeader}`, ...body, ""].join("\n");
-  return { path: normalizedPath, kind: value.kind, unifiedDiff };
-}
-
-// dist/native-message.js
-var ABORTED_TERMINALS = /* @__PURE__ */ new Set(["aborted_streaming", "aborted_tools"]);
-var AUTHENTICATION_ERRORS = /* @__PURE__ */ new Set(["authentication_failed", "oauth_org_not_allowed"]);
-var SUBAGENT_TOOLS = /* @__PURE__ */ new Set(["Agent", "Task", "SendMessage"]);
-var SUBAGENT_DESCRIPTION_LIMIT = 500;
-var SUBAGENT_SUMMARY_LIMIT = 2e3;
-function isRecord6(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function nativeUuid(message) {
-  return typeof message.uuid === "string" && message.uuid.length > 0 ? message.uuid : null;
-}
-function parentToolUseId(message) {
-  return typeof message.parent_tool_use_id === "string" && message.parent_tool_use_id.length > 0 ? message.parent_tool_use_id : null;
-}
-function assistantNativeMessageId(message) {
-  if (!isRecord6(message.message))
-    return null;
-  return typeof message.message.id === "string" && message.message.id.length > 0 ? message.message.id : null;
-}
-function assistantContent(message) {
-  if (message.type !== "assistant" || !isRecord6(message.message))
-    return null;
-  return Array.isArray(message.message.content) ? message.message.content : null;
-}
-function assistantText(message) {
-  const content = assistantContent(message);
-  if (!content)
-    return null;
-  return content.flatMap((block) => isRecord6(block) && block.type === "text" && typeof block.text === "string" ? [block.text] : []).join("");
-}
-function assistantError(message) {
-  return isRecord6(message) && message.type === "assistant" && typeof message.error === "string" ? message.error : null;
-}
-function boundedString(value, limit) {
-  if (typeof value !== "string")
-    return void 0;
-  const trimmed = value.trim();
-  if (trimmed.length === 0)
-    return void 0;
-  return trimmed.slice(0, limit);
-}
-function subagentDescription(argumentsValue, toolName) {
-  if (!isRecord6(argumentsValue))
-    return `${toolName} delegation`;
-  return boundedString(argumentsValue.description, SUBAGENT_DESCRIPTION_LIMIT) ?? boundedString(argumentsValue.summary, SUBAGENT_DESCRIPTION_LIMIT) ?? boundedString(argumentsValue.name, SUBAGENT_DESCRIPTION_LIMIT) ?? `${toolName} delegation`;
-}
-function subagentPrompt2(argumentsValue) {
-  if (!isRecord6(argumentsValue))
-    return void 0;
-  return boundedString(argumentsValue.prompt ?? argumentsValue.message, SUBAGENT_SUMMARY_LIMIT);
-}
-function subagentRole(argumentsValue) {
-  if (!isRecord6(argumentsValue))
-    return void 0;
-  return boundedString(argumentsValue.subagent_type ?? argumentsValue.agent_type, SUBAGENT_DESCRIPTION_LIMIT);
-}
-function subagentBackground(argumentsValue) {
-  return isRecord6(argumentsValue) && argumentsValue.run_in_background === true;
-}
-function targetedSubagentId(argumentsValue) {
-  if (!isRecord6(argumentsValue))
-    return void 0;
-  return boundedString(argumentsValue.to ?? argumentsValue.recipient ?? argumentsValue.agentId, SUBAGENT_DESCRIPTION_LIMIT);
-}
-function includesAuthenticationFailure(message, errors) {
-  if (errors.some((error52) => AUTHENTICATION_ERRORS.has(error52)))
-    return true;
-  const text = [message.result, ...Array.isArray(message.errors) ? message.errors : []].filter((value) => typeof value === "string").join(" ").toLowerCase();
-  return text.includes("not logged in") || text.includes("invalid api key") || text.includes("oauth");
-}
-function failure(kind) {
-  return { status: "failed", kind };
-}
-function safeNonNegativeInteger(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+  return value === "default" ? void 0 : value;
 }
-function finiteNonNegativeNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+function resolveClaudeConfigDirectory(environment = process.env) {
+  return path12.resolve(environment.CLAUDE_CONFIG_DIR ?? path12.join(os6.homedir(), ".claude"));
 }
-function parseResultModelUsage(value) {
-  if (!isRecord6(value))
-    return void 0;
-  const usage = [];
-  for (const entry of Object.values(value)) {
-    if (!isRecord6(entry) || !safeNonNegativeInteger(entry.inputTokens) || !safeNonNegativeInteger(entry.outputTokens)) {
-      return void 0;
-    }
-    usage.push({ inputTokens: entry.inputTokens, outputTokens: entry.outputTokens });
+function parseModelPickerOptions(value) {
+  if (!Array.isArray(value))
+    return [];
+  const options = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of value) {
+    const parsed = modelPickerOptionSchema.safeParse(entry);
+    if (!parsed.success)
+      continue;
+    if (seen.has(parsed.data.model))
+      continue;
+    seen.add(parsed.data.model);
+    options.push({
+      model: parsed.data.model,
+      ...parsed.data.label ? { label: parsed.data.label } : {},
+      ...parsed.data.description ? { description: parsed.data.description } : {},
+      ...parsed.data.behavesAs ? { behavesAs: parsed.data.behavesAs } : {}
+    });
   }
-  return usage;
+  return options;
 }
-function parseLastRequestUsage(value, attribution = {}) {
-  if (!isRecord6(value))
+function parseClaudeModelPickerSettings(value) {
+  if (value === void 0 || value === null)
     return void 0;
-  const inputTokens = value.input_tokens;
-  const outputTokens = value.output_tokens;
-  const cacheCreationInputTokens = value.cache_creation_input_tokens;
-  const cacheReadInputTokens = value.cache_read_input_tokens;
-  if (!safeNonNegativeInteger(inputTokens) || !safeNonNegativeInteger(outputTokens) || !safeNonNegativeInteger(cacheCreationInputTokens) || !safeNonNegativeInteger(cacheReadInputTokens)) {
+  const parsed = modelPickerSettingsSchema.safeParse(value);
+  if (!parsed.success)
+    return void 0;
+  if (parsed.data.options === void 0 && parsed.data.replaceBuiltInOptions === void 0) {
     return void 0;
   }
-  const requestId = boundedString(attribution.requestId, 500);
-  const model = boundedString(attribution.model, 500);
-  const provider = boundedString(attribution.provider, 100);
-  return {
-    ...requestId ? { requestId } : {},
-    ...model ? { model } : {},
-    ...provider ? { provider } : {},
-    inputTokens,
-    outputTokens,
-    cacheCreationInputTokens,
-    cacheReadInputTokens
-  };
-}
-function assistantRequestUsage(message, provider) {
-  if (!isRecord6(message.message))
+  const options = parseModelPickerOptions(parsed.data.options);
+  if (Array.isArray(parsed.data.options) && parsed.data.options.length > 0 && options.length === 0) {
     return void 0;
-  return parseLastRequestUsage(message.message.usage, {
-    requestId: message.message.id ?? message.request_id,
-    model: message.message.model,
-    provider: message.provider ?? message.message.provider ?? provider
-  });
-}
-function parseResultUsageEvent(message) {
-  const totalCostUsd = finiteNonNegativeNumber(message.total_cost_usd) ? message.total_cost_usd : void 0;
-  const modelUsage = parseResultModelUsage(message.modelUsage);
-  const lastRequestUsage = parseLastRequestUsage(message.usage);
-  if (totalCostUsd === void 0 && modelUsage === void 0 && lastRequestUsage === void 0) {
-    return null;
   }
   return {
-    type: "usage.result",
-    ...totalCostUsd !== void 0 ? { totalCostUsd } : {},
-    ...modelUsage !== void 0 ? { modelUsage } : {},
-    ...lastRequestUsage ? { lastRequestUsage } : {}
+    options,
+    replaceBuiltInOptions: parsed.data.replaceBuiltInOptions === true
   };
 }
-function parsePlanLimitWindow(value) {
-  if (!isRecord6(value))
+async function readClaudeUserModelPicker(environment = process.env) {
+  const settingsPath = path12.join(resolveClaudeConfigDirectory(environment), "settings.json");
+  let raw;
+  try {
+    raw = await readFile5(settingsPath, "utf8");
+  } catch {
     return void 0;
-  const utilization = value.utilization;
-  if (typeof utilization !== "number" || !Number.isFinite(utilization) || utilization < 0) {
+  }
+  let document2;
+  try {
+    document2 = JSON.parse(raw);
+  } catch {
     return void 0;
   }
-  const utilizationPercent = Math.min(100, Math.max(0, Math.round(utilization * 1e4) / 100));
-  const resetsAt = value.resetsAt;
-  const resetsAtUnix = safeNonNegativeInteger(resetsAt) ? resetsAt : void 0;
-  return { utilizationPercent, ...resetsAtUnix !== void 0 ? { resetsAtUnix } : {} };
-}
-function parseClaudePlanLimitEvent(message) {
-  if (!isRecord6(message) || message.type !== "rate_limit_event")
-    return null;
-  const info = message.rate_limit_info;
-  if (!isRecord6(info))
-    return null;
-  const windows = isRecord6(info.unifiedWindows) ? info.unifiedWindows : void 0;
-  let fiveHour = parsePlanLimitWindow(windows?.five_hour);
-  let sevenDay = parsePlanLimitWindow(windows?.seven_day);
-  if (!fiveHour && !sevenDay) {
-    const flatWindow = parsePlanLimitWindow(info);
-    if (flatWindow && info.rateLimitType === "five_hour")
-      fiveHour = flatWindow;
-    else if (flatWindow && info.rateLimitType === "seven_day")
-      sevenDay = flatWindow;
+  if (document2 === null || typeof document2 !== "object" || Array.isArray(document2)) {
+    return void 0;
   }
-  if (!fiveHour && !sevenDay)
-    return null;
+  return parseClaudeModelPickerSettings(document2.modelPicker);
+}
+function optionToModelInfo(option2) {
   return {
-    ...fiveHour ? { fiveHour } : {},
-    ...sevenDay ? { sevenDay } : {}
+    value: option2.model,
+    displayName: option2.label ?? option2.model,
+    ...option2.description ? { description: option2.description } : {},
+    ...option2.behavesAs ? { resolvedModel: option2.behavesAs } : {}
   };
 }
-function nativeSubagentId(nativeResult, outputText) {
-  if (isRecord6(nativeResult)) {
-    const structured = boundedString(nativeResult.agentId ?? nativeResult.agent_id ?? nativeResult.task_id, SUBAGENT_DESCRIPTION_LIMIT);
-    if (structured)
-      return structured;
-  }
-  return boundedString(/agentId:\s*([A-Za-z0-9_-]+)/u.exec(outputText ?? "")?.[1], SUBAGENT_DESCRIPTION_LIMIT);
-}
-function subagentContinuesInBackground(nativeResult, outputText) {
-  if (isRecord6(nativeResult)) {
-    if (nativeResult.isAsync === true || nativeResult.is_async === true)
-      return true;
-    if (nativeResult.status === "async_launched")
-      return true;
-  }
-  return outputText?.includes("The agent is working in the background.") ?? false;
-}
-function resultText(content, nativeResult) {
-  let text = "";
-  if (typeof content === "string") {
-    text = content;
-  } else if (Array.isArray(content)) {
-    text = content.flatMap((block) => isRecord6(block) && block.type === "text" && typeof block.text === "string" ? [block.text] : []).join("");
-  }
-  if (text.length > 0)
-    return text;
-  if (!isRecord6(nativeResult))
+function readModelValue(row) {
+  if (row === null || typeof row !== "object" || Array.isArray(row))
     return void 0;
-  const stdout = typeof nativeResult.stdout === "string" ? nativeResult.stdout : "";
-  const stderr = typeof nativeResult.stderr === "string" ? nativeResult.stderr : "";
-  const combined = stdout + stderr;
-  return combined.length > 0 ? combined : void 0;
-}
-function userMessageText(content) {
-  if (typeof content === "string")
-    return content;
-  if (!Array.isArray(content))
-    return null;
-  const text = content.flatMap((block) => isRecord6(block) && block.type === "text" && typeof block.text === "string" ? [block.text] : []).join("");
-  return text.length > 0 ? text : null;
-}
-function parseClaudeTaskNotification(message) {
-  if (!isRecord6(message) || message.type !== "user" || !isRecord6(message.message))
-    return null;
-  if (isRecord6(message.origin) && message.origin.kind !== "task-notification")
-    return null;
-  const content = userMessageText(message.message.content);
-  if (!content || !content.includes("<task-notification>"))
-    return null;
-  const taskId = content.match(/<task-id>([^<]+)<\/task-id>/u)?.[1]?.trim();
-  if (!taskId)
-    return null;
-  const xmlStatus = content.match(/<status>([^<]+)<\/status>/u)?.[1]?.trim();
-  const status = taskStatus(xmlStatus ?? "completed");
-  if (status !== "completed" && status !== "failed" && status !== "interrupted")
-    return null;
-  const summary = content.match(/<summary>([\s\S]*?)<\/summary>/u)?.[1]?.trim();
-  const callId = content.match(/<tool-use-id>([^<]+)<\/tool-use-id>/u)?.[1]?.trim();
-  return {
-    type: "subagent.settled",
-    nativeSubagentId: taskId,
-    status,
-    ...callId ? { callId } : {},
-    ...summary ? { resultSummary: summary.slice(0, SUBAGENT_SUMMARY_LIMIT) } : {}
-  };
+  const value = row.value;
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
 }
-function taskStatus(value) {
-  switch (value) {
-    case "pending":
-      return "pending";
-    case "running":
-      return "running";
-    case "completed":
-      return "completed";
-    case "failed":
-      return "failed";
-    case "killed":
-    case "stopped":
-      return "interrupted";
-    default:
-      return null;
-  }
+function mergeOptionOntoSdkRow(sdkRow, option2) {
+  const base = sdkRow !== null && typeof sdkRow === "object" && !Array.isArray(sdkRow) ? { ...sdkRow } : {};
+  const overlay = optionToModelInfo(option2);
+  return { ...base, ...overlay };
 }
-var ClaudeNativeTurnAccumulator = class {
-  #provider;
-  #activeRootStreamMessageId = null;
-  #assistantErrors = [];
-  #cancelRequested = false;
-  #compactionState = "idle";
-  #completed = false;
-  #completedToolIds = /* @__PURE__ */ new Set();
-  #messageOrdinal = 0;
-  #messages = /* @__PURE__ */ new Map();
-  #protocolConflict = false;
-  #textConflict = false;
-  #tools = /* @__PURE__ */ new Map();
-  constructor(options = {}) {
-    this.#provider = options.provider;
-  }
-  requestCancel() {
-    this.#cancelRequested = true;
-  }
-  consume(message) {
-    if (this.#completed || !isRecord6(message))
-      return { events: [] };
-    const events = [];
-    this.#consumeSegmentLevel(message, events);
-    this.#consumeTaskLifecycle(message, events);
-    const parentCallId = parentToolUseId(message);
-    const nested = parentCallId !== null;
-    if (parentCallId && this.#tools.get(parentCallId)?.subagent === true && (message.type === "assistant" || message.type === "user")) {
-      events.push({ type: "subagent.transcript.changed", callId: parentCallId });
-    }
-    if (!nested) {
-      this.#consumeCompaction(message, events);
-      this.#consumeLocalCommandOutput(message, events);
-    }
-    if (message.type === "stream_event" && isRecord6(message.event)) {
-      if (!nested)
-        this.#consumeStreamEvent(message, events);
-    } else if (message.type === "tool_progress") {
-      this.#consumeToolProgress(message, events);
-    }
-    if (!nested) {
-      const error52 = assistantError(message);
-      if (error52 !== null)
-        this.#assistantErrors.push(error52);
-    }
-    if (message.type === "assistant") {
-      if (!nested)
-        this.#consumeAssistantMessage(message, events);
-    } else if (message.type === "user") {
-      this.#consumeTaskNotification(message, events);
-      this.#consumeToolResults(message, events, nested);
-    }
-    if (message.type !== "result")
-      return { events };
-    const usageEvent = parseResultUsageEvent(message);
-    if (usageEvent)
-      events.push(usageEvent);
-    this.#completed = true;
-    const terminalReason = typeof message.terminal_reason === "string" ? message.terminal_reason : "missing";
-    const nativeSuccess = message.subtype === "success" && message.is_error === false && (terminalReason === "completed" || terminalReason === "missing") && this.#assistantErrors.length === 0;
-    if (nativeSuccess && this.#tools.size > 0)
-      this.#protocolConflict = true;
-    let terminal;
-    if (this.#protocolConflict) {
-      terminal = failure("protocol");
-    } else if (this.#textConflict) {
-      terminal = failure("textConflict");
-    } else if (includesAuthenticationFailure(message, this.#assistantErrors)) {
-      terminal = failure("authentication");
-    } else if (this.#cancelRequested && ABORTED_TERMINALS.has(terminalReason)) {
-      terminal = { status: "cancelled", reason: terminalReason };
-    } else if (this.#cancelRequested) {
-      terminal = failure("cancellationUnproven");
-    } else if (nativeSuccess) {
-      terminal = { status: "succeeded" };
-    } else {
-      terminal = failure("native");
-    }
-    return { events, terminal };
-  }
-  #consumeCompaction(message, events) {
-    if (message.type !== "system")
-      return;
-    if (message.subtype === "status") {
-      if (message.status === "compacting" && this.#compactionState !== "active") {
-        this.#compactionState = "active";
-        events.push({ type: "compaction.started" });
-      }
-      if (message.compact_result === "success" || message.compact_result === "failed") {
-        if (this.#compactionState === "settled")
-          return;
-        if (this.#compactionState === "idle")
-          events.push({ type: "compaction.started" });
-        this.#compactionState = "settled";
-        events.push({
-          type: "compaction.completed",
-          outcome: message.compact_result === "success" ? "succeeded" : "failed"
-        });
-      }
-      return;
-    }
-    if (message.subtype !== "compact_boundary" || this.#compactionState === "settled")
-      return;
-    if (this.#compactionState === "idle")
-      events.push({ type: "compaction.started" });
-    this.#compactionState = "settled";
-    events.push({ type: "compaction.completed", outcome: "succeeded" });
-  }
-  #consumeLocalCommandOutput(message, events) {
-    if (message.type !== "system" || message.subtype !== "local_command_output")
-      return;
-    if (typeof message.content !== "string" || message.content.length === 0)
-      return;
-    const checkpointId = nativeUuid(message);
-    const messageId = checkpointId ?? this.#nextMessageId();
-    const state = this.#messageState(messageId);
-    if (state.completed)
-      return;
-    state.text += message.content;
-    events.push({ type: "text.delta", messageId, delta: message.content });
-    state.completed = true;
-    events.push({
-      type: "message.completed",
-      messageId,
-      ...checkpointId ? { checkpointId } : {}
-    });
-  }
-  /**
-   * Claude opens one native Segment per Root execution and reports its live
-   * background tasks as a level whose membership replaces the previous set.
-   */
-  #consumeSegmentLevel(message, events) {
-    if (message.type !== "system")
-      return;
-    if (message.subtype === "init") {
-      events.push({ type: "segment.started" });
-      return;
-    }
-    if (message.subtype !== "background_tasks_changed" || !Array.isArray(message.tasks))
-      return;
-    const nativeSubagentIds = message.tasks.flatMap((task) => {
-      if (!isRecord6(task))
-        return [];
-      const taskId = boundedString(task.task_id, SUBAGENT_DESCRIPTION_LIMIT);
-      return taskId ? [taskId] : [];
-    });
-    events.push({ type: "subagents.live", nativeSubagentIds });
-  }
-  #consumeTaskLifecycle(message, events) {
-    if (message.type !== "system")
-      return;
-    if (message.subtype === "task_notification") {
-      const agentId = boundedString(message.task_id, SUBAGENT_DESCRIPTION_LIMIT);
-      const status = taskStatus(message.status);
-      if (!agentId || status !== "completed" && status !== "failed" && status !== "interrupted") {
-        return;
-      }
-      const resultSummary = boundedString(message.summary, SUBAGENT_SUMMARY_LIMIT);
-      const callId2 = boundedString(message.tool_use_id, SUBAGENT_DESCRIPTION_LIMIT);
-      events.push({
-        type: "subagent.settled",
-        nativeSubagentId: agentId,
-        status,
-        ...callId2 ? { callId: callId2 } : {},
-        ...resultSummary ? { resultSummary } : {}
-      });
-      return;
-    }
-    const callId = typeof message.tool_use_id === "string" ? message.tool_use_id : null;
-    if (!callId || !this.#tools.get(callId)?.subagent)
-      return;
-    if (message.subtype === "task_started") {
-      const description = boundedString(message.description, SUBAGENT_DESCRIPTION_LIMIT);
-      const role = boundedString(message.subagent_type, SUBAGENT_DESCRIPTION_LIMIT);
-      const agentId = boundedString(message.task_id, SUBAGENT_DESCRIPTION_LIMIT);
-      events.push({
-        type: "subagent.updated",
-        callId,
-        status: "running",
-        ...description ? { description } : {},
-        ...role ? { role } : {},
-        ...agentId ? { nativeSubagentId: agentId } : {}
-      });
-      return;
-    }
-    if (message.subtype === "task_progress") {
-      const description = boundedString(message.description, SUBAGENT_DESCRIPTION_LIMIT);
-      const role = boundedString(message.subagent_type, SUBAGENT_DESCRIPTION_LIMIT);
-      const resultSummary = boundedString(message.summary, SUBAGENT_SUMMARY_LIMIT);
-      const agentId = boundedString(message.task_id, SUBAGENT_DESCRIPTION_LIMIT);
-      events.push({
-        type: "subagent.updated",
-        callId,
-        status: "running",
-        ...description ? { description } : {},
-        ...role ? { role } : {},
-        ...agentId ? { nativeSubagentId: agentId } : {},
-        ...resultSummary ? { resultSummary } : {}
-      });
-      return;
-    }
-    if (message.subtype === "task_updated" && isRecord6(message.patch)) {
-      const status = taskStatus(message.patch.status);
-      if (!status)
-        return;
-      const description = boundedString(message.patch.description, SUBAGENT_DESCRIPTION_LIMIT);
-      const resultSummary = boundedString(message.patch.error, SUBAGENT_SUMMARY_LIMIT);
-      const agentId = boundedString(message.task_id, SUBAGENT_DESCRIPTION_LIMIT);
-      events.push({
-        type: "subagent.updated",
-        callId,
-        status,
-        ...description ? { description } : {},
-        ...agentId ? { nativeSubagentId: agentId } : {},
-        ...resultSummary ? { resultSummary } : {}
-      });
-    }
-  }
-  #consumeStreamEvent(message, events) {
-    const event = message.event;
-    if (!isRecord6(event))
-      return;
-    if (event.type === "message_start" && isRecord6(event.message) && typeof event.message.id === "string" && event.message.id.length > 0) {
-      this.#activeRootStreamMessageId = event.message.id;
-      this.#messageState(event.message.id);
-      return;
-    }
-    if (event.type !== "content_block_delta" || !isRecord6(event.delta))
-      return;
-    const messageId = this.#activeRootStreamMessageId ?? nativeUuid(message) ?? this.#nextMessageId();
-    if (!this.#activeRootStreamMessageId)
-      this.#activeRootStreamMessageId = messageId;
-    const state = this.#messageState(messageId);
-    if (state.completed) {
-      if (event.delta.type === "text_delta")
-        this.#textConflict = true;
-      return;
-    }
-    if (event.delta.type === "text_delta" && typeof event.delta.text === "string") {
-      if (event.delta.text.length === 0)
-        return;
-      state.text += event.delta.text;
-      events.push({ type: "text.delta", messageId, delta: event.delta.text });
-      return;
-    }
-    if (event.delta.type === "thinking_delta" && typeof event.delta.thinking === "string") {
-      if (event.delta.thinking.length === 0)
-        return;
-      state.reasoning += event.delta.thinking;
-      events.push({ type: "reasoning.delta", messageId, delta: event.delta.thinking });
-    }
-  }
-  #consumeAssistantMessage(message, events) {
-    const checkpointId = nativeUuid(message);
-    const nativeMessageId = assistantNativeMessageId(message);
-    const messageId = this.#activeRootStreamMessageId ?? nativeMessageId ?? checkpointId ?? this.#nextMessageId();
-    const state = this.#messageState(messageId);
-    if (state.completed) {
-      this.#consumeToolUseBlocks(message, events, true);
-      const usage = assistantRequestUsage(message, this.#provider);
-      if (usage && !state.usagePublished) {
-        state.usagePublished = true;
-        events.push({
-          type: "message.completed",
-          messageId,
-          ...checkpointId ? { checkpointId } : {},
-          lastRequestUsage: usage
-        });
-      }
-      return;
-    }
-    if (state.reasoning.length > 0) {
-      events.push({ type: "reasoning.completed", messageId });
-    }
-    const completeText = assistantText(message);
-    if (completeText !== null && completeText.length > 0) {
-      if (completeText.startsWith(state.text)) {
-        const suffix = completeText.slice(state.text.length);
-        if (suffix.length > 0) {
-          state.text += suffix;
-          events.push({ type: "text.delta", messageId, delta: suffix });
-        }
-      } else if (completeText !== state.text) {
-        this.#textConflict = true;
-      }
-    }
-    this.#consumeToolUseBlocks(message, events, false);
-    if (!this.#protocolConflict && !this.#textConflict) {
-      const usage = assistantRequestUsage(message, this.#provider);
-      state.usagePublished = usage !== void 0;
-      events.push({
-        type: "message.completed",
-        messageId,
-        ...checkpointId ? { checkpointId } : {},
-        ...usage ? { lastRequestUsage: usage } : {}
-      });
-    }
-    state.completed = true;
-    if (this.#activeRootStreamMessageId === messageId)
-      this.#activeRootStreamMessageId = null;
-  }
-  #consumeToolUseBlocks(message, events, ignoreKnownIds) {
-    for (const block of assistantContent(message) ?? []) {
-      if (!isRecord6(block) || block.type !== "tool_use")
-        continue;
-      const argumentsResult = jsonValueSchema.safeParse(block.input);
-      if (typeof block.id !== "string" || block.id.length === 0 || typeof block.name !== "string" || block.name.length === 0 || !argumentsResult.success) {
-        this.#protocolConflict = true;
-        continue;
-      }
-      if (this.#tools.has(block.id) || this.#completedToolIds.has(block.id)) {
-        if (!ignoreKnownIds)
-          this.#protocolConflict = true;
+function mergeClaudeModelPickerOptions(sdkModels, modelPicker) {
+  if (!modelPicker)
+    return sdkModels;
+  const sdkRows = Array.isArray(sdkModels) ? [...sdkModels] : [];
+  const sdkByValue = /* @__PURE__ */ new Map();
+  for (const row of sdkRows) {
+    const value = readModelValue(row);
+    if (value && !sdkByValue.has(value))
+      sdkByValue.set(value, row);
+  }
+  if (modelPicker.replaceBuiltInOptions) {
+    const defaultSdk = sdkByValue.get("default");
+    const merged2 = [
+      defaultSdk !== void 0 ? defaultSdk : { value: "default", displayName: "Default" }
+    ];
+    const included2 = /* @__PURE__ */ new Set(["default"]);
+    for (const option2 of modelPicker.options) {
+      if (included2.has(option2.model)) {
+        if (option2.model === "default") {
+          merged2[0] = mergeOptionOntoSdkRow(merged2[0], option2);
+        }
         continue;
       }
-      const subagent = SUBAGENT_TOOLS.has(block.name);
-      this.#tools.set(block.id, { name: block.name, subagent });
-      if (subagent) {
-        const prompt = subagentPrompt2(argumentsResult.data);
-        const role = subagentRole(argumentsResult.data);
-        const agentId = targetedSubagentId(argumentsResult.data);
-        events.push({
-          type: "subagent.started",
-          callId: block.id,
-          operation: block.name === "SendMessage" ? "send" : "spawn",
-          description: subagentDescription(argumentsResult.data, block.name),
-          ...prompt ? { prompt } : {},
-          ...role ? { role } : {},
-          background: block.name === "SendMessage" || subagentBackground(argumentsResult.data),
-          ...agentId ? { nativeSubagentId: agentId } : {}
-        });
-      } else {
-        events.push({
-          type: "tool.started",
-          callId: block.id,
-          toolName: block.name,
-          arguments: argumentsResult.data
-        });
-      }
+      merged2.push(mergeOptionOntoSdkRow(sdkByValue.get(option2.model), option2));
+      included2.add(option2.model);
     }
+    return merged2;
   }
-  #consumeToolProgress(message, events) {
-    const callId = message.tool_use_id;
-    const elapsedSeconds = message.elapsed_time_seconds;
-    if (typeof callId !== "string" || this.#tools.get(callId)?.subagent !== false || typeof elapsedSeconds !== "number" || !Number.isFinite(elapsedSeconds) || elapsedSeconds < 0) {
-      return;
-    }
-    events.push({ type: "tool.progress", callId, elapsedMs: Math.round(elapsedSeconds * 1e3) });
+  const merged = [...sdkRows];
+  const included = new Set(sdkRows.flatMap((row) => {
+    const value = readModelValue(row);
+    return value ? [value] : [];
+  }));
+  for (const option2 of modelPicker.options) {
+    if (included.has(option2.model))
+      continue;
+    merged.push(mergeOptionOntoSdkRow(void 0, option2));
+    included.add(option2.model);
   }
-  #consumeTaskNotification(message, events) {
-    const settled = parseClaudeTaskNotification(message);
-    if (settled)
-      events.push(settled);
+  return merged;
+}
+function uniqueDisplayLabels(rows) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const group = groups.get(row.displayName) ?? [];
+    group.push(row);
+    groups.set(row.displayName, group);
   }
-  #consumeToolResults(message, events, ignoreUnknown) {
-    if (!isRecord6(message.message) || !Array.isArray(message.message.content))
-      return;
-    const resultBlocks = message.message.content.filter((block) => isRecord6(block) && block.type === "tool_result");
-    if (resultBlocks.length === 0)
-      return;
-    if (resultBlocks.length > 1 && message.tool_use_result !== void 0) {
-      this.#protocolConflict = true;
-    }
-    for (const block of resultBlocks) {
-      const callId = block.tool_use_id;
-      if (typeof callId !== "string" || callId.length === 0) {
-        this.#protocolConflict = true;
-        continue;
-      }
-      const tool = this.#tools.get(callId);
-      if (!tool || this.#completedToolIds.has(callId)) {
-        if (!ignoreUnknown)
-          this.#protocolConflict = true;
-        continue;
-      }
-      if (block.is_error !== void 0 && typeof block.is_error !== "boolean") {
-        this.#protocolConflict = true;
-        continue;
-      }
-      this.#tools.delete(callId);
-      this.#completedToolIds.add(callId);
-      const isError = block.is_error === true;
-      const nativeResult = resultBlocks.length === 1 ? message.tool_use_result ?? message.toolUseResult : void 0;
-      const outputText = resultText(block.content, nativeResult);
-      const structuredResult = tool.name === "TaskCreate" || tool.name === "TaskUpdate" || tool.name === "TaskList" ? jsonValueSchema.safeParse(nativeResult) : null;
-      if (tool.subagent) {
-        const resultSummary = boundedString(outputText, SUBAGENT_SUMMARY_LIMIT);
-        const agentId = nativeSubagentId(nativeResult, outputText);
-        events.push({
-          type: "subagent.completed",
-          callId,
-          isError,
-          ...subagentContinuesInBackground(nativeResult, outputText) ? { continuesInBackground: true } : {},
-          ...agentId ? { nativeSubagentId: agentId } : {},
-          ...resultSummary ? { resultSummary } : {}
-        });
+  const labels = /* @__PURE__ */ new Map();
+  for (const [displayName, group] of groups) {
+    const sorted = [...group].sort((left, right) => left.value.localeCompare(right.value));
+    for (const [index, row] of sorted.entries()) {
+      if (sorted.length === 1) {
+        labels.set(row.value, displayName);
         continue;
       }
-      const fileChange = isError ? null : parseClaudeNativeFileChange(tool.name, nativeResult);
-      events.push({
-        type: "tool.completed",
-        callId,
-        toolName: tool.name,
-        ...outputText ? { outputText } : {},
-        ...structuredResult?.success ? { structuredResult: structuredResult.data } : {},
-        isError,
-        ...fileChange ? { fileChange } : {}
-      });
+      const nativeSuffix = ` (${row.value})`;
+      const suffix = displayName.length + nativeSuffix.length <= HARNESS_MODEL_LABEL_MAX_LENGTH ? nativeSuffix : ` (alias ${index + 1})`;
+      labels.set(row.value, `${displayName.slice(0, HARNESS_MODEL_LABEL_MAX_LENGTH - suffix.length)}${suffix}`);
     }
   }
-  #messageState(messageId) {
-    const existing = this.#messages.get(messageId);
-    if (existing)
-      return existing;
-    const created = { completed: false, reasoning: "", text: "", usagePublished: false };
-    this.#messages.set(messageId, created);
-    return created;
+  return labels;
+}
+function normalizeRows(value) {
+  if (!Array.isArray(value))
+    throw new Error("Claude Code Model catalog is not an array");
+  const byValue = /* @__PURE__ */ new Map();
+  for (const nativeRow of value) {
+    const row = modelInfoSchema.parse(nativeRow);
+    const existing = byValue.get(row.value);
+    if (existing && JSON.stringify(existing) !== JSON.stringify(row)) {
+      throw new Error("Claude Code Model catalog contains conflicting selectable values");
+    }
+    if (!existing)
+      byValue.set(row.value, row);
   }
-  #nextMessageId() {
-    this.#messageOrdinal += 1;
-    return `claude-assistant-${this.#messageOrdinal}`;
+  if (byValue.size === 0)
+    throw new Error("Claude Code Model catalog is empty");
+  if (!byValue.has("default")) {
+    byValue.set("default", { value: "default", displayName: "Default" });
+  }
+  return [...byValue.values()];
+}
+function normalizeClaudeModelCatalog(snapshot) {
+  if (!snapshot.canSelectModel)
+    throw new Error("Claude Code Model selection is unavailable");
+  const rows = normalizeRows(snapshot.models);
+  const labels = uniqueDisplayLabels(rows);
+  const models = rows.map((row) => {
+    return {
+      ref: encodeClaudeModelRef(row.value),
+      label: labels.get(row.value) ?? row.displayName,
+      ...row.resolvedModel ? { resolvedModelLabel: row.resolvedModel } : {},
+      supportedThinkingOptionIds: [...CLAUDE_THINKING_OPTION_IDS]
+    };
+  });
+  models.sort((left, right) => {
+    if (left.ref.id === CLAUDE_DEFAULT_MODEL_REF.id)
+      return -1;
+    if (right.ref.id === CLAUDE_DEFAULT_MODEL_REF.id)
+      return 1;
+    return left.label.localeCompare(right.label) || left.ref.id.localeCompare(right.ref.id);
+  });
+  const catalog = harnessModelCatalogSchema.parse({
+    models,
+    defaultModel: CLAUDE_DEFAULT_MODEL_REF,
+    thinkingOptions: [...CLAUDE_THINKING_OPTIONS],
+    defaultThinkingOptionId: CLAUDE_DEFAULT_THINKING_OPTION_ID
+  });
+  return { catalog, defaultModel: CLAUDE_DEFAULT_MODEL_REF };
+}
+
+// dist/permission-modes.js
+var nativePermissionModes = /* @__PURE__ */ new Set([
+  "plan",
+  "default",
+  "acceptEdits",
+  "auto",
+  "bypassPermissions"
+]);
+var CLAUDE_DEFAULT_PERMISSION_MODE_ID = harnessPermissionModeIdSchema.parse("default");
+var claudePermissionModes = [
+  {
+    id: "plan",
+    label: "Plan mode",
+    description: "Explore and prepare a plan; approval exits planning and resumes the previous permission mode."
+  },
+  {
+    id: "default",
+    label: "Default",
+    description: "Ask before edits and other protected actions."
+  },
+  {
+    id: "acceptEdits",
+    label: "Accept edits",
+    description: "Allow file edits and ask for other protected actions."
+  },
+  {
+    id: "auto",
+    label: "Auto mode",
+    description: "Let Claude classify permission requests."
+  },
+  {
+    id: "bypassPermissions",
+    label: "Bypass permissions",
+    description: "Skip Claude Code permission checks.",
+    dangerous: true
   }
+];
+function createPermissionModeCatalog(includeAuto, includeBypassPermissions) {
+  return harnessPermissionModeCatalogSchema.parse({
+    modes: claudePermissionModes.filter(({ id }) => (includeAuto || id !== "auto") && (includeBypassPermissions || id !== "bypassPermissions")),
+    defaultModeId: CLAUDE_DEFAULT_PERMISSION_MODE_ID
+  });
+}
+var CLAUDE_PERMISSION_MODE_CATALOG = createPermissionModeCatalog(true, true);
+var CLAUDE_PERMISSION_MODE_CATALOGS = {
+  auto: CLAUDE_PERMISSION_MODE_CATALOG,
+  autoWithoutBypass: createPermissionModeCatalog(true, false),
+  withoutAuto: createPermissionModeCatalog(false, true),
+  withoutAutoOrBypass: createPermissionModeCatalog(false, false)
 };
+var autoModeModelInfoSchema = external_exports.object({ supportsAutoMode: external_exports.literal(true) });
+function claudePermissionModeCatalogForModels(models, bypassPermissionsAvailable = true) {
+  const supportsAutoMode = Array.isArray(models) && models.some((model) => autoModeModelInfoSchema.safeParse(model).success);
+  if (supportsAutoMode) {
+    return bypassPermissionsAvailable ? CLAUDE_PERMISSION_MODE_CATALOGS.auto : CLAUDE_PERMISSION_MODE_CATALOGS.autoWithoutBypass;
+  }
+  return bypassPermissionsAvailable ? CLAUDE_PERMISSION_MODE_CATALOGS.withoutAuto : CLAUDE_PERMISSION_MODE_CATALOGS.withoutAutoOrBypass;
+}
+function claudeBypassPermissionsAvailable(environment, platform = process) {
+  const uid = platform.getuid?.();
+  if (uid === void 0 || uid !== 0)
+    return true;
+  return environment.IS_SANDBOX === "1" || isNativeTruthyFlag(environment.CLAUDE_CODE_BUBBLEWRAP);
+}
+function isNativeTruthyFlag(value) {
+  return ["1", "true", "yes", "on"].includes(value?.trim().toLowerCase() ?? "");
+}
+var CLAUDE_BYPASS_PERMISSIONS_UNAVAILABLE_MESSAGE = "Bypass permissions is unavailable because Claude Code runs as root without a declared sandbox; set IS_SANDBOX=1 for the codexhost Host and restart it";
+function decodeClaudePermissionModeId(permissionModeId) {
+  const parsed = harnessPermissionModeIdSchema.parse(permissionModeId);
+  if (!nativePermissionModes.has(parsed)) {
+    throw new Error("Claude Code Permission Mode belongs to another Adapter");
+  }
+  return parsed;
+}
+function encodeClaudePermissionModeId(permissionMode) {
+  if (!nativePermissionModes.has(permissionMode)) {
+    throw new Error("Claude Code returned an unsupported Permission Mode");
+  }
+  return harnessPermissionModeIdSchema.parse(permissionMode);
+}
+function isClaudePermissionMode(value) {
+  return typeof value === "string" && nativePermissionModes.has(value);
+}
+
+// dist/sdk-transport.js
+import { spawn } from "node:child_process";
+
+// dist/slash-commands.js
+var DYNAMIC_ID_PREFIX = "claude.slash.";
+var CLAUDE_EXCLUDED_COMMANDS = [
+  "advisor",
+  "agents",
+  "design-consent",
+  "design-revoke",
+  "doctor",
+  "extra-usage",
+  "import",
+  "team-onboarding",
+  "ultrareview",
+  "usage-credits",
+  "workflow-launch-exec"
+];
+function parseClaudeSlashCommands(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((entry) => {
+    if (typeof entry !== "object" || entry === null)
+      return [];
+    const record2 = entry;
+    const name = typeof record2.name === "string" ? record2.name.trim().replace(/^\//u, "") : "";
+    if (!name)
+      return [];
+    return [
+      {
+        name,
+        description: typeof record2.description === "string" ? record2.description : "",
+        argumentHint: typeof record2.argumentHint === "string" ? record2.argumentHint : ""
+      }
+    ];
+  });
+}
+function claudeLiveCommandCatalog(builtIns, snapshot) {
+  return mergeLiveHarnessCommands(builtIns, DYNAMIC_ID_PREFIX, snapshot?.commands.map((command) => ({
+    name: command.name,
+    description: command.description,
+    kind: snapshot.skillNames.has(command.name) ? "skill" : "command"
+  })) ?? null, { names: CLAUDE_EXCLUDED_COMMANDS });
+}
+function claudeDynamicCommandPrompt(catalog, commandId, argumentText) {
+  return liveHarnessCommandPrompt(catalog, DYNAMIC_ID_PREFIX, commandId, argumentText);
+}
+
+// dist/account-usage.js
+function projectClaudeAccountUsage(usage, account) {
+  if (!usage.rate_limits_available || !usage.rate_limits)
+    return null;
+  const limits = usage.rate_limits;
+  const windows = [];
+  const add = (product, periodType, value) => {
+    if (!value || typeof value.utilization !== "number" || !Number.isFinite(value.utilization) || value.utilization < 0 || value.utilization > 100)
+      return;
+    windows.push({
+      product,
+      periodType,
+      usagePercent: value.utilization,
+      ...value.resets_at && Number.isFinite(Date.parse(value.resets_at)) ? { resetsAt: value.resets_at } : {}
+    });
+  };
+  add("5-hour window", "five_hour", limits.five_hour);
+  add("7-day window", "seven_day", limits.seven_day);
+  add("OAuth apps · 7-day", "seven_day", limits.seven_day_oauth_apps);
+  add("Opus · 7-day", "seven_day", limits.seven_day_opus);
+  add("Sonnet · 7-day", "seven_day", limits.seven_day_sonnet);
+  for (const window2 of limits.model_scoped ?? [])
+    add(`${window2.display_name} · 7-day`, "seven_day", window2);
+  const [primary, ...others] = windows;
+  if (!primary)
+    return null;
+  const genericPrimary = primary.product === "5-hour window" || primary.product === "7-day window";
+  return {
+    ...account.email ? { email: account.email } : {},
+    ...usage.subscription_type ? { plan: usage.subscription_type } : {},
+    credits: {
+      usedPercent: primary.usagePercent,
+      periodType: primary.periodType,
+      ...!genericPrimary ? { label: primary.product } : {},
+      ...primary.resetsAt ? { resetsAt: primary.resetsAt } : {},
+      ...others.length ? {
+        productUsage: others.map(({ product, usagePercent, resetsAt }) => ({
+          product,
+          usagePercent,
+          ...resetsAt ? { resetsAt } : {}
+        }))
+      } : {}
+    }
+  };
+}
 
 // dist/process-fence.js
-import { execFile } from "node:child_process";
-import path11 from "node:path";
+import { execFile as execFile2 } from "node:child_process";
+import path13 from "node:path";
 import { setTimeout as setTimeout2 } from "node:timers/promises";
 import { promisify } from "node:util";
-var executeFile = promisify(execFile);
+var executeFile = promisify(execFile2);
 function signalGroup(pid, signal) {
   try {
     process.kill(-pid, signal);
@@ -44901,9 +45410,9 @@ async function closeClaudeProcessGroup(child, timeoutMs) {
     if (child.exitCode !== null || child.signalCode !== null)
       throw new Error("Claude process tree cannot be confirmed after its Windows root exited");
     const root = process.env.SystemRoot ?? process.env.SYSTEMROOT;
-    if (!root || !path11.win32.isAbsolute(root))
+    if (!root || !path13.win32.isAbsolute(root))
       throw new Error("Windows SystemRoot is unavailable");
-    await executeFile(path11.win32.join(root, "System32", "taskkill.exe"), ["/PID", String(pid), "/T", "/F"], {
+    await executeFile(path13.win32.join(root, "System32", "taskkill.exe"), ["/PID", String(pid), "/T", "/F"], {
       timeout: timeoutMs,
       windowsHide: true
     });
@@ -44984,9 +45493,6 @@ function rejectAfter(milliseconds, message) {
     }
   };
 }
-function allowsDangerouslySkipPermissions(getuid = process.getuid) {
-  return getuid === void 0 || getuid() !== 0;
-}
 function processExited(child) {
   return child.exitCode !== null || child.signalCode !== null;
 }
@@ -45124,6 +45630,9 @@ function canDeliverSettlementImmediately(event, pendingEvents) {
   if (event.type !== "subagent.settled")
     return false;
   return !pendingEvents.some((pending) => {
+    if (pending.type === "tool.completed") {
+      return event.callId !== void 0 && pending.callId === event.callId;
+    }
     if (pending.type !== "subagent.started" && pending.type !== "subagent.updated" && pending.type !== "subagent.completed") {
       return false;
     }
@@ -45145,6 +45654,7 @@ var ClaudeSdkTransport = class {
   #onPlanLimit;
   #openMode;
   #permissionMode;
+  #allowDangerouslySkipPermissions;
   #queryFactory;
   #thinkingOptionId;
   #active = null;
@@ -45177,6 +45687,7 @@ var ClaudeSdkTransport = class {
     this.#onPlanLimit = options.onPlanLimit;
     this.#openMode = options.openMode;
     this.#permissionMode = options.permissionMode;
+    this.#allowDangerouslySkipPermissions = options.allowDangerouslySkipPermissions ?? false;
     this.#queryFactory = options.queryFactory ?? Okt;
     this.#thinkingOptionId = parseClaudeThinkingOptionId(options.thinkingOptionId);
   }
@@ -45219,7 +45730,7 @@ var ClaudeSdkTransport = class {
         pathToClaudeCodeExecutable: executable,
         settingSources: ["user"],
         permissionMode: this.#permissionMode,
-        ...allowsDangerouslySkipPermissions() ? { allowDangerouslySkipPermissions: true } : {},
+        ...this.#allowDangerouslySkipPermissions ? { allowDangerouslySkipPermissions: true } : {},
         canUseTool: (toolName, input, options) => this.#canUseTool(toolName, input, options),
         persistSession: true,
         includePartialMessages: true,
@@ -45381,12 +45892,18 @@ var ClaudeSdkTransport = class {
     if (!active || !activeQuery)
       throw new Error("Claude SDK transport has no active Turn");
     active.accumulator.requestCancel();
-    const timeout = rejectAfter(this.#abortTimeoutMs, INTERRUPT_TIMEOUT_MESSAGE);
     try {
-      await Promise.race([activeQuery.interrupt(), timeout.promise]);
+      await this.#stopRequest(activeQuery.interrupt(), INTERRUPT_TIMEOUT_MESSAGE);
     } catch (error52) {
       await this.close();
       throw error52 instanceof Error ? error52 : new Error(INTERRUPT_TIMEOUT_MESSAGE);
+    }
+  }
+  /** A user stop must answer: native stop requests share the abort timeout. */
+  async #stopRequest(request, timeoutMessage) {
+    const timeout = rejectAfter(this.#abortTimeoutMs, timeoutMessage);
+    try {
+      await Promise.race([request, timeout.promise]);
     } finally {
       timeout.cancel();
     }
@@ -45518,6 +46035,15 @@ var ClaudeSdkTransport = class {
     if (failures.length > 0)
       throw new AggregateError(failures, "Claude SDK shutdown could not be confirmed");
   }
+  hasBackgroundTasks() {
+    return this.#backgroundTasks.size > 0;
+  }
+  /** The native `task_notification` that follows reports the stopped task. */
+  async stopBackgroundTask(taskId) {
+    if (!this.#query)
+      throw new Error("Claude SDK transport is not running");
+    await this.#stopRequest(this.#query.stopTask(taskId), "Claude background task stop timed out");
+  }
   async #stopBackgroundTasks() {
     const requested = /* @__PURE__ */ new Set();
     const deadline = Date.now() + this.#closeTimeoutMs;
@@ -46029,6 +46555,146 @@ var ClaudeTaskTracker = class {
   }
 };
 
+// dist/background-command-items.js
+import { open as open2 } from "node:fs/promises";
+import { StringDecoder } from "node:string_decoder";
+var POLL_INTERVAL_MS = 1e3;
+var READ_CHUNK_BYTES = 64 * 1024;
+var UNAVAILABLE_OUTPUT = "Native output is unavailable.";
+function notificationOutcome(status) {
+  if (status === "completed")
+    return { status: "succeeded" };
+  if (status === "failed") {
+    return {
+      status: "failed",
+      error: {
+        code: "nativeFailure",
+        message: "Claude Code background command failed",
+        retryable: false
+      }
+    };
+  }
+  return { status: "cancelled", reason: "Background command stopped" };
+}
+var ClaudeBackgroundCommandItems = class {
+  /** Keyed by the Bash `tool_use` id. */
+  #commands = /* @__PURE__ */ new Map();
+  #emit;
+  #outputLimit;
+  constructor(options) {
+    this.#emit = options.emit;
+    this.#outputLimit = options.outputLimit;
+  }
+  taskIds() {
+    return [...this.#commands.values()].map(({ command }) => command.taskId);
+  }
+  follow(command) {
+    const followed = {
+      command,
+      outputFile: command.outputFile,
+      offset: 0,
+      decoder: new StringDecoder("utf8"),
+      output: "",
+      opened: false,
+      truncated: false,
+      timer: null,
+      reading: Promise.resolve(),
+      completed: false
+    };
+    this.#commands.set(command.callId, followed);
+    if (followed.outputFile) {
+      followed.timer = setInterval(() => void this.#poll(followed), POLL_INTERVAL_MS);
+      followed.timer.unref();
+    }
+  }
+  /** Returns whether the notification settles a followed command. */
+  settle(notification) {
+    const followed = notification.callId ? this.#commands.get(notification.callId) : void 0;
+    if (!followed)
+      return false;
+    this.#commands.delete(followed.command.callId);
+    if (followed.timer)
+      clearInterval(followed.timer);
+    followed.outputFile ??= notification.outputFile;
+    void this.#poll(followed).then(() => this.#complete(followed, notificationOutcome(notification.status)));
+    return true;
+  }
+  /** The native process is gone; no notification can arrive any more. */
+  abandonAll(reason) {
+    for (const followed of this.#commands.values()) {
+      if (followed.timer)
+        clearInterval(followed.timer);
+      this.#complete(followed, { status: "cancelled", reason });
+    }
+    this.#commands.clear();
+  }
+  #poll(followed) {
+    followed.reading = followed.reading.then(() => this.#read(followed));
+    return followed.reading;
+  }
+  async #read(followed) {
+    if (!followed.outputFile || followed.truncated)
+      return;
+    let handle;
+    try {
+      handle = await open2(followed.outputFile, "r");
+    } catch {
+      return;
+    }
+    followed.opened = true;
+    try {
+      const buffer = Buffer.alloc(READ_CHUNK_BYTES);
+      for (; ; ) {
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, followed.offset);
+        if (bytesRead === 0)
+          return;
+        followed.offset += bytesRead;
+        this.#append(followed, followed.decoder.write(buffer.subarray(0, bytesRead)));
+        if (followed.truncated)
+          return;
+      }
+    } catch {
+      return;
+    } finally {
+      await handle.close().catch(() => void 0);
+    }
+  }
+  #append(followed, text) {
+    if (text.length === 0 || followed.completed)
+      return;
+    const room = this.#outputLimit - followed.output.length;
+    const accepted = text.length > room ? text.slice(0, Math.max(0, room)) : text;
+    if (text.length > room)
+      followed.truncated = true;
+    if (accepted.length === 0)
+      return;
+    followed.output += accepted;
+    this.#emit({
+      type: "item.updated",
+      turnId: followed.command.turnId,
+      itemId: followed.command.item.itemId,
+      update: { type: "output.append", text: accepted }
+    });
+  }
+  #complete(followed, outcome) {
+    const { command } = followed;
+    followed.completed = true;
+    const output = followed.output.length > 0 ? followed.output : followed.opened ? void 0 : UNAVAILABLE_OUTPUT;
+    this.#emit({
+      type: "item.completed",
+      turnId: command.turnId,
+      snapshot: {
+        item: {
+          ...command.item,
+          ...output !== void 0 ? { output, outputTruncated: followed.truncated } : {},
+          durationMs: Math.max(0, Date.now() - command.startedAtMs)
+        },
+        outcome
+      }
+    });
+  }
+};
+
 // dist/tool-lifecycle.js
 function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -46059,15 +46725,20 @@ var ClaudeToolLifecycle = class {
   #cwd;
   #emit;
   #newItemId;
+  #onDetached;
   #outputLimit;
   #taskTracker;
+  #nativeTurnKey;
   #tools = /* @__PURE__ */ new Map();
+  #toolOrdinal = 0;
   constructor(options) {
     this.#cwd = options.cwd;
     this.#emit = options.emit;
     this.#newItemId = options.newItemId;
+    this.#onDetached = options.onDetached;
     this.#outputLimit = options.outputLimit;
     this.#taskTracker = options.taskTracker;
+    this.#nativeTurnKey = options.nativeTurnKey;
   }
   get size() {
     return this.#tools.size;
@@ -46075,15 +46746,16 @@ var ClaudeToolLifecycle = class {
   start(turnId, event) {
     if (this.#tools.has(event.callId))
       throw new Error("Claude Code Tool started more than once");
+    const itemId = claudeTranscriptItemId(this.#nativeTurnKey, "tool", this.#toolOrdinal += 1);
     const command = event.toolName === "Bash" ? stringField2(event.arguments, "command") : void 0;
     const item = command ? {
       type: "commandExecution",
-      itemId: this.#newItemId(),
+      itemId,
       command,
       cwd: this.#cwd
     } : {
       type: "toolExecution",
-      itemId: this.#newItemId(),
+      itemId,
       toolName: isClaudeTaskTool(event.toolName) ? "Todo" : event.toolName,
       arguments: isClaudeTaskTool(event.toolName) ? {} : event.arguments
     };
@@ -46108,6 +46780,18 @@ var ClaudeToolLifecycle = class {
       throw new Error("Claude Code Tool completion references an unknown Tool");
     }
     this.#tools.delete(event.callId);
+    if (tool.item.type === "commandExecution" && event.backgroundTaskId && !event.isError && !cancellationRequested) {
+      this.#emit({ type: "item.detached", turnId, itemId: tool.item.itemId });
+      this.#onDetached({
+        turnId,
+        callId: event.callId,
+        taskId: event.backgroundTaskId,
+        item: tool.item,
+        startedAtMs: tool.startedAtMs,
+        ...event.backgroundOutputFile ? { outputFile: event.backgroundOutputFile } : {}
+      });
+      return;
+    }
     const output = boundedToolOutput(event.outputText, this.#outputLimit);
     const durationMs = Math.max(tool.elapsedMs, Date.now() - tool.startedAtMs, 0);
     if (tool.item.type === "commandExecution") {
@@ -46361,6 +47045,37 @@ function faultError() {
     retryable: true
   };
 }
+function claudePermissionModeSelectionFailure(permissionMode, error52) {
+  const nativeMessage = error52 instanceof Error ? error52.message.toLowerCase() : "";
+  if (permissionMode === "auto" && nativeMessage.includes("auto mode unavailable")) {
+    return {
+      code: "nativeFailure",
+      message: "Auto mode is unavailable for the current Claude Code Model",
+      retryable: true
+    };
+  }
+  if (permissionMode === "bypassPermissions") {
+    if (nativeMessage.includes("not launched with --dangerously-skip-permissions")) {
+      return {
+        code: "nativeFailure",
+        message: "Claude Code started this Session without bypass permissions support; when running as root, set IS_SANDBOX=1 for the codexhost Host, restart it, and reopen the Session",
+        retryable: false
+      };
+    }
+    if (nativeMessage.includes("disabled by settings or configuration")) {
+      return {
+        code: "nativeFailure",
+        message: "Bypass permissions is disabled by Claude Code settings (permissions.disableBypassPermissionsMode) or organization policy",
+        retryable: false
+      };
+    }
+  }
+  return {
+    code: "nativeFailure",
+    message: "Claude Code rejected the Permission Mode selection",
+    retryable: true
+  };
+}
 function delay2(milliseconds) {
   return new Promise((resolve2) => setTimeout(resolve2, milliseconds));
 }
@@ -46432,6 +47147,7 @@ var ClaudeHarnessSession = class {
   #cancelTimeoutMs;
   #closeTimeoutMs;
   #createTransport;
+  #bypassPermissionsAvailable;
   #cwd;
   #nativeRef;
   #onClosed;
@@ -46448,6 +47164,7 @@ var ClaudeHarnessSession = class {
   #readSessionMessages;
   #sessionId;
   #toolOutputLimit;
+  #backgroundCommands;
   #continuationQuiescenceMs;
   #taskTracker = new ClaudeTaskTracker();
   #acceptingTurn = false;
@@ -46482,6 +47199,7 @@ var ClaudeHarnessSession = class {
     this.#pendingSessions = options.pendingSessions;
     const environment = options.environment;
     this.#createTransport = environment ? (input) => dependencies.createTransport({ ...input, environment }) : dependencies.createTransport;
+    this.#bypassPermissionsAvailable = options.bypassPermissionsAvailable;
     this.#randomUUID = dependencies.randomUUID;
     this.#readSessionMessages = dependencies.readSessionMessages;
     this.#cancelTimeoutMs = options.cancelTimeoutMs;
@@ -46494,6 +47212,10 @@ var ClaudeHarnessSession = class {
     this.#requestedThinkingOptionId = options.requestedThinkingOptionId;
     this.#sessionId = options.sessionId;
     this.#toolOutputLimit = options.toolOutputLimit;
+    this.#backgroundCommands = new ClaudeBackgroundCommandItems({
+      outputLimit: options.toolOutputLimit,
+      emit: (event) => this.#event(event)
+    });
     this.#continuationQuiescenceMs = options.continuationQuiescenceMs;
     this.#nativeRef = options.nativeRef ?? nativeSessionRefSchema.parse({
       harnessId: this.harnessId,
@@ -46695,8 +47417,10 @@ var ClaudeHarnessSession = class {
         cwd: this.#cwd,
         outputLimit: this.#toolOutputLimit,
         taskTracker: this.#taskTracker,
+        nativeTurnKey,
         newItemId: () => hostItemIdSchema.parse(this.#randomUUID()),
-        emit: (event) => this.#event(event)
+        emit: (event) => this.#event(event),
+        onDetached: (command2) => this.#backgroundCommands.follow(command2)
       }),
       interactions: /* @__PURE__ */ new Map(),
       interactionByRequestId: /* @__PURE__ */ new Map(),
@@ -46806,8 +47530,10 @@ var ClaudeHarnessSession = class {
         cwd: this.#cwd,
         outputLimit: this.#toolOutputLimit,
         taskTracker: this.#taskTracker,
+        nativeTurnKey,
         newItemId: () => hostItemIdSchema.parse(this.#randomUUID()),
-        emit: (event) => this.#event(event)
+        emit: (event) => this.#event(event),
+        onDetached: (command2) => this.#backgroundCommands.follow(command2)
       }),
       interactions: /* @__PURE__ */ new Map(),
       interactionByRequestId: /* @__PURE__ */ new Map(),
@@ -46840,6 +47566,28 @@ var ClaudeHarnessSession = class {
     }
     return { ok: true, value: { turnId: command.turnId } };
   }
+  /** Closing the native process stops its background tasks, so they keep the Session. */
+  hasBackgroundWork() {
+    return this.#transport?.hasBackgroundTasks() ?? false;
+  }
+  async stopBackgroundWork() {
+    const transport = this.#transport;
+    if (!transport)
+      return { ok: true, value: void 0 };
+    try {
+      await Promise.all(this.#backgroundCommands.taskIds().map((taskId) => transport.stopBackgroundTask(taskId)));
+      return { ok: true, value: void 0 };
+    } catch (error52) {
+      return {
+        ok: false,
+        error: {
+          code: "nativeFailure",
+          message: error52 instanceof Error ? error52.message : String(error52),
+          retryable: true
+        }
+      };
+    }
+  }
   refreshUsage() {
     if (this.#phase !== "open" || !this.#transport)
       return Promise.resolve();
@@ -47001,6 +47749,21 @@ var ClaudeHarnessSession = class {
         }
       };
     }
+    let permissionModeId = command.permissionModeId;
+    if (permissionMode === "bypassPermissions" && !this.#bypassPermissionsAvailable) {
+      if (this.#transport || this.#startupTask) {
+        return {
+          ok: false,
+          error: {
+            code: "unsupported",
+            message: CLAUDE_BYPASS_PERMISSIONS_UNAVAILABLE_MESSAGE,
+            retryable: false
+          }
+        };
+      }
+      permissionMode = "default";
+      permissionModeId = CLAUDE_DEFAULT_PERMISSION_MODE_ID;
+    }
     this.#usageGeneration += 1;
     this.#contextUsageFreshUntilMs = 0;
     this.#contextUsageCooldownUntilMs = 0;
@@ -47014,18 +47777,13 @@ var ClaudeHarnessSession = class {
         try {
           await transport.setPermissionMode(permissionMode);
         } catch (error52) {
-          const nativeMessage = error52 instanceof Error ? error52.message.toLowerCase() : "";
           return {
             ok: false,
-            error: {
-              code: "nativeFailure",
-              message: permissionMode === "auto" && nativeMessage.includes("auto mode unavailable") ? "Auto mode is unavailable for the current Claude Code Model" : "Claude Code rejected the Permission Mode selection",
-              retryable: true
-            }
+            error: claudePermissionModeSelectionFailure(permissionMode, error52)
           };
         }
       }
-      this.#requestedPermissionModeId = transport ? encodeClaudePermissionModeId(transport.getPermissionMode()) : command.permissionModeId;
+      this.#requestedPermissionModeId = transport ? encodeClaudePermissionModeId(transport.getPermissionMode()) : permissionModeId;
       const persistenceError = await this.#savePendingConfiguration();
       if (persistenceError)
         return { ok: false, error: persistenceError };
@@ -47195,6 +47953,7 @@ var ClaudeHarnessSession = class {
     const active = this.#active;
     if (active)
       this.#finishFailed(active, invalidState("Claude Code Session closed during active Turn"));
+    this.#backgroundCommands.abandonAll("Claude Code Session closed");
     this.#phase = "closed";
     this.#channel.end();
     this.#onClosed();
@@ -47235,6 +47994,7 @@ var ClaudeHarnessSession = class {
         ...model ? { model } : {},
         thinkingOptionId: this.#requestedThinkingOptionId,
         permissionMode,
+        allowDangerouslySkipPermissions: this.#bypassPermissionsAvailable,
         onPermissionModeChanged: (mode) => this.#handlePermissionModeChanged(mode),
         onFault: () => this.#fault(faultError()),
         onPlanLimit: (planLimit) => this.#handlePlanLimit(planLimit)
@@ -47242,9 +48002,8 @@ var ClaudeHarnessSession = class {
       this.#transport = transport;
       transport.setAutonomousTurnHandler((turn) => this.#handleAutonomousTurn(turn));
       transport.setThreadEventHandler((event) => {
-        if (event.type === "subagent.settled") {
-          this.#settleBackgroundSubagent(event.status, event.nativeSubagentId, event.callId, event.resultSummary);
-        }
+        if (event.type === "subagent.settled")
+          this.#settleNativeTask(event);
       });
       transport.setIdleTurnHandler({
         onEvent: (event) => {
@@ -47253,9 +48012,8 @@ var ClaudeHarnessSession = class {
             this.#handleTurnEvent(active, event);
             return;
           }
-          if (event.type === "subagent.settled") {
-            this.#settleBackgroundSubagent(event.status, event.nativeSubagentId, event.callId, event.resultSummary);
-          }
+          if (event.type === "subagent.settled")
+            this.#settleNativeTask(event);
         },
         onTerminal: (result) => {
           const active = this.#active;
@@ -47435,7 +48193,7 @@ var ClaudeHarnessSession = class {
         return;
       }
       case "subagent.settled":
-        this.#settleBackgroundSubagent(event.status, event.nativeSubagentId, event.callId, event.resultSummary);
+        this.#settleNativeTask(event);
         return;
       case "subagent.transcript.changed": {
         const nativeSubagentId2 = active.subagents.nativeSubagentId(event.callId);
@@ -47702,8 +48460,10 @@ var ClaudeHarnessSession = class {
         cwd: this.#cwd,
         outputLimit: this.#toolOutputLimit,
         taskTracker: this.#taskTracker,
+        nativeTurnKey,
         newItemId: () => hostItemIdSchema.parse(this.#randomUUID()),
-        emit: (event) => this.#event(event)
+        emit: (event) => this.#event(event),
+        onDetached: (command) => this.#backgroundCommands.follow(command)
       }),
       interactions: /* @__PURE__ */ new Map(),
       interactionByRequestId: /* @__PURE__ */ new Map(),
@@ -47741,6 +48501,15 @@ var ClaudeHarnessSession = class {
       this.#handleTurnEvent(active, event);
     this.#finishResult(active, turn.result);
   }
+  /**
+   * A native `task_notification` names the tool call that started its task: a
+   * followed background command settles here, anything else is a Subagent.
+   */
+  #settleNativeTask(event) {
+    if (this.#backgroundCommands.settle(event))
+      return;
+    this.#settleBackgroundSubagent(event.status, event.nativeSubagentId, event.callId, event.resultSummary);
+  }
   #settleBackgroundSubagent(status, nativeSubagentId2, callId, resultSummary) {
     this.#occupancy.notify(callId, nativeSubagentId2);
     const active = this.#active;
@@ -48130,6 +48899,7 @@ var ClaudeHarnessSession = class {
     const active = this.#active;
     if (active)
       this.#finishFailed(active, error52);
+    this.#backgroundCommands.abandonAll("Claude Code Session faulted");
     this.#phase = "faulted";
     this.#event({ type: "session.faulted", error: error52 });
     this.#channel.end();
@@ -48145,22 +48915,10 @@ var ClaudeCodeAdapter = class {
   harnessId = claudeCodeHarnessId2;
   sessionImport = Object.freeze({
     listCandidates: async () => {
-      const result = await this.#readImport((signal) => this.#importIndex.list(signal));
+      const result = await this.#importScope.read((signal) => this.#importIndex.list(signal));
       return result.ok ? { ok: true, value: result.value.map(({ candidate }) => candidate) } : result;
     },
-    resolveCandidate: async (nativeSessionId) => {
-      const result = await this.#readImport((signal) => this.#importIndex.resolve(nativeSessionId, signal));
-      if (!result.ok)
-        return result;
-      return result.value ? { ok: true, value: result.value } : {
-        ok: false,
-        error: {
-          code: "sessionNotFound",
-          message: "Claude Code Session is no longer importable",
-          retryable: false
-        }
-      };
-    }
+    resolveCandidate: (nativeSessionId) => this.#importScope.resolve((signal) => this.#importIndex.resolve(nativeSessionId, signal))
   });
   subagents = {
     readSnapshot: async (input) => {
@@ -48205,9 +48963,12 @@ var ClaudeCodeAdapter = class {
   #cancelTimeoutMs;
   #closeTimeoutMs;
   #dependencies;
-  #importAbort = new AbortController();
   #importIndex;
-  #importRequests = /* @__PURE__ */ new Set();
+  #importScope = new SessionImportScope({
+    closedMessage: "Claude Code Adapter is closed",
+    unavailableMessage: "Claude Code Session discovery failed; check storage access and duplicate Session identities, then retry after closing native clients",
+    notFoundMessage: "Claude Code Session is no longer importable"
+  });
   #pendingSessions;
   #toolOutputLimit;
   #continuationQuiescenceMs;
@@ -48237,6 +48998,7 @@ var ClaudeCodeAdapter = class {
     }
     this.#dependencies = dependencies ?? {
       randomUUID: randomUUID3,
+      bypassPermissionsAvailable: (environment2) => claudeBypassPermissionsAvailable(environment2 ?? options.environment ?? process.env),
       inspectInstallation: () => {
         resolveClaudeCodeExecutable({
           ...options.command ? { command: options.command } : {},
@@ -48275,24 +49037,6 @@ var ClaudeCodeAdapter = class {
       readSubagentMessages: ({ cwd, sessionId, nativeSubagentId: nativeSubagentId2 }) => jkt(sessionId, nativeSubagentId2, { dir: cwd })
     };
   }
-  #readImport(operation) {
-    if (this.#importAbort.signal.aborted) {
-      return Promise.resolve({
-        ok: false,
-        error: invalidState("Claude Code Adapter is closed")
-      });
-    }
-    const request = operation(this.#importAbort.signal).then((value) => ({ ok: true, value })).catch(() => ({
-      ok: false,
-      error: {
-        code: "unavailable",
-        message: "Claude Code Session discovery failed; check storage access and duplicate Session identities, then retry after closing native clients",
-        retryable: true
-      }
-    })).finally(() => this.#importRequests.delete(request));
-    this.#importRequests.add(request);
-    return request;
-  }
   async inspect(input = {}) {
     if (this.#closePromise) {
       return {
@@ -48300,7 +49044,7 @@ var ClaudeCodeAdapter = class {
         error: invalidState("Claude Code Adapter is closing")
       };
     }
-    const cwd = path12.resolve(input.cwd ?? process.cwd());
+    const cwd = path14.resolve(input.cwd ?? process.cwd());
     if (!input.refresh) {
       const cached2 = this.#inspectionCache.get(cwd);
       if (cached2)
@@ -48359,7 +49103,7 @@ var ClaudeCodeAdapter = class {
       this.#inspectors.add(inspector);
       stage = "model-catalog";
       const snapshot = await inspector.inspect();
-      const permissionModes = snapshot.canSelectPermissionMode ? claudePermissionModeCatalogForModels(snapshot.models) : void 0;
+      const permissionModes = snapshot.canSelectPermissionMode ? claudePermissionModeCatalogForModels(snapshot.models, this.#dependencies.bypassPermissionsAvailable()) : void 0;
       if (!snapshot.canSelectModel) {
         return {
           status: "unavailable",
@@ -48481,7 +49225,21 @@ var ClaudeCodeAdapter = class {
         }
       };
     }
-    const cwd = path12.resolve(input.cwd);
+    const bypassPermissionsAvailable = this.#dependencies.bypassPermissionsAvailable(input.environment);
+    if (!bypassPermissionsAvailable && requestedPermissionModeId === "bypassPermissions") {
+      if (input.kind === "create") {
+        return {
+          ok: false,
+          error: {
+            code: "unsupported",
+            message: CLAUDE_BYPASS_PERMISSIONS_UNAVAILABLE_MESSAGE,
+            retryable: false
+          }
+        };
+      }
+      requestedPermissionModeId = CLAUDE_DEFAULT_PERMISSION_MODE_ID;
+    }
+    const cwd = path14.resolve(input.cwd);
     if (input.kind === "rollbackLastTurn") {
       for (const source of this.#sessions) {
         const ready = await source.prepareRollback(input.sourceRef.nativeSessionId);
@@ -48540,7 +49298,10 @@ var ClaudeCodeAdapter = class {
           decodeClaudePermissionModeId(pending.configuration.effectivePermissionModeId);
         requestedModel = pending.configuration.effectiveModel ?? requestedModel;
         requestedThinkingOptionId = pending.configuration.effectiveThinkingOptionId ?? requestedThinkingOptionId;
-        requestedPermissionModeId = input.kind === "resume" && input.permissionModeId ? input.permissionModeId : pending.configuration.effectivePermissionModeId ?? requestedPermissionModeId;
+        requestedPermissionModeId = input.kind === "resume" && input.permissionModeId ? requestedPermissionModeId : pending.configuration.effectivePermissionModeId ?? requestedPermissionModeId;
+        if (!bypassPermissionsAvailable && requestedPermissionModeId === "bypassPermissions") {
+          requestedPermissionModeId = CLAUDE_DEFAULT_PERMISSION_MODE_ID;
+        }
       } catch {
         return {
           ok: false,
@@ -48554,6 +49315,7 @@ var ClaudeCodeAdapter = class {
     }
     const session = new ClaudeHarnessSession(cwd, this.#dependencies, this.#closeTimeoutMs, () => this.#sessions.delete(session), (planLimit) => this.#recordPlanLimit(session, planLimit), {
       ...input.environment ? { environment: input.environment } : {},
+      bypassPermissionsAvailable,
       openMode,
       pendingSessions: this.#pendingSessions,
       knownConfiguration: input.kind === "rollbackLastTurn" || input.kind === "resume" && Boolean(input.model || input.thinkingOptionId) || Boolean(durableRef && isPendingClaudeSession(durableRef)),
@@ -48590,10 +49352,9 @@ var ClaudeCodeAdapter = class {
   }
   close() {
     if (!this.#closePromise) {
-      this.#importAbort.abort();
       this.#inspectionCache.clear();
       this.#closePromise = Promise.all([
-        ...this.#importRequests,
+        this.#importScope.close(),
         ...[...this.#inspectors].map((inspector) => inspector.close()),
         ...[...this.#sessions].map((session) => session.close()),
         ...this.#inspectionInFlight.values()
@@ -48603,9 +49364,75 @@ var ClaudeCodeAdapter = class {
   }
 };
 
+// dist/installation.js
+import { readFile as readFile6, realpath as realpath3 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import path15 from "node:path";
+async function readSettings(file2) {
+  const text = await readFile6(file2, "utf8").catch((error52) => {
+    if (error52.code === "ENOENT")
+      return "{}";
+    throw error52;
+  });
+  const settings = JSON.parse(text);
+  if (!settings || typeof settings !== "object" || Array.isArray(settings))
+    throw new Error("Claude update settings are invalid");
+  return settings;
+}
+function createClaudeInstallation(environment, command) {
+  let update;
+  return createInstallationManager({
+    async check() {
+      const executable = resolveClaudeCodeExecutable({
+        environment,
+        ...command ? { command } : {}
+      });
+      const home = environment.HOME ?? environment.USERPROFILE ?? homedir2();
+      const config2 = environment.CLAUDE_CONFIG_DIR ? path15.resolve(home, environment.CLAUDE_CONFIG_DIR) : path15.join(home, ".claude");
+      const managedFile = process.platform === "darwin" ? "/Library/Application Support/ClaudeCode/managed-settings.json" : process.platform === "win32" ? path15.join(environment.ProgramFiles ?? "C:\\Program Files", "ClaudeCode", "managed-settings.json") : "/etc/claude-code/managed-settings.json";
+      const user = await readSettings(path15.join(config2, "settings.json"));
+      const managed = await readSettings(managedFile);
+      const settings = { ...user, ...managed, env: { ...user.env, ...managed.env } };
+      const env = { ...environment, ...settings.env };
+      const currentVersion = versionFromOutput(await runInstallationCommand(executable, ["--version"], {
+        ...env,
+        DISABLE_AUTOUPDATER: "1"
+      }));
+      const channel = settings.autoUpdatesChannel ?? "latest";
+      if (channel !== "latest" && channel !== "stable")
+        throw new Error("Unknown Claude release channel");
+      const latestVersion = installationVersion(await fetchInstallationText(`https://downloads.claude.ai/claude-code-releases/${channel}`));
+      const npm = await npmInstallation(executable, ["@anthropic-ai/claude-code"], env);
+      const launcher = path15.join(home, ".local", "bin", process.platform === "win32" ? "claude.exe" : "claude");
+      const selected = await realpath3(executable);
+      const versions = path15.join(home, ".local", "share", "claude", "versions") + path15.sep;
+      const native = path15.resolve(executable) === launcher && (selected.startsWith(versions) || process.platform === "win32" && selected === launcher);
+      const blocked = !!env.DISABLE_UPDATES && env.DISABLE_UPDATES !== "0" || !!settings.minimumVersion && newerInstallationVersion(latestVersion, installationVersion(settings.minimumVersion)) || !!settings.requiredMaximumVersion && newerInstallationVersion(installationVersion(settings.requiredMaximumVersion), latestVersion);
+      const canUpdate = !blocked && (npm?.canUpdate ?? native);
+      update = async () => {
+        const updateEnv = npm ? { ...env, npm_config_prefix: npm.prefix, NPM_CONFIG_PREFIX: npm.prefix } : env;
+        await runInstallationCommand(executable, ["update"], updateEnv, 3e5);
+      };
+      return {
+        currentVersion,
+        latestVersion,
+        updateAvailable: newerInstallationVersion(currentVersion, latestVersion),
+        canUpdate,
+        ...!canUpdate ? {
+          messageCode: blocked ? "claude-policy-restricted" : "original-installer",
+          message: blocked ? "Claude updates are restricted by the installation's settings or policy." : "Use the original installer or package manager for this Claude installation."
+        } : {}
+      };
+    },
+    async update() {
+      await update();
+    }
+  });
+}
+
 // dist/user-shell-environment.js
-import path13 from "node:path";
-import { execFile as execFile2 } from "node:child_process";
+import path16 from "node:path";
+import { execFile as execFile3 } from "node:child_process";
 var ENVIRONMENT_MARKER = Buffer.from("\0CODEXHOST_USER_SHELL_ENV_V1\0");
 var ENVIRONMENT_COMMAND = "printf '\\0CODEXHOST_USER_SHELL_ENV_V1\\0'; /usr/bin/env -0";
 var SHELL_ENVIRONMENT_TIMEOUT_MS = 3e3;
@@ -48647,14 +49474,14 @@ async function withUserShellEnvironment(environment, dependencies) {
   if (platform === "win32" || !environment.HOME)
     return environment;
   const shell = environment.SHELL?.trim() || defaultShell(platform);
-  if (!shell || !SUPPORTED_SHELLS.has(path13.basename(shell)))
+  if (!shell || !SUPPORTED_SHELLS.has(path16.basename(shell)))
     return environment;
   const cacheKey = `${platform}\0${shell}\0${environment.HOME}`;
   const cached2 = dependencies ? void 0 : shellEnvironmentCache.get(cacheKey);
   if (cached2)
     return mergeMissingEnvironment(environment, cached2);
   const run = dependencies?.run ?? ((command, arguments_, options) => new Promise((resolve2) => {
-    const child = execFile2(command, arguments_, {
+    const child = execFile3(command, arguments_, {
       ...options,
       encoding: "buffer",
       killSignal: "SIGKILL"
@@ -48691,9 +49518,15 @@ async function createHarnessAdapter(context) {
       ...context.brokerDescriptorPath ? { descriptorPath: context.brokerDescriptorPath } : {}
     });
   }
-  return new ClaudeCodeAdapter({
+  return Object.assign(new ClaudeCodeAdapter({
     ...environment[CLAUDE_CODE_COMMAND_ENV] ? { command: environment[CLAUDE_CODE_COMMAND_ENV] } : {},
     environment
+  }), {
+    installation: createClaudeInstallation(environment, environment[CLAUDE_CODE_COMMAND_ENV]),
+    install: createHarnessInstaller(environment, {
+      posix: "https://claude.ai/install.sh",
+      windows: "https://claude.ai/install.ps1"
+    })
   });
 }
 async function warmup(adapter) {