@codexhost/cli-darwin-x64 0.1.0-test.1 → 0.1.0

package/app/host-runtime.mjs

@@ -4,6 +4,9 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// packages/host-runtime/src/release-main.ts
+import { fileURLToPath } from "node:url";
+
 // node_modules/zod/v4/classic/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -726,9 +729,9 @@ function floatSafeRemainder(val, step) {
   return ratio - roundedRatio;
 }
 var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
-function defineLazy(object2, key, getter) {
+function defineLazy(object3, key, getter) {
   let value = void 0;
-  Object.defineProperty(object2, key, {
+  Object.defineProperty(object3, key, {
     get() {
       if (value === EVALUATING) {
         return void 0;
@@ -740,7 +743,7 @@ function defineLazy(object2, key, getter) {
       return value;
     },
     set(v2) {
-      Object.defineProperty(object2, key, {
+      Object.defineProperty(object3, key, {
         value: v2
         // configurable: true,
       });
@@ -770,10 +773,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path8) {
-  if (!path8)
+function getElementAtPath(obj, path11) {
+  if (!path11)
     return obj;
-  return path8.reduce((acc, key) => acc?.[key], obj);
+  return path11.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1182,11 +1185,11 @@ function explicitlyAborted(x2, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path8, issues) {
+function prefixIssues(path11, issues) {
   return issues.map((iss) => {
     var _a4;
     (_a4 = iss).path ?? (_a4.path = []);
-    iss.path.unshift(path8);
+    iss.path.unshift(path11);
     return iss;
   });
 }
@@ -1333,16 +1336,16 @@ function flattenError(error52, mapper = (issue2) => issue2.message) {
 }
 function formatError(error52, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error53, path8 = []) => {
+  const processError = (error53, path11 = []) => {
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path8, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path11, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
       } else {
-        const fullpath = [...path8, ...issue2.path];
+        const fullpath = [...path11, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1369,17 +1372,17 @@ function formatError(error52, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error52, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error53, path8 = []) => {
+  const processError = (error53, path11 = []) => {
     var _a4, _b2;
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path8, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path11, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path8, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
       } else {
-        const fullpath = [...path8, ...issue2.path];
+        const fullpath = [...path11, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1411,8 +1414,8 @@ function treeifyError(error52, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path8 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path8) {
+  const path11 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path11) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14104,13 +14107,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path8 = ref.slice(1).split("/").filter(Boolean);
-  if (path8.length === 0) {
+  const path11 = ref.slice(1).split("/").filter(Boolean);
+  if (path11.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path8[0] === defsKey) {
-    const key = path8[1];
+  if (path11[0] === defsKey) {
+    const key = path11[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14650,6 +14653,50 @@ var threadPermissionModeSelectParamsSchema = external_exports.object({
   permissionModeId: harnessPermissionModeIdSchema
 }).strict();
 
+// packages/shared-contracts/dist/thread-usage.js
+var nonNegativeSafeIntegerSchema = external_exports.number().int().safe().nonnegative();
+var finiteNonNegativeNumberSchema = external_exports.number().finite().nonnegative();
+var cacheHitRatePercentSchema = external_exports.number().finite().min(0).max(100);
+var threadUsageSnapshotSchema = external_exports.object({
+  inputTokens: nonNegativeSafeIntegerSchema.optional(),
+  cachedInputTokens: nonNegativeSafeIntegerSchema.optional(),
+  cacheWriteInputTokens: nonNegativeSafeIntegerSchema.optional(),
+  outputTokens: nonNegativeSafeIntegerSchema.optional(),
+  reasoningOutputTokens: nonNegativeSafeIntegerSchema.optional(),
+  totalTokens: nonNegativeSafeIntegerSchema.optional(),
+  totalCostUsd: finiteNonNegativeNumberSchema.optional(),
+  cacheHitRatePercent: cacheHitRatePercentSchema.optional(),
+  contextWindowTokens: nonNegativeSafeIntegerSchema.optional(),
+  contextUsedTokens: nonNegativeSafeIntegerSchema.optional()
+}).strict().superRefine((usage, context) => {
+  if (Object.keys(usage).length === 0) {
+    context.addIssue({ code: "custom", message: "Thread Usage must contain a reliable field" });
+  }
+  const hasContextUsed = usage.contextUsedTokens !== void 0;
+  const hasContextWindow = usage.contextWindowTokens !== void 0;
+  if (hasContextUsed !== hasContextWindow) {
+    context.addIssue({
+      code: "custom",
+      message: "Thread Usage context fields must be provided together",
+      path: [hasContextUsed ? "contextWindowTokens" : "contextUsedTokens"]
+    });
+  }
+  if (usage.contextWindowTokens === 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Thread Usage contextWindowTokens must be greater than zero",
+      path: ["contextWindowTokens"]
+    });
+  }
+});
+var threadUsageInspectionParamsSchema = external_exports.object({
+  threadId: hostThreadIdSchema
+}).strict();
+var threadUsageInspectionSchema = external_exports.object({
+  threadId: hostThreadIdSchema,
+  usage: threadUsageSnapshotSchema.nullable()
+}).strict();
+
 // packages/shared-contracts/dist/harness-models.js
 var HARNESS_MODEL_REF_MAX_LENGTH = 512;
 var HARNESS_MODEL_LABEL_MAX_LENGTH = 256;
@@ -14740,7 +14787,8 @@ var harnessModelCatalogSchema = external_exports.object({
 });
 var harnessHistoryCapabilitiesSchema = external_exports.object({
   fork: external_exports.boolean(),
-  forkAcrossCwd: external_exports.boolean()
+  forkAcrossCwd: external_exports.boolean(),
+  rollbackLastTurn: external_exports.boolean()
 }).strict().refine((history) => history.fork || !history.forkAcrossCwd, {
   path: ["forkAcrossCwd"],
   message: "Cross-cwd Fork requires exact history Fork support"
@@ -14822,6 +14870,7 @@ var externalThreadInspectionSchema = external_exports.object({
   availableThinkingOptions: harnessThinkingOptionsSchema.optional(),
   effectivePermissionModeId: harnessPermissionModeIdSchema.optional(),
   history: harnessHistoryCapabilitiesSchema,
+  usage: threadUsageSnapshotSchema.optional(),
   locked: external_exports.literal(true)
 }).strict();
 var threadInspectionSchema = external_exports.discriminatedUnion("owner", [
@@ -14950,6 +14999,45 @@ var nativeCheckpointRefV1RuntimeSchema = external_exports.strictObject({
 var nativeCheckpointRefV1Schema = nativeCheckpointRefV1RuntimeSchema;
 var nativeCheckpointRefSchema = nativeCheckpointRefV1Schema;
 
+// packages/shared-contracts/dist/updates.js
+var UPDATE_ERROR_MAX_LENGTH = 500;
+var UPDATE_SEMVER_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u;
+var updateSemanticVersionSchema = external_exports.string().regex(UPDATE_SEMVER_PATTERN);
+var updateInstallationSchema = external_exports.enum(["npm", "windows-installer", "macos-dmg"]);
+var updatePhaseSchema = external_exports.enum([
+  "prepared",
+  "waiting-for-exit",
+  "installing",
+  "restarting",
+  "succeeded",
+  "failed"
+]);
+var updateStatusSchema = external_exports.strictObject({
+  version: updateSemanticVersionSchema,
+  installation: updateInstallationSchema,
+  phase: updatePhaseSchema,
+  updatedAt: external_exports.number().int().nonnegative(),
+  error: external_exports.string().min(1).max(UPDATE_ERROR_MAX_LENGTH).nullable()
+});
+var updateEmptyParamsSchema = external_exports.strictObject({});
+var githubReleaseNotesUrlSchema = external_exports.string().max(300).regex(/^https:\/\/github\.com\/BytePioneer-AI\/codex-host\/releases\/tag\/v[0-9A-Za-z.+-]+$/u, "release notes URL must identify a codexhost GitHub Release");
+var updateCheckResultSchema = external_exports.strictObject({
+  currentVersion: updateSemanticVersionSchema,
+  latestVersion: updateSemanticVersionSchema.nullable(),
+  updateAvailable: external_exports.boolean(),
+  installationAvailable: external_exports.boolean(),
+  releaseNotes: external_exports.string().min(1).max(2e4).nullable(),
+  releaseNotesUrl: githubReleaseNotesUrlSchema.nullable(),
+  status: updateStatusSchema.nullable(),
+  error: external_exports.string().min(1).max(UPDATE_ERROR_MAX_LENGTH).nullable()
+});
+var updateStartResultSchema = external_exports.strictObject({
+  status: updateStatusSchema
+});
+var updateStatusResultSchema = external_exports.strictObject({
+  status: updateStatusSchema.nullable()
+});
+
 // packages/shared-contracts/dist/index.js
 var workspaceContractVersionSchema = external_exports.literal(WORKSPACE_CONTRACT_VERSION);
 
@@ -15057,7 +15145,11 @@ var tokenFields = [
   "contextWindowTokens",
   "contextUsedTokens"
 ];
-var usageFields = /* @__PURE__ */ new Set([...tokenFields, "totalCostUsd"]);
+var usageFields = /* @__PURE__ */ new Set([
+  ...tokenFields,
+  "totalCostUsd",
+  "cacheHitRatePercent"
+]);
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -15081,6 +15173,9 @@ function parseHostUsage(value) {
   if (value.totalCostUsd !== void 0 && (typeof value.totalCostUsd !== "number" || !Number.isFinite(value.totalCostUsd) || value.totalCostUsd < 0)) {
     throw new Error("Harness Usage 'totalCostUsd' must be a finite non-negative number");
   }
+  if (value.cacheHitRatePercent !== void 0 && (typeof value.cacheHitRatePercent !== "number" || !Number.isFinite(value.cacheHitRatePercent) || value.cacheHitRatePercent < 0 || value.cacheHitRatePercent > 100)) {
+    throw new Error("Harness Usage 'cacheHitRatePercent' must be between 0 and 100");
+  }
   const hasContextUsed = value.contextUsedTokens !== void 0;
   const hasContextWindow = value.contextWindowTokens !== void 0;
   if (hasContextUsed !== hasContextWindow) {
@@ -42652,7 +42747,7 @@ var ClaudeHarnessSession = class {
       selectThinkingOption: true,
       selectPermissionMode: true
     },
-    history: { fork: true, forkAcrossCwd: false }
+    history: { fork: true, forkAcrossCwd: false, rollbackLastTurn: false }
   };
   initialState;
   initialUsage = null;
@@ -42719,7 +42814,7 @@ var ClaudeHarnessSession = class {
       };
     }
     if (!this.#statePublished)
-      return { ok: true, value: { turns: [] } };
+      return { ok: true, value: { turns: [], state: this.#state } };
     this.#readingHistory = true;
     try {
       let messages;
@@ -42746,7 +42841,10 @@ var ClaudeHarnessSession = class {
         };
       }
       try {
-        return { ok: true, value: mapClaudeSnapshot(messages, this.#sessionId) };
+        return {
+          ok: true,
+          value: { ...mapClaudeSnapshot(messages, this.#sessionId), state: this.#state }
+        };
       } catch {
         return {
           ok: false,
@@ -43649,7 +43747,7 @@ var ClaudeCodeAdapter = class {
               selectThinkingOption: false,
               selectPermissionMode: snapshot.canSelectPermissionMode
             },
-            history: { fork: true, forkAcrossCwd: false }
+            history: { fork: true, forkAcrossCwd: false, rollbackLastTurn: false }
           }
         };
       }
@@ -43664,7 +43762,7 @@ var ClaudeCodeAdapter = class {
             selectThinkingOption: true,
             selectPermissionMode: snapshot.canSelectPermissionMode
           },
-          history: { fork: true, forkAcrossCwd: false }
+          history: { fork: true, forkAcrossCwd: false, rollbackLastTurn: false }
         }
       };
     } catch (error52) {
@@ -43702,6 +43800,16 @@ var ClaudeCodeAdapter = class {
         }
       };
     }
+    if (input.kind === "rollbackLastTurn") {
+      return {
+        ok: false,
+        error: {
+          code: "unsupported",
+          message: "Claude Code does not support exact last-Turn rollback",
+          retryable: false
+        }
+      };
+    }
     let requestedThinkingOptionId = CLAUDE_DEFAULT_THINKING_OPTION_ID;
     if (input.kind === "create" && input.thinkingOptionId) {
       try {
@@ -44246,6 +44354,11 @@ function mapPiSnapshot(history, state) {
   }
   return { turns };
 }
+function resolvePiLastTurnBoundary(history) {
+  const users = activePiEntries(history).filter((entry) => messageRole(entry) === "user");
+  const last = users.at(-1);
+  return last ? { lastUserEntryId: last.id, sourceTurnCount: users.length } : null;
+}
 function resolvePiForkBoundary(history, checkpointId) {
   const active = activePiEntries(history);
   const users = active.filter((entry) => messageRole(entry) === "user");
@@ -44258,6 +44371,58 @@ function resolvePiForkBoundary(history, checkpointId) {
   };
 }
 
+// packages/adapters/pi/dist/pi-last-turn-rollback.js
+function modelFromState(state) {
+  if (state.provider === null && state.modelId === null)
+    return null;
+  if (state.provider === null || state.modelId === null) {
+    throw new Error("Pi state contains a partial Model identity");
+  }
+  return { provider: state.provider, id: state.modelId };
+}
+async function rollbackPiLastTurn(transport, sourceSessionId, cwd) {
+  const startupState = transport.state;
+  const startupSessionId = startupState.sessionId;
+  const currentModel = modelFromState(startupState);
+  const currentThinking = startupState.thinkingLevel;
+  const copiedHistory = await transport.getEntries();
+  const boundary = resolvePiLastTurnBoundary(copiedHistory);
+  if (!boundary)
+    return { ok: false, reason: "empty" };
+  const sourceSnapshot = mapPiSnapshot(copiedHistory, {
+    sessionId: startupSessionId,
+    model: currentModel
+  });
+  let state = await transport.fork(boundary.lastUserEntryId);
+  if (state.sessionId === sourceSessionId || state.sessionId === startupSessionId) {
+    throw new Error("Pi last-Turn rollback did not create a distinct Native Session");
+  }
+  if (!samePiModel(modelFromState(state), currentModel)) {
+    if (!currentModel)
+      throw new Error("Pi last-Turn rollback changed the current Model");
+    state = await transport.selectModel(currentModel);
+  }
+  if (state.thinkingLevel !== currentThinking) {
+    if (!currentThinking)
+      throw new Error("Pi last-Turn rollback changed current Thinking");
+    state = await transport.selectThinkingOption(currentThinking);
+  }
+  if (!samePiModel(modelFromState(state), currentModel) || state.thinkingLevel !== currentThinking) {
+    throw new Error("Pi last-Turn rollback could not restore current Model and Thinking");
+  }
+  const snapshot = mapPiSnapshot(await transport.getEntries(), {
+    sessionId: state.sessionId,
+    model: modelFromState(state)
+  });
+  const expectedTurnKeys = sourceSnapshot.turns.slice(0, -1).map((turn) => turn.nativeTurnRef.nativeTurnKey);
+  const actualTurnKeys = snapshot.turns.map((turn) => turn.nativeTurnRef.nativeTurnKey);
+  if (snapshot.turns.length !== boundary.sourceTurnCount - 1 || actualTurnKeys.some((key, index) => key !== expectedTurnKeys[index])) {
+    throw new Error("Pi last-Turn rollback did not produce the exact retained history prefix");
+  }
+  await transport.verifySessionCwd(cwd);
+  return { ok: true };
+}
+
 // packages/adapters/pi/dist/pi-rpc-session.js
 import { spawn as spawn2, spawnSync } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -44268,6 +44433,29 @@ import path5 from "node:path";
 function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function nonNegativeSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function optionalPiCacheHitRatePercent(value) {
+  if (!isRecord8(value) || value.role !== "assistant" || !isRecord8(value.usage))
+    return null;
+  const input = nonNegativeSafeInteger(value.usage.input);
+  const cacheRead = nonNegativeSafeInteger(value.usage.cacheRead);
+  const cacheWrite = nonNegativeSafeInteger(value.usage.cacheWrite);
+  if (input === null || cacheRead === null || cacheWrite === null)
+    return null;
+  const promptTokens = input + cacheRead + cacheWrite;
+  return promptTokens > 0 ? cacheRead / promptTokens * 100 : null;
+}
+function latestPiCacheHitRatePercent(history) {
+  let latest = null;
+  for (const entry of activePiEntries(history)) {
+    if (entry.type === "message" && isRecord8(entry.message) && entry.message.role === "assistant") {
+      latest = optionalPiCacheHitRatePercent(entry.message);
+    }
+  }
+  return latest;
+}
 function responseData(response, operation) {
   if (!isRecord8(response.data)) {
     throw new Error(`Pi RPC ${operation} response has no data`);
@@ -44564,13 +44752,13 @@ function piRpcProcessCommand(options, dependencies = {}) {
   const command = platform === "win32" ? resolveWindowsCommand(selectedCommand, options.environment, dependencies.isFile ?? isRegularFile) : selectedCommand;
   const sessionArguments = options.forkSessionFile ? ["--fork", options.forkSessionFile] : options.sessionFile ? ["--session", options.sessionFile] : [];
   const modelArguments = options.model ? ["--provider", options.model.provider, "--model", options.model.id] : [];
-  const arguments_ = ["--mode", "rpc", ...modelArguments, ...sessionArguments];
+  const arguments_2 = ["--mode", "rpc", ...modelArguments, ...sessionArguments];
   const extension = path5.win32.extname(command).toLowerCase();
   if (platform !== "win32" || ![".cmd", ".bat"].includes(extension)) {
-    return { command, arguments: arguments_, windowsVerbatimArguments: false };
+    return { command, arguments: arguments_2, windowsVerbatimArguments: false };
   }
   const quote = (value) => `"${value.replaceAll("%", "%%").replaceAll('"', '""')}"`;
-  const commandLine = [command, ...arguments_].map(quote).join(" ");
+  const commandLine = [command, ...arguments_2].map(quote).join(" ");
   return {
     command: options.environment?.ComSpec ?? options.environment?.COMSPEC ?? "cmd.exe",
     arguments: ["/d", "/v:off", "/s", "/c", `"${commandLine}"`],
@@ -44602,6 +44790,7 @@ var PiRpcSession = class {
   #failed = false;
   #pending = /* @__PURE__ */ new Map();
   #state = null;
+  #latestCacheHitRatePercent;
   constructor(options, processAdapter = nodeProcessAdapter) {
     if (options.sessionFile && options.forkSessionFile) {
       throw new Error("Pi RPC cannot combine Session resume and Fork startup");
@@ -44682,7 +44871,9 @@ var PiRpcSession = class {
   }
   async getSessionUsage() {
     try {
-      return parsePiSessionUsage(await this.#send("get_session_stats", {}));
+      const usage = parsePiSessionUsage(await this.#send("get_session_stats", {}));
+      await this.#ensureLatestCacheHitRate();
+      return this.#withLatestCacheHitRate(usage);
     } catch (error52) {
       if (!(error52 instanceof PiRpcUnsupportedCommandError))
         throw error52;
@@ -44691,9 +44882,23 @@ var PiRpcSession = class {
       if (!this.#state || observedState.sessionId !== this.#state.sessionId || observedState.provider !== this.#state.provider || observedState.modelId !== this.#state.modelId) {
         throw new Error("Pi RPC Usage fallback does not match the confirmed Session state");
       }
-      return parsePiStateContextUsage(response);
+      await this.#ensureLatestCacheHitRate();
+      const usage = parsePiStateContextUsage(response);
+      return usage ? this.#withLatestCacheHitRate(usage) : null;
     }
   }
+  async #ensureLatestCacheHitRate() {
+    if (this.#latestCacheHitRatePercent !== void 0)
+      return;
+    try {
+      this.#latestCacheHitRatePercent = latestPiCacheHitRatePercent(parseSessionHistory(await this.#send("get_entries", {})));
+    } catch {
+      this.#latestCacheHitRatePercent = null;
+    }
+  }
+  #withLatestCacheHitRate(usage) {
+    return this.#latestCacheHitRatePercent === null || this.#latestCacheHitRatePercent === void 0 ? usage : parseHostUsage({ ...usage, cacheHitRatePercent: this.#latestCacheHitRatePercent });
+  }
   async fork(entryId) {
     if (entryId.length === 0)
       throw new Error("Pi Fork Entry ID must not be empty");
@@ -45190,12 +45395,14 @@ var PiRpcSession = class {
     const finalText = assistantText2(value);
     const finalReasoning = assistantReasoning2(value);
     const failure2 = assistantFailure(value);
+    const cacheHitRatePercent = optionalPiCacheHitRatePercent(value);
     if (finalText === null || finalReasoning === null || failure2 === void 0)
       return;
     if (active.assistantMessageId === null && finalText === active.lastFinalizedMessageText && finalReasoning === active.lastFinalizedMessageReasoning && !active.sawStreamedMessageText && !active.sawStreamedMessageReasoning) {
       return;
     }
     active.failure = failure2;
+    this.#latestCacheHitRatePercent = cacheHitRatePercent;
     const messageId = this.#ensureAssistantMessage(active, value);
     if (!active.sawStreamedMessageReasoning && finalReasoning.length > 0) {
       active.reasoningMessageOpen = true;
@@ -45449,8 +45656,8 @@ function numberField(value, key) {
   const field = value[key];
   return typeof field === "number" || field === null ? field : void 0;
 }
-function stripDiffPrefix(path8) {
-  return path8.startsWith("a/") || path8.startsWith("b/") ? path8.slice(2) : path8;
+function stripDiffPrefix(path11) {
+  return path11.startsWith("a/") || path11.startsWith("b/") ? path11.slice(2) : path11;
 }
 function reliableFileChange(result) {
   if (!isRecord11(result) || !isRecord11(result.details) || typeof result.details.patch !== "string") {
@@ -45469,10 +45676,10 @@ function reliableFileChange(result) {
   const oldFile = file2.oldFileName;
   const newFile = file2.newFileName;
   const kind = oldFile === "/dev/null" ? "add" : newFile === "/dev/null" ? "delete" : "update";
-  const path8 = stripDiffPrefix(kind === "delete" ? oldFile : newFile);
-  if (!path8 || path8 === "/dev/null")
+  const path11 = stripDiffPrefix(kind === "delete" ? oldFile : newFile);
+  if (!path11 || path11 === "/dev/null")
     return null;
-  return [{ path: path8, kind, unifiedDiff: patch }];
+  return [{ path: path11, kind, unifiedDiff: patch }];
 }
 function delay3(milliseconds) {
   return new Promise((resolve2) => setTimeout(resolve2, milliseconds));
@@ -45516,7 +45723,7 @@ var PiHarnessSession = class {
         selectThinkingOption: options.supportsThinkingSelection,
         selectPermissionMode: false
       },
-      history: { fork: true, forkAcrossCwd: true }
+      history: { fork: true, forkAcrossCwd: true, rollbackLastTurn: true }
     };
     this.#transport = options.startedTransport ?? null;
     this.initialState = options.startedTransport ? harnessStateFromPi(options.startedTransport.state, options.startedThinkingLevels ?? null) : {};
@@ -45547,10 +45754,13 @@ var PiHarnessSession = class {
       const history = await transport.getEntries();
       return {
         ok: true,
-        value: mapPiSnapshot(history, {
-          sessionId: transport.state.sessionId,
-          model: nativeModelForHistory(transport.state)
-        })
+        value: {
+          ...mapPiSnapshot(history, {
+            sessionId: transport.state.sessionId,
+            model: nativeModelForHistory(transport.state)
+          }),
+          state: this.#state
+        }
       };
     } catch (error52) {
       return { ok: false, error: normalizedError(error52, "nativeFailure") };
@@ -46461,7 +46671,7 @@ var PiAdapter = class {
             selectThinkingOption: thinkingLevels !== null,
             selectPermissionMode: false
           },
-          history: { fork: true, forkAcrossCwd: true }
+          history: { fork: true, forkAcrossCwd: true, rollbackLastTurn: true }
         }
       };
     } catch (error52) {
@@ -46566,7 +46776,7 @@ var PiAdapter = class {
             retryable: false
           });
         }
-      } else {
+      } else if (input.kind === "fork") {
         const checkpoint = nativeCheckpointRefSchema.parse(input.checkpoint);
         const startupSessionId = transport.state.sessionId;
         if (startupSessionId === sourceRef.nativeSessionId) {
@@ -46596,6 +46806,15 @@ var PiAdapter = class {
           throw new Error("Pi Fork derived history does not match the requested Checkpoint");
         }
         await transport.verifySessionCwd(input.cwd);
+      } else {
+        const rolledBack = await rollbackPiLastTurn(transport, sourceRef.nativeSessionId, input.cwd);
+        if (!rolledBack.ok) {
+          throw new PiAdapterFaultError({
+            code: "invalidState",
+            message: "Pi Native Session has no Turn to roll back",
+            retryable: false
+          });
+        }
       }
       const startedThinkingLevels = await transport.getAvailableThinkingLevels();
       this.#thinkingSelectionSupported = startedThinkingLevels !== null;
@@ -46682,6 +46901,7 @@ import { randomUUID as randomUUID7 } from "node:crypto";
 import nodePath from "node:path";
 
 // packages/mapping-store/dist/mapping-store.js
+import { execFileSync } from "node:child_process";
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { constants } from "node:fs";
 import { copyFile, mkdir, open as open2, readFile, readdir, rename, rm as rm2, stat } from "node:fs/promises";
@@ -46721,15 +46941,15 @@ var storedThreadRecordV1Schema = external_exports.object({
   turnMappings: external_exports.array(storedTurnMappingV1Schema),
   createdAt: isoDateSchema,
   updatedAt: isoDateSchema
-}).strict().superRefine((record2, context) => {
-  if (record2.state === "ready" && !record2.nativeSessionRef) {
+}).strict().superRefine((record3, context) => {
+  if (record3.state === "ready" && !record3.nativeSessionRef) {
     context.addIssue({
       code: "custom",
       path: ["nativeSessionRef"],
       message: "Ready Thread must have a Native Session Ref"
     });
   }
-  if (record2.nativeSessionRef && record2.nativeSessionRef.harnessId !== record2.harnessId) {
+  if (record3.nativeSessionRef && record3.nativeSessionRef.harnessId !== record3.harnessId) {
     context.addIssue({
       code: "custom",
       path: ["nativeSessionRef", "harnessId"],
@@ -46738,7 +46958,7 @@ var storedThreadRecordV1Schema = external_exports.object({
   }
   const hostTurnIds = /* @__PURE__ */ new Set();
   const nativeTurnKeys = /* @__PURE__ */ new Set();
-  for (const [index, mapping] of record2.turnMappings.entries()) {
+  for (const [index, mapping] of record3.turnMappings.entries()) {
     if (hostTurnIds.has(mapping.hostTurnId)) {
       context.addIssue({
         code: "custom",
@@ -46762,14 +46982,14 @@ var storedThreadRecordV1Schema = external_exports.object({
     ]) {
       if (!ref)
         continue;
-      if (ref.harnessId !== record2.harnessId) {
+      if (ref.harnessId !== record3.harnessId) {
         context.addIssue({
           code: "custom",
           path: ["turnMappings", index, name, "harnessId"],
           message: "Turn Ref Harness must match the Thread Harness"
         });
       }
-      if (record2.nativeSessionRef && ref.nativeSessionId !== record2.nativeSessionRef.nativeSessionId) {
+      if (record3.nativeSessionRef && ref.nativeSessionId !== record3.nativeSessionRef.nativeSessionId) {
         context.addIssue({
           code: "custom",
           path: ["turnMappings", index, name, "nativeSessionId"],
@@ -46789,8 +47009,8 @@ var MappingStoreError = class extends Error {
     this.name = "MappingStoreError";
   }
 };
-function cloneRecord(record2) {
-  return JSON.parse(JSON.stringify(record2));
+function cloneRecord(record3) {
+  return JSON.parse(JSON.stringify(record3));
 }
 function nativeSessionKey(ref) {
   return `${ref.harnessId}\0${ref.nativeSessionId}`;
@@ -46815,13 +47035,62 @@ async function exists(file2) {
     throw error52;
   }
 }
-function processAlive(pid) {
+function processIdentity(pid) {
   try {
     process.kill(pid, 0);
-    return true;
   } catch (error52) {
-    return systemErrorCode(error52) === "EPERM";
+    if (systemErrorCode(error52) !== "EPERM")
+      return null;
+  }
+  if (process.platform !== "win32") {
+    return { executablePath: null, startedAt: null };
+  }
+  try {
+    const query = [
+      "$ErrorActionPreference = 'Stop'",
+      `$process = Get-Process -Id ${pid}`,
+      "$process | Select-Object Path, StartTime | ConvertTo-Json -Compress"
+    ].join("; ");
+    const result = execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", query], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], windowsHide: true }).trim();
+    if (!result)
+      return { executablePath: null, startedAt: null };
+    const parsed = JSON.parse(result);
+    const executablePath = typeof parsed.Path === "string" ? parsed.Path : null;
+    const startedAt = typeof parsed.StartTime === "string" ? Date.parse(parsed.StartTime) : NaN;
+    return { executablePath, startedAt: Number.isFinite(startedAt) ? startedAt : null };
+  } catch {
+    return { executablePath: null, startedAt: null };
+  }
+}
+function normalizeExecutablePath(value) {
+  return process.platform === "win32" ? value.replaceAll("/", "\\").toLowerCase() : value;
+}
+function isNodeExecutable(value) {
+  const normalized = normalizeExecutablePath(value);
+  return normalized.endsWith("\\node.exe") || normalized.endsWith("/node");
+}
+function lockOwnerIsLive(lock) {
+  if (typeof lock.pid !== "number")
+    return false;
+  const identity = processIdentity(lock.pid);
+  if (!identity)
+    return false;
+  if (process.platform !== "win32")
+    return true;
+  if (identity.executablePath && lock.executablePath) {
+    if (normalizeExecutablePath(identity.executablePath) !== normalizeExecutablePath(lock.executablePath)) {
+      return false;
+    }
+  } else if (identity.executablePath && !lock.executablePath && !isNodeExecutable(identity.executablePath)) {
+    return false;
+  }
+  if (lock.processStartedAt && identity.startedAt !== null) {
+    const expected = Date.parse(lock.processStartedAt);
+    if (Number.isFinite(expected) && Math.abs(identity.startedAt - expected) > 5e3) {
+      return false;
+    }
   }
+  return true;
 }
 var MappingStore = class {
   #backupsDirectory;
@@ -46865,13 +47134,13 @@ var MappingStore = class {
       for (const name of names) {
         const primary = path6.join(this.#threadsDirectory, name);
         const backup = path6.join(this.#backupsDirectory, name);
-        let record2 = null;
+        let record3 = null;
         try {
-          record2 = await this.#readRecord(primary, name);
+          record3 = await this.#readRecord(primary, name);
         } catch (primaryError) {
           try {
-            record2 = await this.#readRecord(backup, name);
-            await this.#replaceFile(primary, record2, false);
+            record3 = await this.#readRecord(backup, name);
+            await this.#replaceFile(primary, record3, false);
           } catch (backupError) {
             const quarantine = path6.join(this.#quarantineDirectory, `${name}.${this.#now().getTime()}.invalid`);
             await rename(primary, quarantine).catch(() => void 0);
@@ -46880,12 +47149,12 @@ var MappingStore = class {
             continue;
           }
         }
-        if (record2.state === "creating" && !record2.nativeSessionRef) {
+        if (record3.state === "creating" && !record3.nativeSessionRef) {
           await rm2(primary, { force: true });
           await rm2(backup, { force: true });
           continue;
         }
-        this.#records.set(record2.hostThreadId, record2);
+        this.#records.set(record3.hostThreadId, record3);
       }
       this.#rebuildIndexes();
       this.#initialized = true;
@@ -46896,8 +47165,8 @@ var MappingStore = class {
   }
   async getThread(hostThreadId) {
     this.#requireInitialized();
-    const record2 = this.#records.get(hostThreadId);
-    return record2 ? cloneRecord(record2) : null;
+    const record3 = this.#records.get(hostThreadId);
+    return record3 ? cloneRecord(record3) : null;
   }
   async listThreads() {
     this.#requireInitialized();
@@ -46917,7 +47186,7 @@ var MappingStore = class {
       throw new MappingStoreError("DUPLICATE_CREATE_REQUEST", "Create request already identifies another Thread");
     }
     const timestamp = this.#now().toISOString();
-    const record2 = storedThreadRecordV1Schema.parse({
+    const record3 = storedThreadRecordV1Schema.parse({
       formatVersion: 1,
       revision: 1,
       hostThreadId: input.hostThreadId,
@@ -46935,8 +47204,8 @@ var MappingStore = class {
       createdAt: timestamp,
       updatedAt: timestamp
     });
-    await this.#writeNew(record2);
-    return cloneRecord(record2);
+    await this.#writeNew(record3);
+    return cloneRecord(record3);
   }
   async commitReady(input) {
     return this.#update(input.hostThreadId, (current) => ({
@@ -46959,6 +47228,18 @@ var MappingStore = class {
       };
     });
   }
+  async replaceReadySessionAfterLastTurn(input) {
+    return this.#update(input.hostThreadId, (current) => {
+      if (current.state !== "ready" || !current.nativeSessionRef || current.nativeSessionRef.nativeSessionId === input.nativeSessionRef.nativeSessionId || input.turnMappings.length !== current.turnMappings.length - 1 || input.turnMappings.some(({ hostTurnId }, index) => hostTurnId !== current.turnMappings[index]?.hostTurnId)) {
+        throw new MappingStoreError("MAPPING_CONFLICT", "Last-Turn Session replacement must retain the exact shorter Host Turn prefix");
+      }
+      return {
+        ...current,
+        nativeSessionRef: input.nativeSessionRef,
+        turnMappings: input.turnMappings
+      };
+    });
+  }
   async upsertTurnMappings(hostThreadId, mappings) {
     return this.#update(hostThreadId, (current) => ({
       ...current,
@@ -47005,8 +47286,8 @@ var MappingStore = class {
   }
   async removeProvisional(hostThreadId) {
     this.#requireInitialized();
-    const record2 = this.#records.get(hostThreadId);
-    if (record2?.state === "ready") {
+    const record3 = this.#records.get(hostThreadId);
+    if (record3?.state === "ready") {
       throw new MappingStoreError("MAPPING_CONFLICT", "Ready Thread cannot be removed as provisional");
     }
     await this.#remove(hostThreadId);
@@ -47097,25 +47378,25 @@ var MappingStore = class {
     }
     return merged;
   }
-  async #writeNew(record2) {
-    this.#validateGlobal(record2, null);
-    await this.#replaceFile(this.#recordPath(record2.hostThreadId), record2, false);
-    this.#records.set(record2.hostThreadId, record2);
+  async #writeNew(record3) {
+    this.#validateGlobal(record3, null);
+    await this.#replaceFile(this.#recordPath(record3.hostThreadId), record3, false);
+    this.#records.set(record3.hostThreadId, record3);
     this.#rebuildIndexes();
   }
-  async #replaceFile(target, record2, preserveBackup) {
+  async #replaceFile(target, record3, preserveBackup) {
     const temp = `${target}.tmp-${randomUUID4()}`;
     let handle = null;
     try {
-      await this.#beforeReplace?.(cloneRecord(record2));
+      await this.#beforeReplace?.(cloneRecord(record3));
       handle = await open2(temp, "wx", constants.S_IRUSR | constants.S_IWUSR);
-      await handle.writeFile(`${JSON.stringify(record2, null, 2)}
+      await handle.writeFile(`${JSON.stringify(record3, null, 2)}
 `, "utf8");
       await handle.sync();
       await handle.close();
       handle = null;
       if (preserveBackup && await exists(target)) {
-        await copyFile(target, this.#backupPath(record2.hostThreadId));
+        await copyFile(target, this.#backupPath(record3.hostThreadId));
       }
       await rename(temp, target);
     } catch (error52) {
@@ -47150,7 +47431,9 @@ var MappingStore = class {
       const lock = {
         pid: process.pid,
         instanceId: this.#instanceId,
-        startedAt: this.#now().toISOString()
+        startedAt: this.#now().toISOString(),
+        executablePath: process.execPath,
+        processStartedAt: new Date(Date.now() - process.uptime() * 1e3).toISOString()
       };
       await handle.writeFile(`${JSON.stringify(lock)}
 `, "utf8");
@@ -47169,7 +47452,7 @@ var MappingStore = class {
       existing = JSON.parse(await readFile(this.#lockPath, "utf8"));
     } catch {
     }
-    if (typeof existing.pid === "number" && processAlive(existing.pid)) {
+    if (typeof existing.pid === "number" && lockOwnerIsLive(existing)) {
       throw new MappingStoreError("STORE_LOCKED", "Another codexhost process owns Mapping Store");
     }
     await rename(this.#lockPath, `${this.#lockPath}.stale-${this.#now().getTime()}`).catch(() => void 0);
@@ -47181,18 +47464,18 @@ var MappingStore = class {
       });
     }
   }
-  #validateGlobal(record2, replacing) {
-    const duplicateCreate = this.#createRequests.get(record2.createRequestId);
+  #validateGlobal(record3, replacing) {
+    const duplicateCreate = this.#createRequests.get(record3.createRequestId);
     if (duplicateCreate && duplicateCreate !== replacing) {
       throw new MappingStoreError("DUPLICATE_CREATE_REQUEST", "Create request is already stored");
     }
-    if (record2.nativeSessionRef) {
-      const duplicateSession = this.#nativeSessions.get(nativeSessionKey(record2.nativeSessionRef));
+    if (record3.nativeSessionRef) {
+      const duplicateSession = this.#nativeSessions.get(nativeSessionKey(record3.nativeSessionRef));
       if (duplicateSession && duplicateSession !== replacing) {
         throw new MappingStoreError("DUPLICATE_NATIVE_SESSION", "Native Session is already mapped");
       }
     }
-    for (const mapping of record2.turnMappings) {
+    for (const mapping of record3.turnMappings) {
       const duplicateHostTurn = this.#hostTurns.get(mapping.hostTurnId);
       if (duplicateHostTurn && duplicateHostTurn !== replacing) {
         throw new MappingStoreError("MAPPING_CONFLICT", "Host Turn is already mapped");
@@ -47208,14 +47491,14 @@ var MappingStore = class {
     this.#nativeSessions.clear();
     this.#hostTurns.clear();
     this.#nativeTurns.clear();
-    for (const record2 of this.#records.values()) {
-      this.#validateGlobal(record2, record2.hostThreadId);
-      this.#createRequests.set(record2.createRequestId, record2.hostThreadId);
-      if (record2.nativeSessionRef) {
-        this.#nativeSessions.set(nativeSessionKey(record2.nativeSessionRef), record2.hostThreadId);
-      }
-      for (const mapping of record2.turnMappings) {
-        this.#hostTurns.set(mapping.hostTurnId, record2.hostThreadId);
+    for (const record3 of this.#records.values()) {
+      this.#validateGlobal(record3, record3.hostThreadId);
+      this.#createRequests.set(record3.createRequestId, record3.hostThreadId);
+      if (record3.nativeSessionRef) {
+        this.#nativeSessions.set(nativeSessionKey(record3.nativeSessionRef), record3.hostThreadId);
+      }
+      for (const mapping of record3.turnMappings) {
+        this.#hostTurns.set(mapping.hostTurnId, record3.hostThreadId);
         this.#nativeTurns.set(nativeTurnKey(mapping), mapping.hostTurnId);
       }
     }
@@ -47604,8 +47887,8 @@ function projectItem(item, outcome, defaultCwd, includeCommandOutput = true) {
       return {
         id: item.itemId,
         type: "fileChange",
-        changes: item.changes.map(({ path: path8, kind, unifiedDiff }) => ({
-          path: path8,
+        changes: item.changes.map(({ path: path11, kind, unifiedDiff }) => ({
+          path: path11,
           kind,
           diff: unifiedDiff
         })),
@@ -48022,8 +48305,8 @@ var CodexTurnProjector = class {
     return messages;
   }
   #fileChangeUpdates(itemId2, changes) {
-    const projectedChanges = changes.map(({ path: path8, kind, unifiedDiff }) => ({
-      path: path8,
+    const projectedChanges = changes.map(({ path: path11, kind, unifiedDiff }) => ({
+      path: path11,
       kind,
       diff: unifiedDiff
     }));
@@ -48106,13 +48389,13 @@ function decodeThreadForkRequest(request) {
   if (runtimeWorkspaceRoots !== void 0 && runtimeWorkspaceRoots !== null && (!Array.isArray(runtimeWorkspaceRoots) || runtimeWorkspaceRoots.some((root) => typeof root !== "string" || root.length === 0))) {
     throw new Error("thread/fork params.runtimeWorkspaceRoots must be text paths or null");
   }
-  const path8 = optionalText(params, "path", { allowEmpty: true });
+  const path11 = optionalText(params, "path", { allowEmpty: true });
   const ephemeral = optionalBoolean(params, "ephemeral");
   return {
     threadId: threadId2,
     ...lastTurnText ? { lastTurnId: hostTurnIdSchema.parse(lastTurnText) } : {},
     ...beforeTurnText ? { beforeTurnId: hostTurnIdSchema.parse(beforeTurnText) } : {},
-    ...path8 ? { path: path8 } : {},
+    ...path11 ? { path: path11 } : {},
     ...optionalField(params, "model"),
     ...optionalField(params, "modelProvider"),
     ...optionalField(params, "cwd"),
@@ -48744,11 +49027,11 @@ var ExternalThreadRepository = class {
   removeThread(hostThreadId) {
     return this.store.removeThread(hostThreadId);
   }
-  async persistTurn(record2, hostTurnId, nativeTurnRef, nativeCheckpointRef) {
-    if (record2.state !== "ready" || !record2.nativeSessionRef || nativeTurnRef.harnessId !== record2.harnessId || nativeTurnRef.nativeSessionId !== record2.nativeSessionRef.nativeSessionId || nativeCheckpointRef && (nativeCheckpointRef.harnessId !== record2.harnessId || nativeCheckpointRef.nativeSessionId !== record2.nativeSessionRef.nativeSessionId)) {
+  async persistTurn(record3, hostTurnId, nativeTurnRef, nativeCheckpointRef) {
+    if (record3.state !== "ready" || !record3.nativeSessionRef || nativeTurnRef.harnessId !== record3.harnessId || nativeTurnRef.nativeSessionId !== record3.nativeSessionRef.nativeSessionId || nativeCheckpointRef && (nativeCheckpointRef.harnessId !== record3.harnessId || nativeCheckpointRef.nativeSessionId !== record3.nativeSessionRef.nativeSessionId)) {
       throw new Error("Live Turn identity does not belong to the stored Thread");
     }
-    return this.store.upsertTurnMappings(record2.hostThreadId, [
+    return this.store.upsertTurnMappings(record3.hostThreadId, [
       {
         hostTurnId,
         nativeTurnRef,
@@ -48756,12 +49039,12 @@ var ExternalThreadRepository = class {
       }
     ]);
   }
-  async commitDerivedSnapshot(record2, nativeSessionRef, snapshot) {
-    if (record2.state !== "creating" || record2.turnMappings.length !== 0) {
+  async commitDerivedSnapshot(record3, nativeSessionRef, snapshot) {
+    if (record3.state !== "creating" || record3.turnMappings.length !== 0) {
       throw new Error("Derived Thread must be provisional before Snapshot commit");
     }
     const mappings = snapshot.turns.map((turn) => {
-      if (turn.nativeTurnRef.harnessId !== record2.harnessId || turn.nativeTurnRef.nativeSessionId !== nativeSessionRef.nativeSessionId || turn.checkpoint && (turn.checkpoint.harnessId !== record2.harnessId || turn.checkpoint.nativeSessionId !== nativeSessionRef.nativeSessionId)) {
+      if (turn.nativeTurnRef.harnessId !== record3.harnessId || turn.nativeTurnRef.nativeSessionId !== nativeSessionRef.nativeSessionId || turn.checkpoint && (turn.checkpoint.harnessId !== record3.harnessId || turn.checkpoint.nativeSessionId !== nativeSessionRef.nativeSessionId)) {
         throw new Error("Derived Snapshot identity does not belong to its Native Session");
       }
       return {
@@ -48771,7 +49054,7 @@ var ExternalThreadRepository = class {
       };
     });
     const nextRecord = await this.store.commitReady({
-      hostThreadId: record2.hostThreadId,
+      hostThreadId: record3.hostThreadId,
       nativeSessionRef,
       turnMappings: mappings
     });
@@ -48782,7 +49065,7 @@ var ExternalThreadRepository = class {
         if (!mapping) throw new Error("Derived Snapshot mapping is incomplete");
         return projectHistoricalTurn({
           turnId: mapping.hostTurnId,
-          cwd: record2.cwd,
+          cwd: record3.cwd,
           snapshot: turn
         });
       })
@@ -48839,8 +49122,41 @@ var ExternalThreadRepository = class {
       })
     };
   }
-  async sessionTreeId(record2) {
-    let current = record2;
+  async commitLastTurnRollback(current, nativeSessionRef, snapshot) {
+    if (current.state !== "ready" || !current.nativeSessionRef || nativeSessionRef.harnessId !== current.harnessId || nativeSessionRef.nativeSessionId === current.nativeSessionRef.nativeSessionId || snapshot.turns.length !== current.turnMappings.length - 1) {
+      throw new Error("Last-Turn rollback is not an exact ready Session replacement");
+    }
+    const mappings = snapshot.turns.map((turn, index) => {
+      const previous = current.turnMappings[index];
+      if (!previous || turn.nativeTurnRef.harnessId !== current.harnessId || turn.nativeTurnRef.nativeSessionId !== nativeSessionRef.nativeSessionId || turn.checkpoint && (turn.checkpoint.harnessId !== current.harnessId || turn.checkpoint.nativeSessionId !== nativeSessionRef.nativeSessionId)) {
+        throw new Error("Last-Turn rollback Snapshot identity is invalid");
+      }
+      return {
+        hostTurnId: previous.hostTurnId,
+        nativeTurnRef: turn.nativeTurnRef,
+        ...turn.checkpoint ? { nativeCheckpointRef: turn.checkpoint } : {}
+      };
+    });
+    const nextRecord = await this.store.replaceReadySessionAfterLastTurn({
+      hostThreadId: current.hostThreadId,
+      nativeSessionRef,
+      turnMappings: mappings
+    });
+    return {
+      record: nextRecord,
+      turns: snapshot.turns.map((turn, index) => {
+        const mapping = mappings[index];
+        if (!mapping) throw new Error("Last-Turn rollback Snapshot mapping is incomplete");
+        return projectHistoricalTurn({
+          turnId: mapping.hostTurnId,
+          cwd: current.cwd,
+          snapshot: turn
+        });
+      })
+    };
+  }
+  async sessionTreeId(record3) {
+    let current = record3;
     const visited = /* @__PURE__ */ new Set();
     while (current.forkSource) {
       if (visited.has(current.hostThreadId))
@@ -48852,18 +49168,18 @@ var ExternalThreadRepository = class {
     }
     return current.hostThreadId;
   }
-  async alignSnapshot(record2, snapshot) {
-    const nativeSessionRef = record2.nativeSessionRef;
-    if (!nativeSessionRef || record2.state !== "ready") {
+  async alignSnapshot(record3, snapshot) {
+    const nativeSessionRef = record3.nativeSessionRef;
+    if (!nativeSessionRef || record3.state !== "ready") {
       throw new Error("External Thread has no committed Native Session identity");
     }
     for (const turn of snapshot.turns) {
-      if (turn.nativeTurnRef.harnessId !== record2.harnessId || turn.nativeTurnRef.nativeSessionId !== nativeSessionRef.nativeSessionId || turn.checkpoint && (turn.checkpoint.harnessId !== record2.harnessId || turn.checkpoint.nativeSessionId !== nativeSessionRef.nativeSessionId)) {
+      if (turn.nativeTurnRef.harnessId !== record3.harnessId || turn.nativeTurnRef.nativeSessionId !== nativeSessionRef.nativeSessionId || turn.checkpoint && (turn.checkpoint.harnessId !== record3.harnessId || turn.checkpoint.nativeSessionId !== nativeSessionRef.nativeSessionId)) {
         throw new Error("External Snapshot identity does not belong to the stored Thread");
       }
     }
     const mappingsByNative = new Map(
-      record2.turnMappings.map(
+      record3.turnMappings.map(
         (mapping) => [nativeTurnKey2(mapping.nativeTurnRef), mapping]
       )
     );
@@ -48886,24 +49202,24 @@ var ExternalThreadRepository = class {
     let existingIndex = 0;
     for (const { existing } of aligned) {
       if (!existing) continue;
-      if (existing.hostTurnId !== record2.turnMappings[existingIndex]?.hostTurnId) {
+      if (existing.hostTurnId !== record3.turnMappings[existingIndex]?.hostTurnId) {
         throw new Error("Persisted Turn mappings do not match the Native Snapshot order");
       }
       existingIndex += 1;
     }
-    if (existingIndex !== record2.turnMappings.length) {
+    if (existingIndex !== record3.turnMappings.length) {
       throw new Error("Persisted Turn mappings do not match the Native Snapshot order");
     }
     const orderedMappings = aligned.map(({ mapping }) => mapping);
-    const mappingsChanged = orderedMappings.length !== record2.turnMappings.length || orderedMappings.some((mapping, index) => {
-      const persisted = record2.turnMappings[index];
+    const mappingsChanged = orderedMappings.length !== record3.turnMappings.length || orderedMappings.some((mapping, index) => {
+      const persisted = record3.turnMappings[index];
       return !persisted || !sameMapping(mapping, persisted);
     });
-    const nextRecord = mappingsChanged ? await this.store.reconcileTurnMappings(record2.hostThreadId, orderedMappings) : record2;
+    const nextRecord = mappingsChanged ? await this.store.reconcileTurnMappings(record3.hostThreadId, orderedMappings) : record3;
     return {
       record: nextRecord,
       turns: aligned.map(
-        ({ mapping, snapshot: turn }) => projectHistoricalTurn({ turnId: mapping.hostTurnId, cwd: record2.cwd, snapshot: turn })
+        ({ mapping, snapshot: turn }) => projectHistoricalTurn({ turnId: mapping.hostTurnId, cwd: record3.cwd, snapshot: turn })
       )
     };
   }
@@ -48922,9 +49238,9 @@ function createExternalThreadRecordInput(input) {
   };
 }
 function externalThreadValue(input) {
-  const { record: record2 } = input;
-  const createdAt = Math.floor(Date.parse(record2.createdAt) / 1e3);
-  const updatedAt = Math.floor(Date.parse(record2.updatedAt) / 1e3);
+  const { record: record3 } = input;
+  const createdAt = Math.floor(Date.parse(record3.createdAt) / 1e3);
+  const updatedAt = Math.floor(Date.parse(record3.updatedAt) / 1e3);
   const preview = input.turns.flatMap((turn) => Array.isArray(turn.items) ? turn.items : []).find(
     (item) => typeof item === "object" && item !== null && !Array.isArray(item) && item.type === "userMessage"
   );
@@ -48933,10 +49249,10 @@ function externalThreadValue(input) {
     (part) => typeof part === "object" && part !== null && !Array.isArray(part) && part.type === "text"
   ).map((part) => typeof part.text === "string" ? part.text : "").join("\n") : "";
   return {
-    id: record2.hostThreadId,
+    id: record3.hostThreadId,
     sessionId: input.sessionId,
     path: null,
-    cwd: record2.cwd,
+    cwd: record3.cwd,
     source: "vscode",
     threadSource: null,
     modelProvider: "codexhost",
@@ -48947,13 +49263,13 @@ function externalThreadValue(input) {
     status: input.loaded === false ? { type: "notLoaded" } : input.running ? { type: "active", activeFlags: [] } : { type: "idle" },
     turns: input.turns,
     preview: previewText,
-    name: record2.title || null,
+    name: record3.title || null,
     gitInfo: null,
-    forkedFromId: record2.forkSource?.hostThreadId ?? null,
+    forkedFromId: record3.forkSource?.hostThreadId ?? null,
     parentThreadId: null,
-    ephemeral: record2.ephemeral,
+    ephemeral: record3.ephemeral,
     canAcceptDirectInput: input.loaded === false ? null : true,
-    historyMode: record2.historyMode,
+    historyMode: record3.historyMode,
     isPinned: false,
     agentNickname: null,
     agentRole: null,
@@ -49083,7 +49399,8 @@ async function executeExternalThreadFork(input) {
       session,
       sessionId: source.sessionId,
       thread,
-      turns: aligned.turns
+      turns: aligned.turns,
+      ...snapshot.value.state ? { restoredState: snapshot.value.state } : {}
     });
     return {
       ok: true,
@@ -49244,6 +49561,96 @@ function listExternalItems(turns, params) {
 }
 
 // packages/host-runtime/src/external-thread-rollback.ts
+function sameCurrentConfiguration(current, replacement) {
+  return current.effectiveModel?.id === replacement.effectiveModel?.id && current.effectiveThinkingOptionId === replacement.effectiveThinkingOptionId;
+}
+async function executeCurrentLastTurnRollback(input) {
+  const { current, adapters, repository, runtime } = input;
+  if (current.record.turnMappings.length === 0) {
+    return {
+      ok: false,
+      error: { code: -32076, message: "External Thread has no Turn to roll back" }
+    };
+  }
+  const currentNativeRef = current.record.nativeSessionRef;
+  const adapter = adapters.get(current.harnessId);
+  if (!currentNativeRef || !adapter) {
+    return {
+      ok: false,
+      error: { code: -32079, message: "External Native Session is unavailable" }
+    };
+  }
+  let opened;
+  try {
+    opened = await adapter.open({
+      kind: "rollbackLastTurn",
+      cwd: current.cwd,
+      sourceRef: currentNativeRef
+    });
+  } catch {
+    return { ok: false, error: { code: -32076, message: "External Thread rollback failed" } };
+  }
+  if (!opened.ok) {
+    return { ok: false, error: mapExternalThreadHarnessError(opened.error, "fork") };
+  }
+  const session = opened.value;
+  const finalNativeRef = session.initialState.nativeRef;
+  if (!finalNativeRef || finalNativeRef.harnessId !== current.harnessId || finalNativeRef.nativeSessionId === currentNativeRef.nativeSessionId) {
+    await session.close().catch(() => void 0);
+    return {
+      ok: false,
+      error: { code: -32076, message: "External rollback did not create a distinct Session" }
+    };
+  }
+  const snapshot = await session.readSnapshot();
+  if (!snapshot.ok) {
+    await session.close().catch(() => void 0);
+    return { ok: false, error: mapExternalThreadHarnessError(snapshot.error, "read") };
+  }
+  if (snapshot.value.turns.length !== current.record.turnMappings.length - 1) {
+    await session.close().catch(() => void 0);
+    return {
+      ok: false,
+      error: { code: -32080, message: "External rollback did not remove exactly one Turn" }
+    };
+  }
+  const replacementState = snapshot.value.state ?? session.initialState;
+  if (!sameCurrentConfiguration(current.stateObserver.state, replacementState)) {
+    await session.close().catch(() => void 0);
+    return {
+      ok: false,
+      error: { code: -32080, message: "External rollback changed Model or Thinking" }
+    };
+  }
+  let aligned;
+  try {
+    aligned = await repository.commitLastTurnRollback(
+      current.record,
+      finalNativeRef,
+      snapshot.value
+    );
+  } catch {
+    await session.close().catch(() => void 0);
+    return {
+      ok: false,
+      error: { code: -32081, message: "External rollback could not be persisted" }
+    };
+  }
+  const thread = externalThreadValue({
+    record: aligned.record,
+    turns: aligned.turns,
+    sessionId: current.sessionId
+  });
+  await runtime.replace(current, {
+    record: aligned.record,
+    session,
+    sessionId: current.sessionId,
+    thread,
+    turns: aligned.turns,
+    restoredState: replacementState
+  });
+  return { ok: true, thread };
+}
 async function executeExternalThreadRollback(input) {
   const { derived, rollback, adapters, repository, runtime } = input;
   if (derived.running) {
@@ -49251,6 +49658,14 @@ async function executeExternalThreadRollback(input) {
   }
   const refreshError = await runtime.refresh(derived);
   if (refreshError) return { ok: false, error: refreshError };
+  if (rollback.numTurns === 1 && derived.session.capabilities.history.rollbackLastTurn) {
+    return executeCurrentLastTurnRollback({
+      current: derived,
+      adapters,
+      repository,
+      runtime
+    });
+  }
   const forkSource = derived.record.forkSource;
   if (!forkSource) {
     return {
@@ -49470,9 +49885,10 @@ var ExternalThreadRuntime = class {
     if (!this.#adapters.has(harnessId)) {
       throw new Error(`External Harness '${input.record.harnessId}' is not registered`);
     }
-    const effectiveModel = input.requestedModel ?? input.session.initialState.effectiveModel;
-    const effectiveThinkingOptionId = input.requestedThinkingOptionId ?? input.session.initialState.effectiveThinkingOptionId;
-    const effectivePermissionModeId = input.requestedPermissionModeId ?? input.session.initialState.effectivePermissionModeId;
+    const initialState = input.restoredState ?? input.session.initialState;
+    const effectiveModel = input.requestedModel ?? initialState.effectiveModel;
+    const effectiveThinkingOptionId = input.requestedThinkingOptionId ?? initialState.effectiveThinkingOptionId;
+    const effectivePermissionModeId = input.requestedPermissionModeId ?? initialState.effectivePermissionModeId;
     const externalThread = {
       id: input.record.hostThreadId,
       cwd: input.record.cwd,
@@ -49484,7 +49900,7 @@ var ExternalThreadRuntime = class {
       ...effectivePermissionModeId ? { requestedPermissionModeId: effectivePermissionModeId } : {},
       record: input.record,
       sessionId: input.sessionId,
-      stateObserver: new SessionStateObserver(input.session.initialState),
+      stateObserver: new SessionStateObserver(initialState),
       thread: input.thread,
       transportModelId: input.record.transportModelId,
       turns: input.turns,
@@ -49518,23 +49934,23 @@ var ExternalThreadRuntime = class {
   async locate(threadId2) {
     const loaded = this.#threads.get(threadId2);
     if (loaded) return { kind: "external", record: loaded.record, thread: loaded };
-    let record2;
+    let record3;
     try {
-      record2 = await this.#repository.find(threadId2);
+      record3 = await this.#repository.find(threadId2);
     } catch {
       return {
         kind: "error",
         error: { code: -32081, message: "External Thread ownership could not be read" }
       };
     }
-    if (!record2) return { kind: "official" };
-    if (record2.state !== "ready" || !record2.nativeSessionRef) {
+    if (!record3) return { kind: "official" };
+    if (record3.state !== "ready" || !record3.nativeSessionRef) {
       return {
         kind: "error",
         error: { code: -32079, message: "External Native Session is unavailable" }
       };
     }
-    return { kind: "external", record: record2, thread: null };
+    return { kind: "external", record: record3, thread: null };
   }
   async resolve(threadId2) {
     const location = await this.locate(threadId2);
@@ -49542,12 +49958,12 @@ var ExternalThreadRuntime = class {
     if (location.thread) {
       return { kind: "external", thread: location.thread, historyFresh: false };
     }
-    const { record: record2 } = location;
+    const { record: record3 } = location;
     let restoring = this.#restores.get(threadId2);
     if (!restoring) {
       const restored = this.#threads.get(threadId2);
       if (restored) return { kind: "external", thread: restored, historyFresh: false };
-      restoring = this.#restore(record2).finally(() => {
+      restoring = this.#restore(record3).finally(() => {
         this.#restores.delete(threadId2);
       });
       this.#restores.set(threadId2, restoring);
@@ -49601,10 +50017,10 @@ var ExternalThreadRuntime = class {
       return failure2;
     }
   }
-  async #restore(record2) {
-    const harnessId = record2.harnessId;
+  async #restore(record3) {
+    const harnessId = record3.harnessId;
     const adapter = this.#adapters.get(harnessId);
-    if (!adapter || !record2.nativeSessionRef) {
+    if (!adapter || !record3.nativeSessionRef) {
       throw new ExternalThreadOpenError({
         code: -32077,
         message: "External Harness is unavailable"
@@ -49612,8 +50028,8 @@ var ExternalThreadRuntime = class {
     }
     const opened = await adapter.open({
       kind: "resume",
-      cwd: record2.cwd,
-      nativeRef: record2.nativeSessionRef
+      cwd: record3.cwd,
+      nativeRef: record3.nativeSessionRef
     });
     if (!opened.ok) {
       throw new ExternalThreadOpenError(mapExternalThreadHarnessError(opened.error, "resume"));
@@ -49624,7 +50040,7 @@ var ExternalThreadRuntime = class {
       if (!snapshot.ok) {
         throw new ExternalThreadOpenError(mapExternalThreadHarnessError(snapshot.error, "read"));
       }
-      const aligned = await this.#repository.alignSnapshot(record2, snapshot.value);
+      const aligned = await this.#repository.alignSnapshot(record3, snapshot.value);
       const sessionId = await this.#repository.sessionTreeId(aligned.record);
       return this.register({
         record: aligned.record,
@@ -49635,7 +50051,8 @@ var ExternalThreadRuntime = class {
           turns: aligned.turns,
           sessionId
         }),
-        turns: aligned.turns
+        turns: aligned.turns,
+        ...snapshot.value.state ? { restoredState: snapshot.value.state } : {}
       });
     } catch (error52) {
       await session.close().catch(() => void 0);
@@ -49829,17 +50246,17 @@ function externalAnchor(entry) {
   if (entry.source !== "external") throw new Error("Expected an External Thread list entry");
   return { timestamp: entry.timestamp, threadId: threadId(entry.thread) };
 }
-function includesExternalRecord(record2, query) {
-  if (record2.state !== "ready" || !record2.nativeSessionRef) return false;
-  if (record2.archived !== query.archived) return false;
-  if (query.cwd !== null && !query.cwd.includes(record2.cwd)) return false;
+function includesExternalRecord(record3, query) {
+  if (record3.state !== "ready" || !record3.nativeSessionRef) return false;
+  if (record3.archived !== query.archived) return false;
+  if (query.cwd !== null && !query.cwd.includes(record3.cwd)) return false;
   if (query.modelProviders !== null && query.modelProviders.length > 0 && !query.modelProviders.includes("codexhost")) {
     return false;
   }
   if (query.sourceKinds !== null && query.sourceKinds.length > 0 && !query.sourceKinds.includes("vscode")) {
     return false;
   }
-  if (query.searchTerm !== null && !record2.title.toLowerCase().includes(query.searchTerm.toLowerCase())) {
+  if (query.searchTerm !== null && !record3.title.toLowerCase().includes(query.searchTerm.toLowerCase())) {
     return false;
   }
   if (query.parentThreadId !== null || query.ancestorThreadId !== null) return false;
@@ -49847,47 +50264,47 @@ function includesExternalRecord(record2, query) {
   return true;
 }
 function resolveExternalSessionTreeIds(records) {
-  const byId = new Map(records.map((record2) => [record2.hostThreadId, record2]));
+  const byId = new Map(records.map((record3) => [record3.hostThreadId, record3]));
   const resolved = /* @__PURE__ */ new Map();
   const resolve2 = (start) => {
     const cached2 = resolved.get(start.hostThreadId);
     if (cached2) return cached2;
-    const path8 = [];
+    const path11 = [];
     const visited = /* @__PURE__ */ new Set();
     let current = start;
     while (true) {
       const known = resolved.get(current.hostThreadId);
       if (known) {
-        for (const record2 of path8) resolved.set(record2.hostThreadId, known);
+        for (const record3 of path11) resolved.set(record3.hostThreadId, known);
         return known;
       }
       if (visited.has(current.hostThreadId)) {
         throw new Error("External Thread Fork tree contains a cycle");
       }
       visited.add(current.hostThreadId);
-      path8.push(current);
+      path11.push(current);
       const sourceId = current.forkSource?.hostThreadId;
       const source = sourceId ? byId.get(sourceId) : void 0;
       if (!source) {
         const root = current.hostThreadId;
-        for (const record2 of path8) resolved.set(record2.hostThreadId, root);
+        for (const record3 of path11) resolved.set(record3.hostThreadId, root);
         return root;
       }
       current = source;
     }
   };
-  for (const record2 of records) resolve2(record2);
+  for (const record3 of records) resolve2(record3);
   return resolved;
 }
 function listExternalThreadMetadata(input) {
   if (!input.query.supportsExternal) return { data: [], hasMore: false };
   const sessionIds = resolveExternalSessionTreeIds(input.records);
-  const entries = input.records.filter((record2) => includesExternalRecord(record2, input.query)).map((record2) => {
-    const runtime = input.runtimeFor(record2.hostThreadId);
-    const sessionId = sessionIds.get(record2.hostThreadId);
+  const entries = input.records.filter((record3) => includesExternalRecord(record3, input.query)).map((record3) => {
+    const runtime = input.runtimeFor(record3.hostThreadId);
+    const sessionId = sessionIds.get(record3.hostThreadId);
     if (!sessionId) throw new Error("External Thread Session tree could not be resolved");
     const thread = externalThreadValue({
-      record: record2,
+      record: record3,
       turns: [],
       sessionId,
       ...runtime ? { running: runtime.running } : { loaded: false }
@@ -49895,7 +50312,7 @@ function listExternalThreadMetadata(input) {
     return {
       source: "external",
       thread,
-      timestamp: input.query.sortKey === "created_at" ? unixTimestamp(record2.createdAt, "createdAt") : unixTimestamp(record2.updatedAt, "updatedAt")
+      timestamp: input.query.sortKey === "created_at" ? unixTimestamp(record3.createdAt, "createdAt") : unixTimestamp(record3.updatedAt, "updatedAt")
     };
   }).sort((left, right) => compareThreadListEntries(left, right, input.query.sortDirection)).filter(
     (entry) => !input.anchor || compareExternalAnchor(entry, input.anchor, input.query.sortDirection) > 0
@@ -49977,7 +50394,7 @@ async function aggregateThreadList(input) {
   let officialIndex = 0;
   let firstOfficialBackwardsCursor;
   let officialRequestCount = 0;
-  const externalIds = new Set(input.records.map((record2) => record2.hostThreadId));
+  const externalIds = new Set(input.records.map((record3) => record3.hostThreadId));
   const requestOfficial = async (cursor, limit) => {
     officialRequestCount += 1;
     if (officialRequestCount > MAX_OFFICIAL_PAGE_REQUESTS) {
@@ -50037,7 +50454,7 @@ async function aggregateThreadList(input) {
   let nextOfficialCursor = officialCursor;
   let nextOfficialDone = officialDone;
   const finalOfficialBatch = officialBatch;
-  if (finalOfficialBatch) {
+  if (finalOfficialBatch && !officialDone) {
     if (officialIndex === 0) {
       nextOfficialCursor = officialBatchStart;
       nextOfficialDone = false;
@@ -50101,7 +50518,15 @@ function officialEnvironment(source) {
     "CODEXHOST_PI_COMMAND",
     "CODEXHOST_ENABLE_CLAUDE_CODE",
     "CODEXHOST_CLAUDE_COMMAND",
-    "CODEXHOST_STOCK_CODEX_PATH"
+    "CODEXHOST_STOCK_CODEX_PATH",
+    "CODEXHOST_LAUNCHER_PID",
+    "CODEXHOST_LAUNCHER_EXECUTABLE",
+    "CODEXHOST_CONTROL_PORT",
+    "CODEXHOST_CONTROL_NONCE",
+    "CODEXHOST_NPM_NODE_PATH",
+    "CODEXHOST_NPM_CLI_PATH",
+    "CODEXHOST_NPM_LAUNCHER_PATH",
+    "CODEXHOST_NPM_PACKAGE_ROOT"
   ]);
   return Object.fromEntries(Object.entries(source).filter(([key]) => !internal.has(key)));
 }
@@ -50145,7 +50570,7 @@ function isHostApprovalRequestId(value) {
 function isHostQuestionRequestId(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= HOST_QUESTION_REQUEST_ID_MIN && value <= HOST_QUESTION_REQUEST_ID_MAX;
 }
-function classifyCreateRequestRoute(request, defaultAgent2) {
+function classifyCreateRequestRoute(request, defaultAgent) {
   const route = decodeCreateRoute(request);
   if (!route) return null;
   if (route.harnessId !== "codex") {
@@ -50159,8 +50584,8 @@ function classifyCreateRequestRoute(request, defaultAgent2) {
   return {
     requestMethod: "thread/start",
     modelCarrier: "official-model",
-    selectedHarness: defaultAgent2,
-    selectionSource: defaultAgent2 === "pi" ? "default-agent" : "official-model"
+    selectedHarness: defaultAgent,
+    selectionSource: defaultAgent === "pi" ? "default-agent" : "official-model"
   };
 }
 function requestObject(request) {
@@ -50322,6 +50747,10 @@ var AppServerHost = class {
         continue;
       }
       const request = requestResult.data;
+      if (request.method === "codexhost/update/check" || request.method === "codexhost/update/start" || request.method === "codexhost/update/status") {
+        await this.#handleUpdateRequest(request);
+        continue;
+      }
       if (request.method === "codexhost/harness/inspect") {
         await this.#inspectHarness(request);
         continue;
@@ -50334,6 +50763,10 @@ var AppServerHost = class {
         await this.#inspectThread(request);
         continue;
       }
+      if (request.method === "codexhost/thread/usage/inspect") {
+        await this.#inspectThreadUsage(request);
+        continue;
+      }
       if (request.method === "codexhost/thread/ownership/list") {
         await this.#listThreadOwnership(request);
         continue;
@@ -50662,9 +51095,9 @@ var AppServerHost = class {
       );
       return;
     }
-    let record2;
+    let record3;
     try {
-      record2 = await this.#repository.setArchived(location.record.hostThreadId, archived);
+      record3 = await this.#repository.setArchived(location.record.hostThreadId, archived);
     } catch {
       await this.#writer.json(
         rpcError(request, -32081, "External Thread archive state could not be persisted")
@@ -50672,13 +51105,13 @@ var AppServerHost = class {
       return;
     }
     const projected = externalThreadValue({
-      record: record2,
+      record: record3,
       turns: [],
       sessionId,
       ...location.thread ? { running: location.thread.running } : { loaded: false }
     });
     if (location.thread) {
-      location.thread.record = record2;
+      location.thread.record = record3;
       location.thread.thread = {
         ...location.thread.thread,
         ...projected,
@@ -50690,9 +51123,40 @@ var AppServerHost = class {
     );
     await this.#writer.json({
       method: archived ? "thread/archived" : "thread/unarchived",
-      params: { threadId: record2.hostThreadId }
+      params: { threadId: record3.hostThreadId }
     });
   }
+  async #handleUpdateRequest(request) {
+    const params = updateEmptyParamsSchema.safeParse(
+      request.params === void 0 ? {} : request.params
+    );
+    if (!params.success) {
+      await this.#writer.json(rpcError(request, -32602, "Update params must be empty"));
+      return;
+    }
+    const coordinator = this.#options.updateCoordinator;
+    if (!coordinator) {
+      await this.#writer.json(rpcError(request, -32090, "Application updates are unavailable"));
+      return;
+    }
+    try {
+      if (request.method === "codexhost/update/check") {
+        const result2 = updateCheckResultSchema.parse(await coordinator.check());
+        await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(result2) }));
+        return;
+      }
+      if (request.method === "codexhost/update/status") {
+        const result2 = updateStatusResultSchema.parse(await coordinator.status());
+        await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(result2) }));
+        return;
+      }
+      const result = updateStartResultSchema.parse(await coordinator.start());
+      await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(result) }));
+      coordinator.requestShutdown();
+    } catch (error52) {
+      await this.#writer.json(rpcError(request, -32091, errorMessage3(error52).slice(0, 500)));
+    }
+  }
   async #inspectHarness(request) {
     const params = harnessInspectParamsSchema.safeParse(request.params);
     if (!params.success) {
@@ -50760,11 +51224,35 @@ var AppServerHost = class {
           effectivePermissionModeId: resolution.thread.stateObserver.state.effectivePermissionModeId
         } : {},
         history: resolution.thread.session.capabilities.history,
+        ...resolution.thread.latestUsage ? { usage: resolution.thread.latestUsage } : {},
         locked: true
       }
     );
     await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(inspection) }));
   }
+  async #inspectThreadUsage(request) {
+    const params = threadUsageInspectionParamsSchema.safeParse(request.params);
+    if (!params.success) {
+      await this.#writer.json(rpcError(request, -32602, "Invalid Thread Usage inspection params"));
+      return;
+    }
+    const resolution = await this.#resolveExternalThread(params.data.threadId);
+    if (resolution.kind === "error") {
+      await this.#writer.json(rpcError(request, resolution.error.code, resolution.error.message));
+      return;
+    }
+    if (resolution.kind === "official") {
+      await this.#writer.json(
+        rpcError(request, -32079, "Thread Usage is unavailable for official Codex Threads")
+      );
+      return;
+    }
+    const result = threadUsageInspectionSchema.parse({
+      threadId: params.data.threadId,
+      usage: resolution.thread.latestUsage
+    });
+    await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(result) }));
+  }
   async #listThreadOwnership(request) {
     const params = threadOwnershipListParamsSchema.safeParse(request.params);
     if (!params.success) {
@@ -50774,8 +51262,8 @@ var AppServerHost = class {
     try {
       const threads = await Promise.all(
         params.data.threadIds.map(async (threadId2) => {
-          const record2 = await this.#repository.find(threadId2);
-          return record2 ? { threadId: threadId2, owner: "external", harnessId: record2.harnessId } : { threadId: threadId2, owner: "codex" };
+          const record3 = await this.#repository.find(threadId2);
+          return record3 ? { threadId: threadId2, owner: "external", harnessId: record3.harnessId } : { threadId: threadId2, owner: "codex" };
         })
       );
       const result = threadOwnershipListResultSchema.parse({ threads });
@@ -51042,9 +51530,9 @@ var AppServerHost = class {
       ephemeral: params.ephemeral === true,
       historyMode: params.historyMode === "paginated" ? "paginated" : "legacy"
     });
-    let record2;
+    let record3;
     try {
-      record2 = await this.#repository.createProvisional(recordInput);
+      record3 = await this.#repository.createProvisional(recordInput);
     } catch {
       this.#routeObservationTracker.rejectCreate(request.id);
       await this.#writer.json(rpcError(request, -32081, "External Thread could not be persisted"));
@@ -51059,7 +51547,7 @@ var AppServerHost = class {
     });
     if (!sessionResult.ok) {
       this.#routeObservationTracker.rejectCreate(request.id);
-      await this.#repository.removeProvisional(record2.hostThreadId).catch(() => void 0);
+      await this.#repository.removeProvisional(record3.hostThreadId).catch(() => void 0);
       const mapped = mapExternalThreadHarnessError(sessionResult.error, "create");
       await this.#writer.json(rpcError(request, mapped.code, mapped.message));
       return;
@@ -51067,20 +51555,20 @@ var AppServerHost = class {
     const session = sessionResult.value;
     try {
       if (session.initialState.nativeRef) {
-        record2 = await this.#repository.commitNative(
-          record2.hostThreadId,
+        record3 = await this.#repository.commitNative(
+          record3.hostThreadId,
           session.initialState.nativeRef
         );
       }
       const thread = externalThreadValue({
-        record: record2,
+        record: record3,
         turns: [],
-        sessionId: record2.hostThreadId
+        sessionId: record3.hostThreadId
       });
       const externalThread = this.#registerExternalThread({
-        record: record2,
+        record: record3,
         session,
-        sessionId: record2.hostThreadId,
+        sessionId: record3.hostThreadId,
         thread,
         turns: [],
         ...requestedModel ? { requestedModel } : {},
@@ -51113,10 +51601,10 @@ var AppServerHost = class {
         params: { thread }
       });
     } catch {
-      this.#externalRuntime.remove(record2.hostThreadId);
-      this.#routeObservationTracker.forgetThread(record2.hostThreadId);
+      this.#externalRuntime.remove(record3.hostThreadId);
+      this.#routeObservationTracker.forgetThread(record3.hostThreadId);
       await session.close().catch(() => void 0);
-      await this.#repository.removeProvisional(record2.hostThreadId).catch(() => void 0);
+      await this.#repository.removeProvisional(record3.hostThreadId).catch(() => void 0);
       await this.#writer.json(rpcError(request, -32081, "External Thread could not be persisted"));
     }
   }
@@ -51231,9 +51719,9 @@ var AppServerHost = class {
       );
       return;
     }
-    let record2;
+    let record3;
     try {
-      record2 = await this.#repository.setTitle(location.record.hostThreadId, name);
+      record3 = await this.#repository.setTitle(location.record.hostThreadId, name);
     } catch {
       await this.#writer.json(
         rpcError(request, -32081, "External Thread title could not be persisted")
@@ -51241,7 +51729,7 @@ var AppServerHost = class {
       return;
     }
     if (location.thread) {
-      location.thread.record = record2;
+      location.thread.record = record3;
       location.thread.thread.name = name;
       location.thread.thread.updatedAt = unixSeconds();
     }
@@ -51404,128 +51892,20 @@ var AppServerHost = class {
       return;
     }
     const params = requestObject(request);
-    let requestedSelection;
-    try {
-      requestedSelection = decodeExternalTransportSelection(thread.harnessId, params.model);
-    } catch (error52) {
-      await this.#writer.json(rpcError(request, -32602, errorMessage3(error52)));
-      return;
-    }
-    if (typeof params.model === "string" && requestedSelection === null) {
-      await this.#writer.json(
-        rpcError(request, -32602, "Turn Model carrier does not belong to the Thread Harness")
-      );
-      return;
-    }
-    const requestedModel = requestedSelection?.model;
-    if (requestedModel) {
-      if (!thread.session.capabilities.configuration.selectModel) {
-        await this.#writer.json(
-          rpcError(request, -32078, "External Harness does not support Model selection")
-        );
-        return;
-      }
-      const current = thread.stateObserver.state.effectiveModel;
-      const pendingCreateSelection = current === void 0 && thread.requestedModel?.id === requestedModel.id;
-      if (current?.id !== requestedModel.id && !pendingCreateSelection) {
-        const beforeRevision = thread.stateObserver.revision;
-        const selection = await thread.session.execute({
-          type: "model.select",
-          model: requestedModel
-        });
-        if (!selection.ok) {
-          await this.#writer.json(rpcError(request, -32078, selection.error.message));
-          return;
-        }
-        try {
-          const state = await thread.stateObserver.waitForChange(beforeRevision);
-          if (state.effectiveModel?.id !== requestedModel.id) {
-            throw new Error("Harness Session activated a different Model");
-          }
-        } catch (error52) {
-          await this.#writer.json(rpcError(request, -32078, errorMessage3(error52)));
-          return;
-        }
-      }
-      thread.requestedModel = requestedModel;
-    }
-    const requestedThinkingOptionId = requestedSelection?.thinkingOptionId;
-    if (requestedThinkingOptionId) {
-      if (!thread.session.capabilities.configuration.selectThinkingOption) {
-        await this.#writer.json(
-          rpcError(request, -32078, "External Harness does not support Thinking selection")
-        );
+    if (typeof params.model === "string") {
+      let route;
+      try {
+        route = decodeCreateRoute({ id: request.id, method: "thread/start", params });
+      } catch (error52) {
+        await this.#writer.json(rpcError(request, -32602, errorMessage3(error52)));
         return;
       }
-      const current = thread.stateObserver.state.effectiveThinkingOptionId;
-      const pendingCreateSelection = current === void 0 && thread.requestedThinkingOptionId === requestedThinkingOptionId;
-      if (current !== requestedThinkingOptionId && !pendingCreateSelection) {
-        const beforeRevision = thread.stateObserver.revision;
-        const selection = await thread.session.execute({
-          type: "thinking.select",
-          thinkingOptionId: requestedThinkingOptionId
-        });
-        if (!selection.ok) {
-          await this.#writer.json(rpcError(request, -32078, selection.error.message));
-          return;
-        }
-        try {
-          const state = await thread.stateObserver.waitForChange(beforeRevision);
-          if (!state.effectiveThinkingOptionId) {
-            throw new Error("Harness Session did not report effective Thinking");
-          }
-          thread.requestedThinkingOptionId = state.effectiveThinkingOptionId;
-        } catch (error52) {
-          await this.#writer.json(rpcError(request, -32078, errorMessage3(error52)));
-          return;
-        }
-      }
-    }
-    const requestedPermissionModeId = requestedSelection?.permissionModeId;
-    if (requestedPermissionModeId) {
-      if (!thread.session.capabilities.configuration.selectPermissionMode) {
+      if (route?.harnessId !== "codex" && route?.harnessId !== thread.harnessId) {
         await this.#writer.json(
-          rpcError(request, -32078, "External Harness does not support Permission Mode selection")
+          rpcError(request, -32602, "Turn Model carrier does not belong to the Thread Harness")
         );
         return;
       }
-      const current = thread.stateObserver.state.effectivePermissionModeId;
-      const pendingCreateSelection = current === void 0 && thread.requestedPermissionModeId === requestedPermissionModeId;
-      if (current !== requestedPermissionModeId && !pendingCreateSelection) {
-        const beforeRevision = thread.stateObserver.revision;
-        const selection = await thread.session.execute({
-          type: "permissionMode.select",
-          permissionModeId: requestedPermissionModeId
-        });
-        if (!selection.ok) {
-          await this.#writer.json(rpcError(request, -32078, selection.error.message));
-          return;
-        }
-        try {
-          const state = await thread.stateObserver.waitForChange(beforeRevision);
-          if (state.effectivePermissionModeId !== requestedPermissionModeId) {
-            throw new Error("Harness Session activated a different Permission Mode");
-          }
-        } catch (error52) {
-          await this.#writer.json(rpcError(request, -32078, errorMessage3(error52)));
-          return;
-        }
-      }
-      thread.requestedPermissionModeId = requestedPermissionModeId;
-    }
-    if (requestedModel || requestedThinkingOptionId || requestedPermissionModeId) {
-      const transportModelId = params.model;
-      thread.transportModelId = transportModelId;
-      if (requestedPermissionModeId) {
-        try {
-          thread.record = await this.#repository.setTransportModelId(
-            thread.record.hostThreadId,
-            transportModelId
-          );
-        } catch (error52) {
-          this.#diagnose(error52);
-        }
-      }
     }
     let text;
     try {
@@ -51955,22 +52335,944 @@ var AppServerHost = class {
   }
 };
 
+// packages/host-runtime/src/update-coordinator.ts
+import { createConnection } from "node:net";
+
+// packages/update-manager/dist/distribution.js
+import { lstat, readFile as readFile2 } from "node:fs/promises";
+import path8 from "node:path";
+
+// packages/update-manager/dist/status.js
+var STATUS_SCHEMA_VERSION = 1;
+var SEMVER_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u;
+function requireSemanticVersion(value) {
+  if (!SEMVER_PATTERN.test(value))
+    throw new Error("update version must be valid semantic version");
+  return value;
+}
+function preparedStatus(version2, installation, now) {
+  return {
+    schemaVersion: STATUS_SCHEMA_VERSION,
+    version: version2,
+    installation,
+    phase: "prepared",
+    updatedAt: Math.floor(now / 1e3)
+  };
+}
+function parseUpdateStatus(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error("background update status must be an object");
+  }
+  const status = value;
+  const allowed2 = ["error", "installation", "phase", "schemaVersion", "updatedAt", "version"];
+  if (Object.keys(status).some((key) => !allowed2.includes(key))) {
+    throw new Error("background update status contains unknown fields");
+  }
+  if (status.schemaVersion !== STATUS_SCHEMA_VERSION || typeof status.version !== "string" || !SEMVER_PATTERN.test(status.version) || !["npm", "windows-installer", "macos-dmg"].includes(String(status.installation)) || !["prepared", "waiting-for-exit", "installing", "restarting", "succeeded", "failed"].includes(String(status.phase)) || !Number.isSafeInteger(status.updatedAt) || status.error !== void 0 && typeof status.error !== "string") {
+    throw new Error("background update status is invalid");
+  }
+  return status;
+}
+
+// packages/update-manager/dist/distribution.js
+var UPDATE_RUNTIME_ENV = Object.freeze({
+  launcherPid: "CODEXHOST_LAUNCHER_PID",
+  launcherExecutable: "CODEXHOST_LAUNCHER_EXECUTABLE",
+  controllerPort: "CODEXHOST_CONTROL_PORT",
+  controllerNonce: "CODEXHOST_CONTROL_NONCE",
+  npmNodePath: "CODEXHOST_NPM_NODE_PATH",
+  npmCliPath: "CODEXHOST_NPM_CLI_PATH",
+  npmLauncherPath: "CODEXHOST_NPM_LAUNCHER_PATH",
+  npmPackageRoot: "CODEXHOST_NPM_PACKAGE_ROOT"
+});
+function object2(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function parseDistributionMetadata(value) {
+  const metadata = object2(value, "distribution metadata");
+  const allowed2 = ["distribution", "schemaVersion", "target", "version"];
+  if (Object.keys(metadata).some((key) => !allowed2.includes(key))) {
+    throw new Error("distribution metadata contains unknown fields");
+  }
+  if (metadata.schemaVersion !== 1 || metadata.distribution !== "npm" && metadata.distribution !== "installer" || !["macos-arm64", "macos-x64", "windows-x64", "windows-arm64"].includes(String(metadata.target)) || typeof metadata.version !== "string") {
+    throw new Error("distribution metadata is invalid");
+  }
+  return {
+    schemaVersion: 1,
+    version: requireSemanticVersion(metadata.version),
+    distribution: metadata.distribution,
+    target: metadata.target
+  };
+}
+function absoluteEnvironmentPath(environment, name) {
+  const value = environment[name];
+  if (!value || !path8.isAbsolute(value))
+    throw new Error(`${name} must be an absolute path`);
+  return path8.normalize(value);
+}
+function positiveEnvironmentInteger(environment, name) {
+  const value = Number(environment[name]);
+  if (!Number.isSafeInteger(value) || value <= 0)
+    throw new Error(`${name} must be positive`);
+  return value;
+}
+function expectedTarget(platform, architecture) {
+  if (platform === "darwin" && architecture === "arm64")
+    return "macos-arm64";
+  if (platform === "darwin" && architecture === "x64")
+    return "macos-x64";
+  if (platform === "win32" && architecture === "arm64")
+    return "windows-arm64";
+  if (platform === "win32" && architecture === "x64")
+    return "windows-x64";
+  throw new Error(`unsupported update host ${platform}/${architecture}`);
+}
+function defaultUpdateStateDirectory(platform = process.platform, environment = process.env) {
+  if (platform === "win32") {
+    const root = environment.LOCALAPPDATA;
+    if (!root || !path8.isAbsolute(root))
+      throw new Error("LOCALAPPDATA is unavailable");
+    return path8.join(root, "codexhost", "updates");
+  }
+  const home = environment.HOME;
+  if (!home || !path8.isAbsolute(home))
+    throw new Error("HOME is unavailable");
+  return platform === "darwin" ? path8.join(home, "Library", "Application Support", "codexhost", "updates") : path8.join(home, ".codexhost", "updates");
+}
+async function resolveInstalledUpdateContext(options) {
+  const environment = options.environment ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const architecture = options.architecture ?? process.arch;
+  if (!path8.isAbsolute(options.hostRuntimePath)) {
+    throw new Error("Host Runtime path must be absolute");
+  }
+  const hostRuntimePath = path8.normalize(options.hostRuntimePath);
+  const runtimeMetadata = await lstat(hostRuntimePath);
+  if (!runtimeMetadata.isFile() || runtimeMetadata.isSymbolicLink()) {
+    throw new Error("Host Runtime must be a regular file");
+  }
+  const appDirectory = path8.dirname(hostRuntimePath);
+  const metadata = parseDistributionMetadata(JSON.parse(await readFile2(path8.join(appDirectory, "codexhost-distribution.json"), "utf8")));
+  const target = expectedTarget(platform, architecture);
+  if (metadata.target !== target) {
+    throw new Error(`installed target ${metadata.target} does not match ${target}`);
+  }
+  const launcherPid = positiveEnvironmentInteger(environment, UPDATE_RUNTIME_ENV.launcherPid);
+  const launcherExecutable = absoluteEnvironmentPath(environment, UPDATE_RUNTIME_ENV.launcherExecutable);
+  const stateDirectory = path8.normalize(options.stateDirectory ?? defaultUpdateStateDirectory(platform, environment));
+  const resourcesRoot = path8.dirname(appDirectory);
+  const installationRoot = platform === "darwin" ? path8.dirname(path8.dirname(resourcesRoot)) : resourcesRoot;
+  const updaterExecutable = path8.join(resourcesRoot, "libexec", platform === "win32" ? "codexhost-updater.exe" : "codexhost-updater");
+  const common = {
+    version: metadata.version,
+    launcherPid,
+    launcherExecutable,
+    updaterExecutable,
+    stateDirectory
+  };
+  const controller = {
+    port: positiveEnvironmentInteger(environment, UPDATE_RUNTIME_ENV.controllerPort),
+    nonce: environment[UPDATE_RUNTIME_ENV.controllerNonce] ?? ""
+  };
+  if (!/^[0-9a-f]{32}$/u.test(controller.nonce)) {
+    throw new Error(`${UPDATE_RUNTIME_ENV.controllerNonce} must be a lowercase nonce`);
+  }
+  if (metadata.distribution === "npm") {
+    const npmOptions = {
+      ...common,
+      nodePath: absoluteEnvironmentPath(environment, UPDATE_RUNTIME_ENV.npmNodePath),
+      npmCliPath: absoluteEnvironmentPath(environment, UPDATE_RUNTIME_ENV.npmCliPath),
+      npmLauncherPath: absoluteEnvironmentPath(environment, UPDATE_RUNTIME_ENV.npmLauncherPath),
+      packageRoot: absoluteEnvironmentPath(environment, UPDATE_RUNTIME_ENV.npmPackageRoot)
+    };
+    if (path8.normalize(npmOptions.packageRoot) !== resourcesRoot) {
+      throw new Error("npm platform package root does not own the Host Runtime");
+    }
+    return { metadata, common, controller, installation: { kind: "npm", options: npmOptions } };
+  }
+  if (platform === "win32") {
+    return {
+      metadata,
+      common,
+      controller,
+      installation: {
+        kind: "windows-installer",
+        options: { ...common, installRoot: installationRoot }
+      }
+    };
+  }
+  if (platform === "darwin") {
+    return {
+      metadata,
+      common,
+      controller,
+      installation: {
+        kind: "macos-dmg",
+        options: { ...common, appPath: installationRoot }
+      }
+    };
+  }
+  throw new Error("installer updates require Windows or macOS");
+}
+
+// packages/update-manager/dist/github-release.js
+var CODEXHOST_LATEST_RELEASE_URL = "https://api.github.com/repos/BytePioneer-AI/codex-host/releases/latest";
+var SHA256_DIGEST_PATTERN = /^sha256:([0-9a-f]{64})$/u;
+var RELEASE_NOTES_URL_PATTERN = /^https:\/\/github\.com\/BytePioneer-AI\/codex-host\/releases\/tag\/(v[0-9A-Za-z.+-]+)$/u;
+var DOWNLOAD_URL_PREFIX = "https://github.com/BytePioneer-AI/codex-host/releases/download/";
+function record2(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function releaseAsset(value) {
+  const asset = record2(value, "GitHub Release asset");
+  if (typeof asset.name !== "string" || asset.name.length === 0 || asset.name.length > 160 || !Number.isSafeInteger(asset.size) || asset.size <= 0 || asset.size > 2 * 1024 * 1024 * 1024 || asset.digest != null && typeof asset.digest !== "string" || typeof asset.browser_download_url !== "string" || !asset.browser_download_url.startsWith(DOWNLOAD_URL_PREFIX)) {
+    throw new Error("GitHub Release asset is invalid");
+  }
+  const url2 = new URL(asset.browser_download_url);
+  if (url2.username || url2.password || url2.search || url2.hash) {
+    throw new Error("GitHub Release asset URL is invalid");
+  }
+  return {
+    name: asset.name,
+    size: asset.size,
+    digest: typeof asset.digest === "string" ? asset.digest : null,
+    downloadUrl: asset.browser_download_url
+  };
+}
+function parseLatestGitHubRelease(value) {
+  const release = record2(value, "GitHub latest Release");
+  if (release.draft !== false || release.prerelease !== false || typeof release.tag_name !== "string" || !release.tag_name.startsWith("v") || typeof release.html_url !== "string" || release.body != null && typeof release.body !== "string" || !Array.isArray(release.assets)) {
+    throw new Error("GitHub latest Release is invalid");
+  }
+  const version2 = requireSemanticVersion(release.tag_name.slice(1));
+  const notesMatch = RELEASE_NOTES_URL_PATTERN.exec(release.html_url);
+  if (!notesMatch || notesMatch[1] !== release.tag_name) {
+    throw new Error("GitHub Release notes URL does not match its tag");
+  }
+  const releaseNotes = typeof release.body === "string" && release.body.trim().length > 0 ? release.body.slice(0, 2e4) : null;
+  return Object.freeze({
+    version: version2,
+    releaseNotes,
+    releaseNotesUrl: release.html_url,
+    assets: Object.freeze(release.assets.map(releaseAsset))
+  });
+}
+async function fetchLatestGitHubRelease(options = {}) {
+  const fetchImpl = options.fetch ?? fetch;
+  const response = await fetchImpl(CODEXHOST_LATEST_RELEASE_URL, {
+    headers: {
+      accept: "application/vnd.github+json",
+      "user-agent": "codexhost-updater",
+      "x-github-api-version": "2022-11-28"
+    },
+    redirect: "error",
+    ...options.signal ? { signal: options.signal } : {}
+  });
+  if (!response.ok)
+    throw new Error(`GitHub latest Release request failed with HTTP ${response.status}`);
+  return parseLatestGitHubRelease(await response.json());
+}
+function numericIdentifiers(value) {
+  const core = value.split(/[+-]/u, 1)[0] ?? "";
+  const parts = core.split(".").map(Number);
+  return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0];
+}
+function compareSemanticVersions(leftValue, rightValue) {
+  const left = requireSemanticVersion(leftValue);
+  const right = requireSemanticVersion(rightValue);
+  const leftNumbers = numericIdentifiers(left);
+  const rightNumbers = numericIdentifiers(right);
+  for (let index = 0; index < 3; index += 1) {
+    const difference = (leftNumbers[index] ?? 0) - (rightNumbers[index] ?? 0);
+    if (difference !== 0)
+      return difference < 0 ? -1 : 1;
+  }
+  const leftPrerelease = left.split("-", 2)[1]?.split("+")[0];
+  const rightPrerelease = right.split("-", 2)[1]?.split("+")[0];
+  if (leftPrerelease === rightPrerelease)
+    return 0;
+  if (leftPrerelease === void 0)
+    return 1;
+  if (rightPrerelease === void 0)
+    return -1;
+  const leftParts = leftPrerelease.split(".");
+  const rightParts = rightPrerelease.split(".");
+  for (let index = 0; index < Math.max(leftParts.length, rightParts.length); index += 1) {
+    const leftPart = leftParts[index];
+    const rightPart = rightParts[index];
+    if (leftPart === rightPart)
+      continue;
+    if (leftPart === void 0)
+      return -1;
+    if (rightPart === void 0)
+      return 1;
+    const leftNumeric = /^\d+$/u.test(leftPart);
+    const rightNumeric = /^\d+$/u.test(rightPart);
+    if (leftNumeric && rightNumeric)
+      return Number(leftPart) < Number(rightPart) ? -1 : 1;
+    if (leftNumeric !== rightNumeric)
+      return leftNumeric ? -1 : 1;
+    return leftPart < rightPart ? -1 : 1;
+  }
+  return 0;
+}
+function expectedInstallerAssetName(version2, target) {
+  requireSemanticVersion(version2);
+  const extension = target.startsWith("macos-") ? "dmg" : "exe";
+  return `codexhost-${version2}-${target}.${extension}`;
+}
+function selectInstallerReleaseArtifact(release, target) {
+  const name = expectedInstallerAssetName(release.version, target);
+  const matches = release.assets.filter((asset2) => asset2.name === name);
+  if (matches.length !== 1)
+    throw new Error(`GitHub Release must contain exactly one ${name}`);
+  const asset = matches[0];
+  if (!asset)
+    throw new Error(`GitHub Release must contain exactly one ${name}`);
+  const digest = asset.digest === null ? null : SHA256_DIGEST_PATTERN.exec(asset.digest);
+  const sha256 = digest?.[1];
+  if (!sha256)
+    throw new Error(`GitHub Release asset ${name} has no valid SHA-256 digest`);
+  const expectedPrefix = `${DOWNLOAD_URL_PREFIX}v${release.version}/`;
+  if (!asset.downloadUrl.startsWith(expectedPrefix) || !asset.downloadUrl.endsWith(`/${name}`)) {
+    throw new Error(`GitHub Release asset ${name} has an unexpected download URL`);
+  }
+  return Object.freeze({
+    name,
+    source: Object.freeze({ url: asset.downloadUrl, sha256, size: asset.size })
+  });
+}
+
+// packages/update-manager/dist/operation-state.js
+import { lstat as lstat2, mkdir as mkdir2, open as open3, readFile as readFile3, readdir as readdir2, rm as rm3, writeFile } from "node:fs/promises";
+import path9 from "node:path";
+var LOCK_FILE = "active-update-v1.lock";
+var STATUS_FILE = "status-v1.json";
+var TERMINAL_PHASES = /* @__PURE__ */ new Set(["succeeded", "failed"]);
+async function regularFile(filePath) {
+  try {
+    const metadata = await lstat2(filePath);
+    return metadata.isFile() && !metadata.isSymbolicLink();
+  } catch (error52) {
+    if (error52.code === "ENOENT")
+      return false;
+    throw error52;
+  }
+}
+async function discoverLatestUpdateStatus(stateDirectory) {
+  if (!path9.isAbsolute(stateDirectory))
+    throw new Error("update state directory must be absolute");
+  let entries;
+  try {
+    entries = await readdir2(stateDirectory, { withFileTypes: true });
+  } catch (error52) {
+    if (error52.code === "ENOENT")
+      return null;
+    throw error52;
+  }
+  const candidates2 = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.isSymbolicLink() || !entry.name.startsWith("update-"))
+      continue;
+    const statusPath = path9.join(stateDirectory, entry.name, STATUS_FILE);
+    if (!await regularFile(statusPath))
+      continue;
+    try {
+      candidates2.push({
+        statusPath,
+        status: parseUpdateStatus(JSON.parse(await readFile3(statusPath, "utf8")))
+      });
+    } catch {
+    }
+  }
+  candidates2.sort((left, right) => right.status.updatedAt - left.status.updatedAt);
+  return candidates2[0] ?? null;
+}
+async function cleanupTerminalUpdateState(stateDirectory, options = {}) {
+  const now = Math.floor((options.now ?? Date.now()) / 1e3);
+  const retentionSeconds = options.retentionSeconds ?? 7 * 24 * 60 * 60;
+  let entries;
+  try {
+    entries = await readdir2(stateDirectory, { withFileTypes: true });
+  } catch (error52) {
+    if (error52.code === "ENOENT")
+      return;
+    throw error52;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.isSymbolicLink() || !entry.name.startsWith("update-"))
+      continue;
+    const directory = path9.join(stateDirectory, entry.name);
+    const statusPath = path9.join(directory, STATUS_FILE);
+    try {
+      const status = parseUpdateStatus(JSON.parse(await readFile3(statusPath, "utf8")));
+      if (TERMINAL_PHASES.has(status.phase) && now - status.updatedAt > retentionSeconds) {
+        await rm3(directory, { recursive: true, force: true });
+      }
+    } catch {
+    }
+  }
+}
+async function acquireUpdateOperationLock(stateDirectory) {
+  if (!path9.isAbsolute(stateDirectory))
+    throw new Error("update state directory must be absolute");
+  await mkdir2(stateDirectory, { recursive: true, mode: 448 });
+  const lockPath = path9.join(stateDirectory, LOCK_FILE);
+  let handle;
+  try {
+    handle = await open3(lockPath, "wx", 384);
+  } catch (error52) {
+    if (error52.code === "EEXIST")
+      return null;
+    throw error52;
+  }
+  await handle.writeFile(`${JSON.stringify({ ownerPid: process.pid, statusPath: null })}
+`, "utf8");
+  await handle.sync();
+  await handle.close();
+  let released = false;
+  return {
+    path: lockPath,
+    async setStatusPath(statusPath) {
+      if (released)
+        throw new Error("update operation lock is released");
+      if (!path9.isAbsolute(statusPath))
+        throw new Error("update status path must be absolute");
+      await writeFile(lockPath, `${JSON.stringify({ ownerPid: process.pid, statusPath: path9.normalize(statusPath) })}
+`, { encoding: "utf8", mode: 384 });
+    },
+    async release() {
+      if (released)
+        return;
+      released = true;
+      await rm3(lockPath, { force: true });
+    }
+  };
+}
+async function recoverUpdateOperationLock(stateDirectory) {
+  const lockPath = path9.join(stateDirectory, LOCK_FILE);
+  if (!await regularFile(lockPath))
+    return;
+  let statusPath;
+  try {
+    const value = JSON.parse(await readFile3(lockPath, "utf8"));
+    statusPath = value.statusPath;
+  } catch {
+    return;
+  }
+  if (typeof statusPath !== "string" || !path9.isAbsolute(statusPath))
+    return;
+  try {
+    const status = parseUpdateStatus(JSON.parse(await readFile3(statusPath, "utf8")));
+    if (TERMINAL_PHASES.has(status.phase))
+      await rm3(lockPath, { force: true });
+  } catch {
+  }
+}
+
+// packages/update-manager/dist/update-manager.js
+import { spawn as spawn4 } from "node:child_process";
+import { randomUUID as randomUUID8 } from "node:crypto";
+import { chmod, copyFile as copyFile2, lstat as lstat4, mkdir as mkdir3, readFile as readFile4, rename as rename2, rm as rm4, writeFile as writeFile2 } from "node:fs/promises";
+import path10 from "node:path";
+
+// packages/update-manager/dist/artifact.js
+import { createHash as createHash2 } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { lstat as lstat3, open as open4 } from "node:fs/promises";
+var MAX_ARTIFACT_BYTES = 2 * 1024 * 1024 * 1024;
+var SHA256_PATTERN = /^[0-9a-f]{64}$/u;
+function validateArtifact(source) {
+  const url2 = new URL(source.url);
+  if (url2.protocol !== "https:" || url2.username || url2.password) {
+    throw new Error("update artifact URL must use HTTPS without credentials");
+  }
+  if (!SHA256_PATTERN.test(source.sha256)) {
+    throw new Error("update artifact SHA-256 must be lowercase hexadecimal");
+  }
+  if (source.size !== void 0 && (!Number.isSafeInteger(source.size) || source.size <= 0 || source.size > MAX_ARTIFACT_BYTES)) {
+    throw new Error(`update artifact size must be between 1 and ${MAX_ARTIFACT_BYTES} bytes`);
+  }
+  return source;
+}
+async function writeChunk(file2, chunk) {
+  let offset = 0;
+  while (offset < chunk.byteLength) {
+    const result = await file2.write(chunk, offset, chunk.byteLength - offset, null);
+    if (result.bytesWritten === 0)
+      throw new Error("update artifact write made no progress");
+    offset += result.bytesWritten;
+  }
+}
+async function downloadArtifact(source, destination) {
+  const response = await fetch(source.url, {
+    redirect: "follow",
+    headers: { "accept-encoding": "identity" }
+  });
+  if (!response.ok || response.body === null) {
+    throw new Error(`update artifact download failed with HTTP ${response.status}`);
+  }
+  const finalUrl = new URL(response.url);
+  if (finalUrl.protocol !== "https:" || finalUrl.username || finalUrl.password) {
+    throw new Error("update artifact redirected to a non-HTTPS URL");
+  }
+  const file2 = await open4(destination, "wx", 384);
+  let bytes = 0;
+  try {
+    const reader = response.body.getReader();
+    while (true) {
+      const item = await reader.read();
+      if (item.done)
+        break;
+      bytes += item.value.byteLength;
+      if (bytes > MAX_ARTIFACT_BYTES) {
+        await reader.cancel();
+        throw new Error(`update artifact exceeds ${MAX_ARTIFACT_BYTES} bytes`);
+      }
+      await writeChunk(file2, item.value);
+    }
+    await file2.sync();
+  } finally {
+    await file2.close();
+  }
+  return { bytes, finalUrl: finalUrl.toString() };
+}
+async function sha256File(filePath) {
+  const hash2 = createHash2("sha256");
+  await new Promise((resolve2, reject) => {
+    const stream = createReadStream(filePath);
+    stream.on("data", (chunk) => hash2.update(chunk));
+    stream.once("error", reject);
+    stream.once("end", resolve2);
+  });
+  return hash2.digest("hex");
+}
+async function verifyDownloadedArtifact(source, filePath, result) {
+  const metadata = await lstat3(filePath);
+  if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size === 0) {
+    throw new Error("downloaded update artifact is not a non-empty regular file");
+  }
+  if (metadata.size !== result.bytes) {
+    throw new Error("downloaded update artifact size changed after download");
+  }
+  if (source.size !== void 0 && metadata.size !== source.size) {
+    throw new Error(`update artifact size mismatch: expected ${source.size}, got ${metadata.size}`);
+  }
+  const actual = await sha256File(filePath);
+  if (actual !== source.sha256) {
+    throw new Error(`update artifact SHA-256 mismatch: expected ${source.sha256}, got ${actual}`);
+  }
+}
+
+// packages/update-manager/dist/update-manager.js
+var REQUEST_SCHEMA_VERSION = 1;
+function errorMessage4(error52) {
+  return error52 instanceof Error ? error52.message : String(error52);
+}
+function requireAbsolutePath(value, label) {
+  if (!path10.isAbsolute(value))
+    throw new Error(`${label} must be an absolute path`);
+  return path10.normalize(value);
+}
+async function requireRegularFile(value, label) {
+  const filePath = requireAbsolutePath(value, label);
+  const metadata = await lstat4(filePath).catch((error52) => {
+    throw new Error(`${label} is unavailable: ${errorMessage4(error52)}`);
+  });
+  if (!metadata.isFile() || metadata.isSymbolicLink()) {
+    throw new Error(`${label} must be a regular file`);
+  }
+  return filePath;
+}
+function requireLauncherPid(value) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error("Launcher PID must be a positive integer");
+  }
+  return value;
+}
+async function writePrivateJson(filePath, value) {
+  await writeFile2(filePath, `${JSON.stringify(value)}
+`, {
+    encoding: "utf8",
+    mode: 384,
+    flag: "wx"
+  });
+}
+function defaultSpawnUpdater(executable, requestPath) {
+  const child = spawn4(executable, ["apply", "--request", requestPath], {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true
+  });
+  child.unref();
+  return child;
+}
+function createBackgroundUpdateManager(dependencies = {}) {
+  const platform = dependencies.platform ?? process.platform;
+  const randomId = dependencies.randomId ?? randomUUID8;
+  const download = dependencies.download ?? downloadArtifact;
+  const spawnUpdater = dependencies.spawnUpdater ?? defaultSpawnUpdater;
+  const now = dependencies.now ?? Date.now;
+  const preparedRequests = /* @__PURE__ */ new Set();
+  async function prepareCommon(options, installation) {
+    const version2 = requireSemanticVersion(options.version);
+    const launcherPid = requireLauncherPid(options.launcherPid);
+    const launcherExecutable = await requireRegularFile(options.launcherExecutable, "Launcher executable");
+    const updaterExecutable = await requireRegularFile(options.updaterExecutable, "Updater executable");
+    const stateDirectory = requireAbsolutePath(options.stateDirectory, "update state directory");
+    await mkdir3(stateDirectory, { recursive: true, mode: 448 });
+    const workDirectory = path10.join(stateDirectory, `update-${version2}-${randomId()}`);
+    await mkdir3(workDirectory, { recursive: false, mode: 448 });
+    const executableSuffix = platform === "win32" ? ".exe" : "";
+    const helperPath = path10.join(workDirectory, `codexhost-updater${executableSuffix}`);
+    await copyFile2(updaterExecutable, helperPath);
+    if (platform !== "win32")
+      await chmod(helperPath, 448);
+    const requestPath = path10.join(workDirectory, "request-v1.json");
+    const statusPath = path10.join(workDirectory, "status-v1.json");
+    await writePrivateJson(statusPath, preparedStatus(version2, installation, now()));
+    return {
+      version: version2,
+      launcherPid,
+      launcherExecutable,
+      workDirectory,
+      helperPath,
+      requestPath,
+      statusPath
+    };
+  }
+  async function prepareArtifact(sourceValue, workDirectory, fileName) {
+    const source = validateArtifact(sourceValue);
+    const temporaryPath = path10.join(workDirectory, `.${fileName}.download`);
+    const artifactPath = path10.join(workDirectory, fileName);
+    try {
+      const result = await download(source, temporaryPath);
+      const finalUrl = new URL(result.finalUrl);
+      if (finalUrl.protocol !== "https:" || finalUrl.username || finalUrl.password) {
+        throw new Error("update artifact downloader returned a non-HTTPS URL");
+      }
+      await verifyDownloadedArtifact(source, temporaryPath, result);
+      await rename2(temporaryPath, artifactPath);
+      return { source, artifactPath };
+    } catch (error52) {
+      await rm4(temporaryPath, { force: true });
+      throw error52;
+    }
+  }
+  async function finalize2(common, installation, artifactPath) {
+    const request = {
+      schema_version: REQUEST_SCHEMA_VERSION,
+      version: common.version,
+      wait_pid: common.launcherPid,
+      wait_executable: common.launcherExecutable,
+      status_path: common.statusPath,
+      installation
+    };
+    await writePrivateJson(common.requestPath, request);
+    preparedRequests.add(common.requestPath);
+    return Object.freeze({
+      version: common.version,
+      installation: installation.kind,
+      requestPath: common.requestPath,
+      statusPath: common.statusPath,
+      helperPath: common.helperPath,
+      ...artifactPath === void 0 ? {} : { artifactPath }
+    });
+  }
+  return Object.freeze({
+    async prepareNpm(options) {
+      const common = await prepareCommon(options, "npm");
+      return finalize2(common, {
+        kind: "npm",
+        node_path: await requireRegularFile(options.nodePath, "npm Node.js executable"),
+        npm_cli_path: await requireRegularFile(options.npmCliPath, "npm CLI"),
+        npm_launcher_path: await requireRegularFile(options.npmLauncherPath, "npm codexhost launcher"),
+        package_root: requireAbsolutePath(options.packageRoot, "npm platform package root")
+      });
+    },
+    async prepareWindowsInstaller(options) {
+      if (platform !== "win32")
+        throw new Error("Windows installer updates require Windows");
+      const common = await prepareCommon(options, "windows-installer");
+      const artifact = await prepareArtifact(options.artifact, common.workDirectory, "update.exe");
+      return finalize2(common, {
+        kind: "windows-installer",
+        installer_path: artifact.artifactPath,
+        artifact_sha256: artifact.source.sha256,
+        install_root: requireAbsolutePath(options.installRoot, "Windows install root")
+      }, artifact.artifactPath);
+    },
+    async prepareMacOsDmg(options) {
+      if (platform !== "darwin")
+        throw new Error("macOS DMG updates require macOS");
+      const common = await prepareCommon(options, "macos-dmg");
+      const appPath = requireAbsolutePath(options.appPath, "macOS application path");
+      if (path10.extname(appPath) !== ".app") {
+        throw new Error("macOS application path must end in .app");
+      }
+      const artifact = await prepareArtifact(options.artifact, common.workDirectory, "update.dmg");
+      return finalize2(common, {
+        kind: "macos-dmg",
+        dmg_path: artifact.artifactPath,
+        artifact_sha256: artifact.source.sha256,
+        app_path: appPath
+      }, artifact.artifactPath);
+    },
+    start(prepared) {
+      if (!preparedRequests.delete(prepared.requestPath)) {
+        throw new Error("background update was not prepared by this manager or was already started");
+      }
+      const child = spawnUpdater(prepared.helperPath, prepared.requestPath);
+      if (child.pid === void 0)
+        throw new Error("background Updater did not report a process ID");
+      return Object.freeze({ ...prepared, updaterPid: child.pid });
+    },
+    async readStatus(statusPathValue) {
+      const statusPath = requireAbsolutePath(statusPathValue, "update status path");
+      try {
+        return parseUpdateStatus(JSON.parse(await readFile4(statusPath, "utf8")));
+      } catch (error52) {
+        if (error52.code === "ENOENT")
+          return null;
+        throw error52;
+      }
+    }
+  });
+}
+
+// packages/host-runtime/src/update-coordinator.ts
+var ERROR_MAX_LENGTH = 500;
+var CONTROLLER_TIMEOUT_MS = 5e3;
+async function startCompatibilityUpdate(coordinator) {
+  try {
+    const check2 = await coordinator.check();
+    if (check2.updateAvailable && check2.installationAvailable) {
+      void coordinator.start().catch(() => void 0);
+      return "update-started";
+    }
+    if (check2.error === null && check2.latestVersion !== null && check2.currentVersion === check2.latestVersion) {
+      return "current";
+    }
+  } catch {
+  }
+  return "unavailable";
+}
+function boundedError(error52) {
+  const message3 = error52 instanceof Error ? error52.message : String(error52);
+  return message3.slice(0, ERROR_MAX_LENGTH) || "Update operation failed";
+}
+function publicStatus(status) {
+  return {
+    version: status.version,
+    installation: status.installation,
+    phase: status.phase,
+    updatedAt: status.updatedAt,
+    error: status.error?.slice(0, ERROR_MAX_LENGTH) ?? null
+  };
+}
+function requestControllerShutdown(controller) {
+  return new Promise((resolve2, reject) => {
+    const socket = createConnection({ host: "127.0.0.1", port: controller.port });
+    let response = "";
+    const timeout = setTimeout(
+      () => socket.destroy(new Error("Controller shutdown timed out")),
+      CONTROLLER_TIMEOUT_MS
+    );
+    const settle = (operation) => {
+      clearTimeout(timeout);
+      operation();
+    };
+    socket.setEncoding("utf8");
+    socket.once("error", (error52) => settle(() => reject(error52)));
+    socket.on("data", (chunk) => {
+      response += chunk;
+    });
+    socket.once(
+      "end",
+      () => settle(() => {
+        if (response === "ready\n") resolve2();
+        else reject(new Error("Desktop Controller rejected the shutdown request"));
+      })
+    );
+    socket.once("connect", () => socket.write(`SHUTDOWN ${controller.nonce}
+`));
+  });
+}
+function createHostUpdateCoordinator(options) {
+  const manager = options.manager ?? createBackgroundUpdateManager(options.platform ? { platform: options.platform } : {});
+  const contextPromise = resolveInstalledUpdateContext({
+    hostRuntimePath: options.hostRuntimePath,
+    ...options.environment ? { environment: options.environment } : {},
+    ...options.platform ? { platform: options.platform } : {},
+    ...options.architecture ? { architecture: options.architecture } : {}
+  });
+  const fetchLatest = options.fetchLatest ?? ((signal) => fetchLatestGitHubRelease({ signal: signal ?? AbortSignal.timeout(15e3) }));
+  const shutdown = options.shutdown ?? requestControllerShutdown;
+  let candidate = null;
+  let shutdownPending = null;
+  async function latestStatus(context) {
+    const discovered = await discoverLatestUpdateStatus(context.common.stateDirectory);
+    return discovered ? publicStatus(discovered.status) : null;
+  }
+  async function installable(context, release) {
+    if (context.metadata.distribution === "npm") return true;
+    try {
+      selectInstallerReleaseArtifact(release, context.metadata.target);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return Object.freeze({
+    async check(signal) {
+      let context;
+      try {
+        context = await contextPromise;
+        await recoverUpdateOperationLock(context.common.stateDirectory);
+        await cleanupTerminalUpdateState(context.common.stateDirectory);
+      } catch (error52) {
+        return {
+          currentVersion: "0.0.0",
+          latestVersion: null,
+          updateAvailable: false,
+          installationAvailable: false,
+          releaseNotes: null,
+          releaseNotesUrl: null,
+          status: null,
+          error: boundedError(error52)
+        };
+      }
+      const status = await latestStatus(context);
+      try {
+        const release = await fetchLatest(signal);
+        candidate = release;
+        const updateAvailable = compareSemanticVersions(context.metadata.version, release.version) < 0;
+        let installationAvailable = false;
+        let error52 = null;
+        if (updateAvailable) {
+          installationAvailable = await installable(context, release);
+          if (!installationAvailable) {
+            error52 = "The latest GitHub Release has no verified asset for this installation";
+          }
+        }
+        return {
+          currentVersion: context.metadata.version,
+          latestVersion: release.version,
+          updateAvailable,
+          installationAvailable,
+          releaseNotes: release.releaseNotes,
+          releaseNotesUrl: release.releaseNotesUrl,
+          status,
+          error: error52
+        };
+      } catch (error52) {
+        return {
+          currentVersion: context.metadata.version,
+          latestVersion: null,
+          updateAvailable: false,
+          installationAvailable: false,
+          releaseNotes: null,
+          releaseNotesUrl: null,
+          status,
+          error: boundedError(error52)
+        };
+      }
+    },
+    async start() {
+      const context = await contextPromise;
+      await recoverUpdateOperationLock(context.common.stateDirectory);
+      const lock = await acquireUpdateOperationLock(context.common.stateDirectory);
+      if (!lock) {
+        const existing = await latestStatus(context);
+        if (existing) return { status: existing };
+        throw new Error("Another update operation is already active");
+      }
+      try {
+        const release = await fetchLatest();
+        if (compareSemanticVersions(context.metadata.version, release.version) >= 0 || candidate && candidate.version !== release.version) {
+          throw new Error("The selected update is no longer the current GitHub Release");
+        }
+        let prepared;
+        if (context.installation.kind === "npm") {
+          prepared = await manager.prepareNpm({
+            ...context.installation.options,
+            version: release.version
+          });
+        } else {
+          const artifact = selectInstallerReleaseArtifact(release, context.metadata.target).source;
+          prepared = context.installation.kind === "windows-installer" ? await manager.prepareWindowsInstaller({
+            ...context.installation.options,
+            version: release.version,
+            artifact
+          }) : await manager.prepareMacOsDmg({
+            ...context.installation.options,
+            version: release.version,
+            artifact
+          });
+        }
+        await lock.setStatusPath(prepared.statusPath);
+        manager.start(prepared);
+        const status = await manager.readStatus(prepared.statusPath);
+        if (!status) throw new Error("Background Updater did not create status");
+        shutdownPending = context.controller;
+        return { status: publicStatus(status) };
+      } catch (error52) {
+        await lock.release();
+        throw error52;
+      }
+    },
+    async status() {
+      try {
+        const context = await contextPromise;
+        await recoverUpdateOperationLock(context.common.stateDirectory);
+        return { status: await latestStatus(context) };
+      } catch {
+        return { status: null };
+      }
+    },
+    requestShutdown() {
+      const controller = shutdownPending;
+      shutdownPending = null;
+      if (!controller) return;
+      setTimeout(() => void shutdown(controller).catch(() => void 0), 50).unref();
+    }
+  });
+}
+
 // packages/host-runtime/src/release-main.ts
 var STOCK_CODEX_PATH_ENV = "CODEXHOST_STOCK_CODEX_PATH";
 var DEFAULT_AGENT_ENV = "CODEXHOST_DEFAULT_AGENT";
-var stockCodexPath = process.env[STOCK_CODEX_PATH_ENV];
-if (!stockCodexPath) throw new Error(`${STOCK_CODEX_PATH_ENV} is required`);
-var defaultAgent = process.env[DEFAULT_AGENT_ENV];
-if (defaultAgent !== "codex" && defaultAgent !== "pi") {
-  throw new Error(`${DEFAULT_AGENT_ENV} must be 'codex' or 'pi'`);
-}
-var externalAdapters = createExternalHarnessAdapters(process.env);
-var host = new AppServerHost({
-  stockCodexPath,
-  arguments: process.argv.slice(2),
-  defaultAgent,
-  environment: process.env,
-  externalAdapters
-});
-void prefetchClaudeCodeModelCatalog(externalAdapters);
-process.exitCode = await host.run();
+var COMPATIBILITY_UPDATE_ARGUMENT = "--codexhost-compatibility-update";
+var arguments_ = process.argv.slice(2);
+var updateCoordinator = createHostUpdateCoordinator({
+  hostRuntimePath: fileURLToPath(import.meta.url),
+  environment: process.env
+});
+if (arguments_.length === 1 && arguments_[0] === COMPATIBILITY_UPDATE_ARGUMENT) {
+  process.stdout.write(`${await startCompatibilityUpdate(updateCoordinator)}
+`);
+} else {
+  const stockCodexPath = process.env[STOCK_CODEX_PATH_ENV];
+  if (!stockCodexPath) throw new Error(`${STOCK_CODEX_PATH_ENV} is required`);
+  const defaultAgent = process.env[DEFAULT_AGENT_ENV];
+  if (defaultAgent !== "codex" && defaultAgent !== "pi") {
+    throw new Error(`${DEFAULT_AGENT_ENV} must be 'codex' or 'pi'`);
+  }
+  const externalAdapters = createExternalHarnessAdapters(process.env);
+  const host = new AppServerHost({
+    stockCodexPath,
+    arguments: arguments_,
+    defaultAgent,
+    environment: process.env,
+    externalAdapters,
+    updateCoordinator
+  });
+  void prefetchClaudeCodeModelCatalog(externalAdapters);
+  process.exitCode = await host.run();
+}