coding-agent-cost 0.1.1__tar.gz → 0.2.0__tar.gz

{coding_agent_cost-0.1.1/coding_agent_cost.egg-info → coding_agent_cost-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coding-agent-cost
-Version: 0.1.1
+Version: 0.2.0
 Summary: Estimate AI coding agent (Claude Code / Codex CLI) token usage and cost from local logs
 Author: shiki-yusuke
 License: MIT
@@ -204,9 +204,33 @@ scraping `report`.
 agent-cost only reads data that is already on disk. It never talks to the
 network, never calls `gh`, and never resolves branches or PRs.
 
-- **Claude Code**: every `assistant` message's `usage` block is one billing
-  event, attributed to the exact model on that event (a session that
-  switches models mid-conversation is not folded into one "primary model").
+- **Claude Code**: every logical assistant message is one billing event,
+  attributed to the exact model on that event (a session that switches
+  models mid-conversation is not folded into one "primary model"). Claude
+  Code's transcript writes one JSONL line per content block of the same
+  message, and those lines are deduplicated first -- but only when a row
+  carries a full `message.id` + `requestId` pair; a row missing either
+  half is emitted on its own (never merged) and flagged
+  `source_quality: "identity_missing"` rather than assumed
+  billing-accurate. `identity_missing` facts are still priced and included
+  in rows/totals; the flag is a warning, not an exclusion or an unpriced
+  status. A message's lines don't necessarily repeat an identical `usage`
+  block: `model` and the input-side fields (input tokens, cache read,
+  cache-write TTL breakdown) stay the same across a message's lines, but
+  `output_tokens` typically grows line by line as the response streams in,
+  and intermediate lines usually lack `usage.speed` entirely (reported as
+  mode `"unknown"`), with only the final line carrying a concrete mode.
+  Within a deduplicated group, `model` or an input-side field that
+  actually differs across the group's rows, two rows disagreeing on a
+  *concrete* mode (`"normal"` vs `"fast"`), or an `output_tokens` value
+  that decreases or is non-monotonic across them, is counted in
+  `data_quality.conflicting_duplicate_groups` as a real billing
+  disagreement -- `output_tokens` growing row by row, and mode
+  `"unknown"` mixed with a single concrete mode elsewhere in the group,
+  are both the ordinary streaming pattern just described and are not
+  flagged, since the reader's own cross-check of real transcripts found
+  exactly that pattern in every observed duplicated group. See
+  `CHANGELOG.md`'s 0.2.0 entry.
   When Anthropic's prompt-cache TTL breakdown (5-minute vs 1-hour writes) is
   present in the log, it's used; otherwise the cache-write tokens are priced
   at the 5-minute rate as an explicit **lower bound** and flagged
@@ -318,6 +342,8 @@ agent-cost measure --session-id <id> [--session-id <id> ...] \
 ```json
 {
   "protocol_version": "measure/v1",
+  "producer_version": "0.2.0",
+  "accounting_basis": "agent-cost-raw-total/v2",
   "generated_at": "...",
   "window": { "since": "...", "until": null },
   "timezone": "UTC",
@@ -334,7 +360,10 @@ agent-cost measure --session-id <id> [--session-id <id> ...] \
     "skipped_files": 0,
     "negative_deltas": 0,
     "unpriced_tokens": 0,
-    "source_quality": { "ok": 41, "first_event_delta": 2 }
+    "duplicate_rows_skipped": 0,
+    "conflicting_duplicate_groups": 0,
+    "missing_dedup_identity_rows": 0,
+    "source_quality": { "ok": 41, "first_event_delta": 2, "identity_missing": 0 }
   }
 }
 ```
@@ -343,10 +372,21 @@ Rows are grouped by agent/model/token-kind only -- `measure` never buckets
 by month, since a query is already scoped to specific sessions. `total` is
 the union of every requested `session_id` (not a global report), so it's
 the number to attribute to whatever unit of work those sessions represent.
+`producer_version` is the agent-cost package version that produced this
+payload; `accounting_basis` identifies the token-accounting semantics
+behind the numbers (separate from `protocol_version`, which only tracks
+the JSON shape) -- a consumer that persists historical measurements should
+key comparability on `accounting_basis`, not `producer_version` alone,
+since a future release can bump the latter while keeping the former.
 `data_quality.unpriced_tokens` and `.source_quality` are scoped to the
-requested sessions; `.malformed_events`/`.skipped_files`/`.negative_deltas`
-describe the health of the underlying log read within `--since`/`--until`
-and are not attributable to one session.
+requested sessions; so are the three dedup counters
+(`duplicate_rows_skipped`, `conflicting_duplicate_groups`,
+`missing_dedup_identity_rows`), which are Claude-only and computed over
+the intersection of the requested session ids and the `--since`/`--until`
+window, never over an unrequested session's rows.
+`.malformed_events`/`.skipped_files`/`.negative_deltas` describe the
+health of the underlying log read within `--since`/`--until` and are not
+attributable to one session.
 
 ## Privacy
 

{coding_agent_cost-0.1.1 → coding_agent_cost-0.2.0}/README.md

@@ -178,9 +178,33 @@ scraping `report`.
 agent-cost only reads data that is already on disk. It never talks to the
 network, never calls `gh`, and never resolves branches or PRs.
 
-- **Claude Code**: every `assistant` message's `usage` block is one billing
-  event, attributed to the exact model on that event (a session that
-  switches models mid-conversation is not folded into one "primary model").
+- **Claude Code**: every logical assistant message is one billing event,
+  attributed to the exact model on that event (a session that switches
+  models mid-conversation is not folded into one "primary model"). Claude
+  Code's transcript writes one JSONL line per content block of the same
+  message, and those lines are deduplicated first -- but only when a row
+  carries a full `message.id` + `requestId` pair; a row missing either
+  half is emitted on its own (never merged) and flagged
+  `source_quality: "identity_missing"` rather than assumed
+  billing-accurate. `identity_missing` facts are still priced and included
+  in rows/totals; the flag is a warning, not an exclusion or an unpriced
+  status. A message's lines don't necessarily repeat an identical `usage`
+  block: `model` and the input-side fields (input tokens, cache read,
+  cache-write TTL breakdown) stay the same across a message's lines, but
+  `output_tokens` typically grows line by line as the response streams in,
+  and intermediate lines usually lack `usage.speed` entirely (reported as
+  mode `"unknown"`), with only the final line carrying a concrete mode.
+  Within a deduplicated group, `model` or an input-side field that
+  actually differs across the group's rows, two rows disagreeing on a
+  *concrete* mode (`"normal"` vs `"fast"`), or an `output_tokens` value
+  that decreases or is non-monotonic across them, is counted in
+  `data_quality.conflicting_duplicate_groups` as a real billing
+  disagreement -- `output_tokens` growing row by row, and mode
+  `"unknown"` mixed with a single concrete mode elsewhere in the group,
+  are both the ordinary streaming pattern just described and are not
+  flagged, since the reader's own cross-check of real transcripts found
+  exactly that pattern in every observed duplicated group. See
+  `CHANGELOG.md`'s 0.2.0 entry.
   When Anthropic's prompt-cache TTL breakdown (5-minute vs 1-hour writes) is
   present in the log, it's used; otherwise the cache-write tokens are priced
   at the 5-minute rate as an explicit **lower bound** and flagged
@@ -292,6 +316,8 @@ agent-cost measure --session-id <id> [--session-id <id> ...] \
 ```json
 {
   "protocol_version": "measure/v1",
+  "producer_version": "0.2.0",
+  "accounting_basis": "agent-cost-raw-total/v2",
   "generated_at": "...",
   "window": { "since": "...", "until": null },
   "timezone": "UTC",
@@ -308,7 +334,10 @@ agent-cost measure --session-id <id> [--session-id <id> ...] \
     "skipped_files": 0,
     "negative_deltas": 0,
     "unpriced_tokens": 0,
-    "source_quality": { "ok": 41, "first_event_delta": 2 }
+    "duplicate_rows_skipped": 0,
+    "conflicting_duplicate_groups": 0,
+    "missing_dedup_identity_rows": 0,
+    "source_quality": { "ok": 41, "first_event_delta": 2, "identity_missing": 0 }
   }
 }
 ```
@@ -317,10 +346,21 @@ Rows are grouped by agent/model/token-kind only -- `measure` never buckets
 by month, since a query is already scoped to specific sessions. `total` is
 the union of every requested `session_id` (not a global report), so it's
 the number to attribute to whatever unit of work those sessions represent.
+`producer_version` is the agent-cost package version that produced this
+payload; `accounting_basis` identifies the token-accounting semantics
+behind the numbers (separate from `protocol_version`, which only tracks
+the JSON shape) -- a consumer that persists historical measurements should
+key comparability on `accounting_basis`, not `producer_version` alone,
+since a future release can bump the latter while keeping the former.
 `data_quality.unpriced_tokens` and `.source_quality` are scoped to the
-requested sessions; `.malformed_events`/`.skipped_files`/`.negative_deltas`
-describe the health of the underlying log read within `--since`/`--until`
-and are not attributable to one session.
+requested sessions; so are the three dedup counters
+(`duplicate_rows_skipped`, `conflicting_duplicate_groups`,
+`missing_dedup_identity_rows`), which are Claude-only and computed over
+the intersection of the requested session ids and the `--since`/`--until`
+window, never over an unrequested session's rows.
+`.malformed_events`/`.skipped_files`/`.negative_deltas` describe the
+health of the underlying log read within `--since`/`--until` and are not
+attributable to one session.
 
 ## Privacy
 

{coding_agent_cost-0.1.1 → coding_agent_cost-0.2.0}/agent_cost/__init__.py

@@ -6,4 +6,4 @@ against a versioned rate catalog. Everything happens locally; there are no
 network calls.
 """
 
-__version__ = "0.1.1"
+__version__ = "0.2.0"

{coding_agent_cost-0.1.1 → coding_agent_cost-0.2.0}/agent_cost/aggregate.py

@@ -84,12 +84,59 @@ def filter_facts(
         yield f
 
 
+def scope_dedup_units(
+    units: Iterable,
+    *,
+    since_utc: Optional[datetime] = None,
+    until_utc: Optional[datetime] = None,
+    session_ids: Optional[set] = None,
+) -> Tuple[int, int, int]:
+    """Re-scope Claude's per-group dedup diagnostics to a window and/or a
+    set of session ids, after the fact.
+
+    ``units`` is duck-typed (each must have ``.occurred_at_utc``,
+    ``.session_id``, ``.duplicate_rows_skipped``, ``.conflicting`` and
+    ``.missing_identity``) rather than imported as
+    ``readers.claude.ClaudeDedupUnit``, to avoid this module depending on
+    a specific reader. Returns
+    ``(duplicate_rows_skipped, conflicting_duplicate_groups,
+    missing_dedup_identity_rows)`` -- the same three counters
+    ``ClaudeParseResult``/``ReadResult`` expose as unscoped file-level
+    totals, but summed only over units that fall inside ``[since_utc,
+    until_utc)`` and, if given, whose ``session_id`` is in
+    ``session_ids``. This mirrors ``filter_facts``'s half-open window
+    semantics so a caller's ``report``/``measure`` window matches exactly
+    what ``build_rows`` priced.
+    """
+    duplicate_rows_skipped = 0
+    conflicting_duplicate_groups = 0
+    missing_dedup_identity_rows = 0
+    for unit in units:
+        if since_utc is not None and unit.occurred_at_utc < since_utc:
+            continue
+        if until_utc is not None and unit.occurred_at_utc >= until_utc:
+            continue
+        if session_ids is not None and unit.session_id not in session_ids:
+            continue
+        duplicate_rows_skipped += unit.duplicate_rows_skipped
+        if unit.conflicting:
+            conflicting_duplicate_groups += 1
+        if unit.missing_identity:
+            missing_dedup_identity_rows += 1
+    return duplicate_rows_skipped, conflicting_duplicate_groups, missing_dedup_identity_rows
+
+
 @dataclass
 class DataQuality:
     malformed_events: int = 0
     skipped_files: int = 0
     negative_deltas: int = 0
     unpriced_tokens: int = 0
+    # Claude-only dedup diagnostics (see readers/claude.py's
+    # parse_session_detailed docstring); always 0 for Codex facts.
+    duplicate_rows_skipped: int = 0
+    conflicting_duplicate_groups: int = 0
+    missing_dedup_identity_rows: int = 0
 
     def to_dict(self) -> dict:
         return {
@@ -97,6 +144,9 @@ class DataQuality:
             "skipped_files": self.skipped_files,
             "negative_deltas": self.negative_deltas,
             "unpriced_tokens": self.unpriced_tokens,
+            "duplicate_rows_skipped": self.duplicate_rows_skipped,
+            "conflicting_duplicate_groups": self.conflicting_duplicate_groups,
+            "missing_dedup_identity_rows": self.missing_dedup_identity_rows,
         }
 
 

{coding_agent_cost-0.1.1 → coding_agent_cost-0.2.0}/agent_cost/cli.py

@@ -11,7 +11,7 @@ from typing import Optional
 from zoneinfo import ZoneInfo
 
 from . import __version__
-from .aggregate import DataQuality, build_rows, filter_facts, rows_totals
+from .aggregate import DataQuality, build_rows, filter_facts, rows_totals, scope_dedup_units
 from .config import load_config
 from .facts import SOURCE_QUALITY_VALUES
 from .rates import RatesValidationError, load_rates
@@ -25,6 +25,15 @@ from .renderers import render_csv, render_json, render_table
 #: should check this before trusting the shape of the payload.
 MEASURE_PROTOCOL_VERSION = "measure/v1"
 
+#: Identifies the token-accounting semantics behind measure's numbers, not
+#: the JSON shape (that's MEASURE_PROTOCOL_VERSION). "v2" marks the fix for
+#: the Claude reader's row-per-content-block over-count (agent-cost 0.2.0);
+#: "v1" numbers (agent-cost 0.1.x) are not comparable to "v2" numbers for
+#: Claude facts. A consumer that persists historical measurements (e.g.
+#: lane's ledger) should key on this, not on producer_version alone, since
+#: a future producer_version could still share the same accounting_basis.
+ACCOUNTING_BASIS = "agent-cost-raw-total/v2"
+
 
 def _parse_window_bound(value: Optional[str], tz: ZoneInfo) -> Optional[datetime]:
     if not value:
@@ -45,14 +54,29 @@ def _parse_window_bound(value: Optional[str], tz: ZoneInfo) -> Optional[datetime
 
 
 def _collect_facts(config, *, agents: set, exclude_archived: bool):
+    """Returns ``(facts, dq, claude_dedup_units)``.
+
+    ``dq``'s ``malformed_events``/``skipped_files``/``negative_deltas`` are
+    unscoped file-level totals (unchanged, existing behavior).
+    ``dq.duplicate_rows_skipped``/``conflicting_duplicate_groups``/
+    ``missing_dedup_identity_rows`` are deliberately left at their
+    ``DataQuality`` defaults here (0) rather than filled in from an
+    unscoped total: those three are Claude-only and must always be
+    re-scoped to the caller's actual window (``report``) or requested
+    session ids + window (``measure``) via ``claude_dedup_units`` and
+    ``aggregate.scope_dedup_units`` -- an unscoped total would silently
+    misrepresent a windowed/session-scoped report or measure output.
+    """
     facts: list = []
     dq = DataQuality()
+    claude_dedup_units: list = []
 
     if "claude" in agents:
         result = claude_reader.read_claude_facts(config.claude_projects_dir)
         facts.extend(result.facts)
         dq.malformed_events += result.malformed_events
         dq.skipped_files += result.skipped_files
+        claude_dedup_units.extend(result.claude_dedup_units)
 
     if "codex" in agents and config.codex_db_path.exists():
         result = codex_reader.read_codex_facts(
@@ -65,7 +89,7 @@ def _collect_facts(config, *, agents: set, exclude_archived: bool):
         dq.skipped_files += result.skipped_files
         dq.negative_deltas += result.negative_deltas
 
-    return facts, dq
+    return facts, dq, claude_dedup_units
 
 
 def cmd_report(args) -> int:
@@ -87,10 +111,20 @@ def cmd_report(args) -> int:
         print(f"[error] rates catalog invalid: {exc}", file=sys.stderr)
         return 2
 
-    facts, dq = _collect_facts(config, agents=agents, exclude_archived=args.exclude_archived)
+    facts, dq, claude_dedup_units = _collect_facts(
+        config, agents=agents, exclude_archived=args.exclude_archived
+    )
     facts = list(filter_facts(facts, since_utc=since, until_utc=until, agents=agents))
     rows, agg_dq = build_rows(facts, catalog, group_by=group_by, timezone_name=args.timezone)
     dq.unpriced_tokens = agg_dq.unpriced_tokens
+    # The three dedup counters are Claude-only and always re-scoped to this
+    # report's actual [since, until) window -- see _collect_facts's
+    # docstring for why they aren't filled in from an unscoped total.
+    (
+        dq.duplicate_rows_skipped,
+        dq.conflicting_duplicate_groups,
+        dq.missing_dedup_identity_rows,
+    ) = scope_dedup_units(claude_dedup_units, since_utc=since, until_utc=until)
 
     payload = {
         "schema_version": "1",
@@ -118,7 +152,7 @@ def cmd_export(args) -> int:
     until = _parse_window_bound(args.until, tz)
     agents = set(args.agent.split(",")) if args.agent else {"claude", "codex"}
 
-    facts, _dq = _collect_facts(config, agents=agents, exclude_archived=False)
+    facts, _dq, _claude_dedup_units = _collect_facts(config, agents=agents, exclude_archived=False)
     facts = list(filter_facts(facts, since_utc=since, until_utc=until, agents=agents))
 
     out = open(args.out, "w") if args.out else sys.stdout
@@ -180,7 +214,7 @@ def cmd_measure(args) -> int:
         return 2
 
     config = load_config()
-    facts, dq = _collect_facts(config, agents=agents, exclude_archived=False)
+    facts, dq, claude_dedup_units = _collect_facts(config, agents=agents, exclude_archived=False)
     facts = list(filter_facts(facts, since_utc=since, until_utc=until, agents=agents))
 
     # measure is a per-session query, not a time-bucketed report: group by
@@ -190,6 +224,17 @@ def cmd_measure(args) -> int:
     requested = set(session_ids)
     combined_facts = [f for f in facts if f.session_id in requested]
 
+    # The three dedup counters are Claude-only and always re-scoped to
+    # exactly this measure call's requested session ids AND window -- an
+    # unrequested session's conflict/identity-missing rows must never
+    # affect a requested session's counters (see _collect_facts's
+    # docstring and cmd_report's equivalent window-only scoping above).
+    (
+        dedup_rows_skipped,
+        dedup_conflicting_groups,
+        dedup_missing_identity_rows,
+    ) = scope_dedup_units(claude_dedup_units, since_utc=since, until_utc=until, session_ids=requested)
+
     quality_counts = {v: 0 for v in SOURCE_QUALITY_VALUES}
     for f in combined_facts:
         quality_counts[f.source_quality] = quality_counts.get(f.source_quality, 0) + 1
@@ -208,6 +253,8 @@ def cmd_measure(args) -> int:
 
     payload = {
         "protocol_version": MEASURE_PROTOCOL_VERSION,
+        "producer_version": __version__,
+        "accounting_basis": ACCOUNTING_BASIS,
         "generated_at": datetime.now(timezone.utc).isoformat(),
         "window": {
             "since": since.isoformat() if since else None,
@@ -227,6 +274,9 @@ def cmd_measure(args) -> int:
             "skipped_files": dq.skipped_files,
             "negative_deltas": dq.negative_deltas,
             "unpriced_tokens": total_dq.unpriced_tokens,
+            "duplicate_rows_skipped": dedup_rows_skipped,
+            "conflicting_duplicate_groups": dedup_conflicting_groups,
+            "missing_dedup_identity_rows": dedup_missing_identity_rows,
             "source_quality": quality_counts,
         },
     }

{coding_agent_cost-0.1.1 → coding_agent_cost-0.2.0}/agent_cost/facts.py

@@ -30,9 +30,12 @@ MODES = ("fast", "normal", "unknown")
 # covers the ordinary case; readers add a more specific value only when a
 # fact's derivation has a real, nameable caveat worth surfacing downstream
 # (e.g. Codex's first delta in a rollout is measured against an assumed
-# zero baseline). This is never left unset -- every Fact defaults to "ok"
-# so export never emits a null source_quality.
-SOURCE_QUALITY_VALUES = ("ok", "first_event_delta")
+# zero baseline; Claude's reader can't dedup a row that lacks a full
+# (message.id, requestId) pair, so it emits that row individually and
+# flags it "identity_missing" rather than silently treating it as "ok").
+# This is never left unset -- every Fact defaults to "ok" so export never
+# emits a null source_quality.
+SOURCE_QUALITY_VALUES = ("ok", "first_event_delta", "identity_missing")
 
 _BRACKET_SUFFIX = re.compile(r"\[[^\]]*\]$")
 _DATE_SUFFIX = re.compile(r"@\d{6,8}$")

{coding_agent_cost-0.1.1 → coding_agent_cost-0.2.0}/agent_cost/rates.json

@@ -1,6 +1,6 @@
 {
   "schema_version": "1",
-  "catalog_version": "2026-09-06",
+  "catalog_version": "2026-09-09",
   "currency": "USD",
   "unit": "per_mtok",
   "usd_per_credit": "0.04",
@@ -8,7 +8,9 @@
     "All Claude rates are standard (non-batch, non-priority) API prices. Batch API is roughly 50% off, but agent-cost's logs have no signal for whether a given request went through Batch, so batch usage is priced at standard rates and will overstate cost for anyone using Batch.",
     "claude-opus-5's launch date could not be confirmed from an authoritative source as of this catalog_version; its rate period's effective_from (2026-07-01) is a placeholder -- update it once confirmed.",
     "gpt-5.6 (sol/terra/luna) credits could not be confirmed from the primary source (help.openai.com's Codex rate card returned HTTP 403 to automated fetches). The values here were cross-checked across several independent secondary sources that agreed with each other and are internally consistent (Sol's $5/$30 per-MTok API price x 25 = 125/750 credits, matching usd_per_credit=0.04); see the gpt-5.6-* sources entries below. Treat effective_from (2026-07-01) as a placeholder and re-verify against the primary rate card when it becomes reachable.",
-    "gpt-6-astra: Codex standard token-based rates only; not API pricing, legacy message metering, or actual contractual charges. Confirmed 2026-09-06 JST (2026-09-05T17:18:23Z). effective_from is this observation cutoff, NOT an official launch or price-start time; earlier events remain unpriced. No Codex long-context surcharge or cache-write charge is applied. Fast multiplier 2.5 applies to explicit priority request settings with matching owned turn/model context; explicit default uses Standard. Missing or ambiguous Astra modes remain unpriced. These settings do not confirm the backend processing tier. See docs/astra-pricing.md for compatibility limits and the separate GPT-5.6 discrepancy report."
+    "gpt-6-astra: Codex standard token-based rates only; not API pricing, legacy message metering, or actual contractual charges. Confirmed 2026-09-06 JST (2026-09-05T17:18:23Z). effective_from is this observation cutoff, NOT an official launch or price-start time; earlier events remain unpriced. No Codex long-context surcharge or cache-write charge is applied. Fast multiplier 2.5 applies to explicit priority request settings with matching owned turn/model context; explicit default uses Standard. Missing or ambiguous Astra modes remain unpriced. These settings do not confirm the backend processing tier. See docs/astra-pricing.md for compatibility limits and the separate GPT-5.6 discrepancy report.",
+    "claude-fable-5-1 added 2026-09-09: rate_id claude-fable-5-1-local-first-observed-2026-09-02. effective_from (2026-09-02T01:17:55Z) is the timestamp the raw model ID was first observed across all 54 local transcript files (none found in August), not a confirmed official launch date -- if an authoritative launch date is confirmed later, add it as a separate rate_id with effective_until on this one rather than editing this period in place. Values (cache_read $0.25/MTok = 0.025x base input) differ from claude-fable-5's cache_read ($1.00/MTok = 0.1x); this is a genuine per-model price difference confirmed against the primary source (see sources below), not an inconsistency to reconcile.",
+    "claude-sonnet-5 corrected 2026-09-09: a prior period (rate_id claude-sonnet-5-standard, effective_from 2026-09-01, values 3.0/0.30/3.75/6.0/15.0) priced a previously-announced rate increase that the pricing page's claude-sonnet-5-introductory-pricing note states did not occur (\"The previously scheduled increase to $3/$15 ... on September 1, 2026 will not occur\"). That period has been replaced by claude-sonnet-5-standard-2026-09-01, which carries the same $2/$0.20/$2.50/$4/$10 values as the preceding claude-sonnet-5-launch-promo period, since the launch price is confirmed to be the ongoing price with no change at the 2026-09-01 boundary. Any measure/v1 or report output computed against the pre-correction catalog for claude-sonnet-5 sessions occurring on or after 2026-09-01 overstated cost by 1.5x for that model. To detect this class of error going forward, cross-check each priced model's rate periods against its primary pricing page's Note text on a recurring (e.g. monthly) basis for mentions of a rate-change announcement being withdrawn or not taking effect -- a period can be internally valid (schema-wise) and still price a rate that was announced but never actually charged."
   ],
   "sources": [
     {
@@ -48,6 +50,16 @@
       "url": "https://developers.openai.com/api/docs/models/gpt-6-astra",
       "retrieved_at": "2026-09-05T17:18:23Z",
       "note": "Boundary check only: API cache writes, long context and API Fast rates are NOT applied to this Codex entry."
+    },
+    {
+      "url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "retrieved_at": "2026-09-09",
+      "note": "used for claude-fable-5-1 (cache_read 0.025x footnote) and the claude-sonnet-5-introductory-pricing correction; local snapshot 2026-09-09 sha256=d79ad28567196bd55dd50e2fd89341b9da9774a45c1d02fcf387078507fd15e0"
+    },
+    {
+      "url": "https://platform.claude.com/docs/en/build-with-claude/prompt-caching",
+      "retrieved_at": "2026-09-09",
+      "note": "cache write TTL multipliers (5m = 1.25x, 1h = 2x), cross-checked against the pricing page cache columns"
     }
   ],
   "models": [
@@ -68,6 +80,23 @@
         }
       ]
     },
+    {
+      "model_key": "claude-fable-5-1",
+      "aliases": [],
+      "fast_multiplier": "1.0",
+      "rates": [
+        {
+          "rate_id": "claude-fable-5-1-local-first-observed-2026-09-02",
+          "effective_from": "2026-09-02T01:17:55+00:00",
+          "effective_until": null,
+          "input_nocache": "10.0",
+          "cache_read": "0.25",
+          "cache_write_5m": "12.50",
+          "cache_write_1h": "20.0",
+          "output": "50.0"
+        }
+      ]
+    },
     {
       "model_key": "claude-mythos-5",
       "aliases": [],
@@ -186,14 +215,14 @@
           "output": "10.0"
         },
         {
-          "rate_id": "claude-sonnet-5-standard",
+          "rate_id": "claude-sonnet-5-standard-2026-09-01",
           "effective_from": "2026-09-01T00:00:00+00:00",
           "effective_until": null,
-          "input_nocache": "3.0",
-          "cache_read": "0.30",
-          "cache_write_5m": "3.75",
-          "cache_write_1h": "6.0",
-          "output": "15.0"
+          "input_nocache": "2.0",
+          "cache_read": "0.20",
+          "cache_write_5m": "2.50",
+          "cache_write_1h": "4.0",
+          "output": "10.0"
         }
       ]
     },

{coding_agent_cost-0.1.1 → coding_agent_cost-0.2.0}/agent_cost/readers/__init__.py

@@ -24,3 +24,14 @@ class ReadResult:
     # `data_quality` (which is reader-agnostic); surfaced for `doctor` /
     # tests.
     tokens_used_diffs: int = 0
+    # Claude-only dedup diagnostics (see readers/claude.py's
+    # parse_session_detailed docstring). Always 0 / empty for the Codex
+    # reader. The three ints are file-level totals, NOT scoped to any
+    # window or session; `claude_dedup_units` carries the same
+    # information per group/row (as `ClaudeDedupUnit`, duck-typed here to
+    # avoid a circular import with readers.claude) so a caller can
+    # re-scope it -- see `agent_cost.aggregate.scope_dedup_units`.
+    duplicate_rows_skipped: int = 0
+    conflicting_duplicate_groups: int = 0
+    missing_dedup_identity_rows: int = 0
+    claude_dedup_units: List = field(default_factory=list)