@codexhost/cli-darwin-x64 0.6.0 → 0.6.2

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, path10) {
-  if (!path10)
+function getElementAtPath(obj, path12) {
+  if (!path12)
     return obj;
-  return path10.reduce((acc, key) => acc?.[key], obj);
+  return path12.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(path10, issues) {
+function prefixIssues(path12, issues) {
   return issues.map((iss) => {
     var _a4;
     (_a4 = iss).path ?? (_a4.path = []);
-    iss.path.unshift(path10);
+    iss.path.unshift(path12);
     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, path10 = []) => {
+  const processError = (error53, path12 = []) => {
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path10, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path12, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
       } else {
-        const fullpath = [...path10, ...issue2.path];
+        const fullpath = [...path12, ...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, path10 = []) => {
+  const processError = (error53, path12 = []) => {
     var _a4, _b2;
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path10, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path12, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
       } else {
-        const fullpath = [...path10, ...issue2.path];
+        const fullpath = [...path12, ...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 path10 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path10) {
+  const path12 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path12) {
     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 path10 = ref.slice(1).split("/").filter(Boolean);
-  if (path10.length === 0) {
+  const path12 = ref.slice(1).split("/").filter(Boolean);
+  if (path12.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path10[0] === defsKey) {
-    const key = path10[1];
+  if (path12[0] === defsKey) {
+    const key = path12[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14550,6 +14550,8 @@ var threadUsageSnapshotSchema = external_exports.object({
   reasoningOutputTokens: nonNegativeSafeIntegerSchema.optional(),
   totalTokens: nonNegativeSafeIntegerSchema.optional(),
   totalCostUsd: finiteNonNegativeNumberSchema.optional(),
+  totalCredits: finiteNonNegativeNumberSchema.optional(),
+  contextUsagePercent: finiteNonNegativeNumberSchema.optional(),
   cacheHitRatePercent: cacheHitRatePercentSchema.optional(),
   contextWindowTokens: nonNegativeSafeIntegerSchema.optional(),
   contextUsedTokens: nonNegativeSafeIntegerSchema.optional(),
@@ -15481,7 +15483,9 @@ var usageFields = /* @__PURE__ */ new Set([
   ...tokenFields,
   ...safeIntegerFields,
   ...percentFields,
-  "totalCostUsd"
+  "totalCostUsd",
+  "totalCredits",
+  "contextUsagePercent"
 ]);
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -15497,6 +15501,12 @@ function parseHostUsage(value) {
       throw new Error(`Harness Usage contains unknown field '${key}'`);
     }
   }
+  for (const field of ["totalCredits", "contextUsagePercent"]) {
+    const candidate = value[field];
+    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0)) {
+      throw new Error(`Harness Usage '${field}' must be a finite non-negative number`);
+    }
+  }
   for (const field of tokenFields) {
     const candidate = value[field];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
@@ -15673,6 +15683,8 @@ var createSchema = external_exports.object({
 }).strict();
 var resumeSchema = external_exports.object({
   kind: external_exports.literal("resume"),
+  model: harnessModelRefSchema.optional(),
+  thinkingOptionId: harnessThinkingOptionIdSchema.optional(),
   nativeRef: nativeSessionRefSchema,
   cwd: cwdSchema,
   knownTurnRefs: external_exports.array(nativeTurnRefSchema).max(1e5).optional()
@@ -15685,6 +15697,9 @@ var forkSchema = external_exports.object({
 }).strict();
 var rollbackSchema = external_exports.object({
   kind: external_exports.literal("rollbackLastTurn"),
+  model: harnessModelRefSchema.optional(),
+  thinkingOptionId: harnessThinkingOptionIdSchema.optional(),
+  permissionModeId: harnessPermissionModeIdSchema.optional(),
   sourceRef: nativeSessionRefSchema,
   cwd: cwdSchema
 }).strict();
@@ -16294,8 +16309,8 @@ var BrokeredHarnessAdapter = class {
 };
 
 // dist/claude-code-adapter.js
-import { randomUUID as randomUUID2 } from "node:crypto";
-import path8 from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
+import path10 from "node:path";
 
 // ../../../node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
 import { createRequire as DW } from "node:module";
@@ -20200,8 +20215,8 @@ var qU = v(function(BU) {
   BU._globalThis = void 0;
   BU._globalThis = typeof globalThis === "object" ? globalThis : global;
 });
-var GU = v(function(os4) {
-  var Axe = os4 && os4.__createBinding || (Object.create ? function(e, t, r, n) {
+var GU = v(function(os5) {
+  var Axe = os5 && os5.__createBinding || (Object.create ? function(e, t, r, n) {
     if (n === void 0) n = r;
     Object.defineProperty(e, n, { enumerable: true, get: function() {
       return t[r];
@@ -20209,11 +20224,11 @@ var GU = v(function(os4) {
   } : function(e, t, r, n) {
     if (n === void 0) n = r;
     e[n] = t[r];
-  }), kxe = os4 && os4.__exportStar || function(e, t) {
+  }), kxe = os5 && os5.__exportStar || function(e, t) {
     for (var r in e) if (r !== "default" && !Object.prototype.hasOwnProperty.call(t, r)) Axe(t, e, r);
   };
-  Object.defineProperty(os4, "__esModule", { value: true });
-  kxe(qU(), os4);
+  Object.defineProperty(os5, "__esModule", { value: true });
+  kxe(qU(), os5);
 });
 var WU = v(function(is) {
   var Oxe = is && is.__createBinding || (Object.create ? function(e, t, r, n) {
@@ -42261,8 +42276,136 @@ function resolveClaudeCodeExecutable(input = {}, dependencies = {}) {
   return targetPath(platform).isAbsolute(resolution.executable) ? resolution.executable : path4.resolve(resolution.executable);
 }
 
-// dist/claude-fork.js
+// dist/pending-session.js
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir, open, readFile as readFile2, rename, rm as rm2, stat, unlink } from "node:fs/promises";
+import os3 from "node:os";
 import path5 from "node:path";
+var reservationSchema = external_exports.strictObject({
+  version: external_exports.literal(1),
+  sessionId: external_exports.uuid(),
+  cwd: external_exports.string().min(1),
+  configuration: harnessConfigurationStateSchema
+});
+function isPendingClaudeSession(ref) {
+  return ref.locator !== void 0;
+}
+var ClaudePendingSessions = class {
+  #directory;
+  constructor(environment) {
+    this.#directory = path5.join(path5.resolve(environment.CLAUDE_CONFIG_DIR ?? path5.join(os3.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 || !path5.isAbsolute(cwd)) {
+      throw new Error("Claude Code pending Session identity is invalid");
+    }
+    return path5.join(this.#directory, ref.nativeSessionId);
+  }
+  async create(cwd, configuration) {
+    const ref = nativeSessionRefSchema.parse({
+      harnessId: "claude-code",
+      nativeSessionId: randomUUID2(),
+      locator: { pendingSession: 1 },
+      formatVersion: 1
+    });
+    const directory = this.#path(ref, cwd);
+    const reservation = reservationSchema.parse({
+      version: 1,
+      sessionId: ref.nativeSessionId,
+      cwd,
+      configuration
+    });
+    await mkdir(this.#directory, { recursive: true, mode: 448 });
+    await mkdir(directory, { mode: 448 });
+    try {
+      const file2 = await open(path5.join(directory, "session.json"), "wx", 384);
+      try {
+        await file2.writeFile(JSON.stringify(reservation));
+        await file2.sync();
+      } finally {
+        await file2.close();
+      }
+    } catch (error52) {
+      await rm2(directory, { recursive: true, force: true });
+      throw error52;
+    }
+    await this.#sync(directory);
+    await this.#sync(this.#directory);
+    return ref;
+  }
+  async read(ref, cwd) {
+    const directory = this.#path(ref, cwd);
+    const reservation = reservationSchema.parse(JSON.parse(await readFile2(path5.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 stat(path5.join(directory, "started"));
+      if (!claim.isFile())
+        throw new Error("Claude Code pending Session claim is invalid");
+      started = true;
+    } catch (error52) {
+      if (error52.code !== "ENOENT")
+        throw error52;
+    }
+    return { started, configuration: reservation.configuration };
+  }
+  async saveConfiguration(ref, cwd, configuration) {
+    await this.read(ref, cwd);
+    const directory = this.#path(ref, cwd);
+    const temporary = path5.join(directory, `${randomUUID2()}.tmp`);
+    try {
+      const file2 = await open(temporary, "wx", 384);
+      try {
+        await file2.writeFile(JSON.stringify(reservationSchema.parse({
+          version: 1,
+          sessionId: ref.nativeSessionId,
+          cwd,
+          configuration
+        })));
+        await file2.sync();
+      } finally {
+        await file2.close();
+      }
+      await rename(temporary, path5.join(directory, "session.json"));
+      await this.#sync(directory);
+    } finally {
+      await rm2(temporary, { force: true });
+    }
+  }
+  async #sync(directory) {
+    if (process.platform === "win32")
+      return;
+    const handle = await open(directory, "r");
+    try {
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+  }
+  async claim(ref, cwd) {
+    await this.read(ref, cwd);
+    const claim = await open(path5.join(this.#path(ref, cwd), "started"), "wx", 384);
+    try {
+      await claim.sync();
+    } finally {
+      await claim.close();
+    }
+    await this.#sync(this.#path(ref, cwd));
+  }
+  /** Only the claim owner may release, after proven close and before submitting any native input. */
+  async release(ref, cwd) {
+    await unlink(path5.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 });
+  }
+};
+
+// dist/claude-fork.js
+import path6 from "node:path";
 import { isDeepStrictEqual } from "node:util";
 
 // dist/item-identity.js
@@ -42330,9 +42473,19 @@ function visibleUserTextParts(message) {
     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 || !isRecord2(value.message))
+    return false;
+  const content = value.message.content;
+  if (!Array.isArray(content) || content.length !== 1)
+    return false;
+  const part = content[0];
+  return isRecord2(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 (!isRecord2(value))
       throw new Error("Claude history contains a malformed message");
@@ -42344,12 +42497,18 @@ function conversationMessages(values, sessionId) {
     if (ids.has(value.uuid))
       throw new Error("Claude history contains duplicate message IDs");
     ids.add(value.uuid);
-    messages.push({
+    const interrupted = isInterruptionRecord(value, promptId);
+    const message = {
       type: value.type,
       uuid: value.uuid,
       message: value.message,
-      syntheticUser: value.type === "user" && (value.isSynthetic === true || value.isMeta === true || isTaskNotificationOrigin(value) || value.toolUseResult !== void 0 && value.toolUseResult !== null)
-    });
+      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;
 }
@@ -42357,6 +42516,8 @@ 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) {
@@ -42403,7 +42564,7 @@ function mapClaudeSnapshot(values, sessionId) {
     const turnMessages = messages.slice(index, end);
     const outcome = turnOutcome(turnMessages);
     const results = toolResultBlocks(turnMessages);
-    const checkpointMessage = turnMessages.findLast(({ type }) => type === "assistant");
+    const checkpointMessage = turnMessages.findLast(({ type, interrupted }) => type === "assistant" || interrupted);
     let agentMessageOrdinal = 0;
     let reasoningOrdinal = 0;
     turns.push({
@@ -42716,6 +42877,7 @@ function comparableTurn(turn) {
       outcome
     })),
     outcome: turn.outcome,
+    hasCheckpoint: turn.checkpoint !== void 0,
     ...turn.model ? { model: turn.model } : {}
   };
 }
@@ -42752,8 +42914,8 @@ async function readSnapshot(dependencies, cwd, sessionId) {
 }
 async function forkClaudeSession(input) {
   const sourceRef = nativeSessionRefSchema.safeParse(input.sourceRef);
-  const checkpoint = nativeCheckpointRefSchema.safeParse(input.checkpoint);
-  if (!sourceRef.success || !checkpoint.success || sourceRef.data.harnessId !== input.harnessId || checkpoint.data.harnessId !== input.harnessId || checkpoint.data.nativeSessionId !== sourceRef.data.nativeSessionId) {
+  const checkpoint = input.kind === "fork" ? nativeCheckpointRefSchema.safeParse(input.checkpoint) : null;
+  if (!sourceRef.success || sourceRef.data.harnessId !== input.harnessId || checkpoint && (!checkpoint.success || checkpoint.data.harnessId !== input.harnessId || checkpoint.data.nativeSessionId !== sourceRef.data.nativeSessionId)) {
     return {
       ok: false,
       error: error51("invalidRequest", "Claude Code Fork identity does not belong to the source Session", false)
@@ -42782,7 +42944,7 @@ async function forkClaudeSession(input) {
       error: error51("protocolError", "Claude Code Session working directory is unavailable", false)
     };
   }
-  if (path5.resolve(sourceInfo.cwd) !== input.cwd) {
+  if (path6.resolve(sourceInfo.cwd) !== input.cwd) {
     return {
       ok: false,
       error: error51("unsupported", "Claude Code cannot Fork across working directories", false)
@@ -42791,8 +42953,39 @@ async function forkClaudeSession(input) {
   const source = await readSnapshot(input.dependencies, input.cwd, sourceRef.data.nativeSessionId);
   if (!source.ok)
     return source;
-  const boundaryIndex = source.value.turns.findIndex((turn) => turn.checkpoint?.checkpointId === checkpoint.data.checkpointId);
-  if (boundaryIndex < 0) {
+  if (input.kind === "rollbackLastTurn" && source.value.turns.length === 0) {
+    return {
+      ok: false,
+      error: error51("invalidRequest", "Claude Code Session has no Turn to roll back", false)
+    };
+  }
+  if (input.kind === "rollbackLastTurn" && source.value.turns.length === 1) {
+    let nativeRef;
+    try {
+      nativeRef = await input.pendingSessions.create(input.cwd, input.configuration);
+    } catch {
+      return {
+        ok: false,
+        error: error51("nativeFailure", "Claude Code empty rollback could not be persisted", true)
+      };
+    }
+    const sourceAfter2 = await readSnapshot(input.dependencies, input.cwd, sourceRef.data.nativeSessionId);
+    if (!sourceAfter2.ok || !isDeepStrictEqual(sourceAfter2.value, source.value)) {
+      await input.pendingSessions.discard(nativeRef, input.cwd).catch(() => void 0);
+      return {
+        ok: false,
+        error: error51("protocolError", "Claude Code source history changed during rollback", false)
+      };
+    }
+    return {
+      ok: true,
+      value: { sessionId: nativeRef.nativeSessionId, nativeRef, openMode: "create" }
+    };
+  }
+  const boundaryIndex = input.kind === "rollbackLastTurn" ? source.value.turns.length - 2 : source.value.turns.findIndex((turn) => checkpoint?.success && turn.checkpoint?.checkpointId === checkpoint.data.checkpointId);
+  const retained = source.value.turns[boundaryIndex];
+  const boundaryId = retained?.checkpoint?.checkpointId ?? (input.kind === "rollbackLastTurn" ? retained?.nativeTurnRef.nativeTurnKey : void 0);
+  if (boundaryIndex < 0 || !boundaryId) {
     return {
       ok: false,
       error: error51("checkpointNotFound", "Claude Code Fork Checkpoint is unavailable", false)
@@ -42801,7 +42994,7 @@ async function forkClaudeSession(input) {
   let derivedSessionId;
   try {
     const forked = await input.dependencies.forkSession({
-      checkpointId: checkpoint.data.checkpointId,
+      checkpointId: boundaryId,
       cwd: input.cwd,
       sourceSessionId: sourceRef.data.nativeSessionId
     });
@@ -42840,7 +43033,7 @@ async function forkClaudeSession(input) {
   const derivedContent = derived.value.turns.map(comparableTurn);
   const sourceIds = nativeIds(source.value);
   const derivedIds = nativeIds(derived.value);
-  if (!isDeepStrictEqual(sourceAfter.value.turns.slice(0, boundaryIndex + 1), sourcePrefix) || !isDeepStrictEqual(derivedContent, expectedPrefix) || derivedIds.size === 0 || [...derivedIds].some((id) => sourceIds.has(id))) {
+  if (input.kind === "rollbackLastTurn" && sourceAfter.value.turns.length !== source.value.turns.length || sourceAfter.value.turns.length < source.value.turns.length || !isDeepStrictEqual(sourceAfter.value.turns.slice(0, source.value.turns.length), source.value.turns) || !isDeepStrictEqual(derivedContent, expectedPrefix) || derivedIds.size === 0 || [...derivedIds].some((id) => sourceIds.has(id))) {
     await cleanup();
     return {
       ok: false,
@@ -42851,26 +43044,26 @@ async function forkClaudeSession(input) {
 }
 
 // dist/claude-transcript.js
-import os3 from "node:os";
-import path6 from "node:path";
-import { readFile as readFile2, readdir, stat } from "node:fs/promises";
+import os4 from "node:os";
+import path7 from "node:path";
+import { readFile as readFile3, readdir, stat as stat2 } from "node:fs/promises";
 function projectDirectoryName(cwd) {
   return cwd.replace(/[^A-Za-z0-9]/gu, "-");
 }
 function configDirectory(environment) {
-  return environment.CLAUDE_CONFIG_DIR ? path6.resolve(environment.CLAUDE_CONFIG_DIR) : path6.join(os3.homedir(), ".claude");
+  return environment.CLAUDE_CONFIG_DIR ? path7.resolve(environment.CLAUDE_CONFIG_DIR) : path7.join(os4.homedir(), ".claude");
 }
 async function existingFile(file2) {
   try {
-    return (await stat(file2)).isFile();
+    return (await stat2(file2)).isFile();
   } catch {
     return false;
   }
 }
 async function findTranscript(input) {
-  const projectsDirectory = path6.join(configDirectory(input.environment), "projects");
+  const projectsDirectory = path7.join(configDirectory(input.environment), "projects");
   const name = `${input.sessionId}.jsonl`;
-  const expected = path6.join(projectsDirectory, projectDirectoryName(input.cwd), name);
+  const expected = path7.join(projectsDirectory, projectDirectoryName(input.cwd), name);
   if (await existingFile(expected))
     return expected;
   let projects;
@@ -42880,7 +43073,7 @@ async function findTranscript(input) {
     return null;
   }
   for (const project of projects) {
-    const candidate = path6.join(projectsDirectory, project, name);
+    const candidate = path7.join(projectsDirectory, project, name);
     if (await existingFile(candidate))
       return candidate;
   }
@@ -42893,7 +43086,7 @@ async function readClaudeTranscript(input) {
   const transcript = await findTranscript(input);
   if (!transcript)
     return null;
-  const contents = await readFile2(transcript, "utf8");
+  const contents = await readFile3(transcript, "utf8");
   const messages = [];
   for (const line of contents.split("\n")) {
     if (line.trim().length === 0)
@@ -43171,7 +43364,7 @@ function projectClaudeAccountUsage(usage, account) {
 }
 
 // dist/file-change.js
-import path7 from "node:path";
+import path8 from "node:path";
 var hunkSchema = external_exports.object({
   oldStart: external_exports.number().int().nonnegative(),
   oldLines: external_exports.number().int().nonnegative(),
@@ -43219,10 +43412,10 @@ function parseClaudeNativeFileChange(toolName, value) {
   };
 }
 function displayPath(nativePath, cwd) {
-  const resolvedCwd = path7.resolve(cwd);
-  const resolvedPath = path7.isAbsolute(nativePath) ? path7.resolve(nativePath) : path7.resolve(cwd, nativePath);
-  const relative = path7.relative(resolvedCwd, resolvedPath);
-  const selected = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path7.sep}`) ? relative : resolvedPath;
+  const resolvedCwd = path8.resolve(cwd);
+  const resolvedPath = path8.isAbsolute(nativePath) ? path8.resolve(nativePath) : path8.resolve(cwd, nativePath);
+  const relative = path8.relative(resolvedCwd, resolvedPath);
+  const selected = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path8.sep}`) ? relative : resolvedPath;
   const normalized = selected.replaceAll("\\", "/");
   return validNativePath(normalized) && normalized !== "." ? normalized : null;
 }
@@ -43234,7 +43427,7 @@ function projectClaudeFileChange(value, cwd) {
     `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`,
     ...hunk.lines
   ]);
-  const absoluteDisplayPath = path7.posix.isAbsolute(normalizedPath);
+  const absoluteDisplayPath = path8.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");
@@ -43921,6 +44114,59 @@ var ClaudeNativeTurnAccumulator = class {
   }
 };
 
+// dist/process-fence.js
+import { execFile } from "node:child_process";
+import path9 from "node:path";
+import { setTimeout as setTimeout2 } from "node:timers/promises";
+import { promisify } from "node:util";
+var executeFile = promisify(execFile);
+function signalGroup(pid, signal) {
+  try {
+    process.kill(-pid, signal);
+    return true;
+  } catch (error52) {
+    if (error52.code === "ESRCH")
+      return false;
+    if (signal === 0 && error52.code === "EPERM")
+      return true;
+    throw error52;
+  }
+}
+async function closeClaudeProcessGroup(child, timeoutMs) {
+  const pid = child.pid;
+  if (!pid)
+    return;
+  if (process.platform === "win32") {
+    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 || !path9.win32.isAbsolute(root))
+      throw new Error("Windows SystemRoot is unavailable");
+    await executeFile(path9.win32.join(root, "System32", "taskkill.exe"), ["/PID", String(pid), "/T", "/F"], {
+      timeout: timeoutMs,
+      windowsHide: true
+    });
+    return;
+  }
+  if (!signalGroup(pid, "SIGTERM"))
+    return;
+  const gracefulDeadline = Date.now() + timeoutMs;
+  while (Date.now() < gracefulDeadline) {
+    if (!signalGroup(pid, 0))
+      return;
+    await setTimeout2(10);
+  }
+  if (!signalGroup(pid, "SIGKILL"))
+    return;
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!signalGroup(pid, 0))
+      return;
+    await setTimeout2(10);
+  }
+  throw new Error("Claude SDK process group did not exit");
+}
+
 // dist/sdk-transport.js
 var CLIENT_APP = "codexhost-claude-code-adapter/0.0.0";
 var APPROVAL_TITLE_MAX_LENGTH = 120;
@@ -44142,6 +44388,7 @@ var ClaudeSdkTransport = class {
   #provider;
   #query = null;
   #started = false;
+  #backgroundTasks = /* @__PURE__ */ new Set();
   constructor(options) {
     this.sessionId = options.sessionId;
     this.#cwd = options.cwd;
@@ -44261,7 +44508,7 @@ var ClaudeSdkTransport = class {
     return this.runTurn("/recap", userMessageId, onEvent);
   }
   runTurn(text, userMessageId, onEvent) {
-    if (!this.#started || !this.#query) {
+    if (this.#closePromise || !this.#started || !this.#query) {
       return Promise.reject(new Error("Claude SDK transport is not started"));
     }
     if (this.#active)
@@ -44416,25 +44663,56 @@ var ClaudeSdkTransport = class {
     }
   }
   async #close() {
+    const failures = [];
     if (this.#active)
       this.#closeInteractions(this.#active, "cancelled");
+    try {
+      const timeout = rejectAfter(this.#closeTimeoutMs, "Claude background tasks did not stop");
+      try {
+        await Promise.race([this.#stopBackgroundTasks(), timeout.promise]);
+      } finally {
+        timeout.cancel();
+      }
+    } catch (error52) {
+      failures.push(error52);
+    }
+    const stopOwnedProcesses = async () => {
+      const stopped = await Promise.allSettled(this.#children.map((child) => closeClaudeProcessGroup(child, this.#closeTimeoutMs)));
+      for (const result of stopped)
+        if (result.status === "rejected")
+          failures.push(result.reason);
+    };
+    if (process.platform === "win32")
+      await stopOwnedProcesses();
     this.#input.end();
-    this.#query?.close();
-    await Promise.race([
-      this.#consumeTask?.catch(() => void 0) ?? Promise.resolve(),
-      delay(this.#closeTimeoutMs)
-    ]);
-    for (const child of this.#children) {
-      if (!processExited(child))
-        child.kill("SIGTERM");
+    try {
+      this.#query?.close();
+    } catch (error52) {
+      failures.push(error52);
     }
-    await Promise.race([
-      Promise.all(this.#children.map((child) => this.#waitForExit(child))),
-      delay(this.#closeTimeoutMs)
-    ]);
-    for (const child of this.#children) {
-      if (!processExited(child))
-        child.kill("SIGKILL");
+    if (process.platform !== "win32")
+      await stopOwnedProcesses();
+    const exitTimeout = rejectAfter(this.#closeTimeoutMs, "Claude SDK process did not exit");
+    try {
+      await Promise.race([
+        Promise.all(this.#children.map((child) => this.#waitForExit(child))),
+        exitTimeout.promise
+      ]);
+    } catch (error52) {
+      failures.push(error52);
+    } finally {
+      exitTimeout.cancel();
+    }
+    const drainTimeout = rejectAfter(this.#closeTimeoutMs, "Claude SDK output did not drain");
+    try {
+      await Promise.race([
+        this.#consumeTask?.catch(() => void 0) ?? Promise.resolve(),
+        drainTimeout.promise
+      ]);
+    } catch (error52) {
+      failures.push(error52);
+    } finally {
+      drainTimeout.cancel();
     }
     this.#query = null;
     const active = this.#active;
@@ -44443,10 +44721,40 @@ var ClaudeSdkTransport = class {
     this.#idleAccumulator = null;
     this.#idleLive = false;
     active?.reject(new Error("Claude SDK transport closed"));
+    if (failures.length > 0)
+      throw new AggregateError(failures, "Claude SDK shutdown could not be confirmed");
+  }
+  async #stopBackgroundTasks() {
+    const requested = /* @__PURE__ */ new Set();
+    const deadline = Date.now() + this.#closeTimeoutMs;
+    while (this.#backgroundTasks.size > 0) {
+      if (Date.now() >= deadline || !this.#query)
+        throw new Error("Claude background tasks remain active");
+      for (const id of this.#backgroundTasks) {
+        if (requested.has(id))
+          continue;
+        requested.add(id);
+        await this.#query.stopTask(id);
+      }
+      if (this.#backgroundTasks.size > 0)
+        await delay(10);
+    }
+  }
+  #observeBackgroundTasks(message) {
+    if (!isRecord6(message) || message.type !== "system")
+      return;
+    if (message.subtype === "background_tasks_changed" && Array.isArray(message.tasks)) {
+      this.#backgroundTasks = new Set(message.tasks.flatMap((task) => isRecord6(task) && typeof task.task_id === "string" ? [task.task_id] : []));
+    } else if (message.subtype === "task_started" && typeof message.task_id === "string") {
+      this.#backgroundTasks.add(message.task_id);
+    } else if (message.subtype === "task_notification" && typeof message.task_id === "string" && ["completed", "failed", "stopped"].includes(String(message.status))) {
+      this.#backgroundTasks.delete(message.task_id);
+    }
   }
   async #consume(activeQuery) {
     try {
       for await (const message of activeQuery) {
+        this.#observeBackgroundTasks(message);
         const permissionMode = permissionModeFromMessage(message);
         if (permissionMode && permissionMode !== this.#permissionMode) {
           this.#permissionMode = permissionMode;
@@ -44518,7 +44826,8 @@ var ClaudeSdkTransport = class {
       env: options.env,
       signal: options.signal,
       stdio: ["pipe", "pipe", "pipe"],
-      windowsHide: true
+      windowsHide: true,
+      detached: process.platform !== "win32"
     });
     child.stderr.on("data", (chunk) => {
       this.#stderrTail = sanitizeDiagnosticTail(`${this.#stderrTail}${chunk.toString()}`);
@@ -45054,9 +45363,12 @@ function normalizedModel(model) {
 }
 function firstPartyPrice(model) {
   const value = normalizedModel(model);
-  if (/claude-opus-4-(5|6|7|8)(?:-|$)/u.test(value)) {
+  if (/claude-opus-(?:5|4-(?:5|6|7|8))(?:-|$)/u.test(value)) {
     return { input: 5, cacheWrite: 6.25, cacheRead: 0.5, output: 25 };
   }
+  if (/claude-fable-5(?:-1)?(?:-|$)/u.test(value)) {
+    return value.includes("fable-5-1") ? { input: 10, cacheWrite: 12.5, cacheRead: 0.25, output: 50 } : { input: 10, cacheWrite: 12.5, cacheRead: 1, output: 50 };
+  }
   if (/claude-opus-4-(0|1)(?:-|$)/u.test(value) || /claude-opus-4-2025/u.test(value)) {
     return { input: 15, cacheWrite: 18.75, cacheRead: 1.5, output: 75 };
   }
@@ -45322,6 +45634,10 @@ var ClaudeHarnessSession = class {
   #onClosed;
   #onPlanLimitObserved;
   #openMode;
+  #pendingSessions;
+  #pendingClaimed = false;
+  #submittedInput = false;
+  #startupTask = null;
   #randomUUID;
   #requestedModel;
   #requestedPermissionModeId;
@@ -45339,7 +45655,9 @@ var ClaudeHarnessSession = class {
   #readingHistory = false;
   #state;
   #statePublished = false;
+  #unpersistedMessageIds = [];
   #transport = null;
+  #hardCancelTask = null;
   #usageGeneration = 0;
   #latestUsage = null;
   #minimumContextUsedTokens = null;
@@ -45358,6 +45676,7 @@ var ClaudeHarnessSession = class {
   #continuationQuiescence = null;
   constructor(cwd, dependencies, closeTimeoutMs, onClosed, onPlanLimitObserved, options) {
     this.#cwd = cwd;
+    this.#pendingSessions = options.pendingSessions;
     const environment = options.environment;
     this.#createTransport = environment ? (input) => dependencies.createTransport({ ...input, environment }) : dependencies.createTransport;
     this.#randomUUID = dependencies.randomUUID;
@@ -45373,7 +45692,7 @@ var ClaudeHarnessSession = class {
     this.#sessionId = options.sessionId;
     this.#toolOutputLimit = options.toolOutputLimit;
     this.#continuationQuiescenceMs = options.continuationQuiescenceMs;
-    this.#nativeRef = nativeSessionRefSchema.parse({
+    this.#nativeRef = options.nativeRef ?? nativeSessionRefSchema.parse({
       harnessId: this.harnessId,
       nativeSessionId: this.#sessionId,
       formatVersion: 1
@@ -45382,9 +45701,17 @@ var ClaudeHarnessSession = class {
       list: async () => ({ ok: true, value: claudeCommandCatalog }),
       execute: (command) => this.#executeHarnessCommand(command)
     };
-    this.initialState = this.#openMode === "resume" ? { nativeRef: this.#nativeRef } : {};
+    const durable = this.#openMode === "resume" || options.nativeRef !== void 0;
+    this.initialState = durable ? {
+      nativeRef: this.#nativeRef,
+      ...options.knownConfiguration ? {
+        ...options.requestedModel ? { effectiveModel: options.requestedModel } : {},
+        effectiveThinkingOptionId: this.#requestedThinkingOptionId,
+        effectivePermissionModeId: this.#requestedPermissionModeId
+      } : {}
+    } : {};
     this.#state = this.initialState;
-    this.#statePublished = this.#openMode === "resume";
+    this.#statePublished = durable;
     this.outputs = this.#channel.outputs;
   }
   async readSnapshot() {
@@ -45407,7 +45734,29 @@ var ClaudeHarnessSession = class {
     try {
       let messages;
       try {
-        messages = await this.#readSessionMessages({ cwd: this.#cwd, sessionId: this.#sessionId });
+        const deadline = Date.now() + this.#closeTimeoutMs;
+        for (; ; ) {
+          messages = await this.#readSessionMessages({
+            cwd: this.#cwd,
+            sessionId: this.#sessionId
+          });
+          const ids = new Set(messages.flatMap((message) => isRecord9(message) && typeof message.uuid === "string" ? [message.uuid] : []));
+          if (this.#unpersistedMessageIds.every((id) => ids.has(id))) {
+            this.#unpersistedMessageIds = [];
+            break;
+          }
+          if (Date.now() >= deadline || this.#phase !== "open") {
+            return {
+              ok: false,
+              error: {
+                code: "sessionBusy",
+                message: "Claude Code history is still being persisted",
+                retryable: true
+              }
+            };
+          }
+          await delay2(25);
+        }
       } catch {
         return {
           ok: false,
@@ -45418,6 +45767,22 @@ var ClaudeHarnessSession = class {
           }
         };
       }
+      if (messages.length === 0 && isPendingClaudeSession(this.#nativeRef)) {
+        try {
+          const pending = await this.#pendingSessions.read(this.#nativeRef, this.#cwd);
+          if (!pending.started)
+            return { ok: true, value: { turns: [], state: this.#state } };
+        } catch {
+          return {
+            ok: false,
+            error: {
+              code: "sessionNotFound",
+              message: "Claude Code pending Session is unavailable",
+              retryable: false
+            }
+          };
+        }
+      }
       if (messages.length === 0) {
         return {
           ok: false,
@@ -45548,6 +45913,7 @@ var ClaudeHarnessSession = class {
       resolveCompletion
     };
     this.#active = active;
+    this.#submittedInput = true;
     this.#event({ type: "turn.started", turnId: command.turnId });
     this.#event({ type: "item.started", turnId: command.turnId, item });
     try {
@@ -45651,6 +46017,7 @@ var ClaudeHarnessSession = class {
       resolveCompletion
     };
     this.#active = active;
+    this.#submittedInput = true;
     this.#event({ type: "turn.started", turnId: command.turnId });
     if (item)
       this.#event({ type: "item.started", turnId: command.turnId, item });
@@ -45672,6 +46039,12 @@ var ClaudeHarnessSession = class {
     this.#requestContextUsage(this.#transport, this.#active?.command.turnId, CONTEXT_USAGE_RETRY_DELAYS_MS);
     return this.#contextRefreshInFlight ?? Promise.resolve();
   }
+  blocksRollback(sessionId) {
+    return this.#sessionId === sessionId && (this.#phase !== "open" || this.#active !== null || this.#acceptingTurn || this.#configurationTask !== null || this.#readingHistory);
+  }
+  async prepareRollback(sessionId) {
+    return this.#sessionId === sessionId ? this.readSnapshot() : { ok: true, value: null };
+  }
   close() {
     if (!this.#closePromise)
       this.#closePromise = this.#close();
@@ -45725,6 +46098,9 @@ var ClaudeHarnessSession = class {
         }
       }
       this.#requestedModel = command.model;
+      const persistenceError = await this.#savePendingConfiguration();
+      if (persistenceError)
+        return { ok: false, error: persistenceError };
       this.#publishState(this.#configuredState());
       return { ok: true, value: { completed: true } };
     } finally {
@@ -45780,6 +46156,9 @@ var ClaudeHarnessSession = class {
         }
       }
       this.#requestedThinkingOptionId = thinkingOptionId;
+      const persistenceError = await this.#savePendingConfiguration();
+      if (persistenceError)
+        return { ok: false, error: persistenceError };
       this.#publishState(this.#configuredState());
       return { ok: true, value: { completed: true } };
     } finally {
@@ -45836,6 +46215,9 @@ var ClaudeHarnessSession = class {
         }
       }
       this.#requestedPermissionModeId = transport ? encodeClaudePermissionModeId(transport.getPermissionMode()) : command.permissionModeId;
+      const persistenceError = await this.#savePendingConfiguration();
+      if (persistenceError)
+        return { ok: false, error: persistenceError };
       this.#publishState(this.#configuredState());
       return { ok: true, value: { completed: true } };
     } finally {
@@ -45968,6 +46350,7 @@ var ClaudeHarnessSession = class {
   async #close() {
     if (this.#phase === "closed")
       return;
+    this.#phase = "closing";
     this.#usageGeneration += 1;
     this.#contextUsageFreshUntilMs = 0;
     this.#contextUsageCooldownUntilMs = 0;
@@ -45977,78 +46360,133 @@ var ClaudeHarnessSession = class {
     this.#contextRefreshWake = null;
     this.#clearCancelEscalation();
     this.#clearContinuationQuiescence();
-    if (this.#phase !== "faulted")
-      this.#phase = "closing";
-    const configurationTask = this.#configurationTask;
-    if (configurationTask) {
-      await Promise.race([configurationTask, delay2(this.#closeTimeoutMs)]);
-    }
-    let transportClosed = false;
-    const active = this.#active;
-    if (active) {
-      active.cancellationRequested = true;
-      if (active.held) {
-        this.#finishFailed(active, invalidState("Claude Code Session closed during active Turn"));
-      } else {
-        await this.#transport?.abort().catch(() => void 0);
-        await Promise.race([active.completion, delay2(this.#closeTimeoutMs)]);
-        if (this.#active === active) {
-          await this.#transport?.close().catch(() => void 0);
-          transportClosed = true;
-          this.#finishFailed(active, invalidState("Claude Code Session closed during active Turn"));
-        }
+    const failures = [];
+    const settle = async (task) => {
+      if (!task)
+        return;
+      const timeout = rejectAfter2(this.#closeTimeoutMs * 4, "Claude Code Session close timed out");
+      try {
+        await Promise.race([task, timeout.promise]);
+      } catch (error52) {
+        failures.push(error52);
+      } finally {
+        timeout.cancel();
       }
-    }
-    if (!transportClosed)
-      await this.#transport?.close().catch(() => void 0);
+    };
+    const closingTransport = this.#transport;
+    await settle(closingTransport?.close());
+    await settle(this.#configurationTask ?? void 0);
+    await settle(this.#startupTask?.then(() => void 0, () => void 0));
+    if (this.#transport !== closingTransport)
+      await settle(this.#transport?.close());
+    if (failures.length === 0)
+      await settle(this.#releaseUnusedClaim());
+    const active = this.#active;
+    if (active)
+      this.#finishFailed(active, invalidState("Claude Code Session closed during active Turn"));
     this.#phase = "closed";
     this.#channel.end();
     this.#onClosed();
+    if (failures.length > 0)
+      throw new AggregateError(failures, "Claude Code Session could not stop safely");
   }
-  async #ensureTransport() {
+  #ensureTransport() {
+    if (this.#startupTask)
+      return this.#startupTask;
     if (this.#transport)
-      return this.#transport;
+      return Promise.resolve(this.#transport);
+    const task = this.#startTransport();
+    this.#startupTask = task;
+    void task.finally(() => {
+      if (this.#startupTask === task)
+        this.#startupTask = null;
+    }).catch(() => void 0);
+    return task;
+  }
+  async #startTransport() {
+    if (this.#openMode === "create" && isPendingClaudeSession(this.#nativeRef)) {
+      await this.#pendingSessions.claim(this.#nativeRef, this.#cwd);
+      this.#pendingClaimed = true;
+    }
+    if (this.#phase !== "open") {
+      await this.#releaseUnusedClaim();
+      throw new Error("Claude Code Session closed during startup");
+    }
     const selectedModel = this.#requestedModel ?? (this.#openMode === "create" ? CLAUDE_DEFAULT_MODEL_REF : void 0);
     const model = selectedModel ? decodeClaudeModelRef(selectedModel) : void 0;
     const permissionMode = decodeClaudePermissionModeId(this.#requestedPermissionModeId);
-    const transport = this.#createTransport({
-      cwd: this.#cwd,
-      sessionId: this.#sessionId,
-      openMode: this.#openMode,
-      ...model ? { model } : {},
-      thinkingOptionId: this.#requestedThinkingOptionId,
-      permissionMode,
-      onPermissionModeChanged: (mode) => this.#handlePermissionModeChanged(mode),
-      onFault: () => this.#fault(faultError()),
-      onPlanLimit: (planLimit) => this.#handlePlanLimit(planLimit)
-    });
-    transport.setAutonomousTurnHandler((turn) => this.#handleAutonomousTurn(turn));
-    transport.setIdleTurnHandler({
-      onEvent: (event) => {
-        const active = this.#active;
-        if (active)
-          this.#handleTurnEvent(active, event);
-      },
-      onTerminal: (result) => {
-        const active = this.#active;
-        if (active)
-          this.#finishResult(active, result);
-      }
-    });
+    let transport;
     try {
+      transport = this.#createTransport({
+        cwd: this.#cwd,
+        sessionId: this.#sessionId,
+        openMode: this.#openMode,
+        ...model ? { model } : {},
+        thinkingOptionId: this.#requestedThinkingOptionId,
+        permissionMode,
+        onPermissionModeChanged: (mode) => this.#handlePermissionModeChanged(mode),
+        onFault: () => this.#fault(faultError()),
+        onPlanLimit: (planLimit) => this.#handlePlanLimit(planLimit)
+      });
+      this.#transport = transport;
+      transport.setAutonomousTurnHandler((turn) => this.#handleAutonomousTurn(turn));
+      transport.setIdleTurnHandler({
+        onEvent: (event) => {
+          const active = this.#active;
+          if (active)
+            this.#handleTurnEvent(active, event);
+        },
+        onTerminal: (result) => {
+          const active = this.#active;
+          if (active)
+            this.#finishResult(active, result);
+        }
+      });
       await transport.start();
       this.#state = {
         ...this.#configuredState(true),
         effectivePermissionModeId: encodeClaudePermissionModeId(transport.getPermissionMode())
       };
     } catch (error52) {
-      await transport.close().catch(() => void 0);
+      try {
+        await this.#transport?.close();
+      } catch (closeError) {
+        this.#fault(faultError());
+        throw closeError;
+      }
+      this.#transport = null;
+      await this.#releaseUnusedClaim();
       throw error52;
     }
     this.#openMode = "resume";
     this.#transport = transport;
     return transport;
   }
+  async #releaseUnusedClaim() {
+    if (!this.#pendingClaimed || this.#submittedInput)
+      return;
+    await this.#pendingSessions.release(this.#nativeRef, this.#cwd);
+    this.#pendingClaimed = false;
+    this.#openMode = "create";
+  }
+  async #savePendingConfiguration() {
+    if (!isPendingClaudeSession(this.#nativeRef))
+      return null;
+    const configuration = { ...this.#configuredState() };
+    delete configuration.nativeRef;
+    try {
+      await this.#pendingSessions.saveConfiguration(this.#nativeRef, this.#cwd, configuration);
+      return null;
+    } catch {
+      const error52 = {
+        code: "nativeFailure",
+        message: "Claude Code pending configuration could not be persisted",
+        retryable: false
+      };
+      this.#fault(error52);
+      return error52;
+    }
+  }
   #configuredState(nativeReady = this.#state.nativeRef !== void 0) {
     const effectiveModel = this.#requestedModel ?? (this.#openMode === "create" ? CLAUDE_DEFAULT_MODEL_REF : this.#state.effectiveModel);
     return {
@@ -46494,7 +46932,7 @@ var ClaudeHarnessSession = class {
     }
   }
   #finishResult(active, result) {
-    if (this.#active !== active)
+    if (this.#active !== active || this.#hardCancelTask)
       return;
     if (result.status === "succeeded" && (active.tools.size > 0 || active.subagents.size > 0)) {
       this.#finishFailed(active, transportFailure("protocol"));
@@ -46787,6 +47225,12 @@ var ClaudeHarnessSession = class {
       checkpointId: active.checkpointId,
       formatVersion: 1
     }) : null;
+    this.#unpersistedMessageIds = [
+      .../* @__PURE__ */ new Set([
+        ...active.nativeTurnRef ? [active.nativeTurnRef.nativeTurnKey] : [],
+        ...active.checkpointId ? [active.checkpointId] : []
+      ])
+    ];
     this.#event({
       type: "turn.completed",
       turnId: active.command.turnId,
@@ -46825,14 +47269,19 @@ var ClaudeHarnessSession = class {
     this.#cancelEscalation = null;
   }
   #hardCancel(active) {
-    if (this.#active !== active)
+    if (this.#active !== active || this.#hardCancelTask)
       return;
     this.#clearCancelEscalation();
     const transport = this.#transport;
-    this.#transport = null;
-    this.#openMode = "resume";
-    this.#finish(active, { status: "cancelled", reason: "Cancelled by user" });
-    void transport?.close().catch(() => void 0);
+    this.#hardCancelTask = Promise.resolve().then(() => transport?.close()).then(() => {
+      if (this.#phase !== "open" || this.#active !== active)
+        return;
+      this.#transport = null;
+      this.#openMode = "resume";
+      this.#finish(active, { status: "cancelled", reason: "Cancelled by user" });
+    }, () => this.#fault(faultError())).finally(() => {
+      this.#hardCancelTask = null;
+    });
   }
   #fault(error52) {
     if (this.#phase === "closed" || this.#phase === "closing" || this.#phase === "faulted")
@@ -46851,8 +47300,7 @@ var ClaudeHarnessSession = class {
     this.#phase = "faulted";
     this.#event({ type: "session.faulted", error: error52 });
     this.#channel.end();
-    void this.#transport?.close();
-    this.#onClosed();
+    void this.#transport?.close().catch(() => void 0);
   }
   #event(event) {
     this.#channel.emit({ kind: "event", event });
@@ -46904,6 +47352,7 @@ var ClaudeCodeAdapter = class {
   #cancelTimeoutMs;
   #closeTimeoutMs;
   #dependencies;
+  #pendingSessions;
   #toolOutputLimit;
   #continuationQuiescenceMs;
   #inspectionCache = /* @__PURE__ */ new Map();
@@ -46914,6 +47363,7 @@ var ClaudeCodeAdapter = class {
   #latestPlanLimit = null;
   #accountInspection = null;
   constructor(options = {}, dependencies) {
+    this.#pendingSessions = new ClaudePendingSessions(options.environment ?? process.env);
     this.#closeTimeoutMs = options.closeTimeoutMs ?? DEFAULT_CLOSE_TIMEOUT_MS;
     this.#cancelTimeoutMs = options.cancelTimeoutMs ?? DEFAULT_CANCEL_TIMEOUT_MS;
     if (!Number.isSafeInteger(this.#cancelTimeoutMs) || this.#cancelTimeoutMs <= 0) {
@@ -46928,7 +47378,7 @@ var ClaudeCodeAdapter = class {
       throw new RangeError("Claude Code continuation quiescence must be a positive safe integer");
     }
     this.#dependencies = dependencies ?? {
-      randomUUID: randomUUID2,
+      randomUUID: randomUUID3,
       inspectInstallation: () => {
         resolveClaudeCodeExecutable({
           ...options.command ? { command: options.command } : {},
@@ -46974,7 +47424,7 @@ var ClaudeCodeAdapter = class {
         error: invalidState("Claude Code Adapter is closing")
       };
     }
-    const cwd = path8.resolve(input.cwd ?? process.cwd());
+    const cwd = path10.resolve(input.cwd ?? process.cwd());
     if (!input.refresh) {
       const cached2 = this.#inspectionCache.get(cwd);
       if (cached2)
@@ -47103,79 +47553,18 @@ var ClaudeCodeAdapter = class {
         }
       };
     }
-    let rollback;
-    if (input.kind === "rollbackLastTurn") {
-      const sourceRef = nativeSessionRefSchema.safeParse(input.sourceRef);
-      if (!sourceRef.success || sourceRef.data.harnessId !== this.harnessId) {
-        return {
-          ok: false,
-          error: {
-            code: "invalidRequest",
-            message: "Claude Code cannot roll back another Harness's Native Session",
-            retryable: false
-          }
-        };
-      }
-      let sourceSnapshot;
-      try {
-        const messages = await this.#dependencies.readSessionMessages({
-          cwd: path8.resolve(input.cwd),
-          sessionId: sourceRef.data.nativeSessionId
-        });
-        sourceSnapshot = mapClaudeSnapshot(messages, sourceRef.data.nativeSessionId);
-      } catch {
-        return {
-          ok: false,
-          error: {
-            code: "nativeFailure",
-            message: "Claude Code history could not be read",
-            retryable: true
-          }
-        };
-      }
-      if (sourceSnapshot.turns.length === 0) {
-        return {
-          ok: false,
-          error: {
-            code: "invalidState",
-            message: "Claude Code Native Session has no Turn to roll back",
-            retryable: false
-          }
-        };
-      }
-      const retained = sourceSnapshot.turns.at(-2);
-      if (!retained) {
-        rollback = {
-          openMode: "create",
-          sessionId: this.#dependencies.randomUUID()
-        };
-      } else if (!retained.checkpoint?.checkpointId) {
-        return {
-          ok: false,
-          error: {
-            code: "checkpointNotFound",
-            message: "Claude Code last-Turn rollback boundary is unavailable",
-            retryable: false
-          }
-        };
-      } else {
-        const forked2 = await forkClaudeSession({
-          checkpoint: retained.checkpoint,
-          cwd: path8.resolve(input.cwd),
-          dependencies: this.#dependencies,
-          harnessId: this.harnessId,
-          sourceRef: sourceRef.data
-        });
-        if (!forked2.ok)
-          return forked2;
-        rollback = {
-          openMode: "resume",
-          sessionId: forked2.value.sessionId
-        };
-      }
+    if (input.kind === "rollbackLastTurn" && [...this.#sessions].some((session2) => session2.blocksRollback(input.sourceRef.nativeSessionId))) {
+      return {
+        ok: false,
+        error: {
+          code: "sessionBusy",
+          message: "Claude Code Session is busy during rollback",
+          retryable: true
+        }
+      };
     }
     let requestedThinkingOptionId = CLAUDE_DEFAULT_THINKING_OPTION_ID;
-    if (input.kind === "create" && input.thinkingOptionId) {
+    if ((input.kind === "create" || input.kind === "rollbackLastTurn" || input.kind === "resume") && input.thinkingOptionId) {
       try {
         requestedThinkingOptionId = parseClaudeThinkingOptionId(input.thinkingOptionId);
       } catch {
@@ -47189,7 +47578,7 @@ var ClaudeCodeAdapter = class {
         };
       }
     }
-    if (input.kind === "create" && input.model) {
+    if ((input.kind === "create" || input.kind === "rollbackLastTurn" || input.kind === "resume") && input.model) {
       try {
         decodeClaudeModelRef(input.model);
       } catch {
@@ -47203,7 +47592,7 @@ var ClaudeCodeAdapter = class {
         };
       }
     }
-    const requestedPermissionModeId = input.kind === "create" ? input.permissionModeId ?? (input.executionPolicy === "unattended-full-access" ? encodeClaudePermissionModeId("auto") : CLAUDE_DEFAULT_PERMISSION_MODE_ID) : CLAUDE_DEFAULT_PERMISSION_MODE_ID;
+    let requestedPermissionModeId = input.kind === "create" ? input.permissionModeId ?? (input.executionPolicy === "unattended-full-access" ? encodeClaudePermissionModeId("auto") : CLAUDE_DEFAULT_PERMISSION_MODE_ID) : input.kind === "rollbackLastTurn" || input.kind === "resume" ? input.permissionModeId ?? CLAUDE_DEFAULT_PERMISSION_MODE_ID : CLAUDE_DEFAULT_PERMISSION_MODE_ID;
     try {
       decodeClaudePermissionModeId(requestedPermissionModeId);
     } catch {
@@ -47216,7 +47605,14 @@ var ClaudeCodeAdapter = class {
         }
       };
     }
-    const cwd = path8.resolve(input.cwd);
+    const cwd = path10.resolve(input.cwd);
+    if (input.kind === "rollbackLastTurn") {
+      for (const source of this.#sessions) {
+        const ready = await source.prepareRollback(input.sourceRef.nativeSessionId);
+        if (!ready.ok)
+          return ready;
+      }
+    }
     const nativeRef = input.kind === "resume" ? nativeSessionRefSchema.safeParse(input.nativeRef) : null;
     if (nativeRef && (!nativeRef.success || nativeRef.data.harnessId !== this.harnessId)) {
       return {
@@ -47228,8 +47624,16 @@ var ClaudeCodeAdapter = class {
         }
       };
     }
-    const forked = input.kind === "fork" ? await forkClaudeSession({
-      checkpoint: input.checkpoint,
+    const forked = input.kind === "fork" || input.kind === "rollbackLastTurn" ? await forkClaudeSession({
+      ...input.kind === "fork" ? { kind: "fork", checkpoint: input.checkpoint } : {
+        kind: "rollbackLastTurn",
+        pendingSessions: this.#pendingSessions,
+        configuration: {
+          ...input.model ? { effectiveModel: input.model } : {},
+          effectiveThinkingOptionId: requestedThinkingOptionId,
+          effectivePermissionModeId: requestedPermissionModeId
+        }
+      },
       cwd,
       dependencies: this.#dependencies,
       harnessId: this.harnessId,
@@ -47237,11 +47641,49 @@ var ClaudeCodeAdapter = class {
     }) : null;
     if (forked && !forked.ok)
       return forked;
+    const durableRef = forked?.ok ? forked.value.nativeRef : nativeRef?.success ? nativeRef.data : void 0;
+    let openMode = forked?.ok && forked.value.openMode === "create" || input.kind === "create" ? "create" : "resume";
+    let requestedModel = input.kind !== "fork" ? input.model : void 0;
+    if (durableRef && isPendingClaudeSession(durableRef)) {
+      try {
+        const pending = await this.#pendingSessions.read(durableRef, cwd);
+        if (!pending.started) {
+          const messages = await this.#dependencies.readSessionMessages({
+            cwd,
+            sessionId: durableRef.nativeSessionId
+          });
+          if (messages.length > 0 || input.kind === "resume" && input.knownTurnRefs?.length)
+            throw new Error("Pending Session unexpectedly contains history");
+          openMode = "create";
+        }
+        if (pending.configuration.effectiveModel)
+          decodeClaudeModelRef(pending.configuration.effectiveModel);
+        if (pending.configuration.effectiveThinkingOptionId)
+          parseClaudeThinkingOptionId(pending.configuration.effectiveThinkingOptionId);
+        if (pending.configuration.effectivePermissionModeId)
+          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;
+      } catch {
+        return {
+          ok: false,
+          error: {
+            code: "sessionNotFound",
+            message: "Claude Code pending Session cannot be recovered",
+            retryable: false
+          }
+        };
+      }
+    }
     const session = new ClaudeHarnessSession(cwd, this.#dependencies, this.#closeTimeoutMs, () => this.#sessions.delete(session), (planLimit) => this.#recordPlanLimit(session, planLimit), {
       ...input.environment ? { environment: input.environment } : {},
-      openMode: rollback?.openMode ?? (input.kind === "create" ? "create" : "resume"),
-      sessionId: rollback?.sessionId ?? (forked?.ok ? forked.value.sessionId : nativeRef?.success ? nativeRef.data.nativeSessionId : this.#dependencies.randomUUID()),
-      ...input.kind === "create" && input.model ? { requestedModel: input.model } : {},
+      openMode,
+      pendingSessions: this.#pendingSessions,
+      knownConfiguration: input.kind === "rollbackLastTurn" || input.kind === "resume" && Boolean(input.model || input.thinkingOptionId) || Boolean(durableRef && isPendingClaudeSession(durableRef)),
+      ...durableRef ? { nativeRef: durableRef } : {},
+      sessionId: forked?.ok ? forked.value.sessionId : nativeRef?.success ? nativeRef.data.nativeSessionId : this.#dependencies.randomUUID(),
+      ...requestedModel ? { requestedModel } : {},
       requestedPermissionModeId,
       requestedThinkingOptionId,
       toolOutputLimit: this.#toolOutputLimit,
@@ -47284,7 +47726,7 @@ var ClaudeCodeAdapter = class {
 };
 
 // dist/user-shell-environment.js
-import path9 from "node:path";
+import path11 from "node:path";
 import { spawnSync } 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";
@@ -47327,7 +47769,7 @@ function withUserShellEnvironment(environment, dependencies) {
   if (platform === "win32" || !environment.HOME)
     return environment;
   const shell = environment.SHELL?.trim() || defaultShell(platform);
-  if (!shell || !SUPPORTED_SHELLS.has(path9.basename(shell)))
+  if (!shell || !SUPPORTED_SHELLS.has(path11.basename(shell)))
     return environment;
   const cacheKey = `${platform}\0${shell}\0${environment.HOME}`;
   const cached2 = dependencies ? void 0 : shellEnvironmentCache.get(cacheKey);