@agent-finops/core 0.5.4 → 0.5.6

package/dist/localAgentLogs.js

@@ -1,11 +1,19 @@
 import { readdir, readFile, stat } from "node:fs/promises";
-import { basename, join, resolve } from "node:path";
+import { basename, isAbsolute, join, resolve, sep } from "node:path";
 import { homedir } from "node:os";
 import { estimateTokenCostUsd } from "./modelPricing.js";
+import { redactSecrets } from "./discovery.js";
 /** Parse one Claude Code transcript (JSONL). Exported for tests. */
 export function parseClaudeCodeTranscript(content, filePath = "") {
     const calls = [];
     const seen = new Set();
+    const prompts = [];
+    const fileCounts = new Map();
+    let title;
+    let lastPrompt;
+    let toolCallCount = 0;
+    let isSubagent = filePath.split(sep).includes("subagents");
+    let parentSessionId;
     for (const line of content.split("\n")) {
         if (!line.trim())
             continue;
@@ -16,9 +24,34 @@ export function parseClaudeCodeTranscript(content, filePath = "") {
         catch {
             continue;
         }
-        if (!isRecord(entry) || entry.type !== "assistant")
+        if (!isRecord(entry))
             continue;
+        if (entry.type === "ai-title") {
+            title = stringOf(entry.aiTitle) ?? title;
+        }
+        if (entry.type === "last-prompt") {
+            lastPrompt = stringOf(entry.lastPrompt) ?? lastPrompt;
+        }
+        if (entry.isSidechain === true)
+            isSubagent = true;
+        parentSessionId = stringOf(entry.parentSessionId) ?? parentSessionId;
         const message = isRecord(entry.message) ? entry.message : undefined;
+        if (entry.type === "user" && message) {
+            for (const prompt of textValues(message.content)) {
+                if (isHumanPrompt(prompt))
+                    prompts.push(prompt);
+            }
+        }
+        if (entry.type === "assistant" && message) {
+            for (const item of recordValues(message.content)) {
+                if (item.type !== "tool_use")
+                    continue;
+                toolCallCount += 1;
+                collectToolFiles(item.input, fileCounts);
+            }
+        }
+        if (entry.type !== "assistant")
+            continue;
         const usage = message && isRecord(message.usage) ? message.usage : undefined;
         if (!message || !usage)
             continue;
@@ -50,15 +83,37 @@ export function parseClaudeCodeTranscript(content, filePath = "") {
             }
         });
     }
+    const fallbackPrompt = lastPrompt && isHumanPrompt(lastPrompt) ? lastPrompt : undefined;
+    const activity = buildLocalAgentActivity({
+        title,
+        prompts: prompts.length > 0 ? prompts : fallbackPrompt ? [fallbackPrompt] : [],
+        files: fileCounts,
+        toolCallCount,
+        project: calls[0]?.project ?? projectFromTranscriptPath(filePath),
+        isSubagent,
+        parentSessionId
+    });
+    if (activity) {
+        for (const call of calls)
+            call.activity = activity;
+    }
     return calls;
 }
 /** Parse one Codex rollout file (JSONL event stream). Exported for tests. */
 export function parseCodexRollout(content) {
     let model;
     let cwd;
+    const toolWorkdirs = new Map();
     let sessionId;
-    let timestamp;
+    let startedAt;
+    let lastActivityAt;
     let lastTotal;
+    let lastRateLimits;
+    const prompts = [];
+    const fileCounts = new Map();
+    let toolCallCount = 0;
+    let isSubagent = false;
+    let parentSessionId;
     for (const line of content.split("\n")) {
         if (!line.trim())
             continue;
@@ -75,18 +130,42 @@ export function parseCodexRollout(content) {
         if (entry.type === "session_meta" && payload) {
             sessionId = stringOf(payload.id) ?? sessionId;
             cwd = stringOf(payload.cwd) ?? cwd;
-            timestamp = toIso(stringOf(payload.timestamp) ?? stringOf(entry.timestamp)) ?? timestamp;
+            startedAt = toIso(stringOf(payload.timestamp) ?? stringOf(entry.timestamp)) ?? startedAt;
+            isSubagent = stringOf(payload.thread_source) === "subagent" || isRecord(payload.source) && "subagent" in payload.source;
+            parentSessionId = stringOf(payload.parent_thread_id) ?? parentSessionId;
         }
         if (entry.type === "turn_context" && payload) {
             model = stringOf(payload.model) ?? model;
             cwd = stringOf(payload.cwd) ?? cwd;
         }
+        if (payload?.type === "function_call" || payload?.type === "custom_tool_call") {
+            toolCallCount += 1;
+            const args = jsonRecord(stringOf(payload.arguments));
+            const workdir = stringOf(args?.workdir) ?? stringOf(args?.cwd);
+            if (workdir && isAbsolute(workdir)) {
+                const normalized = resolve(workdir);
+                toolWorkdirs.set(normalized, (toolWorkdirs.get(normalized) ?? 0) + 1);
+            }
+            collectToolFiles(args, fileCounts);
+            collectPatchFiles(stringOf(args?.patch) ?? stringOf(args?.input) ?? stringOf(payload.input), fileCounts);
+        }
+        if (payload?.type === "message" && payload.role === "user") {
+            for (const prompt of textValues(payload.content)) {
+                if (isHumanPrompt(prompt))
+                    prompts.push(prompt);
+            }
+        }
         if (entry.type === "event_msg" && payload?.type === "token_count") {
+            const eventTimestamp = toIso(stringOf(entry.timestamp)) ?? lastActivityAt ?? startedAt;
             const info = isRecord(payload.info) ? payload.info : undefined;
             const total = info && isRecord(info.total_token_usage) ? info.total_token_usage : undefined;
             if (total) {
                 lastTotal = total;
-                timestamp = timestamp ?? toIso(stringOf(entry.timestamp));
+                lastActivityAt = eventTimestamp;
+            }
+            const rateLimits = parseCodexRateLimits(payload.rate_limits, eventTimestamp);
+            if (rateLimits) {
+                lastRateLimits = rateLimits;
             }
         }
     }
@@ -94,12 +173,24 @@ export function parseCodexRollout(content) {
         return [];
     const input = numberOf(lastTotal.input_tokens) ?? 0;
     const cached = numberOf(lastTotal.cached_input_tokens) ?? 0;
+    const project = projectFromCwd(dominantCodexCwd(cwd, toolWorkdirs));
+    const activity = buildLocalAgentActivity({
+        prompts,
+        files: fileCounts,
+        toolCallCount,
+        project,
+        isSubagent,
+        parentSessionId
+    });
     return [{
             agent: "codex",
             model: model ?? "codex",
-            timestamp: timestamp ?? new Date(0).toISOString(),
-            project: projectFromCwd(cwd),
+            timestamp: lastActivityAt ?? startedAt ?? new Date(0).toISOString(),
+            startedAt,
+            project,
             sessionId,
+            rateLimits: lastRateLimits,
+            activity,
             usage: {
                 // Codex input_tokens INCLUDES cached tokens; split them out.
                 inputTokens: Math.max(0, input - cached),
@@ -108,6 +199,52 @@ export function parseCodexRollout(content) {
             }
         }];
 }
+function parseCodexRateLimits(value, observedAt) {
+    if (!isRecord(value) || !observedAt)
+        return undefined;
+    const windows = [value.primary, value.secondary]
+        .map((window) => parseCodexRateLimitWindow(window))
+        .filter((window) => Boolean(window));
+    if (windows.length === 0)
+        return undefined;
+    return {
+        observedAt,
+        limitId: stringOf(value.limit_id),
+        planType: stringOf(value.plan_type),
+        windows
+    };
+}
+function parseCodexRateLimitWindow(value) {
+    if (!isRecord(value))
+        return undefined;
+    const usedPercent = numberOf(value.used_percent);
+    const windowMinutes = numberOf(value.window_minutes);
+    const resetsAtSeconds = numberOf(value.resets_at);
+    if (usedPercent === undefined ||
+        windowMinutes === undefined ||
+        windowMinutes <= 0 ||
+        resetsAtSeconds === undefined) {
+        return undefined;
+    }
+    const resetMs = resetsAtSeconds < 1_000_000_000_000
+        ? resetsAtSeconds * 1_000
+        : resetsAtSeconds;
+    const resetsAt = toIso(new Date(resetMs).toISOString());
+    if (!resetsAt)
+        return undefined;
+    const kind = windowMinutes === 300
+        ? "five-hour"
+        : windowMinutes === 10_080
+            ? "weekly"
+            : "custom";
+    return {
+        kind,
+        name: kind === "custom" ? `${windowMinutes}-minute` : kind,
+        usedPercent: Math.min(100, Math.max(0, usedPercent)),
+        windowMinutes,
+        resetsAt
+    };
+}
 /** Scan this machine's agent logs and return aggregated UsageRecords. */
 export async function loadLocalAgentUsage(options = {}) {
     const home = homedir();
@@ -215,6 +352,31 @@ function projectFromCwd(cwd) {
     const name = basename(cwd);
     return name.length > 0 ? name : undefined;
 }
+/**
+ * Codex can be launched from HOME and do nearly all of its work through tools
+ * that declare a more specific working directory. Prefer that observed
+ * activity only when the session-level cwd is not already a real project.
+ * Nested tool directories roll up to the shallowest observed ancestor with
+ * the strongest descendant-weighted activity.
+ */
+function dominantCodexCwd(sessionCwd, toolWorkdirs) {
+    const sessionProject = projectFromCwd(sessionCwd);
+    if (sessionProject && sessionProject !== "(home)")
+        return sessionCwd;
+    const home = resolve(homedir());
+    const candidates = [...toolWorkdirs.entries()]
+        .filter(([path]) => resolve(path) !== home);
+    const scored = candidates.map(([candidate]) => ({
+        candidate,
+        score: candidates.reduce((total, [path, count]) => (path === candidate || path.startsWith(`${candidate}${sep}`)
+            ? total + count
+            : total), 0)
+    }));
+    scored.sort((left, right) => (right.score - left.score ||
+        left.candidate.split(sep).length - right.candidate.split(sep).length ||
+        left.candidate.localeCompare(right.candidate)));
+    return scored[0]?.candidate ?? sessionCwd;
+}
 /** Claude Code encodes the project path into the transcript's parent dir name. */
 function projectFromTranscriptPath(filePath) {
     if (!filePath)
@@ -223,6 +385,286 @@ function projectFromTranscriptPath(filePath) {
     const tail = parent.split("-").filter(Boolean).pop();
     return tail && tail.length > 0 ? tail : undefined;
 }
+const FOCUS_STOP_WORDS = new Set([
+    "about", "after", "again", "also", "and", "are", "at", "been", "being", "but",
+    "can", "check", "could", "did", "does", "doing", "dont", "every", "from",
+    "for", "have", "here", "how", "in", "into", "its", "just", "like", "make", "more",
+    "need", "not", "now", "on", "only", "other", "our", "please", "really", "should",
+    "something", "sure", "than", "that", "the", "their", "them", "then", "there",
+    "these", "they", "thing", "think", "this", "through", "to", "too", "use", "user",
+    "users", "want", "was", "way", "we", "what", "when", "where", "which", "while",
+    "who", "why", "will", "with", "work", "working", "would", "you", "your",
+    "redacted"
+]);
+const ACTION_WORDS = [
+    { action: "refining", words: new Set(["adjust", "change", "customize", "design", "edit", "improve", "refine", "revise", "update"]) },
+    { action: "fixing", words: new Set(["bug", "debug", "fix", "repair", "resolve"]) },
+    { action: "testing", words: new Set(["test", "testing", "validate", "verification", "verify"]) },
+    { action: "auditing", words: new Set(["audit", "review", "status"]) },
+    { action: "researching", words: new Set(["compare", "find", "investigate", "research"]) },
+    { action: "configuring", words: new Set(["configure", "connect", "setup"]) },
+    { action: "publishing", words: new Set(["deploy", "launch", "publish", "release"]) },
+    { action: "running", words: new Set(["automation", "monitor", "run", "schedule"]) },
+    { action: "building", words: new Set(["add", "build", "create", "develop", "implement", "include"]) }
+];
+function buildLocalAgentActivity(input) {
+    // Prompt text is never retained, but derived topic tokens can still disclose
+    // a credential if redaction happens only at persistence/output boundaries.
+    // Sanitize before every title/topic/action derivation and again at output.
+    const prompts = input.prompts
+        .map(sanitizeLocalActivityText)
+        .filter(isHumanPrompt);
+    const topic = focusTopic(prompts);
+    const title = cleanTitle(sanitizeLocalActivityText(input.title ?? ""));
+    const files = [...input.files.entries()]
+        .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+        .map(([file]) => sanitizeLocalActivityText(file))
+        .filter(Boolean)
+        .slice(0, 5);
+    const action = inferAction(prompts, title);
+    let source;
+    let kind;
+    let subject;
+    if (topic) {
+        source = "user_prompts";
+        kind = inferActivityKind(topic, input.isSubagent);
+        subject = topic;
+    }
+    else if (title) {
+        source = "agent_title";
+        kind = inferActivityKind(title, input.isSubagent);
+        subject = stripLeadingAction(title);
+    }
+    else if (files[0]) {
+        source = "file_activity";
+        kind = "file";
+        subject = files[0];
+    }
+    else if (input.project) {
+        source = "project";
+        kind = "project";
+        subject = sanitizeLocalActivityText(input.project);
+    }
+    else {
+        return undefined;
+    }
+    if (!subject)
+        return undefined;
+    return {
+        summary: sanitizeLocalActivityText(activitySummary(action, subject, source)),
+        kind,
+        action,
+        source,
+        promptCount: prompts.length,
+        toolCallCount: input.toolCallCount,
+        files,
+        isSubagent: input.isSubagent,
+        parentSessionId: input.parentSessionId
+    };
+}
+function focusTopic(prompts) {
+    if (prompts.length === 0)
+        return undefined;
+    const recent = prompts.slice(-12);
+    const observedTopicTokens = new Set(recent.flatMap((prompt) => (topicTokens(prompt).filter((token) => !FOCUS_STOP_WORDS.has(token)))));
+    const tokenScores = new Map();
+    const pairScores = new Map();
+    recent.forEach((prompt, index) => {
+        const weight = 1 + index / Math.max(1, recent.length - 1);
+        const tokens = topicTokens(prompt).filter((token) => !FOCUS_STOP_WORDS.has(token));
+        const unique = [...new Set(tokens)];
+        for (const token of unique) {
+            tokenScores.set(token, (tokenScores.get(token) ?? 0) + weight);
+        }
+        for (let pairIndex = 0; pairIndex < tokens.length - 1; pairIndex += 1) {
+            const pair = `${tokens[pairIndex]} ${tokens[pairIndex + 1]}`;
+            pairScores.set(pair, (pairScores.get(pair) ?? 0) + weight);
+        }
+    });
+    const topPairs = [...pairScores.entries()]
+        .filter(([, score]) => score >= 2.5)
+        .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]));
+    const topTokens = [...tokenScores.entries()]
+        .filter(([token]) => !isActionToken(token))
+        .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]));
+    const candidateTokens = new Set();
+    for (const [pair] of topPairs.slice(0, 2)) {
+        pair.split(" ").forEach((token) => candidateTokens.add(token));
+    }
+    for (const [token] of topTokens) {
+        if (candidateTokens.size >= 3)
+            break;
+        candidateTokens.add(token);
+    }
+    if (candidateTokens.size === 0)
+        return undefined;
+    const tokens = [...candidateTokens].slice(0, 3);
+    if (tokens.includes("glance") && tokens.includes("hover")) {
+        return tokens.includes("ui") ? "Glance hover UI" : "Glance hover";
+    }
+    if (observedTopicTokens.has("glance") &&
+        ["action", "agent", "handoff", "prompt"].some((token) => observedTopicTokens.has(token))) {
+        return "Glance agent handoff";
+    }
+    if (tokens.includes("hover")) {
+        return tokens.includes("ui") ? "hover UI" : "hover interaction";
+    }
+    if (tokens.includes("landing") && tokens.includes("page"))
+        return "landing page";
+    if (tokens.includes("mcp"))
+        return tokens.includes("feature") ? "MCP feature" : "MCP";
+    if (tokens.includes("seo"))
+        return tokens.includes("strategy") ? "SEO strategy" : "SEO";
+    return tokens.map(displayToken).join(" ");
+}
+function inferAction(prompts, title) {
+    const scores = new Map();
+    const recent = prompts.slice(-12);
+    recent.forEach((prompt, index) => {
+        const weight = 1 + index / Math.max(1, recent.length - 1);
+        for (const token of promptTokens(prompt)) {
+            for (const group of ACTION_WORDS) {
+                if (group.words.has(token)) {
+                    scores.set(group.action, (scores.get(group.action) ?? 0) + weight);
+                }
+            }
+        }
+    });
+    if (title) {
+        for (const token of promptTokens(title)) {
+            for (const group of ACTION_WORDS) {
+                if (group.words.has(token)) {
+                    scores.set(group.action, (scores.get(group.action) ?? 0) + 0.75);
+                }
+            }
+        }
+    }
+    return [...scores.entries()]
+        .sort((left, right) => right[1] - left[1])[0]?.[0] ?? "working";
+}
+function inferActivityKind(subject, isSubagent) {
+    const tokens = new Set(promptTokens(subject));
+    if (tokens.has("automation") || tokens.has("workflow") || tokens.has("schedule"))
+        return "automation";
+    if (tokens.has("agent") || tokens.has("subagent") || isSubagent)
+        return "agent";
+    return "task";
+}
+function activitySummary(action, subject, source) {
+    if (source === "project")
+        return `Working in ${subject}`;
+    const actionLabel = action[0].toUpperCase() + action.slice(1);
+    return `${actionLabel} ${subject}`.replace(/\s+/g, " ").trim();
+}
+function cleanTitle(value) {
+    if (!value)
+        return undefined;
+    const clean = value.replace(/\s+/g, " ").trim().replace(/[.!?]+$/, "");
+    return clean.length >= 3 && clean.length <= 96 ? clean : undefined;
+}
+function stripLeadingAction(value) {
+    const words = value.split(/\s+/);
+    return isActionToken(words[0]?.toLowerCase() ?? "") && words.length > 1
+        ? words.slice(1).join(" ")
+        : value;
+}
+function isActionToken(token) {
+    return ACTION_WORDS.some((group) => group.words.has(token)) ||
+        ["building", "refining", "fixing", "testing", "auditing", "researching", "configuring", "publishing", "running"].includes(token);
+}
+function displayToken(token) {
+    const acronym = new Map([
+        ["api", "API"],
+        ["cli", "CLI"],
+        ["mcp", "MCP"],
+        ["seo", "SEO"],
+        ["ui", "UI"],
+        ["ux", "UX"]
+    ]).get(token);
+    return acronym ?? token;
+}
+function promptTokens(value) {
+    return (value.toLowerCase().match(/[a-z][a-z0-9+#.-]*/g) ?? [])
+        .map((token) => token.replace(/^[.-]+|[.-]+$/g, ""))
+        .filter((token) => token.length >= 2 && token !== "cz" && !/^\d+$/.test(token));
+}
+function topicTokens(value) {
+    // Absolute paths often appear in attached-image metadata and tool-oriented
+    // prompts. They are machine context, not the user's work topic, and can
+    // otherwise outrank meaningful words when only one recent prompt exists.
+    const withoutAbsolutePaths = value.replace(/(^|[\s("'=:])(?:file:\/\/)?\/[^\s)"']+/g, "$1");
+    return promptTokens(sanitizeLocalActivityText(withoutAbsolutePaths));
+}
+/**
+ * Remove known and assignment-shaped credentials from metadata before it can
+ * become a topic, title, Glance field, MCP result, or copy-ready handoff.
+ * This intentionally favors dropping a suspicious token over displaying it.
+ */
+export function sanitizeLocalActivityText(value) {
+    return redactSecrets(value)
+        .replace(/\b(?:api[_ -]?key|access[_ -]?token|auth[_ -]?token|secret|password|credential)\s*[:=]\s*[^\s,;]+/gi, " ")
+        .replace(/\bbearer\s+[A-Za-z0-9._~+/=-]{12,}/gi, " ")
+        .replace(/\b[A-Z][A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIALS?|AUTH)=\[REDACTED\]/g, " ")
+        .replace(/\[REDACTED\]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function isHumanPrompt(value) {
+    const text = value.trim();
+    if (text.length < 3)
+        return false;
+    return ![
+        /^</,
+        /^>>>/,
+        /^\s*\[\d+\]\s+(tool|assistant|user)\b/i,
+        /^#\s*AGENTS\.md/i,
+        /^Assess the exact/i,
+        /^Planned action JSON/i,
+        /^Reviewed Codex/i,
+        /^Some conversation/i,
+        /^The Codex agent/i,
+        /^The following is the Codex/i,
+        /^You are .*primary agent/i,
+        /^You have \d+ weighted tokens left/i
+    ].some((pattern) => pattern.test(text));
+}
+function textValues(value) {
+    if (typeof value === "string")
+        return [value];
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        if (!isRecord(item))
+            return [];
+        return [stringOf(item.text) ?? stringOf(item.content)].filter((text) => Boolean(text));
+    });
+}
+function recordValues(value) {
+    return Array.isArray(value) ? value.filter(isRecord) : [];
+}
+function collectToolFiles(value, counts) {
+    if (!isRecord(value))
+        return;
+    for (const key of ["file_path", "path", "notebook_path"]) {
+        addFile(stringOf(value[key]), counts);
+    }
+    collectPatchFiles(stringOf(value.patch) ?? stringOf(value.input), counts);
+}
+function collectPatchFiles(value, counts) {
+    if (!value)
+        return;
+    for (const match of value.matchAll(/^\*\*\* (?:Add|Update|Delete) File: (.+)$/gm)) {
+        addFile(match[1], counts);
+    }
+}
+function addFile(value, counts) {
+    if (!value)
+        return;
+    const file = basename(value.trim());
+    if (!file || file === "." || file === sep)
+        return;
+    counts.set(file, (counts.get(file) ?? 0) + 1);
+}
 function toIso(value) {
     if (!value)
         return undefined;
@@ -241,6 +683,17 @@ function stringOf(value) {
 function isRecord(value) {
     return typeof value === "object" && value !== null;
 }
+function jsonRecord(value) {
+    if (!value)
+        return undefined;
+    try {
+        const parsed = JSON.parse(value);
+        return isRecord(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function slug(value) {
     return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "x";
 }

package/dist/modelPricing.d.ts

@@ -1,5 +1,5 @@
 /**
- * Published per-token API prices (mid-2026) used to estimate the
+ * Published per-token API prices used to estimate the
  * API-equivalent dollar value of locally observed usage (e.g. Claude Code /
  * Codex session logs, where the provider never reports a price).
  *
@@ -7,6 +7,7 @@
  * matched top-down; first match wins. Unknown models return undefined so
  * callers can label the record "missing" instead of inventing a number.
  */
+export declare const PRICING_TABLE_AS_OF = "2026-07-28";
 export type TokenUsage = {
     /** Billable, uncached input tokens. */
     inputTokens: number;

package/dist/modelPricing.js

@@ -1,3 +1,13 @@
+/**
+ * Published per-token API prices used to estimate the
+ * API-equivalent dollar value of locally observed usage (e.g. Claude Code /
+ * Codex session logs, where the provider never reports a price).
+ *
+ * Estimates only — always surfaced with costConfidence "estimated". Rules are
+ * matched top-down; first match wins. Unknown models return undefined so
+ * callers can label the record "missing" instead of inventing a number.
+ */
+export const PRICING_TABLE_AS_OF = "2026-07-28";
 const pricingRules = [
     // Anthropic
     { match: /^claude-fable-5/i, inputPerM: 10, outputPerM: 50 },
@@ -7,9 +17,18 @@ const pricingRules = [
     { match: /^claude-haiku-4/i, inputPerM: 1, outputPerM: 5 },
     { match: /^claude-3-7-sonnet|^claude-3-5-sonnet/i, inputPerM: 3, outputPerM: 15 },
     { match: /^claude-3-5-haiku/i, inputPerM: 0.8, outputPerM: 4 },
-    // OpenAI (codex CLI models first — more specific)
-    { match: /^gpt-5(\.\d+)?-codex/i, inputPerM: 1.25, outputPerM: 10, cacheReadPerM: 0.125 },
-    { match: /^gpt-5(\.\d+)?-mini/i, inputPerM: 0.25, outputPerM: 2, cacheReadPerM: 0.025 },
+    // OpenAI (newer and more specific families must precede the GPT-5 fallback)
+    { match: /^gpt-5\.6(?:-sol)?$/i, inputPerM: 5, outputPerM: 30, cacheReadPerM: 0.5 },
+    { match: /^gpt-5\.6-terra/i, inputPerM: 2.5, outputPerM: 15, cacheReadPerM: 0.25 },
+    { match: /^gpt-5\.6-luna/i, inputPerM: 1, outputPerM: 6, cacheReadPerM: 0.1 },
+    { match: /^gpt-5\.5(?:-codex)?/i, inputPerM: 5, outputPerM: 30, cacheReadPerM: 0.5 },
+    { match: /^gpt-5\.4-mini/i, inputPerM: 0.75, outputPerM: 4.5, cacheReadPerM: 0.075 },
+    { match: /^gpt-5\.4-nano/i, inputPerM: 0.2, outputPerM: 1.25, cacheReadPerM: 0.02 },
+    { match: /^gpt-5\.4/i, inputPerM: 2.5, outputPerM: 15, cacheReadPerM: 0.25 },
+    { match: /^gpt-5\.3-codex/i, inputPerM: 1.75, outputPerM: 14, cacheReadPerM: 0.175 },
+    { match: /^gpt-5\.2(?:-codex)?/i, inputPerM: 1.75, outputPerM: 14, cacheReadPerM: 0.175 },
+    { match: /^gpt-5(?:\.1)?-codex/i, inputPerM: 1.25, outputPerM: 10, cacheReadPerM: 0.125 },
+    { match: /^gpt-5(?:\.1)?-mini/i, inputPerM: 0.25, outputPerM: 2, cacheReadPerM: 0.025 },
     { match: /^gpt-5/i, inputPerM: 1.25, outputPerM: 10, cacheReadPerM: 0.125 },
     { match: /^gpt-4\.1-nano/i, inputPerM: 0.1, outputPerM: 0.4 },
     { match: /^gpt-4\.1-mini/i, inputPerM: 0.4, outputPerM: 1.6 },

package/dist/planMath.d.ts

@@ -2,9 +2,9 @@ import type { DetectedPlan } from "./planDetection.js";
 import type { UsageRecord } from "./schema.js";
 /**
  * Plan-price math: compares API-equivalent usage (from local agent logs)
- * against published subscription plan prices — the arbitrage check no
- * provider will ever show, because it's the math that tells you to pay
- * them less.
+ * against published subscription plan prices. This is comparison context,
+ * not proof of entitlement, marginal cash cost, remaining capacity, or the
+ * cheapest option for a particular account.
  *
  * Prices are mid-2026 list prices. As of 2026-06-15, programmatic/Agent-SDK
  * usage on Claude plans is metered against a separate monthly credit pool at
@@ -17,7 +17,7 @@ export type SubscriptionPlan = {
     agent: "claude-code" | "codex";
     name: string;
     monthlyUsd: number;
-    /** Rough API-equivalent monthly usage this plan comfortably covers. */
+    /** Rough API-equivalent comparison threshold; not an entitlement limit. */
     coversUpToUsd: number;
 };
 export declare const subscriptionPlans: SubscriptionPlan[];
@@ -27,19 +27,18 @@ export type PlanCheck = {
     apiEquivalentMonthlyUsd: number;
     /** Distinct days of observed usage the projection is based on. */
     windowDays: number;
-    /** Cheapest plan that comfortably covers the projected usage (if any). */
+    /** Reference plan selected by a rough API-equivalent comparison (if any). */
     suggestedPlan?: SubscriptionPlan;
     /** apiEquivalentMonthlyUsd - plan price, when positive. */
     monthlySavingsVsApiUsd?: number;
     /**
-     * API-equivalent usage ÷ plan price — "you're getting N× the plan price in
-     * usage". The number a subscription user actually wants: am I getting my
-     * money's worth? Present only when a plan covers the usage.
+     * API-equivalent usage ÷ plan price. This is a value comparison, not an
+     * account entitlement or ROI measurement.
      */
     valueMultiple?: number;
-    /** The plan actually detected on this machine (or --plan override), if any. */
+    /** Plan label detected in local metadata (or supplied via --plan), if any. */
     detectedPlan?: DetectedPlan;
-    /** Set when projected usage exceeds what the detected tier typically covers. */
+    /** Set when projection exceeds a rough comparison threshold or a limit signal exists. */
     upgradeHint?: string;
     /** One-line, render-ready verdict. */
     headline: string;
@@ -49,10 +48,9 @@ export type PlanCheck = {
  * from local agent logs participate (billing-API records already have real
  * prices and a real plan behind them).
  *
- * When `detectedPlans` carries a locally detected plan (or --plan override)
- * for an agent, the check speaks in facts ("you're on Claude Max 5x") instead
- * of guesses ("Max 20x likely covers this") — and warns when projected usage
- * exceeds what the detected tier typically covers.
+ * When `detectedPlans` carries a locally detected plan label (or --plan
+ * override), the result identifies that provenance and keeps comparison math
+ * separate from provider-reported limits.
  */
 export declare function computePlanChecks(records: UsageRecord[], detectedPlans?: DetectedPlan[]): PlanCheck[];
 //# sourceMappingURL=planMath.d.ts.map