devflow-kit 3.4.0 → 3.6.0

package/dist/core/tracker.js

@@ -60,6 +60,44 @@ export const TRACKER_PROVIDER_IDS = TRACKER_PROVIDERS.map(p => p.id);
  */
 export const DEFAULT_TRACKER_PROVIDER = 'github';
 // ---------------------------------------------------------------------------
+// Tracker tool servers — the allowlist half of the Git and Tracker agents
+// ---------------------------------------------------------------------------
+/**
+ * D-TRACKER-SERVER-ALLOWLIST: the Git and Tracker agents hold a tool ALLOWLIST, and the
+ * tracker tool servers a user has connected differ per machine, so the shipped allowlist
+ * names no server (the agent sources stay vendor-neutral). The installer stamps one
+ * whole-server entry per name below onto the INSTALLED `tools:` line of those two agents
+ * (`stampAgentTools`, src/core/agent-frontmatter.ts), after the file is copied. Claude Code
+ * has no pattern form for an allowlist entry, so a server is granted by its name; a name
+ * that matches no connected server is inert (it grants nothing and blocks nothing).
+ *
+ * The default is one FLAT list, stamped whatever the provider: every install carries every
+ * provider, and a repository may select a provider other than the machine's, so a list
+ * keyed on the machine's provider would strand that repository. A server the user runs
+ * under another name is added with `devflow tracker --servers`. A wrong or missing name
+ * does not fail silently: the agent finds no tool for the capability it needs and reports
+ * `TRACEABILITY: DEGRADED (no tracker tool for {capability})`.
+ *
+ * The default leaves `github` out. Under the github provider the Git agent uses `gh` and
+ * never reads `_mcp.md`, so a stamped `github` server is never used by a tracker operation;
+ * under jira or linear, a connected GitHub server that also advertises issue creation would
+ * make the `_mcp.md` capability selection ambiguous, which is a degraded run. A user who
+ * wants it adds it with `devflow tracker --servers`.
+ */
+export const TRACKER_MCP_SERVERS_DEFAULT = Object.freeze([
+    'atlassian',
+    'jira',
+    'claude_ai_Atlassian',
+    'linear',
+    'claude_ai_Linear',
+]);
+/** A server name as a user may configure it. Byte-exact, like a provider token. */
+export const TRACKER_SERVER_NAME_RE = /^[A-Za-z0-9_-]{1,64}$/;
+/** The most servers one list may hold; every entry lands in a prompt-adjacent frontmatter line. */
+export const TRACKER_SERVERS_MAX = 32;
+/** The reserved word that returns the setting to {@link TRACKER_MCP_SERVERS_DEFAULT}. */
+export const TRACKER_SERVERS_DEFAULT_WORD = 'default';
+// ---------------------------------------------------------------------------
 // Artifact basenames — one spelling for every TypeScript reader
 //
 // NOT the only spelling in the repository, and a rename that assumes it is will
@@ -238,6 +276,72 @@ export function parseTrackerId(input) {
     }
     return { ok: true, value: input };
 }
+/**
+ * Validate a list of tracker server names. The one rule set behind both the CLI argument
+ * and the manifest field.
+ *
+ * REJECT, NEVER REPAIR (as {@link parseTrackerId}): a name is accepted byte-exact against
+ * {@link TRACKER_SERVER_NAME_RE} and must not hold `__`, which is what separates a server
+ * from its tool in an entry such as `mcp__server__tool`. No trim, no case folding, no
+ * alias. Exact duplicates collapse to the first occurrence and the order is kept. The list
+ * is non-empty and holds at most {@link TRACKER_SERVERS_MAX} distinct names.
+ */
+export function validateTrackerServers(raw) {
+    if (raw.length === 0) {
+        return { ok: false, error: 'No tracker servers given. Pass one or more server names, or "default".' };
+    }
+    const seen = new Set();
+    for (const entry of raw) {
+        if (typeof entry !== 'string' || !TRACKER_SERVER_NAME_RE.test(entry)) {
+            return {
+                ok: false,
+                error: `Invalid tracker server name: "${describeTrackerValue(entry)}". ` +
+                    'Names are 1-64 characters from A-Z, a-z, 0-9, "_" and "-".',
+            };
+        }
+        if (entry.includes('__')) {
+            return {
+                ok: false,
+                error: `Invalid tracker server name: "${describeTrackerValue(entry)}". ` +
+                    'A name must not contain "__" (it separates a server from its tool).',
+            };
+        }
+        seen.add(entry);
+    }
+    if (seen.size > TRACKER_SERVERS_MAX) {
+        return { ok: false, error: `Too many tracker servers: ${seen.size} (at most ${TRACKER_SERVERS_MAX}).` };
+    }
+    return { ok: true, value: [...seen] };
+}
+/**
+ * Strict boundary parser for `devflow tracker --servers <list>`.
+ *
+ * `default` alone selects {@link TRACKER_MCP_SERVERS_DEFAULT}; anything else is a
+ * comma-separated list of names handed to {@link validateTrackerServers} unchanged. An
+ * empty argument, an empty item (`a,,b`, a trailing comma) and the reserved word inside a
+ * list are errors, never silently dropped.
+ */
+export function parseTrackerServers(input) {
+    if (input === '') {
+        return { ok: false, error: 'Missing tracker servers. Pass a comma-separated list of names, or "default".' };
+    }
+    if (input === TRACKER_SERVERS_DEFAULT_WORD)
+        return { ok: true, value: { kind: 'default' } };
+    const items = input.split(',');
+    if (items.includes(TRACKER_SERVERS_DEFAULT_WORD)) {
+        return { ok: false, error: `"${TRACKER_SERVERS_DEFAULT_WORD}" is reserved: pass it alone, not inside a list.` };
+    }
+    const validated = validateTrackerServers(items);
+    return validated.ok ? { ok: true, value: { kind: 'list', servers: validated.value } } : validated;
+}
+/** The servers in force for `state`: its own list, else the default. */
+export function effectiveTrackerServers(state) {
+    return state.servers ?? TRACKER_MCP_SERVERS_DEFAULT;
+}
+/** The whole-server allowlist entries for `servers`, in order: `github` becomes `mcp__github`. */
+export function trackerServerTools(servers) {
+    return servers.map(name => `mcp__${name}`);
+}
 /**
  * Tolerant sink normaliser for a raw `manifest.features.tracker` value.
  *
@@ -249,9 +353,11 @@ export function parseTrackerId(input) {
  * D-TRACKER-SELF-HEAL [DR-26]: self-healing here is SILENT and emits no
  * DEGRADED — that is the correct self-heal behaviour, and it is a different
  * condition from a per-repo config value outside the domain (which does emit
- * `unknown tracker provider`). The two must not be conflated.
+ * `unknown tracker provider`). The two must not be conflated. The one exception is
+ * `servers` (see the body): a present but invalid list heals to the default AND reaches
+ * `onWarning` when a caller supplies one, because the user wrote that list on purpose.
  */
-export function normalizeTrackerFeature(raw) {
+export function normalizeTrackerFeature(raw, onWarning) {
     const DEFAULT = { provider: DEFAULT_TRACKER_PROVIDER };
     if (raw === null || raw === undefined || typeof raw !== 'object' || Array.isArray(raw)) {
         return DEFAULT;
@@ -259,6 +365,18 @@ export function normalizeTrackerFeature(raw) {
     const obj = raw;
     if (!isTrackerProvider(obj.provider))
         return DEFAULT;
+    // `servers`: absent is the default, silently. A present value that is not a valid list is
+    // dropped WHOLE (never trimmed to its valid names) and reported through `onWarning`, which a
+    // caller with a terminal passes; the reader itself has no output channel. The state then
+    // reads as the default list, and the next `devflow tracker --servers` or `devflow init`
+    // writes the manifest without the bad value.
+    if (obj.servers === undefined)
+        return { provider: obj.provider };
+    const servers = Array.isArray(obj.servers) ? validateTrackerServers(obj.servers) : undefined;
+    if (servers?.ok === true)
+        return { provider: obj.provider, servers: servers.value };
+    onWarning?.(`The manifest's tracker servers setting is not a valid list (${servers?.ok === false ? servers.error : 'not a list'}); ` +
+        'using the default. Run `devflow tracker --servers <names>` to set it, or `devflow tracker --servers default`.');
     return { provider: obj.provider };
 }
 // ---------------------------------------------------------------------------

package/dist/hud/codex-usage.js

@@ -0,0 +1,247 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { readCache, writeCache, hudCacheDir } from '../core/cache.js';
+const CODEX_CACHE_KEY = 'codex-quota';
+const CODEX_CACHE_TTL_MS = 30_000;
+/** Rollouts last modified longer ago than this are not read. */
+export const CODEX_MAX_AGE_MS = 8 * 24 * 60 * 60 * 1000;
+/** The first read of a rollout, and the one larger read when it holds no record. */
+export const CODEX_TAIL_BYTES = 1024 * 1024;
+export const CODEX_TAIL_RETRY_BYTES = 4 * 1024 * 1024;
+const MAX_YEAR_DIRS = 3;
+const MAX_DAY_DIRS = 14;
+const MAX_ROLLOUTS_PER_DAY = 200;
+const MAX_ROLLOUTS_READ = 3;
+const YEAR_DIR = /^\d{4}$/;
+const MONTH_DIR = /^(0[1-9]|1[0-2])$/;
+const DAY_DIR = /^(0[1-9]|[12]\d|3[01])$/;
+const ROLLOUT_FILE = /^rollout-.*\.jsonl$/;
+/**
+ * D-CODEX-LOCAL-LOGS-ONLY: Codex usage comes from the rate-limit records the
+ * Codex CLI already writes to its own session logs under ~/.codex/sessions. The
+ * statusline reads those logs and nothing else: it opens no credential file
+ * (auth.json) and makes no network call, so it cannot leak a token or stall on a
+ * request. Reason: the HUD runs on every prompt under a 2 s budget, and Codex
+ * publishes the account's limits in every model response it logs.
+ *
+ * The directory is always <home>/.codex, as the proxy's Codex credential check
+ * resolves it; a CODEX_HOME override is not honoured.
+ */
+export function codexSessionsDir(home) {
+    return path.join(home, '.codex', 'sessions');
+}
+function asRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function makeWindow(minutes, usedPercent, resetsAt) {
+    if (!isFiniteNumber(minutes) || minutes <= 0 || !isFiniteNumber(usedPercent) || !isFiniteNumber(resetsAt)) {
+        return null;
+    }
+    return { minutes, usedPercent: Math.max(0, Math.min(100, usedPercent)), resetsAt };
+}
+function makeUsage(windows, limitReached) {
+    if (windows.length === 0)
+        return null;
+    return {
+        windows: [...windows].sort((a, b) => a.minutes - b.minutes),
+        limitReached: typeof limitReached === 'string' && limitReached !== '' ? limitReached : null,
+    };
+}
+/**
+ * D-CODEX-WINDOW-BY-MINUTES: a window is identified by its window_minutes, never
+ * by the primary/secondary slot it arrives in. Reason: the slots carry different
+ * windows per plan (a prolite plan has the weekly window as primary and no
+ * secondary, a team plan a 5h primary and a weekly secondary), so a slot-keyed
+ * reader would label one plan's weekly window as the other's 5h one.
+ *
+ * Parses one rollout line into usage. Accepts only a token_count event whose
+ * rate_limits are the codex limit with at least one complete window; premium
+ * records, null windows, `rate_limits: null` and malformed lines are skipped.
+ */
+function parseUsageLine(line) {
+    let record;
+    try {
+        record = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    const payload = asRecord(asRecord(record)?.payload);
+    if (payload === null || payload.type !== 'token_count')
+        return null;
+    const limits = asRecord(payload.rate_limits);
+    if (limits === null || limits.limit_id !== 'codex')
+        return null;
+    const windows = [];
+    for (const slot of [limits.primary, limits.secondary]) {
+        const raw = asRecord(slot);
+        const parsed = raw && makeWindow(raw.window_minutes, raw.used_percent, raw.resets_at);
+        if (parsed)
+            windows.push(parsed);
+    }
+    return makeUsage(windows, limits.rate_limit_reached_type);
+}
+/** The last line in `text` that holds a valid record, scanning backwards. */
+function lastUsageIn(text) {
+    const lines = text.split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+        // Cheap prefilter: most lines are not token_count events and are never parsed.
+        if (!lines[i].includes('"token_count"'))
+            continue;
+        const usage = parseUsageLine(lines[i]);
+        if (usage)
+            return usage;
+    }
+    return null;
+}
+/** Read the last `bytes` bytes of `file`. `whole` is true when that covered the entire file. */
+function readTail(file, bytes) {
+    let fd;
+    try {
+        fd = fs.openSync(file, 'r');
+    }
+    catch {
+        return null;
+    }
+    try {
+        const size = fs.fstatSync(fd).size;
+        const length = Math.min(size, bytes);
+        const buf = Buffer.alloc(length);
+        let total = 0;
+        while (total < length) {
+            const read = fs.readSync(fd, buf, total, length - total, size - length + total);
+            if (read === 0)
+                break;
+            total += read;
+        }
+        return { text: buf.toString('utf-8', 0, total), whole: length === size };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/**
+ * The newest valid record in `file`, from its tail only. The first read takes
+ * CODEX_TAIL_BYTES; if that holds no record and the file is longer, one retry takes
+ * CODEX_TAIL_RETRY_BYTES. Rollouts reach tens of MB, and a tail holds the newest
+ * records.
+ */
+function latestUsageInFile(file) {
+    for (const bytes of [CODEX_TAIL_BYTES, CODEX_TAIL_RETRY_BYTES]) {
+        const tail = readTail(file, bytes);
+        if (tail === null)
+            return null;
+        const usage = lastUsageIn(tail.text);
+        if (usage !== null || tail.whole)
+            return usage;
+    }
+    return null;
+}
+/** Names of the entries of `dir` of one kind matching `pattern`, newest (greatest) first. */
+function listNames(dir, kind, pattern) {
+    try {
+        return fs
+            .readdirSync(dir, { withFileTypes: true })
+            .filter((e) => (kind === 'dir' ? e.isDirectory() : e.isFile()) && pattern.test(e.name))
+            .map((e) => e.name)
+            .sort()
+            .reverse();
+    }
+    catch {
+        return [];
+    }
+}
+/** The newest MAX_DAY_DIRS day directories, by name: sessions/YYYY/MM/DD. */
+function recentDayDirs(sessionsDir) {
+    const days = [];
+    for (const year of listNames(sessionsDir, 'dir', YEAR_DIR).slice(0, MAX_YEAR_DIRS)) {
+        for (const month of listNames(path.join(sessionsDir, year), 'dir', MONTH_DIR)) {
+            for (const day of listNames(path.join(sessionsDir, year, month), 'dir', DAY_DIR)) {
+                if (days.length >= MAX_DAY_DIRS)
+                    return days;
+                days.push(path.join(sessionsDir, year, month, day));
+            }
+        }
+    }
+    return days;
+}
+/**
+ * D-CODEX-NEWEST-MTIME: the newest data is in the most recently modified rollout,
+ * not the newest-named one. Reason: a day directory is named for the day its
+ * session started, and Codex keeps appending to a session for days, so a rollout in
+ * an older directory can hold today's records. Only the newest MAX_DAY_DIRS day
+ * directories are searched and rollouts untouched for CODEX_MAX_AGE_MS are
+ * ignored, which bounds the work on a long-lived ~/.codex.
+ */
+function recentRollouts(sessionsDir, now) {
+    const rollouts = [];
+    for (const dayDir of recentDayDirs(sessionsDir)) {
+        for (const name of listNames(dayDir, 'file', ROLLOUT_FILE).slice(0, MAX_ROLLOUTS_PER_DAY)) {
+            const file = path.join(dayDir, name);
+            try {
+                const mtimeMs = fs.statSync(file).mtimeMs;
+                if (now - mtimeMs <= CODEX_MAX_AGE_MS)
+                    rollouts.push({ file, mtimeMs });
+            }
+            catch {
+                // Rollout vanished between listing and stat.
+            }
+        }
+    }
+    return rollouts.sort((a, b) => b.mtimeMs - a.mtimeMs).map((r) => r.file);
+}
+/**
+ * Codex's latest rate-limit record, or null when there is none to show: no sessions
+ * directory, no rollout modified within CODEX_MAX_AGE_MS, or no valid record in the
+ * newest MAX_ROLLOUTS_READ of them (a session that has not yet had a model response
+ * holds no record, so the next-newest rollout is tried).
+ *
+ * @param sessionsDir  Codex's sessions directory (see codexSessionsDir).
+ * @param now          Epoch milliseconds, for the rollout age bound.
+ */
+export function readCodexUsage(sessionsDir, now) {
+    for (const file of recentRollouts(sessionsDir, now).slice(0, MAX_ROLLOUTS_READ)) {
+        const usage = latestUsageInFile(file);
+        if (usage !== null)
+            return usage;
+    }
+    return null;
+}
+function validateCodexUsage(data) {
+    const obj = asRecord(data);
+    if (obj === null || !Array.isArray(obj.windows))
+        return null;
+    const windows = [];
+    for (const entry of obj.windows) {
+        const raw = asRecord(entry);
+        const parsed = raw && makeWindow(raw.minutes, raw.usedPercent, raw.resetsAt);
+        if (!parsed)
+            return null;
+        windows.push(parsed);
+    }
+    return makeUsage(windows, obj.limitReached);
+}
+/**
+ * Codex usage for the statusline: the cached read while it is under 30 s old, else
+ * a fresh read of the logs, cached when it found a record. A run that finds none
+ * caches nothing and rescans, which is a handful of directory reads.
+ */
+export async function gatherCodexUsage(devflowDir, sessionsDir, now = Date.now()) {
+    const cacheDir = hudCacheDir(devflowDir);
+    const cached = readCache(cacheDir, CODEX_CACHE_KEY, validateCodexUsage);
+    if (cached !== null)
+        return cached;
+    const usage = readCodexUsage(sessionsDir, now);
+    if (usage !== null)
+        await writeCache(cacheDir, CODEX_CACHE_KEY, usage, CODEX_CACHE_TTL_MS);
+    return usage;
+}
+//# sourceMappingURL=codex-usage.js.map

package/dist/hud/components/codex-quota.js

@@ -0,0 +1,37 @@
+import { dim, red } from '../colors.js';
+import { renderQuotaWindow } from './usage-quota.js';
+/** "5h" for 300 minutes, "7d" for 10080; any other length reads as whole days, whole hours, else minutes. */
+function windowLabel(minutes) {
+    if (minutes % 1440 === 0)
+        return `${minutes / 1440}d`;
+    if (minutes % 60 === 0)
+        return `${minutes / 60}h`;
+    return `${minutes}m`;
+}
+/**
+ * Codex usage limits, in usage-quota's style: "Codex 5h ███░░░░░ 40% (1h 2m) · 7d ...".
+ *
+ * A window whose resets_at has passed has reset since Codex last logged it, so it
+ * renders as 0% with no countdown rather than as the stale figure. The red
+ * "limited" marker shows while Codex reports a reached limit and at least one
+ * window is still counting down; once every window has reset the limit is lifted
+ * and the stale marker is dropped.
+ */
+export default async function codexQuota(ctx) {
+    const usage = ctx.codexUsage;
+    if (!usage || usage.windows.length === 0)
+        return null;
+    const nowMs = Date.now();
+    const hasReset = (resetsAt) => resetsAt * 1000 <= nowMs;
+    const parts = usage.windows.map((w) => hasReset(w.resetsAt)
+        ? renderQuotaWindow(windowLabel(w.minutes), 0, null)
+        : renderQuotaWindow(windowLabel(w.minutes), w.usedPercent, w.resetsAt));
+    const limited = usage.limitReached !== null && usage.windows.some((w) => !hasReset(w.resetsAt));
+    return {
+        text: dim('Codex ') +
+            parts.map((p) => p.text).join(dim(' · ')) +
+            (limited ? ' ' + red('limited') : ''),
+        raw: 'Codex ' + parts.map((p) => p.raw).join(' · ') + (limited ? ' limited' : ''),
+    };
+}
+//# sourceMappingURL=codex-quota.js.map

package/dist/hud/components/usage-quota.js

@@ -48,7 +48,7 @@ export function formatCountdown(resetsAtEpoch) {
     return `${totalMinutes}m`;
 }
 /** Render a single quota window: "5h ████░░░░ 45% (2h 15m)" */
-function renderQuotaWindow(label, percent, resetsAt) {
+export function renderQuotaWindow(label, percent, resetsAt) {
     const bar = renderBar(Math.round(percent));
     const countdown = resetsAt != null ? formatCountdown(resetsAt) : '';
     const countdownText = countdown ? dim(` (${countdown})`) : '';

package/dist/hud/config.js

@@ -18,6 +18,7 @@ export const HUD_COMPONENTS = [
     'versionBadge',
     'sessionCost',
     'usageQuota',
+    'codexQuota',
     'todoProgress',
     'configCounts',
     'learningCounts',

package/dist/hud/index.js

@@ -4,6 +4,7 @@ import { homedir } from 'node:os';
 import { readStdin } from './stdin.js';
 import { loadConfig, resolveComponents } from './config.js';
 import { gatherGitStatus } from './git.js';
+import { codexSessionsDir, gatherCodexUsage } from './codex-usage.js';
 import { parseTranscript } from './transcript.js';
 import { persistSessionCost, aggregateCosts } from './cost-history.js';
 import { gatherConfigCounts } from './components/config-counts.js';
@@ -36,7 +37,10 @@ function extractUsageFromStdin(stdin) {
     };
 }
 async function main() {
-    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), OVERALL_TIMEOUT));
+    let timer;
+    const timeoutPromise = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error('timeout')), OVERALL_TIMEOUT);
+    });
     try {
         const result = await Promise.race([run(), timeoutPromise]);
         process.stdout.write(result);
@@ -44,6 +48,11 @@ async function main() {
     catch {
         // Timeout or error — output nothing (graceful degradation)
     }
+    finally {
+        // A live timer would keep node running for the rest of the budget after the
+        // line is printed, delaying every status-line render by about 2 s.
+        clearTimeout(timer);
+    }
 }
 async function run() {
     const stdin = await readStdin();
@@ -56,7 +65,8 @@ async function run() {
     const components = new Set(resolved);
     const cwd = stdin.cwd || process.cwd();
     // D-ONE-HOME: always $HOME/.devflow — no environment variable relocates it.
-    const devflowDir = path.join(process.env.HOME || homedir(), '.devflow');
+    const home = process.env.HOME || homedir();
+    const devflowDir = path.join(home, '.devflow');
     // Determine what data to gather based on enabled components
     const needsGit = components.has('gitBranch') ||
         components.has('gitAheadBehind') ||
@@ -67,15 +77,17 @@ async function run() {
         components.has('configCounts');
     const needsConfigCounts = components.has('configCounts');
     const needsLearningCounts = components.has('learningCounts');
+    const needsCodexUsage = components.has('codexQuota');
     const needsSessionCost = components.has('sessionCost');
     // Parallel data gathering — only fetch what's needed. The learning counts
     // ride here because resolving the ledger root is one git call.
-    const [git, transcript, learningCountsData] = await Promise.all([
+    const [git, transcript, learningCountsData, codexUsage] = await Promise.all([
         needsGit ? gatherGitStatus(cwd) : Promise.resolve(null),
         needsTranscript && stdin.transcript_path
             ? parseTranscript(stdin.transcript_path)
             : Promise.resolve(null),
         needsLearningCounts ? gatherLedgerLearningCounts(cwd) : Promise.resolve(null),
+        needsCodexUsage ? gatherCodexUsage(devflowDir, codexSessionsDir(home)) : Promise.resolve(null),
     ]);
     // Extract usage quota from stdin rate_limits (replaces OAuth fetch)
     const usage = components.has('usageQuota') ? extractUsageFromStdin(stdin) : null;
@@ -108,6 +120,7 @@ async function run() {
         git,
         transcript,
         usage,
+        codexUsage,
         configCounts: configCountsData,
         learningCounts: learningCountsData,
         costHistory,

package/dist/hud/render.js

@@ -8,6 +8,7 @@ import contextUsage from './components/context-usage.js';
 import versionBadge from './components/version-badge.js';
 import sessionDuration from './components/session-duration.js';
 import usageQuota from './components/usage-quota.js';
+import codexQuota from './components/codex-quota.js';
 import todoProgress from './components/todo-progress.js';
 import configCounts from './components/config-counts.js';
 import learningCounts from './components/learning-counts.js';
@@ -24,6 +25,7 @@ const COMPONENT_MAP = {
     versionBadge,
     sessionDuration,
     usageQuota,
+    codexQuota,
     todoProgress,
     configCounts,
     learningCounts,
@@ -37,7 +39,7 @@ const COMPONENT_MAP = {
  */
 const LINE_GROUPS = [
     ['directory', 'gitBranch', 'gitAheadBehind', 'releaseInfo', 'worktreeCount', 'diffStats'],
-    ['contextUsage', 'usageQuota', 'todoProgress'],
+    ['contextUsage', 'usageQuota', 'codexQuota', 'todoProgress'],
     ['model', 'configCounts', 'sessionCost'],
     ['learningCounts'],
     ['versionBadge'],