@codexhost/cli-darwin-arm64 0.2.1 → 0.2.3

package/app/host-runtime.mjs

@@ -773,10 +773,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path18) {
-  if (!path18)
+function getElementAtPath(obj, path19) {
+  if (!path19)
     return obj;
-  return path18.reduce((acc, key) => acc?.[key], obj);
+  return path19.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1185,11 +1185,11 @@ function explicitlyAborted(x2, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path18, issues) {
+function prefixIssues(path19, issues) {
   return issues.map((iss) => {
     var _a4;
     (_a4 = iss).path ?? (_a4.path = []);
-    iss.path.unshift(path18);
+    iss.path.unshift(path19);
     return iss;
   });
 }
@@ -1336,16 +1336,16 @@ function flattenError(error52, mapper = (issue2) => issue2.message) {
 }
 function formatError(error52, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error53, path18 = []) => {
+  const processError = (error53, path19 = []) => {
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path19, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else {
-        const fullpath = [...path18, ...issue2.path];
+        const fullpath = [...path19, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1372,17 +1372,17 @@ function formatError(error52, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error52, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error53, path18 = []) => {
+  const processError = (error53, path19 = []) => {
     var _a4, _b2;
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path19, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else {
-        const fullpath = [...path18, ...issue2.path];
+        const fullpath = [...path19, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1414,8 +1414,8 @@ function treeifyError(error52, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path18 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path18) {
+  const path19 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path19) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14107,13 +14107,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path18 = ref.slice(1).split("/").filter(Boolean);
-  if (path18.length === 0) {
+  const path19 = ref.slice(1).split("/").filter(Boolean);
+  if (path19.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path18[0] === defsKey) {
-    const key = path18[1];
+  if (path19[0] === defsKey) {
+    const key = path19[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -44838,16 +44838,16 @@ var AbstractApiClient = class {
    * Shared POST leg of both C→S carriers (callUnary/respond): JSON body,
    * optional default timeout merged with the caller's external signal, non-2xx → transport throw.
    */
-  async postJson(path18, body, signal, timeoutPolicy = "default") {
+  async postJson(path19, body, signal, timeoutPolicy = "default") {
     const requestSignal = timeoutPolicy === "default" ? signal === void 0 ? AbortSignal.timeout(this.timeoutMs) : AbortSignal.any([AbortSignal.timeout(this.timeoutMs), signal]) : signal;
-    const response = await this.doFetch(new URL(path18, this.resolveBase()), {
+    const response = await this.doFetch(new URL(path19, this.resolveBase()), {
       method: "POST",
       headers: { "content-type": "application/json" },
       body: JSON.stringify(body),
       ...requestSignal === void 0 ? {} : { signal: requestSignal }
     });
     if (!response.ok)
-      throw new Error(`transport failure for ${path18}: HTTP ${response.status}`);
+      throw new Error(`transport failure for ${path19}: HTTP ${response.status}`);
     return response;
   }
   /**
@@ -44883,10 +44883,10 @@ var AbstractApiClient = class {
    * either parse level is reported and skipped (one corrupt frame must not kill the stream; the
    * client's gap detection covers whatever the frame carried).
    */
-  async *readSse(path18, signal, frameSchema, onOpen) {
-    const response = await this.doFetch(new URL(path18, this.resolveBase()), { signal });
+  async *readSse(path19, signal, frameSchema, onOpen) {
+    const response = await this.doFetch(new URL(path19, this.resolveBase()), { signal });
     if (!response.ok || response.body === null)
-      throw new Error(`transport failure for ${path18}: HTTP ${response.status}`);
+      throw new Error(`transport failure for ${path19}: HTTP ${response.status}`);
     onOpen?.();
     const reader = response.body.getReader();
     const decoder2 = new TextDecoder();
@@ -44910,7 +44910,7 @@ var AbstractApiClient = class {
             full = serverRequestSchema.parse(JSON.parse(data));
             frame = frameSchema.parse(full.payload);
           } catch (error52) {
-            console.error(`[apiproxy] dropping malformed SSE frame on ${path18}:`, error52);
+            console.error(`[apiproxy] dropping malformed SSE frame on ${path19}:`, error52);
             continue;
           }
           this.onEnvelope(full);
@@ -45485,16 +45485,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path18, added, removed, oldPosInc, options) {
-    const last = path18.lastComponent;
+  addToPath(path19, added, removed, oldPosInc, options) {
+    const last = path19.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path18.oldPos + oldPosInc,
+        oldPos: path19.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path18.oldPos + oldPosInc,
+        oldPos: path19.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -47246,7 +47246,7 @@ var packageMetadata3 = {
 
 // packages/adapters/grok/dist/grok-adapter.js
 import { randomUUID as randomUUID3 } from "node:crypto";
-import path10 from "node:path";
+import path11 from "node:path";
 
 // packages/adapters/grok/dist/acp-transport.js
 import { spawn as spawn3, spawnSync } from "node:child_process";
@@ -51877,6 +51877,81 @@ var GrokAcpTransport = class {
   }
 };
 
+// packages/adapters/grok/dist/grok-file-change.js
+import { Buffer as Buffer4 } from "node:buffer";
+import path9 from "node:path";
+var DEFAULT_GROK_FILE_CHANGE_TEXT_LIMIT = 4 * 1024 * 1024;
+var MAX_GROK_FILE_CHANGES_PER_TOOL = 32;
+function isRecord10(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validAbsolutePath(value) {
+  return typeof value === "string" && path9.isAbsolute(value) && value.trim().length > 0 && !value.includes("\0") && !value.includes("\n") && !value.includes("\r");
+}
+function displayPath2(nativePath, cwd) {
+  const resolvedCwd = path9.resolve(cwd);
+  const resolvedPath = path9.resolve(nativePath);
+  const relative = path9.relative(resolvedCwd, resolvedPath);
+  const inside = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path9.sep}`);
+  const selected = inside ? relative : resolvedPath;
+  const normalized = selected.replaceAll("\\", "/");
+  if (normalized.length === 0 || normalized === ".")
+    return null;
+  return { path: normalized, absolute: !inside };
+}
+function projectDiff(value, cwd, remainingTextBytes) {
+  if (!validAbsolutePath(value.path) || typeof value.oldText !== "string" && value.oldText !== null || typeof value.newText !== "string") {
+    return null;
+  }
+  const oldText = value.oldText;
+  const newText = value.newText;
+  if (typeof oldText === "string" && oldText === newText || oldText === null && newText === "") {
+    return null;
+  }
+  const textBytes = Buffer4.byteLength(oldText ?? "", "utf8") + Buffer4.byteLength(newText, "utf8");
+  if (textBytes > remainingTextBytes)
+    return null;
+  const displayed = displayPath2(value.path, cwd);
+  if (!displayed)
+    return null;
+  const kind = oldText === null ? "add" : "update";
+  const oldHeader = kind === "add" ? "/dev/null" : displayed.absolute ? displayed.path : `a/${displayed.path}`;
+  const newHeader = displayed.absolute ? displayed.path : `b/${displayed.path}`;
+  return {
+    change: {
+      path: displayed.path,
+      kind,
+      unifiedDiff: createTwoFilesPatch(oldHeader, newHeader, oldText ?? "", newText, "", "", {
+        context: 3
+      })
+    },
+    textBytes
+  };
+}
+function projectGrokFileChanges(content, cwd, textLimit = DEFAULT_GROK_FILE_CHANGE_TEXT_LIMIT) {
+  if (!Number.isSafeInteger(textLimit) || textLimit <= 0 || !Array.isArray(content))
+    return null;
+  const candidates2 = [];
+  for (const entry of content) {
+    if (isRecord10(entry) && entry.type === "diff")
+      candidates2.push(entry);
+  }
+  if (candidates2.length === 0 || candidates2.length > MAX_GROK_FILE_CHANGES_PER_TOOL)
+    return null;
+  const changes = [];
+  const paths = /* @__PURE__ */ new Set();
+  let textBytes = 0;
+  for (const candidate of candidates2) {
+    const projected = projectDiff(candidate, cwd, textLimit - textBytes);
+    if (!projected || paths.has(projected.change.path))
+      return null;
+    textBytes += projected.textBytes;
+    paths.add(projected.change.path);
+    changes.push(projected.change);
+  }
+  return changes;
+}
+
 // packages/adapters/grok/dist/grok-history.js
 function jsonValue(value) {
   try {
@@ -51910,7 +51985,8 @@ function isSyntheticGrokUserText(text) {
 function isSyntheticGrokTurnKey(nativeTurnKey3) {
   return taskCompletedTurnKeyPattern.test(nativeTurnKey3);
 }
-function mapGrokReplay(replay, harnessId, sessionId, knownTurnRefs = []) {
+function mapGrokReplay(replay, harnessId, sessionId, cwd, knownTurnRefs = []) {
+  const knownByNativeKey = new Map(knownTurnRefs.filter((ref) => ref.harnessId === harnessId && ref.nativeSessionId === sessionId).map((ref) => [ref.nativeTurnKey, ref]));
   const turns = [];
   let input = "";
   let items = [];
@@ -51938,16 +52014,40 @@ function mapGrokReplay(replay, harnessId, sessionId, knownTurnRefs = []) {
     }
     tools.clear();
   };
+  const completeTool = (callId, status, content) => {
+    const tool = tools.get(callId);
+    if (!tool)
+      return;
+    tools.delete(callId);
+    const outcome = status === "failed" ? {
+      status: "failed",
+      error: {
+        code: "nativeFailure",
+        message: `Grok Tool '${tool.toolName}' failed`,
+        retryable: false
+      }
+    } : { status: "succeeded" };
+    items.push({ item: tool, outcome });
+    if (status !== "completed")
+      return;
+    const changes = projectGrokFileChanges(content, cwd);
+    if (!changes)
+      return;
+    const fileItem = {
+      type: "fileChange",
+      itemId: stableId("file-change", turnIndex, ++messageIndex),
+      changes
+    };
+    items.push({ item: fileItem, outcome: { status: "succeeded" } });
+  };
   const completeTurn = (outcome, terminalKey) => {
     if (input.length === 0)
       return;
-    const known = knownTurnRefs[turnIndex];
-    if (known && (known.harnessId !== harnessId || known.nativeSessionId !== sessionId)) {
-      throw new Error("Known Grok Turn identity does not belong to the Native Session");
-    }
-    const stableKey = known?.nativeTurnKey ?? terminalKey ?? nativeTurnKey3;
-    if (!stableKey)
+    const reconstructedKey = terminalKey ?? nativeTurnKey3;
+    if (!reconstructedKey)
       throw new Error("Grok Native history Turn has no stable identity");
+    const known = knownByNativeKey.get(reconstructedKey);
+    const stableKey = known?.nativeTurnKey ?? reconstructedKey;
     completeReasoning();
     completeAgent();
     completeTools();
@@ -52022,6 +52122,9 @@ function mapGrokReplay(replay, harnessId, sessionId, knownTurnRefs = []) {
         namespace: "grok",
         arguments: jsonValue(event.rawInput)
       });
+      if (event.status === "completed" || event.status === "failed") {
+        completeTool(event.callId, event.status, event.content);
+      }
     } else if (event.type === "tool.update") {
       const tool = tools.get(event.callId);
       if (tool && event.rawOutput !== void 0) {
@@ -52030,17 +52133,17 @@ function mapGrokReplay(replay, harnessId, sessionId, knownTurnRefs = []) {
           output: { content: [{ type: "text", text: String(event.rawOutput) }] }
         });
       }
+      if (event.status === "completed" || event.status === "failed") {
+        completeTool(event.callId, event.status, event.content);
+      }
     }
   }
   completeTurn({ status: "unknown", reason: "Grok Native history has no terminal signal" });
-  if (knownTurnRefs.length > turns.length) {
-    throw new Error("Grok Native history is missing persisted Turns");
-  }
   return { turns };
 }
 
 // packages/adapters/grok/dist/grok-models.js
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonBlank(value) {
@@ -52052,7 +52155,7 @@ function thinkingOptions(value) {
   const seen = /* @__PURE__ */ new Set();
   const options = [];
   for (const candidate of value) {
-    if (!isRecord10(candidate) || !nonBlank(candidate.label))
+    if (!isRecord11(candidate) || !nonBlank(candidate.label))
       continue;
     const id2 = harnessThinkingOptionIdSchema.safeParse(candidate.id ?? candidate.value);
     if (!id2.success || seen.has(id2.data))
@@ -52063,7 +52166,7 @@ function thinkingOptions(value) {
   return options;
 }
 function parseGrokModelState(value) {
-  if (!isRecord10(value) || !nonBlank(value.currentModelId) || !Array.isArray(value.availableModels)) {
+  if (!isRecord11(value) || !nonBlank(value.currentModelId) || !Array.isArray(value.availableModels)) {
     return null;
   }
   const currentModel = harnessModelRefSchema.safeParse({ id: value.currentModelId });
@@ -52074,12 +52177,12 @@ function parseGrokModelState(value) {
   const models = [];
   let currentThinkingOptionId;
   for (const candidate of value.availableModels) {
-    if (!isRecord10(candidate) || !nonBlank(candidate.modelId) || !nonBlank(candidate.name))
+    if (!isRecord11(candidate) || !nonBlank(candidate.modelId) || !nonBlank(candidate.name))
       continue;
     const ref = harnessModelRefSchema.safeParse({ id: candidate.modelId });
     if (!ref.success)
       continue;
-    const metadata = isRecord10(candidate._meta) ? candidate._meta : {};
+    const metadata = isRecord11(candidate._meta) ? candidate._meta : {};
     const options2 = thinkingOptions(metadata.reasoningEfforts);
     if (typeof metadata.totalContextTokens === "number" && Number.isSafeInteger(metadata.totalContextTokens) && metadata.totalContextTokens > 0) {
       contextWindowTokensByModel.set(ref.data.id, metadata.totalContextTokens);
@@ -52114,10 +52217,10 @@ function parseGrokModelState(value) {
   };
 }
 function modelStateFromInitialize(response) {
-  return parseGrokModelState(isRecord10(response._meta) ? response._meta.modelState : void 0);
+  return parseGrokModelState(isRecord11(response._meta) ? response._meta.modelState : void 0);
 }
 function modelStateFromSessionResponse(response) {
-  return parseGrokModelState(isRecord10(response) ? response.models : void 0);
+  return parseGrokModelState(isRecord11(response) ? response.models : void 0);
 }
 function stateForGrokModel(modelState, nativeState, model = modelState.currentModel, thinkingOptionId = modelState.currentThinkingOptionId) {
   const selectedModel = model;
@@ -52137,10 +52240,10 @@ function stateForGrokModel(modelState, nativeState, model = modelState.currentMo
 // packages/adapters/grok/dist/grok-credits.js
 import { readFile as readFile2 } from "node:fs/promises";
 import os4 from "node:os";
-import path9 from "node:path";
+import path10 from "node:path";
 var GROK_CREDITS_ENDPOINT = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
 var REQUEST_TIMEOUT_MS = 15e3;
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function finitePercent(value) {
@@ -52154,7 +52257,7 @@ function nonNegativeNumber(value) {
   return value;
 }
 function grokHome(environment) {
-  return environment.GROK_HOME ?? path9.join(environment.HOME ?? environment.USERPROFILE ?? os4.homedir(), ".grok");
+  return environment.GROK_HOME ?? path10.join(environment.HOME ?? environment.USERPROFILE ?? os4.homedir(), ".grok");
 }
 function periodTypeFrom(value) {
   if (typeof value !== "string")
@@ -52170,7 +52273,7 @@ function productUsageFrom(value) {
   if (!Array.isArray(value))
     return void 0;
   const products = value.flatMap((entry) => {
-    if (!isRecord11(entry) || typeof entry.product !== "string")
+    if (!isRecord12(entry) || typeof entry.product !== "string")
       return [];
     const usagePercent = finitePercent(entry.usagePercent);
     return usagePercent === void 0 ? [] : [{ product: entry.product, usagePercent }];
@@ -52178,13 +52281,13 @@ function productUsageFrom(value) {
   return products.length > 0 ? products : void 0;
 }
 function parseGrokCreditsResponse(value, fetchedAt = (/* @__PURE__ */ new Date()).toISOString()) {
-  if (!isRecord11(value) || !isRecord11(value.config))
+  if (!isRecord12(value) || !isRecord12(value.config))
     return null;
   const config2 = value.config;
-  const period = isRecord11(config2.currentPeriod) ? config2.currentPeriod : void 0;
+  const period = isRecord12(config2.currentPeriod) ? config2.currentPeriod : void 0;
   const resetsAt = (typeof period?.end === "string" && period.end.length > 0 ? period.end : void 0) ?? (typeof config2.billingPeriodEnd === "string" && config2.billingPeriodEnd.length > 0 ? config2.billingPeriodEnd : void 0);
-  const onDemandCap = isRecord11(config2.onDemandCap) ? nonNegativeNumber(config2.onDemandCap.val) : void 0;
-  const onDemandUsed = isRecord11(config2.onDemandUsed) ? nonNegativeNumber(config2.onDemandUsed.val) : void 0;
+  const onDemandCap = isRecord12(config2.onDemandCap) ? nonNegativeNumber(config2.onDemandCap.val) : void 0;
+  const onDemandUsed = isRecord12(config2.onDemandUsed) ? nonNegativeNumber(config2.onDemandUsed.val) : void 0;
   const usedPercent = finitePercent(config2.creditUsagePercent) ?? (onDemandCap !== void 0 && onDemandCap > 0 && onDemandUsed !== void 0 ? Math.min(100, Math.max(0, onDemandUsed / onDemandCap * 100)) : resetsAt ? 0 : void 0);
   if (usedPercent === void 0)
     return null;
@@ -52198,11 +52301,11 @@ function parseGrokCreditsResponse(value, fetchedAt = (/* @__PURE__ */ new Date()
   };
 }
 function selectAccessToken(auth, now) {
-  if (!isRecord11(auth))
+  if (!isRecord12(auth))
     return null;
-  const entries = Object.entries(auth).filter(([, value]) => isRecord11(value) && typeof value.key === "string" && value.key.length > 0).sort(([left], [right]) => Number(right.startsWith("https://auth.x.ai")) - Number(left.startsWith("https://auth.x.ai")));
+  const entries = Object.entries(auth).filter(([, value]) => isRecord12(value) && typeof value.key === "string" && value.key.length > 0).sort(([left], [right]) => Number(right.startsWith("https://auth.x.ai")) - Number(left.startsWith("https://auth.x.ai")));
   for (const [, value] of entries) {
-    if (!isRecord11(value) || typeof value.key !== "string")
+    if (!isRecord12(value) || typeof value.key !== "string")
       continue;
     if (typeof value.expires_at === "string") {
       const expiresAt = Date.parse(value.expires_at);
@@ -52217,7 +52320,7 @@ async function fetchGrokCredits(input = {}) {
   try {
     const environment = input.environment ?? process.env;
     const now = input.now ?? /* @__PURE__ */ new Date();
-    const authPath = path9.join(grokHome(environment), "auth.json");
+    const authPath = path10.join(grokHome(environment), "auth.json");
     const raw = input.readAuthFile ? await input.readAuthFile(authPath) : await readFile2(authPath, "utf8");
     const token = selectAccessToken(JSON.parse(raw), now);
     if (!token)
@@ -52242,7 +52345,7 @@ async function fetchGrokCredits(input = {}) {
 
 // packages/adapters/grok/dist/grok-usage.js
 var USD_TICKS_PER_DOLLAR = 1e10;
-function isRecord12(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalToken(value) {
@@ -52259,7 +52362,7 @@ function combineUsage(base, next) {
   return base === null ? next : parseHostUsage({ ...base, ...next });
 }
 function usageFromNative(value) {
-  if (!isRecord12(value))
+  if (!isRecord13(value))
     return null;
   const inputTokens = optionalToken(value.inputTokens);
   const cachedRead = optionalToken(value.cachedReadTokens);
@@ -52286,7 +52389,7 @@ function usageFromPrompt(response) {
   return response.usage ? usageFromNative(response.usage) : null;
 }
 function usageFromSignals(value) {
-  if (!isRecord12(value))
+  if (!isRecord13(value))
     return null;
   try {
     return parseHostUsage({
@@ -52297,21 +52400,80 @@ function usageFromSignals(value) {
     return null;
   }
 }
-function lastTurnUsage(events) {
-  for (let index = events.length - 1; index >= 0; index -= 1) {
-    const event = events[index];
+var summedUsageFields = [
+  "inputTokens",
+  "cachedInputTokens",
+  "cacheWriteInputTokens",
+  "outputTokens",
+  "reasoningOutputTokens",
+  "totalTokens"
+];
+function nativeCostTicks(value) {
+  if (!isRecord13(value))
+    return void 0;
+  const ticks = value.costUsdTicks;
+  if (typeof ticks !== "number" || !Number.isSafeInteger(ticks) || ticks < 0)
+    return void 0;
+  return ticks;
+}
+function historyTurnKey(event, index) {
+  const key = event.nativeTurnKey;
+  if (typeof key === "string" && key.startsWith("task-completed-"))
+    return null;
+  return typeof key === "string" && key.length > 0 ? key : `anon-${index}`;
+}
+function sessionUsageFromHistory(events) {
+  const latestByKey = /* @__PURE__ */ new Map();
+  let lastCacheHitRatePercent;
+  let index = 0;
+  for (const event of events) {
     if (event?.type !== "turn.completed")
       continue;
+    const key = historyTurnKey(event, index);
+    index += 1;
+    if (key === null)
+      continue;
     const usage = usageFromNative(event.usage);
-    if (usage)
-      return usage;
+    if (!usage)
+      continue;
+    const ticks2 = nativeCostTicks(event.usage);
+    latestByKey.set(key, ticks2 === void 0 ? { usage } : { usage, ticks: ticks2 });
+    if (usage.cacheHitRatePercent !== void 0) {
+      lastCacheHitRatePercent = usage.cacheHitRatePercent;
+    }
+  }
+  if (latestByKey.size === 0)
+    return null;
+  const totals = {};
+  let ticks = 0;
+  let hasTicks = false;
+  for (const entry of latestByKey.values()) {
+    for (const field of summedUsageFields) {
+      const value = entry.usage[field];
+      if (value === void 0)
+        continue;
+      totals[field] = (totals[field] ?? 0) + value;
+    }
+    if (entry.ticks === void 0)
+      continue;
+    ticks += entry.ticks;
+    hasTicks = true;
+  }
+  const totalCostUsd = hasTicks ? optionalCostUsd(ticks) : void 0;
+  try {
+    return parseHostUsage({
+      ...totals,
+      ...totalCostUsd !== void 0 ? { totalCostUsd } : {},
+      ...lastCacheHitRatePercent !== void 0 ? { cacheHitRatePercent: lastCacheHitRatePercent } : {}
+    });
+  } catch {
+    return null;
   }
-  return null;
 }
 function usageFromUpdate(update, metadata, contextWindowTokens) {
   try {
     if (update?.sessionUpdate === "usage_update") {
-      const cost = isRecord12(update.cost) ? update.cost : null;
+      const cost = isRecord13(update.cost) ? update.cost : null;
       return parseHostUsage({
         contextUsedTokens: update.used,
         contextWindowTokens: update.size,
@@ -52345,7 +52507,7 @@ function capabilitiesForModels(modelState) {
 }
 var DEFAULT_CLOSE_TIMEOUT_MS3 = 2e3;
 var DEFAULT_TOOL_OUTPUT_LIMIT3 = 64e3;
-function isRecord13(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function invalidState3(message3) {
@@ -52377,10 +52539,10 @@ function jsonValue2(value) {
   return parsed.success ? parsed.data : {};
 }
 function contentText2(content) {
-  if (!content)
+  if (!Array.isArray(content))
     return "";
   return content.flatMap((entry) => {
-    if (!isRecord13(entry) || entry.type !== "content" || !isRecord13(entry.content))
+    if (!isRecord14(entry) || entry.type !== "content" || !isRecord14(entry.content))
       return [];
     return entry.content.type === "text" && typeof entry.content.text === "string" ? [entry.content.text] : [];
   }).join("\n");
@@ -52434,6 +52596,7 @@ var GrokHarnessSession = class {
   #cwd;
   #modelState;
   #onClosed;
+  #refreshCredits;
   #randomUUID;
   #snapshot;
   #toolOutputLimit;
@@ -52449,6 +52612,7 @@ var GrokHarnessSession = class {
     this.#transport = transport;
     this.#modelState = modelState;
     this.#onClosed = onClosed;
+    this.#refreshCredits = options.refreshCredits;
     this.#closeTimeoutMs = options.closeTimeoutMs;
     this.#randomUUID = options.randomUUID;
     this.#toolOutputLimit = options.toolOutputLimit;
@@ -52458,7 +52622,7 @@ var GrokHarnessSession = class {
     this.#state = stateForGrokModel(modelState, { nativeRef: nativeRef(opened.sessionId) });
     this.initialState = this.#state;
     this.#snapshot = {
-      ...mapGrokReplay(options.history, this.harnessId, opened.sessionId, options.knownTurnRefs),
+      ...mapGrokReplay(options.history, this.harnessId, opened.sessionId, cwd, options.knownTurnRefs),
       state: this.#state
     };
     this.outputs = this.#channel.outputs;
@@ -52568,7 +52732,7 @@ var GrokHarnessSession = class {
   async #refreshSnapshot() {
     const history = await this.#transport.getHistory();
     const knownTurnRefs = this.#snapshot.turns.map((turn) => turn.nativeTurnRef);
-    const refreshed = mapGrokReplay(history, this.harnessId, this.#transport.sessionId, knownTurnRefs);
+    const refreshed = mapGrokReplay(history, this.harnessId, this.#transport.sessionId, this.#cwd, knownTurnRefs);
     this.#snapshot.turns = refreshed.turns;
     return history;
   }
@@ -52715,11 +52879,7 @@ var GrokHarnessSession = class {
       this.#startTool(active, event);
     else if (event.type === "tool.update")
       this.#updateTool(active, event);
-    else if (event.type === "turn.completed") {
-      const usage = usageFromNative(event.usage);
-      if (usage)
-        this.#publishUsage(usage, active.command.turnId);
-    } else if (event.type === "usage")
+    else if (event.type === "usage" || event.type === "turn.completed")
       return;
   }
   #appendAgent(active, text, messageId) {
@@ -52781,8 +52941,9 @@ var GrokHarnessSession = class {
     };
     active.tools.set(event.callId, { item, ...event.status ? { status: event.status } : {} });
     this.#event({ type: "item.started", turnId: active.command.turnId, item });
-    if (event.status === "completed" || event.status === "failed")
-      this.#completeTool(active, event.callId, event.status);
+    if (event.status === "completed" || event.status === "failed") {
+      this.#completeTool(active, event.callId, event.status, event.content);
+    }
   }
   #updateTool(active, event) {
     const tool = active.tools.get(event.callId);
@@ -52800,10 +52961,11 @@ var GrokHarnessSession = class {
     }
     if (event.status)
       tool.status = event.status;
-    if (event.status === "completed" || event.status === "failed")
-      this.#completeTool(active, event.callId, event.status);
+    if (event.status === "completed" || event.status === "failed") {
+      this.#completeTool(active, event.callId, event.status, event.content);
+    }
   }
-  #completeTool(active, callId, status) {
+  #completeTool(active, callId, status, content) {
     const tool = active.tools.get(callId);
     if (!tool)
       return;
@@ -52817,6 +52979,18 @@ var GrokHarnessSession = class {
       }
     } : { status: "succeeded" };
     this.#completeItem(active, tool.item, outcome);
+    if (status !== "completed")
+      return;
+    const changes = projectGrokFileChanges(content, this.#cwd);
+    if (!changes)
+      return;
+    const fileItem = {
+      type: "fileChange",
+      itemId: hostItemIdSchema.parse(this.#randomUUID()),
+      changes
+    };
+    this.#event({ type: "item.started", turnId: active.command.turnId, item: fileItem });
+    this.#completeItem(active, fileItem, { status: "succeeded" });
   }
   #completeAgent(active, outcome) {
     const item = active.agent;
@@ -52856,7 +53030,8 @@ var GrokHarnessSession = class {
         outcome = { status: "failed", error: normalizeError(error52, "protocolError") };
       }
     }
-    this.#finish(active, outcome, lastTurnUsage(history) ?? (response ? usageFromPrompt(response) : null), nativeTurnRef2);
+    await this.#refreshCredits().catch(() => void 0);
+    this.#finish(active, outcome, sessionUsageFromHistory(history) ?? (response ? usageFromPrompt(response) : null), nativeTurnRef2);
   }
   #finish(active, outcome, usage = null, nativeTurnRef2) {
     if (this.#active !== active)
@@ -52989,7 +53164,7 @@ var GrokAdapter = class {
   async inspect(input = {}) {
     if (this.#closePromise)
       return { status: "unavailable", error: invalidState3("Grok Adapter is closed") };
-    const cwd = path10.resolve(input.cwd ?? process.cwd());
+    const cwd = path11.resolve(input.cwd ?? process.cwd());
     if (!input.refresh) {
       const cached2 = this.#inspectionCache.get(cwd);
       if (cached2)
@@ -53048,7 +53223,7 @@ var GrokAdapter = class {
         }
       };
     }
-    const cwd = path10.resolve(input.cwd);
+    const cwd = path11.resolve(input.cwd);
     const parsedRef = input.kind === "resume" ? nativeSessionRefSchema.safeParse(input.nativeRef) : null;
     if (parsedRef && (!parsedRef.success || parsedRef.data.harnessId !== this.harnessId)) {
       return {
@@ -53086,13 +53261,14 @@ var GrokAdapter = class {
         }
       }
       const history = await transport.getHistory();
-      const initialUsage = input.kind === "resume" ? combineUsage(lastTurnUsage(history), usageFromSignals(opened.signals)) : null;
+      const initialUsage = input.kind === "resume" ? combineUsage(sessionUsageFromHistory(history), usageFromSignals(opened.signals)) : null;
       const openedSession = new GrokHarnessSession(cwd, transport, opened, modelState, () => this.#sessions.delete(openedSession), {
         closeTimeoutMs: this.#closeTimeoutMs,
         history,
         initialUsage,
         ...input.kind === "resume" && input.knownTurnRefs ? { knownTurnRefs: input.knownTurnRefs } : {},
         randomUUID: this.#dependencies.randomUUID,
+        refreshCredits: () => this.refreshCredits(),
         toolOutputLimit: this.#toolOutputLimit
       });
       session = openedSession;
@@ -53235,7 +53411,7 @@ function normalizePiModelCatalog(nativeModels, effectiveModel, thinkingLevels, e
 
 // packages/adapters/pi/dist/pi-history.js
 var piHarnessId = harnessIdSchema.parse("pi");
-function isRecord14(value) {
+function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function textContent(value) {
@@ -53243,12 +53419,12 @@ function textContent(value) {
     return value;
   if (!Array.isArray(value))
     return "";
-  return value.filter((part) => isRecord14(part) && part.type === "text" && typeof part.text === "string").map((part) => part.text).join("");
+  return value.filter((part) => isRecord15(part) && part.type === "text" && typeof part.text === "string").map((part) => part.text).join("");
 }
 function thinkingContent(value) {
   if (!Array.isArray(value))
     return "";
-  return value.filter((part) => isRecord14(part) && part.type === "thinking" && typeof part.thinking === "string").map((part) => part.thinking).join("");
+  return value.filter((part) => isRecord15(part) && part.type === "thinking" && typeof part.thinking === "string").map((part) => part.thinking).join("");
 }
 function validatedEntry(value) {
   if (typeof value.id !== "string" || value.id.length === 0 || value.parentId !== null && typeof value.parentId !== "string" || typeof value.type !== "string") {
@@ -53279,7 +53455,7 @@ function activePiEntries(history) {
   return reversed.reverse();
 }
 function message(entry) {
-  return entry.type === "message" && isRecord14(entry.message) ? entry.message : null;
+  return entry.type === "message" && isRecord15(entry.message) ? entry.message : null;
 }
 function messageRole(entry) {
   const value = message(entry)?.role;
@@ -53341,7 +53517,7 @@ function snapshotItems(entries, outcome) {
       let projectedText = false;
       let projectedReasoning = false;
       for (const [ordinal, part] of content.entries()) {
-        if (!isRecord14(part))
+        if (!isRecord15(part))
           continue;
         if (part.type === "thinking" && !projectedReasoning && reasoning.length > 0) {
           const item2 = {
@@ -53533,12 +53709,12 @@ async function rollbackPiLastTurn(transport, sourceSessionId, cwd) {
 // packages/adapters/pi/dist/pi-rpc-session.js
 import { spawn as spawn4, spawnSync as spawnSync2 } from "node:child_process";
 import { randomUUID as randomUUID4 } from "node:crypto";
-import path12 from "node:path";
+import path13 from "node:path";
 
 // packages/adapters/pi/dist/command.js
 import { accessSync as accessSync2, constants as constants2, readdirSync as readdirSync2, statSync as statSync3 } from "node:fs";
 import os5 from "node:os";
-import path11 from "node:path";
+import path12 from "node:path";
 function environmentValue2(environment, name) {
   return Object.entries(environment).find(([key]) => key.toLowerCase() === name.toLowerCase())?.[1];
 }
@@ -53551,34 +53727,35 @@ function isExecutable3(filePath, platform) {
   }
 }
 function pathCandidates(command, platform, environment) {
-  const targetPath = platform === "win32" ? path11.win32 : path11.posix;
+  const targetPath = platform === "win32" ? path12.win32 : path12.posix;
   if (targetPath.isAbsolute(command) || command.includes("/") || command.includes("\\")) {
     return [command];
   }
   const extensions = platform === "win32" && targetPath.extname(command) === "" ? (environmentValue2(environment, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD").split(";").map((extension) => extension.trim()).filter(Boolean) : [""];
   return (environmentValue2(environment, "PATH") ?? "").split(targetPath.delimiter).map((directory) => directory.trim().replace(/^"|"$/gu, "")).filter(Boolean).flatMap((directory) => extensions.map((extension) => targetPath.join(directory, command + extension)));
 }
-function nvmCandidates2(homeDirectory, executableName) {
-  const versionsDirectory = path11.join(homeDirectory, ".nvm", "versions", "node");
+function nvmCandidates2(homeDirectory, executableName, targetPath) {
+  const versionsDirectory = targetPath.join(homeDirectory, ".nvm", "versions", "node");
   try {
-    return readdirSync2(versionsDirectory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((left, right) => right.localeCompare(left, void 0, { numeric: true })).map((version2) => path11.join(versionsDirectory, version2, "bin", executableName));
+    return readdirSync2(versionsDirectory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((left, right) => right.localeCompare(left, void 0, { numeric: true })).map((version2) => targetPath.join(versionsDirectory, version2, "bin", executableName));
   } catch {
     return [];
   }
 }
 function userInstallCandidates2(platform, environment, homeDirectory) {
+  const targetPath = platform === "win32" ? path12.win32 : path12.posix;
   if (platform === "win32") {
-    const appData = environment.APPDATA ?? path11.join(homeDirectory, "AppData", "Roaming");
+    const appData = environment.APPDATA ?? targetPath.join(homeDirectory, "AppData", "Roaming");
     return [
-      path11.join(appData, "npm", "pi.cmd"),
-      path11.join(homeDirectory, ".local", "bin", "pi.exe"),
-      path11.join(homeDirectory, ".local", "bin", "pi.cmd")
+      targetPath.join(appData, "npm", "pi.cmd"),
+      targetPath.join(homeDirectory, ".local", "bin", "pi.exe"),
+      targetPath.join(homeDirectory, ".local", "bin", "pi.cmd")
     ];
   }
   return [
-    path11.join(homeDirectory, ".npm-global", "bin", "pi"),
-    path11.join(homeDirectory, ".local", "bin", "pi"),
-    ...nvmCandidates2(homeDirectory, "pi"),
+    targetPath.join(homeDirectory, ".npm-global", "bin", "pi"),
+    targetPath.join(homeDirectory, ".local", "bin", "pi"),
+    ...nvmCandidates2(homeDirectory, "pi", targetPath),
     "/opt/homebrew/bin/pi",
     "/usr/local/bin/pi"
   ];
@@ -53598,7 +53775,7 @@ function resolvePiExecutable(input, dependencies = {}) {
 function withNodeRuntimeOnPath2(environment, runtimeExecutable = process.execPath, platform = process.platform) {
   const pathKey = Object.keys(environment).find((name) => name.toLowerCase() === "path") ?? "PATH";
   const delimiter = platform === "win32" ? ";" : ":";
-  const runtimeDirectory = path11.dirname(runtimeExecutable);
+  const runtimeDirectory = path12.dirname(runtimeExecutable);
   const directories = (environment[pathKey] ?? "").split(delimiter).filter(Boolean);
   const equal = platform === "win32" ? (value) => value.toLowerCase() : (value) => value;
   if (!directories.some((directory) => equal(directory) === equal(runtimeDirectory))) {
@@ -53608,14 +53785,14 @@ function withNodeRuntimeOnPath2(environment, runtimeExecutable = process.execPat
 }
 
 // packages/adapters/pi/dist/pi-usage.js
-function isRecord15(value) {
+function isRecord16(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonNegativeSafeInteger2(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
 }
 function optionalPiCacheHitRatePercent(value) {
-  if (!isRecord15(value) || value.role !== "assistant" || !isRecord15(value.usage))
+  if (!isRecord16(value) || value.role !== "assistant" || !isRecord16(value.usage))
     return null;
   const input = nonNegativeSafeInteger2(value.usage.input);
   const cacheRead = nonNegativeSafeInteger2(value.usage.cacheRead);
@@ -53628,20 +53805,20 @@ function optionalPiCacheHitRatePercent(value) {
 function latestPiCacheHitRatePercent(history) {
   let latest = null;
   for (const entry of activePiEntries(history)) {
-    if (entry.type === "message" && isRecord15(entry.message) && entry.message.role === "assistant") {
+    if (entry.type === "message" && isRecord16(entry.message) && entry.message.role === "assistant") {
       latest = optionalPiCacheHitRatePercent(entry.message);
     }
   }
   return latest;
 }
 function responseData(response, operation) {
-  if (!isRecord15(response.data)) {
+  if (!isRecord16(response.data)) {
     throw new Error(`Pi RPC ${operation} response has no data`);
   }
   return response.data;
 }
 function contextUsage(value) {
-  if (!isRecord15(value))
+  if (!isRecord16(value))
     throw new Error("Pi RPC context Usage is invalid");
   return parseHostUsage({
     contextUsedTokens: value.tokens,
@@ -53651,15 +53828,15 @@ function contextUsage(value) {
 function parsePiSessionUsage(response) {
   const data = responseData(response, "Session stats");
   const tokens = data.tokens;
-  if (tokens !== void 0 && !isRecord15(tokens)) {
+  if (tokens !== void 0 && !isRecord16(tokens)) {
     throw new Error("Pi RPC Session stats tokens are invalid");
   }
   return parseHostUsage({
-    ...isRecord15(tokens) && tokens.input !== void 0 ? { inputTokens: tokens.input } : {},
-    ...isRecord15(tokens) && tokens.cacheRead !== void 0 ? { cachedInputTokens: tokens.cacheRead } : {},
-    ...isRecord15(tokens) && tokens.cacheWrite !== void 0 ? { cacheWriteInputTokens: tokens.cacheWrite } : {},
-    ...isRecord15(tokens) && tokens.output !== void 0 ? { outputTokens: tokens.output } : {},
-    ...isRecord15(tokens) && tokens.total !== void 0 ? { totalTokens: tokens.total } : {},
+    ...isRecord16(tokens) && tokens.input !== void 0 ? { inputTokens: tokens.input } : {},
+    ...isRecord16(tokens) && tokens.cacheRead !== void 0 ? { cachedInputTokens: tokens.cacheRead } : {},
+    ...isRecord16(tokens) && tokens.cacheWrite !== void 0 ? { cacheWriteInputTokens: tokens.cacheWrite } : {},
+    ...isRecord16(tokens) && tokens.output !== void 0 ? { outputTokens: tokens.output } : {},
+    ...isRecord16(tokens) && tokens.total !== void 0 ? { totalTokens: tokens.total } : {},
     ...data.cost !== void 0 ? { totalCostUsd: data.cost } : {},
     ...data.contextUsage !== void 0 ? contextUsage(data.contextUsage) : {}
   });
@@ -53682,7 +53859,7 @@ function optionalPiStateContextUsage(value) {
 import { open, realpath } from "node:fs/promises";
 var MAX_SESSION_HEADER_BYTES = 64 * 1024;
 var utf8Decoder = new TextDecoder("utf-8", { fatal: true });
-function isRecord16(value) {
+function isRecord17(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function readPiSessionHeader(sessionFile) {
@@ -53702,7 +53879,7 @@ async function readPiSessionHeader(sessionFile) {
     } catch {
       throw new Error("Pi Session header is not valid JSON");
     }
-    if (!isRecord16(parsed) || parsed.type !== "session" || typeof parsed.id !== "string" || parsed.id.length === 0 || typeof parsed.cwd !== "string" || parsed.cwd.length === 0) {
+    if (!isRecord17(parsed) || parsed.type !== "session" || typeof parsed.id !== "string" || parsed.id.length === 0 || typeof parsed.cwd !== "string" || parsed.cwd.length === 0) {
       throw new Error("Pi Session header is invalid");
     }
     return { type: "session", id: parsed.id, cwd: parsed.cwd };
@@ -53744,7 +53921,7 @@ var PiRpcUnsupportedCommandError = class extends Error {
   }
 };
 var textDecoder = new TextDecoder("utf-8", { fatal: true });
-function isRecord17(value) {
+function isRecord18(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function message2(value) {
@@ -53756,13 +53933,13 @@ function nonBlankString2(value) {
 function parseNativeModel(value, context) {
   if (value === null || value === void 0)
     return null;
-  if (!isRecord17(value) || !nonBlankString2(value.provider) || !nonBlankString2(value.id)) {
+  if (!isRecord18(value) || !nonBlankString2(value.provider) || !nonBlankString2(value.id)) {
     throw new PiRpcFaultError("protocolError", `Pi RPC returned an invalid ${context} Model`);
   }
   return { provider: value.provider, id: value.id };
 }
 function sessionStateData(response) {
-  const data = isRecord17(response.data) ? response.data : null;
+  const data = isRecord18(response.data) ? response.data : null;
   if (!data)
     throw new PiRpcFaultError("protocolError", "Pi RPC state response has no data");
   return data;
@@ -53794,13 +53971,13 @@ function parseSessionStreaming(response) {
   return isStreaming;
 }
 function parseSessionHistory(response) {
-  const data = isRecord17(response.data) ? response.data : null;
+  const data = isRecord18(response.data) ? response.data : null;
   if (!data || !Array.isArray(data.entries)) {
     throw new PiRpcFaultError("protocolError", "Pi RPC entries response has no Entries");
   }
   const entries = data.entries.map((entry) => {
     const parsed = jsonValueSchema.safeParse(entry);
-    if (!parsed.success || !isRecord17(parsed.data)) {
+    if (!parsed.success || !isRecord18(parsed.data)) {
       throw new PiRpcFaultError("protocolError", "Pi RPC entries response contains an invalid Entry");
     }
     return parsed.data;
@@ -53811,7 +53988,7 @@ function parseSessionHistory(response) {
   return { entries, leafId: data.leafId };
 }
 function parseAvailableThinkingLevels(response) {
-  const data = isRecord17(response.data) ? response.data : null;
+  const data = isRecord18(response.data) ? response.data : null;
   if (!data || !Array.isArray(data.levels) || data.levels.length === 0) {
     throw new PiRpcFaultError("protocolError", "Pi RPC Thinking catalog response has no levels");
   }
@@ -53828,35 +54005,35 @@ function parseAvailableThinkingLevels(response) {
   return levels;
 }
 function parseAvailableModels(response) {
-  const data = isRecord17(response.data) ? response.data : null;
+  const data = isRecord18(response.data) ? response.data : null;
   if (!data || !Array.isArray(data.models)) {
     throw new PiRpcFaultError("protocolError", "Pi RPC Model catalog response has no models");
   }
   return data.models.map((model) => {
     const parsed = parseNativeModel(model, "catalog");
-    if (!parsed || !isRecord17(model) || typeof model.reasoning !== "boolean") {
+    if (!parsed || !isRecord18(model) || typeof model.reasoning !== "boolean") {
       throw new PiRpcFaultError("protocolError", "Pi RPC catalog contains a Model without reasoning capability");
     }
     return { ...parsed, reasoning: model.reasoning };
   });
 }
 function assistantText2(value) {
-  if (!isRecord17(value) || value.role !== "assistant" || !Array.isArray(value.content))
+  if (!isRecord18(value) || value.role !== "assistant" || !Array.isArray(value.content))
     return null;
-  return value.content.filter((content) => isRecord17(content) && content.type === "text" && typeof content.text === "string").map((content) => content.text).join("");
+  return value.content.filter((content) => isRecord18(content) && content.type === "text" && typeof content.text === "string").map((content) => content.text).join("");
 }
 function assistantMessageId(value) {
-  if (!isRecord17(value) || value.role !== "assistant")
+  if (!isRecord18(value) || value.role !== "assistant")
     return null;
   return nonBlankString2(value.responseId) ? value.responseId : null;
 }
 function assistantReasoning(value) {
-  if (!isRecord17(value) || value.role !== "assistant" || !Array.isArray(value.content))
+  if (!isRecord18(value) || value.role !== "assistant" || !Array.isArray(value.content))
     return null;
-  return value.content.filter((content) => isRecord17(content) && content.type === "thinking" && typeof content.thinking === "string").map((content) => content.thinking).join("");
+  return value.content.filter((content) => isRecord18(content) && content.type === "thinking" && typeof content.thinking === "string").map((content) => content.thinking).join("");
 }
 function assistantFailure(value) {
-  if (!isRecord17(value) || value.role !== "assistant")
+  if (!isRecord18(value) || value.role !== "assistant")
     return void 0;
   if (value.stopReason !== "error" && value.stopReason !== "aborted")
     return null;
@@ -53876,7 +54053,7 @@ function signalProcessTree2(child, signal) {
   try {
     process.kill(-child.pid, signal);
   } catch (error52) {
-    if (!isRecord17(error52) || error52.code !== "ESRCH")
+    if (!isRecord18(error52) || error52.code !== "ESRCH")
       throw error52;
   }
 }
@@ -53907,7 +54084,7 @@ function piRpcProcessCommand(options, dependencies = {}) {
   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_2 = ["--mode", "rpc", ...modelArguments, ...sessionArguments];
-  const extension = path12.win32.extname(command).toLowerCase();
+  const extension = path13.win32.extname(command).toLowerCase();
   if (platform !== "win32" || ![".cmd", ".bat"].includes(extension)) {
     return { command, arguments: arguments_2, windowsVerbatimArguments: false };
   }
@@ -53990,7 +54167,7 @@ var PiRpcSession = class {
     });
     child.stderr.resume();
     child.once("error", (error52) => {
-      const kind = isRecord17(error52) && error52.code === "ENOENT" ? "notInstalled" : "unavailable";
+      const kind = isRecord18(error52) && error52.code === "ENOENT" ? "notInstalled" : "unavailable";
       this.#fail(new PiRpcFaultError(kind, `Pi RPC failed to start: ${error52.message}`));
     });
     child.once("exit", (code, signal) => {
@@ -54242,7 +54419,7 @@ var PiRpcSession = class {
       this.#buffer = this.#buffer.subarray(newline3 + 1);
       try {
         const value = JSON.parse(textDecoder.decode(frame));
-        if (!isRecord17(value) || typeof value.type !== "string") {
+        if (!isRecord18(value) || typeof value.type !== "string") {
           throw new PiRpcFaultError("protocolError", "Pi RPC returned an invalid envelope");
         }
         this.#handle(value);
@@ -54281,7 +54458,7 @@ var PiRpcSession = class {
       }
       compactionTurn?.onEvent({
         type: "compaction.completed",
-        outcome: value.aborted === true ? "cancelled" : isRecord17(value.result) ? "succeeded" : "failed",
+        outcome: value.aborted === true ? "cancelled" : isRecord18(value.result) ? "succeeded" : "failed",
         ...nonBlankString2(value.errorMessage) ? { errorMessage: value.errorMessage } : {}
       });
       return;
@@ -54301,7 +54478,7 @@ var PiRpcSession = class {
       this.#startAssistantMessage(active, value.message);
       return;
     }
-    if (value.type === "message_update" && isRecord17(value.assistantMessageEvent)) {
+    if (value.type === "message_update" && isRecord18(value.assistantMessageEvent)) {
       const event = value.assistantMessageEvent;
       if (event.type === "text_delta" && typeof event.delta === "string") {
         const messageId = this.#ensureAssistantMessage(active, value.message);
@@ -54695,7 +54872,7 @@ var PiRpcSession = class {
 // packages/adapters/pi/dist/pi-adapter.js
 var piHarnessId2 = harnessIdSchema.parse("pi");
 var DEFAULT_TOOL_OUTPUT_LIMIT4 = 64e3;
-function isRecord18(value) {
+function isRecord19(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function errorMessage(error52) {
@@ -54769,7 +54946,7 @@ function nativeModelForHistory(state) {
   return nativeModelFromState(state);
 }
 function sessionFileFromRef(ref) {
-  if (ref.harnessId !== piHarnessId2 || !isRecord18(ref.locator) || typeof ref.locator.sessionFile !== "string" || ref.locator.sessionFile.length === 0) {
+  if (ref.harnessId !== piHarnessId2 || !isRecord19(ref.locator) || typeof ref.locator.sessionFile !== "string" || ref.locator.sessionFile.length === 0) {
     throw new Error("Pi Native Session Ref has no resumable Session file");
   }
   return ref.locator.sessionFile;
@@ -54784,9 +54961,9 @@ function toolFailure2(toolName) {
 function nativeText(value) {
   if (typeof value === "string")
     return value;
-  if (!isRecord18(value) || !Array.isArray(value.content))
+  if (!isRecord19(value) || !Array.isArray(value.content))
     return "";
-  return value.content.filter((content) => isRecord18(content) && content.type === "text" && typeof content.text === "string").map(({ text }) => text).join("");
+  return value.content.filter((content) => isRecord19(content) && content.type === "text" && typeof content.text === "string").map(({ text }) => text).join("");
 }
 function boundedOutput(value, limit) {
   const text = nativeText(value);
@@ -54802,19 +54979,19 @@ function outputText2(output) {
   return output?.content.filter((content) => content.type === "text").map(({ text }) => text).join("") ?? "";
 }
 function stringField2(value, key) {
-  return isRecord18(value) && typeof value[key] === "string" ? value[key] : void 0;
+  return isRecord19(value) && typeof value[key] === "string" ? value[key] : void 0;
 }
 function numberField(value, key) {
-  if (!isRecord18(value))
+  if (!isRecord19(value))
     return void 0;
   const field = value[key];
   return typeof field === "number" || field === null ? field : void 0;
 }
-function stripDiffPrefix(path18) {
-  return path18.startsWith("a/") || path18.startsWith("b/") ? path18.slice(2) : path18;
+function stripDiffPrefix(path19) {
+  return path19.startsWith("a/") || path19.startsWith("b/") ? path19.slice(2) : path19;
 }
 function reliableFileChange(result) {
-  if (!isRecord18(result) || !isRecord18(result.details) || typeof result.details.patch !== "string") {
+  if (!isRecord19(result) || !isRecord19(result.details) || typeof result.details.patch !== "string") {
     return null;
   }
   const patch = result.details.patch;
@@ -54830,10 +55007,10 @@ function reliableFileChange(result) {
   const oldFile = file2.oldFileName;
   const newFile = file2.newFileName;
   const kind = oldFile === "/dev/null" ? "add" : newFile === "/dev/null" ? "delete" : "update";
-  const path18 = stripDiffPrefix(kind === "delete" ? oldFile : newFile);
-  if (!path18 || path18 === "/dev/null")
+  const path19 = stripDiffPrefix(kind === "delete" ? oldFile : newFile);
+  if (!path19 || path19 === "/dev/null")
     return null;
-  return [{ path: path18, kind, unifiedDiff: patch }];
+  return [{ path: path19, kind, unifiedDiff: patch }];
 }
 function delay3(milliseconds) {
   return new Promise((resolve2) => setTimeout(resolve2, milliseconds));
@@ -56077,7 +56254,7 @@ import { execFileSync } from "node:child_process";
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { constants as constants3 } from "node:fs";
 import { copyFile, mkdir, open as open2, readFile as readFile3, readdir, rename, rm as rm2, stat } from "node:fs/promises";
-import path13 from "node:path";
+import path14 from "node:path";
 
 // packages/mapping-store/dist/records.js
 var nonBlankTextSchema3 = external_exports.string().refine((value) => value.trim().length > 0, {
@@ -56244,6 +56421,18 @@ function isNodeExecutable(value) {
 function lockOwnerIsLive(lock) {
   if (typeof lock.pid !== "number")
     return false;
+  if (lock.pid === process.pid) {
+    if (lock.executablePath && normalizeExecutablePath(lock.executablePath) !== normalizeExecutablePath(process.execPath)) {
+      return false;
+    }
+    if (lock.processStartedAt) {
+      const expected = Date.parse(lock.processStartedAt);
+      const actual = Date.now() - process.uptime() * 1e3;
+      if (Number.isFinite(expected) && Math.abs(actual - expected) > 5e3)
+        return false;
+    }
+    return true;
+  }
   const identity = processIdentity(lock.pid);
   if (!identity)
     return false;
@@ -56282,11 +56471,11 @@ var MappingStore = class {
   #initialized = false;
   #lockHandle = null;
   constructor(options) {
-    this.#directory = path13.resolve(options.directory);
-    this.#threadsDirectory = path13.join(this.#directory, "threads");
-    this.#backupsDirectory = path13.join(this.#directory, "backups");
-    this.#quarantineDirectory = path13.join(this.#directory, "quarantine");
-    this.#lockPath = path13.join(this.#directory, "store.lock");
+    this.#directory = path14.resolve(options.directory);
+    this.#threadsDirectory = path14.join(this.#directory, "threads");
+    this.#backupsDirectory = path14.join(this.#directory, "backups");
+    this.#quarantineDirectory = path14.join(this.#directory, "quarantine");
+    this.#lockPath = path14.join(this.#directory, "store.lock");
     this.#instanceId = options.instanceId ?? randomUUID6();
     this.#now = options.now ?? (() => /* @__PURE__ */ new Date());
     this.#beforeReplace = options.beforeReplace;
@@ -56304,8 +56493,8 @@ var MappingStore = class {
       await this.#cleanupTemps();
       const names = (await readdir(this.#threadsDirectory)).filter((name) => name.endsWith(".json"));
       for (const name of names) {
-        const primary = path13.join(this.#threadsDirectory, name);
-        const backup = path13.join(this.#backupsDirectory, name);
+        const primary = path14.join(this.#threadsDirectory, name);
+        const backup = path14.join(this.#backupsDirectory, name);
         let record3 = null;
         try {
           record3 = await this.#readRecord(primary, name);
@@ -56314,7 +56503,7 @@ var MappingStore = class {
             record3 = await this.#readRecord(backup, name);
             await this.#replaceFile(primary, record3, false);
           } catch (backupError) {
-            const quarantine = path13.join(this.#quarantineDirectory, `${name}.${this.#now().getTime()}.invalid`);
+            const quarantine = path14.join(this.#quarantineDirectory, `${name}.${this.#now().getTime()}.invalid`);
             await rename(primary, quarantine).catch(() => void 0);
             void primaryError;
             void backupError;
@@ -56423,27 +56612,29 @@ var MappingStore = class {
       if (current.state !== "ready" || !current.nativeSessionRef) {
         throw new MappingStoreError("MAPPING_CONFLICT", "Only a ready Thread can reconcile Snapshot mappings");
       }
-      const merged = this.#mergeMappings(current.turnMappings, mappings);
-      if (merged.length !== mappings.length) {
-        throw new MappingStoreError("MAPPING_CONFLICT", "Snapshot reconciliation must retain every existing Turn mapping");
-      }
-      const mergedByHost = new Map(merged.map((mapping) => [mapping.hostTurnId, mapping]));
-      const ordered = mappings.map(({ hostTurnId }) => {
-        const mapping = mergedByHost.get(hostTurnId);
-        if (!mapping) {
+      const byHost = new Map(current.turnMappings.map((mapping) => [mapping.hostTurnId, mapping]));
+      const byNative = new Map(current.turnMappings.map((mapping) => [nativeTurnKey(mapping), mapping]));
+      const seenHost = /* @__PURE__ */ new Set();
+      const seenNative = /* @__PURE__ */ new Set();
+      const ordered = mappings.map((update) => {
+        const hostMatch = byHost.get(update.hostTurnId);
+        const nativeMatch = byNative.get(nativeTurnKey(update));
+        if (hostMatch && nativeMatch && hostMatch !== nativeMatch) {
+          throw new MappingStoreError("MAPPING_CONFLICT", "Turn identity mapping conflicts");
+        }
+        if (hostMatch && !sameJson(hostMatch.nativeTurnRef, update.nativeTurnRef)) {
+          throw new MappingStoreError("MAPPING_CONFLICT", "Host Turn maps to another Native Turn");
+        }
+        if (nativeMatch && nativeMatch.hostTurnId !== update.hostTurnId) {
+          throw new MappingStoreError("MAPPING_CONFLICT", "Native Turn maps to another Host Turn");
+        }
+        if (seenHost.has(update.hostTurnId) || seenNative.has(nativeTurnKey(update))) {
           throw new MappingStoreError("MAPPING_CONFLICT", "Snapshot reconciliation contains a duplicate Turn mapping");
         }
-        return mapping;
+        seenHost.add(update.hostTurnId);
+        seenNative.add(nativeTurnKey(update));
+        return { ...update };
       });
-      const orderedIndexByHost = new Map(ordered.map(({ hostTurnId }, index) => [hostTurnId, index]));
-      let previousIndex = -1;
-      for (const existing of current.turnMappings) {
-        const nextIndex = orderedIndexByHost.get(existing.hostTurnId);
-        if (nextIndex === void 0 || nextIndex <= previousIndex) {
-          throw new MappingStoreError("MAPPING_CONFLICT", "Snapshot reconciliation reordered an existing Turn mapping");
-        }
-        previousIndex = nextIndex;
-      }
       return sameJson(current.turnMappings, ordered) ? null : { ...current, turnMappings: ordered };
     });
   }
@@ -56595,7 +56786,7 @@ var MappingStore = class {
   }
   async #cleanupTemps() {
     const names = await readdir(this.#threadsDirectory);
-    await Promise.all(names.filter((name) => name.includes(".tmp-")).map((name) => rm2(path13.join(this.#threadsDirectory, name), { force: true })));
+    await Promise.all(names.filter((name) => name.includes(".tmp-")).map((name) => rm2(path14.join(this.#threadsDirectory, name), { force: true })));
   }
   async #acquireLock() {
     const attempt = async () => {
@@ -56688,10 +56879,10 @@ var MappingStore = class {
     }
   }
   #recordPath(hostThreadId) {
-    return path13.join(this.#threadsDirectory, `${hostThreadId}.json`);
+    return path14.join(this.#threadsDirectory, `${hostThreadId}.json`);
   }
   #backupPath(hostThreadId) {
-    return path13.join(this.#backupsDirectory, `${hostThreadId}.json`);
+    return path14.join(this.#backupsDirectory, `${hostThreadId}.json`);
   }
   #requireInitialized() {
     if (!this.#initialized) {
@@ -56710,7 +56901,7 @@ var packageMetadata5 = {
 var TITLE_MAX_LENGTH = 120;
 var DESCRIPTION_MAX_LENGTH = 500;
 var SERVER_NAME_MAX_LENGTH = 80;
-function isRecord19(value) {
+function isRecord20(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function boundedText(value, field, maxLength) {
@@ -56754,7 +56945,7 @@ function responseError(message3) {
 function responsePersist(value) {
   if (value === void 0 || value === null)
     return null;
-  if (!isRecord19(value) || Object.keys(value).length !== 1 || value.persist !== "session" && value.persist !== "always") {
+  if (!isRecord20(value) || Object.keys(value).length !== 1 || value.persist !== "session" && value.persist !== "always") {
     throw responseError("contains malformed persist metadata");
   }
   return value.persist;
@@ -56797,7 +56988,7 @@ function projectCodexApprovalRequest(input) {
     },
     denyResponse,
     parseResponse(result) {
-      if (!isRecord19(result) || typeof result.action !== "string") {
+      if (!isRecord20(result) || typeof result.action !== "string") {
         throw responseError("missing action");
       }
       if (Object.keys(result).some((key) => key !== "action" && key !== "content" && key !== "_meta")) {
@@ -56805,7 +56996,7 @@ function projectCodexApprovalRequest(input) {
       }
       const selectedPersist = responsePersist(result._meta);
       if (result.action === "accept") {
-        if ("content" in result && (!isRecord19(result.content) || Object.keys(result.content).length !== 0)) {
+        if ("content" in result && (!isRecord20(result.content) || Object.keys(result.content).length !== 0)) {
           throw responseError("contains non-empty accepted content");
         }
         if (selectedPersist === "session") {
@@ -56832,7 +57023,7 @@ function projectCodexApprovalRequest(input) {
 }
 
 // packages/protocol-core/dist/codex-question.js
-function isRecord20(value) {
+function isRecord21(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function responseError2(message3) {
@@ -56901,7 +57092,7 @@ function projectCodexQuestionRequest(input) {
       }
     },
     parseResponse(result) {
-      if (!isRecord20(result) || !isRecord20(result.answers)) {
+      if (!isRecord21(result) || !isRecord21(result.answers)) {
         throw responseError2("missing answers object");
       }
       const rawAnswers = result.answers;
@@ -56914,7 +57105,7 @@ function projectCodexQuestionRequest(input) {
         const question = interaction.questions.find(({ id: id2 }) => id2 === questionId);
         if (!question)
           throw responseError2("contains an unknown Question ID");
-        if (!isRecord20(answerValue) || !Array.isArray(answerValue.answers)) {
+        if (!isRecord21(answerValue) || !Array.isArray(answerValue.answers)) {
           throw responseError2("answer entry has no answers array");
         }
         const values = answerValue.answers;
@@ -57060,8 +57251,8 @@ function projectItem(item, outcome, defaultCwd, includeCommandOutput = true) {
       return {
         id: item.itemId,
         type: "fileChange",
-        changes: item.changes.map(({ path: path18, kind, unifiedDiff }) => ({
-          path: path18,
+        changes: item.changes.map(({ path: path19, kind, unifiedDiff }) => ({
+          path: path19,
           kind,
           diff: unifiedDiff
         })),
@@ -57478,8 +57669,8 @@ var CodexTurnProjector = class {
     return messages;
   }
   #fileChangeUpdates(itemId3, changes) {
-    const projectedChanges = changes.map(({ path: path18, kind, unifiedDiff }) => ({
-      path: path18,
+    const projectedChanges = changes.map(({ path: path19, kind, unifiedDiff }) => ({
+      path: path19,
       kind,
       diff: unifiedDiff
     }));
@@ -57524,7 +57715,7 @@ var CodexTurnProjector = class {
 };
 
 // packages/protocol-core/dist/thread-fork.js
-function isRecord21(value) {
+function isRecord22(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalText(params, name, options = {}) {
@@ -57547,7 +57738,7 @@ function optionalBoolean(params, name) {
 function decodeThreadForkRequest(request) {
   if (request.method !== "thread/fork")
     return null;
-  if (!isRecord21(request.params))
+  if (!isRecord22(request.params))
     throw new Error("thread/fork params must be an object");
   const params = request.params;
   const threadId2 = optionalText(params, "threadId");
@@ -57562,13 +57753,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 path18 = optionalText(params, "path", { allowEmpty: true });
+  const path19 = optionalText(params, "path", { allowEmpty: true });
   const ephemeral = optionalBoolean(params, "ephemeral");
   return {
     threadId: threadId2,
     ...lastTurnText ? { lastTurnId: hostTurnIdSchema.parse(lastTurnText) } : {},
     ...beforeTurnText ? { beforeTurnId: hostTurnIdSchema.parse(beforeTurnText) } : {},
-    ...path18 ? { path: path18 } : {},
+    ...path19 ? { path: path19 } : {},
     ...optionalField(params, "model"),
     ...optionalField(params, "modelProvider"),
     ...optionalField(params, "cwd"),
@@ -57583,7 +57774,7 @@ function decodeThreadForkRequest(request) {
 function decodeThreadRollbackRequest(request) {
   if (request.method !== "thread/rollback")
     return null;
-  if (!isRecord21(request.params))
+  if (!isRecord22(request.params))
     throw new Error("thread/rollback params must be an object");
   const { threadId: threadId2, numTurns } = request.params;
   if (typeof threadId2 !== "string" || threadId2.length === 0) {
@@ -57677,13 +57868,13 @@ var THREAD_SOURCE_KINDS = /* @__PURE__ */ new Set([
   "subAgentOther",
   "unknown"
 ]);
-function isRecord22(value) {
+function isRecord23(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function paramsObject(request, method) {
   if (request.params === void 0 && method === "thread/list")
     return {};
-  if (!isRecord22(request.params))
+  if (!isRecord23(request.params))
     throw new Error(`${method} params must be an object`);
   return request.params;
 }
@@ -57755,7 +57946,7 @@ function cursorPayload(value) {
   };
 }
 function parseCursorPayload(value) {
-  if (!isRecord22(value) || value.formatVersion !== 1)
+  if (!isRecord23(value) || value.formatVersion !== 1)
     throw new Error("Host cursor is invalid");
   const { queryFingerprint: fingerprint, sortDirection: sortDirection2, officialCursor, officialDone } = value;
   const { externalAnchor: externalAnchor2, externalDone } = value;
@@ -57764,7 +57955,7 @@ function parseCursorPayload(value) {
   }
   let anchor = null;
   if (externalAnchor2 !== null) {
-    if (!isRecord22(externalAnchor2) || !Number.isSafeInteger(externalAnchor2.timestamp) || typeof externalAnchor2.threadId !== "string" || externalAnchor2.threadId.length === 0) {
+    if (!isRecord23(externalAnchor2) || !Number.isSafeInteger(externalAnchor2.timestamp) || typeof externalAnchor2.threadId !== "string" || externalAnchor2.threadId.length === 0) {
       throw new Error("Host cursor is invalid");
     }
     anchor = {
@@ -57884,7 +58075,7 @@ function decodeThreadMetadataUpdateRequest(request) {
   if (params.gitInfo === null) {
     gitInfo = null;
   } else if (params.gitInfo !== void 0) {
-    if (!isRecord22(params.gitInfo)) {
+    if (!isRecord23(params.gitInfo)) {
       throw new Error("thread/metadata/update params.gitInfo must be an object or null");
     }
     gitInfo = {};
@@ -57912,7 +58103,7 @@ function optionalCursor(value, name) {
   return value;
 }
 function decodeOfficialThreadListPage(value) {
-  if (!isRecord22(value) || !Array.isArray(value.data) || value.data.some((row) => !isRecord22(row))) {
+  if (!isRecord23(value) || !Array.isArray(value.data) || value.data.some((row) => !isRecord23(row))) {
     throw new Error("Official thread/list response is invalid");
   }
   return {
@@ -58234,7 +58425,7 @@ var packageMetadata6 = {
 // packages/host-runtime/src/external-thread-repository.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
 import os6 from "node:os";
-import path14 from "node:path";
+import path15 from "node:path";
 function nativeTurnKey2(ref) {
   return `${ref.harnessId}\0${ref.nativeSessionId}\0${ref.nativeTurnKey}\0${ref.formatVersion}`;
 }
@@ -58243,8 +58434,8 @@ function sameMapping(left, right) {
 }
 function defaultMappingStoreDirectory(environment) {
   const dataDirectory = environment.CODEXHOST_DATA_DIR;
-  return path14.join(
-    dataDirectory ? path14.resolve(dataDirectory) : path14.join(os6.homedir(), ".codexhost"),
+  return path15.join(
+    dataDirectory ? path15.resolve(dataDirectory) : path15.join(os6.homedir(), ".codexhost"),
     "mapping-store"
   );
 }
@@ -58454,25 +58645,14 @@ var ExternalThreadRepository = class {
         ...turn.checkpoint ? { nativeCheckpointRef: turn.checkpoint } : {}
       };
       return {
-        existing,
         snapshot: turn,
         mapping: {
           ...mapping,
+          nativeTurnRef: turn.nativeTurnRef,
           ...turn.checkpoint ? { nativeCheckpointRef: turn.checkpoint } : {}
         }
       };
     });
-    let existingIndex = 0;
-    for (const { existing } of aligned) {
-      if (!existing) continue;
-      if (existing.hostTurnId !== record3.turnMappings[existingIndex]?.hostTurnId) {
-        throw new Error("Persisted Turn mappings do not match the Native Snapshot order");
-      }
-      existingIndex += 1;
-    }
-    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 !== record3.turnMappings.length || orderedMappings.some((mapping, index) => {
       const persisted = record3.turnMappings[index];
@@ -59329,7 +59509,7 @@ var ExternalThreadRuntime = class {
 import { randomUUID as randomUUID8 } from "node:crypto";
 var INTERNAL_REQUEST_PREFIX = "codexhost:official:";
 var MAX_RETIRED_IDS = 1024;
-function isRecord23(value) {
+function isRecord24(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var OfficialRequestBroker = class {
@@ -59372,7 +59552,7 @@ var OfficialRequestBroker = class {
     });
   }
   handle(value) {
-    if (!isRecord23(value) || typeof value.id !== "string") return false;
+    if (!isRecord24(value) || typeof value.id !== "string") return false;
     const pending = this.#pending.get(value.id);
     if (!pending) return this.#retired.has(value.id);
     clearTimeout(pending.timeout);
@@ -59401,11 +59581,11 @@ var OfficialRequestBroker = class {
 };
 
 // packages/host-runtime/src/route-observation.ts
-function isRecord24(value) {
+function isRecord25(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function classifyThreadPurpose(request) {
-  return isRecord24(request.params) && request.params.ephemeral === true ? "ephemeral" : "conversation";
+  return isRecord25(request.params) && request.params.ephemeral === true ? "ephemeral" : "conversation";
 }
 var RequestRouteObservationTracker = class {
   #nextCreateOrdinal = 0;
@@ -59430,13 +59610,13 @@ var RequestRouteObservationTracker = class {
     this.#createByThreadId.set(threadId2, tracked);
   }
   bindOfficialResponse(response) {
-    if (!isRecord24(response) || !("id" in response)) return;
+    if (!isRecord25(response) || !("id" in response)) return;
     const tracked = this.#pendingByRequestId.get(response.id);
     if (!tracked) return;
     this.#pendingByRequestId.delete(response.id);
     const result = response.result;
-    const thread = isRecord24(result) ? result.thread : null;
-    if (isRecord24(thread) && typeof thread.id === "string") {
+    const thread = isRecord25(result) ? result.thread : null;
+    if (isRecord25(thread) && typeof thread.id === "string") {
       this.#createByThreadId.set(thread.id, tracked);
     }
   }
@@ -59533,25 +59713,25 @@ function resolveExternalSessionTreeIds(records) {
   const resolve2 = (start) => {
     const cached2 = resolved.get(start.hostThreadId);
     if (cached2) return cached2;
-    const path18 = [];
+    const path19 = [];
     const visited = /* @__PURE__ */ new Set();
     let current = start;
     while (true) {
       const known = resolved.get(current.hostThreadId);
       if (known) {
-        for (const record3 of path18) resolved.set(record3.hostThreadId, known);
+        for (const record3 of path19) 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);
-      path18.push(current);
+      path19.push(current);
       const sourceId = current.forkSource?.hostThreadId;
       const source = sourceId ? byId.get(sourceId) : void 0;
       if (!source) {
         const root = current.hostThreadId;
-        for (const record3 of path18) resolved.set(record3.hostThreadId, root);
+        for (const record3 of path19) resolved.set(record3.hostThreadId, root);
         return root;
       }
       current = source;
@@ -59602,11 +59782,11 @@ var OfficialThreadListError = class extends Error {
   }
   rpcError;
 };
-function isRecord25(value) {
+function isRecord26(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function officialThreadListPageFromResponse(response) {
-  if (isRecord25(response.error)) {
+  if (isRecord26(response.error)) {
     if (!Number.isSafeInteger(response.error.code) || typeof response.error.message !== "string") {
       throw new Error("Official thread/list error response is invalid");
     }
@@ -59766,14 +59946,14 @@ async function aggregateThreadList(input) {
 }
 
 // packages/host-runtime/src/app-server-host.ts
-function isRecord26(value) {
+function isRecord27(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isCreditsAdapter(adapter) {
   return typeof adapter.credits === "function" && typeof adapter.refreshCredits === "function";
 }
 function projectAccountCredits(value) {
-  if (!isRecord26(value)) return null;
+  if (!isRecord27(value)) return null;
   const rest = { ...value };
   delete rest.fetchedAt;
   const parsed = accountCreditsSnapshotSchema.safeParse(rest);
@@ -59795,6 +59975,7 @@ function officialEnvironment(source) {
     "CODEXHOST_STOCK_CODEX_PATH",
     "CODEXHOST_LAUNCHER_PID",
     "CODEXHOST_LAUNCHER_EXECUTABLE",
+    "CODEXHOST_RUNTIME_DESCRIPTOR_PATH",
     "CODEXHOST_CONTROL_PORT",
     "CODEXHOST_CONTROL_NONCE",
     "CODEXHOST_NPM_NODE_PATH",
@@ -59872,12 +60053,12 @@ function classifyCreateRequestRoute(request, defaultAgent2) {
   };
 }
 function requestObject(request) {
-  if (!isRecord26(request.params)) throw new Error(`${request.method} params must be an object`);
+  if (!isRecord27(request.params)) throw new Error(`${request.method} params must be an object`);
   return request.params;
 }
 function requestText(params) {
   if (!Array.isArray(params.input)) throw new Error("turn/start input must be an array");
-  const text = params.input.filter((item) => isRecord26(item) && item.type === "text").map((item) => item.text).filter((value) => typeof value === "string").join("\n");
+  const text = params.input.filter((item) => isRecord27(item) && item.type === "text").map((item) => item.text).filter((value) => typeof value === "string").join("\n");
   if (!text) throw new Error("turn/start must contain text input");
   return text;
 }
@@ -60151,7 +60332,7 @@ var AppServerHost = class {
         continue;
       }
       if (request.method === "thread/fork") {
-        const params = isRecord26(request.params) ? request.params : {};
+        const params = isRecord27(request.params) ? request.params : {};
         const resolution = typeof params.threadId === "string" ? await this.#resolveExternalThread(params.threadId) : { kind: "official" };
         if (resolution.kind === "error") {
           await this.#writer.json(
@@ -60174,7 +60355,7 @@ var AppServerHost = class {
         }
       }
       if (request.method === "thread/rollback") {
-        const params = isRecord26(request.params) ? request.params : {};
+        const params = isRecord27(request.params) ? request.params : {};
         const resolution = typeof params.threadId === "string" ? await this.#resolveExternalThread(params.threadId) : { kind: "official" };
         if (resolution.kind === "error") {
           await this.#writer.json(
@@ -60314,7 +60495,7 @@ var AppServerHost = class {
           continue;
         }
       }
-      if (request.method.startsWith("thread/") && !EXPLICIT_EXTERNAL_THREAD_METHODS.has(request.method) && isRecord26(request.params) && typeof request.params.threadId === "string") {
+      if (request.method.startsWith("thread/") && !EXPLICIT_EXTERNAL_THREAD_METHODS.has(request.method) && isRecord27(request.params) && typeof request.params.threadId === "string") {
         const location = await this.#locateExternalThread(request.params.threadId);
         if (await this.#writeResolutionError(request, location)) continue;
         if (location.kind === "external") {
@@ -61137,10 +61318,10 @@ var AppServerHost = class {
       ...typeof params.serviceTier === "string" ? { serviceTier: params.serviceTier } : {}
     });
     try {
-      if (params.initialTurnsPage !== void 0 && params.initialTurnsPage !== null && !isRecord26(params.initialTurnsPage)) {
+      if (params.initialTurnsPage !== void 0 && params.initialTurnsPage !== null && !isRecord27(params.initialTurnsPage)) {
         throw new ExternalHistoryRequestError("initialTurnsPage must be an object");
       }
-      const initialPageParams = isRecord26(params.initialTurnsPage) ? params.initialTurnsPage : null;
+      const initialPageParams = isRecord27(params.initialTurnsPage) ? params.initialTurnsPage : null;
       const initialTurnsPage = initialPageParams ? listExternalTurns(turns, initialPageParams) : null;
       const paginated = thread.record.historyMode === "paginated";
       const turnsBackwardsCursor = paginated ? listExternalTurns(turns, { limit: 1, itemsView: "notLoaded" }).backwardsCursor : null;
@@ -61392,7 +61573,7 @@ var AppServerHost = class {
     }
   }
   async #handleDesktopApprovalResponse(value) {
-    if (!isRecord26(value) || !isHostApprovalRequestId(value.id)) return false;
+    if (!isRecord27(value) || !isHostApprovalRequestId(value.id)) return false;
     const pending = this.#pendingDesktopApprovals.get(value.id);
     if (!pending) return true;
     this.#pendingDesktopApprovals.delete(value.id);
@@ -61514,7 +61695,7 @@ var AppServerHost = class {
     }
   }
   async #handleDesktopQuestionResponse(value) {
-    if (!isRecord26(value) || !isHostQuestionRequestId(value.id)) return false;
+    if (!isRecord27(value) || !isHostQuestionRequestId(value.id)) return false;
     const pending = this.#pendingDesktopQuestions.get(value.id);
     if (!pending) return true;
     this.#pendingDesktopQuestions.delete(value.id);
@@ -61626,7 +61807,7 @@ var AppServerHost = class {
 
 // packages/update-manager/dist/distribution.js
 import { lstat, readFile as readFile4 } from "node:fs/promises";
-import path15 from "node:path";
+import path16 from "node:path";
 
 // packages/update-manager/dist/status.js
 var STATUS_SCHEMA_VERSION = 1;
@@ -61681,6 +61862,7 @@ function parseUpdateStatus(value) {
 var UPDATE_RUNTIME_ENV = Object.freeze({
   launcherPid: "CODEXHOST_LAUNCHER_PID",
   launcherExecutable: "CODEXHOST_LAUNCHER_EXECUTABLE",
+  runtimeDescriptorPath: "CODEXHOST_RUNTIME_DESCRIPTOR_PATH",
   controllerPort: "CODEXHOST_CONTROL_PORT",
   controllerNonce: "CODEXHOST_CONTROL_NONCE",
   npmNodePath: "CODEXHOST_NPM_NODE_PATH",
@@ -61700,7 +61882,7 @@ function parseDistributionMetadata(value) {
   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") {
+  if (metadata.schemaVersion !== 1 || metadata.distribution !== "npm" && metadata.distribution !== "installer" || !["macos-arm64", "macos-x64", "windows-x64", "windows-arm64", "linux-x64"].includes(String(metadata.target)) || typeof metadata.version !== "string") {
     throw new Error("distribution metadata is invalid");
   }
   return {
@@ -61712,9 +61894,9 @@ function parseDistributionMetadata(value) {
 }
 function absoluteEnvironmentPath(environment, name) {
   const value = environment[name];
-  if (!value || !path15.isAbsolute(value))
+  if (!value || !path16.isAbsolute(value))
     throw new Error(`${name} must be an absolute path`);
-  return path15.normalize(value);
+  return path16.normalize(value);
 }
 function positiveEnvironmentInteger(environment, name) {
   const value = Number(environment[name]);
@@ -61731,48 +61913,52 @@ function expectedTarget(platform, architecture) {
     return "windows-arm64";
   if (platform === "win32" && architecture === "x64")
     return "windows-x64";
+  if (platform === "linux" && architecture === "x64")
+    return "linux-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 || !path15.isAbsolute(root))
+    if (!root || !path16.isAbsolute(root))
       throw new Error("LOCALAPPDATA is unavailable");
-    return path15.join(root, "codexhost", "updates");
+    return path16.join(root, "codexhost", "updates");
   }
   const home = environment.HOME;
-  if (!home || !path15.isAbsolute(home))
+  if (!home || !path16.isAbsolute(home))
     throw new Error("HOME is unavailable");
-  return platform === "darwin" ? path15.join(home, "Library", "Application Support", "codexhost", "updates") : path15.join(home, ".codexhost", "updates");
+  return platform === "darwin" ? path16.join(home, "Library", "Application Support", "codexhost", "updates") : path16.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 (!path15.isAbsolute(options.hostRuntimePath)) {
+  if (!path16.isAbsolute(options.hostRuntimePath)) {
     throw new Error("Host Runtime path must be absolute");
   }
-  const hostRuntimePath = path15.normalize(options.hostRuntimePath);
+  const hostRuntimePath = path16.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 = path15.dirname(hostRuntimePath);
-  const metadata = parseDistributionMetadata(JSON.parse(await readFile4(path15.join(appDirectory, "codexhost-distribution.json"), "utf8")));
+  const appDirectory = path16.dirname(hostRuntimePath);
+  const metadata = parseDistributionMetadata(JSON.parse(await readFile4(path16.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 = path15.normalize(options.stateDirectory ?? defaultUpdateStateDirectory(platform, environment));
-  const resourcesRoot = path15.dirname(appDirectory);
-  const installationRoot = platform === "darwin" ? path15.dirname(path15.dirname(resourcesRoot)) : resourcesRoot;
-  const updaterExecutable = path15.join(resourcesRoot, "libexec", platform === "win32" ? "codexhost-updater.exe" : "codexhost-updater");
+  const runtimeDescriptorPath = absoluteEnvironmentPath(environment, UPDATE_RUNTIME_ENV.runtimeDescriptorPath);
+  const stateDirectory = path16.normalize(options.stateDirectory ?? defaultUpdateStateDirectory(platform, environment));
+  const resourcesRoot = path16.dirname(appDirectory);
+  const installationRoot = platform === "darwin" ? path16.dirname(path16.dirname(resourcesRoot)) : resourcesRoot;
+  const updaterExecutable = path16.join(resourcesRoot, "libexec", platform === "win32" ? "codexhost-updater.exe" : "codexhost-updater");
   const common = {
     version: metadata.version,
     launcherPid,
     launcherExecutable,
+    runtimeDescriptorPath,
     updaterExecutable,
     stateDirectory
   };
@@ -61791,7 +61977,7 @@ async function resolveInstalledUpdateContext(options) {
       npmLauncherPath: absoluteEnvironmentPath(environment, UPDATE_RUNTIME_ENV.npmLauncherPath),
       packageRoot: absoluteEnvironmentPath(environment, UPDATE_RUNTIME_ENV.npmPackageRoot)
     };
-    if (path15.normalize(npmOptions.packageRoot) !== resourcesRoot) {
+    if (path16.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 } };
@@ -61954,7 +62140,7 @@ function selectInstallerReleaseArtifact(release, target) {
 
 // packages/update-manager/dist/operation-state.js
 import { lstat as lstat2, mkdir as mkdir2, open as open3, readFile as readFile5, readdir as readdir2, rm as rm3, writeFile } from "node:fs/promises";
-import path16 from "node:path";
+import path17 from "node:path";
 var LOCK_FILE = "active-update-v1.lock";
 var STATUS_FILE = "status-v1.json";
 var TERMINAL_PHASES = /* @__PURE__ */ new Set(["succeeded", "failed"]);
@@ -61969,12 +62155,12 @@ async function regularFile(filePath) {
   }
 }
 async function isUpdateOperationActive(stateDirectory) {
-  if (!path16.isAbsolute(stateDirectory))
+  if (!path17.isAbsolute(stateDirectory))
     throw new Error("update state directory must be absolute");
-  return regularFile(path16.join(stateDirectory, LOCK_FILE));
+  return regularFile(path17.join(stateDirectory, LOCK_FILE));
 }
 async function discoverLatestUpdateStatus(stateDirectory) {
-  if (!path16.isAbsolute(stateDirectory))
+  if (!path17.isAbsolute(stateDirectory))
     throw new Error("update state directory must be absolute");
   let entries;
   try {
@@ -61988,7 +62174,7 @@ async function discoverLatestUpdateStatus(stateDirectory) {
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.isSymbolicLink() || !entry.name.startsWith("update-"))
       continue;
-    const statusPath = path16.join(stateDirectory, entry.name, STATUS_FILE);
+    const statusPath = path17.join(stateDirectory, entry.name, STATUS_FILE);
     if (!await regularFile(statusPath))
       continue;
     try {
@@ -62016,8 +62202,8 @@ async function cleanupTerminalUpdateState(stateDirectory, options = {}) {
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.isSymbolicLink() || !entry.name.startsWith("update-"))
       continue;
-    const directory = path16.join(stateDirectory, entry.name);
-    const statusPath = path16.join(directory, STATUS_FILE);
+    const directory = path17.join(stateDirectory, entry.name);
+    const statusPath = path17.join(directory, STATUS_FILE);
     try {
       const status = parseUpdateStatus(JSON.parse(await readFile5(statusPath, "utf8")));
       if (TERMINAL_PHASES.has(status.phase) && now - status.updatedAt > retentionSeconds) {
@@ -62028,10 +62214,10 @@ async function cleanupTerminalUpdateState(stateDirectory, options = {}) {
   }
 }
 async function acquireUpdateOperationLock(stateDirectory) {
-  if (!path16.isAbsolute(stateDirectory))
+  if (!path17.isAbsolute(stateDirectory))
     throw new Error("update state directory must be absolute");
   await mkdir2(stateDirectory, { recursive: true, mode: 448 });
-  const lockPath = path16.join(stateDirectory, LOCK_FILE);
+  const lockPath = path17.join(stateDirectory, LOCK_FILE);
   let handle;
   try {
     handle = await open3(lockPath, "wx", 384);
@@ -62050,9 +62236,9 @@ async function acquireUpdateOperationLock(stateDirectory) {
     async setStatusPath(statusPath) {
       if (released)
         throw new Error("update operation lock is released");
-      if (!path16.isAbsolute(statusPath))
+      if (!path17.isAbsolute(statusPath))
         throw new Error("update status path must be absolute");
-      await writeFile(lockPath, `${JSON.stringify({ ownerPid: process.pid, statusPath: path16.normalize(statusPath) })}
+      await writeFile(lockPath, `${JSON.stringify({ ownerPid: process.pid, statusPath: path17.normalize(statusPath) })}
 `, { encoding: "utf8", mode: 384 });
     },
     async release() {
@@ -62074,7 +62260,7 @@ function processIsAlive(processId) {
   }
 }
 async function recoverUpdateOperationLock(stateDirectory) {
-  const lockPath = path16.join(stateDirectory, LOCK_FILE);
+  const lockPath = path17.join(stateDirectory, LOCK_FILE);
   if (!await regularFile(lockPath))
     return;
   let ownerPid;
@@ -62086,7 +62272,7 @@ async function recoverUpdateOperationLock(stateDirectory) {
   } catch {
     return;
   }
-  if (typeof statusPath !== "string" || !path16.isAbsolute(statusPath))
+  if (typeof statusPath !== "string" || !path17.isAbsolute(statusPath))
     return;
   try {
     const status = parseUpdateStatus(JSON.parse(await readFile5(statusPath, "utf8")));
@@ -62101,7 +62287,7 @@ async function recoverUpdateOperationLock(stateDirectory) {
 import { spawn as spawn6 } from "node:child_process";
 import { randomUUID as randomUUID10 } from "node:crypto";
 import { chmod, copyFile as copyFile2, lstat as lstat4, mkdir as mkdir3, readFile as readFile6, rename as rename2, rm as rm4, writeFile as writeFile2 } from "node:fs/promises";
-import path17 from "node:path";
+import path18 from "node:path";
 
 // packages/update-manager/dist/artifact.js
 import { createHash as createHash2 } from "node:crypto";
@@ -62194,13 +62380,37 @@ async function verifyDownloadedArtifact(source, filePath, result) {
 
 // packages/update-manager/dist/update-manager.js
 var REQUEST_SCHEMA_VERSION = 1;
+var WINDOWS_RENAME_RETRY_DELAYS_MS = [10, 30, 70, 150, 300];
 function errorMessage4(error52) {
   return error52 instanceof Error ? error52.message : String(error52);
 }
+function systemErrorCode2(error52) {
+  return typeof error52 === "object" && error52 !== null && "code" in error52 ? String(error52.code) : null;
+}
+function delay4(milliseconds) {
+  return new Promise((resolve2) => setTimeout(resolve2, milliseconds));
+}
+async function replaceStatusFile(temporaryPath, statusPath) {
+  let retryIndex = 0;
+  for (; ; ) {
+    try {
+      await rename2(temporaryPath, statusPath);
+      return;
+    } catch (error52) {
+      const retryDelay = WINDOWS_RENAME_RETRY_DELAYS_MS[retryIndex];
+      const code = systemErrorCode2(error52);
+      if (process.platform !== "win32" || retryDelay === void 0 || code !== "EACCES" && code !== "EBUSY" && code !== "EPERM") {
+        throw error52;
+      }
+      retryIndex += 1;
+      await delay4(retryDelay);
+    }
+  }
+}
 function requireAbsolutePath(value, label) {
-  if (!path17.isAbsolute(value))
+  if (!path18.isAbsolute(value))
     throw new Error(`${label} must be an absolute path`);
-  return path17.normalize(value);
+  return path18.normalize(value);
 }
 async function requireRegularFile(value, label) {
   const filePath = requireAbsolutePath(value, label);
@@ -62243,7 +62453,7 @@ function createBackgroundUpdateManager(dependencies = {}) {
   const now = dependencies.now ?? Date.now;
   const preparedRequests = /* @__PURE__ */ new Set();
   async function writeStatusSnapshot(statusPath, status) {
-    const temporaryPath = path17.join(path17.dirname(statusPath), `.update-status-${randomId()}.tmp`);
+    const temporaryPath = path18.join(path18.dirname(statusPath), `.update-status-${randomId()}.tmp`);
     try {
       await writeFile2(temporaryPath, `${JSON.stringify(status)}
 `, {
@@ -62251,7 +62461,7 @@ function createBackgroundUpdateManager(dependencies = {}) {
         mode: 384,
         flag: "wx"
       });
-      await rename2(temporaryPath, statusPath);
+      await replaceStatusFile(temporaryPath, statusPath);
     } catch (error52) {
       await rm4(temporaryPath, { force: true });
       throw error52;
@@ -62299,24 +62509,26 @@ function createBackgroundUpdateManager(dependencies = {}) {
     const version2 = requireSemanticVersion(options.version);
     const launcherPid = requireLauncherPid(options.launcherPid);
     const launcherExecutable = await requireRegularFile(options.launcherExecutable, "Launcher executable");
+    const runtimeDescriptorPath = requireAbsolutePath(options.runtimeDescriptorPath, "runtime descriptor path");
     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 = path17.join(stateDirectory, `update-${version2}-${randomId()}`);
+    const workDirectory = path18.join(stateDirectory, `update-${version2}-${randomId()}`);
     await mkdir3(workDirectory, { recursive: false, mode: 448 });
     const executableSuffix = platform === "win32" ? ".exe" : "";
-    const helperPath = path17.join(workDirectory, `codexhost-updater${executableSuffix}`);
+    const helperPath = path18.join(workDirectory, `codexhost-updater${executableSuffix}`);
     await copyFile2(updaterExecutable, helperPath);
     if (platform !== "win32")
       await chmod(helperPath, 448);
-    const requestPath = path17.join(workDirectory, "request-v1.json");
-    const statusPath = path17.join(workDirectory, "status-v1.json");
+    const requestPath = path18.join(workDirectory, "request-v1.json");
+    const statusPath = path18.join(workDirectory, "status-v1.json");
     await writePrivateJson(statusPath, preparedStatus(version2, installation, now()));
     await options.onPrepared?.({ version: version2, installation, statusPath });
     return {
       version: version2,
       launcherPid,
       launcherExecutable,
+      runtimeDescriptorPath,
       workDirectory,
       helperPath,
       requestPath,
@@ -62325,8 +62537,8 @@ function createBackgroundUpdateManager(dependencies = {}) {
   }
   async function prepareArtifact(common, installation, sourceValue, fileName) {
     const source = validateArtifact(sourceValue);
-    const temporaryPath = path17.join(common.workDirectory, `.${fileName}.download`);
-    const artifactPath = path17.join(common.workDirectory, fileName);
+    const temporaryPath = path18.join(common.workDirectory, `.${fileName}.download`);
+    const artifactPath = path18.join(common.workDirectory, fileName);
     const progress = progressReporter(common.statusPath, common.version, installation, source.size);
     try {
       const result = await download(source, temporaryPath, progress.update);
@@ -62352,6 +62564,7 @@ function createBackgroundUpdateManager(dependencies = {}) {
       version: common.version,
       wait_pid: common.launcherPid,
       wait_executable: common.launcherExecutable,
+      runtime_descriptor_path: common.runtimeDescriptorPath,
       status_path: common.statusPath,
       installation
     };
@@ -62399,7 +62612,7 @@ function createBackgroundUpdateManager(dependencies = {}) {
         throw new Error("macOS DMG updates require macOS");
       const common = await prepareCommon(options, "macos-dmg");
       const appPath = requireAbsolutePath(options.appPath, "macOS application path");
-      if (path17.extname(appPath) !== ".app") {
+      if (path18.extname(appPath) !== ".app") {
         throw new Error("macOS application path must end in .app");
       }
       const artifact = await prepareArtifact(common, "macos-dmg", options.artifact, "update.dmg");
@@ -62469,9 +62682,11 @@ function createHostUpdateCoordinator(options) {
     return publicStatus(discovered.status);
   }
   async function installable(context, release) {
-    if (context.metadata.distribution === "npm") return true;
+    if (context.installation.kind === "npm") return true;
+    const target = context.metadata.target;
+    if (target === "linux-x64") return false;
     try {
-      selectInstallerReleaseArtifact(release, context.metadata.target);
+      selectInstallerReleaseArtifact(release, target);
       return true;
     } catch {
       return false;
@@ -62569,10 +62784,11 @@ function createHostUpdateCoordinator(options) {
                 onPrepared
               });
             } else {
-              const artifact = selectInstallerReleaseArtifact(
-                release,
-                context.metadata.target
-              ).source;
+              const target = context.metadata.target;
+              if (target === "linux-x64") {
+                throw new Error("Linux installer updates are unsupported");
+              }
+              const artifact = selectInstallerReleaseArtifact(release, target).source;
               prepared2 = context.installation.kind === "windows-installer" ? await manager.prepareWindowsInstaller({
                 ...context.installation.options,
                 version: release.version,