@codexhost/cli-darwin-arm64 0.2.0 → 0.2.2

package/app/host-runtime.mjs

@@ -773,10 +773,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path17) {
-  if (!path17)
+function getElementAtPath(obj, path18) {
+  if (!path18)
     return obj;
-  return path17.reduce((acc, key) => acc?.[key], obj);
+  return path18.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(path17, issues) {
+function prefixIssues(path18, issues) {
   return issues.map((iss) => {
     var _a4;
     (_a4 = iss).path ?? (_a4.path = []);
-    iss.path.unshift(path17);
+    iss.path.unshift(path18);
     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, path17 = []) => {
+  const processError = (error53, path18 = []) => {
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path17, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path17, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path17, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
       } else {
-        const fullpath = [...path17, ...issue2.path];
+        const fullpath = [...path18, ...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, path17 = []) => {
+  const processError = (error53, path18 = []) => {
     var _a4, _b2;
     for (const issue2 of error53.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path17, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path17, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path17, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
       } else {
-        const fullpath = [...path17, ...issue2.path];
+        const fullpath = [...path18, ...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 path17 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path17) {
+  const path18 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path18) {
     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 path17 = ref.slice(1).split("/").filter(Boolean);
-  if (path17.length === 0) {
+  const path18 = ref.slice(1).split("/").filter(Boolean);
+  if (path18.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path17[0] === defsKey) {
-    const key = path17[1];
+  if (path18[0] === defsKey) {
+    const key = path18[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14690,12 +14690,24 @@ var threadUsageSnapshotSchema = external_exports.object({
     });
   }
 });
+var usagePercentSchema = external_exports.number().finite().min(0).max(100);
+var accountCreditsProductUsageSchema = external_exports.object({
+  product: external_exports.string().min(1),
+  usagePercent: usagePercentSchema
+}).strict();
+var accountCreditsSnapshotSchema = external_exports.object({
+  usedPercent: usagePercentSchema,
+  resetsAt: external_exports.string().min(1).optional(),
+  periodType: external_exports.enum(["weekly", "monthly", "unknown"]),
+  productUsage: external_exports.array(accountCreditsProductUsageSchema).min(1).optional()
+}).strict();
 var threadUsageInspectionParamsSchema = external_exports.object({
   threadId: hostThreadIdSchema
 }).strict();
 var threadUsageInspectionSchema = external_exports.object({
   threadId: hostThreadIdSchema,
-  usage: threadUsageSnapshotSchema.nullable()
+  usage: threadUsageSnapshotSchema.nullable(),
+  accountCredits: accountCreditsSnapshotSchema.optional()
 }).strict();
 
 // packages/shared-contracts/dist/harness-models.js
@@ -19116,8 +19128,8 @@ var qU = v(function(BU) {
   BU._globalThis = void 0;
   BU._globalThis = typeof globalThis === "object" ? globalThis : global;
 });
-var GU = v(function(os6) {
-  var Axe = os6 && os6.__createBinding || (Object.create ? function(e, t, r, n) {
+var GU = v(function(os7) {
+  var Axe = os7 && os7.__createBinding || (Object.create ? function(e, t, r, n) {
     if (n === void 0) n = r;
     Object.defineProperty(e, n, { enumerable: true, get: function() {
       return t[r];
@@ -19125,11 +19137,11 @@ var GU = v(function(os6) {
   } : function(e, t, r, n) {
     if (n === void 0) n = r;
     e[n] = t[r];
-  }), kxe = os6 && os6.__exportStar || function(e, t) {
+  }), kxe = os7 && os7.__exportStar || function(e, t) {
     for (var r in e) if (r !== "default" && !Object.prototype.hasOwnProperty.call(t, r)) Axe(t, e, r);
   };
-  Object.defineProperty(os6, "__esModule", { value: true });
-  kxe(qU(), os6);
+  Object.defineProperty(os7, "__esModule", { value: true });
+  kxe(qU(), os7);
 });
 var WU = v(function(is) {
   var Oxe = is && is.__createBinding || (Object.create ? function(e, t, r, n) {
@@ -44826,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(path17, body, signal, timeoutPolicy = "default") {
+  async postJson(path18, 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(path17, this.resolveBase()), {
+    const response = await this.doFetch(new URL(path18, 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 ${path17}: HTTP ${response.status}`);
+      throw new Error(`transport failure for ${path18}: HTTP ${response.status}`);
     return response;
   }
   /**
@@ -44871,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(path17, signal, frameSchema, onOpen) {
-    const response = await this.doFetch(new URL(path17, this.resolveBase()), { signal });
+  async *readSse(path18, signal, frameSchema, onOpen) {
+    const response = await this.doFetch(new URL(path18, this.resolveBase()), { signal });
     if (!response.ok || response.body === null)
-      throw new Error(`transport failure for ${path17}: HTTP ${response.status}`);
+      throw new Error(`transport failure for ${path18}: HTTP ${response.status}`);
     onOpen?.();
     const reader = response.body.getReader();
     const decoder2 = new TextDecoder();
@@ -44898,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 ${path17}:`, error52);
+            console.error(`[apiproxy] dropping malformed SSE frame on ${path18}:`, error52);
             continue;
           }
           this.onEnvelope(full);
@@ -45473,16 +45485,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path17, added, removed, oldPosInc, options) {
-    const last = path17.lastComponent;
+  addToPath(path18, added, removed, oldPosInc, options) {
+    const last = path18.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path17.oldPos + oldPosInc,
+        oldPos: path18.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path17.oldPos + oldPosInc,
+        oldPos: path18.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -46657,13 +46669,7 @@ var DeepSeekHarnessSession = class {
           error: invalidState2(`DeepSeek Harness rejected Interaction: ${receipt.reason}`)
         };
       }
-      active.interactions.delete(command.interactionId);
-      this.#emit({
-        type: "interaction.closed",
-        interactionId: command.interactionId,
-        turnId: active.command.turnId,
-        reason: "responded"
-      });
+      this.#closeHostInteraction(active, command.interactionId, "responded");
       return { ok: true, value: { accepted: true } };
     } catch (error52) {
       return { ok: false, error: normalizedError(error52, "nativeFailure") };
@@ -46945,15 +46951,19 @@ var DeepSeekHarnessSession = class {
       const matches = type === "approval" ? pending.type === "approval" && pending.approvalId === nativeId : pending.type === "question" && pending.rpcId === nativeId;
       if (!matches)
         continue;
-      active.interactions.delete(interactionId);
-      this.#emit({
-        type: "interaction.closed",
-        interactionId,
-        turnId: active.command.turnId,
-        reason: "responded"
-      });
+      this.#closeHostInteraction(active, interactionId, "responded");
     }
   }
+  #closeHostInteraction(active, interactionId, reason) {
+    if (!active.interactions.delete(interactionId))
+      return;
+    this.#emit({
+      type: "interaction.closed",
+      interactionId,
+      turnId: active.command.turnId,
+      reason
+    });
+  }
   #finishTurn(active, reason) {
     const terminal = projectTurnReason(reason);
     const itemOutcome3 = terminal.outcome.status === "succeeded" ? { status: "succeeded" } : terminal.outcome.status === "cancelled" ? {
@@ -46965,15 +46975,9 @@ var DeepSeekHarnessSession = class {
     for (const tool of active.tools.values())
       this.#completeItem(active, tool.item, itemOutcome3);
     active.tools.clear();
-    for (const [interactionId] of active.interactions) {
-      this.#emit({
-        type: "interaction.closed",
-        interactionId,
-        turnId: active.command.turnId,
-        reason: "cancelled"
-      });
+    for (const interactionId of [...active.interactions.keys()]) {
+      this.#closeHostInteraction(active, interactionId, "cancelled");
     }
-    active.interactions.clear();
     const nativeTurnRef2 = this.#nativeTurnRef(active.nativeTurn);
     this.#turns.push({
       nativeTurnRef: nativeTurnRef2,
@@ -47046,15 +47050,9 @@ var DeepSeekHarnessSession = class {
       for (const tool of active.tools.values())
         this.#completeItem(active, tool.item, outcome);
       active.tools.clear();
-      for (const [interactionId] of active.interactions) {
-        this.#emit({
-          type: "interaction.closed",
-          interactionId,
-          turnId: active.command.turnId,
-          reason: "cancelled"
-        });
+      for (const interactionId of [...active.interactions.keys()]) {
+        this.#closeHostInteraction(active, interactionId, "cancelled");
       }
-      active.interactions.clear();
       this.#emit({
         type: "turn.completed",
         turnId: active.command.turnId,
@@ -47248,7 +47246,7 @@ var packageMetadata3 = {
 
 // packages/adapters/grok/dist/grok-adapter.js
 import { randomUUID as randomUUID3 } from "node:crypto";
-import path9 from "node:path";
+import path10 from "node:path";
 
 // packages/adapters/grok/dist/acp-transport.js
 import { spawn as spawn3, spawnSync } from "node:child_process";
@@ -51605,8 +51603,8 @@ function transportEvent(update, metadata) {
 function nativeSessionFile(options, sessionId, fileName) {
   const environment = { ...process.env, ...options.environment };
   const home = environment.HOME ?? environment.USERPROFILE ?? os3.homedir();
-  const grokHome = environment.GROK_HOME ?? path8.join(home, ".grok");
-  return path8.join(grokHome, "sessions", encodeURIComponent(path8.resolve(options.cwd)), sessionId, fileName);
+  const grokHome2 = environment.GROK_HOME ?? path8.join(home, ".grok");
+  return path8.join(grokHome2, "sessions", encodeURIComponent(path8.resolve(options.cwd)), sessionId, fileName);
 }
 function nativeHistoryPath(options, sessionId) {
   return nativeSessionFile(options, sessionId, "updates.jsonl");
@@ -51904,7 +51902,16 @@ function terminalOutcome(stopReason) {
     }
   };
 }
+var systemReminderPattern = /^\s*<system-reminder>[\s\S]*$/u;
+var taskCompletedTurnKeyPattern = /^task-completed-/u;
+function isSyntheticGrokUserText(text) {
+  return systemReminderPattern.test(text);
+}
+function isSyntheticGrokTurnKey(nativeTurnKey3) {
+  return taskCompletedTurnKeyPattern.test(nativeTurnKey3);
+}
 function mapGrokReplay(replay, harnessId, sessionId, 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 = [];
@@ -51935,13 +51942,11 @@ function mapGrokReplay(replay, harnessId, sessionId, knownTurnRefs = []) {
   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();
@@ -51964,6 +51969,8 @@ function mapGrokReplay(replay, harnessId, sessionId, knownTurnRefs = []) {
   };
   for (const event of replay) {
     if (event.type === "user.text") {
+      if (isSyntheticGrokUserText(event.text))
+        continue;
       if (input.length > 0) {
         completeTurn({
           status: "unknown",
@@ -51982,6 +51989,8 @@ function mapGrokReplay(replay, harnessId, sessionId, knownTurnRefs = []) {
     if (input.length === 0)
       continue;
     if (event.type === "turn.completed") {
+      if (isSyntheticGrokTurnKey(event.nativeTurnKey))
+        continue;
       completeTurn(terminalOutcome(event.stopReason), event.nativeTurnKey);
     } else if (event.type === "agent.text") {
       if (!agent) {
@@ -52023,9 +52032,6 @@ function mapGrokReplay(replay, harnessId, sessionId, knownTurnRefs = []) {
     }
   }
   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 };
 }
 
@@ -52124,9 +52130,115 @@ 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";
+var GROK_CREDITS_ENDPOINT = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
+var REQUEST_TIMEOUT_MS = 15e3;
+function isRecord11(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function finitePercent(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return void 0;
+  return Math.min(100, Math.max(0, value));
+}
+function nonNegativeNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+    return void 0;
+  return value;
+}
+function grokHome(environment) {
+  return environment.GROK_HOME ?? path9.join(environment.HOME ?? environment.USERPROFILE ?? os4.homedir(), ".grok");
+}
+function periodTypeFrom(value) {
+  if (typeof value !== "string")
+    return "unknown";
+  const normalized = value.toUpperCase();
+  if (normalized.includes("WEEKLY"))
+    return "weekly";
+  if (normalized.includes("MONTHLY"))
+    return "monthly";
+  return "unknown";
+}
+function productUsageFrom(value) {
+  if (!Array.isArray(value))
+    return void 0;
+  const products = value.flatMap((entry) => {
+    if (!isRecord11(entry) || typeof entry.product !== "string")
+      return [];
+    const usagePercent = finitePercent(entry.usagePercent);
+    return usagePercent === void 0 ? [] : [{ product: entry.product, usagePercent }];
+  });
+  return products.length > 0 ? products : void 0;
+}
+function parseGrokCreditsResponse(value, fetchedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  if (!isRecord11(value) || !isRecord11(value.config))
+    return null;
+  const config2 = value.config;
+  const period = isRecord11(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 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;
+  const productUsage = productUsageFrom(config2.productUsage);
+  return {
+    usedPercent,
+    periodType: periodTypeFrom(period?.type),
+    fetchedAt,
+    ...resetsAt ? { resetsAt } : {},
+    ...productUsage ? { productUsage } : {}
+  };
+}
+function selectAccessToken(auth, now) {
+  if (!isRecord11(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")));
+  for (const [, value] of entries) {
+    if (!isRecord11(value) || typeof value.key !== "string")
+      continue;
+    if (typeof value.expires_at === "string") {
+      const expiresAt = Date.parse(value.expires_at);
+      if (Number.isFinite(expiresAt) && expiresAt <= now.getTime())
+        continue;
+    }
+    return value.key;
+  }
+  return null;
+}
+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 raw = input.readAuthFile ? await input.readAuthFile(authPath) : await readFile2(authPath, "utf8");
+    const token = selectAccessToken(JSON.parse(raw), now);
+    if (!token)
+      return null;
+    const fetchImpl = input.fetch ?? fetch;
+    const response = await fetchImpl(GROK_CREDITS_ENDPOINT, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "x-xai-token-auth": "xai-grok-cli",
+        Accept: "application/json"
+      },
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+    });
+    if (!response.ok)
+      return null;
+    return parseGrokCreditsResponse(await response.json(), now.toISOString());
+  } catch {
+    return null;
+  }
+}
+
 // packages/adapters/grok/dist/grok-usage.js
 var USD_TICKS_PER_DOLLAR = 1e10;
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalToken(value) {
@@ -52143,7 +52255,7 @@ function combineUsage(base, next) {
   return base === null ? next : parseHostUsage({ ...base, ...next });
 }
 function usageFromNative(value) {
-  if (!isRecord11(value))
+  if (!isRecord12(value))
     return null;
   const inputTokens = optionalToken(value.inputTokens);
   const cachedRead = optionalToken(value.cachedReadTokens);
@@ -52170,7 +52282,7 @@ function usageFromPrompt(response) {
   return response.usage ? usageFromNative(response.usage) : null;
 }
 function usageFromSignals(value) {
-  if (!isRecord11(value))
+  if (!isRecord12(value))
     return null;
   try {
     return parseHostUsage({
@@ -52181,21 +52293,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 (!isRecord12(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 = isRecord11(update.cost) ? update.cost : null;
+      const cost = isRecord12(update.cost) ? update.cost : null;
       return parseHostUsage({
         contextUsedTokens: update.used,
         contextWindowTokens: update.size,
@@ -52229,7 +52400,7 @@ function capabilitiesForModels(modelState) {
 }
 var DEFAULT_CLOSE_TIMEOUT_MS3 = 2e3;
 var DEFAULT_TOOL_OUTPUT_LIMIT3 = 64e3;
-function isRecord12(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function invalidState3(message3) {
@@ -52264,7 +52435,7 @@ function contentText2(content) {
   if (!content)
     return "";
   return content.flatMap((entry) => {
-    if (!isRecord12(entry) || entry.type !== "content" || !isRecord12(entry.content))
+    if (!isRecord13(entry) || entry.type !== "content" || !isRecord13(entry.content))
       return [];
     return entry.content.type === "text" && typeof entry.content.text === "string" ? [entry.content.text] : [];
   }).join("\n");
@@ -52318,6 +52489,7 @@ var GrokHarnessSession = class {
   #cwd;
   #modelState;
   #onClosed;
+  #refreshCredits;
   #randomUUID;
   #snapshot;
   #toolOutputLimit;
@@ -52333,6 +52505,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;
@@ -52599,11 +52772,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) {
@@ -52740,7 +52909,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)
@@ -52827,22 +52997,53 @@ var GrokAdapter = class {
   harnessId = grokHarnessId;
   #closeTimeoutMs;
   #dependencies;
+  #environment;
+  #fetchCredits;
   #inspectionCache = /* @__PURE__ */ new Map();
   #sessions = /* @__PURE__ */ new Set();
   #toolOutputLimit;
   #closePromise = null;
+  #credits = null;
+  #creditsRefresh = null;
   constructor(options = {}, dependencies) {
     this.#closeTimeoutMs = options.closeTimeoutMs ?? DEFAULT_CLOSE_TIMEOUT_MS3;
+    this.#environment = options.environment;
     this.#toolOutputLimit = options.toolOutputLimit ?? DEFAULT_TOOL_OUTPUT_LIMIT3;
     this.#dependencies = dependencies ?? {
       randomUUID: randomUUID3,
       createTransport: (transportOptions) => new GrokAcpTransport({ ...options, ...transportOptions })
     };
+    this.#fetchCredits = this.#dependencies.fetchCredits ?? ((input) => fetchGrokCredits(input.environment ? { environment: input.environment } : this.#environment ? { environment: this.#environment } : {}));
+  }
+  credits() {
+    return this.#credits;
+  }
+  refreshCredits() {
+    if (this.#closePromise)
+      return Promise.resolve(this.#credits);
+    if (this.#creditsRefresh)
+      return this.#creditsRefresh;
+    this.#creditsRefresh = this.#loadCredits().finally(() => {
+      this.#creditsRefresh = null;
+    });
+    return this.#creditsRefresh;
+  }
+  #scheduleCreditsRefresh() {
+    void this.refreshCredits();
+  }
+  async #loadCredits() {
+    try {
+      const snapshot = await this.#fetchCredits(this.#environment ? { environment: this.#environment } : {});
+      if (snapshot)
+        this.#credits = snapshot;
+    } catch {
+    }
+    return this.#credits;
   }
   async inspect(input = {}) {
     if (this.#closePromise)
       return { status: "unavailable", error: invalidState3("Grok Adapter is closed") };
-    const cwd = path9.resolve(input.cwd ?? process.cwd());
+    const cwd = path10.resolve(input.cwd ?? process.cwd());
     if (!input.refresh) {
       const cached2 = this.#inspectionCache.get(cwd);
       if (cached2)
@@ -52862,6 +53063,7 @@ var GrokAdapter = class {
         capabilities: capabilitiesForModels(modelState)
       };
       this.#inspectionCache.set(cwd, ready);
+      this.#scheduleCreditsRefresh();
       return ready;
     } catch (error52) {
       await transport?.close().catch(() => void 0);
@@ -52900,7 +53102,7 @@ var GrokAdapter = class {
         }
       };
     }
-    const cwd = path9.resolve(input.cwd);
+    const cwd = path10.resolve(input.cwd);
     const parsedRef = input.kind === "resume" ? nativeSessionRefSchema.safeParse(input.nativeRef) : null;
     if (parsedRef && (!parsedRef.success || parsedRef.data.harnessId !== this.harnessId)) {
       return {
@@ -52938,17 +53140,19 @@ 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;
       this.#sessions.add(openedSession);
+      this.#scheduleCreditsRefresh();
       return { ok: true, value: openedSession };
     } catch (error52) {
       await transport.close().catch(() => void 0);
@@ -53086,7 +53290,7 @@ function normalizePiModelCatalog(nativeModels, effectiveModel, thinkingLevels, e
 
 // packages/adapters/pi/dist/pi-history.js
 var piHarnessId = harnessIdSchema.parse("pi");
-function isRecord13(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function textContent(value) {
@@ -53094,12 +53298,12 @@ function textContent(value) {
     return value;
   if (!Array.isArray(value))
     return "";
-  return value.filter((part) => isRecord13(part) && part.type === "text" && typeof part.text === "string").map((part) => part.text).join("");
+  return value.filter((part) => isRecord14(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) => isRecord13(part) && part.type === "thinking" && typeof part.thinking === "string").map((part) => part.thinking).join("");
+  return value.filter((part) => isRecord14(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") {
@@ -53130,7 +53334,7 @@ function activePiEntries(history) {
   return reversed.reverse();
 }
 function message(entry) {
-  return entry.type === "message" && isRecord13(entry.message) ? entry.message : null;
+  return entry.type === "message" && isRecord14(entry.message) ? entry.message : null;
 }
 function messageRole(entry) {
   const value = message(entry)?.role;
@@ -53192,7 +53396,7 @@ function snapshotItems(entries, outcome) {
       let projectedText = false;
       let projectedReasoning = false;
       for (const [ordinal, part] of content.entries()) {
-        if (!isRecord13(part))
+        if (!isRecord14(part))
           continue;
         if (part.type === "thinking" && !projectedReasoning && reasoning.length > 0) {
           const item2 = {
@@ -53384,12 +53588,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 path11 from "node:path";
+import path12 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 os4 from "node:os";
-import path10 from "node:path";
+import os5 from "node:os";
+import path11 from "node:path";
 function environmentValue2(environment, name) {
   return Object.entries(environment).find(([key]) => key.toLowerCase() === name.toLowerCase())?.[1];
 }
@@ -53402,34 +53606,35 @@ function isExecutable3(filePath, platform) {
   }
 }
 function pathCandidates(command, platform, environment) {
-  const targetPath = platform === "win32" ? path10.win32 : path10.posix;
+  const targetPath = platform === "win32" ? path11.win32 : path11.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 = path10.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) => path10.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" ? path11.win32 : path11.posix;
   if (platform === "win32") {
-    const appData = environment.APPDATA ?? path10.join(homeDirectory, "AppData", "Roaming");
+    const appData = environment.APPDATA ?? targetPath.join(homeDirectory, "AppData", "Roaming");
     return [
-      path10.join(appData, "npm", "pi.cmd"),
-      path10.join(homeDirectory, ".local", "bin", "pi.exe"),
-      path10.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 [
-    path10.join(homeDirectory, ".npm-global", "bin", "pi"),
-    path10.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"
   ];
@@ -53438,7 +53643,7 @@ function resolvePiExecutable(input, dependencies = {}) {
   const platform = dependencies.platform ?? process.platform;
   const configuredCommand = input.command ?? input.environment.PI_COMMAND;
   const command = configuredCommand ?? "pi";
-  const homeDirectory = dependencies.homeDirectory ?? input.environment.HOME ?? input.environment.USERPROFILE ?? os4.homedir();
+  const homeDirectory = dependencies.homeDirectory ?? input.environment.HOME ?? input.environment.USERPROFILE ?? os5.homedir();
   const candidates2 = [
     ...pathCandidates(command, platform, input.environment),
     ...configuredCommand ? [] : userInstallCandidates2(platform, input.environment, homeDirectory)
@@ -53449,7 +53654,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 = path10.dirname(runtimeExecutable);
+  const runtimeDirectory = path11.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))) {
@@ -53459,14 +53664,14 @@ function withNodeRuntimeOnPath2(environment, runtimeExecutable = process.execPat
 }
 
 // packages/adapters/pi/dist/pi-usage.js
-function isRecord14(value) {
+function isRecord15(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 (!isRecord14(value) || value.role !== "assistant" || !isRecord14(value.usage))
+  if (!isRecord15(value) || value.role !== "assistant" || !isRecord15(value.usage))
     return null;
   const input = nonNegativeSafeInteger2(value.usage.input);
   const cacheRead = nonNegativeSafeInteger2(value.usage.cacheRead);
@@ -53479,20 +53684,20 @@ function optionalPiCacheHitRatePercent(value) {
 function latestPiCacheHitRatePercent(history) {
   let latest = null;
   for (const entry of activePiEntries(history)) {
-    if (entry.type === "message" && isRecord14(entry.message) && entry.message.role === "assistant") {
+    if (entry.type === "message" && isRecord15(entry.message) && entry.message.role === "assistant") {
       latest = optionalPiCacheHitRatePercent(entry.message);
     }
   }
   return latest;
 }
 function responseData(response, operation) {
-  if (!isRecord14(response.data)) {
+  if (!isRecord15(response.data)) {
     throw new Error(`Pi RPC ${operation} response has no data`);
   }
   return response.data;
 }
 function contextUsage(value) {
-  if (!isRecord14(value))
+  if (!isRecord15(value))
     throw new Error("Pi RPC context Usage is invalid");
   return parseHostUsage({
     contextUsedTokens: value.tokens,
@@ -53502,15 +53707,15 @@ function contextUsage(value) {
 function parsePiSessionUsage(response) {
   const data = responseData(response, "Session stats");
   const tokens = data.tokens;
-  if (tokens !== void 0 && !isRecord14(tokens)) {
+  if (tokens !== void 0 && !isRecord15(tokens)) {
     throw new Error("Pi RPC Session stats tokens are invalid");
   }
   return parseHostUsage({
-    ...isRecord14(tokens) && tokens.input !== void 0 ? { inputTokens: tokens.input } : {},
-    ...isRecord14(tokens) && tokens.cacheRead !== void 0 ? { cachedInputTokens: tokens.cacheRead } : {},
-    ...isRecord14(tokens) && tokens.cacheWrite !== void 0 ? { cacheWriteInputTokens: tokens.cacheWrite } : {},
-    ...isRecord14(tokens) && tokens.output !== void 0 ? { outputTokens: tokens.output } : {},
-    ...isRecord14(tokens) && tokens.total !== void 0 ? { totalTokens: tokens.total } : {},
+    ...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 } : {},
     ...data.cost !== void 0 ? { totalCostUsd: data.cost } : {},
     ...data.contextUsage !== void 0 ? contextUsage(data.contextUsage) : {}
   });
@@ -53533,7 +53738,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 isRecord15(value) {
+function isRecord16(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function readPiSessionHeader(sessionFile) {
@@ -53553,7 +53758,7 @@ async function readPiSessionHeader(sessionFile) {
     } catch {
       throw new Error("Pi Session header is not valid JSON");
     }
-    if (!isRecord15(parsed) || parsed.type !== "session" || typeof parsed.id !== "string" || parsed.id.length === 0 || typeof parsed.cwd !== "string" || parsed.cwd.length === 0) {
+    if (!isRecord16(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 };
@@ -53595,7 +53800,7 @@ var PiRpcUnsupportedCommandError = class extends Error {
   }
 };
 var textDecoder = new TextDecoder("utf-8", { fatal: true });
-function isRecord16(value) {
+function isRecord17(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function message2(value) {
@@ -53607,13 +53812,13 @@ function nonBlankString2(value) {
 function parseNativeModel(value, context) {
   if (value === null || value === void 0)
     return null;
-  if (!isRecord16(value) || !nonBlankString2(value.provider) || !nonBlankString2(value.id)) {
+  if (!isRecord17(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 = isRecord16(response.data) ? response.data : null;
+  const data = isRecord17(response.data) ? response.data : null;
   if (!data)
     throw new PiRpcFaultError("protocolError", "Pi RPC state response has no data");
   return data;
@@ -53645,13 +53850,13 @@ function parseSessionStreaming(response) {
   return isStreaming;
 }
 function parseSessionHistory(response) {
-  const data = isRecord16(response.data) ? response.data : null;
+  const data = isRecord17(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 || !isRecord16(parsed.data)) {
+    if (!parsed.success || !isRecord17(parsed.data)) {
       throw new PiRpcFaultError("protocolError", "Pi RPC entries response contains an invalid Entry");
     }
     return parsed.data;
@@ -53662,7 +53867,7 @@ function parseSessionHistory(response) {
   return { entries, leafId: data.leafId };
 }
 function parseAvailableThinkingLevels(response) {
-  const data = isRecord16(response.data) ? response.data : null;
+  const data = isRecord17(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");
   }
@@ -53679,35 +53884,35 @@ function parseAvailableThinkingLevels(response) {
   return levels;
 }
 function parseAvailableModels(response) {
-  const data = isRecord16(response.data) ? response.data : null;
+  const data = isRecord17(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 || !isRecord16(model) || typeof model.reasoning !== "boolean") {
+    if (!parsed || !isRecord17(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 (!isRecord16(value) || value.role !== "assistant" || !Array.isArray(value.content))
+  if (!isRecord17(value) || value.role !== "assistant" || !Array.isArray(value.content))
     return null;
-  return value.content.filter((content) => isRecord16(content) && content.type === "text" && typeof content.text === "string").map((content) => content.text).join("");
+  return value.content.filter((content) => isRecord17(content) && content.type === "text" && typeof content.text === "string").map((content) => content.text).join("");
 }
 function assistantMessageId(value) {
-  if (!isRecord16(value) || value.role !== "assistant")
+  if (!isRecord17(value) || value.role !== "assistant")
     return null;
   return nonBlankString2(value.responseId) ? value.responseId : null;
 }
 function assistantReasoning(value) {
-  if (!isRecord16(value) || value.role !== "assistant" || !Array.isArray(value.content))
+  if (!isRecord17(value) || value.role !== "assistant" || !Array.isArray(value.content))
     return null;
-  return value.content.filter((content) => isRecord16(content) && content.type === "thinking" && typeof content.thinking === "string").map((content) => content.thinking).join("");
+  return value.content.filter((content) => isRecord17(content) && content.type === "thinking" && typeof content.thinking === "string").map((content) => content.thinking).join("");
 }
 function assistantFailure(value) {
-  if (!isRecord16(value) || value.role !== "assistant")
+  if (!isRecord17(value) || value.role !== "assistant")
     return void 0;
   if (value.stopReason !== "error" && value.stopReason !== "aborted")
     return null;
@@ -53727,7 +53932,7 @@ function signalProcessTree2(child, signal) {
   try {
     process.kill(-child.pid, signal);
   } catch (error52) {
-    if (!isRecord16(error52) || error52.code !== "ESRCH")
+    if (!isRecord17(error52) || error52.code !== "ESRCH")
       throw error52;
   }
 }
@@ -53758,7 +53963,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 = path11.win32.extname(command).toLowerCase();
+  const extension = path12.win32.extname(command).toLowerCase();
   if (platform !== "win32" || ![".cmd", ".bat"].includes(extension)) {
     return { command, arguments: arguments_2, windowsVerbatimArguments: false };
   }
@@ -53841,7 +54046,7 @@ var PiRpcSession = class {
     });
     child.stderr.resume();
     child.once("error", (error52) => {
-      const kind = isRecord16(error52) && error52.code === "ENOENT" ? "notInstalled" : "unavailable";
+      const kind = isRecord17(error52) && error52.code === "ENOENT" ? "notInstalled" : "unavailable";
       this.#fail(new PiRpcFaultError(kind, `Pi RPC failed to start: ${error52.message}`));
     });
     child.once("exit", (code, signal) => {
@@ -54093,7 +54298,7 @@ var PiRpcSession = class {
       this.#buffer = this.#buffer.subarray(newline3 + 1);
       try {
         const value = JSON.parse(textDecoder.decode(frame));
-        if (!isRecord16(value) || typeof value.type !== "string") {
+        if (!isRecord17(value) || typeof value.type !== "string") {
           throw new PiRpcFaultError("protocolError", "Pi RPC returned an invalid envelope");
         }
         this.#handle(value);
@@ -54132,7 +54337,7 @@ var PiRpcSession = class {
       }
       compactionTurn?.onEvent({
         type: "compaction.completed",
-        outcome: value.aborted === true ? "cancelled" : isRecord16(value.result) ? "succeeded" : "failed",
+        outcome: value.aborted === true ? "cancelled" : isRecord17(value.result) ? "succeeded" : "failed",
         ...nonBlankString2(value.errorMessage) ? { errorMessage: value.errorMessage } : {}
       });
       return;
@@ -54152,7 +54357,7 @@ var PiRpcSession = class {
       this.#startAssistantMessage(active, value.message);
       return;
     }
-    if (value.type === "message_update" && isRecord16(value.assistantMessageEvent)) {
+    if (value.type === "message_update" && isRecord17(value.assistantMessageEvent)) {
       const event = value.assistantMessageEvent;
       if (event.type === "text_delta" && typeof event.delta === "string") {
         const messageId = this.#ensureAssistantMessage(active, value.message);
@@ -54546,7 +54751,7 @@ var PiRpcSession = class {
 // packages/adapters/pi/dist/pi-adapter.js
 var piHarnessId2 = harnessIdSchema.parse("pi");
 var DEFAULT_TOOL_OUTPUT_LIMIT4 = 64e3;
-function isRecord17(value) {
+function isRecord18(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function errorMessage(error52) {
@@ -54620,7 +54825,7 @@ function nativeModelForHistory(state) {
   return nativeModelFromState(state);
 }
 function sessionFileFromRef(ref) {
-  if (ref.harnessId !== piHarnessId2 || !isRecord17(ref.locator) || typeof ref.locator.sessionFile !== "string" || ref.locator.sessionFile.length === 0) {
+  if (ref.harnessId !== piHarnessId2 || !isRecord18(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;
@@ -54635,9 +54840,9 @@ function toolFailure2(toolName) {
 function nativeText(value) {
   if (typeof value === "string")
     return value;
-  if (!isRecord17(value) || !Array.isArray(value.content))
+  if (!isRecord18(value) || !Array.isArray(value.content))
     return "";
-  return value.content.filter((content) => isRecord17(content) && content.type === "text" && typeof content.text === "string").map(({ text }) => text).join("");
+  return value.content.filter((content) => isRecord18(content) && content.type === "text" && typeof content.text === "string").map(({ text }) => text).join("");
 }
 function boundedOutput(value, limit) {
   const text = nativeText(value);
@@ -54653,19 +54858,19 @@ function outputText2(output) {
   return output?.content.filter((content) => content.type === "text").map(({ text }) => text).join("") ?? "";
 }
 function stringField2(value, key) {
-  return isRecord17(value) && typeof value[key] === "string" ? value[key] : void 0;
+  return isRecord18(value) && typeof value[key] === "string" ? value[key] : void 0;
 }
 function numberField(value, key) {
-  if (!isRecord17(value))
+  if (!isRecord18(value))
     return void 0;
   const field = value[key];
   return typeof field === "number" || field === null ? field : void 0;
 }
-function stripDiffPrefix(path17) {
-  return path17.startsWith("a/") || path17.startsWith("b/") ? path17.slice(2) : path17;
+function stripDiffPrefix(path18) {
+  return path18.startsWith("a/") || path18.startsWith("b/") ? path18.slice(2) : path18;
 }
 function reliableFileChange(result) {
-  if (!isRecord17(result) || !isRecord17(result.details) || typeof result.details.patch !== "string") {
+  if (!isRecord18(result) || !isRecord18(result.details) || typeof result.details.patch !== "string") {
     return null;
   }
   const patch = result.details.patch;
@@ -54681,10 +54886,10 @@ function reliableFileChange(result) {
   const oldFile = file2.oldFileName;
   const newFile = file2.newFileName;
   const kind = oldFile === "/dev/null" ? "add" : newFile === "/dev/null" ? "delete" : "update";
-  const path17 = stripDiffPrefix(kind === "delete" ? oldFile : newFile);
-  if (!path17 || path17 === "/dev/null")
+  const path18 = stripDiffPrefix(kind === "delete" ? oldFile : newFile);
+  if (!path18 || path18 === "/dev/null")
     return null;
-  return [{ path: path17, kind, unifiedDiff: patch }];
+  return [{ path: path18, kind, unifiedDiff: patch }];
 }
 function delay3(milliseconds) {
   return new Promise((resolve2) => setTimeout(resolve2, milliseconds));
@@ -55927,8 +56132,8 @@ import nodePath from "node:path";
 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 readFile2, readdir, rename, rm as rm2, stat } from "node:fs/promises";
-import path12 from "node:path";
+import { copyFile, mkdir, open as open2, readFile as readFile3, readdir, rename, rm as rm2, stat } from "node:fs/promises";
+import path13 from "node:path";
 
 // packages/mapping-store/dist/records.js
 var nonBlankTextSchema3 = external_exports.string().refine((value) => value.trim().length > 0, {
@@ -56095,6 +56300,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;
@@ -56133,11 +56350,11 @@ var MappingStore = class {
   #initialized = false;
   #lockHandle = null;
   constructor(options) {
-    this.#directory = path12.resolve(options.directory);
-    this.#threadsDirectory = path12.join(this.#directory, "threads");
-    this.#backupsDirectory = path12.join(this.#directory, "backups");
-    this.#quarantineDirectory = path12.join(this.#directory, "quarantine");
-    this.#lockPath = path12.join(this.#directory, "store.lock");
+    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.#instanceId = options.instanceId ?? randomUUID6();
     this.#now = options.now ?? (() => /* @__PURE__ */ new Date());
     this.#beforeReplace = options.beforeReplace;
@@ -56155,8 +56372,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 = path12.join(this.#threadsDirectory, name);
-        const backup = path12.join(this.#backupsDirectory, name);
+        const primary = path13.join(this.#threadsDirectory, name);
+        const backup = path13.join(this.#backupsDirectory, name);
         let record3 = null;
         try {
           record3 = await this.#readRecord(primary, name);
@@ -56165,7 +56382,7 @@ var MappingStore = class {
             record3 = await this.#readRecord(backup, name);
             await this.#replaceFile(primary, record3, false);
           } catch (backupError) {
-            const quarantine = path12.join(this.#quarantineDirectory, `${name}.${this.#now().getTime()}.invalid`);
+            const quarantine = path13.join(this.#quarantineDirectory, `${name}.${this.#now().getTime()}.invalid`);
             await rename(primary, quarantine).catch(() => void 0);
             void primaryError;
             void backupError;
@@ -56274,27 +56491,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 };
     });
   }
@@ -56339,7 +56558,7 @@ var MappingStore = class {
     if (handle)
       await handle.close().catch(() => void 0);
     try {
-      const current = JSON.parse(await readFile2(this.#lockPath, "utf8"));
+      const current = JSON.parse(await readFile3(this.#lockPath, "utf8"));
       if (current.instanceId === this.#instanceId)
         await rm2(this.#lockPath, { force: true });
     } catch {
@@ -56433,7 +56652,7 @@ var MappingStore = class {
     }
   }
   async #readRecord(file2, expectedName) {
-    const parsed = storedThreadRecordV1Schema.safeParse(JSON.parse(await readFile2(file2, "utf8")));
+    const parsed = storedThreadRecordV1Schema.safeParse(JSON.parse(await readFile3(file2, "utf8")));
     if (!parsed.success) {
       throw new MappingStoreError("INVALID_RECORD", "Mapping Store record is invalid", {
         cause: parsed.error
@@ -56446,7 +56665,7 @@ var MappingStore = class {
   }
   async #cleanupTemps() {
     const names = await readdir(this.#threadsDirectory);
-    await Promise.all(names.filter((name) => name.includes(".tmp-")).map((name) => rm2(path12.join(this.#threadsDirectory, name), { force: true })));
+    await Promise.all(names.filter((name) => name.includes(".tmp-")).map((name) => rm2(path13.join(this.#threadsDirectory, name), { force: true })));
   }
   async #acquireLock() {
     const attempt = async () => {
@@ -56472,7 +56691,7 @@ var MappingStore = class {
     }
     let existing = {};
     try {
-      existing = JSON.parse(await readFile2(this.#lockPath, "utf8"));
+      existing = JSON.parse(await readFile3(this.#lockPath, "utf8"));
     } catch {
     }
     if (typeof existing.pid === "number" && lockOwnerIsLive(existing)) {
@@ -56539,10 +56758,10 @@ var MappingStore = class {
     }
   }
   #recordPath(hostThreadId) {
-    return path12.join(this.#threadsDirectory, `${hostThreadId}.json`);
+    return path13.join(this.#threadsDirectory, `${hostThreadId}.json`);
   }
   #backupPath(hostThreadId) {
-    return path12.join(this.#backupsDirectory, `${hostThreadId}.json`);
+    return path13.join(this.#backupsDirectory, `${hostThreadId}.json`);
   }
   #requireInitialized() {
     if (!this.#initialized) {
@@ -56561,7 +56780,7 @@ var packageMetadata5 = {
 var TITLE_MAX_LENGTH = 120;
 var DESCRIPTION_MAX_LENGTH = 500;
 var SERVER_NAME_MAX_LENGTH = 80;
-function isRecord18(value) {
+function isRecord19(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function boundedText(value, field, maxLength) {
@@ -56605,7 +56824,7 @@ function responseError(message3) {
 function responsePersist(value) {
   if (value === void 0 || value === null)
     return null;
-  if (!isRecord18(value) || Object.keys(value).length !== 1 || value.persist !== "session" && value.persist !== "always") {
+  if (!isRecord19(value) || Object.keys(value).length !== 1 || value.persist !== "session" && value.persist !== "always") {
     throw responseError("contains malformed persist metadata");
   }
   return value.persist;
@@ -56648,7 +56867,7 @@ function projectCodexApprovalRequest(input) {
     },
     denyResponse,
     parseResponse(result) {
-      if (!isRecord18(result) || typeof result.action !== "string") {
+      if (!isRecord19(result) || typeof result.action !== "string") {
         throw responseError("missing action");
       }
       if (Object.keys(result).some((key) => key !== "action" && key !== "content" && key !== "_meta")) {
@@ -56656,7 +56875,7 @@ function projectCodexApprovalRequest(input) {
       }
       const selectedPersist = responsePersist(result._meta);
       if (result.action === "accept") {
-        if ("content" in result && (!isRecord18(result.content) || Object.keys(result.content).length !== 0)) {
+        if ("content" in result && (!isRecord19(result.content) || Object.keys(result.content).length !== 0)) {
           throw responseError("contains non-empty accepted content");
         }
         if (selectedPersist === "session") {
@@ -56683,7 +56902,7 @@ function projectCodexApprovalRequest(input) {
 }
 
 // packages/protocol-core/dist/codex-question.js
-function isRecord19(value) {
+function isRecord20(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function responseError2(message3) {
@@ -56752,7 +56971,7 @@ function projectCodexQuestionRequest(input) {
       }
     },
     parseResponse(result) {
-      if (!isRecord19(result) || !isRecord19(result.answers)) {
+      if (!isRecord20(result) || !isRecord20(result.answers)) {
         throw responseError2("missing answers object");
       }
       const rawAnswers = result.answers;
@@ -56765,7 +56984,7 @@ function projectCodexQuestionRequest(input) {
         const question = interaction.questions.find(({ id: id2 }) => id2 === questionId);
         if (!question)
           throw responseError2("contains an unknown Question ID");
-        if (!isRecord19(answerValue) || !Array.isArray(answerValue.answers)) {
+        if (!isRecord20(answerValue) || !Array.isArray(answerValue.answers)) {
           throw responseError2("answer entry has no answers array");
         }
         const values = answerValue.answers;
@@ -56911,8 +57130,8 @@ function projectItem(item, outcome, defaultCwd, includeCommandOutput = true) {
       return {
         id: item.itemId,
         type: "fileChange",
-        changes: item.changes.map(({ path: path17, kind, unifiedDiff }) => ({
-          path: path17,
+        changes: item.changes.map(({ path: path18, kind, unifiedDiff }) => ({
+          path: path18,
           kind,
           diff: unifiedDiff
         })),
@@ -57329,8 +57548,8 @@ var CodexTurnProjector = class {
     return messages;
   }
   #fileChangeUpdates(itemId3, changes) {
-    const projectedChanges = changes.map(({ path: path17, kind, unifiedDiff }) => ({
-      path: path17,
+    const projectedChanges = changes.map(({ path: path18, kind, unifiedDiff }) => ({
+      path: path18,
       kind,
       diff: unifiedDiff
     }));
@@ -57375,7 +57594,7 @@ var CodexTurnProjector = class {
 };
 
 // packages/protocol-core/dist/thread-fork.js
-function isRecord20(value) {
+function isRecord21(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalText(params, name, options = {}) {
@@ -57398,7 +57617,7 @@ function optionalBoolean(params, name) {
 function decodeThreadForkRequest(request) {
   if (request.method !== "thread/fork")
     return null;
-  if (!isRecord20(request.params))
+  if (!isRecord21(request.params))
     throw new Error("thread/fork params must be an object");
   const params = request.params;
   const threadId2 = optionalText(params, "threadId");
@@ -57413,13 +57632,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 path17 = optionalText(params, "path", { allowEmpty: true });
+  const path18 = optionalText(params, "path", { allowEmpty: true });
   const ephemeral = optionalBoolean(params, "ephemeral");
   return {
     threadId: threadId2,
     ...lastTurnText ? { lastTurnId: hostTurnIdSchema.parse(lastTurnText) } : {},
     ...beforeTurnText ? { beforeTurnId: hostTurnIdSchema.parse(beforeTurnText) } : {},
-    ...path17 ? { path: path17 } : {},
+    ...path18 ? { path: path18 } : {},
     ...optionalField(params, "model"),
     ...optionalField(params, "modelProvider"),
     ...optionalField(params, "cwd"),
@@ -57434,7 +57653,7 @@ function decodeThreadForkRequest(request) {
 function decodeThreadRollbackRequest(request) {
   if (request.method !== "thread/rollback")
     return null;
-  if (!isRecord20(request.params))
+  if (!isRecord21(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) {
@@ -57528,13 +57747,13 @@ var THREAD_SOURCE_KINDS = /* @__PURE__ */ new Set([
   "subAgentOther",
   "unknown"
 ]);
-function isRecord21(value) {
+function isRecord22(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function paramsObject(request, method) {
   if (request.params === void 0 && method === "thread/list")
     return {};
-  if (!isRecord21(request.params))
+  if (!isRecord22(request.params))
     throw new Error(`${method} params must be an object`);
   return request.params;
 }
@@ -57606,7 +57825,7 @@ function cursorPayload(value) {
   };
 }
 function parseCursorPayload(value) {
-  if (!isRecord21(value) || value.formatVersion !== 1)
+  if (!isRecord22(value) || value.formatVersion !== 1)
     throw new Error("Host cursor is invalid");
   const { queryFingerprint: fingerprint, sortDirection: sortDirection2, officialCursor, officialDone } = value;
   const { externalAnchor: externalAnchor2, externalDone } = value;
@@ -57615,7 +57834,7 @@ function parseCursorPayload(value) {
   }
   let anchor = null;
   if (externalAnchor2 !== null) {
-    if (!isRecord21(externalAnchor2) || !Number.isSafeInteger(externalAnchor2.timestamp) || typeof externalAnchor2.threadId !== "string" || externalAnchor2.threadId.length === 0) {
+    if (!isRecord22(externalAnchor2) || !Number.isSafeInteger(externalAnchor2.timestamp) || typeof externalAnchor2.threadId !== "string" || externalAnchor2.threadId.length === 0) {
       throw new Error("Host cursor is invalid");
     }
     anchor = {
@@ -57735,7 +57954,7 @@ function decodeThreadMetadataUpdateRequest(request) {
   if (params.gitInfo === null) {
     gitInfo = null;
   } else if (params.gitInfo !== void 0) {
-    if (!isRecord21(params.gitInfo)) {
+    if (!isRecord22(params.gitInfo)) {
       throw new Error("thread/metadata/update params.gitInfo must be an object or null");
     }
     gitInfo = {};
@@ -57763,7 +57982,7 @@ function optionalCursor(value, name) {
   return value;
 }
 function decodeOfficialThreadListPage(value) {
-  if (!isRecord21(value) || !Array.isArray(value.data) || value.data.some((row) => !isRecord21(row))) {
+  if (!isRecord22(value) || !Array.isArray(value.data) || value.data.some((row) => !isRecord22(row))) {
     throw new Error("Official thread/list response is invalid");
   }
   return {
@@ -58084,8 +58303,8 @@ var packageMetadata6 = {
 
 // packages/host-runtime/src/external-thread-repository.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
-import os5 from "node:os";
-import path13 from "node:path";
+import os6 from "node:os";
+import path14 from "node:path";
 function nativeTurnKey2(ref) {
   return `${ref.harnessId}\0${ref.nativeSessionId}\0${ref.nativeTurnKey}\0${ref.formatVersion}`;
 }
@@ -58094,8 +58313,8 @@ function sameMapping(left, right) {
 }
 function defaultMappingStoreDirectory(environment) {
   const dataDirectory = environment.CODEXHOST_DATA_DIR;
-  return path13.join(
-    dataDirectory ? path13.resolve(dataDirectory) : path13.join(os5.homedir(), ".codexhost"),
+  return path14.join(
+    dataDirectory ? path14.resolve(dataDirectory) : path14.join(os6.homedir(), ".codexhost"),
     "mapping-store"
   );
 }
@@ -58305,25 +58524,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];
@@ -59180,7 +59388,7 @@ var ExternalThreadRuntime = class {
 import { randomUUID as randomUUID8 } from "node:crypto";
 var INTERNAL_REQUEST_PREFIX = "codexhost:official:";
 var MAX_RETIRED_IDS = 1024;
-function isRecord22(value) {
+function isRecord23(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var OfficialRequestBroker = class {
@@ -59223,7 +59431,7 @@ var OfficialRequestBroker = class {
     });
   }
   handle(value) {
-    if (!isRecord22(value) || typeof value.id !== "string") return false;
+    if (!isRecord23(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);
@@ -59252,11 +59460,11 @@ var OfficialRequestBroker = class {
 };
 
 // packages/host-runtime/src/route-observation.ts
-function isRecord23(value) {
+function isRecord24(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function classifyThreadPurpose(request) {
-  return isRecord23(request.params) && request.params.ephemeral === true ? "ephemeral" : "conversation";
+  return isRecord24(request.params) && request.params.ephemeral === true ? "ephemeral" : "conversation";
 }
 var RequestRouteObservationTracker = class {
   #nextCreateOrdinal = 0;
@@ -59281,13 +59489,13 @@ var RequestRouteObservationTracker = class {
     this.#createByThreadId.set(threadId2, tracked);
   }
   bindOfficialResponse(response) {
-    if (!isRecord23(response) || !("id" in response)) return;
+    if (!isRecord24(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 = isRecord23(result) ? result.thread : null;
-    if (isRecord23(thread) && typeof thread.id === "string") {
+    const thread = isRecord24(result) ? result.thread : null;
+    if (isRecord24(thread) && typeof thread.id === "string") {
       this.#createByThreadId.set(thread.id, tracked);
     }
   }
@@ -59384,25 +59592,25 @@ function resolveExternalSessionTreeIds(records) {
   const resolve2 = (start) => {
     const cached2 = resolved.get(start.hostThreadId);
     if (cached2) return cached2;
-    const path17 = [];
+    const path18 = [];
     const visited = /* @__PURE__ */ new Set();
     let current = start;
     while (true) {
       const known = resolved.get(current.hostThreadId);
       if (known) {
-        for (const record3 of path17) resolved.set(record3.hostThreadId, known);
+        for (const record3 of path18) 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);
-      path17.push(current);
+      path18.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 path17) resolved.set(record3.hostThreadId, root);
+        for (const record3 of path18) resolved.set(record3.hostThreadId, root);
         return root;
       }
       current = source;
@@ -59453,11 +59661,11 @@ var OfficialThreadListError = class extends Error {
   }
   rpcError;
 };
-function isRecord24(value) {
+function isRecord25(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function officialThreadListPageFromResponse(response) {
-  if (isRecord24(response.error)) {
+  if (isRecord25(response.error)) {
     if (!Number.isSafeInteger(response.error.code) || typeof response.error.message !== "string") {
       throw new Error("Official thread/list error response is invalid");
     }
@@ -59617,9 +59825,19 @@ async function aggregateThreadList(input) {
 }
 
 // packages/host-runtime/src/app-server-host.ts
-function isRecord25(value) {
+function isRecord26(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;
+  const rest = { ...value };
+  delete rest.fetchedAt;
+  const parsed = accountCreditsSnapshotSchema.safeParse(rest);
+  return parsed.success ? parsed.data : null;
+}
 function errorMessage3(error52) {
   return error52 instanceof Error ? error52.message : String(error52);
 }
@@ -59636,6 +59854,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",
@@ -59713,12 +59932,12 @@ function classifyCreateRequestRoute(request, defaultAgent2) {
   };
 }
 function requestObject(request) {
-  if (!isRecord25(request.params)) throw new Error(`${request.method} params must be an object`);
+  if (!isRecord26(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) => isRecord25(item) && item.type === "text").map((item) => item.text).filter((value) => typeof value === "string").join("\n");
+  const text = params.input.filter((item) => isRecord26(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;
 }
@@ -59872,11 +60091,11 @@ var AppServerHost = class {
       }
       const request = requestResult.data;
       if (request.method === "codexhost/update/check" || request.method === "codexhost/update/start" || request.method === "codexhost/update/status") {
-        await this.#handleUpdateRequest(request);
+        this.#dispatchDesktopRequest(() => this.#handleUpdateRequest(request));
         continue;
       }
       if (request.method === "codexhost/harness/inspect") {
-        await this.#inspectHarness(request);
+        this.#dispatchDesktopRequest(() => this.#inspectHarness(request));
         continue;
       }
       if (request.method === "codexhost/thread/fork") {
@@ -59921,7 +60140,7 @@ var AppServerHost = class {
           await writeFrame(official.stdin, frame);
           continue;
         }
-        await this.#listThreads(request, listRequest);
+        this.#dispatchDesktopRequest(() => this.#listThreads(request, listRequest));
         continue;
       }
       if (request.method === "thread/archive" || request.method === "thread/unarchive") {
@@ -59992,7 +60211,7 @@ var AppServerHost = class {
         continue;
       }
       if (request.method === "thread/fork") {
-        const params = isRecord25(request.params) ? request.params : {};
+        const params = isRecord26(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(
@@ -60015,7 +60234,7 @@ var AppServerHost = class {
         }
       }
       if (request.method === "thread/rollback") {
-        const params = isRecord25(request.params) ? request.params : {};
+        const params = isRecord26(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(
@@ -60155,7 +60374,7 @@ var AppServerHost = class {
           continue;
         }
       }
-      if (request.method.startsWith("thread/") && !EXPLICIT_EXTERNAL_THREAD_METHODS.has(request.method) && isRecord25(request.params) && typeof request.params.threadId === "string") {
+      if (request.method.startsWith("thread/") && !EXPLICIT_EXTERNAL_THREAD_METHODS.has(request.method) && isRecord26(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") {
@@ -60276,7 +60495,6 @@ var AppServerHost = class {
       }
       const result = updateStartResultSchema.parse(await coordinator.start());
       await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(result) }));
-      coordinator.requestShutdown();
     } catch (error52) {
       await this.#writer.json(rpcError(request, -32091, errorMessage3(error52).slice(0, 500)));
     }
@@ -60371,9 +60589,13 @@ var AppServerHost = class {
       );
       return;
     }
+    const adapter = this.#externalAdapters.get(resolution.thread.harnessId);
+    if (adapter && isCreditsAdapter(adapter)) void adapter.refreshCredits();
+    const credits = adapter && isCreditsAdapter(adapter) ? projectAccountCredits(adapter.credits()) : null;
     const result = threadUsageInspectionSchema.parse({
       threadId: params.data.threadId,
-      usage: resolution.thread.latestUsage
+      usage: resolution.thread.latestUsage,
+      ...credits ? { accountCredits: credits } : {}
     });
     await this.#writer.json(rpcEnvelope(request, { result: jsonValueSchema.parse(result) }));
   }
@@ -60975,10 +61197,10 @@ var AppServerHost = class {
       ...typeof params.serviceTier === "string" ? { serviceTier: params.serviceTier } : {}
     });
     try {
-      if (params.initialTurnsPage !== void 0 && params.initialTurnsPage !== null && !isRecord25(params.initialTurnsPage)) {
+      if (params.initialTurnsPage !== void 0 && params.initialTurnsPage !== null && !isRecord26(params.initialTurnsPage)) {
         throw new ExternalHistoryRequestError("initialTurnsPage must be an object");
       }
-      const initialPageParams = isRecord25(params.initialTurnsPage) ? params.initialTurnsPage : null;
+      const initialPageParams = isRecord26(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;
@@ -61230,7 +61452,7 @@ var AppServerHost = class {
     }
   }
   async #handleDesktopApprovalResponse(value) {
-    if (!isRecord25(value) || !isHostApprovalRequestId(value.id)) return false;
+    if (!isRecord26(value) || !isHostApprovalRequestId(value.id)) return false;
     const pending = this.#pendingDesktopApprovals.get(value.id);
     if (!pending) return true;
     this.#pendingDesktopApprovals.delete(value.id);
@@ -61352,7 +61574,7 @@ var AppServerHost = class {
     }
   }
   async #handleDesktopQuestionResponse(value) {
-    if (!isRecord25(value) || !isHostQuestionRequestId(value.id)) return false;
+    if (!isRecord26(value) || !isHostQuestionRequestId(value.id)) return false;
     const pending = this.#pendingDesktopQuestions.get(value.id);
     if (!pending) return true;
     this.#pendingDesktopQuestions.delete(value.id);
@@ -61453,18 +61675,18 @@ var AppServerHost = class {
     }
     await this.#writer.json(projection);
   }
+  #dispatchDesktopRequest(run) {
+    void run().catch((error52) => this.#diagnose(error52));
+  }
   #diagnose(error52) {
     this.#options.diagnosticOutput.write(`codexhost Host Runtime: ${errorMessage3(error52)}
 `);
   }
 };
 
-// packages/host-runtime/src/update-coordinator.ts
-import { createConnection } from "node:net";
-
 // packages/update-manager/dist/distribution.js
-import { lstat, readFile as readFile3 } from "node:fs/promises";
-import path14 from "node:path";
+import { lstat, readFile as readFile4 } from "node:fs/promises";
+import path15 from "node:path";
 
 // packages/update-manager/dist/status.js
 var STATUS_SCHEMA_VERSION = 1;
@@ -61519,6 +61741,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",
@@ -61538,7 +61761,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 {
@@ -61550,9 +61773,9 @@ function parseDistributionMetadata(value) {
 }
 function absoluteEnvironmentPath(environment, name) {
   const value = environment[name];
-  if (!value || !path14.isAbsolute(value))
+  if (!value || !path15.isAbsolute(value))
     throw new Error(`${name} must be an absolute path`);
-  return path14.normalize(value);
+  return path15.normalize(value);
 }
 function positiveEnvironmentInteger(environment, name) {
   const value = Number(environment[name]);
@@ -61569,48 +61792,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 || !path14.isAbsolute(root))
+    if (!root || !path15.isAbsolute(root))
       throw new Error("LOCALAPPDATA is unavailable");
-    return path14.join(root, "codexhost", "updates");
+    return path15.join(root, "codexhost", "updates");
   }
   const home = environment.HOME;
-  if (!home || !path14.isAbsolute(home))
+  if (!home || !path15.isAbsolute(home))
     throw new Error("HOME is unavailable");
-  return platform === "darwin" ? path14.join(home, "Library", "Application Support", "codexhost", "updates") : path14.join(home, ".codexhost", "updates");
+  return platform === "darwin" ? path15.join(home, "Library", "Application Support", "codexhost", "updates") : path15.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 (!path14.isAbsolute(options.hostRuntimePath)) {
+  if (!path15.isAbsolute(options.hostRuntimePath)) {
     throw new Error("Host Runtime path must be absolute");
   }
-  const hostRuntimePath = path14.normalize(options.hostRuntimePath);
+  const hostRuntimePath = path15.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 = path14.dirname(hostRuntimePath);
-  const metadata = parseDistributionMetadata(JSON.parse(await readFile3(path14.join(appDirectory, "codexhost-distribution.json"), "utf8")));
+  const appDirectory = path15.dirname(hostRuntimePath);
+  const metadata = parseDistributionMetadata(JSON.parse(await readFile4(path15.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 = path14.normalize(options.stateDirectory ?? defaultUpdateStateDirectory(platform, environment));
-  const resourcesRoot = path14.dirname(appDirectory);
-  const installationRoot = platform === "darwin" ? path14.dirname(path14.dirname(resourcesRoot)) : resourcesRoot;
-  const updaterExecutable = path14.join(resourcesRoot, "libexec", platform === "win32" ? "codexhost-updater.exe" : "codexhost-updater");
+  const runtimeDescriptorPath = absoluteEnvironmentPath(environment, UPDATE_RUNTIME_ENV.runtimeDescriptorPath);
+  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 common = {
     version: metadata.version,
     launcherPid,
     launcherExecutable,
+    runtimeDescriptorPath,
     updaterExecutable,
     stateDirectory
   };
@@ -61629,7 +61856,7 @@ async function resolveInstalledUpdateContext(options) {
       npmLauncherPath: absoluteEnvironmentPath(environment, UPDATE_RUNTIME_ENV.npmLauncherPath),
       packageRoot: absoluteEnvironmentPath(environment, UPDATE_RUNTIME_ENV.npmPackageRoot)
     };
-    if (path14.normalize(npmOptions.packageRoot) !== resourcesRoot) {
+    if (path15.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 } };
@@ -61791,8 +62018,8 @@ function selectInstallerReleaseArtifact(release, target) {
 }
 
 // packages/update-manager/dist/operation-state.js
-import { lstat as lstat2, mkdir as mkdir2, open as open3, readFile as readFile4, readdir as readdir2, rm as rm3, writeFile } from "node:fs/promises";
-import path15 from "node:path";
+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";
 var LOCK_FILE = "active-update-v1.lock";
 var STATUS_FILE = "status-v1.json";
 var TERMINAL_PHASES = /* @__PURE__ */ new Set(["succeeded", "failed"]);
@@ -61807,12 +62034,12 @@ async function regularFile(filePath) {
   }
 }
 async function isUpdateOperationActive(stateDirectory) {
-  if (!path15.isAbsolute(stateDirectory))
+  if (!path16.isAbsolute(stateDirectory))
     throw new Error("update state directory must be absolute");
-  return regularFile(path15.join(stateDirectory, LOCK_FILE));
+  return regularFile(path16.join(stateDirectory, LOCK_FILE));
 }
 async function discoverLatestUpdateStatus(stateDirectory) {
-  if (!path15.isAbsolute(stateDirectory))
+  if (!path16.isAbsolute(stateDirectory))
     throw new Error("update state directory must be absolute");
   let entries;
   try {
@@ -61826,13 +62053,13 @@ async function discoverLatestUpdateStatus(stateDirectory) {
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.isSymbolicLink() || !entry.name.startsWith("update-"))
       continue;
-    const statusPath = path15.join(stateDirectory, entry.name, STATUS_FILE);
+    const statusPath = path16.join(stateDirectory, entry.name, STATUS_FILE);
     if (!await regularFile(statusPath))
       continue;
     try {
       candidates2.push({
         statusPath,
-        status: parseUpdateStatus(JSON.parse(await readFile4(statusPath, "utf8")))
+        status: parseUpdateStatus(JSON.parse(await readFile5(statusPath, "utf8")))
       });
     } catch {
     }
@@ -61854,10 +62081,10 @@ async function cleanupTerminalUpdateState(stateDirectory, options = {}) {
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.isSymbolicLink() || !entry.name.startsWith("update-"))
       continue;
-    const directory = path15.join(stateDirectory, entry.name);
-    const statusPath = path15.join(directory, STATUS_FILE);
+    const directory = path16.join(stateDirectory, entry.name);
+    const statusPath = path16.join(directory, STATUS_FILE);
     try {
-      const status = parseUpdateStatus(JSON.parse(await readFile4(statusPath, "utf8")));
+      const status = parseUpdateStatus(JSON.parse(await readFile5(statusPath, "utf8")));
       if (TERMINAL_PHASES.has(status.phase) && now - status.updatedAt > retentionSeconds) {
         await rm3(directory, { recursive: true, force: true });
       }
@@ -61866,10 +62093,10 @@ async function cleanupTerminalUpdateState(stateDirectory, options = {}) {
   }
 }
 async function acquireUpdateOperationLock(stateDirectory) {
-  if (!path15.isAbsolute(stateDirectory))
+  if (!path16.isAbsolute(stateDirectory))
     throw new Error("update state directory must be absolute");
   await mkdir2(stateDirectory, { recursive: true, mode: 448 });
-  const lockPath = path15.join(stateDirectory, LOCK_FILE);
+  const lockPath = path16.join(stateDirectory, LOCK_FILE);
   let handle;
   try {
     handle = await open3(lockPath, "wx", 384);
@@ -61888,9 +62115,9 @@ async function acquireUpdateOperationLock(stateDirectory) {
     async setStatusPath(statusPath) {
       if (released)
         throw new Error("update operation lock is released");
-      if (!path15.isAbsolute(statusPath))
+      if (!path16.isAbsolute(statusPath))
         throw new Error("update status path must be absolute");
-      await writeFile(lockPath, `${JSON.stringify({ ownerPid: process.pid, statusPath: path15.normalize(statusPath) })}
+      await writeFile(lockPath, `${JSON.stringify({ ownerPid: process.pid, statusPath: path16.normalize(statusPath) })}
 `, { encoding: "utf8", mode: 384 });
     },
     async release() {
@@ -61912,22 +62139,22 @@ function processIsAlive(processId) {
   }
 }
 async function recoverUpdateOperationLock(stateDirectory) {
-  const lockPath = path15.join(stateDirectory, LOCK_FILE);
+  const lockPath = path16.join(stateDirectory, LOCK_FILE);
   if (!await regularFile(lockPath))
     return;
   let ownerPid;
   let statusPath;
   try {
-    const value = JSON.parse(await readFile4(lockPath, "utf8"));
+    const value = JSON.parse(await readFile5(lockPath, "utf8"));
     ownerPid = value.ownerPid;
     statusPath = value.statusPath;
   } catch {
     return;
   }
-  if (typeof statusPath !== "string" || !path15.isAbsolute(statusPath))
+  if (typeof statusPath !== "string" || !path16.isAbsolute(statusPath))
     return;
   try {
-    const status = parseUpdateStatus(JSON.parse(await readFile4(statusPath, "utf8")));
+    const status = parseUpdateStatus(JSON.parse(await readFile5(statusPath, "utf8")));
     if (TERMINAL_PHASES.has(status.phase) || typeof ownerPid !== "number" || !processIsAlive(ownerPid)) {
       await rm3(lockPath, { force: true });
     }
@@ -61938,8 +62165,8 @@ async function recoverUpdateOperationLock(stateDirectory) {
 // packages/update-manager/dist/update-manager.js
 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 readFile5, rename as rename2, rm as rm4, writeFile as writeFile2 } from "node:fs/promises";
-import path16 from "node:path";
+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";
 
 // packages/update-manager/dist/artifact.js
 import { createHash as createHash2 } from "node:crypto";
@@ -62032,13 +62259,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 (!path16.isAbsolute(value))
+  if (!path17.isAbsolute(value))
     throw new Error(`${label} must be an absolute path`);
-  return path16.normalize(value);
+  return path17.normalize(value);
 }
 async function requireRegularFile(value, label) {
   const filePath = requireAbsolutePath(value, label);
@@ -62081,7 +62332,7 @@ function createBackgroundUpdateManager(dependencies = {}) {
   const now = dependencies.now ?? Date.now;
   const preparedRequests = /* @__PURE__ */ new Set();
   async function writeStatusSnapshot(statusPath, status) {
-    const temporaryPath = path16.join(path16.dirname(statusPath), `.update-status-${randomId()}.tmp`);
+    const temporaryPath = path17.join(path17.dirname(statusPath), `.update-status-${randomId()}.tmp`);
     try {
       await writeFile2(temporaryPath, `${JSON.stringify(status)}
 `, {
@@ -62089,7 +62340,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;
@@ -62137,24 +62388,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 = path16.join(stateDirectory, `update-${version2}-${randomId()}`);
+    const workDirectory = path17.join(stateDirectory, `update-${version2}-${randomId()}`);
     await mkdir3(workDirectory, { recursive: false, mode: 448 });
     const executableSuffix = platform === "win32" ? ".exe" : "";
-    const helperPath = path16.join(workDirectory, `codexhost-updater${executableSuffix}`);
+    const helperPath = path17.join(workDirectory, `codexhost-updater${executableSuffix}`);
     await copyFile2(updaterExecutable, helperPath);
     if (platform !== "win32")
       await chmod(helperPath, 448);
-    const requestPath = path16.join(workDirectory, "request-v1.json");
-    const statusPath = path16.join(workDirectory, "status-v1.json");
+    const requestPath = path17.join(workDirectory, "request-v1.json");
+    const statusPath = path17.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,
@@ -62163,8 +62416,8 @@ function createBackgroundUpdateManager(dependencies = {}) {
   }
   async function prepareArtifact(common, installation, sourceValue, fileName) {
     const source = validateArtifact(sourceValue);
-    const temporaryPath = path16.join(common.workDirectory, `.${fileName}.download`);
-    const artifactPath = path16.join(common.workDirectory, fileName);
+    const temporaryPath = path17.join(common.workDirectory, `.${fileName}.download`);
+    const artifactPath = path17.join(common.workDirectory, fileName);
     const progress = progressReporter(common.statusPath, common.version, installation, source.size);
     try {
       const result = await download(source, temporaryPath, progress.update);
@@ -62190,6 +62443,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
     };
@@ -62237,7 +62491,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 (path16.extname(appPath) !== ".app") {
+      if (path17.extname(appPath) !== ".app") {
         throw new Error("macOS application path must end in .app");
       }
       const artifact = await prepareArtifact(common, "macos-dmg", options.artifact, "update.dmg");
@@ -62260,7 +62514,7 @@ function createBackgroundUpdateManager(dependencies = {}) {
     async readStatus(statusPathValue) {
       const statusPath = requireAbsolutePath(statusPathValue, "update status path");
       try {
-        return parseUpdateStatus(JSON.parse(await readFile5(statusPath, "utf8")));
+        return parseUpdateStatus(JSON.parse(await readFile6(statusPath, "utf8")));
       } catch (error52) {
         if (error52.code === "ENOENT")
           return null;
@@ -62272,37 +62526,10 @@ function createBackgroundUpdateManager(dependencies = {}) {
 
 // packages/host-runtime/src/update-coordinator.ts
 var ERROR_MAX_LENGTH = 500;
-var CONTROLLER_TIMEOUT_MS = 5e3;
-var UPDATER_READY_TIMEOUT_MS = 1e4;
-var UPDATER_READY_POLL_MS = 20;
 function boundedError(error52) {
   const message3 = error52 instanceof Error ? error52.message : String(error52);
   return message3.slice(0, ERROR_MAX_LENGTH) || "Update operation failed";
 }
-function delay4(milliseconds) {
-  return new Promise((resolve2) => setTimeout(resolve2, milliseconds));
-}
-async function waitForUpdaterReady(manager, statusPath) {
-  const deadline = Date.now() + UPDATER_READY_TIMEOUT_MS;
-  while (Date.now() < deadline) {
-    const status = await manager.readStatus(statusPath);
-    switch (status?.phase) {
-      case "waiting-for-exit":
-      case "installing":
-      case "restarting":
-      case "succeeded":
-        return;
-      case "failed":
-        throw new Error(status.error ?? "Background Updater failed before Desktop shutdown");
-      case "prepared":
-        break;
-      default:
-        throw new Error("Background Updater reported an unexpected startup phase");
-    }
-    await delay4(UPDATER_READY_POLL_MS);
-  }
-  throw new Error("Background Updater did not become ready before Desktop shutdown");
-}
 function publicStatus(status) {
   return {
     version: status.version,
@@ -62314,34 +62541,6 @@ function publicStatus(status) {
     error: status.error?.slice(0, ERROR_MAX_LENGTH) ?? null
   };
 }
-function requestControllerShutdown(controller) {
-  return new Promise((resolve2, reject) => {
-    const socket = createConnection({ host: "127.0.0.1", port: controller.port });
-    let response = "";
-    const timeout = setTimeout(
-      () => socket.destroy(new Error("Controller shutdown timed out")),
-      CONTROLLER_TIMEOUT_MS
-    );
-    const settle = (operation) => {
-      clearTimeout(timeout);
-      operation();
-    };
-    socket.setEncoding("utf8");
-    socket.once("error", (error52) => settle(() => reject(error52)));
-    socket.on("data", (chunk) => {
-      response += chunk;
-    });
-    socket.once(
-      "end",
-      () => settle(() => {
-        if (response === "ready\n") resolve2();
-        else reject(new Error("Desktop Controller rejected the shutdown request"));
-      })
-    );
-    socket.once("connect", () => socket.write(`SHUTDOWN ${controller.nonce}
-`));
-  });
-}
 function createHostUpdateCoordinator(options) {
   const platform = options.platform ?? process.platform;
   const manager = options.manager ?? createBackgroundUpdateManager({ platform });
@@ -62352,16 +62551,7 @@ function createHostUpdateCoordinator(options) {
     ...options.architecture ? { architecture: options.architecture } : {}
   });
   const fetchLatest = options.fetchLatest ?? ((signal) => fetchLatestGitHubRelease({ signal: signal ?? AbortSignal.timeout(15e3) }));
-  const shutdown = options.shutdown ?? requestControllerShutdown;
   let candidate = null;
-  let shutdownPending = null;
-  let shutdownRequested = false;
-  const scheduleShutdown = () => {
-    if (!shutdownRequested || !shutdownPending) return;
-    const controller = shutdownPending;
-    shutdownPending = null;
-    setTimeout(() => void shutdown(controller).catch(() => void 0), 50).unref();
-  };
   async function latestStatus(context) {
     const discovered = await discoverLatestUpdateStatus(context.common.stateDirectory);
     if (!discovered) return null;
@@ -62371,9 +62561,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;
@@ -62471,10 +62663,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,
@@ -62488,9 +62681,6 @@ function createHostUpdateCoordinator(options) {
               });
             }
             if (platform !== "darwin") manager.start(prepared2);
-            await waitForUpdaterReady(manager, prepared2.statusPath);
-            shutdownPending = context.controller;
-            scheduleShutdown();
           } catch (error52) {
             await lock.release();
             rejectPrepared(error52);
@@ -62514,10 +62704,6 @@ function createHostUpdateCoordinator(options) {
       } catch {
         return { status: null };
       }
-    },
-    requestShutdown() {
-      shutdownRequested = true;
-      scheduleShutdown();
     }
   });
 }