@codexhost/cli-win32-arm64 0.12.2 → 0.13.0

package/app/plugins/grok/plugin.mjs

@@ -372,20 +372,180 @@ function createHarnessInstaller(environment, source) {
   };
 }
 
+// dist/usage-statistics.js
+import os2 from "node:os";
+import path5 from "node:path";
+import { readFile } from "node:fs/promises";
+
+// ../../harness-adapter/dist/usage-statistics.js
+import { createReadStream } from "node:fs";
+import { lstat, opendir } from "node:fs/promises";
+import path4 from "node:path";
+import { createInterface } from "node:readline";
+var MAX_SESSION_ID_LENGTH = 512;
+var MAX_CWD_LENGTH = 4096;
+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;
+  if (sessionId === void 0 && cwd === void 0)
+    return entry;
+  return {
+    ...entry,
+    ...sessionId !== void 0 ? { sessionId } : {},
+    ...cwd !== void 0 ? { cwd } : {}
+  };
+}
+async function jsonlUsageSources(root, maxDepth, signal) {
+  const sources = [];
+  const visit = async (directory, depth) => {
+    signal.throwIfAborted();
+    const entries = await opendir(directory).catch((error53) => {
+      if (error53.code === "ENOENT")
+        return null;
+      throw error53;
+    });
+    if (!entries)
+      return;
+    for await (const entry of entries) {
+      signal.throwIfAborted();
+      const file2 = path4.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        if (depth < maxDepth)
+          await visit(file2, depth + 1);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        const info = await lstat(file2).catch(() => null);
+        if (info?.isFile() && info.size > 0) {
+          sources.push({ id: file2, fingerprint: `${info.ino}:${info.size}:${info.mtimeMs}` });
+        }
+      }
+    }
+  };
+  await visit(root, 0);
+  return sources;
+}
+async function* jsonlRecords(file2, marker, signal) {
+  const lines = createInterface({
+    input: createReadStream(file2, { encoding: "utf8", signal }),
+    crlfDelay: Infinity
+  });
+  for await (const line of lines) {
+    if (!line.includes(marker))
+      continue;
+    let value;
+    try {
+      value = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      yield value;
+    }
+  }
+}
+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;
+}
+
+// dist/usage-statistics.js
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var USD_TICKS = 1e10;
+function count(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function grokHome(environment) {
+  return environment.GROK_HOME || path5.join(environment.HOME || os2.homedir(), ".grok");
+}
+async function forkedAtMs(directory) {
+  try {
+    const summary = JSON.parse(await readFile(path5.join(directory, "summary.json"), "utf8"));
+    return isRecord(summary) && typeof summary.parent_session_id === "string" ? nativeTimeMs(summary.created_at) : null;
+  } catch {
+    return null;
+  }
+}
+function grokSession(file2) {
+  const directory = path5.dirname(file2);
+  let cwd;
+  try {
+    cwd = decodeURIComponent(path5.basename(path5.dirname(directory)));
+  } catch {
+    cwd = void 0;
+  }
+  return { sessionId: path5.basename(directory), cwd };
+}
+async function readGrokUsage(file2, signal) {
+  const forkedAt = await forkedAtMs(path5.dirname(file2));
+  const session = grokSession(file2);
+  const entries = [];
+  for await (const line of jsonlRecords(file2, '"turn_completed"', signal)) {
+    const params = isRecord(line.params) ? line.params : {};
+    const update = isRecord(params.update) ? params.update : {};
+    const usage = isRecord(update.usage) ? update.usage : {};
+    if (update.sessionUpdate !== "turn_completed" || typeof update.prompt_id !== "string")
+      continue;
+    const meta3 = isRecord(params._meta) ? params._meta : {};
+    const at = nativeTimeMs(meta3.agentTimestampMs) ?? (typeof line.timestamp === "number" ? nativeTimeMs(line.timestamp * 1e3) : null);
+    if (at === null || forkedAt !== null && at <= forkedAt)
+      continue;
+    for (const [model2, value] of Object.entries(isRecord(usage.modelUsage) ? usage.modelUsage : {})) {
+      if (!isRecord(value))
+        continue;
+      const input = count(value.inputTokens);
+      const output = count(value.outputTokens);
+      const cached2 = count(value.cachedReadTokens);
+      const written = count(value.cacheCreationTokens ?? 0);
+      const reasoning = count(value.reasoningTokens);
+      const ticks = count(value.costUsdTicks);
+      if (input === null || output === null || value.totalTokens !== input + output)
+        continue;
+      const cacheKnown = cached2 !== null && cached2 <= input && written === 0;
+      entries.push(withUsageSession({
+        id: `${update.prompt_id}:${model2}`,
+        occurredAtMs: at,
+        model: model2,
+        inputTokens: input,
+        ...cacheKnown ? { cachedInputTokens: cached2, cacheWriteInputTokens: 0 } : {},
+        outputTokens: output,
+        ...reasoning !== null && reasoning <= output ? { reasoningOutputTokens: reasoning } : {},
+        // A turn Grok marks incomplete has no cost of its own; it counts as free rather
+        // than as a model without a price.
+        ...ticks !== null ? { costUsd: ticks / USD_TICKS } : usage.usageIsIncomplete === true ? { costUsd: 0 } : {}
+      }, session));
+    }
+  }
+  return entries;
+}
+function createGrokUsageStatistics(environment) {
+  return Object.freeze({
+    // sessions/<url-encoded cwd>/<session>/updates.jsonl; subagents are sessions of their own.
+    listSources: async (signal) => (await jsonlUsageSources(path5.join(grokHome(environment), "sessions"), 2, signal)).filter((source) => path5.basename(source.id) === "updates.jsonl"),
+    readSource: (id, signal) => readGrokUsage(id, signal)
+  });
+}
+
 // dist/grok-adapter.js
 import { randomUUID } from "node:crypto";
 
 // dist/grok-credential-export.js
 import { createHash } from "node:crypto";
-import { readFile } from "node:fs/promises";
-import os2 from "node:os";
-import path4 from "node:path";
+import { readFile as readFile2 } from "node:fs/promises";
+import os3 from "node:os";
+import path6 from "node:path";
 async function readGrokCredentials(environment) {
   if ([environment.XAI_API_KEY, environment.GROK_API_KEY, environment.GROK_TOKEN].some((v) => v?.trim()))
     return [];
   try {
-    const home = environment.GROK_HOME ?? path4.join(environment.HOME ?? os2.homedir(), ".grok");
-    const auth = JSON.parse(await readFile(path4.join(home, "auth.json"), "utf8"));
+    const home = environment.GROK_HOME ?? path6.join(environment.HOME ?? os3.homedir(), ".grok");
+    const auth = JSON.parse(await readFile2(path6.join(home, "auth.json"), "utf8"));
     const client2 = "b1a00492-073a-47ea-816f-4c329264a828";
     const entry = auth[`https://auth.x.ai::${client2}`] ?? auth["https://auth.x.ai"];
     if (!entry || entry.oidc_issuer !== "https://auth.x.ai" || entry.oidc_client_id !== client2)
@@ -412,7 +572,7 @@ async function readGrokCredentials(environment) {
 }
 
 // dist/grok-adapter.js
-import path13 from "node:path";
+import path15 from "node:path";
 
 // ../../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -1180,10 +1340,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path14) {
-  if (!path14)
+function getElementAtPath(obj, path16) {
+  if (!path16)
     return obj;
-  return path14.reduce((acc, key) => acc?.[key], obj);
+  return path16.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1592,11 +1752,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path14, issues) {
+function prefixIssues(path16, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path14);
+    iss.path.unshift(path16);
     return iss;
   });
 }
@@ -1743,16 +1903,16 @@ function flattenError(error53, mapper = (issue2) => issue2.message) {
 }
 function formatError(error53, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error54, path14 = []) => {
+  const processError = (error54, path16 = []) => {
     for (const issue2 of error54.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path14, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path16, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
       } else {
-        const fullpath = [...path14, ...issue2.path];
+        const fullpath = [...path16, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1779,17 +1939,17 @@ function formatError(error53, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error53, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error54, path14 = []) => {
+  const processError = (error54, path16 = []) => {
     var _a3, _b;
     for (const issue2 of error54.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path14, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path16, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path14, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path16, ...issue2.path]);
       } else {
-        const fullpath = [...path14, ...issue2.path];
+        const fullpath = [...path16, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1821,8 +1981,8 @@ function treeifyError(error53, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path14 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path14) {
+  const path16 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path16) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -5050,8 +5210,8 @@ function az_default() {
 }
 
 // ../../../node_modules/zod/v4/locales/be.js
-function getBelarusianPlural(count, one, few, many) {
-  const absCount = Math.abs(count);
+function getBelarusianPlural(count3, one, few, many) {
+  const absCount = Math.abs(count3);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -7129,8 +7289,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(count3, one, many) {
+  return Math.abs(count3) === 1 ? one : many;
 }
 function withDefiniteArticle(word) {
   if (!word)
@@ -9258,8 +9418,8 @@ function ro_default() {
 }
 
 // ../../../node_modules/zod/v4/locales/ru.js
-function getRussianPlural(count, one, few, many) {
-  const absCount = Math.abs(count);
+function getRussianPlural(count3, one, few, many) {
+  const absCount = Math.abs(count3);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -14514,13 +14674,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path14 = ref.slice(1).split("/").filter(Boolean);
-  if (path14.length === 0) {
+  const path16 = ref.slice(1).split("/").filter(Boolean);
+  if (path16.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path14[0] === defsKey) {
-    const key = path14[1];
+  if (path16[0] === defsKey) {
+    const key = path16[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14928,6 +15088,15 @@ function date4(params) {
 // ../../../node_modules/zod/v4/classic/external.js
 config(en_default());
 
+// ../../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),
@@ -14998,6 +15167,153 @@ 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 count2 = 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: count2,
+  inputTokens: count2,
+  cachedInputTokens: count2,
+  cacheWriteInputTokens: count2,
+  cacheKnownInputTokens: count2,
+  outputTokens: count2,
+  reasoningOutputTokens: count2,
+  /** 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: count2,
+  /**
+   * Requests whose storage gave no token counts: counted as requests, with neither tokens nor
+   * cost, and not as unpriced.
+   */
+  unmeteredRequests: count2
+});
+var totals = usageStatisticsTotalsSchema.shape;
+var usageStatisticsSessionSchema = external_exports.strictObject({
+  harness,
+  sessionId: external_exports.string().min(1).max(512),
+  project: project.nullable(),
+  /** Models the session used, most requests first. */
+  models: external_exports.array(model).max(16),
+  firstAtMs: count2,
+  lastAtMs: count2,
+  ...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: count2, read: count2 }),
+  /** 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: count2,
+    requests: count2
+  })).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: count2
+  })).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)
+});
+
 // ../../shared-contracts/dist/ids.js
 var opaqueIdSchema = external_exports.string().refine((value) => value.trim().length > 0, {
   message: "Identifier must not be empty or whitespace"
@@ -15045,6 +15361,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"
@@ -15109,6 +15429,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(),
@@ -15120,7 +15441,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" });
@@ -15141,6 +15466,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",
@@ -15395,27 +15734,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",
@@ -15609,13 +15948,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()
@@ -16034,6 +16400,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,
@@ -16136,10 +16507,12 @@ var tokenFields = [
 ];
 var safeIntegerFields = [
   "planFiveHourResetsAtUnix",
-  "planSevenDayResetsAtUnix"
+  "planSevenDayResetsAtUnix",
+  "timeToFirstOutputMs"
 ];
 var percentFields = [
   "cacheHitRatePercent",
+  "sessionCacheHitRatePercent",
   "planFiveHourUsedPercent",
   "planSevenDayUsedPercent"
 ];
@@ -16147,16 +16520,20 @@ var usageFields = /* @__PURE__ */ new Set([
   ...tokenFields,
   ...safeIntegerFields,
   ...percentFields,
+  "sessionCacheUsage",
   "totalCostUsd",
   "totalCredits",
   "contextUsagePercent",
-  "outputTokensPerSecond"
+  "outputTokensPerSecond",
+  "apiOutputTokensPerSecond",
+  "costSource",
+  "unpricedModels"
 ]);
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseHostUsage(value) {
-  if (!isRecord(value))
+  if (!isRecord2(value))
     throw new Error("Harness Usage must be an object");
   const keys = Object.keys(value);
   if (keys.length === 0)
@@ -16166,7 +16543,11 @@ function parseHostUsage(value) {
       throw new Error(`Harness Usage contains unknown field '${key}'`);
     }
   }
-  for (const field of ["totalCredits", "contextUsagePercent"]) {
+  for (const field of [
+    "totalCredits",
+    "contextUsagePercent",
+    "apiOutputTokensPerSecond"
+  ]) {
     const candidate = value[field];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0)) {
       throw new Error(`Harness Usage '${field}' must be a finite non-negative number`);
@@ -16196,6 +16577,12 @@ function parseHostUsage(value) {
       throw new Error(`Harness Usage '${field}' must be between 0 and 100`);
     }
   }
+  if (value.sessionCacheUsage !== void 0) {
+    const totals2 = value.sessionCacheUsage;
+    if (!isRecord2(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) {
@@ -16210,8 +16597,43 @@ 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"
+]);
 
 // ../../harness-adapter/dist/live-command-catalog.js
 var COMMON_EXCLUDED_LIVE_COMMANDS = /* @__PURE__ */ new Set([
@@ -16333,9 +16755,9 @@ function mergeLiveHarnessCommands(builtIns, idPrefix, live, exclusions = {}) {
 
 // dist/acp-transport.js
 import { spawn, spawnSync } from "node:child_process";
-import { readdir, readFile as readFile2 } from "node:fs/promises";
-import os4 from "node:os";
-import path10 from "node:path";
+import { readdir, readFile as readFile3 } from "node:fs/promises";
+import os5 from "node:os";
+import path12 from "node:path";
 import { Readable, Writable } from "node:stream";
 
 // ../../../node_modules/@agentclientprotocol/sdk/dist/schema/index.js
@@ -18073,17 +18495,17 @@ function isResponseMessage(value) {
 function isNotificationMessage(value) {
   return isJsonRpcEnvelope(value) && !("id" in value) && typeof value["method"] === "string";
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
 function isJsonRpcEnvelope(value) {
-  return isRecord2(value) && value["jsonrpc"] === "2.0";
+  return isRecord3(value) && value["jsonrpc"] === "2.0";
 }
 function isJsonRpcId(value) {
   return value === null || typeof value === "string" || typeof value === "number" && Number.isFinite(value);
 }
 function isResponseShapedMessage(value) {
-  return isRecord2(value) && !("method" in value) && ("id" in value || "result" in value || "error" in value);
+  return isRecord3(value) && !("method" in value) && ("id" in value || "result" in value || "error" in value);
 }
 function isResponseBatch(batch) {
   let hasValidCall = false;
@@ -18093,7 +18515,7 @@ function isResponseBatch(batch) {
   for (const entry of batch) {
     hasValidCall ||= isRequestMessage(entry) || isNotificationMessage(entry);
     hasValidResponse ||= isResponseMessage(entry);
-    if (!isRecord2(entry)) {
+    if (!isRecord3(entry)) {
       continue;
     }
     hasCallShape ||= "method" in entry;
@@ -18108,13 +18530,13 @@ function isResponseBatch(batch) {
   return hasResponseShape && !hasCallShape;
 }
 function cancelRequestId(params) {
-  if (!isRecord2(params) || !isJsonRpcId(params["requestId"])) {
+  if (!isRecord3(params) || !isJsonRpcId(params["requestId"])) {
     return void 0;
   }
   return params["requestId"];
 }
 function isErrorResponse(value) {
-  return isRecord2(value) && typeof value["code"] === "number" && Number.isInteger(value["code"]) && typeof value["message"] === "string";
+  return isRecord3(value) && typeof value["code"] === "number" && Number.isInteger(value["code"]) && typeof value["message"] === "string";
 }
 var Handled = {
   /**
@@ -18605,7 +19027,7 @@ var Connection = class {
       this.receiveBatch(message);
       return;
     }
-    if (!isRecord2(message)) {
+    if (!isRecord3(message)) {
       console.error("Invalid message", { message });
       return;
     }
@@ -18622,9 +19044,9 @@ var Connection = class {
       return;
     }
     const responseBatch = isResponseBatch(batch);
-    const responseCount = responseBatch ? 0 : batch.reduce((count, message) => count + (isNotificationMessage(message) ? 0 : 1), 0);
+    const responseCount = responseBatch ? 0 : batch.reduce((count3, message) => count3 + (isNotificationMessage(message) ? 0 : 1), 0);
     let remaining = responseCount;
-    let remainingNotifications = batch.reduce((count, message) => count + (isNotificationMessage(message) ? 1 : 0), 0);
+    let remainingNotifications = batch.reduce((count3, message) => count3 + (isNotificationMessage(message) ? 1 : 0), 0);
     let responseSent = false;
     const responses = [];
     const sendResponsesIfReady = async () => {
@@ -18668,7 +19090,7 @@ var Connection = class {
     if (this.abortController.signal.aborted) {
       return Promise.resolve();
     }
-    if (!isRecord2(message)) {
+    if (!isRecord3(message)) {
       console.error("Invalid message", { message });
       return Promise.resolve();
     }
@@ -19038,7 +19460,7 @@ function ndJsonStream(output, input) {
         if (trimmedLine) {
           try {
             const message = JSON.parse(trimmedLine);
-            if (isRecord2(message) || Array.isArray(message)) {
+            if (isRecord3(message) || Array.isArray(message)) {
               controller.enqueue(message);
             } else {
               console.warn("Skipping JSON line that is not an object:", trimmedLine);
@@ -20501,14 +20923,14 @@ var ClientSideConnection = class {
 
 // dist/grok-slash-commands.js
 var GROK_LIVE_COMMAND_ID_PREFIX = "grok.slash.";
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseGrokAvailableCommands(value) {
   if (!Array.isArray(value))
     return [];
   return value.flatMap((entry) => {
-    if (!isRecord3(entry))
+    if (!isRecord4(entry))
       return [];
     const name = typeof entry.name === "string" ? entry.name.trim().replace(/^\//u, "") : "";
     if (!name)
@@ -20517,14 +20939,14 @@ function parseGrokAvailableCommands(value) {
       {
         name,
         description: typeof entry.description === "string" ? entry.description : "",
-        meta: isRecord3(entry._meta) ? entry._meta : null
+        meta: isRecord4(entry._meta) ? entry._meta : null
       }
     ];
   });
 }
 function isGrokSkill(command) {
-  const path14 = command.meta?.path;
-  return typeof path14 === "string" && /(^|[\\/])SKILL\.md$/u.test(path14) || typeof command.meta?.qualifiedName === "string";
+  const path16 = command.meta?.path;
+  return typeof path16 === "string" && /(^|[\\/])SKILL\.md$/u.test(path16) || typeof command.meta?.qualifiedName === "string";
 }
 function grokLiveCommands(native) {
   return native.map((command) => ({
@@ -20535,7 +20957,7 @@ function grokLiveCommands(native) {
 }
 
 // dist/command.js
-import path5 from "node:path";
+import path7 from "node:path";
 var GrokExecutableError = class extends Error {
   code = "GROK_NOT_FOUND";
 };
@@ -20564,7 +20986,7 @@ function resolveGrokExecutable(input = {}) {
   });
   if (!resolution)
     throw new GrokExecutableError("Grok CLI is not installed");
-  return targetPath(platform).isAbsolute(resolution.executable) ? resolution.executable : path5.resolve(resolution.executable);
+  return targetPath(platform).isAbsolute(resolution.executable) ? resolution.executable : path7.resolve(resolution.executable);
 }
 function grokInvocation(command, platform = process.platform, modelId) {
   const arguments_ = ["agent", "--no-leader"];
@@ -20577,11 +20999,11 @@ function grokInvocation(command, platform = process.platform, modelId) {
 
 // dist/grok-fork.js
 import { isDeepStrictEqual } from "node:util";
-import path8 from "node:path";
+import path10 from "node:path";
 
 // dist/grok-file-change.js
 import { Buffer as Buffer2 } from "node:buffer";
-import path6 from "node:path";
+import path8 from "node:path";
 
 // ../../../node_modules/diff/libesm/diff/base.js
 var Diff = class {
@@ -20683,16 +21105,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path14, added, removed, oldPosInc, options) {
-    const last = path14.lastComponent;
+  addToPath(path16, added, removed, oldPosInc, options) {
+    const last = path16.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path14.oldPos + oldPosInc,
+        oldPos: path16.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path14.oldPos + oldPosInc,
+        oldPos: path16.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -21001,17 +21423,17 @@ function splitLines(text) {
 // dist/grok-file-change.js
 var DEFAULT_GROK_FILE_CHANGE_TEXT_LIMIT = 4 * 1024 * 1024;
 var MAX_GROK_FILE_CHANGES_PER_TOOL = 32;
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function validAbsolutePath(value) {
-  return typeof value === "string" && path6.isAbsolute(value) && value.trim().length > 0 && !value.includes("\0") && !value.includes("\n") && !value.includes("\r");
+  return typeof value === "string" && path8.isAbsolute(value) && value.trim().length > 0 && !value.includes("\0") && !value.includes("\n") && !value.includes("\r");
 }
 function displayPath(nativePath, cwd) {
-  const resolvedCwd = path6.resolve(cwd);
-  const resolvedPath = path6.resolve(nativePath);
-  const relative = path6.relative(resolvedCwd, resolvedPath);
-  const inside = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path6.sep}`);
+  const resolvedCwd = path8.resolve(cwd);
+  const resolvedPath = path8.resolve(nativePath);
+  const relative = path8.relative(resolvedCwd, resolvedPath);
+  const inside = relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path8.sep}`);
   const selected = inside ? relative : resolvedPath;
   const normalized = selected.replaceAll("\\", "/");
   if (normalized.length === 0 || normalized === ".")
@@ -21052,7 +21474,7 @@ function projectGrokFileChanges(content, cwd, textLimit = DEFAULT_GROK_FILE_CHAN
     return null;
   const candidates = [];
   for (const entry of content) {
-    if (isRecord4(entry) && entry.type === "diff")
+    if (isRecord5(entry) && entry.type === "diff")
       candidates.push(entry);
   }
   if (candidates.length === 0 || candidates.length > MAX_GROK_FILE_CHANGES_PER_TOOL)
@@ -21073,8 +21495,8 @@ function projectGrokFileChanges(content, cwd, textLimit = DEFAULT_GROK_FILE_CHAN
 
 // dist/local-media-markdown.js
 import { existsSync, statSync } from "node:fs";
-import os3 from "node:os";
-import path7 from "node:path";
+import os4 from "node:os";
+import path9 from "node:path";
 var MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
   ".aac",
   ".gif",
@@ -21093,14 +21515,14 @@ var MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
   ".webp"
 ]);
 function grokMediaResolveRoots(cwd, sessionDirectory) {
-  const roots = [path7.resolve(cwd)];
+  const roots = [path9.resolve(cwd)];
   if (sessionDirectory) {
-    const session = path7.resolve(sessionDirectory);
-    roots.push(session, path7.join(session, "videos"), path7.join(session, "images"));
+    const session = path9.resolve(sessionDirectory);
+    roots.push(session, path9.join(session, "videos"), path9.join(session, "images"));
   }
-  const home = process.env.HOME ?? process.env.USERPROFILE ?? os3.homedir();
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? os4.homedir();
   if (home)
-    roots.push(path7.join(home, "Downloads"));
+    roots.push(path9.join(home, "Downloads"));
   return roots;
 }
 function rewriteLocalMediaMarkdown(text, roots, options = {}) {
@@ -21201,7 +21623,7 @@ function parseInlineCode(text, start) {
   return { closed: false, content: text.slice(start + 1), end: text.length };
 }
 function mediaMarkdownImage(absolutePath) {
-  const name = path7.basename(absolutePath).replaceAll("]", "\\]");
+  const name = path9.basename(absolutePath).replaceAll("]", "\\]");
   return `![${name}](${formatMarkdownDestination(absolutePath, false)})`;
 }
 function parseMarkdownImage(text, start) {
@@ -21326,11 +21748,11 @@ function resolveLocalMediaPath(raw, roots, exists = mediaFileExists) {
   if (!hasMediaExtension(stripped))
     return null;
   if (isAbsoluteMediaPath(stripped)) {
-    const absolute = path7.resolve(stripped);
+    const absolute = path9.resolve(stripped);
     return exists(absolute) ? absolute : null;
   }
   for (const root of roots) {
-    const absolute = path7.resolve(root, stripped);
+    const absolute = path9.resolve(root, stripped);
     if (exists(absolute))
       return absolute;
   }
@@ -21352,11 +21774,11 @@ function stripFileUrl(value) {
   }
 }
 function isAbsoluteMediaPath(value) {
-  return path7.isAbsolute(value) || /^[a-zA-Z]:[\\/]/.test(value);
+  return path9.isAbsolute(value) || /^[a-zA-Z]:[\\/]/.test(value);
 }
 function hasMediaExtension(value) {
   const pathname = value.split(/[?#]/, 1)[0] ?? value;
-  return MEDIA_EXTENSIONS.has(path7.extname(pathname).toLowerCase());
+  return MEDIA_EXTENSIONS.has(path9.extname(pathname).toLowerCase());
 }
 function mediaFileExists(absolutePath) {
   try {
@@ -21369,14 +21791,14 @@ function mediaFileExists(absolutePath) {
 // dist/grok-tool-output.js
 var DEFAULT_GROK_TOOL_OUTPUT_LIMIT = 64e3;
 var EXECUTE_TOOL_NAMES = /* @__PURE__ */ new Set(["bash", "run_terminal_command", "shell", "cursor_shell"]);
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stringField(value, key) {
-  return isRecord5(value) && typeof value[key] === "string" && value[key].length > 0 ? value[key] : void 0;
+  return isRecord6(value) && typeof value[key] === "string" && value[key].length > 0 ? value[key] : void 0;
 }
 function numberField(value, key) {
-  if (!isRecord5(value))
+  if (!isRecord6(value))
     return void 0;
   const field = value[key];
   if (field === null)
@@ -21399,7 +21821,7 @@ function firstReadableText(...candidates) {
   for (const candidate of candidates) {
     if (typeof candidate === "string" && candidate.length > 0)
       return candidate;
-    if (isRecord5(candidate)) {
+    if (isRecord6(candidate)) {
       const nested = stringField(candidate, "content") ?? stringField(candidate, "text") ?? stringField(candidate, "tool_result") ?? stringField(candidate, "raw_output");
       if (nested)
         return nested;
@@ -21422,7 +21844,7 @@ function grokToolArguments(rawInput) {
   if (!parsed.success)
     return {};
   const argumentsValue = parsed.data;
-  if (!isRecord5(argumentsValue) || stringField(argumentsValue, "path"))
+  if (!isRecord6(argumentsValue) || stringField(argumentsValue, "path"))
     return argumentsValue;
   const targetFile = stringField(argumentsValue, "target_file");
   return targetFile ? { ...argumentsValue, path: targetFile } : argumentsValue;
@@ -21435,7 +21857,7 @@ function grokCommand(name, kind, rawInput) {
     return command;
   if (name && EXECUTE_TOOL_NAMES.has(name))
     return command;
-  return isRecord5(rawInput) && rawInput.variant === "Bash" ? command : void 0;
+  return isRecord6(rawInput) && rawInput.variant === "Bash" ? command : void 0;
 }
 function grokCommandCwd(rawInput, fallback) {
   return stringField(rawInput, "cwd") ?? fallback;
@@ -21462,11 +21884,11 @@ function acpContentText(content) {
   if (!Array.isArray(content))
     return "";
   return content.flatMap((entry) => {
-    if (!isRecord5(entry))
+    if (!isRecord6(entry))
       return [];
     if (entry.type === "text" && typeof entry.text === "string")
       return [entry.text];
-    if (entry.type !== "content" || !isRecord5(entry.content))
+    if (entry.type !== "content" || !isRecord6(entry.content))
       return [];
     return entry.content.type === "text" && typeof entry.content.text === "string" ? [entry.content.text] : [];
   }).join("\n");
@@ -21477,10 +21899,10 @@ function acpContentImages(content, remainingBytes) {
   const images = [];
   let remaining = remainingBytes;
   for (const entry of content) {
-    if (!isRecord5(entry))
+    if (!isRecord6(entry))
       continue;
     const image = entry.type === "image" ? entry : entry.type === "content" ? entry.content : null;
-    if (!isRecord5(image) || image.type !== "image")
+    if (!isRecord6(image) || image.type !== "image")
       continue;
     const mimeType = stringField(image, "mimeType") ?? stringField(image, "mime_type");
     const data = stringField(image, "data");
@@ -21503,14 +21925,14 @@ function bashOutput(rawOutput) {
 function rawOutputProjection(rawOutput) {
   if (typeof rawOutput === "string")
     return rawOutput.length > 0 ? { text: rawOutput } : {};
-  if (!isRecord5(rawOutput))
+  if (!isRecord6(rawOutput))
     return {};
   if (rawOutput.type === "Bash" || rawOutput.variant === "Bash" || numberField(rawOutput, "exit_code") !== void 0 || numberField(rawOutput, "exitCode") !== void 0) {
     const bash = bashOutput(rawOutput);
     if (bash.text !== void 0 || bash.exitCode !== void 0)
       return bash;
   }
-  const text = firstReadableText(rawOutput.content, rawOutput.text, rawOutput.tool_result, rawOutput.raw_output, isRecord5(rawOutput.FileContent) ? rawOutput.FileContent : void 0, isRecord5(rawOutput.Content) ? rawOutput.Content : void 0);
+  const text = firstReadableText(rawOutput.content, rawOutput.text, rawOutput.tool_result, rawOutput.raw_output, isRecord6(rawOutput.FileContent) ? rawOutput.FileContent : void 0, isRecord6(rawOutput.Content) ? rawOutput.Content : void 0);
   if (text)
     return { text };
   if (typeof rawOutput.match_count === "number" && Number.isFinite(rawOutput.match_count)) {
@@ -21574,11 +21996,11 @@ var WAIT_TOOL_NAMES = /* @__PURE__ */ new Set([
 var KILL_TOOL_NAMES = /* @__PURE__ */ new Set(["kill_command_or_subagent", "kill_task"]);
 var DESCRIPTION_LIMIT = 500;
 var SUMMARY_LIMIT = 2e3;
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function idField(value, key) {
-  if (!isRecord6(value))
+  if (!isRecord7(value))
     return void 0;
   const field = value[key];
   if (typeof field === "string") {
@@ -21590,7 +22012,7 @@ function idField(value, key) {
   return void 0;
 }
 function stringField2(value, key) {
-  if (!isRecord6(value) || typeof value[key] !== "string")
+  if (!isRecord7(value) || typeof value[key] !== "string")
     return void 0;
   const trimmed = value[key].trim();
   return trimmed.length > 0 ? trimmed : void 0;
@@ -21613,7 +22035,7 @@ function collectIds(value) {
   };
   push(idField(value, "task_id"));
   push(idField(value, "subagent_id"));
-  if (isRecord6(value)) {
+  if (isRecord7(value)) {
     const list = value.task_ids ?? value.subagent_ids;
     if (Array.isArray(list)) {
       for (const entry of list)
@@ -21632,7 +22054,7 @@ function grokSubagentOperation(name, title, rawInput) {
     return "send";
   if (SPAWN_TOOL_NAMES.has(id))
     return "spawn";
-  if (isRecord6(rawInput) && rawInput.variant === "Task")
+  if (isRecord7(rawInput) && rawInput.variant === "Task")
     return "spawn";
   return null;
 }
@@ -21655,7 +22077,7 @@ function grokSubagentRole(rawInput) {
   return bounded(stringField2(rawInput, "subagent_type") ?? stringField2(rawInput, "agent_type") ?? stringField2(rawInput, "type"), DESCRIPTION_LIMIT);
 }
 function grokSubagentBackground(rawInput) {
-  if (!isRecord6(rawInput))
+  if (!isRecord7(rawInput))
     return true;
   if (rawInput.background === false || rawInput.run_in_background === false)
     return false;
@@ -21693,7 +22115,7 @@ function grokSubagentResultSummary(...candidates) {
   return void 0;
 }
 function grokSubagentEventFromUpdate(update) {
-  if (!isRecord6(update) || typeof update.sessionUpdate !== "string")
+  if (!isRecord7(update) || typeof update.sessionUpdate !== "string")
     return null;
   const nativeSubagentId = idField(update, "subagent_id") ?? idField(update, "child_session_id");
   if (!nativeSubagentId)
@@ -21701,13 +22123,13 @@ function grokSubagentEventFromUpdate(update) {
   if (update.sessionUpdate === "subagent_spawned") {
     const description = bounded(stringField2(update, "description"), DESCRIPTION_LIMIT);
     const role = bounded(stringField2(update, "subagent_type") ?? stringField2(update, "role"), DESCRIPTION_LIMIT);
-    const model = bounded(stringField2(update, "model"), DESCRIPTION_LIMIT);
+    const model2 = bounded(stringField2(update, "model"), DESCRIPTION_LIMIT);
     return {
       type: "subagent.spawned",
       nativeSubagentId,
       ...description ? { description } : {},
       ...role ? { role } : {},
-      ...model ? { model } : {}
+      ...model2 ? { model: model2 } : {}
     };
   }
   if (update.sessionUpdate === "subagent_finished") {
@@ -21754,14 +22176,14 @@ function grokSubagentWaitSettlements(input) {
   return ids.map((id) => ({ id, status: overall }));
 }
 function taskOutputResults(rawOutput) {
-  if (!isRecord6(rawOutput))
+  if (!isRecord7(rawOutput))
     return [];
   if (Array.isArray(rawOutput.results)) {
-    return rawOutput.results.filter(isRecord6);
+    return rawOutput.results.filter(isRecord7);
   }
   const nested = firstRecord(rawOutput.MultiResult, rawOutput.multiResult, rawOutput.multi_result);
   if (nested && Array.isArray(nested.results)) {
-    return nested.results.filter(isRecord6);
+    return nested.results.filter(isRecord7);
   }
   const single = firstRecord(rawOutput.Result, rawOutput.result);
   if (single)
@@ -21772,7 +22194,7 @@ function taskOutputResults(rawOutput) {
 }
 function firstRecord(...values) {
   for (const value of values) {
-    if (isRecord6(value))
+    if (isRecord7(value))
       return value;
   }
   return void 0;
@@ -21795,7 +22217,7 @@ function taskOutputTextSettlements(rawOutput, content, ids) {
   return settled;
 }
 function taskOutputStatus(rawOutput, content) {
-  if (isRecord6(rawOutput) && typeof rawOutput.status === "string")
+  if (isRecord7(rawOutput) && typeof rawOutput.status === "string")
     return rawOutput.status;
   const text = extractText(content) ?? extractText(rawOutput);
   if (!text)
@@ -21854,7 +22276,7 @@ function extractText(value, depth = 0) {
     const joined = parts.join("\n").trim();
     return joined.length > 0 ? joined : void 0;
   }
-  if (!isRecord6(value))
+  if (!isRecord7(value))
     return void 0;
   if (typeof value.text === "string" && value.text.trim().length > 0)
     return value.text.trim();
@@ -22213,7 +22635,7 @@ function mapGrokReplay(replay, harnessId, sessionId, cwd, knownTurnRefs = [], to
         rememberSubagentAlias(event.callId, nativeSubagentId);
         const prompt = grokSubagentPrompt(event.rawInput);
         const role = grokSubagentRole(event.rawInput);
-        const model = grokSubagentModel(event.rawInput);
+        const model2 = grokSubagentModel(event.rawInput);
         subagents.set(event.callId, {
           type: "subagentDelegation",
           itemId: stableId("subagent", turnIndex, ++messageIndex),
@@ -22225,7 +22647,7 @@ function mapGrokReplay(replay, harnessId, sessionId, cwd, knownTurnRefs = [], to
               ...nativeSubagentId ? { nativeSubagentId } : {},
               description: grokSubagentDescription(event.rawInput, event.title),
               ...role ? { role } : {},
-              ...model ? { model } : {},
+              ...model2 ? { model: model2 } : {},
               background: grokSubagentBackground(event.rawInput),
               status: "running"
             }
@@ -22324,11 +22746,11 @@ var GROK_SESSION_DELETE_METHOD = "_x.ai/session/delete";
 function error51(code, message, retryable = false) {
   return { code, message, retryable };
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isGrokMethodNotFound(error53) {
-  if (isRecord7(error53) && error53.code === -32601)
+  if (isRecord8(error53) && error53.code === -32601)
     return true;
   const message = error53 instanceof Error ? error53.message : String(error53);
   return /method not found/iu.test(message);
@@ -22346,10 +22768,10 @@ function buildGrokForkParams(input) {
   };
 }
 function parseGrokForkResponse(value) {
-  if (!isRecord7(value) || value.error !== void 0)
+  if (!isRecord8(value) || value.error !== void 0)
     return null;
-  const payload = typeof value.newSessionId !== "string" && isRecord7(value.result) ? value.result : value;
-  if (!isRecord7(payload) || payload.error !== void 0)
+  const payload = typeof value.newSessionId !== "string" && isRecord8(value.result) ? value.result : value;
+  if (!isRecord8(payload) || payload.error !== void 0)
     return null;
   if (typeof payload.newSessionId !== "string" || payload.newSessionId.length === 0)
     return null;
@@ -22365,11 +22787,11 @@ function parseGrokForkResponse(value) {
 }
 function projectRelativePath(value, cwds) {
   const normalized = value.replaceAll("\\", "/");
-  if (!path8.isAbsolute(value))
+  if (!path10.isAbsolute(value))
     return normalized;
   for (const cwd of cwds) {
-    const relative = path8.relative(path8.resolve(cwd), path8.resolve(value));
-    if (relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path8.sep}`)) {
+    const relative = path10.relative(path10.resolve(cwd), path10.resolve(value));
+    if (relative.length > 0 && relative !== ".." && !relative.startsWith(`..${path10.sep}`)) {
       return relative.replaceAll("\\", "/");
     }
   }
@@ -22434,8 +22856,8 @@ async function forkGrokSession(input) {
       error: error51("sessionNotFound", "Grok Native Session is unavailable")
     };
   }
-  const sourceCwd = path8.resolve(located.cwd);
-  const targetCwd = path8.resolve(input.cwd);
+  const sourceCwd = path10.resolve(located.cwd);
+  const targetCwd = path10.resolve(input.cwd);
   const source = await readSnapshot({ ...input, cwd: sourceCwd }, sourceRef.data.nativeSessionId);
   if (!source.ok)
     return source;
@@ -22510,9 +22932,10 @@ async function forkGrokSession(input) {
 // dist/grok-compaction.js
 var GROK_SESSION_UPDATE_EXTENSION_METHODS = [
   "_x.ai/session/update",
-  "x.ai/session_notification"
+  "x.ai/session_notification",
+  "_x.ai/session_notification"
 ];
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalNonNegativeInt(value) {
@@ -22533,7 +22956,7 @@ function isGrokExtensionSessionUpdateMethod(method) {
   return GROK_SESSION_UPDATE_EXTENSION_METHODS.includes(method);
 }
 function grokCompactionEventFromUpdate(update) {
-  if (!isRecord8(update) || typeof update.sessionUpdate !== "string")
+  if (!isRecord9(update) || typeof update.sessionUpdate !== "string")
     return null;
   const tokensUsed = optionalNonNegativeInt(firstPresent(update, ["tokensUsed", "tokens_used"]));
   const contextWindowTokens = optionalNonNegativeInt(firstPresent(update, ["contextWindowTokens", "contextWindow", "context_window"]));
@@ -22572,7 +22995,7 @@ function grokCompactionEventFromUpdate(update) {
 // dist/grok-manual-compaction.js
 var GROK_COMPACT_CONVERSATION_METHOD = "x.ai/compact_conversation";
 var GROK_COMPACT_CONVERSATION_FALLBACK_METHOD = "_x.ai/compact_conversation";
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalNonNegativeInt2(value) {
@@ -22584,7 +23007,7 @@ function optionalErrorMessage2(value) {
 function parseGrokCompactResult(value, cancelled = false) {
   if (cancelled)
     return { outcome: "cancelled" };
-  if (!isRecord9(value))
+  if (!isRecord10(value))
     return { outcome: "succeeded" };
   const tokensBefore = optionalNonNegativeInt2(value.tokensBefore ?? value.tokens_before);
   const tokensAfter = optionalNonNegativeInt2(value.tokensAfter ?? value.tokens_after);
@@ -22617,12 +23040,12 @@ function parseGrokCompactResult(value, cancelled = false) {
 }
 
 // dist/grok-rewind.js
-import path9 from "node:path";
+import path11 from "node:path";
 var GROK_REWIND_EXECUTE_METHOD = "_x.ai/rewind/execute";
 function error52(code, message, retryable = false) {
   return { code, message, retryable };
 }
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function buildGrokRewindParams(input) {
@@ -22634,10 +23057,10 @@ function buildGrokRewindParams(input) {
   };
 }
 function parseGrokRewindResponse(value) {
-  if (!isRecord10(value))
+  if (!isRecord11(value))
     return null;
-  const payload = typeof value.success !== "boolean" && isRecord10(value.result) ? value.result : value;
-  if (!isRecord10(payload) || typeof payload.success !== "boolean")
+  const payload = typeof value.success !== "boolean" && isRecord11(value.result) ? value.result : value;
+  if (!isRecord11(payload) || typeof payload.success !== "boolean")
     return null;
   return rewindPayload(payload);
 }
@@ -22690,8 +23113,8 @@ async function rewindGrokLastTurn(input) {
       error: error52("sessionNotFound", "Grok Native Session is unavailable")
     };
   }
-  const sourceCwd = path9.resolve(located.cwd);
-  const targetCwd = path9.resolve(input.cwd);
+  const sourceCwd = path11.resolve(located.cwd);
+  const targetCwd = path11.resolve(input.cwd);
   if (sourceCwd !== targetCwd) {
     return {
       ok: false,
@@ -22794,16 +23217,16 @@ var GrokTransportError = class extends Error {
     this.name = "GrokTransportError";
   }
 };
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function acpToolName(update, metadata) {
-  if (!isRecord11(update))
+  if (!isRecord12(update))
     return void 0;
   if (typeof update.name === "string" && update.name.length > 0)
     return update.name;
-  const meta3 = isRecord11(update._meta) ? update._meta : metadata;
-  const tool = meta3 && isRecord11(meta3["x.ai/tool"]) ? meta3["x.ai/tool"] : void 0;
+  const meta3 = isRecord12(update._meta) ? update._meta : metadata;
+  const tool = meta3 && isRecord12(meta3["x.ai/tool"]) ? meta3["x.ai/tool"] : void 0;
   return tool && typeof tool.name === "string" && tool.name.length > 0 ? tool.name : void 0;
 }
 function errorText(error53) {
@@ -22859,12 +23282,27 @@ function signalProcessTree(child, signal) {
   try {
     process.kill(-child.pid, signal);
   } catch (error53) {
-    if (!isRecord11(error53) || error53.code !== "ESRCH")
+    if (!isRecord12(error53) || error53.code !== "ESRCH")
       throw error53;
   }
 }
 function transportEvent(update, metadata) {
   const extension = update;
+  if (extension.sessionUpdate === "response_completed") {
+    return {
+      type: "response.completed",
+      ...extension.usage !== void 0 ? { usage: extension.usage } : {},
+      ...typeof extension.message_id === "string" && extension.message_id ? { messageId: extension.message_id } : {},
+      ...metadata ? { metadata } : {}
+    };
+  }
+  if (extension.sessionUpdate === "tool_call_delta_chunk" && typeof extension.arguments_delta === "string") {
+    return {
+      type: "tool.input.delta",
+      text: extension.arguments_delta,
+      ...metadata ? { metadata } : {}
+    };
+  }
   if (extension.sessionUpdate === "turn_completed" && typeof extension.prompt_id === "string" && extension.prompt_id.length > 0 && typeof extension.stop_reason === "string") {
     return {
       type: "turn.completed",
@@ -22934,34 +23372,34 @@ function transportEvent(update, metadata) {
 }
 function grokHomeDir(options) {
   const environment = { ...process.env, ...options.environment };
-  const home = environment.HOME ?? environment.USERPROFILE ?? os4.homedir();
-  return environment.GROK_HOME ?? path10.join(home, ".grok");
+  const home = environment.HOME ?? environment.USERPROFILE ?? os5.homedir();
+  return environment.GROK_HOME ?? path12.join(home, ".grok");
 }
 function grokNativeSessionDirectory(options, sessionId) {
-  return path10.join(grokHomeDir(options), "sessions", encodeURIComponent(path10.resolve(options.cwd)), sessionId);
+  return path12.join(grokHomeDir(options), "sessions", encodeURIComponent(path12.resolve(options.cwd)), sessionId);
 }
 function nativeSessionFile(options, sessionId, fileName) {
-  return path10.join(grokNativeSessionDirectory(options, sessionId), fileName);
+  return path12.join(grokNativeSessionDirectory(options, sessionId), fileName);
 }
 function nativeHistoryPath(options, sessionId) {
   return nativeSessionFile(options, sessionId, "updates.jsonl");
 }
 async function readNativeSignals(options, sessionId) {
   try {
-    return JSON.parse(await readFile2(nativeSessionFile(options, sessionId, "signals.json"), "utf8"));
+    return JSON.parse(await readFile3(nativeSessionFile(options, sessionId, "signals.json"), "utf8"));
   } catch {
     return void 0;
   }
 }
 function isMissingFile(error53) {
-  return isRecord11(error53) && error53.code === "ENOENT";
+  return isRecord12(error53) && error53.code === "ENOENT";
 }
 async function locateGrokNativeSession(options, sessionId) {
   if (sessionId.length === 0)
     return null;
   let entries;
   try {
-    entries = await readdir(path10.join(grokHomeDir(options), "sessions"), { withFileTypes: true });
+    entries = await readdir(path12.join(grokHomeDir(options), "sessions"), { withFileTypes: true });
   } catch (error53) {
     if (isMissingFile(error53))
       return null;
@@ -22975,9 +23413,9 @@ async function locateGrokNativeSession(options, sessionId) {
       continue;
     let summaryRaw;
     try {
-      summaryRaw = await readFile2(path10.join(grokHomeDir(options), "sessions", entry.name, sessionId, "summary.json"), "utf8");
+      summaryRaw = await readFile3(path12.join(grokHomeDir(options), "sessions", entry.name, sessionId, "summary.json"), "utf8");
     } catch (error53) {
-      if (isMissingFile(error53) || isRecord11(error53) && error53.code === "ENOTDIR")
+      if (isMissingFile(error53) || isRecord12(error53) && error53.code === "ENOTDIR")
         continue;
       throw new GrokTransportError("unavailable", "Grok Native Session metadata could not be read", {
         cause: error53
@@ -22989,11 +23427,11 @@ async function locateGrokNativeSession(options, sessionId) {
     } catch {
       continue;
     }
-    if (!isRecord11(parsed))
+    if (!isRecord12(parsed))
       continue;
     const info = parsed.info;
-    const cwd = isRecord11(info) && typeof info.cwd === "string" && info.cwd.length > 0 ? path10.resolve(info.cwd) : path10.resolve(decodeURIComponent(entry.name));
-    const sourceWorkspaceDir = typeof parsed.source_workspace_dir === "string" && parsed.source_workspace_dir.length > 0 ? path10.resolve(parsed.source_workspace_dir) : void 0;
+    const cwd = isRecord12(info) && typeof info.cwd === "string" && info.cwd.length > 0 ? path12.resolve(info.cwd) : path12.resolve(decodeURIComponent(entry.name));
+    const sourceWorkspaceDir = typeof parsed.source_workspace_dir === "string" && parsed.source_workspace_dir.length > 0 ? path12.resolve(parsed.source_workspace_dir) : void 0;
     matches.push({
       cwd,
       ...sourceWorkspaceDir ? { sourceWorkspaceDir } : {}
@@ -23003,7 +23441,7 @@ async function locateGrokNativeSession(options, sessionId) {
 }
 async function readGrokNativeHistory(options, sessionId) {
   try {
-    return parseNativeHistory(await readFile2(nativeHistoryPath({ ...options, cwd: path10.resolve(options.cwd) }, sessionId), "utf8"), sessionId);
+    return parseNativeHistory(await readFile3(nativeHistoryPath({ ...options, cwd: path12.resolve(options.cwd) }, sessionId), "utf8"), sessionId);
   } catch (error53) {
     if (isMissingFile(error53))
       return [];
@@ -23025,12 +23463,12 @@ function parseNativeHistory(contents, sessionId) {
     } catch {
       throw new GrokTransportError("protocolError", "Grok Native history contains invalid JSON");
     }
-    if (!isRecord11(record2) || !isRecord11(record2.params))
+    if (!isRecord12(record2) || !isRecord12(record2.params))
       continue;
     const params = record2.params;
-    if (params.sessionId !== sessionId || !isRecord11(params.update))
+    if (params.sessionId !== sessionId || !isRecord12(params.update))
       continue;
-    const metadata = isRecord11(params._meta) ? params._meta : void 0;
+    const metadata = isRecord12(params._meta) ? params._meta : void 0;
     const event = transportEvent(params.update, metadata);
     if (event)
       events.push(metadata ? { ...event, metadata } : event);
@@ -23087,6 +23525,13 @@ var GrokAcpTransport = class {
   async getHistory() {
     return this.readHistory(this.sessionId);
   }
+  /** Native cumulative usage since this process attached, not persisted Session totals. */
+  async getUsage() {
+    if (!this.#connection)
+      throw new GrokTransportError("unavailable", "Grok ACP is unavailable");
+    const result = await withTimeout(this.#connection.request("_x.ai/session/usage", { sessionId: this.sessionId }), this.#options.commandTimeoutMs, "Grok Session usage");
+    return isRecord12(result) ? result.usage : void 0;
+  }
   async readHistory(sessionId, cwd = this.#options.cwd) {
     return readGrokNativeHistory({ ...this.#options, cwd }, sessionId);
   }
@@ -23289,6 +23734,7 @@ var GrokAcpTransport = class {
         prompt: [{ type: "text", text }]
       });
     } finally {
+      await yieldToEventLoop();
       if (this.#activePrompt === active)
         this.#activePrompt = null;
     }
@@ -23327,16 +23773,17 @@ var GrokAcpTransport = class {
         this.#activeCompact = null;
     }
   }
-  async setModel(modelId, reasoningEffort) {
+  async setModel(modelId, reasoningEffort, contextWindowTokens) {
     const connection = this.#connection;
     if (!connection || !this.#sessionId)
       throw new Error("Grok ACP Session is unavailable");
     const response = await connection.request("session/set_model", {
       sessionId: this.#sessionId,
       modelId,
-      ...reasoningEffort ? { reasoningEffort } : {}
+      ...reasoningEffort ? { reasoningEffort } : {},
+      ...contextWindowTokens !== void 0 ? { _meta: { contextWindow: contextWindowTokens } } : {}
     });
-    if (!isRecord11(response) || !isRecord11(response._meta) || !isRecord11(response._meta.model)) {
+    if (!isRecord12(response) || !isRecord12(response._meta) || !isRecord12(response._meta.model)) {
       throw new GrokTransportError("protocolError", "Grok rejected Model configuration");
     }
     const selected = response._meta.model.Ok;
@@ -23388,7 +23835,7 @@ var GrokAcpTransport = class {
       this.#availableCommands = parseGrokAvailableCommands(update.availableCommands);
       return;
     }
-    const metadata = isRecord11(notification._meta) ? notification._meta : void 0;
+    const metadata = isRecord12(notification._meta) ? notification._meta : void 0;
     const event = transportEvent(notification.update, metadata);
     if (!event)
       return;
@@ -23403,7 +23850,7 @@ var GrokAcpTransport = class {
   #handleExtensionNotification(method, params) {
     if (!isGrokExtensionSessionUpdateMethod(method))
       return;
-    if (typeof params.sessionId !== "string" || !isRecord11(params.update))
+    if (typeof params.sessionId !== "string" || !isRecord12(params.update))
       return;
     this.#handleUpdate(params);
   }
@@ -23421,13 +23868,13 @@ var GrokAcpTransport = class {
 };
 
 // dist/session-import.js
-import { createReadStream } from "node:fs";
-import { opendir, readFile as readFile3, stat } from "node:fs/promises";
-import path11 from "node:path";
-import { createInterface } from "node:readline";
+import { createReadStream as createReadStream2 } from "node:fs";
+import { opendir as opendir2, readFile as readFile4, stat } from "node:fs/promises";
+import path13 from "node:path";
+import { createInterface as createInterface2 } from "node:readline";
 
 // ../../harness-adapter/dist/session-import.js
-import { lstat } from "node:fs/promises";
+import { lstat as lstat2 } from "node:fs/promises";
 var SessionImportChangedError = class extends Error {
   constructor(message = "Native Session changed during discovery; refresh and retry") {
     super(message);
@@ -23446,7 +23893,7 @@ function isStorageAccessError(error53) {
 }
 async function optionalLstat(file2) {
   try {
-    return await lstat(file2);
+    return await lstat2(file2);
   } catch (error53) {
     if (isMissingFileError(error53))
       return null;
@@ -23544,11 +23991,11 @@ var SessionImportScope = class {
 // dist/session-import.js
 var MAX_METADATA_BYTES = 4 * 1024 * 1024;
 var SUBAGENT_SESSION_KINDS = /* @__PURE__ */ new Set(["subagent", "subagent_resume"]);
-function isRecord12(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function readJson(file2, signal) {
-  return JSON.parse(await readFile3(file2, { encoding: "utf8", signal }));
+  return JSON.parse(await readFile4(file2, { encoding: "utf8", signal }));
 }
 function processAlive(pid) {
   if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0)
@@ -23557,12 +24004,12 @@ function processAlive(pid) {
     process.kill(pid, 0);
     return true;
   } catch (error53) {
-    return isRecord12(error53) && error53.code === "EPERM";
+    return isRecord13(error53) && error53.code === "EPERM";
   }
 }
 async function firstUserText(file2, signal) {
-  const stream = createReadStream(file2, { encoding: "utf8", signal });
-  const lines = createInterface({ input: stream, crlfDelay: Infinity });
+  const stream = createReadStream2(file2, { encoding: "utf8", signal });
+  const lines = createInterface2({ input: stream, crlfDelay: Infinity });
   try {
     for await (const line of lines) {
       signal.throwIfAborted();
@@ -23574,10 +24021,10 @@ async function firstUserText(file2, signal) {
       } catch {
         continue;
       }
-      const update = isRecord12(entry) && isRecord12(entry.params) ? entry.params.update : null;
-      if (!isRecord12(update) || update.sessionUpdate !== "user_message_chunk")
+      const update = isRecord13(entry) && isRecord13(entry.params) ? entry.params.update : null;
+      if (!isRecord13(update) || update.sessionUpdate !== "user_message_chunk")
         continue;
-      const text = isRecord12(update.content) ? update.content.text : null;
+      const text = isRecord13(update.content) ? update.content.text : null;
       return typeof text === "string" ? text : "";
     }
     return null;
@@ -23644,7 +24091,7 @@ var GrokSessionImport = class {
     const active = /* @__PURE__ */ new Set();
     let entries;
     try {
-      entries = await readJson(path11.join(this.#home(), "active_sessions.json"), signal);
+      entries = await readJson(path13.join(this.#home(), "active_sessions.json"), signal);
     } catch (error53) {
       signal.throwIfAborted();
       if (isStorageAccessError(error53))
@@ -23654,26 +24101,26 @@ var GrokSessionImport = class {
     if (!Array.isArray(entries))
       return active;
     for (const entry of entries) {
-      if (isRecord12(entry) && typeof entry.session_id === "string" && processAlive(entry.pid))
+      if (isRecord13(entry) && typeof entry.session_id === "string" && processAlive(entry.pid))
         active.add(entry.session_id);
     }
     return active;
   }
   /** Session ID to every directory claiming it. Enumerated links are not followed. */
   async #sessionDirectories(signal) {
-    const root = path11.join(this.#home(), "sessions");
+    const root = path13.join(this.#home(), "sessions");
     const found = /* @__PURE__ */ new Map();
     const info = await optionalLstat(root);
     if (!info)
       return found;
     if (!info.isDirectory())
       throw new Error("Grok Session store is not a directory");
-    for await (const workspace of await opendir(root)) {
+    for await (const workspace of await opendir2(root)) {
       signal.throwIfAborted();
       if (!workspace.isDirectory())
         continue;
-      const workspaceDirectory = path11.join(root, workspace.name);
-      const sessions = await opendir(workspaceDirectory).catch((error53) => {
+      const workspaceDirectory = path13.join(root, workspace.name);
+      const sessions = await opendir2(workspaceDirectory).catch((error53) => {
         if (isMissingFileError(error53))
           return null;
         throw error53;
@@ -23685,7 +24132,7 @@ var GrokSessionImport = class {
         if (!session.isDirectory())
           continue;
         const directories = found.get(session.name) ?? [];
-        directories.push(path11.join(workspaceDirectory, session.name));
+        directories.push(path13.join(workspaceDirectory, session.name));
         found.set(session.name, directories);
       }
     }
@@ -23693,25 +24140,25 @@ var GrokSessionImport = class {
   }
   async #candidate(sessionDirectory, active, signal) {
     signal.throwIfAborted();
-    const nativeSessionId = path11.basename(sessionDirectory);
+    const nativeSessionId = path13.basename(sessionDirectory);
     const files = [
-      path11.join(sessionDirectory, "summary.json"),
-      path11.join(sessionDirectory, "updates.jsonl")
+      path13.join(sessionDirectory, "summary.json"),
+      path13.join(sessionDirectory, "updates.jsonl")
     ];
     return readStableFiles(files, async ([summaryInfo, updates]) => {
       if (!summaryInfo?.isFile() || !updates?.isFile() || summaryInfo.size > MAX_METADATA_BYTES)
         return null;
       try {
         const summary = await readJson(files[0], signal);
-        if (!isRecord12(summary) || !isRecord12(summary.info) || summary.info.id !== nativeSessionId)
+        if (!isRecord13(summary) || !isRecord13(summary.info) || summary.info.id !== nativeSessionId)
           return null;
         if (typeof summary.session_kind === "string" && SUBAGENT_SESSION_KINDS.has(summary.session_kind))
           return null;
         const nativeCwd = summary.info.cwd;
-        if (typeof nativeCwd !== "string" || !path11.isAbsolute(nativeCwd) || nativeCwd.includes("\0"))
+        if (typeof nativeCwd !== "string" || !path13.isAbsolute(nativeCwd) || nativeCwd.includes("\0"))
           return null;
-        const cwd = path11.resolve(nativeCwd);
-        if (encodeURIComponent(cwd) !== path11.basename(path11.dirname(sessionDirectory)))
+        const cwd = path13.resolve(nativeCwd);
+        if (encodeURIComponent(cwd) !== path13.basename(path13.dirname(sessionDirectory)))
           return null;
         if (!(await stat(cwd)).isDirectory())
           return null;
@@ -23930,7 +24377,7 @@ var GrokSubagentLifecycle = class {
 };
 
 // dist/grok-models.js
-function isRecord13(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonBlank(value) {
@@ -23942,7 +24389,7 @@ function thinkingOptions(value) {
   const seen = /* @__PURE__ */ new Set();
   const options = [];
   for (const candidate of value) {
-    if (!isRecord13(candidate) || !nonBlank(candidate.label))
+    if (!isRecord14(candidate) || !nonBlank(candidate.label))
       continue;
     const id = harnessThinkingOptionIdSchema.safeParse(candidate.id ?? candidate.value);
     if (!id.success || seen.has(id.data))
@@ -23953,7 +24400,7 @@ function thinkingOptions(value) {
   return options;
 }
 function parseGrokModelState(value) {
-  if (!isRecord13(value) || !nonBlank(value.currentModelId) || !Array.isArray(value.availableModels)) {
+  if (!isRecord14(value) || !nonBlank(value.currentModelId) || !Array.isArray(value.availableModels)) {
     return null;
   }
   const currentModel = harnessModelRefSchema.safeParse({ id: value.currentModelId });
@@ -23961,16 +24408,20 @@ function parseGrokModelState(value) {
     return null;
   const allThinking = /* @__PURE__ */ new Map();
   const contextWindowTokensByModel = /* @__PURE__ */ new Map();
+  const defaultContextWindowTokensByModel = /* @__PURE__ */ new Map();
   const models = [];
   let currentThinkingOptionId;
   for (const candidate of value.availableModels) {
-    if (!isRecord13(candidate) || !nonBlank(candidate.modelId) || !nonBlank(candidate.name))
+    if (!isRecord14(candidate) || !nonBlank(candidate.modelId) || !nonBlank(candidate.name))
       continue;
     const ref = harnessModelRefSchema.safeParse({ id: candidate.modelId });
     if (!ref.success)
       continue;
-    const metadata = isRecord13(candidate._meta) ? candidate._meta : {};
+    const metadata = isRecord14(candidate._meta) ? candidate._meta : {};
     const options2 = thinkingOptions(metadata.reasoningEfforts);
+    if (Array.isArray(metadata.contextWindows) && metadata.contextWindows.includes(5e5)) {
+      defaultContextWindowTokensByModel.set(ref.data.id, 5e5);
+    }
     if (typeof metadata.totalContextTokens === "number" && Number.isSafeInteger(metadata.totalContextTokens) && metadata.totalContextTokens > 0) {
       contextWindowTokensByModel.set(ref.data.id, metadata.totalContextTokens);
     }
@@ -23994,6 +24445,7 @@ function parseGrokModelState(value) {
   return {
     currentModel: currentModel.data,
     contextWindowTokensByModel,
+    defaultContextWindowTokensByModel,
     ...currentThinkingOptionId ? { currentThinkingOptionId } : {},
     catalog: {
       models,
@@ -24004,13 +24456,13 @@ function parseGrokModelState(value) {
   };
 }
 function modelStateFromInitialize(response) {
-  return parseGrokModelState(isRecord13(response._meta) ? response._meta.modelState : void 0);
+  return parseGrokModelState(isRecord14(response._meta) ? response._meta.modelState : void 0);
 }
 function modelStateFromSessionResponse(response) {
-  return parseGrokModelState(isRecord13(response) ? response.models : void 0);
+  return parseGrokModelState(isRecord14(response) ? response.models : void 0);
 }
-function stateForGrokModel(modelState, nativeState, model = modelState.currentModel, thinkingOptionId = modelState.currentThinkingOptionId, permissionModeId) {
-  const selectedModel = model;
+function stateForGrokModel(modelState, nativeState, model2 = modelState.currentModel, thinkingOptionId = modelState.currentThinkingOptionId, permissionModeId) {
+  const selectedModel = model2;
   const catalogModel = modelState.catalog.models.find(({ ref }) => ref.id === selectedModel.id);
   const availableThinkingOptions = catalogModel?.supportedThinkingOptionIds?.flatMap((id) => {
     const option = modelState.catalog.thinkingOptions.find((candidate) => candidate.id === id);
@@ -24026,12 +24478,12 @@ function stateForGrokModel(modelState, nativeState, model = modelState.currentMo
 }
 
 // dist/grok-credits.js
-import { readFile as readFile4 } from "node:fs/promises";
-import os5 from "node:os";
-import path12 from "node:path";
+import { readFile as readFile5 } from "node:fs/promises";
+import os6 from "node:os";
+import path14 from "node:path";
 var GROK_CREDITS_ENDPOINT = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
 var REQUEST_TIMEOUT_MS = 15e3;
-function isRecord14(value) {
+function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function finitePercent(value) {
@@ -24040,15 +24492,15 @@ function finitePercent(value) {
   return Math.min(100, Math.max(0, value));
 }
 function nonNegativeCentValue(value) {
-  if (!isRecord14(value))
+  if (!isRecord15(value))
     return void 0;
   const amount = value.val === void 0 ? 0 : value.val;
   if (typeof amount !== "number" || !Number.isFinite(amount) || amount < 0)
     return void 0;
   return amount;
 }
-function grokHome(environment) {
-  return environment.GROK_HOME ?? path12.join(environment.HOME ?? environment.USERPROFILE ?? os5.homedir(), ".grok");
+function grokHome2(environment) {
+  return environment.GROK_HOME ?? path14.join(environment.HOME ?? environment.USERPROFILE ?? os6.homedir(), ".grok");
 }
 function periodTypeFrom(value) {
   if (typeof value !== "string")
@@ -24064,7 +24516,7 @@ function productUsageFrom(value) {
   if (!Array.isArray(value))
     return void 0;
   const products = value.flatMap((entry) => {
-    if (!isRecord14(entry) || typeof entry.product !== "string")
+    if (!isRecord15(entry) || typeof entry.product !== "string")
       return [];
     const usagePercent = finitePercent(entry.usagePercent);
     return usagePercent === void 0 ? [] : [{ product: entry.product, usagePercent }];
@@ -24072,10 +24524,10 @@ function productUsageFrom(value) {
   return products.length > 0 ? products : void 0;
 }
 function parseGrokCreditsResponse(value, fetchedAt = (/* @__PURE__ */ new Date()).toISOString()) {
-  if (!isRecord14(value) || !isRecord14(value.config))
+  if (!isRecord15(value) || !isRecord15(value.config))
     return null;
   const config2 = value.config;
-  const period = isRecord14(config2.currentPeriod) ? config2.currentPeriod : void 0;
+  const period = isRecord15(config2.currentPeriod) ? config2.currentPeriod : void 0;
   const periodType = periodTypeFrom(period?.type);
   const resetsAt = (typeof period?.end === "string" && period.end.length > 0 ? period.end : void 0) ?? (typeof config2.billingPeriodEnd === "string" && config2.billingPeriodEnd.length > 0 ? config2.billingPeriodEnd : void 0);
   let usedPercent = finitePercent(config2.creditUsagePercent);
@@ -24102,11 +24554,11 @@ function parseGrokCreditsResponse(value, fetchedAt = (/* @__PURE__ */ new Date()
   };
 }
 function selectAccessToken(auth, now) {
-  if (!isRecord14(auth))
+  if (!isRecord15(auth))
     return null;
-  const entries = Object.entries(auth).filter(([issuer, value]) => (issuer === "https://auth.x.ai" || issuer.startsWith("https://auth.x.ai::")) && isRecord14(value) && typeof value.key === "string" && value.key.length > 0).sort(([left], [right]) => Number(right.startsWith("https://auth.x.ai")) - Number(left.startsWith("https://auth.x.ai")));
+  const entries = Object.entries(auth).filter(([issuer, value]) => (issuer === "https://auth.x.ai" || issuer.startsWith("https://auth.x.ai::")) && isRecord15(value) && typeof value.key === "string" && value.key.length > 0).sort(([left], [right]) => Number(right.startsWith("https://auth.x.ai")) - Number(left.startsWith("https://auth.x.ai")));
   for (const [, value] of entries) {
-    if (!isRecord14(value) || typeof value.key !== "string")
+    if (!isRecord15(value) || typeof value.key !== "string")
       continue;
     if (typeof value.expires_at === "string") {
       const expiresAt = Date.parse(value.expires_at);
@@ -24127,8 +24579,8 @@ async function fetchGrokAccount(input = {}) {
     if ([environment.XAI_API_KEY, environment.GROK_API_KEY, environment.GROK_TOKEN].some((value) => value?.trim()))
       return null;
     const now = input.now ?? /* @__PURE__ */ new Date();
-    const authPath = path12.join(grokHome(environment), "auth.json");
-    const raw = input.readAuthFile ? await input.readAuthFile(authPath) : await readFile4(authPath, "utf8");
+    const authPath = path14.join(grokHome2(environment), "auth.json");
+    const raw = input.readAuthFile ? await input.readAuthFile(authPath) : await readFile5(authPath, "utf8");
     const token = selectAccessToken(JSON.parse(raw), now);
     if (!token)
       return null;
@@ -24177,7 +24629,7 @@ async function fetchGrokCredits(input = {}) {
 
 // dist/grok-usage.js
 var USD_TICKS_PER_DOLLAR = 1e10;
-function isRecord15(value) {
+function isRecord16(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalToken(value) {
@@ -24194,7 +24646,7 @@ function combineUsage(base, next) {
   return base === null ? next : parseHostUsage({ ...base, ...next });
 }
 function usageFromNative(value) {
-  if (!isRecord15(value))
+  if (!isRecord16(value))
     return null;
   const inputTokens = optionalToken(value.inputTokens);
   const cachedRead = optionalToken(value.cachedReadTokens);
@@ -24217,11 +24669,108 @@ function usageFromNative(value) {
     return null;
   }
 }
-function usageFromPrompt(response) {
-  return response.usage ? usageFromNative(response.usage) : null;
+function usageFromResponse(value) {
+  if (!isRecord16(value))
+    return null;
+  const buckets = [
+    value.input_tokens,
+    value.cache_read_input_tokens,
+    value.cache_creation_input_tokens
+  ];
+  const inputTokens = buckets.every((n) => typeof n === "number" && Number.isSafeInteger(n) && n >= 0) ? buckets.reduce((sum, n) => sum + n, 0) : void 0;
+  const outputTokens = optionalToken(value.output_tokens);
+  return usageFromNative({
+    inputTokens,
+    outputTokens,
+    cachedReadTokens: value.cache_read_input_tokens,
+    cacheCreationTokens: value.cache_creation_input_tokens,
+    reasoningTokens: value.reasoning_tokens,
+    ...inputTokens !== void 0 && outputTokens !== void 0 ? { totalTokens: inputTokens + outputTokens } : {}
+  });
 }
+var GrokTurnUsage = class {
+  #totals = {};
+  #seen = /* @__PURE__ */ new Set();
+  #cacheComplete;
+  #compacting = false;
+  #startedAtMs;
+  #streamKey;
+  #outputTokens = 0;
+  #durationMs = 0;
+  #latestCacheHit;
+  constructor(base, emptySession = false) {
+    for (const field of summedUsageFields) {
+      const value = base?.[field];
+      if (value !== void 0)
+        this.#totals[field] = value;
+    }
+    this.#cacheComplete = base?.sessionCacheUsage !== void 0 || emptySession;
+  }
+  observe(event) {
+    if (event.type === "compaction.started" || event.type === "compaction.completed") {
+      this.#startedAtMs = void 0;
+      this.#streamKey = void 0;
+      this.#compacting = event.type === "compaction.started";
+    }
+    if (this.#compacting)
+      return null;
+    if (event.type === "subagent.spawned")
+      this.#cacheComplete = false;
+    if (event.type === "agent.text" || event.type === "agent.thought" || event.type === "tool.input.delta") {
+      if (!event.text)
+        return null;
+      const key = event.metadata?.streamStartMs;
+      if (key !== void 0 && this.#streamKey !== void 0 && key !== this.#streamKey)
+        this.#startedAtMs = void 0;
+      if (key !== void 0)
+        this.#streamKey = key;
+      this.#startedAtMs ??= Date.now();
+    }
+    if (event.type !== "response.completed")
+      return null;
+    if (event.messageId) {
+      if (this.#seen.has(event.messageId))
+        return null;
+      this.#seen.add(event.messageId);
+    }
+    const duration3 = this.#startedAtMs === void 0 ? 0 : Date.now() - this.#startedAtMs;
+    this.#startedAtMs = void 0;
+    this.#streamKey = void 0;
+    const usage = usageFromResponse(event.usage);
+    this.#latestCacheHit = usage?.cacheHitRatePercent;
+    if (usage?.inputTokens === void 0 || usage.cachedInputTokens === void 0)
+      this.#cacheComplete = false;
+    if (usage) {
+      for (const field of summedUsageFields) {
+        const value = usage[field];
+        if (value !== void 0)
+          this.#totals[field] = (this.#totals[field] ?? 0) + value;
+      }
+      if (duration3 > 0 && usage.outputTokens !== void 0) {
+        this.#outputTokens += usage.outputTokens;
+        this.#durationMs += duration3;
+      }
+    }
+    return this.snapshot();
+  }
+  metrics() {
+    return {
+      ...this.#durationMs > 0 ? { outputTokensPerSecond: this.#outputTokens * 1e3 / this.#durationMs } : {},
+      ...this.#latestCacheHit !== void 0 ? { cacheHitRatePercent: this.#latestCacheHit } : {}
+    };
+  }
+  snapshot() {
+    const inputTokens = this.#totals.inputTokens;
+    const cachedInputTokens = this.#totals.cachedInputTokens;
+    return {
+      ...this.#totals,
+      ...this.metrics(),
+      ...this.#cacheComplete && inputTokens !== void 0 && cachedInputTokens !== void 0 ? { sessionCacheUsage: { inputTokens, cachedInputTokens } } : {}
+    };
+  }
+};
 function usageFromSignals(value) {
-  if (!isRecord15(value))
+  if (!isRecord16(value))
     return null;
   try {
     return parseHostUsage({
@@ -24241,13 +24790,23 @@ var summedUsageFields = [
   "totalTokens"
 ];
 function nativeCostTicks(value) {
-  if (!isRecord15(value))
+  if (!isRecord16(value))
     return void 0;
   const ticks = value.costUsdTicks;
   if (typeof ticks !== "number" || !Number.isSafeInteger(ticks) || ticks < 0)
     return void 0;
   return ticks;
 }
+function sessionCostFromNative(value, initialCostUsd) {
+  if (!isRecord16(value))
+    return void 0;
+  if (value.costIsPartial !== void 0 && value.costIsPartial !== false)
+    return void 0;
+  if (value.usageIsIncomplete !== void 0 && value.usageIsIncomplete !== false)
+    return void 0;
+  const ticks = nativeCostTicks(value);
+  return ticks === void 0 ? void 0 : optionalCostUsd(Math.round(initialCostUsd * USD_TICKS_PER_DOLLAR) + ticks);
+}
 function historyTurnKey(event, index) {
   const key = event.nativeTurnKey;
   if (typeof key === "string" && key.startsWith("task-completed-"))
@@ -24256,7 +24815,6 @@ function historyTurnKey(event, index) {
 }
 function sessionUsageFromHistory(events) {
   const latestByKey = /* @__PURE__ */ new Map();
-  let lastCacheHitRatePercent;
   let index = 0;
   for (const event of events) {
     if (event?.type !== "turn.completed")
@@ -24265,26 +24823,26 @@ function sessionUsageFromHistory(events) {
     index += 1;
     if (key === null)
       continue;
-    const usage = usageFromNative(event.usage);
-    if (!usage)
+    if (event.usage === void 0 && latestByKey.has(key))
       continue;
+    const usage = usageFromNative(event.usage);
     const ticks2 = nativeCostTicks(event.usage);
-    latestByKey.set(key, ticks2 === void 0 ? { usage } : { usage, ticks: ticks2 });
-    if (usage.cacheHitRatePercent !== void 0) {
-      lastCacheHitRatePercent = usage.cacheHitRatePercent;
-    }
+    const complete = isRecord16(event.usage) && (event.usage.usageIsIncomplete === void 0 || event.usage.usageIsIncomplete === false) && usage?.inputTokens !== void 0 && usage.cachedInputTokens !== void 0 && usage.cachedInputTokens <= usage.inputTokens;
+    latestByKey.set(key, { usage, complete, ...ticks2 !== void 0 ? { ticks: ticks2 } : {} });
   }
   if (latestByKey.size === 0)
     return null;
-  const totals = {};
+  const totals2 = {};
   let ticks = 0;
   let hasTicks = false;
   for (const entry of latestByKey.values()) {
+    if (!entry.usage)
+      continue;
     for (const field of summedUsageFields) {
       const value = entry.usage[field];
       if (value === void 0)
         continue;
-      totals[field] = (totals[field] ?? 0) + value;
+      totals2[field] = (totals2[field] ?? 0) + value;
     }
     if (entry.ticks === void 0)
       continue;
@@ -24294,9 +24852,14 @@ function sessionUsageFromHistory(events) {
   const totalCostUsd = hasTicks ? optionalCostUsd(ticks) : void 0;
   try {
     return parseHostUsage({
-      ...totals,
+      ...totals2,
       ...totalCostUsd !== void 0 ? { totalCostUsd } : {},
-      ...lastCacheHitRatePercent !== void 0 ? { cacheHitRatePercent: lastCacheHitRatePercent } : {}
+      ...[...latestByKey.values()].every((entry) => entry.complete) && totals2.inputTokens !== void 0 && totals2.cachedInputTokens !== void 0 ? {
+        sessionCacheUsage: {
+          inputTokens: totals2.inputTokens,
+          cachedInputTokens: totals2.cachedInputTokens
+        }
+      } : {}
     });
   } catch {
     return null;
@@ -24318,7 +24881,7 @@ function usageFromCompact(tokensAfter, contextWindowTokens) {
 function usageFromUpdate(update, metadata, contextWindowTokens) {
   try {
     if (update?.sessionUpdate === "usage_update") {
-      const cost = isRecord15(update.cost) ? update.cost : null;
+      const cost = isRecord16(update.cost) ? update.cost : null;
       return parseHostUsage({
         contextUsedTokens: update.used,
         contextWindowTokens: update.size,
@@ -24449,6 +25012,8 @@ var GrokHarnessSession = class {
   #phase = "open";
   #state;
   #usage = null;
+  #initialCostUsd;
+  #costRequest = 0;
   constructor(cwd, transport, opened, modelState, onClosed, options) {
     this.#cwd = cwd;
     this.#sessionDirectory = options.sessionDirectory;
@@ -24462,6 +25027,7 @@ var GrokHarnessSession = class {
     this.#toolOutputLimit = options.toolOutputLimit;
     this.initialUsage = options.initialUsage ?? null;
     this.#usage = this.initialUsage;
+    this.#initialCostUsd = this.initialUsage?.totalCostUsd ?? 0;
     this.capabilities = capabilitiesForModels(modelState);
     this.commands = {
       list: async () => ({ ok: true, value: this.#liveCommandCatalog() }),
@@ -24550,6 +25116,7 @@ var GrokHarnessSession = class {
     });
     const active = {
       command,
+      usage: new GrokTurnUsage(this.#usage, this.#snapshot.turns.length === 0),
       agent: null,
       agentMessageId: null,
       rawAgentText: "",
@@ -24725,9 +25292,9 @@ var GrokHarnessSession = class {
   }
   async #selectThinking(command) {
     const parsed = harnessThinkingOptionIdSchema.safeParse(command.thinkingOptionId);
-    const model = this.#state.effectiveModel;
-    const available = this.#modelState.catalog.models.find(({ ref }) => ref.id === model?.id);
-    if (!parsed.success || !model || !available?.supportedThinkingOptionIds?.includes(parsed.data)) {
+    const model2 = this.#state.effectiveModel;
+    const available = this.#modelState.catalog.models.find(({ ref }) => ref.id === model2?.id);
+    if (!parsed.success || !model2 || !available?.supportedThinkingOptionIds?.includes(parsed.data)) {
       return {
         ok: false,
         error: {
@@ -24737,9 +25304,9 @@ var GrokHarnessSession = class {
         }
       };
     }
-    return this.#configure(model, parsed.data);
+    return this.#configure(model2, parsed.data);
   }
-  async #configure(model, thinkingOptionId) {
+  async #configure(model2, thinkingOptionId) {
     if (this.#configuring) {
       return {
         ok: false,
@@ -24752,9 +25319,20 @@ var GrokHarnessSession = class {
     }
     this.#configuring = true;
     try {
-      await this.#transport.setModel(model.id, thinkingOptionId);
-      this.#state = stateForGrokModel(this.#modelState, { nativeRef: nativeRef(this.#transport.sessionId) }, model, thinkingOptionId, this.#state.effectivePermissionModeId);
+      const contextWindow = this.#modelState.defaultContextWindowTokensByModel.get(model2.id);
+      await this.#transport.setModel(model2.id, thinkingOptionId, contextWindow);
+      if (contextWindow !== void 0) {
+        this.#modelState.contextWindowTokensByModel = new Map([
+          ...this.#modelState.contextWindowTokensByModel,
+          [model2.id, contextWindow]
+        ]);
+      }
+      this.#state = stateForGrokModel(this.#modelState, { nativeRef: nativeRef(this.#transport.sessionId) }, model2, thinkingOptionId, this.#state.effectivePermissionModeId);
       this.#event({ type: "session.state.changed", state: this.#state });
+      const selectedWindow = this.#modelState.contextWindowTokensByModel.get(model2.id);
+      if (selectedWindow !== void 0 && this.#usage?.contextUsedTokens !== void 0) {
+        this.#publishUsage({ contextWindowTokens: selectedWindow });
+      }
       return { ok: true, value: { completed: true } };
     } catch (error53) {
       return { ok: false, error: normalizeError(error53, "nativeFailure") };
@@ -24867,6 +25445,11 @@ var GrokHarnessSession = class {
   #handleEvent(active, event) {
     if (this.#active !== active || this.#phase !== "open")
       return;
+    const requestUsage = active.usage?.observe(event);
+    if (requestUsage) {
+      this.#publishUsage(requestUsage, active.command.turnId, true);
+      void this.#refreshCost(active);
+    }
     const contextUsage = usageFromUpdate(event.type === "usage" ? event.update : void 0, event.metadata, this.#state.effectiveModel ? this.#modelState.contextWindowTokensByModel.get(this.#state.effectiveModel.id) : void 0);
     if (contextUsage)
       this.#publishUsage(contextUsage, active.command.turnId);
@@ -24890,6 +25473,17 @@ var GrokHarnessSession = class {
     } else if (event.type === "usage" || event.type === "turn.completed")
       return;
   }
+  async #refreshCost(active) {
+    const request = ++this.#costRequest;
+    try {
+      const totalCostUsd = sessionCostFromNative(await this.#transport.getUsage(), this.#initialCostUsd);
+      if (this.#active !== active || this.#phase !== "open" || request !== this.#costRequest)
+        return;
+      if (totalCostUsd !== void 0)
+        this.#publishUsage({ totalCostUsd }, active.command.turnId);
+    } catch {
+    }
+  }
   #startCompaction(active, event) {
     if (active.compactionItem)
       return;
@@ -25002,14 +25596,14 @@ var GrokHarnessSession = class {
       const prompt = grokSubagentPrompt(event.rawInput);
       const role = grokSubagentRole(event.rawInput);
       const nativeSubagentId = grokNativeSubagentId(event.rawInput);
-      const model = grokSubagentModel(event.rawInput);
+      const model2 = grokSubagentModel(event.rawInput);
       active.subagents.start(active.command.turnId, {
         callId: event.callId,
         operation,
         description: grokSubagentDescription(event.rawInput, event.title),
         ...prompt ? { prompt } : {},
         ...role ? { role } : {},
-        ...model ? { model } : {},
+        ...model2 ? { model: model2 } : {},
         background: grokSubagentBackground(event.rawInput),
         ...nativeSubagentId ? { nativeSubagentId } : {}
       });
@@ -25234,8 +25828,18 @@ var GrokHarnessSession = class {
         outcome = { status: "failed", error: normalizeError(error53, "protocolError") };
       }
     }
+    const promptUsage = response?.usage ?? response?._meta?.usage;
+    if (nativeTurnRef && promptUsage !== void 0 && !history.some((event) => event.type === "turn.completed" && event.nativeTurnKey === nativeTurnRef.nativeTurnKey && event.usage !== void 0)) {
+      history.push({
+        type: "turn.completed",
+        nativeTurnKey: nativeTurnRef.nativeTurnKey,
+        stopReason: response?.stopReason ?? "end_turn",
+        usage: promptUsage
+      });
+    }
+    const usage = sessionUsageFromHistory(history);
     await this.#refreshCredits().catch(() => void 0);
-    this.#finish(active, checkpoint ? { ...outcome, checkpoint } : outcome, sessionUsageFromHistory(history) ?? (response ? usageFromPrompt(response) : null), nativeTurnRef);
+    this.#finish(active, checkpoint ? { ...outcome, checkpoint } : outcome, usage, nativeTurnRef);
   }
   #finish(active, outcome, usage = null, nativeTurnRef) {
     if (this.#active !== active)
@@ -25262,8 +25866,8 @@ var GrokHarnessSession = class {
       });
     }
     this.#active = null;
-    if (usage)
-      this.#publishUsage(usage, active.command.turnId);
+    if (usage || this.#usage)
+      this.#publishUsage({ ...usage, ...active.usage?.metrics() }, active.command.turnId, true);
     this.#event({
       type: "turn.completed",
       turnId: active.command.turnId,
@@ -25272,8 +25876,14 @@ var GrokHarnessSession = class {
     });
     active.resolveCompletion();
   }
-  #publishUsage(usage, observedForTurnId) {
-    const merged = combineUsage(this.#usage, usage);
+  #publishUsage(usage, observedForTurnId, replaceMetrics = false) {
+    const base = this.#usage ? { ...this.#usage } : null;
+    if (base && replaceMetrics) {
+      delete base.outputTokensPerSecond;
+      delete base.cacheHitRatePercent;
+      delete base.sessionCacheUsage;
+    }
+    const merged = combineUsage(base, usage);
     if (merged === null || JSON.stringify(merged) === JSON.stringify(this.#usage))
       return;
     this.#usage = merged;
@@ -25331,6 +25941,7 @@ var GrokAdapter = class {
   liveCommandCatalog = true;
   harnessId = grokHarnessId;
   sessionImport;
+  usageStatistics;
   subagents = {
     readSnapshot: async (input) => {
       if (input.parent.harnessId !== this.harnessId || input.nativeSubagentId.trim().length === 0) {
@@ -25379,6 +25990,7 @@ var GrokAdapter = class {
     this.#closeTimeoutMs = options.closeTimeoutMs ?? DEFAULT_CLOSE_TIMEOUT_MS;
     this.#environment = options.environment;
     this.sessionImport = new GrokSessionImport(options.environment);
+    this.usageStatistics = createGrokUsageStatistics(options.environment ?? process.env);
     this.#toolOutputLimit = options.toolOutputLimit ?? DEFAULT_GROK_TOOL_OUTPUT_LIMIT;
     this.#dependencies = dependencies ?? {
       randomUUID,
@@ -25422,7 +26034,7 @@ var GrokAdapter = class {
   async inspect(input = {}) {
     if (this.#closePromise)
       return { status: "unavailable", error: invalidState("Grok Adapter is closed") };
-    const cwd = path13.resolve(input.cwd ?? process.cwd());
+    const cwd = path15.resolve(input.cwd ?? process.cwd());
     if (!input.refresh) {
       const cached2 = this.#inspectionCache.get(cwd);
       if (cached2)
@@ -25484,7 +26096,7 @@ var GrokAdapter = class {
         }
       };
     }
-    const cwd = path13.resolve(input.cwd);
+    const cwd = path15.resolve(input.cwd);
     const parsedRef = input.kind === "resume" ? nativeSessionRefSchema.safeParse(input.nativeRef) : null;
     if (parsedRef && (!parsedRef.success || parsedRef.data.harnessId !== this.harnessId)) {
       return {
@@ -25588,6 +26200,8 @@ var GrokAdapter = class {
       const modelState = modelStateFromSessionResponse(opened.session) ?? modelStateFromInitialize(opened.initialize);
       if (!modelState)
         throw new GrokTransportError("protocolError", "Grok returned an invalid Model catalog");
+      const nativeModelId = modelState.currentModel.id;
+      const nativeThinkingOptionId = modelState.currentThinkingOptionId;
       const retainedConfiguration = sourceConfiguration;
       if ((input.kind === "rollbackLastTurn" || input.kind === "fork") && retainedConfiguration) {
         const operation = input.kind === "rollbackLastTurn" ? "Rewind" : "Fork";
@@ -25600,7 +26214,6 @@ var GrokAdapter = class {
           throw new GrokTransportError("protocolError", `Grok Thinking option is unavailable after ${operation}`);
         }
         if (retainedConfiguration.model.id !== modelState.currentModel.id || retainedConfiguration.thinkingOptionId !== modelState.currentThinkingOptionId) {
-          await transport.setModel(retainedConfiguration.model.id, retainedConfiguration.thinkingOptionId);
           modelState.currentModel = retainedConfiguration.model;
           if (retainedConfiguration.thinkingOptionId) {
             modelState.currentThinkingOptionId = retainedConfiguration.thinkingOptionId;
@@ -25619,7 +26232,6 @@ var GrokAdapter = class {
           throw new GrokTransportError("protocolError", "Requested Grok Thinking option is unavailable");
         }
         if (selectedModel.id !== modelState.currentModel.id || selectedThinking !== modelState.currentThinkingOptionId) {
-          await transport.setModel(selectedModel.id, selectedThinking);
           modelState.currentModel = selectedModel;
           if (selectedThinking)
             modelState.currentThinkingOptionId = selectedThinking;
@@ -25627,8 +26239,21 @@ var GrokAdapter = class {
             delete modelState.currentThinkingOptionId;
         }
       }
+      const contextWindow = modelState.defaultContextWindowTokensByModel.get(modelState.currentModel.id);
+      if (modelState.currentModel.id !== nativeModelId || modelState.currentThinkingOptionId !== nativeThinkingOptionId || contextWindow !== void 0 && modelState.contextWindowTokensByModel.get(modelState.currentModel.id) !== contextWindow) {
+        await transport.setModel(modelState.currentModel.id, modelState.currentThinkingOptionId, contextWindow);
+        if (contextWindow !== void 0) {
+          modelState.contextWindowTokensByModel = new Map([
+            ...modelState.contextWindowTokensByModel,
+            [modelState.currentModel.id, contextWindow]
+          ]);
+        }
+      }
       const history = await transport.getHistory();
-      const initialUsage = input.kind === "resume" || input.kind === "fork" || input.kind === "rollbackLastTurn" ? combineUsage(sessionUsageFromHistory(history), usageFromSignals(opened.signals)) : null;
+      let initialUsage = input.kind === "resume" || input.kind === "fork" || input.kind === "rollbackLastTurn" ? combineUsage(sessionUsageFromHistory(history), usageFromSignals(opened.signals)) : null;
+      if (contextWindow !== void 0 && initialUsage?.contextUsedTokens !== void 0) {
+        initialUsage = combineUsage(initialUsage, { contextWindowTokens: contextWindow });
+      }
       const environment = input.environment ?? this.#environment;
       const sessionDirectory = grokNativeSessionDirectory(environment ? { cwd, environment } : { cwd }, opened.sessionId);
       const openedSession = new GrokHarnessSession(cwd, transport, opened, modelState, () => this.#sessions.delete(openedSession), {