@codexhost/cli-linux-arm64 0.12.2 → 0.13.1

package/app/plugins/zcode/plugin.mjs

@@ -5,9 +5,66 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// dist/adapter.js
-import path3 from "node:path";
-import { stat as stat2 } from "node:fs/promises";
+// dist/usage-statistics.js
+import os from "node:os";
+import path from "node:path";
+import { lstat } from "node:fs/promises";
+
+// ../../harness-adapter/dist/usage-statistics.js
+var MAX_SESSION_ID_LENGTH = 512;
+var MAX_CWD_LENGTH = 4096;
+var MAX_SESSION_TITLE_LENGTH = 200;
+function usageSessionTitle(value) {
+  if (typeof value !== "string")
+    return void 0;
+  const normalized = value.replaceAll("\0", "").replaceAll(/\s+/gu, " ").trim();
+  if (!normalized)
+    return void 0;
+  if (normalized.length <= MAX_SESSION_TITLE_LENGTH)
+    return normalized;
+  const characters = [...normalized];
+  if (characters.length <= MAX_SESSION_TITLE_LENGTH)
+    return normalized;
+  return `${characters.slice(0, MAX_SESSION_TITLE_LENGTH - 1).join("").trimEnd()}…`;
+}
+function sessionIdOk(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= MAX_SESSION_ID_LENGTH;
+}
+function cwdOk(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= MAX_CWD_LENGTH && !value.includes("\0") && (value.startsWith("/") || /^[A-Za-z]:[\\/]/u.test(value) || value.startsWith("\\\\"));
+}
+function withUsageSession(entry, session) {
+  const sessionId = sessionIdOk(session.sessionId) ? session.sessionId : void 0;
+  const cwd = cwdOk(session.cwd) ? session.cwd : void 0;
+  const sessionTitle = sessionId !== void 0 ? usageSessionTitle(session.title) : void 0;
+  if (sessionId === void 0 && cwd === void 0)
+    return entry;
+  return {
+    ...entry,
+    ...sessionId !== void 0 ? { sessionId } : {},
+    ...cwd !== void 0 ? { cwd } : {},
+    ...sessionTitle !== void 0 ? { sessionTitle } : {}
+  };
+}
+function usageEntryFromRequest(request, occurredAtMs) {
+  if (!Number.isSafeInteger(occurredAtMs) || occurredAtMs <= 0)
+    return null;
+  return {
+    id: request.requestId,
+    occurredAtMs,
+    ...request.model !== void 0 ? { model: request.model } : {},
+    inputTokens: request.inputTokens,
+    ...request.cachedInputTokens !== void 0 ? { cachedInputTokens: request.cachedInputTokens } : {},
+    ...request.cacheWriteInputTokens !== void 0 ? { cacheWriteInputTokens: request.cacheWriteInputTokens } : {},
+    ...request.cacheWrite1hInputTokens !== void 0 ? { cacheWrite1hInputTokens: request.cacheWrite1hInputTokens } : {},
+    outputTokens: request.outputTokens,
+    ...request.reasoningOutputTokens !== void 0 ? { reasoningOutputTokens: request.reasoningOutputTokens } : {}
+  };
+}
+function nativeTimeMs(value) {
+  const time3 = typeof value === "number" ? value : typeof value === "string" ? Date.parse(value) : Number.NaN;
+  return Number.isFinite(time3) && time3 > 0 ? Math.floor(time3) : null;
+}
 
 // ../../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -775,10 +832,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path4) {
-  if (!path4)
+function getElementAtPath(obj, path7) {
+  if (!path7)
     return obj;
-  return path4.reduce((acc, key) => acc?.[key], obj);
+  return path7.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1187,11 +1244,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path4, issues) {
+function prefixIssues(path7, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path4);
+    iss.path.unshift(path7);
     return iss;
   });
 }
@@ -1338,16 +1395,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path4 = []) => {
+  const processError = (error52, path7 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path4, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else {
-        const fullpath = [...path4, ...issue2.path];
+        const fullpath = [...path7, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1374,17 +1431,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path4 = []) => {
+  const processError = (error52, path7 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path4, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else {
-        const fullpath = [...path4, ...issue2.path];
+        const fullpath = [...path7, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1416,8 +1473,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path4 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path4) {
+  const path7 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path7) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -4645,8 +4702,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) {
@@ -6724,8 +6781,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)
@@ -8853,8 +8910,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) {
@@ -14109,13 +14166,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path4 = ref.slice(1).split("/").filter(Boolean);
-  if (path4.length === 0) {
+  const path7 = ref.slice(1).split("/").filter(Boolean);
+  if (path7.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path4[0] === defsKey) {
-    const key = path4[1];
+  if (path7[0] === defsKey) {
+    const key = path7[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14317,8 +14374,8 @@ function convertBaseSchema(schema, ctx) {
           break;
         }
         const objectSchema2 = z.object(shape).passthrough();
-        const recordSchema2 = z.looseRecord(keySchema, valueSchema);
-        zodSchema = z.intersection(objectSchema2, recordSchema2);
+        const recordSchema3 = z.looseRecord(keySchema, valueSchema);
+        zodSchema = z.intersection(objectSchema2, recordSchema3);
         break;
       }
       if (schema.patternProperties) {
@@ -14523,6 +14580,143 @@ function date4(params) {
 // ../../../node_modules/zod/v4/classic/external.js
 config(en_default());
 
+// dist/protocol.js
+var recordSchema = external_exports.record(external_exports.string(), external_exports.unknown());
+var nativeModelSchema = external_exports.object({
+  providerId: external_exports.string().min(1),
+  modelId: external_exports.string().min(1),
+  variant: external_exports.string().optional(),
+  options: external_exports.object({ reasoningLevel: external_exports.string().min(1).optional() }).optional()
+});
+var levelSchema = external_exports.object({ value: external_exports.string(), label: external_exports.string() });
+var modelSchema = external_exports.object({
+  ref: nativeModelSchema,
+  label: external_exports.string(),
+  providerLabel: external_exports.string().optional(),
+  disabledReason: external_exports.string().optional(),
+  contextWindow: external_exports.number().int().positive().optional(),
+  reasoning: external_exports.object({
+    enabled: external_exports.boolean().optional(),
+    levels: external_exports.array(levelSchema),
+    defaultLevel: external_exports.string().optional()
+  }).transform((reasoning) => ({
+    ...reasoning,
+    enabled: reasoning.enabled ?? reasoning.levels.length > 0
+  })).optional()
+}).transform(({ providerLabel, ...model2 }) => {
+  const provider = model2.ref.providerId === "account:bigmodel-individual-coding-plan" ? "BigModel" : model2.ref.providerId === "account:zai-individual-coding-plan" ? "Z.AI" : providerLabel;
+  return { ...model2, label: provider ? `${provider} / ${model2.label}` : model2.label };
+});
+var settingsSchema = external_exports.object({
+  model: external_exports.object({
+    current: nativeModelSchema.optional(),
+    available: external_exports.array(modelSchema),
+    lastUsed: nativeModelSchema.optional()
+  }),
+  thoughtLevel: external_exports.object({
+    enabled: external_exports.boolean(),
+    current: external_exports.string().optional(),
+    defaultLevel: external_exports.string().optional(),
+    available: external_exports.array(levelSchema)
+  }),
+  mode: external_exports.object({ current: external_exports.enum(["build", "edit", "plan", "yolo", "auto"]) })
+});
+var workspaceSchema = external_exports.object({
+  workspacePath: external_exports.string().min(1),
+  workspaceKey: external_exports.string().min(1),
+  workspaceIdentity: external_exports.string().optional()
+});
+var summarySchema = external_exports.object({
+  sessionId: external_exports.string().min(1),
+  workspace: workspaceSchema,
+  title: external_exports.string(),
+  status: external_exports.string(),
+  mode: external_exports.string(),
+  createdAt: external_exports.number(),
+  updatedAt: external_exports.number(),
+  parentSessionId: external_exports.string().optional(),
+  sessionKind: external_exports.string()
+});
+var partSchema = external_exports.object({
+  partId: external_exports.string().min(1),
+  messageId: external_exports.string(),
+  sessionId: external_exports.string(),
+  type: external_exports.string()
+}).catchall(external_exports.unknown());
+var messageSchema = external_exports.object({
+  info: external_exports.object({
+    messageId: external_exports.string().min(1),
+    sessionId: external_exports.string(),
+    role: external_exports.enum(["user", "assistant"]),
+    parentMessageId: external_exports.string().optional(),
+    time: external_exports.object({ created: external_exports.number(), completed: external_exports.number().optional() }),
+    model: nativeModelSchema.optional(),
+    // Keep telemetry unvalidated here: bad usage must not break history or the Turn.
+    tokens: external_exports.unknown().optional(),
+    finish: external_exports.string().optional(),
+    error: recordSchema.optional(),
+    synthetic: external_exports.boolean().optional(),
+    visibility: external_exports.string().optional(),
+    semantics: recordSchema.optional()
+  }),
+  parts: external_exports.array(partSchema)
+});
+var snapshotSchema = external_exports.object({
+  protocol: external_exports.object({ name: external_exports.literal("ZCode Protocol"), version: external_exports.literal(1) }),
+  session: summarySchema,
+  settings: settingsSchema,
+  projection: external_exports.object({
+    status: external_exports.string(),
+    contextUsed: external_exports.number(),
+    contextWindow: external_exports.number(),
+    currentTurnId: external_exports.string().optional(),
+    backgroundJobs: external_exports.array(external_exports.unknown()).optional(),
+    target: recordSchema.nullable().optional()
+  }),
+  messages: external_exports.array(messageSchema),
+  runtime: recordSchema,
+  target: recordSchema.nullable().optional(),
+  slashCommands: external_exports.array(external_exports.object({ name: external_exports.string(), description: external_exports.string(), source: external_exports.string().optional() })).optional()
+});
+var workspaceStateSchema = external_exports.object({
+  workspace: workspaceSchema,
+  settings: settingsSchema
+});
+var eventSchema = external_exports.object({
+  eventId: external_exports.string(),
+  sessionId: external_exports.string(),
+  turnId: external_exports.string().optional(),
+  seq: external_exports.number(),
+  timestamp: external_exports.number(),
+  type: external_exports.string(),
+  payload: recordSchema.optional()
+});
+var runtimeUsageSchema = external_exports.object({
+  contextUsage: external_exports.object({
+    used: external_exports.number().int().nonnegative(),
+    cache: external_exports.object({
+      totalCacheReadTokens: external_exports.number().int().nonnegative(),
+      totalCacheWriteTokens: external_exports.number().int().nonnegative(),
+      latestHitRate: external_exports.number().min(0).max(1).nullish()
+    }).nullish()
+  })
+});
+function record2(value) {
+  return recordSchema.safeParse(value).data ?? {};
+}
+function text(value) {
+  return typeof value === "string" ? value : "";
+}
+
+// ../../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()
+});
+
 // ../../shared-contracts/dist/credential-imports.js
 var credentialSourceSchema = external_exports.object({
   id: external_exports.string().min(1).max(256),
@@ -14593,6 +14787,160 @@ var harnessDisplaySetSchema = external_exports.strictObject({
   initializeOnly: external_exports.boolean().optional()
 });
 
+// ../../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()
+});
+
+// ../../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()
+});
+
 // ../../shared-contracts/dist/ids.js
 var opaqueIdSchema = external_exports.string().refine((value) => value.trim().length > 0, {
   message: "Identifier must not be empty or whitespace"
@@ -14640,6 +14988,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"
@@ -14704,6 +15056,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(),
@@ -14715,7 +15068,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((usage, context) => {
   if (Object.keys(usage).length === 0) {
     context.addIssue({ code: "custom", message: "Thread Usage must contain a reliable field" });
@@ -14736,6 +15093,20 @@ var threadUsageSnapshotSchema = external_exports.object({
       path: ["contextWindowTokens"]
     });
   }
+  if (usage.costSource !== void 0 && usage.totalCostUsd === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Thread Usage costSource must be provided with totalCostUsd",
+      path: ["costSource"]
+    });
+  }
+  if (usage.unpricedModels !== void 0 && usage.costSource !== "publicPrice") {
+    context.addIssue({
+      code: "custom",
+      message: "Thread Usage unpricedModels must be provided with a publicPrice cost",
+      path: ["unpricedModels"]
+    });
+  }
   if (usage.planFiveHourResetsAtUnix !== void 0 && usage.planFiveHourUsedPercent === void 0) {
     context.addIssue({
       code: "custom",
@@ -14990,27 +15361,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",
@@ -15204,13 +15575,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()
@@ -15629,6 +16027,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,
@@ -15652,10 +16055,6 @@ var remoteConnectionsReplySchema = external_exports.union([
 // ../../shared-contracts/dist/index.js
 var workspaceContractVersionSchema = external_exports.literal(WORKSPACE_CONTRACT_VERSION);
 
-// dist/transport.js
-import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-
 // ../../harness-adapter/dist/approval.js
 function invalidRequest(message) {
   return { code: "invalidRequest", message, retryable: false };
@@ -15771,10 +16170,12 @@ var tokenFields = [
 ];
 var safeIntegerFields = [
   "planFiveHourResetsAtUnix",
-  "planSevenDayResetsAtUnix"
+  "planSevenDayResetsAtUnix",
+  "timeToFirstOutputMs"
 ];
 var percentFields = [
   "cacheHitRatePercent",
+  "sessionCacheHitRatePercent",
   "planFiveHourUsedPercent",
   "planSevenDayUsedPercent"
 ];
@@ -15782,10 +16183,14 @@ var usageFields = /* @__PURE__ */ new Set([
   ...tokenFields,
   ...safeIntegerFields,
   ...percentFields,
+  "sessionCacheUsage",
   "totalCostUsd",
   "totalCredits",
   "contextUsagePercent",
-  "outputTokensPerSecond"
+  "outputTokensPerSecond",
+  "apiOutputTokensPerSecond",
+  "costSource",
+  "unpricedModels"
 ]);
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -15801,7 +16206,11 @@ function parseHostUsage(value) {
       throw new Error(`Harness Usage contains unknown field '${key}'`);
     }
   }
-  for (const field2 of ["totalCredits", "contextUsagePercent"]) {
+  for (const field2 of [
+    "totalCredits",
+    "contextUsagePercent",
+    "apiOutputTokensPerSecond"
+  ]) {
     const candidate = value[field2];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0)) {
       throw new Error(`Harness Usage '${field2}' must be a finite non-negative number`);
@@ -15831,6 +16240,12 @@ function parseHostUsage(value) {
       throw new Error(`Harness Usage '${field2}' must be between 0 and 100`);
     }
   }
+  if (value.sessionCacheUsage !== void 0) {
+    const totals2 = value.sessionCacheUsage;
+    if (!isRecord(totals2) || Object.keys(totals2).some((key) => key !== "inputTokens" && key !== "cachedInputTokens") || typeof totals2.inputTokens !== "number" || !Number.isSafeInteger(totals2.inputTokens) || totals2.inputTokens < 0 || typeof totals2.cachedInputTokens !== "number" || !Number.isSafeInteger(totals2.cachedInputTokens) || totals2.cachedInputTokens < 0 || totals2.cachedInputTokens > totals2.inputTokens) {
+      throw new Error("Harness Usage 'sessionCacheUsage' must contain complete bounded token totals");
+    }
+  }
   const hasContextUsed = value.contextUsedTokens !== void 0;
   const hasContextWindow = value.contextWindowTokens !== void 0;
   if (hasContextUsed !== hasContextWindow) {
@@ -15845,8 +16260,333 @@ function parseHostUsage(value) {
   if (value.planSevenDayResetsAtUnix !== void 0 && value.planSevenDayUsedPercent === void 0) {
     throw new Error("Harness Usage 'planSevenDayResetsAtUnix' must be provided with 'planSevenDayUsedPercent'");
   }
+  if (value.costSource !== void 0) {
+    if (value.costSource !== "publicPrice" && value.costSource !== "native") {
+      throw new Error("Harness Usage 'costSource' must be 'publicPrice' or 'native'");
+    }
+    if (value.totalCostUsd === void 0) {
+      throw new Error("Harness Usage 'costSource' must be provided with 'totalCostUsd'");
+    }
+  }
+  if (value.unpricedModels !== void 0) {
+    const models = value.unpricedModels;
+    if (!Array.isArray(models) || models.length === 0 || !models.every((model2) => typeof model2 === "string" && model2.length > 0)) {
+      throw new Error("Harness Usage 'unpricedModels' must be a non-empty list of Model IDs");
+    }
+    if (value.costSource !== "publicPrice") {
+      throw new Error("Harness Usage 'unpricedModels' must be provided with a 'publicPrice' cost");
+    }
+    return { ...value, unpricedModels: [...models] };
+  }
   return { ...value };
 }
+var requestTokenFields = [
+  "inputTokens",
+  "cachedInputTokens",
+  "cacheWriteInputTokens",
+  "cacheWrite1hInputTokens",
+  "outputTokens",
+  "reasoningOutputTokens",
+  "startedAtMs",
+  "completedAtMs"
+];
+var requestFields = /* @__PURE__ */ new Set([
+  ...requestTokenFields,
+  "requestId",
+  "historical",
+  "model",
+  "provider"
+]);
+function parseHostUsageRequest(value) {
+  if (!isRecord(value))
+    throw new Error("Harness Usage request must be an object");
+  for (const key of Object.keys(value)) {
+    if (!requestFields.has(key)) {
+      throw new Error(`Harness Usage request contains unknown field '${key}'`);
+    }
+  }
+  if (typeof value.requestId !== "string" || value.requestId.length === 0) {
+    throw new Error("Harness Usage request 'requestId' must be a non-empty string");
+  }
+  for (const field2 of ["model", "provider"]) {
+    const candidate = value[field2];
+    if (candidate !== void 0 && (typeof candidate !== "string" || candidate.length === 0)) {
+      throw new Error(`Harness Usage request '${field2}' must be a non-empty string`);
+    }
+  }
+  if (value.historical !== void 0 && typeof value.historical !== "boolean") {
+    throw new Error("Harness Usage request 'historical' must be a boolean");
+  }
+  for (const field2 of requestTokenFields) {
+    const candidate = value[field2];
+    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
+      throw new Error(`Harness Usage request '${field2}' must be a non-negative safe integer`);
+    }
+  }
+  if (value.inputTokens === void 0 || value.outputTokens === void 0) {
+    throw new Error("Harness Usage request must contain 'inputTokens' and 'outputTokens'");
+  }
+  const request = value;
+  if ((request.cachedInputTokens ?? 0) + (request.cacheWriteInputTokens ?? 0) > request.inputTokens) {
+    throw new Error("Harness Usage request cache Tokens must not exceed 'inputTokens'");
+  }
+  if ((request.reasoningOutputTokens ?? 0) > request.outputTokens) {
+    throw new Error("Harness Usage request 'reasoningOutputTokens' must not exceed 'outputTokens'");
+  }
+  if (request.cacheWrite1hInputTokens !== void 0 && request.cacheWrite1hInputTokens > (request.cacheWriteInputTokens ?? -1)) {
+    throw new Error("Harness Usage request 'cacheWrite1hInputTokens' must not exceed 'cacheWriteInputTokens'");
+  }
+  if (request.startedAtMs === void 0 !== (request.completedAtMs === void 0)) {
+    throw new Error("Harness Usage request timing fields must be provided together");
+  }
+  if (request.startedAtMs !== void 0 && request.completedAtMs !== void 0 && request.completedAtMs < request.startedAtMs) {
+    throw new Error("Harness Usage request 'completedAtMs' must not precede 'startedAtMs'");
+  }
+  return { ...request };
+}
+
+// dist/usage.js
+function requestTokens(id, model2, value) {
+  const tokens = record2(value), cache = record2(tokens.cache);
+  const request = parseHostUsageRequest({
+    requestId: id,
+    ...model2 ? { model: model2 } : {},
+    inputTokens: tokens.input,
+    outputTokens: tokens.output,
+    ...cache.read !== void 0 ? { cachedInputTokens: cache.read } : {},
+    ...cache.write !== void 0 ? { cacheWriteInputTokens: cache.write } : {},
+    ...tokens.reasoning !== void 0 ? { reasoningOutputTokens: tokens.reasoning } : {}
+  });
+  if (!Number.isSafeInteger(tokens.total) || tokens.total !== request.inputTokens + request.outputTokens)
+    throw new Error("ZCode request token convention is unknown");
+  return request;
+}
+function zcodeUsageRecord(message) {
+  const info = message.info;
+  if (info.role !== "assistant" || info.synthetic === true || info.semantics?.origin === "system")
+    return { kind: "none" };
+  if (info.time.completed === void 0)
+    return { kind: "missing" };
+  const tokens = record2(info.tokens), cache = record2(tokens.cache);
+  if ((info.error || info.finish === "start_plan_admission_retry_discarded") && tokens.total === void 0 && tokens.input === 0 && tokens.output === 0 && tokens.reasoning === 0 && cache.read === 0 && cache.write === 0)
+    return { kind: "none" };
+  try {
+    return {
+      kind: "request",
+      request: requestTokens(info.messageId, info.model?.modelId, info.tokens)
+    };
+  } catch {
+    return { kind: "missing" };
+  }
+}
+var ZcodeUsage = class {
+  sessionId;
+  emit;
+  #seen = /* @__PURE__ */ new Map();
+  #pending;
+  #timings = /* @__PURE__ */ new Map();
+  #complete = true;
+  constructor(sessionId, emit) {
+    this.sessionId = sessionId;
+    this.emit = emit;
+  }
+  invalidate() {
+    if (!this.#complete)
+      return;
+    this.#complete = false;
+    this.emit({ type: "usage.history", complete: false });
+  }
+  replay(messages, historical) {
+    for (const message of messages) {
+      if (message.info.sessionId !== this.sessionId)
+        continue;
+      const result = zcodeUsageRecord(message);
+      if (result.kind === "missing")
+        this.invalidate();
+      else if (result.kind === "request") {
+        this.#publish({
+          ...result.request,
+          ...historical ? { historical: true } : this.#timings.get(result.request.requestId)
+        });
+      }
+    }
+    if (historical)
+      this.emit({ type: "usage.history", complete: this.#complete });
+    this.#pending = void 0;
+    this.#timings.clear();
+  }
+  #publish(request) {
+    if ((request.reasoningOutputTokens ?? 0) > 0) {
+      request = { ...request };
+      delete request.startedAtMs;
+      delete request.completedAtMs;
+    }
+    const previous = this.#seen.get(request.requestId);
+    if (previous) {
+      if (previous.model !== request.model || previous.inputTokens !== request.inputTokens || previous.outputTokens !== request.outputTokens || previous.cachedInputTokens !== request.cachedInputTokens || previous.cacheWriteInputTokens !== request.cacheWriteInputTokens || (previous.reasoningOutputTokens ?? 0) !== (request.reasoningOutputTokens ?? 0))
+        this.invalidate();
+      return;
+    }
+    this.#seen.set(request.requestId, request);
+    this.emit({ type: "usage.request", request });
+  }
+  observe(event) {
+    if (event.sessionId !== this.sessionId)
+      return;
+    const p = event.payload ?? {};
+    if (event.type === "turn.started") {
+      this.#pending = void 0;
+      this.#timings.clear();
+      return;
+    }
+    if (event.type === "model.streaming") {
+      const pending2 = this.#pending;
+      if (!pending2 || pending2.turnId !== event.turnId || p.source === "subagent")
+        return;
+      const id = text(p.assistantMessageId);
+      if (!id)
+        return;
+      if (pending2.messageId && pending2.messageId !== id)
+        pending2.ambiguous = true;
+      pending2.messageId = id;
+      if (pending2.startedAtMs === void 0 && ((p.kind === "text_delta" || p.kind === "reasoning_delta") && text(p.delta) || p.kind === "tool_input_start" || p.kind === "tool_input_delta" && text(p.delta) || p.kind === "tool_call"))
+        pending2.startedAtMs = event.timestamp;
+      return;
+    }
+    if (event.type !== "session.updated" || p.querySource !== "main_turn")
+      return;
+    if (p.type === "model_request_started") {
+      const id = text(p.requestId), model2 = text(p.modelId);
+      if (!id || !model2)
+        return;
+      this.#pending = {
+        id,
+        model: model2,
+        turnId: event.turnId,
+        ambiguous: this.#pending !== void 0
+      };
+      return;
+    }
+    if (p.type !== "model_request_completed")
+      return;
+    const pending = this.#pending;
+    if (!pending || pending.id !== p.requestId || pending.turnId !== event.turnId)
+      return;
+    this.#pending = void 0;
+    if (pending.ambiguous || !pending.messageId || pending.model !== p.modelId)
+      return;
+    const start = pending.startedAtMs;
+    if (start !== void 0 && Number.isSafeInteger(start) && Number.isSafeInteger(event.timestamp) && event.timestamp >= start)
+      this.#timings.set(pending.messageId, {
+        startedAtMs: start,
+        completedAtMs: event.timestamp
+      });
+    const usage = record2(p.usage);
+    if (usage.cacheReadTokens === void 0 || usage.cacheWriteTokens === void 0)
+      return;
+    try {
+      const request = requestTokens(pending.messageId, pending.model, {
+        input: usage.inputTokens,
+        output: usage.outputTokens,
+        total: usage.totalTokens,
+        reasoning: usage.reasoningTokens,
+        cache: { read: usage.cacheReadTokens, write: usage.cacheWriteTokens }
+      });
+      this.#publish({ ...request, ...this.#timings.get(pending.messageId) });
+    } catch {
+      this.invalidate();
+    }
+  }
+};
+
+// dist/usage-statistics.js
+function zcodeDatabasePath(environment) {
+  return path.join(environment.ZCODE_DATA_BASE_DIR?.trim() || environment.HOME || os.homedir(), ".zcode", "cli", "db", "db.sqlite");
+}
+async function readZcodeUsage(file2) {
+  const { DatabaseSync } = await import("node:sqlite");
+  const database = new DatabaseSync(file2, { readOnly: true });
+  try {
+    const entries = [];
+    const directories = /* @__PURE__ */ new Map();
+    const titles = /* @__PURE__ */ new Map();
+    const hasSessions = database.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'session'").get();
+    if (hasSessions) {
+      const columns = new Set(database.prepare("PRAGMA table_info(session)").all().map((row) => String(row.name)));
+      const titleColumn = columns.has("title") ? ", title" : "";
+      for (const row of database.prepare(`SELECT id, directory${titleColumn} FROM session`).iterate()) {
+        if (typeof row.directory === "string")
+          directories.set(String(row.id), row.directory);
+        const title = usageSessionTitle(row.title);
+        if (title)
+          titles.set(String(row.id), title);
+      }
+    }
+    for (const row of database.prepare("SELECT id, session_id, data FROM message").iterate()) {
+      let data;
+      try {
+        data = record2(JSON.parse(String(row.data)));
+      } catch {
+        continue;
+      }
+      if (data.role !== "assistant")
+        continue;
+      const modelId = text(data.modelId) || text(data.modelID);
+      const providerId = text(data.providerId) || text(data.providerID);
+      const parsed = messageSchema.safeParse({
+        info: {
+          ...data,
+          messageId: String(row.id),
+          sessionId: String(row.session_id),
+          ...modelId && providerId ? { model: { providerId, modelId } } : {}
+        },
+        parts: []
+      });
+      if (!parsed.success)
+        continue;
+      const usage = zcodeUsageRecord(parsed.data);
+      const at = nativeTimeMs(parsed.data.info.time.created);
+      const entry = usage.kind === "request" && at !== null && usageEntryFromRequest(usage.request, at);
+      if (entry) {
+        const sessionId = String(row.session_id);
+        entries.push(withUsageSession(entry, {
+          sessionId,
+          cwd: directories.get(sessionId),
+          title: titles.get(sessionId)
+        }));
+      }
+    }
+    return entries;
+  } finally {
+    database.close();
+  }
+}
+function createZcodeUsageStatistics(environment) {
+  return Object.freeze({
+    async listSources() {
+      const file2 = zcodeDatabasePath(environment);
+      const info = await lstat(file2).catch(() => null);
+      if (!info?.isFile())
+        return [];
+      const wal = await lstat(`${file2}-wal`).catch(() => null);
+      return [
+        {
+          id: file2,
+          fingerprint: `${info.ino}:${info.size}:${info.mtimeMs}:${wal ? `${wal.size}:${wal.mtimeMs}` : "-"}`
+        }
+      ];
+    },
+    readSource: (id) => readZcodeUsage(id)
+  });
+}
+
+// dist/adapter.js
+import path6 from "node:path";
+import { stat as stat2 } from "node:fs/promises";
+
+// dist/transport.js
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 
 // dist/errors.js
 var ZcodeError = class extends Error {
@@ -15873,136 +16613,10 @@ function nativeError(error51) {
   return { code: "nativeFailure", message: "ZCode operation failed", retryable: false };
 }
 
-// dist/protocol.js
-var recordSchema = external_exports.record(external_exports.string(), external_exports.unknown());
-var nativeModelSchema = external_exports.object({
-  providerId: external_exports.string().min(1),
-  modelId: external_exports.string().min(1),
-  variant: external_exports.string().optional(),
-  options: external_exports.object({ reasoningLevel: external_exports.string().min(1).optional() }).optional()
-});
-var levelSchema = external_exports.object({ value: external_exports.string(), label: external_exports.string() });
-var modelSchema = external_exports.object({
-  ref: nativeModelSchema,
-  label: external_exports.string(),
-  providerLabel: external_exports.string().optional(),
-  disabledReason: external_exports.string().optional(),
-  contextWindow: external_exports.number().int().positive().optional(),
-  reasoning: external_exports.object({
-    enabled: external_exports.boolean().optional(),
-    levels: external_exports.array(levelSchema),
-    defaultLevel: external_exports.string().optional()
-  }).transform((reasoning) => ({
-    ...reasoning,
-    enabled: reasoning.enabled ?? reasoning.levels.length > 0
-  })).optional()
-}).transform(({ providerLabel, ...model }) => ({
-  ...model,
-  label: providerLabel ? `${providerLabel} / ${model.label}` : model.label
-}));
-var settingsSchema = external_exports.object({
-  model: external_exports.object({
-    current: nativeModelSchema.optional(),
-    available: external_exports.array(modelSchema),
-    lastUsed: nativeModelSchema.optional()
-  }),
-  thoughtLevel: external_exports.object({
-    enabled: external_exports.boolean(),
-    current: external_exports.string().optional(),
-    defaultLevel: external_exports.string().optional(),
-    available: external_exports.array(levelSchema)
-  }),
-  mode: external_exports.object({ current: external_exports.enum(["build", "edit", "plan", "yolo", "auto"]) })
-});
-var workspaceSchema = external_exports.object({
-  workspacePath: external_exports.string().min(1),
-  workspaceKey: external_exports.string().min(1),
-  workspaceIdentity: external_exports.string().optional()
-});
-var summarySchema = external_exports.object({
-  sessionId: external_exports.string().min(1),
-  workspace: workspaceSchema,
-  title: external_exports.string(),
-  status: external_exports.string(),
-  mode: external_exports.string(),
-  createdAt: external_exports.number(),
-  updatedAt: external_exports.number(),
-  parentSessionId: external_exports.string().optional(),
-  sessionKind: external_exports.string()
-});
-var partSchema = external_exports.object({
-  partId: external_exports.string().min(1),
-  messageId: external_exports.string(),
-  sessionId: external_exports.string(),
-  type: external_exports.string()
-}).catchall(external_exports.unknown());
-var messageSchema = external_exports.object({
-  info: external_exports.object({
-    messageId: external_exports.string().min(1),
-    sessionId: external_exports.string(),
-    role: external_exports.enum(["user", "assistant"]),
-    parentMessageId: external_exports.string().optional(),
-    time: external_exports.object({ created: external_exports.number(), completed: external_exports.number().optional() }),
-    model: nativeModelSchema.optional(),
-    finish: external_exports.string().optional(),
-    error: recordSchema.optional(),
-    synthetic: external_exports.boolean().optional(),
-    visibility: external_exports.string().optional(),
-    semantics: recordSchema.optional()
-  }),
-  parts: external_exports.array(partSchema)
-});
-var snapshotSchema = external_exports.object({
-  protocol: external_exports.object({ name: external_exports.literal("ZCode Protocol"), version: external_exports.literal(1) }),
-  session: summarySchema,
-  settings: settingsSchema,
-  projection: external_exports.object({
-    status: external_exports.string(),
-    contextUsed: external_exports.number(),
-    contextWindow: external_exports.number(),
-    currentTurnId: external_exports.string().optional(),
-    backgroundJobs: external_exports.array(external_exports.unknown()).optional(),
-    target: recordSchema.nullable().optional()
-  }),
-  messages: external_exports.array(messageSchema),
-  runtime: recordSchema,
-  target: recordSchema.nullable().optional(),
-  slashCommands: external_exports.array(external_exports.object({ name: external_exports.string(), description: external_exports.string(), source: external_exports.string().optional() })).optional()
-});
-var workspaceStateSchema = external_exports.object({
-  workspace: workspaceSchema,
-  settings: settingsSchema
-});
-var eventSchema = external_exports.object({
-  eventId: external_exports.string(),
-  sessionId: external_exports.string(),
-  turnId: external_exports.string().optional(),
-  seq: external_exports.number(),
-  timestamp: external_exports.number(),
-  type: external_exports.string(),
-  payload: recordSchema.optional()
-});
-var runtimeUsageSchema = external_exports.object({
-  contextUsage: external_exports.object({
-    used: external_exports.number().int().nonnegative(),
-    cache: external_exports.object({
-      totalCacheReadTokens: external_exports.number().int().nonnegative(),
-      totalCacheWriteTokens: external_exports.number().int().nonnegative(),
-      latestHitRate: external_exports.number().min(0).max(1).nullish()
-    }).nullish()
-  })
-});
-function record2(value) {
-  return recordSchema.safeParse(value).data ?? {};
-}
-function text(value) {
-  return typeof value === "string" ? value : "";
-}
-
 // dist/installation.js
 import { open, stat } from "node:fs/promises";
 import { homedir } from "node:os";
-import path from "node:path";
+import path2 from "node:path";
 var DEFAULT_DARWIN_APP = "/Applications/ZCode.app";
 var DEFAULT_LINUX_APP = "/opt/ZCode";
 async function isFile(file2) {
@@ -16047,11 +16661,11 @@ async function resolveDefaultApp(environment, platform2) {
   if (platform2 === "linux")
     return DEFAULT_LINUX_APP;
   const candidates = [
-    environment.LOCALAPPDATA && path.join(environment.LOCALAPPDATA, "Programs", "ZCode"),
-    environment.ProgramFiles && path.join(environment.ProgramFiles, "ZCode")
+    environment.LOCALAPPDATA && path2.join(environment.LOCALAPPDATA, "Programs", "ZCode"),
+    environment.ProgramFiles && path2.join(environment.ProgramFiles, "ZCode")
   ].filter(Boolean);
   for (const candidate of candidates) {
-    if (await isFile(path.join(candidate, "resources", "app.asar")))
+    if (await isFile(path2.join(candidate, "resources", "app.asar")))
       return candidate;
   }
   return candidates[0] ?? "";
@@ -16063,30 +16677,30 @@ async function resolveInstallation(environment, app, platform2 = process.platfor
   const explicitApp = app?.trim() || environment.CODEXHOST_ZCODE_APP?.trim();
   const targetApp = explicitApp || await resolveDefaultApp(environment, platform2);
   const missing = () => new ZcodeError("notInstalled", `ZCode Desktop was not found at ${targetApp}; install it or set its application path`);
-  const resources = platform2 === "darwin" ? path.join(targetApp, "Contents", "Resources") : path.join(targetApp, "resources");
-  const pkg = await readPackageJsonFromAsar(path.join(resources, "app.asar"));
+  const resources = platform2 === "darwin" ? path2.join(targetApp, "Contents", "Resources") : path2.join(targetApp, "resources");
+  const pkg = await readPackageJsonFromAsar(path2.join(resources, "app.asar"));
   if (!pkg?.productName || !pkg.version)
     throw missing();
   let runtime;
   if (platform2 === "darwin") {
-    runtime = path.join(targetApp, "Contents", "Frameworks", `${pkg.productName} Helper.app`, "Contents", "MacOS", `${pkg.productName} Helper`);
+    runtime = path2.join(targetApp, "Contents", "Frameworks", `${pkg.productName} Helper.app`, "Contents", "MacOS", `${pkg.productName} Helper`);
   } else if (platform2 === "win32") {
-    runtime = path.join(targetApp, `${pkg.productName}.exe`);
+    runtime = path2.join(targetApp, `${pkg.productName}.exe`);
   } else {
     const linuxExecutableName = pkg.productName.toLowerCase().replace(/\s+/g, "-");
-    runtime = path.join(targetApp, linuxExecutableName);
+    runtime = path2.join(targetApp, linuxExecutableName);
   }
-  const cli = path.join(resources, "glm", "zcode.cjs");
-  const builtinProviderConfig = environment.ZCODE_BUILTIN_PROVIDER_CONFIG_FILE || path.join(resources, "config", "provider", "zcode-builtin.json");
+  const cli = path2.join(resources, "glm", "zcode.cjs");
+  const builtinProviderConfig = environment.ZCODE_BUILTIN_PROVIDER_CONFIG_FILE || path2.join(resources, "config", "provider", "zcode-builtin.json");
   if (!await isFile(runtime) || !await isFile(cli) || !await isFile(builtinProviderConfig))
     throw missing();
-  const dataRoot = path.join(environment.ZCODE_DATA_BASE_DIR?.trim() || environment.HOME || homedir(), ".zcode", "v2");
+  const dataRoot = path2.join(environment.ZCODE_DATA_BASE_DIR?.trim() || environment.HOME || homedir(), ".zcode", "v2");
   return {
     runtime,
     version: pkg.version,
     cli,
     builtinProviderConfig,
-    personalProviderConfig: environment.ZCODE_PERSONAL_PROVIDER_CONFIG_FILE || path.join(dataRoot, "provider_config.json"),
+    personalProviderConfig: environment.ZCODE_PERSONAL_PROVIDER_CONFIG_FILE || path2.join(dataRoot, "provider_config.json"),
     dataRoot
   };
 }
@@ -16108,25 +16722,15 @@ function createZcodeInstallation(environment, app) {
 }
 
 // dist/account.js
+import { createHash as createHash3 } from "node:crypto";
+import { readFile as readFile3 } from "node:fs/promises";
+import path5 from "node:path";
+
+// dist/credentials.js
 import { createDecipheriv, createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { homedir as homedir2, platform, userInfo } from "node:os";
-import path2 from "node:path";
-var SIGN_IN = "Sign in to ZCode Desktop with a Start Plan account, then try again";
-var builtinSchema = external_exports.object({
-  revision: external_exports.union([external_exports.number(), external_exports.string()]),
-  config: external_exports.object({
-    providerConfigRules: external_exports.object({
-      providerRules: external_exports.array(external_exports.object({
-        providerId: external_exports.string().min(1),
-        config: external_exports.object({
-          builtinModelIds: external_exports.array(external_exports.string()).optional(),
-          access: external_exports.object({ mode: external_exports.string(), accountType: external_exports.string() }).partial().optional()
-        })
-      }))
-    })
-  })
-});
+import path3 from "node:path";
 function decrypt(value, environment) {
   if (!value.startsWith("enc:v1:"))
     return value;
@@ -16147,25 +16751,231 @@ function decrypt(value, environment) {
     throw new ZcodeError("authenticationRequired", "Cannot decrypt ZCode credentials; ZCODE_CREDENTIAL_SECRET must match ZCode Desktop");
   }
 }
-async function readCredential(installation, environment, key) {
+async function readCredentials(installation, environment) {
   let store;
   try {
-    store = JSON.parse(await readFile(path2.join(installation.dataRoot, "credentials.json"), "utf8"));
+    store = JSON.parse(await readFile(path3.join(installation.dataRoot, "credentials.json"), "utf8"));
   } catch (error51) {
     if (error51.code === "ENOENT")
-      return "";
+      return () => "";
     throw new ZcodeError("authenticationRequired", "Cannot read ZCode credentials");
   }
-  const value = external_exports.record(external_exports.string(), external_exports.string()).safeParse(store).data?.[key];
-  return value ? decrypt(value, environment) : "";
+  const values = external_exports.record(external_exports.string(), external_exports.string()).safeParse(store).data;
+  return (key) => {
+    const value = values?.[key];
+    return value ? decrypt(value, environment) : "";
+  };
+}
+async function readCredential(installation, environment, key) {
+  return (await readCredentials(installation, environment))(key);
+}
+
+// dist/personal-coding-plan.js
+import { createHash as createHash2 } from "node:crypto";
+import { readFile as readFile2 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import path4 from "node:path";
+var familySchema = external_exports.enum(["zai", "bigmodel"]);
+var recordSchema2 = external_exports.record(external_exports.string(), external_exports.unknown());
+var CONNECT = "Connect Personal Coding Plan in ZCode Desktop, then re-detect ZCode and reopen the Thread";
+function personalCodingPlanOrigin(family, environment) {
+  const test = environment.ZCODE_ENV?.trim().toLowerCase() === "test";
+  const prefix = family === "zai" ? "ZAI" : "BIGMODEL";
+  const suffix = family === "zai" ? "BUSINESS_BASE_URL" : "API_BASE_URL";
+  const origin = environment[`${prefix}_${suffix}`]?.trim() || environment[`${prefix}_${test ? "TEST" : "PRODUCTION"}_${suffix}`]?.trim() || (family === "zai" ? test ? "https://api.chatglm.site" : "https://api.z.ai" : test ? "https://dev.bigmodel.cn" : "https://bigmodel.cn");
+  const url2 = new URL(origin);
+  if (!["http:", "https:"].includes(url2.protocol) || url2.username || url2.password)
+    throw new Error("Invalid ZCode business origin");
+  return url2.origin;
+}
+async function readSelection(environment, family) {
+  const home = environment.ZCODE_DESKTOP_HOME_DIR?.trim() || environment.HOME?.trim() || environment.USERPROFILE?.trim() || homedir3();
+  let raw;
+  try {
+    raw = JSON.parse(await readFile2(path4.join(home, ".zcode", "v2", "setting.json"), "utf8"));
+  } catch (error51) {
+    if (error51.code === "ENOENT")
+      return false;
+    throw new ZcodeError("configurationRequired", CONNECT);
+  }
+  const settings = recordSchema2.parse(raw);
+  if (settings.providerFamilyDomain !== family)
+    return false;
+  if (Object.hasOwn(settings, "providerFamilyConnectionSelections")) {
+    const selections = recordSchema2.parse(settings.providerFamilyConnectionSelections);
+    return external_exports.object({ kind: external_exports.literal("individual-coding-plan") }).safeParse(selections[family]).success;
+  }
+  const modes = recordSchema2.safeParse(settings.modelProviderFamilyModes).data;
+  const keys = recordSchema2.safeParse(settings.modelProviderFamilySelectedKeys).data;
+  return modes?.[family] !== "apiKey" && keys?.[family] === `coding-plan:builtin:${family}-coding-plan`;
+}
+var envelopeSchema = external_exports.object({
+  success: external_exports.boolean().optional(),
+  code: external_exports.number().optional(),
+  data: external_exports.array(external_exports.unknown())
+});
+var subscriptionSchema = external_exports.object({
+  productId: external_exports.string().optional(),
+  productName: external_exports.string().optional(),
+  status: external_exports.string(),
+  inCurrentPeriod: external_exports.boolean()
+});
+function codingProduct(value) {
+  const entry = recordSchema2.safeParse(value).data;
+  return [entry?.productId, entry?.productName].some((field2) => typeof field2 === "string" && field2.toLowerCase().includes("coding"));
+}
+async function queryEntitlement(family, apiKey, environment) {
+  try {
+    const response = await fetch(`${personalCodingPlanOrigin(family, environment)}/api/biz/subscription/list`, {
+      method: "GET",
+      // The subscription endpoint accepts the model API Key, not the OAuth token or Start JWT.
+      headers: { Authorization: apiKey.trim() },
+      redirect: "error",
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (response.status === 401 || response.status === 403)
+      return "credential-failed";
+    if (!response.ok)
+      return "unknown";
+    const parsed = envelopeSchema.safeParse(await response.json());
+    if (!parsed.success)
+      return "unknown";
+    const payload = parsed.data;
+    if (payload.success === false || payload.code !== void 0 && ![0, 200].includes(payload.code))
+      return "unknown";
+    let malformed = false;
+    for (const item of payload.data) {
+      if (!codingProduct(item))
+        continue;
+      const subscription = subscriptionSchema.safeParse(item);
+      if (!subscription.success)
+        malformed = true;
+      else if (subscription.data.status === "VALID" && subscription.data.inCurrentPeriod)
+        return "available";
+    }
+    return malformed ? "unknown" : "unavailable";
+  } catch {
+    return "unknown";
+  }
 }
+var PersonalCodingPlanAccount = class {
+  installation;
+  environment;
+  #authorized = /* @__PURE__ */ new Map();
+  constructor(installation, environment) {
+    this.installation = installation;
+    this.environment = environment;
+  }
+  async #context(providerId, family) {
+    const [credential, current] = await Promise.all([
+      readCredentials(this.installation, this.environment),
+      readSelection(this.environment, family)
+    ]);
+    if (credential("oauth:active_provider") !== family)
+      return void 0;
+    const raw = credential(`oauth:${family}:user_info`);
+    if (!raw)
+      return void 0;
+    const profile = recordSchema2.parse(JSON.parse(raw));
+    const normalized = external_exports.object({ id: external_exports.string(), username: external_exports.string(), displayName: external_exports.string() }).safeParse(profile).data;
+    const identity = normalized ? normalized.id.trim() : family === "zai" && typeof profile.user_id === "string" ? profile.user_id.trim() : "";
+    if (!identity || identity === "unknown")
+      return void 0;
+    const key = `account-provider:coding-plan:${providerId}:account:${encodeURIComponent(identity)}:api-key`;
+    return { identity, current, apiKey: credential(key).trim() };
+  }
+  async inspect(providerId, accountType) {
+    const family = familySchema.parse(accountType);
+    this.#authorized.delete(providerId);
+    let current = false;
+    try {
+      const context = await this.#context(providerId, family);
+      if (!context)
+        return {
+          availability: "unavailable",
+          entitled: false,
+          current,
+          unavailableReason: "not-connected"
+        };
+      current = context.current;
+      const connectionKey = createHash2("sha256").update(JSON.stringify([family, context.identity, "individual-coding-plan"])).digest("hex");
+      const base = { current, connectionKey };
+      if (!context.apiKey)
+        return {
+          ...base,
+          availability: "unavailable",
+          entitled: false,
+          unavailableReason: "credential-failed"
+        };
+      const entitlement = await queryEntitlement(family, context.apiKey, this.environment);
+      const after = await this.#context(providerId, family);
+      if (!after || after.identity !== context.identity || after.current !== current || after.apiKey !== context.apiKey)
+        return { availability: "unknown", entitled: false, current: false };
+      if (entitlement === "available") {
+        if (current)
+          this.#authorized.set(providerId, { family, identity: context.identity });
+        return { ...base, availability: "available", entitled: true };
+      }
+      return {
+        ...base,
+        availability: entitlement === "unknown" ? "unknown" : "unavailable",
+        entitled: false,
+        ...entitlement === "unknown" ? {} : {
+          unavailableReason: entitlement === "unavailable" ? "not-entitled" : "credential-failed"
+        }
+      };
+    } catch {
+      return { availability: "unknown", entitled: false, current };
+    }
+  }
+  async requestAuth(request, signal) {
+    const parsed = external_exports.object({
+      providerId: external_exports.string(),
+      modelSelection: external_exports.object({ providerId: external_exports.string() }),
+      accountAccess: external_exports.object({
+        type: external_exports.literal("zhipu-account"),
+        mode: external_exports.literal("individual-coding-plan"),
+        accountType: familySchema
+      })
+    }).safeParse(request);
+    if (!parsed.success)
+      throw new ZcodeError("authenticationRequired", CONNECT);
+    const { providerId, modelSelection, accountAccess } = parsed.data;
+    const authorized = this.#authorized.get(providerId);
+    if (!authorized || authorized.family !== accountAccess.accountType || modelSelection.providerId !== providerId)
+      throw new ZcodeError("authenticationRequired", CONNECT);
+    signal.throwIfAborted();
+    const context = await this.#context(providerId, authorized.family);
+    signal.throwIfAborted();
+    if (!context?.current || context.identity !== authorized.identity || !context.apiKey)
+      throw new ZcodeError("authenticationRequired", CONNECT);
+    return { apiKey: context.apiKey };
+  }
+};
+
+// dist/account.js
+var SIGN_IN = "Sign in to ZCode Desktop with a Start Plan account, then try again";
+var builtinSchema = external_exports.object({
+  revision: external_exports.union([external_exports.number(), external_exports.string()]),
+  config: external_exports.object({
+    providerConfigRules: external_exports.object({
+      providerRules: external_exports.array(external_exports.object({
+        providerId: external_exports.string().min(1),
+        config: external_exports.object({
+          builtinModelIds: external_exports.array(external_exports.string()).optional(),
+          access: external_exports.object({ mode: external_exports.string(), accountType: external_exports.string() }).partial().optional()
+        })
+      }))
+    })
+  })
+});
 function resolveEndpointOrigin(environment) {
   return environment.ZCODE_BASE_URL?.trim() || "https://zcode.z.ai";
 }
 async function readDeviceMid(installation) {
   try {
-    const file2 = path2.join(installation.dataRoot, "telemetry-state.json");
-    const parsed = JSON.parse(await readFile(file2, "utf8"));
+    const file2 = path5.join(installation.dataRoot, "telemetry-state.json");
+    const parsed = JSON.parse(await readFile3(file2, "utf8"));
     return typeof parsed?.deviceMid === "string" ? parsed.deviceMid.trim() : "";
   } catch {
     return "";
@@ -16263,24 +17073,38 @@ async function queryStartPlanBalance(origin, appVersion, jwt2, deviceMid) {
 }
 async function accountConfig(installation, environment) {
   const file2 = installation.builtinProviderConfig;
-  const builtin = builtinSchema.parse(JSON.parse(await readFile(file2, "utf8")));
-  const basedOnZCodeBuiltinRevision = `zcode-builtin:${builtin.revision}:${createHash("sha256").update(path2.resolve(file2)).digest("hex")}`;
+  const builtin = builtinSchema.parse(JSON.parse(await readFile3(file2, "utf8")));
+  const basedOnZCodeBuiltinRevision = `zcode-builtin:${builtin.revision}:${createHash3("sha256").update(path5.resolve(file2)).digest("hex")}`;
   const family = await readCredential(installation, environment, "oauth:active_provider");
   let balanceData;
   if (family) {
-    const jwt2 = await readCredential(installation, environment, "zcodejwttoken");
-    const deviceMid = await readDeviceMid(installation);
-    if (jwt2 && deviceMid) {
-      const origin = resolveEndpointOrigin(environment);
-      balanceData = await queryStartPlanBalance(origin, installation.version, jwt2, deviceMid);
+    try {
+      const jwt2 = await readCredential(installation, environment, "zcodejwttoken");
+      const deviceMid = await readDeviceMid(installation);
+      if (jwt2 && deviceMid) {
+        const origin = resolveEndpointOrigin(environment);
+        balanceData = await queryStartPlanBalance(origin, installation.version, jwt2, deviceMid);
+      }
+    } catch {
     }
   }
   let startPlan = false;
+  const codingPlan = new PersonalCodingPlanAccount(installation, environment);
   const providers = {};
   const states = {};
   for (const rule of builtin.config.providerConfigRules.providerRules) {
     const access = rule.config.access;
-    if (!family || access?.mode !== "start-plan" || access.accountType !== family)
+    if (!family || access?.accountType !== family)
+      continue;
+    if (access.mode === "individual-coding-plan" && (family === "zai" || family === "bigmodel")) {
+      const state = await codingPlan.inspect(rule.providerId, family);
+      providers[rule.providerId] = {
+        access: { type: "zhipu-account", entitled: state.entitled }
+      };
+      states[rule.providerId] = state;
+      continue;
+    }
+    if (access.mode !== "start-plan")
       continue;
     const allowedModels = resolveStartPlanModels(balanceData, rule.config.builtinModelIds);
     if (allowedModels.length > 0) {
@@ -16302,7 +17126,7 @@ async function accountConfig(installation, environment) {
       };
     }
   }
-  const overlayDigest = createHash("sha256").update(JSON.stringify([providers, states])).digest("hex").slice(0, 16);
+  const overlayDigest = createHash3("sha256").update(JSON.stringify([providers, states])).digest("hex").slice(0, 16);
   return {
     params: {
       revision: `codexhost:${family || "signed-out"}:${builtin.revision}:${overlayDigest}`,
@@ -16310,16 +17134,20 @@ async function accountConfig(installation, environment) {
       providers,
       states
     },
-    startPlan
+    startPlan,
+    codingPlan
   };
 }
-async function providerRuntimeHeaders(accountAccess, signal, installation, environment, verifier) {
-  if (external_exports.object({ mode: external_exports.literal("start-plan") }).safeParse(accountAccess).success !== true)
-    return {
-      headersApplied: false,
-      errorMessage: "codexhost supports only the ZCode Start Plan account"
-    };
+async function providerRuntimeHeaders(request, signal, installation, environment, verifier, codingPlan) {
+  const mode = external_exports.object({ mode: external_exports.string() }).safeParse(request.accountAccess).data?.mode;
   try {
+    if (mode === "individual-coding-plan")
+      return { headersApplied: true, requestAuth: await codingPlan.requestAuth(request, signal) };
+    if (mode !== "start-plan")
+      return {
+        headersApplied: false,
+        errorMessage: "codexhost supports ZCode Start Plan and Personal Coding Plan; Team Coding Plan is not supported"
+      };
     const apiKey = await readCredential(installation, environment, "zcodejwttoken");
     if (!apiKey)
       return { headersApplied: false, errorMessage: SIGN_IN };
@@ -16328,7 +17156,7 @@ async function providerRuntimeHeaders(accountAccess, signal, installation, envir
   } catch (error51) {
     return {
       headersApplied: false,
-      errorMessage: error51 instanceof ZcodeError ? error51.message : "ZCode Start Plan verification failed"
+      errorMessage: error51 instanceof ZcodeError ? error51.message : "ZCode account authentication failed"
     };
   }
 }
@@ -16412,6 +17240,7 @@ var CliTransport = class {
   // Aborting these cancels only this transport's running and queued shared verifications.
   #headerRequests = /* @__PURE__ */ new Map();
   #startPlan = false;
+  #codingPlan;
   #fault;
   #closed = false;
   #closePromise;
@@ -16434,9 +17263,10 @@ var CliTransport = class {
     if (this.#child || this.#closed)
       throw new ZcodeError("invalidState", "ZCode transport already started or closed");
     const installation = await resolveInstallation(this.options.environment, this.options.app);
-    const { params: accountParams, startPlan } = await accountConfig(installation, this.options.environment);
+    const { params: accountParams, startPlan, codingPlan } = await accountConfig(installation, this.options.environment);
     this.#installation = installation;
     this.#startPlan = startPlan;
+    this.#codingPlan = codingPlan;
     const child = spawn(installation.runtime, [installation.cli, "app-server", "--stdio", "--surface", "desktop"], {
       cwd: this.options.cwd,
       env: {
@@ -16561,7 +17391,7 @@ var CliTransport = class {
       this.#headerRequests.set(requestId, controller);
       try {
         reply({
-          result: await providerRuntimeHeaders(params.accountAccess, controller.signal, this.#installation, this.options.environment, () => this.options.verifier(this.#installation.version))
+          result: await providerRuntimeHeaders(params, controller.signal, this.#installation, this.options.environment, () => this.options.verifier(this.#installation.version), this.#codingPlan)
         });
       } finally {
         this.#headerRequests.delete(requestId);
@@ -17292,32 +18122,32 @@ import { randomUUID as randomUUID2 } from "node:crypto";
 
 // dist/models.js
 var ZCODE_ID = harnessIdSchema.parse("zcode");
-function encodeModel(model) {
+function encodeModel(model2) {
   return harnessModelRefSchema.parse({
-    id: `zcode-local-v1.${Buffer.from(JSON.stringify([model.providerId, model.modelId])).toString("base64url")}`
+    id: `zcode-local-v1.${Buffer.from(JSON.stringify([model2.providerId, model2.modelId])).toString("base64url")}`
   });
 }
-function decodeModel(model) {
+function decodeModel(model2) {
   try {
     const prefix = "zcode-local-v1.";
-    const value = JSON.parse(Buffer.from(model.id.slice(prefix.length), "base64url").toString("utf8"));
-    if (!model.id.startsWith(prefix) || !Array.isArray(value) || value.length !== 2)
+    const value = JSON.parse(Buffer.from(model2.id.slice(prefix.length), "base64url").toString("utf8"));
+    if (!model2.id.startsWith(prefix) || !Array.isArray(value) || value.length !== 2)
       throw new Error();
     const native = nativeModelSchema.parse({ providerId: value[0], modelId: value[1] });
-    if (encodeModel(native).id !== model.id)
+    if (encodeModel(native).id !== model2.id)
       throw new Error();
     return native;
   } catch {
     throw new ZcodeError("invalidRequest", "Invalid ZCode model reference");
   }
 }
-function selectNativeModel(model, settings, thinkingOption) {
-  const native = decodeModel(model);
-  const entry = settings.model.available.find((entry2) => encodeModel(entry2.ref).id === model.id && !entry2.disabledReason);
+function selectNativeModel(model2, settings, thinkingOption) {
+  const native = decodeModel(model2);
+  const entry = settings.model.available.find((entry2) => encodeModel(entry2.ref).id === model2.id && !entry2.disabledReason);
   if (!entry)
     throw new ZcodeError("invalidRequest", "ZCode model is not available");
   const current = settings.model.current;
-  const level = thinkingOption ?? (current && encodeModel(current).id === model.id ? current.options?.reasoningLevel : void 0) ?? entry.reasoning?.defaultLevel;
+  const level = thinkingOption ?? (current && encodeModel(current).id === model2.id ? current.options?.reasoningLevel : void 0) ?? entry.reasoning?.defaultLevel;
   if (level === void 0)
     return native;
   if (!entry.reasoning?.levels.some((option) => option.value === level))
@@ -17325,20 +18155,20 @@ function selectNativeModel(model, settings, thinkingOption) {
   return { ...native, options: { reasoningLevel: level } };
 }
 function modelCatalog(settings) {
-  const available = settings.model.available.filter((model) => !model.disabledReason);
+  const available = settings.model.available.filter((model2) => !model2.disabledReason);
   const levels = new Map(settings.thoughtLevel.available.map((level) => [level.value, level]));
-  for (const model of available)
-    for (const level of model.reasoning?.levels ?? [])
+  for (const model2 of available)
+    for (const level of model2.reasoning?.levels ?? [])
       levels.set(level.value, level);
   const current = settings.model.current ? encodeModel(settings.model.current) : void 0;
   const defaultThinking = settings.thoughtLevel.current ?? settings.thoughtLevel.defaultLevel;
   return harnessModelCatalogSchema.parse({
-    models: available.map((model) => ({
-      ref: encodeModel(model.ref),
-      label: model.label,
-      supportedThinkingOptionIds: model.reasoning?.enabled ? model.reasoning.levels.map((level) => level.value) : []
+    models: available.map((model2) => ({
+      ref: encodeModel(model2.ref),
+      label: model2.label,
+      supportedThinkingOptionIds: model2.reasoning?.enabled ? model2.reasoning.levels.map((level) => level.value) : []
     })),
-    ...current && available.some((model) => encodeModel(model.ref).id === current.id) ? { defaultModel: current } : {},
+    ...current && available.some((model2) => encodeModel(model2.ref).id === current.id) ? { defaultModel: current } : {},
     thinkingOptions: [...levels.values()].map((level) => ({ id: level.value, label: level.label })),
     ...defaultThinking && levels.has(defaultThinking) ? { defaultThinkingOptionId: defaultThinking } : {}
   });
@@ -17363,7 +18193,7 @@ function permissionModes(current = "build") {
 function sessionState(snapshot, locator) {
   const settings = snapshot.settings;
   const current = settings.model.current ? encodeModel(settings.model.current) : void 0;
-  const model = settings.model.available.find((candidate) => encodeModel(candidate.ref).id === current?.id);
+  const model2 = settings.model.available.find((candidate) => encodeModel(candidate.ref).id === current?.id);
   return {
     nativeRef: nativeSessionRefSchema.parse({
       harnessId: ZCODE_ID,
@@ -17372,7 +18202,7 @@ function sessionState(snapshot, locator) {
       locator: { ...locator, cwd: snapshot.session.workspace.workspacePath }
     }),
     ...current && settings.model.current?.providerId !== "zcode-unconfigured" ? { effectiveModel: current } : {},
-    ...model ? { resolvedModelLabel: model.label } : {},
+    ...model2 ? { resolvedModelLabel: model2.label } : {},
     ...settings.thoughtLevel.enabled && settings.thoughtLevel.current ? {
       effectiveThinkingOptionId: harnessThinkingOptionIdSchema.parse(settings.thoughtLevel.current)
     } : {},
@@ -17386,7 +18216,7 @@ function sessionState(snapshot, locator) {
 function sessionUsage(snapshot, catalog) {
   const runtime = runtimeUsageSchema.safeParse(snapshot.runtime).data?.contextUsage;
   const current = snapshot.settings.model.current;
-  const window = catalog.model.available.find((model) => model.ref.providerId === current?.providerId && model.ref.modelId === current.modelId)?.contextWindow ?? snapshot.projection.contextWindow;
+  const window = catalog.model.available.find((model2) => model2.ref.providerId === current?.providerId && model2.ref.modelId === current.modelId)?.contextWindow ?? snapshot.projection.contextWindow;
   const cache = runtime?.cache;
   const usage = {
     ...window > 0 ? {
@@ -17502,16 +18332,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path4, added, removed, oldPosInc, options) {
-    const last = path4.lastComponent;
+  addToPath(path7, added, removed, oldPosInc, options) {
+    const last = path7.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path4.oldPos + oldPosInc,
+        oldPos: path7.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path4.oldPos + oldPosInc,
+        oldPos: path7.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -18572,6 +19402,7 @@ var ZcodeSession = class {
   };
   #state;
   #snapshot;
+  #usage;
   #active;
   #pendingInteractions = /* @__PURE__ */ new Map();
   #closed = false;
@@ -18590,6 +19421,7 @@ var ZcodeSession = class {
     this.capabilities = ZCODE_CAPABILITIES;
     this.catalog = modelCatalog(nativeCatalog);
     this.#snapshot = snapshot;
+    this.#usage = new ZcodeUsage(snapshot.session.sessionId, (event) => this.#emit(event));
     this.#goalActive = (snapshot.target === void 0 ? snapshot.projection.target : snapshot.target)?.status === "active";
     this.#state = sessionState(snapshot, transport.locator);
     this.initialState = structuredClone(this.#state);
@@ -18607,6 +19439,7 @@ var ZcodeSession = class {
     this.#channel.emit({ kind: "event", event });
   }
   async subscribe() {
+    this.#usage.replay(this.#snapshot.messages, true);
     await this.transport.listen("onDynamicSessionEvent", {
       sessionId: this.sessionId,
       deliveryKind: "desktop-continuous",
@@ -18750,7 +19583,7 @@ var ZcodeSession = class {
       try {
         let method, params;
         if (command.type === "model.select") {
-          if (!this.catalog.models.some((model) => model.ref.id === command.model.id))
+          if (!this.catalog.models.some((model2) => model2.ref.id === command.model.id))
             return failure("invalidRequest", "ZCode model is not available");
           method = "setModel";
           params = {
@@ -18889,6 +19722,7 @@ var ZcodeSession = class {
     if (event.seq <= this.#lastSeq)
       return;
     this.#lastSeq = event.seq;
+    this.#usage.observe(event);
     if (event.type === "session.updated" && event.payload && Object.hasOwn(event.payload, "target"))
       this.#goalActive = record2(event.payload.target).status === "active";
     if (event.type === "turn.started") {
@@ -18963,6 +19797,9 @@ var ZcodeSession = class {
       } : turn?.outcome;
       if (!outcome || outcome.status === "unknown")
         throw new ZcodeError("protocolError", "ZCode completed without a confirmed turn outcome");
+      if (this.#active !== active || this.#closed || this.#faulted)
+        return;
+      this.#usage.replay(snapshot.messages, false);
       this.#finish(active, {
         ...outcome,
         ...turn?.checkpoint ? { checkpoint: turn.checkpoint } : {}
@@ -19077,8 +19914,10 @@ var ZcodeAdapter = class {
   // One verification page and SDK instance for the whole Host, as in ZCode Desktop.
   #verifier;
   #prewarmed = false;
+  usageStatistics;
   constructor(options = {}) {
     this.options = options;
+    this.usageStatistics = createZcodeUsageStatistics(options.environment ?? process.env);
   }
   #sharedVerifier = (appVersion) => this.#verifier ??= (this.options.createVerifier ?? createZcodeVerifier)({
     appVersion,
@@ -19110,7 +19949,7 @@ var ZcodeAdapter = class {
   async inspect(input = {}) {
     let transport;
     try {
-      transport = await this.#transport(path3.resolve(input.cwd ?? process.cwd()));
+      transport = await this.#transport(path6.resolve(input.cwd ?? process.cwd()));
       const settings = await readCatalog(transport);
       const catalog = modelCatalog(settings);
       if (!catalog.models.length)
@@ -19118,7 +19957,7 @@ var ZcodeAdapter = class {
           status: "unavailable",
           error: {
             code: "authenticationRequired",
-            message: "ZCode has no available models. Sign in to ZCode Desktop with a Start Plan account or add a personal provider in ZCode.",
+            message: "ZCode has no available models. Connect Start Plan or Personal Coding Plan in ZCode Desktop, or add a personal provider, then re-detect ZCode. Team Coding Plan is not supported.",
             retryable: true
           }
         };
@@ -19156,18 +19995,18 @@ var ZcodeAdapter = class {
     let transport;
     let createdId;
     try {
-      transport = await this.#transport(path3.resolve(input.cwd), input.environment);
+      transport = await this.#transport(path6.resolve(input.cwd), input.environment);
       let snapshot, settings;
       if (input.kind === "create") {
         settings = await readCatalog(transport);
         if (input.permissionModeId && !permissionModes().modes.some((m) => m.id === input.permissionModeId))
           throw new ZcodeError("invalidRequest", "Unknown ZCode permission mode");
-        const model = input.model ? selectNativeModel(input.model, settings, input.thinkingOptionId) : void 0;
+        const model2 = input.model ? selectNativeModel(input.model, settings, input.thinkingOptionId) : void 0;
         const mode = input.executionPolicy === "unattended-full-access" ? "yolo" : input.permissionModeId;
         const created = await transport.command(null, "createSession", {
           workspaceId: input.cwd,
           config: {
-            ...model ? { modelSelection: model } : {},
+            ...model2 ? { modelSelection: model2 } : {},
             ...mode ? { mode } : {},
             ...input.thinkingOptionId ? { thought: input.thinkingOptionId } : {}
           }