devflow-kit 1.8.2 → 2.0.0

package/dist/core/teammate-mode-cleanup.js

@@ -0,0 +1,33 @@
+/**
+ * Strip `teammateMode: "auto"` from a freshly parsed copy of the settings JSON.
+ * Returns the serialised JSON string (with trailing newline).
+ *
+ * Pure string→string — matches the pipeline pattern used by stripFlags /
+ * stripViewMode so uninstall.ts can chain it without a separate parse/stringify.
+ * Only removes the key when the value is exactly `"auto"`; user-set values
+ * (`"tmux"`, `"in-process"`, etc.) are preserved as-is.
+ *
+ * Tolerant: malformed JSON is returned unchanged (no-op). Non-object roots
+ * (null, arrays, primitives) are treated as a no-op — only object roots can
+ * carry the key (avoids PF-004: a TypeError here would escape the function
+ * and surface as an unhandled error during uninstall).
+ */
+export function stripDevflowTeammateModeFromJson(settingsJson) {
+    let parsed;
+    try {
+        parsed = JSON.parse(settingsJson);
+    }
+    catch {
+        return settingsJson; // Malformed JSON — leave untouched
+    }
+    // Tolerant: only object roots can carry the key; null/arrays/primitives are no-ops.
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        return settingsJson;
+    }
+    const settings = parsed;
+    if (settings['teammateMode'] !== 'auto')
+        return settingsJson;
+    delete settings['teammateMode'];
+    return JSON.stringify(settings, null, 2) + '\n';
+}
+//# sourceMappingURL=teammate-mode-cleanup.js.map

package/dist/hud/colors.js

@@ -55,8 +55,19 @@ export function bgRed(s) {
 export function truncate(s, max) {
     return s.length > max ? s.slice(0, max - 1) + '\u2026' : s;
 }
-const ANSI_PATTERN = /\x1b\[[0-9;]*m/g;
+// S2 — Terminal-escape and control-character sanitization (HIGH, pre-existing defect).
+//
+// The prior pattern (/\x1b\[[0-9;]*m/g) matched only SGR sequences (colour).
+// The broadened ANSI_PATTERN also covers:
+//   CSI sequences  — \x1b[ ... with intermediate bytes, any final byte
+//   OSC sequences  — \x1b] ... terminated by BEL (\x07) or ST (\x1b\\)
+//   Two-byte C1    — \x1b followed by any single character in the C1 range
+// CTRL_PATTERN removes non-printable C0 control chars that are not TAB (\x09)
+// or standard newlines (\x0a, \x0d).  Together they prevent agent names
+// embedded in model IDs from injecting escape sequences into --list output.
+const ANSI_PATTERN = /\x1b(?:\[[0-9;?]*[ -\/]*[@-~]|\][^\x07\x1b]*(?:\x07|\x1b\\)|[@-Z\\-_])/g;
+const CTRL_PATTERN = /[\x00-\x08\x0b-\x1f\x7f]/g;
 export function stripAnsi(s) {
-    return s.replace(ANSI_PATTERN, '');
+    return s.replace(ANSI_PATTERN, '').replace(CTRL_PATTERN, '');
 }
 //# sourceMappingURL=colors.js.map

package/dist/hud/components/config-counts.js

@@ -49,8 +49,8 @@ export function gatherConfigCounts(cwd) {
         path.join(claudeDir, 'rules'),
     ]) {
         try {
-            const files = fs.readdirSync(rulesDir);
-            rules += files.filter((f) => f.endsWith('.md') || f.endsWith('.mdc')).length;
+            const entries = fs.readdirSync(rulesDir, { recursive: true, withFileTypes: true });
+            rules += entries.filter((d) => d.isFile() && (d.name.endsWith('.md') || d.name.endsWith('.mdc'))).length;
         }
         catch {
             /* ignore */

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

@@ -37,8 +37,8 @@ export default async function contextUsage(ctx) {
         const inK = Math.round(cw.current_usage.input_tokens / 1000);
         suffix = ` (in: ${inK}k)`;
     }
-    const raw = `Current Session ${filledBar}${emptyBar} ${pct}%${suffix}`;
-    const text = dim('Current Session ') +
+    const raw = `Context ${filledBar}${emptyBar} ${pct}%${suffix}`;
+    const text = dim('Context ') +
         colorFn(filledBar) +
         dim(emptyBar) +
         ' ' +

package/dist/hud/components/learning-counts.js

@@ -0,0 +1,92 @@
+import * as fs from 'node:fs';
+import { dim } from '../colors.js';
+import { getDecisionsLedgerPath } from '../../core/project-paths.js';
+/**
+ * @devflow-design-decision D309
+ * Counts come from decisions-ledger.jsonl (the render source of truth), NOT
+ * the rendered decisions.md/pitfalls.md, so the HUD never couples to markdown
+ * format. Active-row semantics mirror render-decisions.cjs exactly: a row
+ * counts when anchor_id is set and decisions_status is absent or outside
+ * INACTIVE_STATUSES — so the numbers always equal the entries visible in the
+ * rendered files.
+ */
+const INACTIVE_STATUSES = new Set(['Deprecated', 'Superseded', 'Retired']);
+function isLedgerCountRow(val) {
+    if (typeof val !== 'object' || val === null)
+        return false;
+    const o = val;
+    if (o.type !== 'decision' && o.type !== 'pitfall')
+        return false;
+    if (typeof o.anchor_id !== 'string' || o.anchor_id.length === 0)
+        return false;
+    return o.decisions_status === undefined || typeof o.decisions_status === 'string';
+}
+function isActive(row) {
+    if (!row.decisions_status)
+        return true;
+    return !INACTIVE_STATUSES.has(row.decisions_status);
+}
+/**
+ * Read .devflow/learning/decisions-ledger.jsonl and count active anchored
+ * rows by type. Returns null if the ledger is missing or holds no valid rows
+ * (graceful fallback). Exported for use by the main HUD entry point.
+ */
+export function gatherLearningCounts(cwd) {
+    let content;
+    try {
+        content = fs.readFileSync(getDecisionsLedgerPath(cwd), 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    const counts = { decisions: 0, pitfalls: 0 };
+    let parsedAny = false;
+    for (const rawLine of content.split('\n')) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            // Skip malformed lines — graceful
+            continue;
+        }
+        if (!isLedgerCountRow(parsed))
+            continue;
+        parsedAny = true;
+        if (!isActive(parsed))
+            continue;
+        if (parsed.type === 'decision')
+            counts.decisions++;
+        else
+            counts.pitfalls++;
+    }
+    return parsedAny ? counts : null;
+}
+/**
+ * HUD component: decisions/pitfalls counts.
+ * Shows how many active ADR/PF entries the project has accumulated.
+ * Returns null when no ledger exists or every entry is retired.
+ */
+export default async function learningCounts(ctx) {
+    const data = ctx.learningCounts;
+    if (!data)
+        return null;
+    const { decisions, pitfalls } = data;
+    if (decisions + pitfalls === 0)
+        return null;
+    const parts = [];
+    if (decisions > 0)
+        parts.push(`${decisions} decision${decisions !== 1 ? 's' : ''}`);
+    if (pitfalls > 0)
+        parts.push(`${pitfalls} pitfall${pitfalls !== 1 ? 's' : ''}`);
+    // Intentionally one dimmed clause (unlike config-counts, which dims each
+    // part and joins with a middot for a list of independent facts): "Learning:
+    // N decisions, M pitfalls" reads as a single sentence, so the whole string
+    // is dimmed once and parts are comma-joined rather than middot-separated.
+    const raw = `Learning: ${parts.join(', ')}`;
+    return { text: dim(raw), raw };
+}
+//# sourceMappingURL=learning-counts.js.map

package/dist/hud/components/session-cost.js

@@ -1,9 +1,17 @@
 import { dim } from '../colors.js';
+/** Session cost with optional rolling 7-day (/wk) and 30-day (/mo) totals. */
 export default async function sessionCost(ctx) {
     const cost = ctx.stdin.cost?.total_cost_usd;
     if (cost == null)
         return null;
-    const formatted = `$${cost.toFixed(2)}`;
-    return { text: dim(formatted), raw: formatted };
+    const parts = [`$${cost.toFixed(2)}`];
+    if (ctx.costHistory?.weeklyCost != null && ctx.costHistory.weeklyCost > 0) {
+        parts.push(`$${ctx.costHistory.weeklyCost.toFixed(2)}/wk`);
+    }
+    if (ctx.costHistory?.monthlyCost != null && ctx.costHistory.monthlyCost > 0) {
+        parts.push(`$${ctx.costHistory.monthlyCost.toFixed(2)}/mo`);
+    }
+    const raw = parts.join(' \u00B7 ');
+    return { text: dim(raw), raw };
 }
 //# sourceMappingURL=session-cost.js.map

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

@@ -22,24 +22,59 @@ function renderBar(percent) {
     const raw = `${filledBar}${emptyBar} ${percent}%`;
     return { text, raw };
 }
+/**
+ * Format seconds remaining until a reset timestamp into compact form.
+ * Returns '' if the timestamp is in the past or not provided.
+ * Format: '2h 15m', '3d 12h', '45m'
+ */
+export function formatCountdown(resetsAtEpoch) {
+    const nowMs = Date.now();
+    const resetsAtMs = resetsAtEpoch * 1000;
+    const remainingMs = resetsAtMs - nowMs;
+    if (remainingMs <= 0)
+        return '';
+    const totalSeconds = Math.floor(remainingMs / 1000);
+    const totalMinutes = Math.floor(totalSeconds / 60);
+    const totalHours = Math.floor(totalMinutes / 60);
+    const days = Math.floor(totalHours / 24);
+    if (days > 0) {
+        const hours = totalHours % 24;
+        return hours > 0 ? `${days}d ${hours}h` : `${days}d`;
+    }
+    if (totalHours > 0) {
+        const minutes = totalMinutes % 60;
+        return minutes > 0 ? `${totalHours}h ${minutes}m` : `${totalHours}h`;
+    }
+    return `${totalMinutes}m`;
+}
+/** Render a single quota window: "5h ████░░░░ 45% (2h 15m)" */
+function renderQuotaWindow(label, percent, resetsAt) {
+    const bar = renderBar(Math.round(percent));
+    const countdown = resetsAt != null ? formatCountdown(resetsAt) : '';
+    const countdownText = countdown ? dim(` (${countdown})`) : '';
+    const countdownRaw = countdown ? ` (${countdown})` : '';
+    return {
+        text: dim(label + ' ') + bar.text + countdownText,
+        raw: `${label} ${bar.raw}${countdownRaw}`,
+    };
+}
 export default async function usageQuota(ctx) {
     if (!ctx.usage)
         return null;
-    const { fiveHourPercent, sevenDayPercent } = ctx.usage;
+    const { fiveHourPercent, sevenDayPercent, fiveHourResetsAt, sevenDayResetsAt } = ctx.usage;
     const parts = [];
     if (fiveHourPercent !== null) {
-        const bar = renderBar(Math.round(fiveHourPercent));
-        parts.push({ text: dim('5h ') + bar.text, raw: `5h ${bar.raw}` });
+        parts.push(renderQuotaWindow('5h', fiveHourPercent, fiveHourResetsAt));
     }
     if (sevenDayPercent !== null) {
-        const bar = renderBar(Math.round(sevenDayPercent));
-        parts.push({ text: dim('7d ') + bar.text, raw: `7d ${bar.raw}` });
+        parts.push(renderQuotaWindow('7d', sevenDayPercent, sevenDayResetsAt));
     }
     if (parts.length === 0)
         return null;
     const sep = dim(' \u00B7 ');
-    const text = dim('Session ') + parts.map((p) => p.text).join(sep);
-    const raw = 'Session ' + parts.map((p) => p.raw).join(' \u00B7 ');
-    return { text, raw };
+    return {
+        text: parts.map((p) => p.text).join(sep),
+        raw: parts.map((p) => p.raw).join(' \u00B7 '),
+    };
 }
 //# sourceMappingURL=usage-quota.js.map

package/dist/hud/components/version-badge.js

@@ -2,9 +2,18 @@ import { execFile } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { yellow } from '../colors.js';
-import { readCache, writeCache } from '../cache.js';
+import { readCache, writeCache, hudCacheDir } from '../../core/cache.js';
+import { getPackageRoot } from '../../core/paths.js';
 const VERSION_CACHE_KEY = 'version-check';
 const VERSION_CACHE_TTL = 24 * 60 * 60 * 1000; // 24 hours
+function validateVersionInfo(data) {
+    if (typeof data !== 'object' || data === null)
+        return null;
+    const obj = data;
+    if (typeof obj.latest !== 'string')
+        return null;
+    return { latest: obj.latest };
+}
 function getCurrentVersion(devflowDir) {
     // Try manifest.json first (most reliable for installed version)
     try {
@@ -18,7 +27,7 @@ function getCurrentVersion(devflowDir) {
     }
     // Try package.json as fallback
     try {
-        const pkgPath = path.join(path.dirname(new URL(import.meta.url).pathname), '..', '..', '..', 'package.json');
+        const pkgPath = path.join(getPackageRoot(), 'package.json');
         const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
         if (typeof pkg.version === 'string')
             return pkg.version;
@@ -61,16 +70,17 @@ export default async function versionBadge(ctx) {
     const current = getCurrentVersion(ctx.devflowDir);
     if (!current)
         return null;
-    // Check cache
-    let info = readCache(VERSION_CACHE_KEY);
+    const cacheDir = hudCacheDir(ctx.devflowDir); // authoritative path from cache.ts (avoids PF-013)
+    // Cache only the npm registry result (expensive); current is always live
+    let info = readCache(cacheDir, VERSION_CACHE_KEY, validateVersionInfo);
     if (!info) {
         const latest = await fetchLatestVersion();
         if (latest) {
-            info = { current, latest };
-            writeCache(VERSION_CACHE_KEY, info, VERSION_CACHE_TTL);
+            info = { latest };
+            await writeCache(cacheDir, VERSION_CACHE_KEY, info, VERSION_CACHE_TTL);
         }
     }
-    if (info && compareVersions(info.current, info.latest) < 0) {
+    if (info && compareVersions(current, info.latest) < 0) {
         const badge = `\u2726 Devflow v${info.latest} \u00B7 update: npx devflow-kit init`;
         return { text: yellow(badge), raw: badge };
     }

package/dist/hud/config.js

@@ -2,7 +2,9 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { homedir } from 'node:os';
 /**
- * All 14 HUD components in display order.
+ * Default HUD components in display order.
+ * sessionDuration is intentionally omitted — the component is retained
+ * in the type system and render map but excluded from display by default.
  */
 export const HUD_COMPONENTS = [
     'directory',
@@ -14,11 +16,11 @@ export const HUD_COMPONENTS = [
     'model',
     'contextUsage',
     'versionBadge',
-    'sessionDuration',
     'sessionCost',
     'usageQuota',
     'todoProgress',
     'configCounts',
+    'learningCounts',
 ];
 export function getConfigPath() {
     const devflowDir = process.env.DEVFLOW_DIR || path.join(process.env.HOME || homedir(), '.devflow');

package/dist/hud/cost-history.js

@@ -0,0 +1,281 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { homedir } from 'node:os';
+const SECONDS_1_HOUR = 3600;
+const SECONDS_PER_DAY = 86400;
+const SECONDS_7_DAYS = 7 * SECONDS_PER_DAY;
+const SECONDS_30_DAYS = 30 * SECONDS_PER_DAY;
+const SECONDS_90_DAYS = 90 * SECONDS_PER_DAY;
+const ARCHIVE_TRIM_THRESHOLD = 500;
+const CACHE_TTL_MS = 30_000;
+/** Returns the current time as a Unix epoch in whole seconds. */
+function nowEpoch() {
+    return Math.floor(Date.now() / 1000);
+}
+function isSessionEntry(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const obj = value;
+    return (typeof obj.session_id === 'string' &&
+        typeof obj.cost_usd === 'number' &&
+        typeof obj.timestamp === 'number' &&
+        typeof obj.cwd === 'string');
+}
+let sessionsDirCreated = false;
+let cachedAggregation = null;
+/**
+ * Returns the paths used for cost storage.
+ * Respects DEVFLOW_DIR env for testability.
+ */
+export function getCostFilePaths() {
+    const devflowDir = process.env.DEVFLOW_DIR ||
+        path.join(process.env.HOME || homedir(), '.devflow');
+    const sessionsDir = path.join(devflowDir, 'costs', 'sessions');
+    const archivePath = path.join(devflowDir, 'costs', 'archive.jsonl');
+    return { sessionsDir, archivePath };
+}
+/**
+ * Persist the current session cost atomically.
+ * Fire-and-forget — all errors are swallowed to avoid blocking HUD render.
+ * Periodic cleanup runs every ~50 seconds (when timestamp % 50 === 0).
+ */
+export function persistSessionCost(sessionId, costUsd, cwd) {
+    if (costUsd <= 0 || !Number.isFinite(costUsd))
+        return;
+    // Sanitize sessionId to prevent path traversal (defense-in-depth)
+    if (!sessionId || /[/\\]/.test(sessionId))
+        return;
+    try {
+        const { sessionsDir } = getCostFilePaths();
+        if (!sessionsDirCreated) {
+            fs.mkdirSync(sessionsDir, { recursive: true });
+            sessionsDirCreated = true;
+        }
+        const entry = {
+            session_id: sessionId,
+            cost_usd: costUsd,
+            timestamp: nowEpoch(),
+            cwd,
+        };
+        const filePath = path.join(sessionsDir, `${sessionId}.json`);
+        const tmpPath = `${filePath}.tmp`;
+        const data = JSON.stringify(entry);
+        // Atomic write: write to .tmp then rename
+        try {
+            fs.writeFileSync(tmpPath, data, { encoding: 'utf-8', flag: 'wx' });
+        }
+        catch (err) {
+            if (err.code === 'EEXIST') {
+                // Stale .tmp from prior crash — unlink and retry once
+                try {
+                    fs.unlinkSync(tmpPath);
+                }
+                catch { /* race — already removed */ }
+                fs.writeFileSync(tmpPath, data, { encoding: 'utf-8', flag: 'wx' });
+            }
+            else {
+                throw err;
+            }
+        }
+        fs.renameSync(tmpPath, filePath);
+        // Periodic cleanup: run every ~50 seconds
+        if (entry.timestamp % 50 === 0) {
+            runCleanup();
+        }
+    }
+    catch {
+        // Non-fatal: HUD must not block on cost persistence errors
+    }
+}
+/** Remove orphaned .tmp files in sessionsDir that are older than 1 hour. */
+function cleanOrphanedTmpFiles(sessionsDir, nowSeconds, files) {
+    for (const filename of files) {
+        if (!filename.endsWith('.tmp'))
+            continue;
+        const filePath = path.join(sessionsDir, filename);
+        try {
+            const stat = fs.statSync(filePath);
+            const ageSeconds = nowSeconds - Math.floor(stat.mtimeMs / 1000);
+            if (ageSeconds > SECONDS_1_HOUR) {
+                fs.unlinkSync(filePath);
+            }
+        }
+        catch { /* non-fatal */ }
+    }
+}
+/** Archive session JSON files older than 24 hours into the archive JSONL. */
+function archiveStaleSessionFiles(sessionsDir, archivePath, nowSeconds, files) {
+    for (const filename of files) {
+        if (!filename.endsWith('.json'))
+            continue;
+        const filePath = path.join(sessionsDir, filename);
+        try {
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (!isSessionEntry(parsed))
+                continue;
+            const age = nowSeconds - parsed.timestamp;
+            if (age > SECONDS_PER_DAY) {
+                fs.mkdirSync(path.dirname(archivePath), { recursive: true });
+                fs.appendFileSync(archivePath, JSON.stringify(parsed) + '\n');
+                fs.unlinkSync(filePath);
+            }
+        }
+        catch { /* non-fatal: skip malformed files */ }
+    }
+}
+/**
+ * Clean up stale session files, orphaned .tmp files, and trim archive.
+ * Called periodically from persistSessionCost.
+ */
+export function runCleanup() {
+    try {
+        const { sessionsDir, archivePath } = getCostFilePaths();
+        const nowSeconds = nowEpoch();
+        let sessionFiles;
+        try {
+            sessionFiles = fs.readdirSync(sessionsDir);
+        }
+        catch {
+            return;
+        }
+        cleanOrphanedTmpFiles(sessionsDir, nowSeconds, sessionFiles);
+        archiveStaleSessionFiles(sessionsDir, archivePath, nowSeconds, sessionFiles);
+        // Trim archive.jsonl when it exceeds threshold
+        trimArchive(archivePath, nowSeconds);
+    }
+    catch { /* non-fatal */ }
+}
+function trimArchive(archivePath, nowSeconds) {
+    try {
+        const raw = fs.readFileSync(archivePath, 'utf-8');
+        const lines = raw.split('\n').filter((l) => l.trim().length > 0);
+        if (lines.length <= ARCHIVE_TRIM_THRESHOLD)
+            return;
+        // Remove entries older than 90 days
+        const cutoff = nowSeconds - SECONDS_90_DAYS;
+        const retained = lines.filter((line) => {
+            try {
+                const parsed = JSON.parse(line);
+                if (!isSessionEntry(parsed))
+                    return false;
+                return parsed.timestamp >= cutoff;
+            }
+            catch {
+                return false;
+            }
+        });
+        fs.writeFileSync(archivePath, retained.join('\n') + '\n', 'utf-8');
+    }
+    catch { /* non-fatal */ }
+}
+/** Insert or replace entry in map, keeping the one with the higher cost_usd. */
+function upsertMax(map, entry) {
+    const existing = map.get(entry.session_id);
+    if (!existing || entry.cost_usd > existing.cost_usd) {
+        map.set(entry.session_id, entry);
+    }
+}
+/** Read all valid SessionEntry objects from the sessions directory. */
+function readSessionEntries(sessionsDir) {
+    const map = new Map();
+    try {
+        const files = fs.readdirSync(sessionsDir);
+        for (const filename of files) {
+            if (!filename.endsWith('.json'))
+                continue;
+            try {
+                const raw = fs.readFileSync(path.join(sessionsDir, filename), 'utf-8');
+                const parsed = JSON.parse(raw);
+                if (isSessionEntry(parsed)) {
+                    upsertMax(map, parsed);
+                }
+            }
+            catch { /* skip malformed */ }
+        }
+    }
+    catch { /* sessions dir may not exist yet */ }
+    return map;
+}
+/** Read all valid SessionEntry objects from the archive JSONL file. */
+function readArchiveEntries(archivePath) {
+    const entries = [];
+    try {
+        const raw = fs.readFileSync(archivePath, 'utf-8');
+        const lines = raw.split('\n').filter((l) => l.trim().length > 0);
+        for (const line of lines) {
+            try {
+                const parsed = JSON.parse(line);
+                if (isSessionEntry(parsed)) {
+                    entries.push(parsed);
+                }
+            }
+            catch { /* skip malformed JSONL lines */ }
+        }
+    }
+    catch { /* archive may not exist yet */ }
+    return entries;
+}
+/**
+ * Aggregate costs from all session files and archive.
+ * The currentSessionId + currentCostUsd parameters are authoritative
+ * (from stdin) and override any file-based entry for the same session.
+ * Results are cached for CACHE_TTL_MS to avoid repeated filesystem reads.
+ */
+export function aggregateCosts(currentSessionId, currentCostUsd) {
+    // Return cached result if still valid
+    if (cachedAggregation !== null && Date.now() < cachedAggregation.expiresAt) {
+        return cachedAggregation.value;
+    }
+    try {
+        const { sessionsDir, archivePath } = getCostFilePaths();
+        const sessionMap = readSessionEntries(sessionsDir);
+        for (const entry of readArchiveEntries(archivePath)) {
+            upsertMax(sessionMap, entry);
+        }
+        // Override/add current session from stdin (authoritative), only when cost > 0
+        if (currentCostUsd > 0) {
+            const currentEntry = {
+                session_id: currentSessionId,
+                cost_usd: currentCostUsd,
+                timestamp: nowEpoch(),
+                cwd: '',
+            };
+            const existingCurrent = sessionMap.get(currentSessionId);
+            if (!existingCurrent || currentCostUsd >= existingCurrent.cost_usd) {
+                sessionMap.set(currentSessionId, currentEntry);
+            }
+        }
+        if (sessionMap.size === 0) {
+            cachedAggregation = { value: null, expiresAt: Date.now() + CACHE_TTL_MS };
+            return null;
+        }
+        const nowSeconds = nowEpoch();
+        const cutoff7d = nowSeconds - SECONDS_7_DAYS;
+        const cutoff30d = nowSeconds - SECONDS_30_DAYS;
+        let weeklyCost = 0;
+        let monthlyCost = 0;
+        let hasWeekly = false;
+        let hasMonthly = false;
+        for (const entry of sessionMap.values()) {
+            if (entry.timestamp >= cutoff30d) {
+                monthlyCost += entry.cost_usd;
+                hasMonthly = true;
+            }
+            if (entry.timestamp >= cutoff7d) {
+                weeklyCost += entry.cost_usd;
+                hasWeekly = true;
+            }
+        }
+        const result = {
+            weeklyCost: hasWeekly ? weeklyCost : null,
+            monthlyCost: hasMonthly ? monthlyCost : null,
+        };
+        cachedAggregation = { value: result, expiresAt: Date.now() + CACHE_TTL_MS };
+        return result;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=cost-history.js.map