@codexhost/cli-darwin-x64 0.12.2 → 0.13.1

package/README.md

@@ -7,7 +7,7 @@ Run Pi and Claude Code as first-class external harnesses inside Codex Desktop.
 ## Install
 
 ```bash
-npm install -g @codexhost/cli@0.12.2
+npm install -g @codexhost/cli@0.13.1
 ```
 
 Do not install this package directly. npm selects it through the optional dependencies of `@codexhost/cli`.

package/THIRD_PARTY_NOTICES.txt

@@ -1,10 +1,18 @@
 codexhost npm package third-party notices
 
+@deepseek-ai/cordis 4.0.4
+License: MIT
+License text: licenses/Cordis-LICENSE.txt
+
+@deepseek-ai/cosmokit 1.8.5
+License: MIT
+License text: licenses/Cosmokit-LICENSE.txt
+
 @agentclientprotocol/sdk 1.3.0
 License: Apache-2.0
 License text: licenses/Agent-Client-Protocol-SDK-LICENSE.txt
 
-@anthropic-ai/claude-agent-sdk 0.3.220
+@anthropic-ai/claude-agent-sdk 0.3.273
 License: SEE LICENSE IN README.md
 License text: licenses/Claude-Agent-SDK-LICENSE.md
 

package/app/codexhost-distribution.json

@@ -1 +1 @@
-{"schemaVersion":1,"version":"0.12.2","distribution":"npm","target":"macos-x64"}
+{"schemaVersion":1,"version":"0.13.1","distribution":"npm","target":"macos-x64"}

package/app/console-server.mjs

@@ -358,39 +358,25 @@ async function regularFile(filePath) {
     throw error51;
   }
 }
-async function isUpdateOperationActive(stateDirectory) {
+async function discoverActiveUpdateStatus(stateDirectory) {
   if (!path4.isAbsolute(stateDirectory))
     throw new Error("update state directory must be absolute");
-  return regularFile(path4.join(stateDirectory, LOCK_FILE));
-}
-async function discoverLatestUpdateStatus(stateDirectory) {
-  if (!path4.isAbsolute(stateDirectory))
-    throw new Error("update state directory must be absolute");
-  let entries;
+  const lockPath = path4.join(stateDirectory, LOCK_FILE);
+  if (!await regularFile(lockPath))
+    return null;
   try {
-    entries = await readdir(stateDirectory, { withFileTypes: true });
-  } catch (error51) {
-    if (error51.code === "ENOENT")
+    const lock = JSON.parse(await readFile2(lockPath, "utf8"));
+    if (typeof lock.statusPath !== "string" || !path4.isAbsolute(lock.statusPath))
       return null;
-    throw error51;
-  }
-  const candidates = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory() || entry.isSymbolicLink() || !entry.name.startsWith("update-"))
-      continue;
-    const statusPath = path4.join(stateDirectory, entry.name, STATUS_FILE);
-    if (!await regularFile(statusPath))
-      continue;
-    try {
-      candidates.push({
-        statusPath,
-        status: parseUpdateStatus(JSON.parse(await readFile2(statusPath, "utf8")))
-      });
-    } catch {
-    }
+    if (!await regularFile(lock.statusPath))
+      return null;
+    const status = parseUpdateStatus(JSON.parse(await readFile2(lock.statusPath, "utf8")));
+    if (TERMINAL_PHASES.has(status.phase))
+      return null;
+    return { statusPath: lock.statusPath, status };
+  } catch {
+    return null;
   }
-  candidates.sort((left, right) => right.status.updatedAt - left.status.updatedAt);
-  return candidates[0] ?? null;
 }
 async function cleanupTerminalUpdateState(stateDirectory, options = {}) {
   const now = Math.floor((options.now ?? Date.now()) / 1e3);
@@ -588,6 +574,48 @@ async function verifyDownloadedArtifact(source, filePath, result) {
   }
 }
 
+// packages/update-manager/dist/updater-ready.js
+import { setTimeout as delay } from "node:timers/promises";
+async function waitForUpdaterReady(child, readStatus, timeoutMs = 1e4) {
+  let failure;
+  const onError = (error51) => {
+    failure = error51;
+  };
+  const onExit = () => {
+    failure = new Error("Background Updater exited before completing handoff");
+  };
+  child.on("error", onError);
+  child.on("exit", onExit);
+  const deadline = performance.now() + timeoutMs;
+  try {
+    while (true) {
+      const status = await readStatus();
+      if (status?.phase === "failed")
+        throw new Error(status.error ?? "Background Updater failed");
+      if (failure)
+        throw failure;
+      if (child.exitCode != null || child.signalCode != null) {
+        throw new Error("Background Updater exited before completing handoff");
+      }
+      if (status?.phase === "waiting-for-exit")
+        return;
+      if (status && status.phase !== "prepared") {
+        throw new Error(`Unexpected Updater phase during handoff: ${status.phase}`);
+      }
+      if (performance.now() >= deadline) {
+        throw new Error("Background Updater did not confirm handoff before the startup timeout");
+      }
+      await delay(20);
+    }
+  } catch (error51) {
+    child.kill();
+    throw error51;
+  } finally {
+    child.removeListener("error", onError);
+    child.removeListener("exit", onExit);
+  }
+}
+
 // packages/update-manager/dist/update-manager.js
 var REQUEST_SCHEMA_VERSION = 1;
 var WINDOWS_RENAME_RETRY_DELAYS_MS = [10, 30, 70, 150, 300];
@@ -597,7 +625,7 @@ function errorMessage(error51) {
 function systemErrorCode(error51) {
   return typeof error51 === "object" && error51 !== null && "code" in error51 ? String(error51.code) : null;
 }
-function delay(milliseconds) {
+function delay2(milliseconds) {
   return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 async function replaceStatusFile(temporaryPath, statusPath) {
@@ -613,7 +641,7 @@ async function replaceStatusFile(temporaryPath, statusPath) {
         throw error51;
       }
       retryIndex += 1;
-      await delay(retryDelay);
+      await delay2(retryDelay);
     }
   }
 }
@@ -833,14 +861,20 @@ function createBackgroundUpdateManager(dependencies = {}) {
         app_path: appPath
       }, artifact.artifactPath);
     },
-    start(prepared) {
+    async start(prepared) {
       if (!preparedRequests.delete(prepared.requestPath)) {
         throw new Error("background update was not prepared by this manager or was already started");
       }
-      const child = spawnUpdater(prepared.helperPath, prepared.requestPath);
-      if (child.pid === void 0)
-        throw new Error("background Updater did not report a process ID");
-      return Object.freeze({ ...prepared, updaterPid: child.pid });
+      try {
+        const child = spawnUpdater(prepared.helperPath, prepared.requestPath);
+        await waitForUpdaterReady(child, () => this.readStatus(prepared.statusPath));
+        if (child.pid === void 0)
+          throw new Error("background Updater did not report a process ID");
+        return Object.freeze({ ...prepared, updaterPid: child.pid });
+      } catch (error51) {
+        await writeFailedStatus(prepared.statusPath, prepared.version, prepared.installation, error51);
+        throw error51;
+      }
     },
     async readStatus(statusPathValue) {
       const statusPath = requireAbsolutePath(statusPathValue, "update status path");
@@ -5498,8 +5532,8 @@ function az_default() {
 }
 
 // node_modules/zod/v4/locales/be.js
-function getBelarusianPlural(count, one, few, many) {
-  const absCount = Math.abs(count);
+function getBelarusianPlural(count2, one, few, many) {
+  const absCount = Math.abs(count2);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -7577,8 +7611,8 @@ function hu_default() {
 }
 
 // node_modules/zod/v4/locales/hy.js
-function getArmenianPlural(count, one, many) {
-  return Math.abs(count) === 1 ? one : many;
+function getArmenianPlural(count2, one, many) {
+  return Math.abs(count2) === 1 ? one : many;
 }
 function withDefiniteArticle(word) {
   if (!word)
@@ -9706,8 +9740,8 @@ function ro_default() {
 }
 
 // node_modules/zod/v4/locales/ru.js
-function getRussianPlural(count, one, few, many) {
-  const absCount = Math.abs(count);
+function getRussianPlural(count2, one, few, many) {
+  const absCount = Math.abs(count2);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -15376,6 +15410,15 @@ function date4(params) {
 // node_modules/zod/v4/classic/external.js
 config(en_default());
 
+// packages/shared-contracts/dist/delegation-read.js
+var REMOTE_THREAD_REPLY_MAX_BYTES = 16 * 1024 * 1024;
+var delegationReadParamsSchema = external_exports.strictObject({
+  threadId: external_exports.string().min(1).max(1024),
+  view: external_exports.enum(["result", "messages"]),
+  cursor: external_exports.string().min(1).max(8192).optional(),
+  limit: external_exports.number().int().min(1).max(100).optional()
+});
+
 // packages/shared-contracts/dist/credential-imports.js
 var credentialSourceSchema = external_exports.object({
   id: external_exports.string().min(1).max(256),
@@ -15446,6 +15489,160 @@ var harnessDisplaySetSchema = external_exports.strictObject({
   initializeOnly: external_exports.boolean().optional()
 });
 
+// packages/shared-contracts/dist/model-price-overrides.js
+var usdPerMillionTokens = external_exports.number().finite().nonnegative();
+var modelPriceOverrideSchema = external_exports.strictObject({
+  input: usdPerMillionTokens,
+  output: usdPerMillionTokens,
+  cacheRead: usdPerMillionTokens.optional(),
+  cacheWrite: usdPerMillionTokens.optional(),
+  cacheWrite1h: usdPerMillionTokens.optional()
+});
+var modelPriceKeySchema = external_exports.string().max(512).refine((key) => key.trim() === key && key.length > 0, "Model ID is required");
+var modelPriceOverridesSchema = external_exports.strictObject({
+  /** Absolute path of the Host's `pricing.json`. */
+  path: external_exports.string(),
+  entries: external_exports.array(external_exports.strictObject({ key: external_exports.string(), price: modelPriceOverrideSchema })),
+  /** Why the existing file is unusable; the Host then ignores it and refuses to overwrite it. */
+  error: external_exports.string().nullable()
+});
+var modelPriceOverridesGetSchema = external_exports.strictObject({});
+var modelPriceOverridesSetSchema = external_exports.strictObject({
+  key: modelPriceKeySchema,
+  price: modelPriceOverrideSchema.nullable(),
+  previousKey: modelPriceKeySchema.optional()
+});
+var modelPriceDefaultParamsSchema = external_exports.strictObject({
+  model: modelPriceKeySchema
+});
+var modelPriceSuggestionSchema = external_exports.strictObject({
+  /** Verified from catalog canonical links, not inferred from names or equal prices. */
+  official: external_exports.boolean().optional(),
+  canonicalModelId: external_exports.string().min(1).optional(),
+  provider: external_exports.string().min(1).max(512),
+  model: external_exports.string().min(1).max(512),
+  price: modelPriceOverrideSchema
+});
+var modelPriceDefaultResultSchema = external_exports.strictObject({
+  price: modelPriceOverrideSchema.nullable(),
+  /** Local catalog suggestions only; never used automatically for pricing. */
+  suggestions: external_exports.array(modelPriceSuggestionSchema).max(6).optional()
+});
+
+// packages/shared-contracts/dist/usage-statistics.js
+var USAGE_STATISTICS_RANGES = ["today", "7d", "30d", "90d", "all"];
+var count = external_exports.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
+var localDate = external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/u);
+var harness = external_exports.string().min(1).max(128);
+var model = external_exports.string().min(1).max(512);
+var project = external_exports.string().min(1).max(4096);
+var usageStatisticsParamsSchema = external_exports.strictObject({
+  range: external_exports.enum(USAGE_STATISTICS_RANGES),
+  harness: harness.optional(),
+  model: model.nullable().optional(),
+  project: project.nullable().optional(),
+  /** One local date inside the range. */
+  date: localDate.optional()
+});
+var usageStatisticsTotalsSchema = external_exports.strictObject({
+  requests: count,
+  inputTokens: count,
+  cachedInputTokens: count,
+  cacheWriteInputTokens: count,
+  cacheKnownInputTokens: count,
+  outputTokens: count,
+  reasoningOutputTokens: count,
+  /** USD at the public price, summed over the priced requests only. */
+  costUsd: external_exports.number().finite().min(0),
+  /** Requests without a price (or the cache data the price needs); not in `costUsd`. */
+  unpricedRequests: count,
+  /**
+   * Requests whose storage gave no token counts: counted as requests, with neither tokens nor
+   * cost, and not as unpriced.
+   */
+  unmeteredRequests: count
+});
+var totals = usageStatisticsTotalsSchema.shape;
+var usageStatisticsSessionSchema = external_exports.strictObject({
+  harness,
+  sessionId: external_exports.string().min(1).max(512),
+  project: project.nullable(),
+  /** Persisted Desktop title for a mapped Session, otherwise its native name; may be absent. */
+  title: external_exports.string().min(1).max(200).optional(),
+  /** Models the session used, most requests first. */
+  models: external_exports.array(model).max(16),
+  firstAtMs: count,
+  lastAtMs: count,
+  ...totals
+});
+var usageStatisticsResultSchema = external_exports.strictObject({
+  range: external_exports.enum(USAGE_STATISTICS_RANGES),
+  /** First local date of the range; null for all time. */
+  from: localDate.nullable(),
+  to: localDate,
+  /** The filters these figures apply, echoed so a late answer to older filters is recognised. */
+  filters: external_exports.strictObject({
+    harness: harness.nullable(),
+    model: model.nullable(),
+    unknownModel: external_exports.boolean(),
+    project: project.nullable(),
+    unknownProject: external_exports.boolean(),
+    date: localDate.nullable()
+  }),
+  /** Reading of native storage: incomplete while the first read, or a refresh, is under way. */
+  reading: external_exports.strictObject({ complete: external_exports.boolean(), sources: count, read: count }),
+  /** Harnesses whose storage could not be read; their part is missing, the rest is complete. */
+  failures: external_exports.array(external_exports.strictObject({ harness, message: external_exports.string().max(2048) })).max(256),
+  /** Every value seen in the range, ignoring the filters, to choose filters from. */
+  options: external_exports.strictObject({
+    harnesses: external_exports.array(harness).max(256),
+    models: external_exports.array(model.nullable()).max(4096),
+    projects: external_exports.array(project.nullable()).max(4096)
+  }),
+  /** Current display metadata, scoped by Harness. Never a pricing or filter identity.
+   * Optional for older Hosts; missing/conflicting labels fall back to the native model ID.
+   */
+  modelLabels: external_exports.array(external_exports.strictObject({ harness, model, label: model })).max(4096).optional(),
+  /** Native credits, all filters applied, never combined across Harnesses or treated as USD.
+   * Only groups with at least one reported value appear; reportedRequests exposes partial data.
+   */
+  credits: external_exports.array(external_exports.strictObject({
+    harness,
+    model: model.nullable(),
+    credits: external_exports.number().finite().min(0),
+    reportedRequests: count,
+    requests: count
+  })).max(4096).optional(),
+  /** All filters applied. */
+  totals: usageStatisticsTotalsSchema,
+  /** Each date and Harness of the range: every filter except the day. */
+  daily: external_exports.array(external_exports.strictObject({ date: localDate, harness, ...totals })).max(2e5),
+  /** Local weekday (0 = Sunday) and hour, all filters applied. */
+  hourly: external_exports.array(external_exports.strictObject({
+    weekday: external_exports.number().int().min(0).max(6),
+    hour: external_exports.number().int().min(0).max(23),
+    ...totals
+  })).max(168),
+  byHarness: external_exports.array(external_exports.strictObject({ harness, ...totals })).max(256),
+  byModel: external_exports.array(external_exports.strictObject({
+    model: model.nullable(),
+    ...totals,
+    /** Requests priced by what the Harness recorded they cost, not by a price list. */
+    harnessPricedRequests: count
+  })).max(4096),
+  byProject: external_exports.array(external_exports.strictObject({ project: project.nullable(), ...totals })).max(4096),
+  /**
+   * The sessions that spent the most, by cost and by tokens without cache, all filters applied;
+   * requests without a native session are not listed here but count everywhere else.
+   */
+  sessions: external_exports.array(usageStatisticsSessionSchema).max(100),
+  /**
+   * The sessions last active in the range, newest first, all filters applied. Optional for older
+   * Hosts; missing is treated as no list rather than no sessions.
+   */
+  recentSessions: external_exports.array(usageStatisticsSessionSchema).max(100).optional()
+});
+
 // packages/shared-contracts/dist/ids.js
 var opaqueIdSchema = external_exports.string().refine((value) => value.trim().length > 0, {
   message: "Identifier must not be empty or whitespace"
@@ -15493,6 +15690,10 @@ var CONSOLE_HOST_METHODS = Object.freeze([
   "codexhost/account/list",
   "codexhost/account/refresh",
   "codexhost/account/usage/inspect",
+  "codexhost/usage/model-prices/get",
+  "codexhost/usage/model-prices/set",
+  "codexhost/usage/model-prices/default",
+  "codexhost/usage/statistics/get",
   "codexhost/update/check",
   "codexhost/update/start",
   "codexhost/update/status"
@@ -15560,6 +15761,7 @@ var threadUsageSnapshotSchema = external_exports.object({
   cacheWriteInputTokens: nonNegativeSafeIntegerSchema.optional(),
   outputTokens: nonNegativeSafeIntegerSchema.optional(),
   outputTokensPerSecond: finiteNonNegativeNumberSchema.optional(),
+  apiOutputTokensPerSecond: finiteNonNegativeNumberSchema.optional(),
   reasoningOutputTokens: nonNegativeSafeIntegerSchema.optional(),
   totalTokens: nonNegativeSafeIntegerSchema.optional(),
   totalCostUsd: finiteNonNegativeNumberSchema.optional(),
@@ -15571,7 +15773,11 @@ var threadUsageSnapshotSchema = external_exports.object({
   planFiveHourUsedPercent: cacheHitRatePercentSchema.optional(),
   planFiveHourResetsAtUnix: nonNegativeSafeIntegerSchema.optional(),
   planSevenDayUsedPercent: cacheHitRatePercentSchema.optional(),
-  planSevenDayResetsAtUnix: nonNegativeSafeIntegerSchema.optional()
+  planSevenDayResetsAtUnix: nonNegativeSafeIntegerSchema.optional(),
+  sessionCacheHitRatePercent: cacheHitRatePercentSchema.optional(),
+  timeToFirstOutputMs: nonNegativeSafeIntegerSchema.optional(),
+  costSource: external_exports.enum(["publicPrice", "native"]).optional(),
+  unpricedModels: external_exports.array(external_exports.string().min(1)).min(1).optional()
 }).strict().superRefine((usage2, context) => {
   if (Object.keys(usage2).length === 0) {
     context.addIssue({ code: "custom", message: "Thread Usage must contain a reliable field" });
@@ -15592,6 +15798,20 @@ var threadUsageSnapshotSchema = external_exports.object({
       path: ["contextWindowTokens"]
     });
   }
+  if (usage2.costSource !== void 0 && usage2.totalCostUsd === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Thread Usage costSource must be provided with totalCostUsd",
+      path: ["costSource"]
+    });
+  }
+  if (usage2.unpricedModels !== void 0 && usage2.costSource !== "publicPrice") {
+    context.addIssue({
+      code: "custom",
+      message: "Thread Usage unpricedModels must be provided with a publicPrice cost",
+      path: ["unpricedModels"]
+    });
+  }
   if (usage2.planFiveHourResetsAtUnix !== void 0 && usage2.planFiveHourUsedPercent === void 0) {
     context.addIssue({
       code: "custom",
@@ -15846,27 +16066,27 @@ var harnessModelCatalogSchema = external_exports.object({
 }).strict().superRefine((catalog, context) => {
   const refs = /* @__PURE__ */ new Set();
   const thinkingIds = new Set(catalog.thinkingOptions.map(({ id }) => id));
-  for (const [index, model] of catalog.models.entries()) {
-    if (refs.has(model.ref.id)) {
+  for (const [index, model2] of catalog.models.entries()) {
+    if (refs.has(model2.ref.id)) {
       context.addIssue({
         code: "custom",
         message: "Model Catalog refs must be unique",
         path: ["models", index, "ref", "id"]
       });
     }
-    refs.add(model.ref.id);
-    if (model.fastModel) {
-      if (refs.has(model.fastModel.id) || catalog.models.some((entry) => entry.ref.id === model.fastModel?.id)) {
+    refs.add(model2.ref.id);
+    if (model2.fastModel) {
+      if (refs.has(model2.fastModel.id) || catalog.models.some((entry) => entry.ref.id === model2.fastModel?.id)) {
         context.addIssue({
           code: "custom",
           message: "Fast Model refs must be distinct and unique",
           path: ["models", index, "fastModel"]
         });
       }
-      refs.add(model.fastModel.id);
+      refs.add(model2.fastModel.id);
     }
     const supportedThinkingIds = /* @__PURE__ */ new Set();
-    for (const [optionIndex, optionId] of (model.supportedThinkingOptionIds ?? []).entries()) {
+    for (const [optionIndex, optionId] of (model2.supportedThinkingOptionIds ?? []).entries()) {
       if (supportedThinkingIds.has(optionId)) {
         context.addIssue({
           code: "custom",
@@ -16060,13 +16280,40 @@ var HARNESS_PLUGIN_LIMIT = 128;
 var harnessPluginIdSchema = external_exports.string().min(1).max(128).regex(/^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/u).refine((id) => id !== "codex", "The official Codex identity is reserved").pipe(harnessIdSchema);
 var relativeResourceSchema = external_exports.string().min(1).max(512).refine((value) => !/[\\\u0000:#?]/u.test(value) && !value.startsWith("/") && !value.split("/").some((part) => part === ".." || part === ""), "Plugin resources must be relative paths inside the plugin");
 var documentationUrlSchema = external_exports.url().refine((value) => /^https:\/\/[^/?#@]+(?:[/?#]|$)/iu.test(value), "Plugin documentation links must be credential-free HTTPS URLs");
+var localizedTextSchema = external_exports.object({ en: external_exports.string().max(4096), "zh-CN": external_exports.string().max(4096).optional() }).strict();
+var harnessInstallationGuideSchema = external_exports.object({
+  commands: external_exports.array(external_exports.object({ terminal: external_exports.string().max(256), command: external_exports.string().max(4096) }).strict()).max(8),
+  before: localizedTextSchema.optional(),
+  after: localizedTextSchema.optional(),
+  downloads: external_exports.array(external_exports.object({ label: external_exports.string().max(128), url: documentationUrlSchema }).strict()).max(8).optional()
+}).strict();
 var pluginPresentationShape = {
   id: harnessPluginIdSchema,
   name: external_exports.string().trim().min(1).max(128),
   version: external_exports.string().min(1).max(128),
+  /** Capability-only plugin; omitted for existing session-capable plugins. */
+  kind: external_exports.literal("usage").optional(),
+  /** Original image styling or bounded vector paths; never arbitrary CSS/SVG markup. */
+  iconStyle: external_exports.object({
+    vector: external_exports.object({
+      viewBox: external_exports.string().max(128).regex(/^-?\d+(?:\.\d+)?(?: +-?\d+(?:\.\d+)?){3}$/u),
+      color: external_exports.string().regex(/^(?:currentColor|#[a-f0-9]{6})$/iu),
+      paths: external_exports.array(external_exports.object({
+        d: external_exports.string().min(1).max(32768).regex(/^[MmLlHhVvCcSsQqTtAaZz\d.,+eE\s-]+$/u),
+        fillRule: external_exports.enum(["evenodd", "nonzero"]).optional(),
+        fill: external_exports.string().regex(/^(?:currentColor|#[a-f0-9]{6})$/iu).optional()
+      }).strict()).min(1).max(32)
+    }).strict().optional(),
+    background: external_exports.string().regex(/^#[a-f0-9]{6}$/iu).optional(),
+    borderRadius: external_exports.number().min(0).max(50).optional(),
+    paddingRatio: external_exports.number().min(0).max(0.25).optional()
+  }).strict().optional(),
+  installation: harnessInstallationGuideSchema.optional(),
+  notice: localizedTextSchema.optional(),
   /** The factory accepts a persisted local entrypoint through its construction context. */
   launchCommand: external_exports.literal(true).optional(),
   links: external_exports.object({
+    website: documentationUrlSchema.optional(),
     documentation: documentationUrlSchema.optional(),
     installation: documentationUrlSchema.optional()
   }).strict().optional()
@@ -16480,6 +16727,11 @@ var codexSshDraftSchema = external_exports.strictObject({
 });
 var remoteConnectionsRequestSchema = external_exports.discriminatedUnion("action", [
   external_exports.strictObject({ action: external_exports.literal("list") }),
+  external_exports.strictObject({
+    action: external_exports.literal("read-thread"),
+    hostId: hostId.refine((id) => id !== "local"),
+    input: delegationReadParamsSchema
+  }),
   external_exports.strictObject({
     action: external_exports.literal("save"),
     draft: codexSshDraftSchema,
@@ -16772,14 +17024,14 @@ function createConsoleHarnesses(roots, environment = process.env) {
   return {
     list,
     async setLaunchPath(id, value) {
-      const harness = (await list()).find((candidate) => candidate.id === id);
-      if (!harness) throw new ConsoleHarnessError(404, `Harness '${id}' is not installed`);
-      if (!harness.launchCommand) {
+      const harness2 = (await list()).find((candidate) => candidate.id === id);
+      if (!harness2) throw new ConsoleHarnessError(404, `Harness '${id}' is not installed`);
+      if (!harness2.launchCommand) {
         throw new ConsoleHarnessError(400, `Harness '${id}' does not accept an installation path`);
       }
       try {
         const settings = await store.set(id, value);
-        return { ...harness, launchPath: settings.path };
+        return { ...harness2, launchPath: settings.path };
       } catch (error51) {
         throw new ConsoleHarnessError(400, error51 instanceof Error ? error51.message : String(error51));
       }
@@ -17358,14 +17610,15 @@ function createConsoleUpdates(options) {
   });
   let candidate = null;
   let handedOff = false;
+  let currentStatusPath = null;
   async function latestStatus() {
-    const directory = stateDirectory();
-    const discovered = await discoverLatestUpdateStatus(directory);
-    if (!discovered) return null;
-    if (discovered.status.phase !== "succeeded" && discovered.status.phase !== "failed" && !await isUpdateOperationActive(directory)) {
-      return null;
+    if (!currentStatusPath) {
+      const active = await discoverActiveUpdateStatus(stateDirectory());
+      if (!active) return null;
+      currentStatusPath = active.statusPath;
     }
-    return publicStatus(discovered.status);
+    const status = await manager.readStatus(currentStatusPath);
+    return status ? publicStatus(status) : null;
   }
   function installable(metadata, release) {
     const kind = installationKind(metadata);
@@ -17492,6 +17745,7 @@ function createConsoleUpdates(options) {
         if (existing) return { status: existing };
         throw new ConsoleUpdateError("busy", "Another update operation is already active");
       }
+      currentStatusPath = null;
       try {
         const release = await fetchLatest();
         if (compareSemanticVersions(metadata.version, release.version) >= 0 || candidate && candidate.version !== release.version) {
@@ -17510,9 +17764,10 @@ function createConsoleUpdates(options) {
           try {
             const prepared = await prepare(metadata, target, release, async (info) => {
               await lock.setStatusPath(info.statusPath);
+              currentStatusPath = info.statusPath;
               resolvePrepared(info.statusPath);
             });
-            manager.start(prepared);
+            await manager.start(prepared);
             handedOff = true;
             options.onHandedOff();
           } catch (error51) {
@@ -17840,8 +18095,8 @@ function startConsoleServer(options) {
         return;
       }
       try {
-        const harness = await options.harnesses.setLaunchPath(id, value === "" ? null : value);
-        sendJson(response, 200, { harness });
+        const harness2 = await options.harnesses.setLaunchPath(id, value === "" ? null : value);
+        sendJson(response, 200, { harness: harness2 });
       } catch (error51) {
         sendJson(response, error51 instanceof ConsoleHarnessError ? error51.status : 500, {
           error: error51 instanceof Error ? error51.message : String(error51)
@@ -17948,7 +18203,7 @@ async function consoleBuildId(entryPath2, environment = process.env) {
   }
   const runtime = await readRuntimeMetadata(entryPath2, environment).catch(() => null);
   if (runtime?.distribution === "development") parts.push(runtime.version);
-  return parts.join(".");
+  return JSON.stringify([parts.join("."), dataDirectory(environment)]);
 }
 function startDetachedServer(entryPath2, environment) {
   const child = spawn3(process.execPath, [entryPath2, "serve"], {
@@ -18019,7 +18274,7 @@ async function runUpdateCommand(target, updates, write = console.log) {
   const { status } = await updates.start(target);
   if (status.phase === "failed") throw new Error(status.error ?? "Update failed");
   write(
-    `Update ${status.version}: ${status.phase}. The background updater will finish installation and restart codexhost.`
+    `Update ${status.version}: ${status.phase}. The background updater has accepted the handoff; installation is not complete yet. It will install the update and restart codexhost.`
   );
 }
 async function updateFromCommand(appDirectory2, arguments_) {