@codexhost/cli-darwin-x64 0.13.0 → 0.13.2

package/app/plugins/codex-usage/plugin.mjs

@@ -14676,6 +14676,8 @@ var usageStatisticsSessionSchema = external_exports.strictObject({
   harness,
   sessionId: external_exports.string().min(1).max(512),
   project: project.nullable(),
+  /** Persisted Desktop title for a mapped Session, otherwise its native name; may be absent. */
+  title: external_exports.string().min(1).max(200).optional(),
   /** Models the session used, most requests first. */
   models: external_exports.array(model).max(16),
   firstAtMs: count,
@@ -14742,7 +14744,12 @@ var usageStatisticsResultSchema = external_exports.strictObject({
    * 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)
+  sessions: external_exports.array(usageStatisticsSessionSchema).max(100),
+  /**
+   * The sessions last active in the range, newest first, all filters applied. Optional for older
+   * Hosts; missing is treated as no list rather than no sessions.
+   */
+  recentSessions: external_exports.array(usageStatisticsSessionSchema).max(100).optional()
 });
 
 // ../../shared-contracts/dist/ids.js
@@ -15862,8 +15869,24 @@ import path from "node:path";
 import { setImmediate as yieldToEventLoop } from "node:timers/promises";
 
 // ../../harness-adapter/dist/usage-statistics.js
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
 var MAX_SESSION_ID_LENGTH = 512;
 var MAX_CWD_LENGTH = 4096;
+var MAX_SESSION_TITLE_LENGTH = 200;
+function usageSessionTitle(value) {
+  if (typeof value !== "string")
+    return void 0;
+  const normalized = value.replaceAll("\0", "").replaceAll(/\s+/gu, " ").trim();
+  if (!normalized)
+    return void 0;
+  if (normalized.length <= MAX_SESSION_TITLE_LENGTH)
+    return normalized;
+  const characters = [...normalized];
+  if (characters.length <= MAX_SESSION_TITLE_LENGTH)
+    return normalized;
+  return `${characters.slice(0, MAX_SESSION_TITLE_LENGTH - 1).join("").trimEnd()}…`;
+}
 function sessionIdOk(value) {
   return typeof value === "string" && value.length > 0 && value.length <= MAX_SESSION_ID_LENGTH;
 }
@@ -15873,12 +15896,14 @@ function cwdOk(value) {
 function withUsageSession(entry, session) {
   const sessionId = sessionIdOk(session.sessionId) ? session.sessionId : void 0;
   const cwd = cwdOk(session.cwd) ? session.cwd : void 0;
+  const sessionTitle = sessionId !== void 0 ? usageSessionTitle(session.title) : void 0;
   if (sessionId === void 0 && cwd === void 0)
     return entry;
   return {
     ...entry,
     ...sessionId !== void 0 ? { sessionId } : {},
-    ...cwd !== void 0 ? { cwd } : {}
+    ...cwd !== void 0 ? { cwd } : {},
+    ...sessionTitle !== void 0 ? { sessionTitle } : {}
   };
 }
 function tokenCount(value) {
@@ -15918,6 +15943,12 @@ function parseHarnessUsageEntry(value) {
     return null;
   if (entry.cwd !== void 0 && !cwdOk(entry.cwd))
     return null;
+  if (entry.sessionTitle !== void 0) {
+    const sessionTitle = usageSessionTitle(entry.sessionTitle);
+    if (sessionTitle === void 0)
+      return null;
+    entry.sessionTitle = sessionTitle;
+  }
   if (entry.tokensUnknown !== void 0 && entry.tokensUnknown !== true)
     return null;
   if (entry.costUsd !== void 0 && (typeof entry.costUsd !== "number" || !Number.isFinite(entry.costUsd) || entry.costUsd < 0)) {
@@ -15928,6 +15959,25 @@ function parseHarnessUsageEntry(value) {
   }
   return entry;
 }
+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;
@@ -16336,7 +16386,7 @@ var CodexCounters = class {
 };
 
 // dist/rollout-io.js
-import { createReadStream } from "node:fs";
+import { createReadStream as createReadStream2 } from "node:fs";
 import { StringDecoder } from "node:string_decoder";
 import { promisify } from "node:util";
 import { zstdDecompress } from "node:zlib";
@@ -16401,7 +16451,7 @@ function frameSize(data) {
 }
 async function* rolloutBytes(file2, signal) {
   signal.throwIfAborted();
-  const stream = createReadStream(file2, { signal });
+  const stream = createReadStream2(file2, { signal });
   let pending = Buffer.alloc(0);
   try {
     for await (const value of stream) {
@@ -16493,32 +16543,84 @@ async function copyRelation(a, b, signal) {
 // dist/usage-statistics.js
 var ROLLOUT = /^rollout-.*?([0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12})(?:[_-][0-9a-f-]+)?\.jsonl(?:\.zst)?$/iu;
 var text = (value) => typeof value === "string" ? value : "";
+var ROW_KINDS = /* @__PURE__ */ new Set([
+  "session_meta",
+  "turn_context",
+  "token_usage_record",
+  "compacted",
+  "event_msg",
+  "response_item"
+]);
+var HEAD_TYPE = /"type"\s*:\s*"([^"]+)"/u;
+var TAIL_TYPE = /"type"\s*:\s*"([^"]+)"\s*\}\s*$/u;
+function rowKind(line) {
+  const head = HEAD_TYPE.exec(line.slice(0, 1024))?.[1];
+  if (head && ROW_KINDS.has(head))
+    return head;
+  return TAIL_TYPE.exec(line.slice(-1024))?.[1] ?? head;
+}
 async function stamp(file2) {
   const s = await lstat(file2, { bigint: true });
   if (!s.isFile())
     throw new Error("Codex rollout is not a regular file");
   return `${s.dev}:${s.ino}:${s.size}:${s.mtimeNs}:${s.ctimeNs}`;
 }
-function fingerprint(files) {
-  return createHash("sha256").update(JSON.stringify(files)).digest("hex");
+function fingerprint(files, extra = "") {
+  return createHash("sha256").update(JSON.stringify(files)).update(extra).digest("hex");
 }
-async function readCodexRollouts(files, thread, signal) {
+function typedPrompt(value) {
+  if (typeof value !== "string")
+    return void 0;
+  const text2 = value.trim();
+  if (!text2 || text2.startsWith("<") || text2.startsWith("# AGENTS.md") || text2.startsWith("<!--")) {
+    return void 0;
+  }
+  return usageSessionTitle(text2);
+}
+function userItemPrompt(payload) {
+  if (!payload || payload.type !== "message" || payload.role !== "user")
+    return void 0;
+  if (!Array.isArray(payload.content))
+    return typedPrompt(payload.content);
+  for (const part of payload.content) {
+    if (typeof part !== "object" || part === null)
+      continue;
+    const block = part;
+    if (block.type === "input_text" || block.type === "text") {
+      const prompt = typedPrompt(block.text);
+      if (prompt)
+        return prompt;
+    }
+  }
+  return void 0;
+}
+async function readThreadNames(home, signal) {
+  const names = /* @__PURE__ */ new Map();
+  try {
+    for await (const line of jsonlRecords(path.join(home, "session_index.jsonl"), '"thread_name"', signal)) {
+      const id = text(line.id);
+      const name = usageSessionTitle(line.thread_name);
+      if (id && name)
+        names.set(id, name);
+    }
+  } catch (error51) {
+    if (error51.code !== "ENOENT")
+      throw error51;
+  }
+  return names;
+}
+async function readCodexRollouts(files, thread, signal, options = {}) {
   const counters = new CodexCounters();
-  let model2 = "", cwd = "", ownFrom = null, firstMeta = false, forkAt = 0, seen = 0;
+  let model2 = "", cwd = "", ownFrom = null, firstMeta = false, forkAt = 0, seen = 0, firstPrompt;
   for (const file2 of files) {
     for await (const line of rolloutLines(file2, signal)) {
       signal.throwIfAborted();
       if (++seen % 128 === 0)
         await yieldToEventLoop(void 0, { signal });
-      const kind = /"type"\s*:\s*"([^"]+)"/u.exec(line.slice(0, 1024))?.[1];
-      if (!kind || ![
-        "session_meta",
-        "turn_context",
-        "token_usage_record",
-        "compacted",
-        "event_msg",
-        "response_item"
-      ].includes(kind))
+      const kind = rowKind(line);
+      if (!kind && line.trim())
+        options.onIncomplete?.();
+      if (!kind || !ROW_KINDS.has(kind))
         continue;
       if (kind === "response_item" && !/"role"\s*:\s*"user"/u.test(line.slice(0, 1024)))
         continue;
@@ -16528,19 +16630,24 @@ async function readCodexRollouts(files, thread, signal) {
       try {
         row = object2(JSON.parse(line));
       } catch {
+        options.onIncomplete?.();
         continue;
       }
       const p = object2(row?.payload);
       const at = nativeTimeMs(row?.timestamp);
-      if (!row || !p || at === null)
+      if (!row || !p || at === null) {
+        options.onIncomplete?.();
         continue;
+      }
       switch (row.type) {
         case "session_meta": {
           if (!firstMeta) {
             if (text(p.id) !== thread)
               throw new Error("Codex rollout identity does not match its source");
-            if (p.forked_from_id || p.parent_thread_id || p.subagent_history_start_ordinal)
+            if (p.forked_from_id || p.parent_thread_id || p.subagent_history_start_ordinal) {
               forkAt = nativeTimeMs(p.timestamp) ?? at;
+              options.onIncomplete?.();
+            }
             cwd = text(p.cwd);
             firstMeta = true;
           }
@@ -16554,30 +16661,41 @@ async function readCodexRollouts(files, thread, signal) {
           counters.context("", text(p.turn_id), model2);
           break;
         case "token_usage_record":
+          if (!usage(p.usage) || !text(p.response_id))
+            options.onIncomplete?.();
           counters.record(at, model2, p);
           break;
         case "compacted": {
           const record2 = object2(p.latest_token_usage_record);
-          if (record2 && p.compaction_response_id && record2.response_id === p.compaction_response_id)
+          if (record2 && p.compaction_response_id && record2.response_id === p.compaction_response_id) {
+            if (!usage(record2.usage))
+              options.onIncomplete?.();
             counters.record(at, model2, record2, true);
+          }
           break;
         }
         case "response_item":
           counters.boundary();
+          firstPrompt ??= userItemPrompt(p);
           break;
         case "event_msg":
           if (p.type === "task_started") {
             counters.context("", text(p.turn_id), "");
             counters.boundary();
           }
-          if (p.type === "user_message")
+          if (p.type === "user_message") {
             counters.boundary();
+            firstPrompt ??= typedPrompt(p.message);
+          }
           if (p.type === "thread_settings_applied") {
             model2 = text(object2(p.thread_settings)?.model) || model2;
             counters.context("", "", model2);
           }
           if (p.type === "token_count") {
             const info = object2(p.info);
+            options.onTokenCount?.(info);
+            if (info && !usage(info.total_token_usage))
+              options.onIncomplete?.();
             if (info)
               counters.count(at, model2, usage(info.total_token_usage), usage(info.last_token_usage));
           }
@@ -16604,12 +16722,22 @@ async function readCodexRollouts(files, thread, signal) {
       ...v.usage.known & 8 ? { cacheWriteInputTokens: written } : {},
       ...v.usage.known & 16 ? { reasoningOutputTokens: reasoning } : {}
     });
-    return entry ? [withUsageSession(entry, { sessionId: thread, cwd })] : [];
+    return entry ? [withUsageSession(entry, { sessionId: thread, cwd, title: firstPrompt })] : [];
   });
 }
-function createCodexUsageStatistics(environment) {
+function createCodexUsageStatistics(environment, options = {}) {
   const home = path.resolve(environment.CODEX_HOME || path.join(environment.HOME || environment.USERPROFILE || os.homedir(), ".codex"));
   const groups = /* @__PURE__ */ new Map();
+  let names = /* @__PURE__ */ new Map();
+  let namesStamp = "";
+  async function threadNames(signal) {
+    const current = await stamp(path.join(home, "session_index.jsonl")).catch(() => "-");
+    if (namesStamp === current)
+      return names;
+    names = await readThreadNames(home, signal);
+    namesStamp = current;
+    return names;
+  }
   return {
     async listSources(signal) {
       const found = /* @__PURE__ */ new Map();
@@ -16628,7 +16756,7 @@ function createCodexUsageStatistics(environment) {
           if (!entry.isFile())
             continue;
           const thread = ROLLOUT.exec(entry.name)?.[1];
-          if (!thread)
+          if (!thread || options.sessionId && thread !== options.sessionId)
             continue;
           const list = found.get(thread) ?? [];
           list.push({ file: file2, fingerprint: await stamp(file2) });
@@ -16637,13 +16765,14 @@ function createCodexUsageStatistics(environment) {
       }
       await visit(path.join(home, "sessions"), 0);
       await visit(path.join(home, "archived_sessions"), 0);
+      const indexStamp = options.sessionId ? "" : await stamp(path.join(home, "session_index.jsonl")).catch(() => "-");
       const result = [];
       groups.clear();
       for (const [thread, files] of found) {
         files.sort((a, b) => path.basename(a.file).localeCompare(path.basename(b.file)) || a.file.localeCompare(b.file));
         const id = path.join(home, `usage-thread-${thread}`);
         groups.set(id, { thread, files });
-        result.push({ id, fingerprint: fingerprint(files) });
+        result.push({ id, fingerprint: fingerprint(files, indexStamp) });
       }
       return result;
     },
@@ -16674,11 +16803,511 @@ function createCodexUsageStatistics(environment) {
         if (!duplicate)
           kept.push(candidate);
       }
-      const entries = await readCodexRollouts(kept.map(({ file: file2 }) => file2), group.thread, signal);
+      const entries = await readCodexRollouts(kept.map(({ file: file2 }) => file2), group.thread, signal, options);
       for (const file2 of group.files)
         if (await stamp(file2.file) !== file2.fingerprint)
           throw new Error("Codex rollout changed while reading; refresh to retry");
-      return entries;
+      const named = options.sessionId ? void 0 : (await threadNames(signal)).get(group.thread);
+      return named ? entries.map((entry) => withUsageSession(entry, {
+        sessionId: entry.sessionId,
+        cwd: entry.cwd,
+        title: named
+      })) : entries;
+    }
+  };
+}
+
+// dist/session-usage.js
+import { setTimeout as delay } from "node:timers/promises";
+
+// ../../harness-adapter/dist/usage.js
+var tokenFields = [
+  "inputTokens",
+  "cachedInputTokens",
+  "cacheWriteInputTokens",
+  "outputTokens",
+  "reasoningOutputTokens",
+  "totalTokens",
+  "contextWindowTokens",
+  "contextUsedTokens"
+];
+var safeIntegerFields = [
+  "planFiveHourResetsAtUnix",
+  "planSevenDayResetsAtUnix",
+  "timeToFirstOutputMs"
+];
+var percentFields = [
+  "cacheHitRatePercent",
+  "sessionCacheHitRatePercent",
+  "planFiveHourUsedPercent",
+  "planSevenDayUsedPercent"
+];
+var usageFields = /* @__PURE__ */ new Set([
+  ...tokenFields,
+  ...safeIntegerFields,
+  ...percentFields,
+  "sessionCacheUsage",
+  "totalCostUsd",
+  "totalCredits",
+  "contextUsagePercent",
+  "outputTokensPerSecond",
+  "apiOutputTokensPerSecond",
+  "costSource",
+  "unpricedModels"
+]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseHostUsage(value) {
+  if (!isRecord(value))
+    throw new Error("Harness Usage must be an object");
+  const keys = Object.keys(value);
+  if (keys.length === 0)
+    throw new Error("Harness Usage must contain a reliable field");
+  for (const key2 of keys) {
+    if (!usageFields.has(key2)) {
+      throw new Error(`Harness Usage contains unknown field '${key2}'`);
+    }
+  }
+  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`);
+    }
+  }
+  for (const field of tokenFields) {
+    const candidate = value[field];
+    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
+      throw new Error(`Harness Usage '${field}' must be a non-negative safe integer`);
+    }
+  }
+  for (const field of safeIntegerFields) {
+    const candidate = value[field];
+    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
+      throw new Error(`Harness Usage '${field}' must be a non-negative safe integer`);
+    }
+  }
+  if (value.outputTokensPerSecond !== void 0 && (typeof value.outputTokensPerSecond !== "number" || !Number.isFinite(value.outputTokensPerSecond) || value.outputTokensPerSecond < 0)) {
+    throw new Error("Harness Usage 'outputTokensPerSecond' must be a finite non-negative number");
+  }
+  if (value.totalCostUsd !== void 0 && (typeof value.totalCostUsd !== "number" || !Number.isFinite(value.totalCostUsd) || value.totalCostUsd < 0)) {
+    throw new Error("Harness Usage 'totalCostUsd' must be a finite non-negative number");
+  }
+  for (const field of percentFields) {
+    const candidate = value[field];
+    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0 || candidate > 100)) {
+      throw new Error(`Harness Usage '${field}' must be between 0 and 100`);
+    }
+  }
+  if (value.sessionCacheUsage !== void 0) {
+    const totals2 = value.sessionCacheUsage;
+    if (!isRecord(totals2) || Object.keys(totals2).some((key2) => key2 !== "inputTokens" && key2 !== "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) {
+    throw new Error("Harness Usage context fields must be provided together");
+  }
+  if (hasContextWindow && value.contextWindowTokens === 0) {
+    throw new Error("Harness Usage 'contextWindowTokens' must be greater than zero");
+  }
+  if (value.planFiveHourResetsAtUnix !== void 0 && value.planFiveHourUsedPercent === void 0) {
+    throw new Error("Harness Usage 'planFiveHourResetsAtUnix' must be provided with 'planFiveHourUsedPercent'");
+  }
+  if (value.planSevenDayResetsAtUnix !== void 0 && value.planSevenDayUsedPercent === void 0) {
+    throw new Error("Harness Usage 'planSevenDayResetsAtUnix' must be provided with 'planSevenDayUsedPercent'");
+  }
+  if (value.costSource !== void 0) {
+    if (value.costSource !== "publicPrice" && value.costSource !== "native") {
+      throw new Error("Harness Usage 'costSource' must be 'publicPrice' or 'native'");
+    }
+    if (value.totalCostUsd === void 0) {
+      throw new Error("Harness Usage 'costSource' must be provided with 'totalCostUsd'");
+    }
+  }
+  if (value.unpricedModels !== void 0) {
+    const models = value.unpricedModels;
+    if (!Array.isArray(models) || models.length === 0 || !models.every((model2) => typeof model2 === "string" && model2.length > 0)) {
+      throw new Error("Harness Usage 'unpricedModels' must be a non-empty list of Model IDs");
+    }
+    if (value.costSource !== "publicPrice") {
+      throw new Error("Harness Usage 'unpricedModels' must be provided with a 'publicPrice' cost");
+    }
+    return { ...value, unpricedModels: [...models] };
+  }
+  return { ...value };
+}
+var requestTokenFields = [
+  "inputTokens",
+  "cachedInputTokens",
+  "cacheWriteInputTokens",
+  "cacheWrite1hInputTokens",
+  "outputTokens",
+  "reasoningOutputTokens",
+  "startedAtMs",
+  "completedAtMs"
+];
+var requestFields = /* @__PURE__ */ new Set([
+  ...requestTokenFields,
+  "requestId",
+  "historical",
+  "model",
+  "provider"
+]);
+function parseHostUsageRequest(value) {
+  if (!isRecord(value))
+    throw new Error("Harness Usage request must be an object");
+  for (const key2 of Object.keys(value)) {
+    if (!requestFields.has(key2)) {
+      throw new Error(`Harness Usage request contains unknown field '${key2}'`);
+    }
+  }
+  if (typeof value.requestId !== "string" || value.requestId.length === 0) {
+    throw new Error("Harness Usage request 'requestId' must be a non-empty string");
+  }
+  for (const field of ["model", "provider"]) {
+    const candidate = value[field];
+    if (candidate !== void 0 && (typeof candidate !== "string" || candidate.length === 0)) {
+      throw new Error(`Harness Usage request '${field}' must be a non-empty string`);
+    }
+  }
+  if (value.historical !== void 0 && typeof value.historical !== "boolean") {
+    throw new Error("Harness Usage request 'historical' must be a boolean");
+  }
+  for (const field of requestTokenFields) {
+    const candidate = value[field];
+    if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
+      throw new Error(`Harness Usage request '${field}' must be a non-negative safe integer`);
+    }
+  }
+  if (value.inputTokens === void 0 || value.outputTokens === void 0) {
+    throw new Error("Harness Usage request must contain 'inputTokens' and 'outputTokens'");
+  }
+  const request = value;
+  if ((request.cachedInputTokens ?? 0) + (request.cacheWriteInputTokens ?? 0) > request.inputTokens) {
+    throw new Error("Harness Usage request cache Tokens must not exceed 'inputTokens'");
+  }
+  if ((request.reasoningOutputTokens ?? 0) > request.outputTokens) {
+    throw new Error("Harness Usage request 'reasoningOutputTokens' must not exceed 'outputTokens'");
+  }
+  if (request.cacheWrite1hInputTokens !== void 0 && request.cacheWrite1hInputTokens > (request.cacheWriteInputTokens ?? -1)) {
+    throw new Error("Harness Usage request 'cacheWrite1hInputTokens' must not exceed 'cacheWriteInputTokens'");
+  }
+  if (request.startedAtMs === void 0 !== (request.completedAtMs === void 0)) {
+    throw new Error("Harness Usage request timing fields must be provided together");
+  }
+  if (request.startedAtMs !== void 0 && request.completedAtMs !== void 0 && request.completedAtMs < request.startedAtMs) {
+    throw new Error("Harness Usage request 'completedAtMs' must not precede 'startedAtMs'");
+  }
+  return { ...request };
+}
+
+// dist/session-observation.js
+var integer2 = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+function tokenSnapshot(value) {
+  const token = object2(value);
+  if (!token)
+    return null;
+  const total = object2(token.total);
+  const last = object2(token.last);
+  const result = {};
+  for (const field of [
+    "totalTokens",
+    "inputTokens",
+    "cachedInputTokens",
+    "cacheWriteInputTokens",
+    "outputTokens",
+    "reasoningOutputTokens"
+  ]) {
+    const n = integer2(total?.[field]);
+    if (n !== void 0)
+      result[field] = n;
+  }
+  const used = integer2(last?.totalTokens);
+  const window = integer2(token.modelContextWindow);
+  if (used !== void 0 && window !== void 0 && window > 0) {
+    result.contextUsedTokens = used;
+    result.contextWindowTokens = window;
+  }
+  const input = integer2(last?.inputTokens);
+  const cached2 = integer2(last?.cachedInputTokens);
+  if (input && cached2 !== void 0 && cached2 <= input)
+    result.cacheHitRatePercent = cached2 / input * 100;
+  if (result.inputTokens && result.cachedInputTokens !== void 0) {
+    result.sessionCacheUsage = {
+      inputTokens: result.inputTokens,
+      cachedInputTokens: result.cachedInputTokens
+    };
+  }
+  try {
+    return Object.keys(result).length ? parseHostUsage(result) : null;
+  } catch {
+    return null;
+  }
+}
+function observeSessionUsage(message) {
+  const frame = object2(message);
+  const params = object2(frame?.params);
+  if (!params || typeof params.threadId !== "string" || !params.threadId)
+    return null;
+  const sessionId = params.threadId;
+  if (frame?.method === "thread/tokenUsage/updated") {
+    const usage2 = tokenSnapshot(params.tokenUsage);
+    return usage2 ? { sessionId, usage: usage2 } : null;
+  }
+  if (frame?.method === "turn/started" || frame?.method === "turn/completed") {
+    const turn = object2(params.turn);
+    return typeof turn?.id === "string" && turn.id ? {
+      sessionId,
+      turn: { id: turn.id, phase: frame.method === "turn/started" ? "started" : "completed" }
+    } : null;
+  }
+  if (typeof params.turnId !== "string" || !params.turnId)
+    return null;
+  if ([
+    "item/agentMessage/delta",
+    "item/reasoning/textDelta",
+    "item/reasoning/summaryTextDelta"
+  ].includes(String(frame?.method)) && typeof params.delta === "string" && params.delta.length > 0) {
+    return { sessionId, turn: { id: params.turnId, phase: "output" } };
+  }
+  return null;
+}
+function rolloutTokenSnapshot(info) {
+  const record2 = object2(info);
+  if (!record2)
+    return null;
+  const convert = (value) => {
+    const u = object2(value);
+    return u && {
+      totalTokens: u.total_tokens,
+      inputTokens: u.input_tokens,
+      cachedInputTokens: u.cached_input_tokens,
+      cacheWriteInputTokens: u.cache_write_input_tokens,
+      outputTokens: u.output_tokens,
+      reasoningOutputTokens: u.reasoning_output_tokens
+    };
+  };
+  return tokenSnapshot({
+    total: convert(record2.total_token_usage),
+    last: convert(record2.last_token_usage),
+    modelContextWindow: record2.model_context_window
+  });
+}
+
+// dist/response-timing.js
+var nonNegativeInteger = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+var CodexResponseTiming = class {
+  #turns = /* @__PURE__ */ new Map();
+  reset() {
+    this.#turns.clear();
+  }
+  observe(message, now) {
+    const frame = object2(message);
+    const params = object2(frame?.params);
+    if (!params || typeof params.threadId !== "string")
+      return null;
+    const sessionId = params.threadId;
+    const turn = object2(params.turn);
+    if (frame?.method === "turn/started" && typeof turn?.id === "string") {
+      if (this.#turns.get(sessionId)?.id !== turn.id) {
+        this.#turns.set(sessionId, {
+          id: turn.id,
+          pending: false,
+          unavailable: false,
+          seen: /* @__PURE__ */ new Set()
+        });
+      }
+      return null;
+    }
+    const state = this.#turns.get(sessionId);
+    if (!state)
+      return null;
+    const unavailable = () => {
+      state.unavailable = true;
+      return { sessionId, timingUnavailable: { turnId: state.id } };
+    };
+    if (frame?.method === "thread/closed") {
+      this.#turns.delete(sessionId);
+      return unavailable();
+    }
+    if (frame?.method === "turn/completed" && turn?.id === state.id) {
+      this.#turns.delete(sessionId);
+      return state.pending || state.unavailable ? unavailable() : null;
+    }
+    if (params.turnId !== state.id)
+      return null;
+    if (frame?.method === "error")
+      return unavailable();
+    if (frame?.method === "rawResponse/completed") {
+      const id = params.responseId;
+      if (typeof id !== "string" || !id)
+        return unavailable();
+      if (state.seen.has(id))
+        return null;
+      state.seen.add(id);
+      const usage2 = object2(params.usage);
+      const startedAtMs = state.firstOutputAtMs;
+      state.firstOutputAtMs = void 0;
+      state.pending = false;
+      if (state.unavailable || startedAtMs === void 0 || !nonNegativeInteger(now) || now <= startedAtMs || !nonNegativeInteger(usage2?.outputTokens) || usage2.reasoningOutputTokens != null && (!nonNegativeInteger(usage2.reasoningOutputTokens) || usage2.reasoningOutputTokens > usage2.outputTokens)) {
+        return unavailable();
+      }
+      return {
+        sessionId,
+        requestTiming: {
+          requestId: id,
+          turnId: state.id,
+          outputTokens: usage2.outputTokens,
+          startedAtMs,
+          completedAtMs: now
+        }
+      };
+    }
+    if (frame?.method === "rawResponseItem/completed") {
+      const item = object2(params.item);
+      if (item?.type === "message" && item.role === "assistant" || [
+        "reasoning",
+        "function_call",
+        "custom_tool_call",
+        "local_shell_call",
+        "web_search_call",
+        "image_generation_call",
+        "tool_search_call"
+      ].includes(String(item?.type)))
+        state.pending = true;
+      return null;
+    }
+    if (frame?.method === "item/started") {
+      const item = object2(params.item);
+      if (item?.type === "agentMessage" || item?.type === "reasoning" || item?.type === "plan") {
+        state.pending = true;
+        state.firstOutputAtMs ??= now;
+      }
+      return null;
+    }
+    const reasoning = frame?.method === "item/reasoning/textDelta" || frame?.method === "item/reasoning/summaryTextDelta";
+    if ((reasoning || frame?.method === "item/agentMessage/delta" || frame?.method === "item/plan/delta") && typeof params.delta === "string" && params.delta.length > 0) {
+      state.pending = true;
+      state.firstOutputAtMs ??= now;
+    }
+    return null;
+  }
+};
+
+// dist/session-usage.js
+function createCodexSessionUsage(environment, closed) {
+  const timing = new CodexResponseTiming();
+  const rawCompleted = "rawResponse/completed";
+  let hideRawCompleted = false;
+  const live = /* @__PURE__ */ new Map();
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    requestOptions({ method, params, initializeParams }) {
+      if (closed.aborted)
+        return null;
+      if (method === "initialize") {
+        const capabilities2 = object2(params.capabilities);
+        const excluded2 = capabilities2?.optOutNotificationMethods;
+        hideRawCompleted = false;
+        if (capabilities2?.experimentalApi !== true || !Array.isArray(excluded2))
+          return null;
+        if (!excluded2.includes(rawCompleted))
+          return null;
+        hideRawCompleted = true;
+        return {
+          capabilities: {
+            ...capabilities2,
+            optOutNotificationMethods: excluded2.filter((method2) => method2 !== rawCompleted)
+          }
+        };
+      }
+      const capabilities = object2(initializeParams?.capabilities);
+      const excluded = capabilities?.optOutNotificationMethods;
+      return method === "thread/start" && capabilities?.experimentalApi === true && !(Array.isArray(excluded) && excluded.includes(rawCompleted)) && (params.experimentalRawEvents === void 0 || params.experimentalRawEvents === false) ? { experimentalRawEvents: true } : null;
+    },
+    shouldForwardNotification(message) {
+      return closed.aborted || !hideRawCompleted || object2(message)?.method !== rawCompleted;
+    },
+    reset() {
+      timing.reset();
+    },
+    observe(message, observedAtMs = Date.now()) {
+      if (closed.aborted)
+        return null;
+      const observation = observeSessionUsage(message);
+      const measured = timing.observe(message, observedAtMs);
+      if (observation?.usage)
+        live.set(observation.sessionId, observation.usage);
+      return measured ? { ...observation, ...measured } : observation;
+    },
+    async read(sessionId, signal) {
+      signal = AbortSignal.any([signal, closed]);
+      signal.throwIfAborted();
+      for (let attempt = 0; ; attempt++) {
+        let snapshot = null;
+        let complete = true;
+        const reader = createCodexUsageStatistics(environment, {
+          sessionId,
+          onTokenCount: (info) => {
+            snapshot = rolloutTokenSnapshot(info) ?? snapshot;
+          },
+          onIncomplete: () => {
+            complete = false;
+          }
+        });
+        const sources = await reader.listSources(signal);
+        const source = sources[0];
+        if (!source)
+          return null;
+        let history = cache.get(sessionId);
+        if (history?.fingerprint !== source.fingerprint) {
+          const entries = await reader.readSource(source.id, signal);
+          const requests = entries.map((entry) => parseHostUsageRequest({
+            requestId: entry.id,
+            historical: true,
+            ...entry.model ? { model: entry.model } : {},
+            inputTokens: entry.inputTokens,
+            outputTokens: entry.outputTokens,
+            ...entry.cachedInputTokens !== void 0 ? { cachedInputTokens: entry.cachedInputTokens } : {},
+            // Codex/OpenAI cache has no separately billed cache creation bucket.
+            cacheWriteInputTokens: entry.cacheWriteInputTokens ?? 0,
+            ...entry.reasoningOutputTokens !== void 0 ? { reasoningOutputTokens: entry.reasoningOutputTokens } : {}
+          }));
+          const inputTokens = requests.reduce((sum, r) => sum + r.inputTokens, 0);
+          const outputTokens = requests.reduce((sum, r) => sum + r.outputTokens, 0);
+          const cachedInputTokens = requests.every((r) => r.cachedInputTokens !== void 0) ? requests.reduce((sum, r) => sum + (r.cachedInputTokens ?? 0), 0) : void 0;
+          const last = requests.at(-1);
+          const usage2 = requests.length ? parseHostUsage({
+            ...snapshot ?? {},
+            inputTokens,
+            outputTokens,
+            totalTokens: inputTokens + outputTokens,
+            ...cachedInputTokens !== void 0 ? { cachedInputTokens } : {},
+            ...complete && cachedInputTokens !== void 0 ? { sessionCacheUsage: { inputTokens, cachedInputTokens } } : {},
+            ...last?.inputTokens && last.cachedInputTokens !== void 0 ? { cacheHitRatePercent: last.cachedInputTokens / last.inputTokens * 100 } : {}
+          }) : snapshot;
+          history = {
+            fingerprint: source.fingerprint,
+            history: { usage: usage2, requests, complete: complete && requests.length > 0 }
+          };
+          cache.set(sessionId, history);
+        }
+        const result = history.history;
+        const latest = live.get(sessionId);
+        const caughtUp = !latest || (latest.inputTokens ?? 0) <= (result.usage?.inputTokens ?? 0) && (latest.outputTokens ?? 0) <= (result.usage?.outputTokens ?? 0);
+        if (!caughtUp && attempt < 2) {
+          await delay(50 * (attempt + 1), void 0, { signal });
+          continue;
+        }
+        return { ...result, complete: result.complete && caughtUp };
+      }
     }
   };
 }
@@ -16689,6 +17318,7 @@ function createUsageStatisticsAdapter(context) {
   const reader = createCodexUsageStatistics(context.environment);
   return {
     harnessId: harnessIdSchema.parse("codex-usage"),
+    sessionUsage: createCodexSessionUsage(context.environment, abort.signal),
     usageStatistics: {
       listSources: (signal) => reader.listSources(AbortSignal.any([signal, abort.signal])),
       readSource: (id, signal) => reader.readSource(id, AbortSignal.any([signal, abort.signal]))