ccdeck 3.43.4 → 3.45.0

package/src/server/cli-lines.mjs

@@ -0,0 +1,224 @@
+// What `ccdeck accounts`, `ccdeck usage` and `ccdeck sessions` print (#2183).
+//
+// Pure — rows, a palette, glyphs and a width in; lines out — so the layout can
+// be pinned at 40 columns and at 120 without a terminal, and so the same rows a
+// running deck serves and the rows read in this process draw identically. The
+// palette and glyphs are the boot's own (term.mjs), which is what makes these
+// lines look like the product rather than like a script beside it: the same
+// colour tier, the same ASCII fallback on a console that cannot draw a block.
+import { sinceLabel, stripAnsi } from "./term.mjs";
+
+/**
+ * Text that came from somewhere else — a session's title and folder, the
+ * question Claude Code passed on, an alias somebody typed — on one line and
+ * without the bytes a terminal acts on. A newline would break the row it is
+ * in, and an ESC would reach the terminal as a command rather than as text.
+ */
+export function oneLine(s) {
+  return String(s ?? "").replace(/[\u0000-\u001f\u007f-\u009f]+/g, " ").replace(/\s+/g, " ").trim();
+}
+
+// The columns a character takes: two for the wide ones (CJK, Hangul, the
+// fullwidth forms, the pictographic emoji), none for combining marks, joiners
+// and variation selectors, one otherwise. Enough of wcwidth that a title in
+// Japanese, or with an emoji in it, does not wrap the row it was clipped to.
+const WIDE = /[ᄀ-ᅟ⺀-〾ぁ-㏿㐀-䶿一-鿿ꀀ-꓏가-힣豈-﫿︰-﹏＀-｠￠-￦\u{1f300}-\u{1f64f}\u{1f680}-\u{1f6ff}\u{1f900}-\u{1f9ff}\u{20000}-\u{3fffd}]/u;
+const ZERO = /[\p{Mn}\p{Me}​-‏︀-️]/u;
+const cellsOf = (ch) => (ZERO.test(ch) ? 0 : WIDE.test(ch) ? 2 : 1);
+
+/** How many columns `s` takes on a terminal, its colour codes not counted. */
+export function textWidth(s) {
+  let w = 0;
+  for (const ch of stripAnsi(String(s))) w += cellsOf(ch);
+  return w;
+}
+
+/** The longest start of `s` that fits in `n` columns. */
+function takeCells(s, n) {
+  let out = "";
+  let w = 0;
+  for (const ch of s) {
+    const c = cellsOf(ch);
+    if (w + c > n) break;
+    out += ch;
+    w += c;
+  }
+  return out;
+}
+
+/** A ten-cell meter, or `cells` of them. Blocks where the terminal can draw
+ *  them, `#` and `.` where it cannot. */
+export function meter(pct, { cells = 10, unicode = true } = {}) {
+  const p = Math.min(100, Math.max(0, Number(pct) || 0));
+  const full = Math.round((p / 100) * cells);
+  const [on, off] = unicode ? ["█", "░"] : ["#", "."];
+  return on.repeat(full) + off.repeat(cells - full);
+}
+
+/** The tone a percentage is drawn in: the panel's thresholds, near the limit
+ *  in warn and at it in err. */
+export function pctTone(pct, tone) {
+  return pct >= 90 ? tone.err : pct >= 75 ? tone.warn : tone.ok;
+}
+
+/** "1h 12m" until a reset given in epoch SECONDS, or "" when there is none or
+ *  it has passed — a reset in the past is a reading that is out of date, and
+ *  "resets in 0s" would claim otherwise. */
+export function untilReset(resetAt, now = Date.now()) {
+  if (typeof resetAt !== "number" || !Number.isFinite(resetAt)) return "";
+  const ms = resetAt * 1000 - now;
+  return ms > 0 ? sinceLabel(ms) : "";
+}
+
+const padEnd = (s, n) => s + " ".repeat(Math.max(0, n - textWidth(s)));
+const padStart = (s, n) => " ".repeat(Math.max(0, n - textWidth(s))) + s;
+// Cut to `n` columns with the glyph tier's own ellipsis, which is three
+// characters on a console that cannot draw the one-character one.
+export const clip = (s, n, ellipsis = "…") => (textWidth(s) <= n ? s
+  : n <= textWidth(ellipsis) ? takeCells(s, n) : `${takeCells(s, n - textWidth(ellipsis))}${ellipsis}`);
+
+/** What is wrong with an account, in words, or null when nothing is. */
+export function accountTrouble(a) {
+  if (a.disabled) return { word: "disabled", tone: "muted" };
+  if (a.error && !a.staleCopy) return { word: "sign-in needed", tone: "err" };
+  if (a.stopped) return { word: "not collecting usage", tone: "warn" };
+  return null;
+}
+
+function lanesText(a, { tone, g, unicode, now, wide }) {
+  const lanes = (a.lanes ?? []).filter(l => l.id === "five_hour" || l.id === "seven_day");
+  if (!lanes.length) {
+    return a.fetchedAt == null ? `${tone.muted}not read yet${tone.reset}` : `${tone.muted}no usage reading${tone.reset}`;
+  }
+  return lanes.map(l => {
+    const pct = `${Math.round(l.pct)}%`;
+    const until = untilReset(l.resetAt, now);
+    const bar = wide ? ` ${pctTone(l.pct, tone)}${meter(l.pct, { unicode })}${tone.reset}` : "";
+    const reset = wide && until ? ` ${tone.muted}${g.restart} ${padEnd(until, 7)}${tone.reset}` : wide ? "          " : "";
+    return `${tone.muted}${l.label}${tone.reset}${bar} ${pctTone(l.pct, tone)}${padStart(pct, 4)}${tone.reset}${reset}`;
+  }).join("  ");
+}
+
+/**
+ * The roster, one account per line, the active one marked.
+ *
+ * Three widths. From 104 columns each lane has its meter and its reset; from 64
+ * the percentages stand alone; below that the alias goes and the email is
+ * clipped. Nothing wraps: a row that wrapped would put one account's usage
+ * under another's name.
+ */
+export function accountLines(accounts, { tone, g, unicode = true, columns = 80, now = Date.now() } = {}) {
+  const rows = Array.isArray(accounts) ? accounts : [];
+  if (!rows.length) return [`  ${tone.muted}${g.dash}  no Claude accounts yet${tone.reset}`];
+  const wide = columns >= 104;
+  const aliasOf = (a) => oneLine(a.alias);
+  const emailOf = (a) => oneLine(a.email) || "(no email)";
+  const showAlias = columns >= 64 && rows.some(a => aliasOf(a));
+  const numW = Math.max(...rows.map(a => String(a.num).length));
+  const aliasW = showAlias ? Math.min(14, Math.max(...rows.map(a => textWidth(aliasOf(a))))) : 0;
+  // What is left for the email once the mark, the slot, the alias and the
+  // lanes have their room; never less than 12, which still shows whose it is.
+  const lanesW = wide ? 66 : 20;
+  const emailRoom = Math.max(12, columns - 2 - 2 - numW - 2 - (showAlias ? aliasW + 2 : 0) - 2 - lanesW);
+  const emailW = Math.min(emailRoom, Math.max(...rows.map(a => textWidth(emailOf(a)))));
+  return rows.map(a => {
+    const mark = a.active ? `${tone.ok}${g.pulse}${tone.reset}` : " ";
+    const num = `${a.active ? tone.bold : ""}${padStart(String(a.num), numW)}${tone.reset}`;
+    const alias = showAlias ? `${tone.accent}${padEnd(clip(aliasOf(a), aliasW, g.ellipsis), aliasW)}${tone.reset}  ` : "";
+    const email = padEnd(clip(emailOf(a), emailW, g.ellipsis), emailW);
+    const trouble = accountTrouble(a);
+    const status = trouble
+      ? `${tone[trouble.tone]}${trouble.word}${tone.reset}`
+      : lanesText(a, { tone, g, unicode, now, wide });
+    // The last lane's reset is padded for the column after it, which the last
+    // lane does not have: the padding goes, and the colour reset behind it stays.
+    const line = `  ${mark} ${num}  ${alias}${email}  ${status}`.replace(/ +((?:\x1b\[[0-9;]*m)*)$/, "$1");
+    // How old the reading is, where it fits: the one part of a row that can be
+    // left off without the row saying something else.
+    const age = !trouble && a.stale && a.fetchedAt != null
+      ? `  ${tone.muted}read ${sinceLabel(now - a.fetchedAt)} ago${tone.reset}`
+      : "";
+    return textWidth(line) + textWidth(age) <= columns ? line + age : line;
+  });
+}
+
+/** One account's lanes, at length, for `ccdeck usage`: every lane the roster
+ *  holds, the model-scoped ones included, each with a twenty-cell meter. */
+export function usageLines(a, { tone, g, unicode = true, columns = 80, now = Date.now() } = {}) {
+  const alias = oneLine(a.alias);
+  const head = `  ${tone.ok}${g.pulse}${tone.reset} ${tone.bold}#${a.num} ${oneLine(a.email) || "(no email)"}${tone.reset}`
+    + `${alias ? ` ${tone.accent}(${alias})${tone.reset}` : ""}`;
+  const out = [head, ""];
+  const trouble = accountTrouble(a);
+  if (trouble) out.push(`    ${tone[trouble.tone]}${trouble.word}${tone.reset}`);
+  const lanes = a.lanes ?? [];
+  const labelW = Math.max(2, ...lanes.map(l => String(l.label).length));
+  const cells = columns >= 70 ? 20 : 10;
+  for (const l of lanes) {
+    const until = untilReset(l.resetAt, now);
+    out.push(`    ${tone.muted}${padEnd(String(l.label), labelW)}${tone.reset}  ${pctTone(l.pct, tone)}${meter(l.pct, { cells, unicode })}`
+      + `${padStart(`${Math.round(l.pct)}%`, 5)}${tone.reset}${until ? `   ${tone.muted}resets in ${until}${tone.reset}` : ""}`);
+  }
+  if (!lanes.length) out.push(`    ${tone.muted}${a.fetchedAt == null ? "not read yet" : "no usage reading"}${tone.reset}`);
+  if (a.fetchedAt != null) out.push("", `    ${tone.muted}read ${sinceLabel(now - a.fetchedAt)} ago${tone.reset}`);
+  return out;
+}
+
+/** "opus-4-1" for "claude-opus-4-1-20250805": the part a person says. */
+export function shortModel(model) {
+  if (typeof model !== "string" || !model) return "";
+  return oneLine(model).replace(/^claude-/, "").replace(/-\d{8}$/, "").replace(/\[.*\]$/, "");
+}
+
+const STATE_WORDS = { waiting: "waiting", working: "working", idle: "your turn", ended: "ended" };
+
+/**
+ * The sessions, one per line, the ones waiting on a human first and their
+ * question underneath in their own words.
+ */
+export function sessionLines(sessions, { tone, g, columns = 80, now = Date.now() } = {}) {
+  const rows = Array.isArray(sessions) ? sessions : [];
+  if (!rows.length) return [`  ${tone.muted}${g.dash}  no sessions right now${tone.reset}`];
+  const label = (s) => oneLine(s.name) || oneLine(s.project) || oneLine(s.id).slice(0, 8);
+  const agentOf = (s) => (s.provider === "codex" ? "Codex" : "Claude");
+  // The mark, the state word and the age take 23 columns; the label gets what
+  // the agent column leaves, and on a narrow terminal the agent column gives
+  // way first — the model, then the agent — so the label, which is how a person
+  // tells two sessions apart, keeps at least eight.
+  const LEAD = 23;
+  const tails = [
+    (s) => `${agentOf(s)}${shortModel(s.model) ? ` ${g.bullet} ${shortModel(s.model)}` : ""}`,
+    (s) => agentOf(s),
+    () => "",
+  ];
+  const longestLabel = Math.max(...rows.map(s => textWidth(label(s))));
+  const tailOf = tails.find(t => columns - LEAD - 2 - Math.max(...rows.map(s => textWidth(t(s)))) >= 8) ?? tails[2];
+  const tailW = Math.max(...rows.map(s => textWidth(tailOf(s))));
+  const labelW = Math.max(1, Math.min(longestLabel, columns - LEAD - (tailW ? tailW + 2 : 0)));
+  const out = [];
+  for (const s of rows) {
+    const icon = s.state === "waiting" ? `${tone.warn}${g.warn}${tone.reset}`
+      : s.state === "working" ? `${tone.ok}${g.pulse}${tone.reset}`
+      : s.state === "idle" ? `${tone.accent}${g.bullet}${tone.reset}`
+      : `${tone.muted}${g.dash}${tone.reset}`;
+    const word = STATE_WORDS[s.state] ?? s.state;
+    const wordTone = s.state === "waiting" ? tone.warn : s.state === "ended" ? tone.muted : "";
+    const age = sinceLabel(now - (s.since ?? s.lastEventAt ?? now));
+    const tail = tailOf(s);
+    const named = padEnd(clip(label(s), labelW, g.ellipsis), labelW);
+    out.push((`  ${icon} ${wordTone}${padEnd(word, 9)}${tone.reset} ${tone.muted}${padStart(age, 7)}${tone.reset}  `
+      + `${tail ? `${named}  ${tone.muted}${tail}${tone.reset}` : named}`).replace(/ +((?:\x1b\[[0-9;]*m)*)$/, "$1"));
+    if (s.state === "waiting" && s.waiting) {
+      const what = oneLine(s.waiting.message) || (s.waiting.kind === "asked" ? "asked a question" : "needs your permission");
+      // The tool the prompt is most likely about, unless Claude Code's own
+      // sentence already names it — "permission to use Bash (Bash)" says
+      // nothing twice over.
+      const tool0 = oneLine(s.waiting.tool);
+      const toolText = tool0 && !what.includes(tool0) ? ` (${tool0})` : "";
+      const room = Math.max(8, columns - 6 - textWidth(toolText));
+      const tool = toolText ? `${tone.muted}${toolText}${tone.reset}` : "";
+      out.push(`      ${tone.warn}${clip(what, room, g.ellipsis)}${tone.reset}${tool}`);
+    }
+  }
+  return out;
+}

package/src/server/codex-cost-usage.mjs

@@ -0,0 +1,67 @@
+import { FREE_AUTO_REVIEW_TIER, isFreeAutoReview } from "./codex-review-policy.mjs";
+// Price only observed increases under recorded settings, never a whole session
+// at its latest tier. These are API-equivalent estimates, not billing evidence.
+const FIELDS = ["input_tokens", "output_tokens", "cached_input_tokens", "cache_write_input_tokens"];
+const TIERS = new Map([["default", "standard"], ["standard", "standard"], ["priority", "fast"], ["fast", "fast"], ["flex", "flex"]]);
+const count = n => typeof n === "number" && Number.isFinite(n) && n >= 0 ? n : 0;
+const empty = () => Object.fromEntries(FIELDS.map(k => [k, 0]));
+export function codexCostState() {
+  return { model: null, tier: null, previous: null, models: new Map() };
+}
+export function codexCostGap(state) {
+  state.gapPrevious = state.previous;
+  state.previous = null;
+  state.tier = null;
+  state.model = null;
+  state.lastUsageAt = undefined;
+}
+export function foldCodexCost(state, obj) {
+  const pl = obj?.payload;
+  if (obj?.type === "session_meta") {
+    state.creator = pl?.creator_account_id;
+    state.startedAt = obj.timestamp;
+    if (state.previous === null) state.previous = empty();
+  }
+  if (obj?.type === "session_meta" && typeof pl?.model === "string") state.model = pl.model;
+  if ((obj?.type === "turn_context" || obj?.type === "response_item") && typeof pl?.model === "string") state.model = pl.model;
+  if (obj?.type !== "event_msg") return;
+  if (pl?.type === "thread_settings_applied" && Object.hasOwn(pl.thread_settings ?? {}, "service_tier")) {
+    const tier = pl.thread_settings.service_tier;
+    state.tier = TIERS.get(tier) ?? "unknown";
+  }
+  const raw = pl?.type === "token_count" ? pl.info?.total_token_usage : null;
+  if (!raw || typeof raw !== "object") return;
+  const next = Object.fromEntries(FIELDS.map(k => [k, count(raw[k])]));
+  const priorUsageAt = state.lastUsageAt;
+  state.lastUsageAt = obj.timestamp;
+  const prior = state.previous;
+  const baseline = prior ?? state.gapPrevious;
+  state.gapPrevious = null;
+  state.previous = next;
+  // The first total could precede the tier setting; the first read after a gap
+  // certainly does. Leave that part at base rates instead of guessing its tier.
+  if (baseline && FIELDS.some(k => next[k] < baseline[k])) {
+    state.models.clear();
+    return;
+  }
+  if (!prior || !state.model) return;
+  const delta = Object.fromEntries(FIELDS.map(k => [k, next[k] - prior[k]]));
+  const bucket = state.models.get(state.model) ?? { ...empty(), speeds: new Map() };
+  for (const k of FIELDS) bucket[k] += delta[k];
+  const free = isFreeAutoReview(state.model, state.creator, obj.timestamp)
+    && (isFreeAutoReview(state.model, state.creator, priorUsageAt)
+      || isFreeAutoReview(state.model, state.creator, state.startedAt));
+  const billedTier = free ? FREE_AUTO_REVIEW_TIER : state.tier;
+  if (billedTier && billedTier !== "standard") {
+    const share = bucket.speeds.get(billedTier) ?? empty();
+    for (const k of FIELDS) share[k] += delta[k];
+    bucket.speeds.set(billedTier, share);
+  }
+  state.models.set(state.model, bucket);
+}
+export function codexCostBuckets(state) {
+  if (state.models.size === 0) return undefined;
+  return Object.fromEntries([...state.models].map(([model, { speeds, ...usage }]) => [model, {
+    ...usage, ...(speeds.size ? { speeds: Object.fromEntries(speeds) } : {}),
+  }]));
+}

package/src/server/codex-enrichment.mjs

@@ -10,6 +10,7 @@
 // (event-pipeline.mjs) hands every live event to maybeResolveCodex, and
 // session-tracking.mjs forgets a session through forgetCodexSession. The
 // bodies are unchanged.
+import { codexCostState, codexCostGap, foldCodexCost, codexCostBuckets } from "./codex-cost-usage.mjs";
 import { stat } from "node:fs/promises";
 import { join } from "node:path";
 import { STOP, rolloutNameId, walkRolloutDays } from "./codex-dir.mjs";
@@ -48,6 +49,7 @@ import { sessionReadGate } from "./session-read-gate.mjs";
 const codexRolloutPathBySid = new Map();
 const CODEX_READ_THROTTLE_MS = 2500;
 const codexUsageReads = sessionReadGate(CODEX_READ_THROTTLE_MS);
+const codexUsageRequests = new Map();
 // How many of the newest day directories a lookup reads when it is not owed
 // the whole tree: the bound listRecentCodexRollouts keeps for the watcher.
 const CODEX_RECENT_DAY_DIRS = 2;
@@ -211,6 +213,7 @@ export async function readCodexRollout(path) {
     const s = await stat(path);
     if (s.size === 0) return null;
     let text;
+    const pricing = codexCostState();
     if (s.size <= CODEX_HEAD_BYTES + CODEX_TAIL_BYTES) {
       text = await readByteRange(path, 0, s.size);
     } else {
@@ -221,7 +224,7 @@ export async function readCodexRollout(path) {
       // the loop below skips it.
       const head = await readByteRange(path, 0, CODEX_HEAD_BYTES);
       const tail = await readByteRange(path, s.size - CODEX_TAIL_BYTES, s.size);
-      text = `${head}\n${tail}`;
+      text = `${head}\n__ccdeck_gap__\n${tail}`;
     }
     let lastUsage = null;
     let model = null;
@@ -230,9 +233,11 @@ export async function readCodexRollout(path) {
     // Undefined until a turn_context is read: "no turn yet" is not "no effort".
     let effort;
     for (const line of text.split("\n")) {
+      if (line === "__ccdeck_gap__") { codexCostGap(pricing); continue; }
       if (!line) continue;
       let obj;
       try { obj = JSON.parse(line); } catch { continue; }
+      foldCodexCost(pricing, obj);
       // One record is one of these at most: each asks the record's own type.
       const meta = sessionMeta(obj);
       if (meta) {
@@ -251,28 +256,47 @@ export async function readCodexRollout(path) {
       if (obj?.type === "turn_context") effort = turnContextEffort(obj.payload);
     }
     if (!lastUsage && !model && !contextWindow) return null;
-    return { usage: lastUsage, model, contextWindow, cwd, effort };
+    const usageByModel = codexCostBuckets(pricing);
+    return { usage: lastUsage, model, contextWindow, cwd, effort,
+      ...(usageByModel ? { usageByModel } : {}) };
   } catch {
     return null;
   }
 }
 
-function maybeResolveCodex(payload) {
+function maybeResolveCodex(payload, opts = {}) {
   if (!payload || typeof payload !== "object") return;
   if (payload.provider !== "codex") return;
   const sid = payload.session_id;
   if (!sid) return;
-  codexUsageReads.run(sid, async () => {
+  let entry = codexUsageRequests.get(sid);
+  if (!entry) {
+    entry = { revision: 0, opts: {}, timer: null };
+    codexUsageRequests.set(sid, entry);
+  }
+  entry.revision++;
+  entry.opts = { persist: opts.persist };
+  runCodexUsageRead(sid, entry);
+}
+
+function runCodexUsageRead(sid, entry) {
+  if (codexUsageRequests.get(sid) !== entry) return;
+  const revision = entry.revision;
+  const emitOpts = entry.opts;
+  const started = codexUsageReads.run(sid, async () => {
     const path = await findCodexRolloutPath(sid);
-    if (!path) return;
+    if (!path || codexUsageRequests.get(sid) !== entry || entry.revision !== revision) return;
     const r = await readCodexRollout(path);
-    if (!r) return;
+    // Watcher activity, eviction or shutdown can supersede either await.
+    // Never let a delayed snapshot overwrite newer live observations.
+    if (!r || codexUsageRequests.get(sid) !== entry || entry.revision !== revision) return;
     if (r.usage) {
       pushEvent({
         hook_event_name: "UsageObserved",
         session_id: sid,
         usage: r.usage,
-      }, "internal");
+        usageByModel: r.usageByModel ?? null,
+      }, "internal", emitOpts);
     }
     if (r.model) {
       pushEvent({
@@ -282,7 +306,7 @@ function maybeResolveCodex(payload) {
         // A hook-delivered session has no watcher to spread it, so it rides
         // here, beside the model it qualifies.
         ...(r.effort !== undefined ? { reasoning_effort: r.effort } : {}),
-      }, "internal");
+      }, "internal", emitOpts);
     }
     if (r.contextWindow) {
       // Piggy-back on the model event with the window — reducer reads
@@ -292,9 +316,21 @@ function maybeResolveCodex(payload) {
         session_id: sid,
         model: r.model ?? undefined,
         model_context_window: r.contextWindow,
-      }, "internal");
+      }, "internal", emitOpts);
     }
   });
+  if (started) {
+    clearTimeout(entry.timer);
+    entry.timer = null;
+  } else if (!entry.timer) {
+    // Keep demand until a read actually starts, including while another read
+    // is pending. At most one unref'd retry timer exists for this session.
+    entry.timer = setTimeout(() => {
+      entry.timer = null;
+      runCodexUsageRead(sid, entry);
+    }, CODEX_READ_THROTTLE_MS + 1);
+    entry.timer.unref?.();
+  }
 }
 
 /**
@@ -305,6 +341,8 @@ function maybeResolveCodex(payload) {
 function forgetCodexSession(sid) {
   codexRolloutPathBySid.delete(sid);
   codexUsageReads.forget(sid);
+  clearTimeout(codexUsageRequests.get(sid)?.timer);
+  codexUsageRequests.delete(sid);
   codexSessionModel.delete(sid);
   codexSessionApproval.delete(sid);
   codexSessionEffort.delete(sid);
@@ -316,3 +354,9 @@ function forgetCodexSession(sid) {
 // at each declaration, so the declarations read as they did where they came
 // from.
 export { findCodexRolloutPath, forgetCodexSession, maybeResolveCodex };
+
+export function stopCodexEnrichment() {
+  for (const entry of codexUsageRequests.values()) clearTimeout(entry.timer);
+  codexUsageRequests.clear();
+  codexUsageReads.forgetAll();
+}

package/src/server/codex-review-policy.d.mts

@@ -0,0 +1,4 @@
+export const AUTO_REVIEW_MODEL: string;
+export const FREE_AUTO_REVIEW_TIER: string;
+export const FREE_AUTO_REVIEW_FROM: number;
+export function isFreeAutoReview(model: unknown, creator: unknown, at: unknown): boolean;

package/src/server/codex-review-policy.mjs

@@ -0,0 +1,11 @@
+// OpenAI confirms ChatGPT auto-review checks are free:
+// https://help.openai.com/en/articles/11369540-using-codex-with-your-chatgpt-plan
+// The announcement was on Oct 6. Use the following UTC day conservatively;
+// do not infer the exact historical billing cutover from the current policy.
+export const AUTO_REVIEW_MODEL = "codex-auto-review";
+export const FREE_AUTO_REVIEW_TIER = "chatgpt-auto-review-free";
+export const FREE_AUTO_REVIEW_FROM = Date.parse("2026-10-07T00:00:00Z");
+export function isFreeAutoReview(model, creator, at) {
+  return model === AUTO_REVIEW_MODEL && typeof creator === "string" && creator.trim().length > 0
+    && typeof at === "string" && Date.parse(at) >= FREE_AUTO_REVIEW_FROM;
+}

package/src/server/codex-skills.mjs

@@ -0,0 +1,146 @@
+// Which Codex skill a rollout line shows in use, for Skill activity (#2181).
+//
+// Codex writes no record of its own that a skill ran. Two things in a rollout
+// say so anyway:
+//
+//   - the `<skill>` message Codex injects when a person picks one with `$name`
+//     or /skills, which it writes only once the skill has loaded (explicit);
+//   - the model reading a skill's SKILL.md, or running one of its scripts, which
+//     is Codex's own rule for a skill it chose itself (detected).
+//
+// A detected use counts only for a skill in the catalog Codex gave that session
+// (its `<skills_instructions>` message) and only when the command succeeded, so
+// searching for SKILL.md files or reading a Claude skill is not a use. One use
+// per turn and skill: the turn id is the row's key, which also lands a forked
+// rollout's copy of its parent's turns on the rows the parent already wrote.
+import { posix, win32 } from "node:path";
+import { noteSkillUse } from "./tool-audit.mjs";
+import { readByteRange } from "./jsonl-chunks.mjs";
+
+// The catalog sits in the first lines of a rollout, a few tens of KB in.
+const CATALOG_HEAD_BYTES = 512 * 1024;
+const slashes = path => path.replace(/\\/g, "/");
+
+/** The skills a `<skills_instructions>` message lists: SKILL.md path → name,
+ *  and each skill's folder for its scripts. Null when the text has none. */
+export function parseSkillCatalog(text) {
+  const start = typeof text === "string" ? text.indexOf("<skills_instructions>") : -1;
+  if (start < 0) return null;
+  const roots = new Map(), files = new Map(), dirs = [];
+  const end = text.indexOf("</skills_instructions>", start);
+  for (const line of text.slice(start, end < 0 ? undefined : end).split("\n")) {
+    const root = /^- `(r\d+)` = `(.+)`\s*$/.exec(line);
+    if (root) { roots.set(root[1], slashes(root[2]).replace(/\/+$/, "")); continue; }
+    const entry = /^- (\S+): .*\(file: (r\d+)\/([^()]*\/SKILL\.md)\)\s*$/.exec(line);
+    if (!entry || !roots.has(entry[2])) continue;
+    const file = `${roots.get(entry[2])}/${slashes(entry[3])}`;
+    files.set(file, entry[1]);
+    dirs.push([file.slice(0, -"SKILL.md".length), entry[1]]);
+  }
+  return files.size ? { files, dirs } : null;
+}
+
+/** The catalog a rollout began with, for a session this deck joined late. */
+export async function readCodexSkillCatalog(path) {
+  try {
+    const head = await readByteRange(path, 0, CATALOG_HEAD_BYTES);
+    for (const line of head.split("\n")) {
+      if (!line.includes("<skills_instructions>")) continue;
+      return parseSkillCatalog(messageText(JSON.parse(line)?.payload));
+    }
+  } catch {}
+  return null;
+}
+
+function messageText(payload) {
+  if (payload?.type !== "message" || !Array.isArray(payload.content)) return "";
+  return payload.content.map(part => typeof part?.text === "string" ? part.text : "").join("\n");
+}
+
+// A rollout's paths are its own machine's, so their shape picks the rules, not
+// the host reading them: `fileURLToPath` refuses a drive-less file URL on
+// Windows, and the host's `resolve` would put its own drive letter in front.
+const windowsPath = path => /^(?:[A-Za-z]:[\\/]|\\\\|\/\/)/.test(path);
+const localPath = value => {
+  if (typeof value !== "string" || !value) return null;
+  if (!value.startsWith("file://")) return value;
+  try {
+    const { host, pathname } = new URL(value);
+    const path = decodeURIComponent(pathname);
+    return host ? `//${host}${path}` : /^\/[A-Za-z]:\//.test(path) ? path.slice(1) : path;
+  } catch { return null; }
+};
+const resolveIn = (cwd, path) => (windowsPath(cwd) ? win32 : posix).resolve(cwd, path);
+
+/** A finished command that may have touched a skill: worth reading the catalog for. */
+const commandItem = obj => {
+  const item = obj?.type === "event_msg" && obj.payload?.type === "item_completed" ? obj.payload.item : null;
+  return item?.type === "CommandExecution" && item.exit_code === 0 && Array.isArray(item.parsed_cmd) ? item : null;
+};
+
+/** Per-rollout state: the catalog (undefined until known, null for none), the
+ *  turn the last `task_started` opened, and the turn-and-skill keys counted. */
+export const codexSkillState = () => ({ catalog: undefined, turn: null, seen: new Set(), waiting: [], loading: false });
+
+/**
+ * The skill uses one rollout line shows, as `{ key, name, origin, at }`.
+ * `skills` is the rollout's codexSkillState. A command names its own turn; the
+ * injected `<skill>` message names none and belongs to the turn just opened.
+ */
+export function codexSkillUses(obj, skills) {
+  const pl = obj?.payload;
+  const at = typeof obj?.timestamp === "string" ? Date.parse(obj.timestamp) : undefined;
+  if (obj?.type === "event_msg" && pl?.type === "task_started" && typeof pl.turn_id === "string") { skills.turn = pl.turn_id; return []; }
+  const turn = (typeof pl?.turn_id === "string" ? pl.turn_id : skills.turn) ?? `at:${obj?.timestamp ?? ""}`;
+  const use = (name, origin) => {
+    const key = `${turn}|${name}`;
+    if (skills.seen.has(key)) return [];
+    if (skills.seen.size >= 256) skills.seen.clear();
+    skills.seen.add(key);
+    return [{ key, name, origin, at }];
+  };
+  if (obj?.type === "response_item" && pl?.type === "message") {
+    const text = messageText(pl);
+    if (pl.role === "developer" && text.includes("<skills_instructions>")) { skills.catalog = parseSkillCatalog(text); return []; }
+    if (pl.role !== "user") return [];
+    return [...text.matchAll(/<skill>\s*<name>([^<]+)<\/name>/g)].flatMap(m => use(m[1].trim(), "typed"));
+  }
+  const item = commandItem(obj);
+  if (!item || !skills.catalog) return [];
+  const cwd = localPath(item.cwd);
+  const found = [];
+  for (const parsed of item.parsed_cmd) {
+    if (parsed?.type === "read" && typeof parsed.path === "string") {
+      const name = skills.catalog.files.get(slashes(cwd ? resolveIn(cwd, parsed.path) : parsed.path));
+      if (name) found.push(name);
+    } else if (parsed?.type === "unknown" && typeof parsed.cmd === "string") {
+      const cmd = slashes(parsed.cmd);
+      for (const [dir, name] of skills.catalog.dirs) if (cmd.includes(`${dir}scripts/`)) found.push(name);
+    }
+  }
+  return [...new Set(found)].flatMap(name => use(name, "detected"));
+}
+
+/**
+ * Count the skills one rollout line shows. `state` is the watcher's cursor for
+ * the rollout: its session, cwd, subagent link and path. A command that may
+ * read a skill, in a session joined after its catalog went by, waits for the
+ * catalog to be read off the head of the file.
+ */
+export function noteCodexSkills(obj, state, note = noteSkillUse) {
+  const skills = state.skills ??= codexSkillState();
+  const session = state.link?.parent_session_id ?? state.sid, cwd = state.cwd, subagent = !!state.link;
+  const send = uses => { for (const use of uses) note({ ...use, session, cwd, subagent }); };
+  if (skills.catalog === undefined && commandItem(obj) && state.path) {
+    skills.waiting.push(obj);
+    if (!skills.loading) {
+      skills.loading = true;
+      void readCodexSkillCatalog(state.path).then(catalog => {
+        if (skills.catalog === undefined) skills.catalog = catalog;
+        for (const line of skills.waiting.splice(0)) send(codexSkillUses(line, skills));
+      });
+    }
+    return;
+  }
+  send(codexSkillUses(obj, skills));
+}

package/src/server/codex-watch.mjs

@@ -16,6 +16,7 @@ import { STOP, rolloutNameId, sidFromRolloutName, walkRolloutDays } from "./code
 // record that says whose rollout it is — see codex-translate.mjs. The watcher
 // below still decides which lines are read and where each one goes.
 import { codexObjToPayload, codexSessionModel, sessionMeta } from "./codex-translate.mjs";
+import { noteCodexSkills } from "./codex-skills.mjs";
 import { codexCwdInWorkspace, writesCodexLog } from "./log-election.mjs";
 // The one spelling of a rollout's cwd — see canonical-path.mjs.
 import { canonicalCwd } from "./canonical-path.mjs";
@@ -351,7 +352,7 @@ async function openCodexCursor(path, st, now, firstRun, recover = false) {
   // UsageObserved in the file to every tab, and re-appending the lot to
   // the shared events.jsonl if this deck is the elected writer (#981).
   const fresh = !codexSeenEver.has(path);
-  const state = { offset: fresh ? 0 : st.size, sid: header.sid, cwd: header.cwd, link: header.link, skip: false, sawBeginning: fresh, rootOpened: false, seenAt: now };
+  const state = { offset: fresh ? 0 : st.size, sid: header.sid, cwd: header.cwd, link: header.link, skip: false, sawBeginning: fresh, rootOpened: false, seenAt: now, path };
   codexFileState.set(path, state);
   rememberCodexPath(path);
   if (firstRun) {
@@ -409,6 +410,8 @@ function emitCodexLines(state, consume, persist) {
     if (!line) continue;
     let obj;
     try { obj = JSON.parse(line); } catch { continue; }
+    // Skill activity reads the line itself: what says a skill ran is not an event.
+    noteCodexSkills(obj, state);
     const prevModel = codexSessionModel.get(state.sid);
     const payload = codexObjToPayload(obj, state.sid, state.cwd);
     const link = codexThreadLink(obj, state.sid, state.cwd);
@@ -486,7 +489,7 @@ async function openGrownOlderRollouts(now) {
     // Never `sawBeginning`, whatever this process read of the file before: the
     // lines before `was` are ones this deck has either drawn already or joined
     // too late for, and either way a SessionStart now would be a false one.
-    const state = { offset: skip ? st.size : was, sid: header.sid, cwd: header.cwd, link: header.link, skip, sawBeginning: false, rootOpened: false, seenAt: now, mtimeMs: st.mtimeMs };
+    const state = { offset: skip ? st.size : was, sid: header.sid, cwd: header.cwd, link: header.link, skip, sawBeginning: false, rootOpened: false, seenAt: now, mtimeMs: st.mtimeMs, path };
     codexFileState.set(path, state);
     rememberCodexPath(path);
     opened.push({ path, st, state });