cogpit-memory 0.1.10 → 0.2.1

package/dist/lib/agentEnvelope.d.ts

@@ -0,0 +1,24 @@
+export interface ParsedAgentEnvelope {
+    /** Sender named by the first envelope that names one, or null when none does. */
+    sender: string | null;
+    /** True when at least one envelope was unwrapped, even if it named no sender. */
+    matched: boolean;
+    /** Text with every envelope unwrapped. Unchanged when no envelope matched. */
+    body: string;
+}
+/**
+ * Removes envelope framing that wraps a body — an envelope no reader unwrapped,
+ * or the trailing tag the nested case above leaves behind. Only the wrapper
+ * goes: a tag quoted inside the body is content, and stays.
+ */
+export declare function stripEnvelopeFraming(body: string): string;
+export declare function parseAgentEnvelope(text: string): ParsedAgentEnvelope;
+/**
+ * Whether a message reads as asking the reader for something: announced in the
+ * opening, or left on the closing line as a `?` or a request.
+ *
+ * This is the one guessed signal in agent mail, so callers must gate it on the
+ * message also being unanswered — a false positive then disappears as soon as
+ * the reader replies, and can never go stale on screen.
+ */
+export declare function looksLikeQuestion(body: string): boolean;

package/dist/lib/codex-exec.d.ts

@@ -0,0 +1,27 @@
+export interface JsStringLiteral {
+    endIndex: number;
+    value: string;
+}
+export interface CodexExecInvocation {
+    name: string;
+    argumentSource: string;
+    startIndex: number;
+}
+export declare function readJsStringLiteral(source: string, startIndex: number): JsStringLiteral | null;
+/**
+ * Extract actual tool invocations from a Codex code-mode `exec` script.
+ *
+ * This is a lexer, not a JavaScript evaluator: it deliberately ignores strings
+ * and comments, balances nested literals, and only recognizes calls rooted at
+ * the injected `tools` object. That keeps transcript rendering deterministic
+ * and safe even when the persisted script is malformed or user-controlled.
+ */
+export declare function extractCodexExecInvocations(source: string): CodexExecInvocation[];
+/** Return the source expression for a top-level property of an object argument. */
+export declare function extractJsPropertySource(source: string, property: string): string | null;
+/** Find simple string-valued object properties at any nesting depth. */
+export declare function extractJsStringPropertyValues(source: string, property: string): string[];
+/** Find simple numeric object properties at any nesting depth. */
+export declare function extractJsNumberPropertyValues(source: string, property: string): number[];
+/** Count top-level entries in an array literal, or one for a non-empty value. */
+export declare function countJsCollectionEntries(source: string): number;

package/dist/lib/codex-tool-normalization.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Normalize a Codex function name to its canonical collaboration-tool name.
+ * Current collaboration tools carry a namespace separately, but older and
+ * transitional rollouts also encoded it in the function name itself.
+ */
+export declare function normalizeFunctionName(rawName: string): string;
 export declare function inferToolError(output: string | null): boolean;
 /** Normalize Codex update_plan input to TodoWrite format. */
 export declare function normalizePlanToTodos(input: Record<string, unknown>): Record<string, unknown>;

package/dist/lib/helpers.d.ts

@@ -5,6 +5,20 @@ export declare function matchSubagentToMember(leadSessionId: string, subagentFil
     agentType: string;
     prompt?: string;
 }>): Promise<string | null>;
+/**
+ * Encode a cwd using Claude Code's project-directory naming convention: every
+ * character outside `[A-Za-z0-9]` becomes `-`, so both `/Users/x/proj` and
+ * `C:\Users\x\proj` collapse into a flat directory name under
+ * `~/.claude/projects`. Mirrors `shared/providers/claude.ts`; this package is
+ * published standalone and cannot import outside its own `src` root.
+ */
+export declare function encodeClaudeDirName(cwd: string): string;
+/**
+ * Best-effort inverse of {@link encodeClaudeDirName}. The encoding is lossy —
+ * a literal `-` is indistinguishable from a separator — so callers that can
+ * read a session's recorded `cwd` should always prefer that.
+ */
+export declare function decodeClaudeDirName(dirName: string): string;
 export declare function projectDirToReadableName(dirName: string): {
     path: string;
     shortName: string;

package/dist/lib/interactiveState.d.ts

@@ -24,8 +24,13 @@ export interface UserQuestionState {
 }
 export type PendingInteraction = PlanApprovalState | UserQuestionState | null;
 /**
- * Check if the previous turn's last tool call is the same interactive tool
- * with a pending/error result -- indicates a stuck loop we should suppress.
+ * Check if the previous turn's last tool call is the same interactive tool that
+ * *errored* -- indicates a stuck re-call loop we should suppress.
+ *
+ * An unanswered (result === null) prompt in the previous turn is NOT a loop:
+ * it just means the user replied with a message instead of answering, and the
+ * agent is now asking again. Treating that as stuck suppressed the current
+ * prompt entirely, leaving the turn blocked with no way to answer it.
  */
 export declare function isStuckInteractiveLoop(turns: Turn[], toolName: string): boolean;
 /**

package/dist/lib/messageTypeGuards.d.ts

@@ -5,13 +5,22 @@
  * dependencies. Extracted here as a dependency-free leaf module (imports only
  * from ./types) so both files can share a single source of truth.
  */
-import type { RawMessage, UserMessage, AssistantMessage, ProgressMessage, SystemMessage, SummaryMessage, QueueOperationMessage } from "./types";
+import type { RawMessage, UserMessage, AssistantMessage, ProgressMessage, SystemMessage, SummaryMessage, QueueOperationMessage, AttachmentMessage } from "./types";
 export declare function isUserMessage(msg: RawMessage): msg is UserMessage;
 export declare function isAssistantMessage(msg: RawMessage): msg is AssistantMessage;
 export declare function isProgressMessage(msg: RawMessage): msg is ProgressMessage;
 export declare function isSystemMessage(msg: RawMessage): msg is SystemMessage;
 export declare function isSummaryMessage(msg: RawMessage): msg is SummaryMessage;
 export declare function isQueueOperationMessage(msg: RawMessage): msg is QueueOperationMessage;
+export declare function isAttachmentMessage(msg: RawMessage): msg is AttachmentMessage;
+/**
+ * The synthetic user message Claude Code writes after compacting, carrying the
+ * summary text. Flagged `isVisibleInTranscriptOnly` too — it is transcript
+ * furniture, never something the user typed.
+ */
+export declare function isCompactSummaryMessage(msg: RawMessage): msg is UserMessage & {
+    isCompactSummary: true;
+};
 export declare function isCompactBoundary(msg: RawMessage): msg is SystemMessage & {
     subtype: "compact_boundary";
 };

package/dist/lib/sessionStats.d.ts

@@ -1,5 +1,9 @@
 /**
  * Session statistics computation — token usage aggregation and tool call tallying.
+ *
+ * Token totals are the raw figures the transcript reports. Costs are not
+ * computed here: pricing needs the live LiteLLM rate table, which callers
+ * apply via shared/usageCost/pricing.ts.
  */
 import type { Turn, SessionStats } from "./types";
 export declare function createEmptySessionStats(turnCount: number): SessionStats;

package/dist/lib/sessionStatus.d.ts

@@ -6,7 +6,7 @@
  * This is a pure function — status is always derived from data,
  * never stored as app state.
  */
-export type SessionStatus = "idle" | "thinking" | "tool_use" | "processing" | "completed" | "compacting" | "deferred";
+export type SessionStatus = "idle" | "thinking" | "tool_use" | "processing" | "completed" | "compacting" | "deferred" | "awaiting_agents";
 export interface SessionStatusInfo {
     status: SessionStatus;
     /** Name of the tool currently being used (if status is tool_use) */
@@ -15,7 +15,15 @@ export interface SessionStatusInfo {
     pendingQueue?: number;
     /** Why the session terminated (from Claude Code's terminal_reason). Only set for non-normal endings. */
     terminalReason?: string;
+    /** Number of background agents/workflows still running (status awaiting_agents) */
+    pendingAgents?: number;
+    /** Short descriptions of the pending background agents, oldest first */
+    pendingAgentDescriptions?: string[];
 }
+type RawMsg = {
+    type: string;
+    [key: string]: unknown;
+};
 /**
  * Derive session status from raw JSONL message objects.
  *
@@ -26,11 +34,9 @@ export interface SessionStatusInfo {
  * format. If a third provider is added, add a detection branch here and in
  * `src/lib/providers/registry.ts`.
  */
-export declare function deriveSessionStatus(rawMessages: Array<{
-    type: string;
-    [key: string]: unknown;
-}>): SessionStatusInfo;
+export declare function deriveSessionStatus(rawMessages: RawMsg[]): SessionStatusInfo;
 /** Human-readable label for terminal_reason values from Claude Code. */
 export declare function getTerminalReasonLabel(reason: string): string;
 /** Human-readable label for a session status. Returns null for "idle". */
-export declare function getStatusLabel(status: SessionStatus | undefined, toolName?: string, terminalReason?: string): string | null;
+export declare function getStatusLabel(status: SessionStatus | undefined, toolName?: string, terminalReason?: string, pendingAgents?: number): string | null;
+export {};

package/dist/lib/token-costs.d.ts

@@ -1,48 +1,27 @@
 /**
- * Token cost calculation library — single source of truth.
+ * Token display estimation and cost formatting.
  *
- * Pricing is reverse-engineered from the Claude Code binary (v2.1.53) to match
- * exactly what CC reports.  CC calculates cost per API call in the message_delta
- * handler using final usage from the streaming response — but the JSONL only
- * records the message_start placeholder usage (output_tokens is severely
- * undercounted, thinking tokens are omitted entirely).  We compensate by
- * estimating output from actual content (≈4 chars/token).
+ * Pricing lives in shared/usageCost/pricing.ts, driven by LiteLLM's live rate
+ * table — nothing here carries hardcoded rates. What remains is display-only
+ * accounting of the thinking/visible output split.
+ *
+ * Claude Code 2.1.19x+ reports thinking tokens directly on the assistant
+ * record, so that half of the split is now exact. Older transcripts recorded
+ * only the message_start placeholder usage, so they still fall back to a
+ * content estimate at ≈4 chars/token — as does the visible-output half, which
+ * the CLI does not break out.
  */
-import type { Turn, SubAgentMessage } from "./types";
+import type { Turn } from "./types";
 /** Approximate characters per token for content-based estimation. */
 export declare const CHARS_PER_TOKEN = 4;
-export interface CostInput {
-    model: string | null;
-    inputTokens: number;
-    outputTokens: number;
-    cacheWriteTokens: number;
-    cacheReadTokens: number;
-    webSearchRequests?: number;
-    /** Fast-mode flag from usage.speed — "fast" bills a higher tier on Opus 4.6/4.7 */
-    speed?: string;
-}
 /**
- * Calculate the cost of a single API call / turn.
+ * Thinking tokens for a turn: the count the model reported when it is
+ * available, falling back to a character estimate for older transcripts.
  *
- * This is the single entry point for all cost calculations.  All other
- * functions in the codebase should use this instead of computing cost
- * themselves.
- */
-export declare function calculateCost(c: CostInput): number;
-/**
- * Backward-compatible wrapper.  Prefer `calculateCost()` for new code.
+ * A reported 0 is a fact — a turn that did no thinking — so presence is tested
+ * rather than truthiness.
  */
-export declare function calculateTurnCost(model: string | null, inputTokens: number, outputTokens: number, cacheCreationTokens: number, cacheReadTokens: number): number;
-/** Estimate thinking tokens from a turn's thinking blocks. */
 export declare function estimateThinkingTokens(turn: Turn): number;
 /** Estimate non-thinking output tokens (text + tool use JSON). */
 export declare function estimateVisibleOutputTokens(turn: Turn): number;
-/** Estimate total output tokens (thinking + visible). Uses max(estimated, reported). */
-export declare function estimateTotalOutputTokens(turn: Turn): number;
-/** Estimate output tokens for a sub-agent message. */
-export declare function estimateSubAgentOutput(sa: SubAgentMessage): number;
-/** Calculate cost for a turn using estimated output tokens. */
-export declare function calculateTurnCostEstimated(turn: Turn): number;
-/** Calculate cost for a sub-agent message using estimated output tokens. */
-export declare function calculateSubAgentCostEstimated(sa: SubAgentMessage): number;
 export declare function formatCost(usd: number): string;

package/dist/lib/turnBuilder.d.ts

@@ -2,4 +2,37 @@
  * Turn builder — state machine that converts raw JSONL messages into Turn objects.
  */
 import type { RawMessage, Turn } from "./types";
+/**
+ * Attach each peer message to the `SendMessage` that answered it.
+ *
+ * Walks blocks in chronological order holding the still-unanswered messages per
+ * sender, so a reply claims the oldest outstanding message from that sender and
+ * pairing only ever runs forward in time. A `SendMessage` sent *before* any
+ * inbound message from that sender is an instruction, not a reply.
+ *
+ * The join is on the sender name, which is the only key available: the block
+ * carries no task id, because `origin.senderTaskId` names the sending agent's
+ * task rather than the message. `SendMessage.input.to` uses the same names that
+ * arrive in `origin.from`, so the join holds.
+ *
+ * A pure recompute: every existing pairing is cleared before the walk, so the
+ * answer depends only on the list handed in. Callers that assemble a transcript
+ * from several `buildTurns` calls — the page stitcher and the incremental
+ * append — re-run it over the joined list and get what a single parse of that
+ * list would have produced. Turns holding no peer message come back by
+ * reference, so a re-run costs nothing for the rest of the transcript.
+ */
+export declare function pairAgentMessageReplies(turns: readonly Turn[]): Turn[];
+/**
+ * Raw-message index where each turn `buildTurns` would produce begins, so
+ * `starts[i]` is the index that produces `turns[i]`.
+ *
+ * Incremental appends need both a rebuild cut point and the number of turns
+ * that precede it. Deriving them separately is how an append drifts out of
+ * sync with a full re-parse, so both come from this one pass.
+ *
+ * Mirrors the turn-creation rule of `buildTurns` below — a parser test asserts
+ * the two agree, so keep them in lockstep.
+ */
+export declare function findTurnStartIndices(messages: RawMessage[]): number[];
 export declare function buildTurns(messages: RawMessage[]): Turn[];

package/dist/lib/types.d.ts

@@ -80,6 +80,21 @@ export interface UserMessage extends BaseMessage {
         content: UserContent;
     };
     isMeta?: boolean;
+    /**
+     * Set on the synthetic user message Claude Code writes after a compaction.
+     * Its content is the real compaction summary wrapped in resume boilerplate —
+     * `compact_boundary.content` is only ever the fixed string "Conversation
+     * compacted", so this message is the sole source of the summary text.
+     */
+    isCompactSummary?: boolean;
+    /**
+     * Why Claude Code wrote this record. `"task-notification"` marks a
+     * background task reporting back, not a prompt the reader typed. Absent on
+     * records written before Claude Code added the field (pre-2.1.220).
+     */
+    origin?: {
+        kind?: string;
+    } | null;
     permissionMode?: string;
     thinkingMetadata?: {
         maxThinkingTokens: number;
@@ -94,6 +109,25 @@ export interface TokenUsage {
     cache_read_input_tokens?: number;
     /** "fast" when the turn ran in fast mode (billed at a higher tier on Opus 4.6/4.7) */
     speed?: string;
+    /**
+     * Claude Code 2.1.19x+ reports the thinking slice of `output_tokens`
+     * exactly. Already counted inside output_tokens — never add it to a cost sum.
+     */
+    output_tokens_details?: {
+        thinking_tokens?: number;
+    };
+}
+/**
+ * What drove a response, when Claude Code could attribute it (CC 2.1.17x+).
+ * Written as flat `attribution*` fields on the assistant record.
+ */
+export interface MessageAttribution {
+    /** Subagent type, e.g. "Explore", "implementer", "workflow-subagent". */
+    agent?: string;
+    skill?: string;
+    plugin?: string;
+    mcpServer?: string;
+    mcpTool?: string;
 }
 export interface AssistantMessage extends BaseMessage {
     type: "assistant";
@@ -106,6 +140,17 @@ export interface AssistantMessage extends BaseMessage {
         usage: TokenUsage;
     };
     requestId?: string;
+    /**
+     * Reasoning effort this response ran at (CC 2.1.212+): low | medium | high |
+     * xhigh | max. Codex spells its own levels differently (e.g. "trivial"), so
+     * this stays a plain string rather than a union.
+     */
+    effort?: string;
+    attributionAgent?: string;
+    attributionSkill?: string;
+    attributionPlugin?: string;
+    attributionMcpServer?: string;
+    attributionMcpTool?: string;
 }
 /**
  * @deprecated Claude Code v2.1.63+ no longer emits inline agent_progress messages.
@@ -195,10 +240,12 @@ export interface SystemMessage extends BaseMessage {
     durationMs?: number;
     isMeta?: boolean;
     content?: string;
-    compactMetadata?: {
-        trigger: "auto" | "manual";
-        preTokens: number;
-    };
+    compactMetadata?: CompactionMeta;
+}
+export interface CompactionMeta {
+    trigger: "auto" | "manual";
+    preTokens: number;
+    postTokens?: number;
 }
 export interface FileHistorySnapshotMessage extends BaseMessage {
     type: "file-history-snapshot";
@@ -221,7 +268,57 @@ export interface QueueOperationMessage extends BaseMessage {
     operation: "enqueue" | "dequeue" | "remove" | string;
     content?: string | null;
 }
-export type RawMessage = UserMessage | AssistantMessage | ProgressMessage | SystemMessage | FileHistorySnapshotMessage | SummaryMessage | QueueOperationMessage;
+/**
+ * Claude Code persists the text of a prompt queued mid-turn here, not on the
+ * queue-operation record. `commandMode` separates prompts the user typed
+ * ("prompt") from Claude's own injected notices ("task-notification").
+ */
+export interface AttachmentMessage extends BaseMessage {
+    type: "attachment";
+    attachment?: {
+        type?: string;
+        prompt?: string | ContentBlock[] | null;
+        commandMode?: string;
+        timestamp?: string;
+        /**
+         * Who queued this prompt. `"human"` is the reader typing mid-turn;
+         * `"peer"` is another agent sending this session a message. `body` is the
+         * message with its envelope already stripped, so it beats re-parsing
+         * `prompt`. Absent on records written before Claude Code added the field.
+         */
+        origin?: {
+            kind?: string;
+            from?: string;
+            name?: string;
+            senderTaskId?: string;
+            body?: string;
+        } | null;
+    } | null;
+}
+/**
+ * Written when a session enters or leaves a `.claude/worktrees/*` checkout.
+ * The record is the session's current worktree state, so a later one supersedes
+ * an earlier one, and a null `worktreeSession` means the session left.
+ */
+export interface WorktreeStateMessage extends BaseMessage {
+    type: "worktree-state";
+    worktreeSession?: {
+        originalCwd?: string;
+        preEnterOriginalCwd?: string;
+        worktreePath?: string;
+        worktreeName?: string;
+        worktreeBranch?: string;
+        originalBranch?: string;
+        originalHeadCommit?: string;
+        sessionId?: string;
+    } | null;
+}
+/** The agent type a session was launched as, e.g. "general-purpose". */
+export interface AgentSettingMessage extends BaseMessage {
+    type: "agent-setting";
+    agentSetting?: string;
+}
+export type RawMessage = UserMessage | AssistantMessage | ProgressMessage | SystemMessage | FileHistorySnapshotMessage | SummaryMessage | QueueOperationMessage | AttachmentMessage;
 export interface ToolCall {
     id: string;
     name: string;
@@ -272,6 +369,26 @@ export type TurnContentBlock = {
     kind: "queued_prompt";
     content: string;
     timestamp?: string;
+}
+/**
+ * A message another agent sent this session mid-turn. Distinct from
+ * `queued_prompt`, which is the reader's own text. `reply` is filled by the
+ * pairing pass when a later SendMessage answered this sender.
+ *
+ * Deliberately carries no sender task id. `origin.senderTaskId` on the record
+ * identifies the sending agent's *task*, not the message — one agent's
+ * question and its later done-report share an id — so it is useless as a
+ * per-message key and destructive as a dedup key.
+ */
+ | {
+    kind: "agent_message";
+    sender: string;
+    body: string;
+    timestamp?: string;
+    reply?: {
+        summary: string;
+        timestamp: string;
+    };
 } | {
     kind: "sub_agent";
     messages: SubAgentMessage[];
@@ -302,6 +419,18 @@ export type TurnContentBlock = {
     kind: "recap";
     content: string;
     timestamp?: string;
+}
+/**
+ * A background task reporting back, which resumes the turn that launched it
+ * rather than opening one of its own. `content` is the raw record text —
+ * one or more `<task-notification>` blocks, possibly inside a
+ * `<system-reminder>` envelope (Claude Code 2.1.234+) — left unparsed here
+ * for the same reason `queued_prompt` is: the renderers own that grammar.
+ */
+ | {
+    kind: "task_notification";
+    content: string;
+    timestamp?: string;
 };
 export interface Turn {
     id: string;
@@ -316,15 +445,38 @@ export interface Turn {
     durationMs: number | null;
     tokenUsage: TokenUsage | null;
     model: string | null;
-    /** Set when a compaction happened before this turn */
+    /**
+     * Summary of the compaction that happened before this turn, as written by
+     * the compacting model. Absent when the transcript records the boundary but
+     * not the summary (e.g. the session ended right after compacting).
+     */
     compactionSummary?: string;
+    /** Trigger and token counts of the compaction that happened before this turn */
+    compactionMeta?: CompactionMeta;
+    /**
+     * Reasoning effort the turn ran at, when the transcript recorded one.
+     * A turn spanning several assistant messages reports the last one, since
+     * effort can be changed mid-session.
+     */
+    effort?: string;
+    /**
+     * What drove this turn — skill, plugin, MCP server, subagent type. Merged
+     * across the turn's assistant messages, since a turn can start under a skill
+     * and later reach for an MCP tool. Undefined when nothing was attributed.
+     */
+    attribution?: MessageAttribution;
+    /**
+     * Set when this turn was opened without its start record — the parse window
+     * began mid-turn. Such a turn is the newer half of a byte-boundary cut and
+     * must be stitched onto the previous turn once the older page arrives.
+     */
+    isFragment?: boolean;
 }
 export interface SessionStats {
     totalInputTokens: number;
     totalOutputTokens: number;
     totalCacheCreationTokens: number;
     totalCacheReadTokens: number;
-    totalCostUSD: number;
     toolCallCounts: Record<string, number>;
     errorCount: number;
     totalDurationMs: number;

package/package.json

@@ -1,7 +1,23 @@
 {
   "name": "cogpit-memory",
-  "version": "0.1.10",
+  "version": "0.2.1",
   "description": "CLI tool for Claude Code and Codex session introspection",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gentritbiba/cogpit.git",
+    "directory": "packages/cogpit-memory"
+  },
+  "homepage": "https://github.com/gentritbiba/cogpit/tree/master/packages/cogpit-memory",
+  "bugs": "https://github.com/gentritbiba/cogpit/issues",
+  "keywords": [
+    "claude-code",
+    "codex",
+    "session",
+    "memory",
+    "cli",
+    "agent"
+  ],
   "packageManager": "bun@1.3.14",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -13,7 +29,9 @@
   },
   "files": [
     "dist/",
-    "skill/"
+    "skill/",
+    "README.md",
+    "LICENSE"
   ],
   "scripts": {
     "test": "bun test",

package/skill/SKILL.md

@@ -151,7 +151,7 @@ Response shape:
 ```
 
 Key details:
-- `contentBlocks` kinds: `thinking`, `text`, `tool_calls`, `sub_agent`, `background_agent`, `queued_prompt`, `hook_event`, `plan_mode`, `recap`
+- `contentBlocks` kinds: `thinking`, `text`, `tool_calls`, `sub_agent`, `background_agent`, `queued_prompt`, `hook_event`, `plan_mode`, `recap`, `agent_message`
 - Tool call `result` is truncated at 10,000 chars -- check `resultTruncated: true`
 - Tool call `result` may be `null` if the tool hasn't returned yet
 - Sub-agent blocks show prompt + result text. For full sub-agent conversation, use Layer 3

package/dist/lib/pricingTiers.d.ts

@@ -1,30 +0,0 @@
-/**
- * Pricing tier constants and model-to-tier resolution.
- *
- * Sources: Claude Code v2.1.172 binary (decompiled JS bundle) for Anthropic
- * models, and the official OpenAI model pricing pages for GPT models.
- * Each model maps to a tier with five price points.
- *
- * Changes vs the old v2.1.53 table:
- *  - Extended-context (>200k input) pricing is gone — flat pricing per model.
- *  - New frontier tier for Fable 5 / Mythos 5 / Opus 4.8 ($10/$50).
- *  - Sonnet 4.5/4.6 dropped to the $3/$15 tier (was $5/$25).
- *  - Fast mode (usage.speed === "fast" on Opus 4.6/4.7) bills $30/$150;
- *    Opus 4.8 fast bills the same as standard.
- */
-export interface PricingTier {
-    input: number;
-    output: number;
-    cacheWrite: number;
-    cacheRead: number;
-    webSearch: number;
-}
-export declare function resolveTier(model: string, speed?: string): PricingTier;
-/**
- * Whether Cogpit has a published USD price for this model.
- *
- * Keep the historical Claude-family fallback for old rollouts whose model is
- * absent or abbreviated, but never price a future/unknown GPT model as if it
- * were Claude. That would create a precise-looking but invented dollar value.
- */
-export declare function hasKnownPricing(model: string | null | undefined): boolean;