standout 0.5.34 → 0.5.35

package/dist/ai-usage.js

@@ -1,1306 +0,0 @@
-import { createReadStream, existsSync, readdirSync, realpathSync, statSync, } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-import { createInterface } from "readline";
-import { gatherCursor } from "./cursor.js";
-import { redactSecrets } from "./redact.js";
-const MAX_PROMPT_SAMPLES = 50;
-const MAX_PROMPT_LEN = 200;
-// Conversation collection (rolling 30-day window only) — feeds the prompt-insight
-// cards and the server-side collaboration-style analysis. All bounded + truncated.
-const MAX_PROMPTS_PER_SESSION = 8;
-const MAX_EXCHANGES = 500;
-// Display samples stay short; exchanges fed to the collaboration analysis keep
-// (effectively) the full prompt — secrets are redacted first, so this is safe.
-const MAX_ASSISTANT_LEN = 800;
-const MAX_EXCHANGE_PROMPT_LEN = 2000;
-const MAX_PROMPT_FREQUENCY = 12;
-// Style-analysis corpus: collect a bounded reservoir, then evenly sample down.
-const MAX_CONVO_RESERVOIR = 5000;
-const CONVO_SAMPLE_TARGET = 160;
-const MAX_CONVO_PER_SESSION = 6;
-const CONVO_SAMPLE_LEN = 400;
-// Heuristic for "did the user push back / correct the AI" — an active-vs-passive signal.
-const CORRECTION_RE = /\b(no|nope|actually|wrong|incorrect|instead|revert|undo|don'?t|stop|not what|that'?s not)\b/i;
-// Trivial continuations/acknowledgements + pasted shell commands aren't real
-// "asks" — exclude them from the most-common-ask ranking (still counted as turns).
-const TRIVIAL_ASK_RE = /^(y|n|yes|yep|yeah|ya|ok|okay|k|sure|go|go ahead|do it|continue|please continue|next|thanks|thank you|thx|ty|nice|cool|perfect|great|good|done|ship it|lgtm|👍|\.|\?)\b[\s.!]*$/i;
-const SHELL_COMMAND_RE = /^(npx|npm|pnpm|yarn|bun|git|cd|ls|cat|node|python|pip|brew|sudo|docker|curl|echo|mkdir|rm|mv|cp)\b/i;
-export function isLowSignalAsk(sample) {
-    const t = sample.trim();
-    if (t.length < 12)
-        return true;
-    if (TRIVIAL_ASK_RE.test(t))
-        return true;
-    if (SHELL_COMMAND_RE.test(t))
-        return true;
-    return false;
-}
-const USAGE_WINDOW_DAYS = 30;
-const USAGE_WINDOW_MS = USAGE_WINDOW_DAYS * 24 * 60 * 60 * 1000;
-// Idle gaps longer than this don't count as active time (lunch, overnight, a
-// session left open). There's no per-session ceiling — long focused sessions count fully.
-const MAX_ACTIVE_GAP_MINUTES = 15;
-// Parallel workspaces: Conductor workspaces AND git worktrees (the main way the
-// user runs many agents at once). Counted from the raw cwd before compactCwd
-// collapses worktrees into their repo.
-const PARALLEL_WORKSPACE_RE = /\/(conductor\/workspaces|\.worktrees|\.claude\/worktrees)\//;
-const SINGLE_EVENT_SESSION_MINUTES = 1;
-const INJECTED_PROMPT_PREFIXES = [
-    "AGENTS.md instructions for",
-    "# AGENTS.md",
-    "<system-reminder>",
-    "<system_instruction>",
-    "<environment_context>",
-    "<command-message>",
-    "<command-name>",
-    "Caveat: The messages below were generated",
-    "Please continue the conversation",
-    // Conductor auto-injected template — not user's words
-    "Please review the changes in this workspace",
-    // Codex/agent system instructions that land in the user role
-    "Respond directly to the user's prompt",
-    "Respond directly to the user",
-];
-function isInjectedPrompt(text) {
-    const head = text.trimStart().slice(0, 200);
-    return INJECTED_PROMPT_PREFIXES.some((p) => head.startsWith(p));
-}
-function stripInjectedWrappers(text) {
-    let out = text;
-    // Repeatedly strip paired XML-ish wrappers (non-greedy) until stable
-    let prev;
-    do {
-        prev = out;
-        out = out.replace(/<([a-zA-Z][\w-]*)>[\s\S]*?<\/\1>/g, " ");
-    } while (out !== prev && out.length < prev.length);
-    // Strip any remaining stray opening or closing tags
-    out = out.replace(/<\/?[a-zA-Z][\w-]*>/g, " ");
-    return out;
-}
-const EXT_TO_LANG = {
-    ts: "typescript",
-    tsx: "typescript",
-    js: "javascript",
-    jsx: "javascript",
-    mjs: "javascript",
-    cjs: "javascript",
-    py: "python",
-    go: "go",
-    rs: "rust",
-    java: "java",
-    kt: "kotlin",
-    swift: "swift",
-    rb: "ruby",
-    php: "php",
-    cpp: "cpp",
-    cc: "cpp",
-    hpp: "cpp",
-    h: "c",
-    c: "c",
-    cs: "csharp",
-    scala: "scala",
-    sh: "shell",
-    bash: "shell",
-    zsh: "shell",
-    sql: "sql",
-    tf: "terraform",
-    hcl: "terraform",
-    yaml: "yaml",
-    yml: "yaml",
-    json: "json",
-    md: "markdown",
-    mdx: "markdown",
-    css: "css",
-    scss: "sass",
-    sass: "sass",
-    vue: "vue",
-    svelte: "svelte",
-    dart: "dart",
-    lua: "lua",
-    r: "r",
-    ex: "elixir",
-    exs: "elixir",
-    erl: "erlang",
-    clj: "clojure",
-};
-const FRAMEWORK_SIGNALS = [
-    { match: /next\.config\.(js|ts|mjs)/, name: "nextjs" },
-    { match: /nuxt\.config\.(js|ts)/, name: "nuxt" },
-    { match: /remix\.config\.(js|ts)/, name: "remix" },
-    { match: /astro\.config\.(js|ts|mjs)/, name: "astro" },
-    { match: /svelte\.config\.(js|ts)/, name: "sveltekit" },
-    { match: /angular\.json/, name: "angular" },
-    { match: /vite\.config\.(js|ts|mjs)/, name: "vite" },
-    { match: /webpack\.config\.(js|ts)/, name: "webpack" },
-    { match: /prisma\/schema\.prisma/, name: "prisma" },
-    { match: /drizzle\.config\.(js|ts)/, name: "drizzle" },
-    { match: /tailwind\.config\.(js|ts|mjs)/, name: "tailwind" },
-    { match: /tsconfig\.json/, name: "typescript" },
-    { match: /jest\.config\.(js|ts)/, name: "jest" },
-    { match: /vitest\.config\.(js|ts)/, name: "vitest" },
-    { match: /playwright\.config\.(js|ts)/, name: "playwright" },
-    { match: /Cargo\.toml/, name: "rust" },
-    { match: /pyproject\.toml/, name: "python" },
-    { match: /requirements\.txt/, name: "python" },
-    { match: /Pipfile/, name: "python" },
-    { match: /go\.mod/, name: "go" },
-    { match: /Gemfile/, name: "ruby" },
-    { match: /pom\.xml/, name: "maven" },
-    { match: /build\.gradle/, name: "gradle" },
-    { match: /Dockerfile/, name: "docker" },
-    { match: /docker-compose\.(yml|yaml)/, name: "docker" },
-    { match: /fastapi/i, name: "fastapi" },
-    { match: /django/i, name: "django" },
-    { match: /rails/i, name: "rails" },
-    { match: /\.github\/workflows/, name: "github-actions" },
-    { match: /terraform/i, name: "terraform" },
-    { match: /supabase/i, name: "supabase" },
-    { match: /vercel\.(json|ts)/, name: "vercel" },
-];
-// Generated / vendored / build paths don't reflect what the user actually works
-// in — exclude them from the framework usage count so the stack weights toward
-// hand-authored code (e.g. Prisma migrations don't inflate "prisma").
-const GENERATED_PATH_RE = /(^|\/)(node_modules|dist|build|out|coverage|vendor|\.next|\.turbo|\.cache|__generated__|generated|migrations?)(\/|$)|\.generated\.|[-.]lock\.(json|ya?ml)$|package-lock\.json$/i;
-export function emptyRaw() {
-    return {
-        sessions: new Map(),
-        toolCounts: new Map(),
-        filePaths: new Set(),
-        hourCounts: new Array(24).fill(0),
-        weekendEvents: 0,
-        totalEvents: 0,
-        userMessageEvents: 0,
-        userMessageWeekendEvents: 0,
-        promptSamples: [],
-        promptSamplesSeen: new Set(),
-        activeDays: new Set(),
-        promptCounts: new Map(),
-        exchanges: [],
-        userTurns: 0,
-        correctionTurns: 0,
-        convoSamples: [],
-        convoTurns: 0,
-        questionTurns: 0,
-        promptCharsTotal: 0,
-        seenMessageIds: new Set(),
-    };
-}
-function inWindow(ts, opts) {
-    return ((opts.windowStartMs === undefined || ts >= opts.windowStartMs) &&
-        (opts.windowEndMs === undefined || ts < opts.windowEndMs));
-}
-// Build a dedup key that ignores trailing punctuation and case. Copy/paste
-// kickoff prompts (e.g. "run localhost and we are working on the /org part")
-// often appear identically across many parallel Conductor workspaces.
-function dedupKey(prompt) {
-    return prompt
-        .toLowerCase()
-        .replace(/[\s\p{P}]+$/u, "")
-        .slice(0, 160);
-}
-function pushPromptSample(raw, sample) {
-    if (raw.promptSamples.length >= MAX_PROMPT_SAMPLES)
-        return;
-    const key = dedupKey(sample);
-    if (raw.promptSamplesSeen.has(key))
-        return;
-    raw.promptSamplesSeen.add(key);
-    raw.promptSamples.push(sample);
-}
-function recordPromptFrequency(raw, sample) {
-    const key = dedupKey(sample);
-    const existing = raw.promptCounts.get(key);
-    if (existing)
-        existing.count += 1;
-    else
-        raw.promptCounts.set(key, { text: sample, count: 1 });
-}
-function sanitizeAssistantText(text) {
-    if (!text)
-        return null;
-    let out = stripInjectedWrappers(text.trim())
-        .replace(/```[\s\S]*?```/g, " ")
-        .replace(/\s+/g, " ")
-        .trim();
-    if (out.length < 8)
-        return null;
-    out = redactSecrets(out);
-    if (out.length > MAX_ASSISTANT_LEN)
-        out = out.slice(0, MAX_ASSISTANT_LEN) + "…";
-    return out;
-}
-// Records one user prompt for the conversation corpus: bumps frequency, counts
-// the turn (and whether it reads as a correction), and parks it as the pending
-// prompt so the next assistant reply can be paired into an exchange.
-function recordConversationUserTurn(target, sessionId, sample, longSample) {
-    const count = target.sessionPromptCounts.get(sessionId) ?? 0;
-    if (count >= MAX_PROMPTS_PER_SESSION)
-        return;
-    target.sessionPromptCounts.set(sessionId, count + 1);
-    // Real turns (for interaction signals) include everything; the "most common
-    // ask" ranking excludes trivial acknowledgements + pasted shell commands.
-    if (!isLowSignalAsk(sample))
-        recordPromptFrequency(target.raw, sample);
-    target.raw.userTurns += 1;
-    if (CORRECTION_RE.test(sample))
-        target.raw.correctionTurns += 1;
-    // The exchange (fed to the collaboration LLM) keeps the fuller prompt.
-    target.pendingPrompt.set(sessionId, longSample);
-}
-// Conversation-style signal: not subject to the per-session ask cap above, since
-// the reflexive mid-session "ok"/"go" turns are themselves part of the style.
-function recordConvoStyle(raw, text, ts, session) {
-    raw.convoTurns += 1;
-    raw.promptCharsTotal += text.length;
-    if (text.includes("?"))
-        raw.questionTurns += 1;
-    if (raw.convoSamples.length < MAX_CONVO_RESERVOIR && Number.isFinite(ts)) {
-        raw.convoSamples.push({
-            text: text.length > CONVO_SAMPLE_LEN ? text.slice(0, CONVO_SAMPLE_LEN) : text,
-            ts,
-            session,
-        });
-    }
-}
-function recordConversationAssistantTurn(target, sessionId, text) {
-    const pending = target.pendingPrompt.get(sessionId);
-    if (!pending)
-        return;
-    if (target.raw.exchanges.length >= MAX_EXCHANGES)
-        return;
-    const reply = sanitizeAssistantText(text);
-    if (!reply)
-        return;
-    target.raw.exchanges.push({ user: pending, assistant: reply });
-    target.pendingPrompt.delete(sessionId);
-}
-function sanitizePrompt(raw, maxLen = MAX_PROMPT_LEN) {
-    if (!raw)
-        return null;
-    // Drop messages that are nothing BUT injected content (AGENTS.md dumps, etc.)
-    if (isInjectedPrompt(raw) && !/\n\n[\S]/.test(raw))
-        return null;
-    let text = stripInjectedWrappers(raw.trim());
-    text = text
-        .replace(/```[\s\S]*?```/g, " ")
-        .replace(/^#\s*AGENTS\.md[^\n]*\n/i, "")
-        .replace(/^Implement the following plan[:.]?\s*/i, "")
-        .replace(/^#+\s*/gm, "")
-        .replace(/\s+/g, " ")
-        .trim();
-    if (!text || text.length < 8)
-        return null;
-    text = redactSecrets(text);
-    if (text.length > maxLen) {
-        text = text.slice(0, maxLen) + "…";
-    }
-    return text;
-}
-function registerFile(raw, filePath) {
-    if (!filePath || typeof filePath !== "string")
-        return;
-    if (raw.filePaths.size > 5000)
-        return;
-    raw.filePaths.add(filePath);
-}
-function recordSessionMeta(raw, sessionId, ts, cwd, model, version) {
-    const minute = Math.floor(ts / 60_000);
-    const existing = raw.sessions.get(sessionId);
-    if (existing) {
-        if (ts < existing.firstTs)
-            existing.firstTs = ts;
-        if (ts > existing.lastTs)
-            existing.lastTs = ts;
-        existing.eventTimestamps.add(minute);
-        if (!existing.cwd && cwd)
-            existing.cwd = cwd;
-        if (model)
-            existing.models.add(model);
-        if (!existing.version && version)
-            existing.version = version;
-    }
-    else {
-        raw.sessions.set(sessionId, {
-            firstTs: ts,
-            lastTs: ts,
-            eventTimestamps: new Set([minute]),
-            cwd,
-            models: model ? new Set([model]) : new Set(),
-            modelTurnCounts: new Map(),
-            inputTokens: 0,
-            outputTokens: 0,
-            cacheReadTokens: 0,
-            cacheWriteTokens: 0,
-            version,
-        });
-    }
-}
-function recordTurn(raw, sessionId, model, tokens) {
-    const session = raw.sessions.get(sessionId);
-    if (!session)
-        return;
-    if (model) {
-        session.modelTurnCounts.set(model, (session.modelTurnCounts.get(model) ?? 0) + 1);
-    }
-    session.inputTokens += tokens.input ?? 0;
-    session.outputTokens += tokens.output ?? 0;
-    session.cacheReadTokens += tokens.cacheRead ?? 0;
-    session.cacheWriteTokens += tokens.cacheWrite ?? 0;
-}
-function recordTemporal(raw, ts) {
-    const d = new Date(ts);
-    if (isNaN(d.getTime()))
-        return;
-    raw.totalEvents += 1;
-    raw.hourCounts[d.getHours()] += 1;
-    const day = d.getDay();
-    if (day === 0 || day === 6)
-        raw.weekendEvents += 1;
-    raw.activeDays.add(d.toISOString().slice(0, 10));
-}
-// Weekend share is computed from messages the USER actually sent (not every log
-// line) so it reflects when they work, not assistant/tool log volume. Local tz.
-function recordUserMessageTemporal(raw, ts) {
-    const d = new Date(ts);
-    if (isNaN(d.getTime()))
-        return;
-    raw.userMessageEvents += 1;
-    const day = d.getDay();
-    if (day === 0 || day === 6)
-        raw.userMessageWeekendEvents += 1;
-}
-// Worktree setups symlink each worktree's ~/.claude/projects dir back to one
-// physical dir, so readdir/stat (which follow symlinks) surface the same session
-// file under dozens of paths. Collapse to physical files so nothing is counted
-// more than once.
-export function dedupeByRealpath(files) {
-    files.sort((a, b) => b.mtime - a.mtime);
-    const seen = new Set();
-    const out = [];
-    for (const f of files) {
-        let real;
-        try {
-            real = realpathSync(f.path);
-        }
-        catch {
-            real = f.path;
-        }
-        if (seen.has(real))
-            continue;
-        seen.add(real);
-        out.push(f.path);
-    }
-    return out;
-}
-function listClaudeCodeFiles() {
-    const base = join(homedir(), ".claude", "projects");
-    if (!existsSync(base))
-        return [];
-    const files = [];
-    try {
-        for (const projectDir of readdirSync(base)) {
-            const full = join(base, projectDir);
-            let entries;
-            try {
-                entries = readdirSync(full);
-            }
-            catch {
-                continue;
-            }
-            for (const entry of entries) {
-                if (!entry.endsWith(".jsonl"))
-                    continue;
-                const filePath = join(full, entry);
-                try {
-                    const stat = statSync(filePath);
-                    files.push({ path: filePath, mtime: stat.mtimeMs });
-                }
-                catch {
-                    // skip
-                }
-            }
-        }
-    }
-    catch {
-        return [];
-    }
-    return dedupeByRealpath(files);
-}
-function listCodexFiles() {
-    const base = join(homedir(), ".codex", "sessions");
-    if (!existsSync(base))
-        return [];
-    const files = [];
-    const walk = (dir, depth) => {
-        if (depth > 4)
-            return;
-        let entries;
-        try {
-            entries = readdirSync(dir);
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            const full = join(dir, entry);
-            let stat;
-            try {
-                stat = statSync(full);
-            }
-            catch {
-                continue;
-            }
-            if (stat.isDirectory()) {
-                walk(full, depth + 1);
-            }
-            else if (entry.endsWith(".jsonl") && entry.startsWith("rollout-")) {
-                files.push({ path: full, mtime: stat.mtimeMs });
-            }
-        }
-    };
-    walk(base, 0);
-    return dedupeByRealpath(files);
-}
-async function streamLines(filePath, onLine) {
-    const stream = createReadStream(filePath, { encoding: "utf-8" });
-    const rl = createInterface({ input: stream, crlfDelay: Infinity });
-    let n = 0;
-    for await (const line of rl) {
-        if (line)
-            onLine(line);
-        // Per-line work runs as a microtask drain, which starves macrotask timers
-        // (the loading spinner). Yield a macrotask periodically so it keeps
-        // animating during big scans.
-        if ((++n & 2047) === 0)
-            await new Promise((r) => setImmediate(r));
-    }
-}
-export async function parseClaudeCodeFile(filePath, raw, opts = {}) {
-    await parseClaudeCodeFileTargets(filePath, [{ raw, opts }]);
-}
-function makeTargets(targetInputs) {
-    return targetInputs.map((target) => ({
-        raw: target.raw,
-        opts: target.opts ?? {},
-        seenUserPromptThisSession: false,
-        collectConversation: target.collectConversation ?? false,
-        sessionPromptCounts: new Map(),
-        pendingPrompt: new Map(),
-    }));
-}
-export async function parseClaudeCodeFileTargets(filePath, targetInputs) {
-    const targets = makeTargets(targetInputs);
-    // Session id derivable from filename: <uuid>.jsonl
-    const fileName = filePath.split("/").pop() || "";
-    const fallbackSessionId = fileName.replace(/\.jsonl$/, "");
-    let sessionId = fallbackSessionId;
-    await streamLines(filePath, (line) => {
-        let d;
-        try {
-            d = JSON.parse(line);
-        }
-        catch {
-            return;
-        }
-        const ts = typeof d.timestamp === "string" ? Date.parse(d.timestamp) : NaN;
-        if (typeof d.sessionId === "string")
-            sessionId = d.sessionId;
-        const cwd = typeof d.cwd === "string" ? d.cwd : null;
-        const version = typeof d.version === "string" ? d.version : null;
-        const type = d.type;
-        const message = d.message;
-        for (const target of targets) {
-            const shouldCount = !isNaN(ts) && inWindow(ts, target.opts);
-            if (shouldCount)
-                recordTemporal(target.raw, ts);
-            if (type === "user" && message) {
-                const content = message.content;
-                // Skip tool_result payloads (those are arrays of objects)
-                if (shouldCount && typeof content === "string") {
-                    // Count real (non-injected) user messages for the weekend share.
-                    if (!isInjectedPrompt(content))
-                        recordUserMessageTemporal(target.raw, ts);
-                    const sample = sanitizePrompt(content);
-                    if (sample) {
-                        if (!target.seenUserPromptThisSession) {
-                            pushPromptSample(target.raw, sample);
-                            target.seenUserPromptThisSession = true;
-                        }
-                        // Exclude injected/system templates from the conversation corpus so
-                        // "most common ask" reflects real user prompts, not boilerplate.
-                        if (target.collectConversation && !isInjectedPrompt(content)) {
-                            const longSample = sanitizePrompt(content, MAX_EXCHANGE_PROMPT_LEN) ?? sample;
-                            recordConversationUserTurn(target, sessionId, sample, longSample);
-                            // Style counters are local-only (no LLM) — measure the full prompt,
-                            // not the 200-char display sample, so a late "?" still counts.
-                            const fullSample = sanitizePrompt(content, Number.POSITIVE_INFINITY) ?? sample;
-                            recordConvoStyle(target.raw, fullSample, ts, sessionId);
-                        }
-                    }
-                }
-                if (shouldCount) {
-                    recordSessionMeta(target.raw, sessionId, ts, cwd, null, version);
-                }
-            }
-            else if (type === "assistant" && message) {
-                const model = typeof message.model === "string" ? message.model : null;
-                if (shouldCount) {
-                    recordSessionMeta(target.raw, sessionId, ts, cwd, model, version);
-                }
-                const usage = message.usage;
-                const messageId = typeof message.id === "string" ? message.id : null;
-                // One assistant message spans multiple JSONL lines (one per content
-                // block), each repeating the same usage; resumed sessions also re-emit
-                // prior messages. Count each message's tokens exactly once.
-                if (shouldCount && usage) {
-                    const seen = messageId
-                        ? target.raw.seenMessageIds.has(messageId)
-                        : false;
-                    if (!seen) {
-                        if (messageId)
-                            target.raw.seenMessageIds.add(messageId);
-                        recordTurn(target.raw, sessionId, model, {
-                            input: usage.input_tokens,
-                            output: usage.output_tokens,
-                            cacheRead: usage.cache_read_input_tokens,
-                            cacheWrite: usage.cache_creation_input_tokens,
-                        });
-                    }
-                }
-                const content = message.content;
-                if (shouldCount && Array.isArray(content)) {
-                    const textParts = [];
-                    for (const item of content) {
-                        if (item && typeof item === "object") {
-                            const itemType = item.type;
-                            if (itemType === "text" && target.collectConversation) {
-                                const text = item.text;
-                                if (typeof text === "string")
-                                    textParts.push(text);
-                            }
-                            if (itemType === "tool_use") {
-                                const toolName = item.name;
-                                if (toolName) {
-                                    target.raw.toolCounts.set(toolName, (target.raw.toolCounts.get(toolName) || 0) + 1);
-                                }
-                                const input = item
-                                    .input;
-                                if (input) {
-                                    registerFile(target.raw, input.file_path);
-                                    registerFile(target.raw, input.path);
-                                    registerFile(target.raw, input.notebook_path);
-                                }
-                            }
-                        }
-                    }
-                    if (target.collectConversation && textParts.length > 0) {
-                        recordConversationAssistantTurn(target, sessionId, textParts.join(" "));
-                    }
-                }
-            }
-            else if (shouldCount) {
-                recordSessionMeta(target.raw, sessionId, ts, cwd, null, version);
-            }
-        }
-    });
-}
-export async function parseCodexFile(filePath, raw, opts = {}) {
-    await parseCodexFileTargets(filePath, [{ raw, opts }]);
-}
-async function parseCodexFileTargets(filePath, targetInputs) {
-    const targets = makeTargets(targetInputs);
-    let sessionId = filePath.split("/").pop() || filePath;
-    let cliVersion = null;
-    let cwd = null;
-    let model = null;
-    await streamLines(filePath, (line) => {
-        let d;
-        try {
-            d = JSON.parse(line);
-        }
-        catch {
-            return;
-        }
-        const ts = typeof d.timestamp === "string" ? Date.parse(d.timestamp) : NaN;
-        const type = d.type;
-        const payload = d.payload;
-        if (type === "session_meta" && payload) {
-            if (typeof payload.id === "string")
-                sessionId = payload.id;
-            if (typeof payload.cwd === "string")
-                cwd = payload.cwd;
-            if (typeof payload.cli_version === "string")
-                cliVersion = payload.cli_version;
-            if (typeof payload.model === "string")
-                model = payload.model;
-            // Codex doesn't always set a `model` field — sniff the base_instructions
-            // for "based on <model>" so we can label the provider/model in stats.
-            if (!model) {
-                const bi = payload.base_instructions;
-                const head = bi?.text?.slice(0, 200) ?? "";
-                const m = head.match(/based on (GPT-?\d+(?:[\.-]\d+)?(?:-mini|-nano|-turbo|-pro)?)/i);
-                if (m)
-                    model = m[1].toLowerCase().replace(/\s+/g, "-");
-                else if (typeof payload.model_provider === "string") {
-                    // Fall back to a generic provider label
-                    model = `${payload.model_provider}-default`;
-                }
-            }
-        }
-        for (const target of targets) {
-            const shouldCount = !isNaN(ts) && inWindow(ts, target.opts);
-            if (shouldCount)
-                recordTemporal(target.raw, ts);
-            if (shouldCount) {
-                recordSessionMeta(target.raw, sessionId, ts, cwd, model, cliVersion);
-            }
-            if (type === "event_msg" && payload) {
-                // Codex emits cumulative token totals; overwrite the session running totals.
-                const info = payload.info;
-                const totals = info?.total_token_usage;
-                if (shouldCount && totals && target.raw.sessions.has(sessionId)) {
-                    const session = target.raw.sessions.get(sessionId);
-                    // Codex `total_token_usage.input_tokens` INCLUDES cached_input_tokens.
-                    // Store FRESH input (input - cached) + cache separately so it matches
-                    // how Claude Code reports (fresh input + separate cache).
-                    const cached = totals.cached_input_tokens ?? 0;
-                    const totalIn = totals.input_tokens ?? 0;
-                    session.inputTokens = Math.max(0, totalIn - cached);
-                    session.outputTokens = totals.output_tokens ?? session.outputTokens;
-                    session.cacheReadTokens = cached;
-                    if (model) {
-                        session.modelTurnCounts.set(model, (session.modelTurnCounts.get(model) ?? 0) + 1);
-                    }
-                }
-            }
-            else if (type === "response_item" && payload) {
-                const pType = payload.type;
-                const role = payload.role;
-                if ((pType === "function_call" || pType === "local_shell_call") &&
-                    shouldCount) {
-                    const toolName = payload.name ||
-                        (pType === "local_shell_call" ? "shell" : "function");
-                    target.raw.toolCounts.set(toolName, (target.raw.toolCounts.get(toolName) || 0) + 1);
-                    // Try to extract file path from arguments
-                    const argsRaw = payload.arguments;
-                    if (typeof argsRaw === "string") {
-                        try {
-                            const args = JSON.parse(argsRaw);
-                            registerFile(target.raw, args.path);
-                            registerFile(target.raw, args.file_path);
-                            if (typeof args.cmd === "string") {
-                                // Pull file-looking tokens from shell commands
-                                const tokens = args.cmd.match(/[\w./-]+\.[a-zA-Z0-9]{1,6}\b/g);
-                                if (tokens)
-                                    tokens
-                                        .slice(0, 5)
-                                        .forEach((t) => registerFile(target.raw, t));
-                            }
-                        }
-                        catch {
-                            // skip
-                        }
-                    }
-                }
-                else if (shouldCount && role === "user") {
-                    const content = payload.content;
-                    if (Array.isArray(content)) {
-                        let countedUserMsg = false;
-                        for (const item of content) {
-                            if (item && typeof item === "object") {
-                                const text = item.text;
-                                if (typeof text === "string") {
-                                    // One weekend-share tick per real user message line.
-                                    if (!countedUserMsg && !isInjectedPrompt(text)) {
-                                        recordUserMessageTemporal(target.raw, ts);
-                                        countedUserMsg = true;
-                                    }
-                                    const sample = sanitizePrompt(text);
-                                    if (sample) {
-                                        if (!target.seenUserPromptThisSession) {
-                                            pushPromptSample(target.raw, sample);
-                                            target.seenUserPromptThisSession = true;
-                                        }
-                                        if (target.collectConversation && !isInjectedPrompt(text)) {
-                                            const longSample = sanitizePrompt(text, MAX_EXCHANGE_PROMPT_LEN) ?? sample;
-                                            recordConversationUserTurn(target, sessionId, sample, longSample);
-                                            // Style counters are local-only (no LLM) — measure the
-                                            // full prompt so a late "?" still counts.
-                                            const fullSample = sanitizePrompt(text, Number.POSITIVE_INFINITY) ??
-                                                sample;
-                                            recordConvoStyle(target.raw, fullSample, ts, sessionId);
-                                        }
-                                        break;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                else if (shouldCount &&
-                    role === "assistant" &&
-                    target.collectConversation) {
-                    const content = payload.content;
-                    if (Array.isArray(content)) {
-                        const textParts = [];
-                        for (const item of content) {
-                            if (item && typeof item === "object") {
-                                const text = item.text;
-                                if (typeof text === "string")
-                                    textParts.push(text);
-                            }
-                        }
-                        if (textParts.length > 0) {
-                            recordConversationAssistantTurn(target, sessionId, textParts.join(" "));
-                        }
-                    }
-                }
-            }
-        }
-    });
-}
-/**
- * Compute longest historical streak + current streak from a set of YYYY-MM-DD
- * day strings. Current streak counts consecutive days ending today or yesterday;
- * older trailing streaks count as 0 (broken).
- */
-export function computeStreaks(activeDays) {
-    if (activeDays.size === 0)
-        return { longest: 0, current: 0 };
-    const sorted = [...activeDays].sort();
-    const dayMs = 86_400_000;
-    let longest = 1;
-    let run = 1;
-    for (let i = 1; i < sorted.length; i++) {
-        const prev = Date.parse(sorted[i - 1]);
-        const curr = Date.parse(sorted[i]);
-        const diff = Math.round((curr - prev) / dayMs);
-        if (diff === 1) {
-            run += 1;
-            if (run > longest)
-                longest = run;
-        }
-        else if (diff > 1) {
-            run = 1;
-        }
-    }
-    // Current streak — walk backward from the latest day
-    let current = 1;
-    for (let i = sorted.length - 1; i > 0; i--) {
-        const prev = Date.parse(sorted[i - 1]);
-        const curr = Date.parse(sorted[i]);
-        if (Math.round((curr - prev) / dayMs) === 1) {
-            current += 1;
-        }
-        else {
-            break;
-        }
-    }
-    // Streak only counts as "current" if it ended today or yesterday
-    const lastDay = Date.parse(sorted[sorted.length - 1]);
-    const today = Date.parse(new Date().toISOString().slice(0, 10));
-    const daysSinceLast = Math.round((today - lastDay) / dayMs);
-    if (daysSinceLast > 1)
-        current = 0;
-    return { longest, current };
-}
-function estimateActiveDurationMs(minuteBuckets) {
-    const sorted = [...new Set(minuteBuckets)]
-        .filter((m) => Number.isFinite(m))
-        .sort((a, b) => a - b)
-        .map((m) => m * 60_000);
-    if (sorted.length === 0)
-        return 0;
-    if (sorted.length === 1)
-        return SINGLE_EVENT_SESSION_MINUTES * 60 * 1000;
-    // Sum the time between consecutive events, but clamp each gap to 15 min so idle
-    // stretches (lunch, overnight, a session left open) don't count as active time.
-    // No per-session ceiling — a genuinely long focused session counts in full.
-    const maxGapMs = MAX_ACTIVE_GAP_MINUTES * 60 * 1000;
-    let total = 0;
-    for (let i = 1; i < sorted.length; i++) {
-        const gap = sorted[i] - sorted[i - 1];
-        if (gap <= 0)
-            continue;
-        total += Math.min(gap, maxGapMs);
-    }
-    return total;
-}
-function compactCwd(cwd) {
-    const home = homedir();
-    const p = cwd.startsWith(home) ? cwd.replace(home, "~") : cwd;
-    // Collapse git worktrees back to the repo they branch from so parallel
-    // worktrees of one project don't each register as a separate project.
-    //   ~/work/standout/.worktrees/feat-x      → ~/work/standout
-    //   ~/work/standout/.claude/worktrees/foo  → ~/work/standout
-    // Conductor paths (~/conductor/workspaces/...) are left intact so the
-    // conductor-workspace split below still detects them.
-    return p
-        .replace(/\/\.claude\/worktrees\/[^/]+.*$/, "")
-        .replace(/\/\.worktrees\/[^/]+.*$/, "");
-}
-// Split a session's events into active segments (consecutive events <= 15min
-// apart), so concurrency reflects real work, not a tab idle for days.
-function activeSegments(minuteBuckets) {
-    const sorted = [...new Set(minuteBuckets)]
-        .filter((m) => Number.isFinite(m))
-        .sort((a, b) => a - b)
-        .map((m) => m * 60_000);
-    if (sorted.length === 0)
-        return [];
-    const maxGapMs = MAX_ACTIVE_GAP_MINUTES * 60 * 1000;
-    const segs = [];
-    let segStart = sorted[0];
-    let prev = sorted[0];
-    for (let i = 1; i < sorted.length; i++) {
-        if (sorted[i] - prev > maxGapMs) {
-            segs.push([segStart, prev]);
-            segStart = sorted[i];
-        }
-        prev = sorted[i];
-    }
-    segs.push([segStart, prev]);
-    return segs;
-}
-// Time-weighted concurrency: how many sessions overlap at once. Open-tab uses the
-// full first→last span (idle tabs included); active-juggle only the active segments.
-function computeConcurrency(sessions) {
-    let longestMs = 0;
-    const openSpans = [];
-    const activeSpans = [];
-    for (const s of sessions) {
-        if (Number.isFinite(s.firstTs) && Number.isFinite(s.lastTs)) {
-            const span = s.lastTs - s.firstTs;
-            if (span > longestMs)
-                longestMs = span;
-            if (span > 0)
-                openSpans.push([s.firstTs, s.lastTs]);
-        }
-        for (const seg of activeSegments(s.eventTimestamps))
-            if (seg[1] > seg[0])
-                activeSpans.push(seg);
-    }
-    // Time-weighted average / peak overlap over a set of intervals.
-    const sweep = (spans) => {
-        const events = [];
-        for (const [a, b] of spans) {
-            events.push([a, 1]);
-            events.push([b, -1]);
-        }
-        events.sort((x, y) => x[0] - y[0] || x[1] - y[1]);
-        let cur = 0;
-        let peak = 0;
-        let weighted = 0;
-        let covered = 0;
-        let multi = 0;
-        let prev = null;
-        for (const [t, delta] of events) {
-            if (prev !== null && t > prev && cur > 0) {
-                weighted += cur * (t - prev);
-                covered += t - prev;
-                if (cur >= 2)
-                    multi += t - prev;
-            }
-            cur += delta;
-            if (cur > peak)
-                peak = cur;
-            prev = t;
-        }
-        const avg = covered > 0 ? weighted / covered : 0;
-        return { avg, peak, multiFraction: covered > 0 ? multi / covered : 0 };
-    };
-    const open = sweep(openSpans);
-    const active = sweep(activeSpans);
-    return {
-        open_tab_avg: +open.avg.toFixed(1),
-        open_tab_peak: open.peak,
-        longest_session_hours: +(longestMs / 1000 / 3600).toFixed(1),
-        active_juggle_pct: +active.multiFraction.toFixed(2),
-    };
-}
-// Evenly-spread sample of the conversation reservoir: cap per session, then stride
-// across the ts-sorted pool so the sample spans the whole window, not just the tail.
-function sampleConversation(reservoir) {
-    const bySession = new Map();
-    for (const r of reservoir) {
-        const arr = bySession.get(r.session);
-        if (arr)
-            arr.push(r);
-        else
-            bySession.set(r.session, [{ text: r.text, ts: r.ts }]);
-    }
-    const picked = [];
-    for (const arr of bySession.values()) {
-        arr.sort((a, b) => a.ts - b.ts);
-        if (arr.length <= MAX_CONVO_PER_SESSION) {
-            picked.push(...arr);
-        }
-        else {
-            const step = arr.length / MAX_CONVO_PER_SESSION;
-            for (let i = 0; i < MAX_CONVO_PER_SESSION; i++)
-                picked.push(arr[Math.floor(i * step)]);
-        }
-    }
-    picked.sort((a, b) => a.ts - b.ts);
-    if (picked.length <= CONVO_SAMPLE_TARGET)
-        return picked.map((p) => p.text);
-    const step = picked.length / CONVO_SAMPLE_TARGET;
-    const out = [];
-    for (let i = 0; i < CONVO_SAMPLE_TARGET; i++)
-        out.push(picked[Math.floor(i * step)].text);
-    return out;
-}
-export function finalize(raw) {
-    if (raw.sessions.size === 0)
-        return null;
-    const sessionTimes = Array.from(raw.sessions.values());
-    let totalDurationMs = 0;
-    let firstTs = Infinity;
-    let lastTs = -Infinity;
-    const projectCounts = new Map();
-    const parallelCwds = new Set();
-    const modelsSet = new Set();
-    const versionsSet = new Set();
-    for (const s of sessionTimes) {
-        totalDurationMs += estimateActiveDurationMs(s.eventTimestamps);
-        if (s.firstTs < firstTs)
-            firstTs = s.firstTs;
-        if (s.lastTs > lastTs)
-            lastTs = s.lastTs;
-        if (s.cwd) {
-            // Count distinct parallel workspaces from the RAW cwd before compactCwd
-            // collapses worktrees — both Conductor and git worktrees count.
-            if (PARALLEL_WORKSPACE_RE.test(s.cwd))
-                parallelCwds.add(s.cwd);
-            const key = compactCwd(s.cwd);
-            projectCounts.set(key, (projectCounts.get(key) || 0) + 1);
-        }
-        s.models.forEach((m) => {
-            if (m && !m.startsWith("<") && !m.includes("synthetic"))
-                modelsSet.add(m);
-        });
-        if (s.version)
-            versionsSet.add(s.version);
-    }
-    const languages = {};
-    // Count how many distinct file paths touch each language/framework — a usage
-    // proxy, so the stack orders by what the user actually works in. Generated /
-    // vendored / build paths are skipped so they don't reflect hand-authored work.
-    const frameworkCounts = {};
-    for (const filePath of raw.filePaths) {
-        if (GENERATED_PATH_RE.test(filePath))
-            continue;
-        const lowered = filePath.toLowerCase();
-        const ext = lowered.split(".").pop();
-        if (ext && EXT_TO_LANG[ext]) {
-            const lang = EXT_TO_LANG[ext];
-            languages[lang] = (languages[lang] || 0) + 1;
-        }
-        for (const sig of FRAMEWORK_SIGNALS) {
-            if (sig.match.test(filePath))
-                frameworkCounts[sig.name] = (frameworkCounts[sig.name] ?? 0) + 1;
-        }
-    }
-    const frameworks = Object.keys(frameworkCounts).sort((a, b) => frameworkCounts[b] - frameworkCounts[a]);
-    // Peak hour = argmax of hourCounts
-    let peakHour = null;
-    let peakVal = 0;
-    raw.hourCounts.forEach((count, hour) => {
-        if (count > peakVal) {
-            peakVal = count;
-            peakHour = hour;
-        }
-    });
-    // Weekend share = fraction of messages the USER sent that landed on Sat/Sun
-    // (local tz). Falls back to all-event timing only if no user messages were seen.
-    const weekendRatio = raw.userMessageEvents > 0
-        ? raw.userMessageWeekendEvents / raw.userMessageEvents
-        : raw.totalEvents > 0
-            ? raw.weekendEvents / raw.totalEvents
-            : 0;
-    const toolCallCounts = {};
-    for (const [name, count] of raw.toolCounts) {
-        toolCallCounts[name] = count;
-    }
-    // Group Conductor parallel-workspace sessions into a single virtual project
-    // and surface their count separately. Conductor spawns Claude Code in
-    // ~/conductor/workspaces/<name> dirs, so each branch shows up as its own
-    // project in the raw data — useful for the wrapped "73 parallel branches" card.
-    let conductorWorkspaces = 0;
-    let conductorSessions = 0;
-    const nonConductorProjects = [];
-    for (const [cwd, count] of projectCounts.entries()) {
-        if (cwd.includes("/conductor/workspaces/")) {
-            conductorWorkspaces += 1;
-            conductorSessions += count;
-        }
-        else {
-            nonConductorProjects.push({ cwd, session_count: count });
-        }
-    }
-    const projects = nonConductorProjects
-        .sort((a, b) => b.session_count - a.session_count)
-        .slice(0, 20);
-    const streaks = computeStreaks(raw.activeDays);
-    // Per-session token + model + month aggregates
-    let totalInputTokens = 0;
-    let totalOutputTokens = 0;
-    let totalCacheReadTokens = 0;
-    let totalCacheWriteTokens = 0;
-    const modelSessionCounts = {};
-    const monthly = new Map();
-    for (const s of sessionTimes) {
-        totalInputTokens += s.inputTokens;
-        totalOutputTokens += s.outputTokens;
-        totalCacheReadTokens += s.cacheReadTokens;
-        totalCacheWriteTokens += s.cacheWriteTokens;
-        // Primary model for this session = the one with the most turns
-        let primary = null;
-        let primaryCount = 0;
-        for (const [m, n] of s.modelTurnCounts) {
-            if (n > primaryCount) {
-                primary = m;
-                primaryCount = n;
-            }
-        }
-        if (primary && !primary.startsWith("<") && !primary.includes("synthetic")) {
-            modelSessionCounts[primary] = (modelSessionCounts[primary] ?? 0) + 1;
-        }
-        // Bucket into month based on session start
-        if (isFinite(s.firstTs)) {
-            const monthKey = new Date(s.firstTs).toISOString().slice(0, 7); // YYYY-MM
-            let bucket = monthly.get(monthKey);
-            if (!bucket) {
-                bucket = {
-                    sessions: 0,
-                    durationMs: 0,
-                    inputTokens: 0,
-                    outputTokens: 0,
-                    cacheReadTokens: 0,
-                    cacheWriteTokens: 0,
-                    modelTurnCounts: new Map(),
-                };
-                monthly.set(monthKey, bucket);
-            }
-            bucket.sessions += 1;
-            bucket.durationMs += estimateActiveDurationMs(s.eventTimestamps);
-            bucket.inputTokens += s.inputTokens;
-            bucket.outputTokens += s.outputTokens;
-            bucket.cacheReadTokens += s.cacheReadTokens;
-            bucket.cacheWriteTokens += s.cacheWriteTokens;
-            for (const [m, n] of s.modelTurnCounts) {
-                bucket.modelTurnCounts.set(m, (bucket.modelTurnCounts.get(m) ?? 0) + n);
-            }
-        }
-    }
-    const monthlyBuckets = [...monthly.entries()]
-        .sort(([a], [b]) => a.localeCompare(b))
-        .map(([month, b]) => {
-        let primary = null;
-        let primaryCount = 0;
-        for (const [m, n] of b.modelTurnCounts) {
-            if (n > primaryCount) {
-                primary = m;
-                primaryCount = n;
-            }
-        }
-        return {
-            month,
-            sessions: b.sessions,
-            duration_hours: +(b.durationMs / 1000 / 3600).toFixed(1),
-            input_tokens: b.inputTokens,
-            output_tokens: b.outputTokens,
-            cache_read_tokens: b.cacheReadTokens,
-            cache_write_tokens: b.cacheWriteTokens,
-            cache_tokens: b.cacheReadTokens + b.cacheWriteTokens,
-            primary_model: primary,
-        };
-    });
-    return {
-        total_sessions: raw.sessions.size,
-        active_days: raw.activeDays.size,
-        first_session: isFinite(firstTs) ? new Date(firstTs).toISOString() : null,
-        last_session: isFinite(lastTs) ? new Date(lastTs).toISOString() : null,
-        total_duration_hours: +(totalDurationMs / 1000 / 3600).toFixed(1),
-        tool_call_counts: toolCallCounts,
-        projects,
-        models: [...modelsSet],
-        versions: [...versionsSet].slice(0, 10),
-        peak_hour: peakHour,
-        hour_buckets: raw.hourCounts.slice(),
-        weekend_ratio: +weekendRatio.toFixed(2),
-        longest_streak_days: streaks.longest,
-        current_streak_days: streaks.current,
-        conductor_workspaces: conductorWorkspaces,
-        conductor_session_count: conductorSessions,
-        parallel_workspaces: parallelCwds.size,
-        languages,
-        frameworks: [...frameworks],
-        framework_counts: frameworkCounts,
-        prompt_samples: raw.promptSamples,
-        conversation_samples: sampleConversation(raw.convoSamples),
-        conversation: {
-            total_prompts: raw.convoTurns,
-            question_ratio: raw.convoTurns > 0
-                ? +(raw.questionTurns / raw.convoTurns).toFixed(2)
-                : 0,
-            avg_prompt_chars: raw.convoTurns > 0
-                ? Math.round(raw.promptCharsTotal / raw.convoTurns)
-                : 0,
-        },
-        concurrency: computeConcurrency(sessionTimes),
-        prompt_frequency: [...raw.promptCounts.values()]
-            .sort((a, b) => b.count - a.count)
-            .slice(0, MAX_PROMPT_FREQUENCY),
-        exchanges: raw.exchanges,
-        interaction: {
-            user_turns: raw.userTurns,
-            correction_turns: raw.correctionTurns,
-            tool_calls: [...raw.toolCounts.values()].reduce((a, b) => a + b, 0),
-        },
-        total_input_tokens: totalInputTokens,
-        total_output_tokens: totalOutputTokens,
-        total_cache_read_tokens: totalCacheReadTokens,
-        total_cache_write_tokens: totalCacheWriteTokens,
-        model_session_counts: modelSessionCounts,
-        monthly_buckets: monthlyBuckets,
-    };
-}
-function summarizeUsage(stats) {
-    return {
-        total_sessions: stats.total_sessions,
-        active_days: stats.active_days,
-        first_session: stats.first_session,
-        last_session: stats.last_session,
-        total_duration_hours: stats.total_duration_hours,
-        total_input_tokens: stats.total_input_tokens,
-        total_output_tokens: stats.total_output_tokens,
-        total_cache_read_tokens: stats.total_cache_read_tokens,
-        total_cache_write_tokens: stats.total_cache_write_tokens,
-        monthly_buckets: stats.monthly_buckets,
-        hour_buckets: stats.hour_buckets,
-        peak_hour: stats.peak_hour,
-        longest_streak_days: stats.longest_streak_days,
-    };
-}
-function emptyWindowStats(allTime) {
-    return {
-        total_sessions: 0,
-        active_days: 0,
-        first_session: null,
-        last_session: null,
-        total_duration_hours: 0,
-        tool_call_counts: {},
-        projects: [],
-        models: [],
-        versions: [],
-        peak_hour: null,
-        hour_buckets: new Array(24).fill(0),
-        weekend_ratio: 0,
-        longest_streak_days: 0,
-        current_streak_days: 0,
-        conductor_workspaces: 0,
-        conductor_session_count: 0,
-        parallel_workspaces: 0,
-        languages: {},
-        frameworks: [],
-        framework_counts: {},
-        prompt_samples: [],
-        conversation_samples: [],
-        conversation: { total_prompts: 0, question_ratio: 0, avg_prompt_chars: 0 },
-        concurrency: {
-            open_tab_avg: 0,
-            open_tab_peak: 0,
-            longest_session_hours: 0,
-            active_juggle_pct: 0,
-        },
-        prompt_frequency: [],
-        exchanges: [],
-        interaction: { user_turns: 0, correction_turns: 0, tool_calls: 0 },
-        total_input_tokens: 0,
-        total_output_tokens: 0,
-        total_cache_read_tokens: 0,
-        total_cache_write_tokens: 0,
-        model_session_counts: {},
-        monthly_buckets: [],
-        all_time: summarizeUsage(allTime),
-    };
-}
-function withAllTime(recent, allTime, previous = null) {
-    if (!allTime)
-        return recent;
-    const stats = recent ?? emptyWindowStats(allTime);
-    stats.all_time = summarizeUsage(allTime);
-    if (previous)
-        stats.previous_30d = summarizeUsage(previous);
-    return stats;
-}
-export async function gatherAiUsage() {
-    const claudeFiles = listClaudeCodeFiles();
-    const codexFiles = listCodexFiles();
-    const windowStartMs = Date.now() - USAGE_WINDOW_MS;
-    const previousWindowStartMs = windowStartMs - USAGE_WINDOW_MS;
-    const claudeRecentRaw = emptyRaw();
-    const claudePreviousRaw = emptyRaw();
-    const claudeAllRaw = emptyRaw();
-    const codexRecentRaw = emptyRaw();
-    const codexPreviousRaw = emptyRaw();
-    const codexAllRaw = emptyRaw();
-    const [cursor] = await Promise.all([
-        gatherCursor({ windowStartMs }).catch(() => null),
-        (async () => {
-            for (const file of claudeFiles) {
-                try {
-                    await parseClaudeCodeFileTargets(file, [
-                        {
-                            raw: claudeRecentRaw,
-                            opts: { windowStartMs },
-                            collectConversation: true,
-                        },
-                        {
-                            raw: claudePreviousRaw,
-                            opts: {
-                                windowStartMs: previousWindowStartMs,
-                                windowEndMs: windowStartMs,
-                            },
-                        },
-                        { raw: claudeAllRaw },
-                    ]);
-                }
-                catch {
-                    // skip
-                }
-            }
-        })(),
-        (async () => {
-            for (const file of codexFiles) {
-                try {
-                    await parseCodexFileTargets(file, [
-                        {
-                            raw: codexRecentRaw,
-                            opts: { windowStartMs },
-                            collectConversation: true,
-                        },
-                        {
-                            raw: codexPreviousRaw,
-                            opts: {
-                                windowStartMs: previousWindowStartMs,
-                                windowEndMs: windowStartMs,
-                            },
-                        },
-                        { raw: codexAllRaw },
-                    ]);
-                }
-                catch {
-                    // skip
-                }
-            }
-        })(),
-    ]);
-    return {
-        claude_code: withAllTime(finalize(claudeRecentRaw), finalize(claudeAllRaw), finalize(claudePreviousRaw)),
-        codex: withAllTime(finalize(codexRecentRaw), finalize(codexAllRaw), finalize(codexPreviousRaw)),
-        cursor,
-    };
-}