devflow-kit 3.5.0 → 3.6.0

package/dist/core/plugins.js

@@ -34,7 +34,7 @@ export const DEVFLOW_PLUGINS = [
          *
          * Guard 5 reverse (registry-integrity.test.ts, "declared agents are spawned")
          * skips a plugin whose commands spawn nothing — `if (spawned.size === 0)
-         * continue` — and this plugin ships no commands at all. So `learning` and
+         * continue` — and this plugin ships no commands at all. So `curate` and
          * `tracker`, which are spawned by a SessionStart directive rather than by any
          * command, satisfy the reverse check STRUCTURALLY.
          *
@@ -48,11 +48,13 @@ export const DEVFLOW_PLUGINS = [
          * set-equal, both directions, against the `agentType` values present in
          * dist/commands/, and a hook-spawned agent appears in none of them.
          */
-        agents: ['learning', 'tracker'],
+        agents: ['curate', 'tracker'],
         /**
          * D-AGENT-REFS: `agent-references` is a reference-only skill. It holds the Synthesize mode
-         * templates and the Learning maintain step, which those two agents read by explicit path, so
-         * it sits here (core-skills is always installed) and no other plugin lists or requires it.
+         * templates and the Curate maintain step, which those two agents read by explicit path, and
+         * the command branches that D-CMD-REF-HAND moves out of a command (`references/commands/`),
+         * which a command reads by explicit path, so it sits here (core-skills is always installed)
+         * and no other plugin lists or requires it.
          * It is never preloaded: tests/guards/agent-references.test.ts holds that, and the one
          * exception to the repo-wide ban on `disable-model-invocation` names this skill alone.
          */
@@ -102,7 +104,7 @@ export const DEVFLOW_PLUGINS = [
         name: 'devflow-implement',
         description: 'Complete task implementation workflow - accepts plan documents, issues, or task descriptions',
         commands: ['/implement'],
-        agents: ['git', 'code', 'code-fix', 'simplify', 'scrutinize', 'evaluate', 'test', 'validate', 'knowledge'],
+        agents: ['git', 'code', 'fix', 'polish', 'harden', 'evaluate', 'test', 'validate', 'knowledge'],
         skills: ['patterns', 'qa', 'quality-gates', 'worktree-support', 'feature-knowledge', 'apply-feature-knowledge'],
         requires: [
             'apply-decisions',
@@ -141,7 +143,7 @@ export const DEVFLOW_PLUGINS = [
         name: 'devflow-resolve',
         description: 'Process and fix code review issues with blast-radius triage, Code agent fixes, and Validate agent verification',
         commands: ['/resolve'],
-        agents: ['git', 'triage', 'code', 'code-fix', 'simplify', 'validate', 'test', 'knowledge'],
+        agents: ['git', 'triage', 'code', 'fix', 'polish', 'validate', 'test', 'knowledge'],
         skills: ['patterns', 'worktree-support', 'feature-knowledge', 'apply-feature-knowledge', 'apply-decisions'],
         requires: [
             'architecture',
@@ -167,7 +169,7 @@ export const DEVFLOW_PLUGINS = [
         name: 'devflow-debug',
         description: 'Debugging workflows with competing hypothesis investigation via parallel subagents',
         commands: ['/debug'],
-        agents: ['git', 'synthesize', 'simplify', 'knowledge', 'explore', 'code'],
+        agents: ['git', 'synthesize', 'polish', 'knowledge', 'explore', 'code'],
         skills: ['git', 'worktree-support', 'feature-knowledge', 'apply-feature-knowledge'],
         // D-DEBUG-FIX-VIA-CODE: the fix is a Code spawn. Code loads no skill by language or mode
         // (D-NO-RUNTIME-SKILLS), so `requires:` lists only the skills this command, its agents and the
@@ -232,9 +234,9 @@ export const DEVFLOW_PLUGINS = [
     },
     {
         name: 'devflow-self-review',
-        description: 'Self-review workflow: Simplify agent + Scrutinize agent for code quality',
+        description: 'Self-review workflow: Polish agent + Harden agent for code quality',
         commands: ['/self-review'],
-        agents: ['simplify', 'scrutinize', 'validate', 'knowledge'],
+        agents: ['polish', 'harden', 'validate', 'knowledge'],
         skills: ['quality-gates', 'software-design', 'worktree-support', 'feature-knowledge', 'apply-feature-knowledge'],
         // D-PRELOAD-TRIM: no agent, command or skill in this plugin's corpus names
         // `testing` (Validate preloads only `worktree-support`), so it is not required here.
@@ -245,7 +247,7 @@ export const DEVFLOW_PLUGINS = [
         name: 'devflow-bug-analysis',
         description: 'Proactive bug finding with static and semantic analysis',
         commands: ['/bug-analysis'],
-        agents: ['git', 'diagnose', 'synthesize'],
+        agents: ['git', 'debug', 'synthesize'],
         skills: [
             'apply-decisions',
             'apply-feature-knowledge',
@@ -272,7 +274,7 @@ export const DEVFLOW_PLUGINS = [
         name: 'devflow-ambient',
         description: 'Orchestrator ambient mode — session charter, per-prompt reminder, plan handoff',
         commands: [],
-        agents: ['code', 'code-edit', 'validate', 'simplify', 'scrutinize', 'evaluate', 'test', 'skim', 'review', 'git', 'synthesize', 'triage', 'design', 'knowledge', 'research', 'learning', 'explore'],
+        agents: ['code', 'refactor', 'validate', 'polish', 'harden', 'evaluate', 'test', 'skim', 'review', 'git', 'synthesize', 'triage', 'design', 'knowledge', 'research', 'curate', 'explore'],
         skills: [
             'review-methodology',
             'security',
@@ -313,7 +315,7 @@ export const DEVFLOW_PLUGINS = [
         description: 'Dynamic workflow recipes - dependency-aware tickets→plan→build delivery pipeline',
         // Commands compiled from commands/*.mds at build time (build:mds).
         commands: ['/dynamic-tickets', '/dynamic-plan', '/dynamic-build', '/dynamic-profile'],
-        agents: ['code', 'code-fix', 'validate', 'simplify', 'scrutinize', 'evaluate', 'test', 'review', 'git', 'synthesize', 'knowledge', 'design'],
+        agents: ['code', 'fix', 'validate', 'polish', 'harden', 'evaluate', 'test', 'review', 'git', 'synthesize', 'knowledge', 'design'],
         skills: ['apply-decisions', 'apply-feature-knowledge', 'worktree-support', 'docs-framework'],
         requires: [
             'architecture',

package/dist/core/project-paths.js

@@ -46,7 +46,7 @@ export function getFeatureConfigPath(projectRoot) {
 export function getLearningPendingTurnsPath(projectRoot) {
     return path.join(projectRoot, '.devflow', 'learning', '.pending-turns.jsonl');
 }
-/** .devflow/learning/.pending-turns.processing — the claimed batch a Learning run holds while it processes it */
+/** .devflow/learning/.pending-turns.processing — the claimed batch a Curate run holds while it processes it */
 export function getLearningPendingTurnsProcessingPath(projectRoot) {
     return path.join(projectRoot, '.devflow', 'learning', '.pending-turns.processing');
 }
@@ -65,8 +65,8 @@ export function getDecisionsFilePath(projectRoot) {
 export function getPitfallsFilePath(projectRoot) {
     return path.join(projectRoot, '.devflow', 'learning', 'pitfalls.md');
 }
-/** .devflow/learning/learning.json — project-level learning agent tuning config */
-export function getLearningTuningConfigPath(projectRoot) {
+/** .devflow/learning/learning.json — project-level curate agent tuning config */
+export function getCurateTuningConfigPath(projectRoot) {
     return path.join(projectRoot, '.devflow', 'learning', 'learning.json');
 }
 /** .devflow/learning/decisions-ledger.jsonl — anchored ledger rows (single source of truth for rendering) */

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'],

package/dist/learning-off/agents/{diagnose.md → debug.md}

@@ -1,6 +1,6 @@
 ---
-name: Diagnose
-description: Proactive bug finding agent with static+semantic analysis. Focus-specific analysis across security, functional, integration, and usability categories.
+name: Debug
+description: Proactive bug finding agent with static+semantic analysis. Focus-specific analysis across security, functional, integration, and usability categories. The /bug-analysis command spawns it. It is not the /debug command.
 model: opus
 effort: medium
 skills:
@@ -15,7 +15,7 @@ tools:
   - Skill
 ---
 
-# Diagnose Agent
+# Debug Agent
 
 You are a proactive bug finding agent. Your focus area is specified in the prompt. You hunt for real bugs — not style issues — using a 5-step methodology that combines static analysis findings with semantic code understanding.
 
@@ -111,7 +111,7 @@ Assign to each verified finding:
 
 **Category mapping** (for `/resolve` compatibility — severity-based approximation):
 
-> **Trade-off**: The Review agent uses location-based categories (lines you added / lines you touched / unchanged lines). The Diagnose agent focuses on diff-changed code and lacks per-line location context, so it approximates using severity as a proxy. This means a LOW-severity bug in newly-added code is placed in Pre-existing — not because it predates the change, but to signal lower urgency. The resolve pipeline should treat Pre-existing findings from the Diagnose agent as low-urgency, not as assertions about code origin.
+> **Trade-off**: The Review agent uses location-based categories (lines you added / lines you touched / unchanged lines). The Debug agent focuses on diff-changed code and lacks per-line location context, so it approximates using severity as a proxy. This means a LOW-severity bug in newly-added code is placed in Pre-existing — not because it predates the change, but to signal lower urgency. The resolve pipeline should treat Pre-existing findings from the Debug agent as low-urgency, not as assertions about code origin.
 
 - CRITICAL / HIGH severity → `## Issues in Your Changes (BLOCKING)` — must fix before merge
 - MEDIUM severity → `## Issues in Code You Touched (Should Fix)` — fix while here

package/dist/learning-off/agents/{code-fix.md → fix.md}

@@ -1,5 +1,5 @@
 ---
-name: Code-fix
+name: Fix
 description: Autonomous gate-failure repair on feature branch. Fixes the listed validation, alignment, QA or CI failures, verifies, and commits.
 model: sonnet
 effort: high
@@ -27,7 +27,7 @@ disallowedTools:
   - DesignSync
 ---
 
-# Code-fix Agent
+# Fix Agent
 
 You are an autonomous repair specialist working on a feature branch. A quality gate (validation, alignment, QA or CI) reported failures. You fix exactly the failures you are given, verify the fix and commit it. You operate independently, making implementation decisions without requiring approval for each step.
 

package/dist/learning-off/agents/{scrutinize.md → harden.md}

@@ -1,5 +1,5 @@
 ---
-name: Scrutinize
+name: Harden
 description: Self-review agent that evaluates and fixes implementation issues using 9-pillar framework. Runs in fresh context after Code agent completes.
 model: opus
 effort: medium
@@ -30,9 +30,9 @@ disallowedTools:
   - mcp__*
 ---
 
-# Scrutinize Agent
+# Harden Agent
 
-You are a meticulous self-review specialist. You evaluate implementations against the 9-pillar quality framework and fix the issues you find. You run in a fresh context after the Code and Simplify agents complete, ensuring adequate resources for thorough review and fixes.
+You are a meticulous self-review specialist. You evaluate implementations against the 9-pillar quality framework and fix the issues you find. You run in a fresh context after the Code and Polish agents complete, ensuring adequate resources for thorough review and fixes.
 
 ## Input Context
 
@@ -53,7 +53,7 @@ You receive from orchestrator:
 
 4. **Evaluate P1 pillars** (Complexity, Error Handling, Tests): These SHOULD pass. Fix all issues found.
 
-5. **Evaluate P2** (Documentation): Fix if straightforward. Naming and Consistency belong to the Simplify agent: report them as SKIP.
+5. **Evaluate P2** (Documentation): Fix if straightforward. Naming and Consistency belong to the Polish agent: report them as SKIP.
 
 6. **Commit fixes**: If any changes were made, create a commit with message "fix: address self-review issues".
 
@@ -91,8 +91,8 @@ Return structured completion status:
 - Tests: PASS | FIXED (description)
 
 ### P2 Pillars
-- Naming: SKIP (Simplify agent)
-- Consistency: SKIP (Simplify agent)
+- Naming: SKIP (Polish agent)
+- Consistency: SKIP (Polish agent)
 - Documentation: PASS | FIXED (description)
 
 ### Files Modified

package/dist/learning-off/agents/{code-edit.md → refactor.md}

@@ -1,6 +1,6 @@
 ---
-name: Code-edit
-description: Autonomous mechanical edit on feature branch. Applies a rename, move or boilerplate that adds no behaviour, and commits.
+name: Refactor
+description: Autonomous mechanical edit on feature branch. Makes a given rename, move or boilerplate change and commits. For judgment-based cleanup use Polish.
 model: sonnet
 effort: high
 skills:
@@ -26,7 +26,7 @@ disallowedTools:
   - DesignSync
 ---
 
-# Code-edit Agent
+# Refactor Agent
 
 You are an autonomous editing specialist working on a feature branch. You apply one mechanical change, run the tests of the touched modules once and commit. You operate independently, making implementation decisions without requiring approval for each step.