@renseiai/agentfactory-cli 0.8.0

package/dist/src/lib/governor-dependencies.js

@@ -0,0 +1,361 @@
+/**
+ * Real Governor Dependencies
+ *
+ * Maps each GovernorDependencies callback to its real implementation
+ * using the Linear SDK (via LinearAgentClient) and Redis storage
+ * (from @renseiai/agentfactory-server).
+ */
+import { isHeld as checkIsHeld, getOverridePriority as checkOverridePriority, } from '@renseiai/agentfactory';
+import { getSessionStateByIssue, didJustFailQA, getWorkflowState, getTotalSessionCount, RedisProcessingStateStorage, storeSessionState, dispatchWork as issueLockDispatchWork, } from '@renseiai/agentfactory-server';
+// ---------------------------------------------------------------------------
+// Logging
+// ---------------------------------------------------------------------------
+const log = {
+    info: (msg, data) => console.log(`[governor-deps] ${msg}`, data ? JSON.stringify(data) : ''),
+    warn: (msg, data) => console.warn(`[governor-deps] ${msg}`, data ? JSON.stringify(data) : ''),
+    error: (msg, data) => console.error(`[governor-deps] ${msg}`, data ? JSON.stringify(data) : ''),
+};
+// ---------------------------------------------------------------------------
+// Action-to-WorkType mapping
+// ---------------------------------------------------------------------------
+function actionToWorkType(action) {
+    switch (action) {
+        case 'trigger-research':
+            return 'research';
+        case 'trigger-backlog-creation':
+            return 'backlog-creation';
+        case 'trigger-development':
+            return 'development';
+        case 'trigger-qa':
+            return 'qa';
+        case 'trigger-acceptance':
+            return 'acceptance';
+        case 'trigger-refinement':
+            return 'refinement';
+        case 'decompose':
+            return 'coordination';
+        case 'escalate-human':
+            return 'escalation';
+        default:
+            return 'development';
+    }
+}
+/**
+ * Create real GovernorDependencies backed by the Linear SDK and Redis.
+ *
+ * Each callback wraps its implementation in a try/catch so that a single
+ * failing dependency does not crash the entire governor scan loop.
+ */
+export function createRealDependencies(config) {
+    const processingState = new RedisProcessingStateStorage();
+    // Caches populated by listIssues() single GraphQL query.
+    // parentIssueIds: issues with children (isParent = true)
+    // scannedIssueIds: all issues returned by the last scan (isParent known definitively)
+    // Only issues NOT in scannedIssueIds need an API fallback (e.g., webhook-driven).
+    const parentIssueIds = new Set();
+    const scannedIssueIds = new Set();
+    return {
+        // -----------------------------------------------------------------------
+        // 1. listIssues -- scan Linear project using single GraphQL query
+        // -----------------------------------------------------------------------
+        listIssues: async (project) => {
+            try {
+                const rawIssues = await config.linearClient.listProjectIssues(project);
+                // Cache issue IDs for isParentIssue() lookups — avoids per-issue API calls
+                parentIssueIds.clear();
+                scannedIssueIds.clear();
+                for (const issue of rawIssues) {
+                    scannedIssueIds.add(issue.id);
+                    if (issue.childCount > 0) {
+                        parentIssueIds.add(issue.id);
+                    }
+                }
+                return rawIssues.map((issue) => ({
+                    id: issue.id,
+                    identifier: issue.identifier,
+                    title: issue.title,
+                    description: issue.description,
+                    status: issue.status,
+                    labels: issue.labels,
+                    createdAt: issue.createdAt,
+                    parentId: issue.parentId,
+                    project: issue.project,
+                }));
+            }
+            catch (err) {
+                log.error('listIssues failed', {
+                    project,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return [];
+            }
+        },
+        // -----------------------------------------------------------------------
+        // 2. hasActiveSession -- check Redis session storage
+        // -----------------------------------------------------------------------
+        hasActiveSession: async (issueId) => {
+            try {
+                const session = await getSessionStateByIssue(issueId);
+                if (!session)
+                    return false;
+                const activeStatuses = ['running', 'claimed', 'pending', 'finalizing'];
+                return activeStatuses.includes(session.status);
+            }
+            catch (err) {
+                log.error('hasActiveSession failed', {
+                    issueId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return false;
+            }
+        },
+        // -----------------------------------------------------------------------
+        // 3. isWithinCooldown -- check if QA just failed for this issue
+        // -----------------------------------------------------------------------
+        isWithinCooldown: async (issueId) => {
+            try {
+                return await didJustFailQA(issueId);
+            }
+            catch (err) {
+                log.error('isWithinCooldown failed', {
+                    issueId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return false;
+            }
+        },
+        // -----------------------------------------------------------------------
+        // 4. isParentIssue -- check cache first, fall back to API
+        // -----------------------------------------------------------------------
+        isParentIssue: async (issueId) => {
+            // Check cached parent IDs from listIssues (populated by single GraphQL query)
+            if (parentIssueIds.has(issueId))
+                return true;
+            // If the issue was in the scan, we know definitively it's not a parent
+            if (scannedIssueIds.has(issueId))
+                return false;
+            // Fall back to API only for issues not in the last scan (e.g., webhook-driven)
+            try {
+                return await config.linearClient.isParentIssue(issueId);
+            }
+            catch (err) {
+                log.error('isParentIssue failed', {
+                    issueId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return false;
+            }
+        },
+        // -----------------------------------------------------------------------
+        // 5. isHeld -- check touchpoint override storage
+        // -----------------------------------------------------------------------
+        isHeld: async (issueId) => {
+            try {
+                return await checkIsHeld(issueId);
+            }
+            catch (err) {
+                log.error('isHeld failed', {
+                    issueId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return false;
+            }
+        },
+        // -----------------------------------------------------------------------
+        // 6. getOverridePriority -- check touchpoint override storage
+        // -----------------------------------------------------------------------
+        getOverridePriority: async (issueId) => {
+            try {
+                return await checkOverridePriority(issueId);
+            }
+            catch (err) {
+                log.error('getOverridePriority failed', {
+                    issueId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return null;
+            }
+        },
+        // -----------------------------------------------------------------------
+        // 7. getWorkflowStrategy -- check Redis workflow state
+        // -----------------------------------------------------------------------
+        getWorkflowStrategy: async (issueId) => {
+            try {
+                const workflowState = await getWorkflowState(issueId);
+                return workflowState?.strategy;
+            }
+            catch (err) {
+                log.error('getWorkflowStrategy failed', {
+                    issueId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return undefined;
+            }
+        },
+        // -----------------------------------------------------------------------
+        // 8. isResearchCompleted -- check Redis processing state
+        // -----------------------------------------------------------------------
+        isResearchCompleted: async (issueId) => {
+            try {
+                return await processingState.isPhaseCompleted(issueId, 'research');
+            }
+            catch (err) {
+                log.error('isResearchCompleted failed', {
+                    issueId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return false;
+            }
+        },
+        // -----------------------------------------------------------------------
+        // 9. isBacklogCreationCompleted -- check Redis processing state
+        // -----------------------------------------------------------------------
+        isBacklogCreationCompleted: async (issueId) => {
+            try {
+                return await processingState.isPhaseCompleted(issueId, 'backlog-creation');
+            }
+            catch (err) {
+                log.error('isBacklogCreationCompleted failed', {
+                    issueId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return false;
+            }
+        },
+        // -----------------------------------------------------------------------
+        // 10. getCompletedSessionCount -- count completed sessions for circuit breaker
+        // -----------------------------------------------------------------------
+        getCompletedSessionCount: async (issueId) => {
+            try {
+                return await getTotalSessionCount(issueId);
+            }
+            catch (err) {
+                log.error('getCompletedSessionCount failed', {
+                    issueId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return 0;
+            }
+        },
+        // -----------------------------------------------------------------------
+        // 11. dispatchWork -- create Linear session and queue work
+        //     Accepts GovernorIssue directly (already resolved in the scan),
+        //     eliminating 2 redundant API calls per dispatch.
+        // -----------------------------------------------------------------------
+        dispatchWork: async (issue, action) => {
+            const issueId = issue.id;
+            const issueIdentifier = issue.identifier;
+            const projectName = issue.project;
+            try {
+                let workType = actionToWorkType(action);
+                // Parent issues use coordination variants for development, QA, acceptance, and refinement
+                if (parentIssueIds.has(issueId)) {
+                    if (workType === 'development')
+                        workType = 'coordination';
+                    else if (workType === 'qa')
+                        workType = 'qa-coordination';
+                    else if (workType === 'acceptance')
+                        workType = 'acceptance-coordination';
+                    else if (workType === 'refinement')
+                        workType = 'refinement-coordination';
+                }
+                log.info('Dispatching work', { issueId, issueIdentifier, action, workType });
+                // Create a Linear Agent Session on the issue so the UI shows activity
+                // Resolve OAuth client fresh each dispatch (handles token refresh/expiry)
+                const oauthClient = await config.resolveOAuthClient?.();
+                const sessionClient = oauthClient ?? config.linearClient;
+                let sessionId;
+                try {
+                    const sessionResult = await sessionClient.createAgentSessionOnIssue({
+                        issueId,
+                    });
+                    sessionId = sessionResult.sessionId;
+                }
+                catch (err) {
+                    log.warn('Could not create agent session, will queue without sessionId', {
+                        issueId,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+                const finalSessionId = sessionId ?? `governor-${issueId}-${Date.now()}`;
+                const now = Date.now();
+                // Fetch workflow state for retry context injection
+                const workflowState = await getWorkflowState(issueId);
+                const workflowContext = workflowState?.cycleCount
+                    ? {
+                        cycleCount: workflowState.cycleCount,
+                        strategy: workflowState.strategy,
+                        failureSummary: workflowState.failureSummary,
+                    }
+                    : undefined;
+                // Generate prompt for the work type (with retry context if available)
+                const prompt = config.generatePrompt?.(issueIdentifier, workType, undefined, workflowContext);
+                // Register a pending session FIRST so hasActiveSession() returns true
+                // immediately, preventing re-dispatch on subsequent poll sweeps.
+                await storeSessionState(finalSessionId, {
+                    issueId,
+                    issueIdentifier,
+                    providerSessionId: null,
+                    worktreePath: '',
+                    status: 'pending',
+                    workerId: null,
+                    queuedAt: now,
+                    priority: 3,
+                    workType: workType,
+                    projectName,
+                    organizationId: config.organizationId,
+                    promptContext: prompt,
+                });
+                // Queue the work item for a worker to pick up
+                const queuedWork = {
+                    sessionId: finalSessionId,
+                    issueId,
+                    issueIdentifier,
+                    priority: 3,
+                    queuedAt: now,
+                    workType: workType,
+                    projectName,
+                    prompt,
+                };
+                // Use issue-lock dispatch instead of raw queueWork().
+                // If the issue is already locked (another session is in-flight),
+                // work is parked and promoted when the lock is released.
+                const result = await issueLockDispatchWork(queuedWork);
+                if (!result.dispatched && !result.parked) {
+                    log.warn('Failed to dispatch or park work', {
+                        issueId,
+                        action,
+                    });
+                }
+                else if (result.parked) {
+                    log.info('Work parked (issue already locked)', {
+                        issueId,
+                        issueIdentifier,
+                        action,
+                        workType,
+                        replaced: result.replaced,
+                        sessionId: finalSessionId,
+                    });
+                }
+                else {
+                    log.info('Work queued successfully', {
+                        issueId,
+                        issueIdentifier,
+                        action,
+                        workType,
+                        projectName,
+                        sessionId: finalSessionId,
+                    });
+                }
+            }
+            catch (err) {
+                log.error('dispatchWork failed', {
+                    issueId,
+                    action,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                throw err; // Re-throw so the governor can record the error
+            }
+        },
+    };
+}

package/dist/src/lib/governor-logger.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Governor Logger — Colorized, structured display for the governor CLI.
+ *
+ * Uses ANSI escape codes directly (matching the core Logger pattern)
+ * to avoid external dependencies like chalk.
+ */
+import type { ScanResult } from '@renseiai/agentfactory';
+import type { LinearApiQuota } from '@renseiai/agentfactory-linear';
+export interface StartupBannerConfig {
+    version: string;
+    projects: string[];
+    scanIntervalMs: number;
+    maxConcurrentDispatches: number;
+    mode: string;
+    once: boolean;
+    features: {
+        autoResearch: boolean;
+        autoBacklogCreation: boolean;
+        autoDevelopment: boolean;
+        autoQA: boolean;
+        autoAcceptance: boolean;
+    };
+    redisConnected: boolean;
+    oauthResolved: boolean;
+}
+export declare function printStartupBanner(config: StartupBannerConfig): void;
+export declare function printScanSummary(results: ScanResult[], durationMs: number, quota?: LinearApiQuota, apiCalls?: number): void;
+export declare function printQuotaBar(quota: LinearApiQuota, apiCalls?: number): void;
+export declare function printCircuitBreakerWarning(status: string): void;
+//# sourceMappingURL=governor-logger.d.ts.map

package/dist/src/lib/governor-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governor-logger.d.ts","sourceRoot":"","sources":["../../../src/lib/governor-logger.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAkCnE,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,cAAc,EAAE,MAAM,CAAA;IACtB,uBAAuB,EAAE,MAAM,CAAA;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,OAAO,CAAA;IACb,QAAQ,EAAE;QACR,YAAY,EAAE,OAAO,CAAA;QACrB,mBAAmB,EAAE,OAAO,CAAA;QAC5B,eAAe,EAAE,OAAO,CAAA;QACxB,MAAM,EAAE,OAAO,CAAA;QACf,cAAc,EAAE,OAAO,CAAA;KACxB,CAAA;IACD,cAAc,EAAE,OAAO,CAAA;IACvB,aAAa,EAAE,OAAO,CAAA;CACvB;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI,CAqFpE;AAMD,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,UAAU,EAAE,EACrB,UAAU,EAAE,MAAM,EAClB,KAAK,CAAC,EAAE,cAAc,EACtB,QAAQ,CAAC,EAAE,MAAM,GAChB,IAAI,CA6CN;AAMD,wBAAgB,aAAa,CAAC,KAAK,EAAE,cAAc,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAuC5E;AAMD,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAa/D"}

package/dist/src/lib/governor-logger.js

@@ -0,0 +1,210 @@
+/**
+ * Governor Logger — Colorized, structured display for the governor CLI.
+ *
+ * Uses ANSI escape codes directly (matching the core Logger pattern)
+ * to avoid external dependencies like chalk.
+ */
+// ---------------------------------------------------------------------------
+// ANSI colors (matching packages/core/src/logger.ts)
+// ---------------------------------------------------------------------------
+const c = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    brightBlack: '\x1b[90m',
+    brightGreen: '\x1b[92m',
+    brightYellow: '\x1b[93m',
+    brightRed: '\x1b[91m',
+    brightCyan: '\x1b[96m',
+};
+function color(text, ...codes) {
+    return `${codes.join('')}${text}${c.reset}`;
+}
+export function printStartupBanner(config) {
+    const w = 56; // inner width
+    const top = `${c.cyan}┌${'─'.repeat(w)}┐${c.reset}`;
+    const bottom = `${c.cyan}└${'─'.repeat(w)}┘${c.reset}`;
+    const sep = `${c.cyan}├${'─'.repeat(w)}┤${c.reset}`;
+    const pad = (text, rawLen) => {
+        const padding = w - 2 - rawLen;
+        return `${c.cyan}│${c.reset} ${text}${' '.repeat(Math.max(0, padding))} ${c.cyan}│${c.reset}`;
+    };
+    const title = 'AgentFactory Governor';
+    const titleLen = title.length + config.version.length + 3;
+    const titleLine = `${c.bold}${c.white}${title}${c.reset} ${c.dim}v${config.version}${c.reset}`;
+    const lines = [
+        top,
+        pad(titleLine, titleLen),
+        sep,
+    ];
+    // Projects
+    const projList = config.projects.join(', ');
+    lines.push(pad(`${color('Projects:', c.bold)} ${projList}`, 10 + projList.length));
+    // Scan interval
+    const intervalSec = `${config.scanIntervalMs / 1000}s`;
+    lines.push(pad(`${color('Interval:', c.bold)} ${intervalSec}`, 10 + intervalSec.length));
+    // Max dispatches
+    const maxStr = String(config.maxConcurrentDispatches);
+    lines.push(pad(`${color('Max dispatch:', c.bold)} ${maxStr}/scan`, 14 + maxStr.length + 5));
+    // Mode
+    const modeStr = config.once ? 'single scan' : config.mode;
+    lines.push(pad(`${color('Mode:', c.bold)} ${modeStr}`, 6 + modeStr.length));
+    lines.push(sep);
+    // Feature flags
+    const features = config.features;
+    const featureEntries = [
+        ['Research', features.autoResearch],
+        ['Backlog Creation', features.autoBacklogCreation],
+        ['Development', features.autoDevelopment],
+        ['QA', features.autoQA],
+        ['Acceptance', features.autoAcceptance],
+    ];
+    const enabledList = featureEntries
+        .filter(([, v]) => v)
+        .map(([k]) => k);
+    const disabledList = featureEntries
+        .filter(([, v]) => !v)
+        .map(([k]) => k);
+    if (enabledList.length > 0) {
+        const text = enabledList.join(', ');
+        lines.push(pad(`${color('Enabled:', c.green, c.bold)} ${text}`, 9 + text.length));
+    }
+    if (disabledList.length > 0) {
+        const text = disabledList.join(', ');
+        lines.push(pad(`${color('Disabled:', c.dim)} ${text}`, 10 + text.length));
+    }
+    lines.push(sep);
+    // Integration status
+    const redisStatus = config.redisConnected
+        ? color('connected', c.green)
+        : color('not configured', c.yellow);
+    const redisRawLen = config.redisConnected ? 16 : 22;
+    lines.push(pad(`${color('Redis:', c.bold)} ${redisStatus}`, 7 + (redisRawLen - 7)));
+    const oauthStatus = config.oauthResolved
+        ? color('resolved', c.green)
+        : color('personal API key', c.yellow);
+    const oauthRawLen = config.oauthResolved ? 15 : 24;
+    lines.push(pad(`${color('OAuth:', c.bold)} ${oauthStatus}`, 7 + (oauthRawLen - 7)));
+    lines.push(bottom);
+    console.log(lines.join('\n'));
+    console.log();
+}
+// ---------------------------------------------------------------------------
+// Scan Summary
+// ---------------------------------------------------------------------------
+export function printScanSummary(results, durationMs, quota, apiCalls) {
+    const ts = formatTime();
+    for (const result of results) {
+        const { project, scannedIssues, actionsDispatched, skippedReasons, errors } = result;
+        const projectTag = color(`[${project}]`, c.cyan, c.bold);
+        // Main summary line
+        const dispatched = actionsDispatched > 0
+            ? color(String(actionsDispatched), c.green, c.bold)
+            : color('0', c.dim);
+        const scanned = color(String(scannedIssues), c.white);
+        const skipped = skippedReasons.size > 0
+            ? color(String(skippedReasons.size), c.dim)
+            : '0';
+        console.log(`${color(ts, c.dim)} ${projectTag} ${scanned} scanned, ${dispatched} dispatched, ${skipped} skipped`);
+        // Errors
+        if (errors.length > 0) {
+            for (const err of errors) {
+                console.log(`${color(ts, c.dim)} ${projectTag} ${color('ERR', c.red)} ${err.issueId}: ${err.error}`);
+            }
+        }
+    }
+    // Duration
+    const durStr = durationMs < 1000
+        ? `${durationMs}ms`
+        : `${(durationMs / 1000).toFixed(1)}s`;
+    console.log(`${color(ts, c.dim)} ${color('Scan completed', c.dim)} in ${color(durStr, c.white)}`);
+    // Quota bar
+    if (quota) {
+        printQuotaBar(quota, apiCalls);
+    }
+    console.log();
+}
+// ---------------------------------------------------------------------------
+// Quota Bar
+// ---------------------------------------------------------------------------
+export function printQuotaBar(quota, apiCalls) {
+    const barWidth = 20;
+    // Request quota bar
+    if (quota.requestsRemaining != null && quota.requestsLimit != null) {
+        const used = quota.requestsLimit - quota.requestsRemaining;
+        const pct = quota.requestsLimit > 0 ? used / quota.requestsLimit : 0;
+        const barColor = getQuotaColor(1 - pct);
+        const bar = renderBar(pct, barWidth, barColor);
+        const usedStr = used.toLocaleString();
+        const limitStr = quota.requestsLimit.toLocaleString();
+        const pctStr = `(${Math.round(pct * 100)}%)`;
+        let line = `  Linear API  ${bar} ${usedStr}/${limitStr} req ${color(pctStr, c.dim)}`;
+        if (apiCalls != null) {
+            line += `  ${color('│', c.dim)} ${apiCalls} calls this scan`;
+        }
+        console.log(line);
+    }
+    // Complexity quota bar
+    if (quota.complexityRemaining != null && quota.complexityLimit != null) {
+        const used = quota.complexityLimit - quota.complexityRemaining;
+        const pct = quota.complexityLimit > 0 ? used / quota.complexityLimit : 0;
+        const barColor = getQuotaColor(1 - pct);
+        const bar = renderBar(pct, barWidth, barColor);
+        const usedStr = formatCompact(used);
+        const limitStr = formatCompact(quota.complexityLimit);
+        const pctStr = `(${Math.round(pct * 100)}%)`;
+        let line = `              ${bar} ${usedStr}/${limitStr} cmplx ${color(pctStr, c.dim)}`;
+        if (quota.resetSeconds != null) {
+            const resetMin = Math.ceil(quota.resetSeconds / 60);
+            line += `  ${color('│', c.dim)} resets in ${resetMin}m`;
+        }
+        console.log(line);
+    }
+}
+// ---------------------------------------------------------------------------
+// Circuit Breaker Warning
+// ---------------------------------------------------------------------------
+export function printCircuitBreakerWarning(status) {
+    if (status === 'closed')
+        return;
+    const ts = formatTime();
+    if (status === 'open') {
+        console.log(`${color(ts, c.dim)} ${color('CIRCUIT BREAKER OPEN', c.brightRed, c.bold)} — API calls blocked, waiting for reset`);
+    }
+    else if (status === 'half-open') {
+        console.log(`${color(ts, c.dim)} ${color('CIRCUIT BREAKER HALF-OPEN', c.brightYellow, c.bold)} — probing with single request`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function formatTime() {
+    const now = new Date();
+    return `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}`;
+}
+function getQuotaColor(remainingPct) {
+    if (remainingPct < 0.10)
+        return c.brightRed;
+    if (remainingPct < 0.20)
+        return c.brightYellow;
+    return c.brightGreen;
+}
+function renderBar(pct, width, barColor) {
+    const filled = Math.round(pct * width);
+    const empty = width - filled;
+    return `[${barColor}${'█'.repeat(filled)}${c.dim}${'░'.repeat(empty)}${c.reset}]`;
+}
+function formatCompact(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(0)}K`;
+    return String(n);
+}