@liberseek/boft-cli-win32-arm64 0.6.4 → 0.6.6

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, path12) {
-  if (!path12)
+function getElementAtPath(obj, path14) {
+  if (!path14)
     return obj;
-  return path12.reduce((acc, key) => acc?.[key], obj);
+  return path14.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(path12, issues) {
+function prefixIssues(path14, issues) {
   return issues.map((iss) => {
     var _a4;
     (_a4 = iss).path ?? (_a4.path = []);
-    iss.path.unshift(path12);
+    iss.path.unshift(path14);
     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, path12 = []) => {
+  const processError = (error53, path14 = []) => {
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path12, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path14, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
       } else {
-        const fullpath = [...path12, ...issue2.path];
+        const fullpath = [...path14, ...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, path12 = []) => {
+  const processError = (error53, path14 = []) => {
     var _a4, _b2;
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path12, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path14, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path12, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
       } else {
-        const fullpath = [...path12, ...issue2.path];
+        const fullpath = [...path14, ...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 path12 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path12) {
+  const path14 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path14) {
     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 path12 = ref.slice(1).split("/").filter(Boolean);
-  if (path12.length === 0) {
+  const path14 = ref.slice(1).split("/").filter(Boolean);
+  if (path14.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path12[0] === defsKey) {
-    const key = path12[1];
+  if (path14[0] === defsKey) {
+    const key = path14[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -15525,6 +15525,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)) {
@@ -15710,6 +15716,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()
@@ -15722,6 +15730,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();
@@ -16431,8 +16442,8 @@ var BrokeredHarnessAdapter = class {
 };
 
 // dist/claude-code-adapter.js
-import { randomUUID as randomUUID2 } from "node:crypto";
-import path10 from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
+import path12 from "node:path";
 
 // ../../../node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
 import { createRequire as DW } from "node:module";
@@ -20339,8 +20350,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];
@@ -20348,11 +20359,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) {
@@ -42589,8 +42600,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
@@ -42680,9 +42819,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");
@@ -42694,13 +42843,19 @@ 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,
       timestampMs: isoToMs(value.timestamp),
-      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;
 }
@@ -42708,6 +42863,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) {
@@ -42755,7 +42912,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);
     const startedAtMs = turnMessages[0]?.timestampMs;
     const completedAtMs = turnMessages.at(-1)?.timestampMs;
     let agentMessageOrdinal = 0;
@@ -43099,6 +43256,7 @@ function comparableTurn(turn) {
       outcome
     })),
     outcome: turn.outcome,
+    hasCheckpoint: turn.checkpoint !== void 0,
     ...turn.model ? { model: turn.model } : {}
   };
 }
@@ -43135,8 +43293,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)
@@ -43165,7 +43323,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)
@@ -43174,8 +43332,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)
@@ -43184,7 +43373,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
     });
@@ -43223,7 +43412,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,
@@ -43234,8 +43423,8 @@ async function forkClaudeSession(input) {
 }
 
 // dist/claude-session-import.js
-import { realpath, stat } from "node:fs/promises";
-import path6 from "node:path";
+import { realpath, stat as stat2 } from "node:fs/promises";
+import path7 from "node:path";
 function titleFromMetadata(metadata) {
   for (const value of [metadata.customTitle, metadata.summary, metadata.firstPrompt]) {
     if (typeof value !== "string")
@@ -43257,14 +43446,14 @@ async function sourceFromMetadata(metadata, isRunning, signal, canonicalCwds, pr
   ];
   let cwd = null;
   for (const candidate2 of new Set(candidates)) {
-    if (!path6.isAbsolute(candidate2))
+    if (!path7.isAbsolute(candidate2))
       continue;
     let canonical = canonicalCwds.get(candidate2);
     if (!canonical) {
       canonical = (async () => {
         try {
           const resolved = await realpath(candidate2);
-          return (await stat(resolved)).isDirectory() ? resolved : null;
+          return (await stat2(resolved)).isDirectory() ? resolved : null;
         } catch {
           return null;
         }
@@ -43334,7 +43523,7 @@ var ClaudeSessionImportIndex = class {
     if (!metadata || metadata.sessionId !== nativeSessionId)
       return null;
     const preferredCwds = [];
-    if (typeof metadata.cwd === "string" && path6.isAbsolute(metadata.cwd)) {
+    if (typeof metadata.cwd === "string" && path7.isAbsolute(metadata.cwd)) {
       try {
         const messages = await this.#dependencies.readSessionMessages({
           cwd: metadata.cwd,
@@ -43347,7 +43536,7 @@ var ClaudeSessionImportIndex = class {
             continue;
           }
           const cwd = message.cwd;
-          if (path6.isAbsolute(cwd) && !preferredCwds.includes(cwd))
+          if (path7.isAbsolute(cwd) && !preferredCwds.includes(cwd))
             preferredCwds.push(cwd);
         }
       } catch {
@@ -43358,25 +43547,25 @@ var ClaudeSessionImportIndex = class {
 };
 
 // dist/claude-transcript.js
-import os3 from "node:os";
-import path7 from "node:path";
-import { readFile as readFile2, readdir, stat as stat2 } from "node:fs/promises";
+import os4 from "node:os";
+import path8 from "node:path";
+import { readFile as readFile3, 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 ? path7.resolve(environment.CLAUDE_CONFIG_DIR) : path7.join(os3.homedir(), ".claude");
+  return environment.CLAUDE_CONFIG_DIR ? path8.resolve(environment.CLAUDE_CONFIG_DIR) : path8.join(os4.homedir(), ".claude");
 }
 async function existingFile(file2) {
   try {
-    return (await stat2(file2)).isFile();
+    return (await stat3(file2)).isFile();
   } catch {
     return false;
   }
 }
 async function findTranscriptFile(environment, cwd, relativeName) {
-  const projectsDirectory = path7.join(configDirectory(environment), "projects");
-  const expected = path7.join(projectsDirectory, projectDirectoryName(cwd), relativeName);
+  const projectsDirectory = path8.join(configDirectory(environment), "projects");
+  const expected = path8.join(projectsDirectory, projectDirectoryName(cwd), relativeName);
   if (await existingFile(expected))
     return expected;
   let projects;
@@ -43386,7 +43575,7 @@ async function findTranscriptFile(environment, cwd, relativeName) {
     return null;
   }
   for (const project of projects) {
-    const candidate = path7.join(projectsDirectory, project, relativeName);
+    const candidate = path8.join(projectsDirectory, project, relativeName);
     if (await existingFile(candidate))
       return candidate;
   }
@@ -43417,14 +43606,14 @@ async function readClaudeTranscript(input) {
   const transcript = await findTranscriptFile(input.environment, input.cwd, `${input.sessionId}.jsonl`);
   if (!transcript)
     return null;
-  return parseTranscriptRecords(await readFile2(transcript, "utf8"), input.sessionId);
+  return parseTranscriptRecords(await readFile3(transcript, "utf8"), input.sessionId);
 }
 async function readClaudeSubagentTranscript(input) {
-  const relativeName = path7.join(input.sessionId, "subagents", `agent-${input.nativeSubagentId}.jsonl`);
+  const relativeName = path8.join(input.sessionId, "subagents", `agent-${input.nativeSubagentId}.jsonl`);
   const transcript = await findTranscriptFile(input.environment, input.cwd, relativeName);
   if (!transcript)
     return null;
-  return parseTranscriptRecords(await readFile2(transcript, "utf8"), input.sessionId);
+  return parseTranscriptRecords(await readFile3(transcript, "utf8"), input.sessionId);
 }
 
 // dist/model-catalog.js
@@ -43686,8 +43875,8 @@ function projectClaudeAccountUsage(usage, account) {
 }
 
 // dist/gateway-models.js
-import { readFile as readFile3 } from "node:fs/promises";
-import path8 from "node:path";
+import { readFile as readFile4 } from "node:fs/promises";
+import path9 from "node:path";
 var GATEWAY_MODELS_TIMEOUT_MS = 3e3;
 var GATEWAY_MODELS_MAX_BYTES = 2 * 1024 * 1024;
 var OFFICIAL_ANTHROPIC_HOST = "api.anthropic.com";
@@ -43729,14 +43918,14 @@ function claudeConfigDirectory(environment) {
   if (configured)
     return configured;
   const home = trimmedEnv(environment, "HOME") ?? trimmedEnv(environment, "USERPROFILE");
-  return home ? path8.join(home, ".claude") : void 0;
+  return home ? path9.join(home, ".claude") : void 0;
 }
 async function readClaudeUserSettingsEnv(environment) {
   const configDir = claudeConfigDirectory(environment);
   if (!configDir)
     return {};
   try {
-    const raw = await readFile3(path8.join(configDir, "settings.json"), "utf8");
+    const raw = await readFile4(path9.join(configDir, "settings.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
       return {};
@@ -43868,7 +44057,7 @@ async function applyGatewayModelCatalog(snapshot, environment, dependencies = {}
 }
 
 // dist/file-change.js
-import path9 from "node:path";
+import path10 from "node:path";
 var hunkSchema = external_exports.object({
   oldStart: external_exports.number().int().nonnegative(),
   oldLines: external_exports.number().int().nonnegative(),
@@ -43916,10 +44105,10 @@ function parseClaudeNativeFileChange(toolName, value) {
   };
 }
 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 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;
 }
@@ -43931,7 +44120,7 @@ function projectClaudeFileChange(value, cwd) {
     `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`,
     ...hunk.lines
   ]);
-  const absoluteDisplayPath = path9.posix.isAbsolute(normalizedPath);
+  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");
@@ -44625,6 +44814,59 @@ var ClaudeNativeTurnAccumulator = class {
   }
 };
 
+// dist/process-fence.js
+import { execFile } from "node:child_process";
+import path11 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 || !path11.win32.isAbsolute(root))
+      throw new Error("Windows SystemRoot is unavailable");
+    await executeFile(path11.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;
@@ -44875,6 +45117,7 @@ var ClaudeSdkTransport = class {
   #provider;
   #query = null;
   #started = false;
+  #backgroundTasks = /* @__PURE__ */ new Set();
   constructor(options) {
     this.sessionId = options.sessionId;
     this.#cwd = options.cwd;
@@ -44994,7 +45237,7 @@ var ClaudeSdkTransport = class {
     return this.runTurn("/recap", userMessageId, onEvent);
   }
   runTurn(input, 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)
@@ -45149,25 +45392,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;
@@ -45176,10 +45450,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;
@@ -45256,7 +45560,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()}`);
@@ -46071,6 +46376,10 @@ var ClaudeHarnessSession = class {
   #onClosed;
   #onPlanLimitObserved;
   #openMode;
+  #pendingSessions;
+  #pendingClaimed = false;
+  #submittedInput = false;
+  #startupTask = null;
   #randomUUID;
   #requestedModel;
   #requestedPermissionModeId;
@@ -46088,7 +46397,9 @@ var ClaudeHarnessSession = class {
   #readingHistory = false;
   #state;
   #statePublished = false;
+  #unpersistedMessageIds = [];
   #transport = null;
+  #hardCancelTask = null;
   #usageGeneration = 0;
   #latestUsage = null;
   #minimumContextUsedTokens = null;
@@ -46115,6 +46426,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;
@@ -46130,7 +46442,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
@@ -46139,9 +46451,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() {
@@ -46164,7 +46484,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,
@@ -46175,6 +46517,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,
@@ -46319,6 +46677,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 {
@@ -46426,6 +46785,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 });
@@ -46447,6 +46807,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();
@@ -46500,6 +46866,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 {
@@ -46555,6 +46924,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 {
@@ -46611,6 +46983,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 {
@@ -46743,6 +47118,7 @@ var ClaudeHarnessSession = class {
   async #close() {
     if (this.#phase === "closed")
       return;
+    this.#phase = "closing";
     this.#usageGeneration += 1;
     this.#contextUsageFreshUntilMs = 0;
     this.#contextUsageCooldownUntilMs = 0;
@@ -46752,78 +47128,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 {
@@ -47312,7 +47743,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"));
@@ -47649,6 +48080,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,
@@ -47688,14 +48125,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")
@@ -47714,8 +48156,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 });
@@ -47789,6 +48230,7 @@ var ClaudeCodeAdapter = class {
   #importAbort = new AbortController();
   #importIndex;
   #importRequests = /* @__PURE__ */ new Set();
+  #pendingSessions;
   #toolOutputLimit;
   #continuationQuiescenceMs;
   #inspectionCache = /* @__PURE__ */ new Map();
@@ -47799,6 +48241,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) {
@@ -47813,7 +48256,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 } : {},
@@ -47893,7 +48336,7 @@ var ClaudeCodeAdapter = class {
         error: invalidState("Claude Code Adapter is closing")
       };
     }
-    const cwd = path10.resolve(input.cwd ?? process.cwd());
+    const cwd = path12.resolve(input.cwd ?? process.cwd());
     if (!input.refresh) {
       const cached2 = this.#inspectionCache.get(cwd);
       if (cached2)
@@ -48023,79 +48466,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: path10.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: path10.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 {
@@ -48109,7 +48491,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 {
@@ -48123,7 +48505,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 {
@@ -48136,7 +48518,14 @@ var ClaudeCodeAdapter = class {
         }
       };
     }
-    const cwd = path10.resolve(input.cwd);
+    const cwd = path12.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 {
@@ -48148,8 +48537,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,
@@ -48157,11 +48554,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,
@@ -48206,7 +48641,7 @@ var ClaudeCodeAdapter = class {
 };
 
 // dist/user-shell-environment.js
-import path11 from "node:path";
+import path13 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";
@@ -48249,7 +48684,7 @@ function withUserShellEnvironment(environment, dependencies) {
   if (platform === "win32" || !environment.HOME)
     return environment;
   const shell = environment.SHELL?.trim() || defaultShell(platform);
-  if (!shell || !SUPPORTED_SHELLS.has(path11.basename(shell)))
+  if (!shell || !SUPPORTED_SHELLS.has(path13.basename(shell)))
     return environment;
   const cacheKey = `${platform}\0${shell}\0${environment.HOME}`;
   const cached2 = dependencies ? void 0 : shellEnvironmentCache.get(cacheKey);