cc-session-tools 3.10.0__tar.gz → 3.10.2__tar.gz

{cc_session_tools-3.10.0/src/cc_session_tools.egg-info → cc_session_tools-3.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-session-tools
-Version: 3.10.0
+Version: 3.10.2
 Summary: Claude Code session management CLI tools (ccd, ccr, ccs, claude-code-usage, ccst) and hook library (hooks package)
 Author: raffishquartan
 License: MIT License

{cc_session_tools-3.10.0 → cc_session_tools-3.10.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cc-session-tools"
-version = "3.10.0"
+version = "3.10.2"
 description = "Claude Code session management CLI tools (ccd, ccr, ccs, claude-code-usage, ccst) and hook library (hooks package)"
 readme = "README.md"
 license = { file = "LICENSE" }

{cc_session_tools-3.10.0 → cc_session_tools-3.10.2}/src/cc_session_tools/lib/pdata/cutover.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import time
+from collections.abc import Callable
 from pathlib import Path
 
 from cc_session_tools.lib.pdata.init_paths import (
@@ -59,6 +60,7 @@ def _write_pointer_file(*, project_root: Path, project: str, entry: ManifestEntr
 def archive_entries(
     *, project_root: Path, entries: list[ManifestEntry], project: str,
     write_pointer_files: bool = True,
+    on_archived: Callable[[ManifestEntry], None] | None = None,
 ) -> None:
     """Move every db-owned entry's source file into project_root/.pdata-migrated/,
     preserving its relative path, and append one line per entry to MANIFEST.md.
@@ -69,7 +71,11 @@ def archive_entries(
     Markdown pointer file back at each entry's original path so anything else in the
     project that cites the old path by name finds a live signpost instead of a silent
     404. Pass write_pointer_files=False (--leave-no-pointer-files at the CLI) to
-    suppress this."""
+    suppress this.
+
+    `on_archived`, if given, is called with each entry immediately after its source has been
+    moved (before its log line and pointer file are written), so a caller that sees this
+    function raise part-way knows exactly which entries were already cut over."""
     if not entries:
         return
     archive_root = project_root / MIGRATED_ARCHIVE_DIRNAME
@@ -82,6 +88,8 @@ def archive_entries(
             destination = archive_root / entry.path
             destination.parent.mkdir(parents=True, exist_ok=True)
             source.rename(destination)
+            if on_archived is not None:
+                on_archived(entry)
             log.write(
                 f"- {now} — {entry.path} — migrated source, superseded by ccst pdata "
                 f"(record_group={entry.db_group()})\n"

{cc_session_tools-3.10.0 → cc_session_tools-3.10.2}/src/cc_session_tools/lib/pdata/init_service.py

@@ -213,6 +213,69 @@ def _rollback(*, project: str, created_ids: list[int]) -> list[str]:
     return rollback_failures
 
 
+def _rollback_after_error(
+    exc: BaseException, *, project: str, created_ids: list[int],
+    on_progress: Callable[[str], None] | None,
+) -> None:
+    """Roll back `created_ids` after an error `write()` did not anticipate, without ever
+    replacing `exc` (the caller re-raises it): a rollback that itself fails is reported through
+    `on_progress` and attached to `exc` as a note naming every record id still live, so the
+    manual cleanup the failure implies is not a hunt."""
+    if not created_ids:
+        return
+    try:
+        failures = _rollback(project=project, created_ids=created_ids)
+    except Exception as rollback_exc:
+        note = (
+            f"rollback of {len(created_ids)} inserted row(s) aborted: {rollback_exc!r} - rows "
+            f"from this run may still be live; record ids: {created_ids}"
+        )
+        exc.add_note(note)
+        _emit(on_progress, note)
+        return
+    rolled_back = len(created_ids) - len(failures)
+    _emit(
+        on_progress,
+        f"Unexpected {type(exc).__name__} - rolled back {rolled_back} of "
+        f"{len(created_ids)} inserted row(s)",
+    )
+    if failures:
+        exc.add_note("rows from this run still live:\n" + "\n".join(failures))
+        for failure in failures:
+            _emit(on_progress, f"  {failure}")
+
+
+def _recover_from_failed_cutover(
+    exc: BaseException, *, project: str, m: Manifest, proposal_path: Path,
+    written_entries: list[ManifestEntry], archived: list[ManifestEntry],
+    entry_rows: dict[str, list[tuple[int, ImportRow]]],
+    on_progress: Callable[[str], None] | None,
+) -> None:
+    """Cutover failed part-way. An entry whose source was already moved into the archive is cut
+    over: its rows are its live copy, so they stay and the entry is marked migrated (a rerun then
+    skips it). An entry still in place has its rows rolled back, so a rerun imports it once
+    rather than twice."""
+    if archived:
+        stamp = datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
+        for entry in archived:
+            entry.migrated_at = stamp
+        try:
+            manifest.save(m, proposal_path)
+        except Exception as save_exc:
+            exc.add_note(
+                f"could not record {len(archived)} already cut-over entr(ies) as migrated in "
+                f"{proposal_path}: {save_exc!r}; mark these migrated by hand before re-running: "
+                f"{', '.join(e.path for e in archived)}"
+            )
+    archived_paths = {e.path for e in archived}
+    pending_ids = [
+        record_id
+        for entry in written_entries if entry.path not in archived_paths
+        for record_id, _ in entry_rows[entry.path]
+    ]
+    _rollback_after_error(exc, project=project, created_ids=pending_ids, on_progress=on_progress)
+
+
 def _check_db_not_locked(project: str) -> None:
     """Pre-flight concurrency guard (inter-session message 20260819T114156Z-3ec7,
     gap #2): refuse to start --write if another connection already holds a write
@@ -432,105 +495,125 @@ def write(
         db_owned = [e for e in m.entries if e.classification == "db-owned"]
         already_migrated = [e for e in db_owned if e.migrated_at is not None]
         to_import = [e for e in db_owned if e.migrated_at is None]
-        _emit(on_progress, f"Importing {len(to_import)} file(s)...")
-        if already_migrated:
-            _emit(
-                on_progress,
-                f"  skipping {len(already_migrated)} already-migrated file(s): "
-                f"{', '.join(e.path for e in already_migrated)}",
+        # Everything from the first insert through the backup either returns a WriteResult
+        # (rolling back by hand) or, for any exception this code did not anticipate, rolls the
+        # inserted rows back here before re-raising - never leaves them live with the manifest
+        # unmarked and cutover unrun.
+        try:
+            _emit(on_progress, f"Importing {len(to_import)} file(s)...")
+            if already_migrated:
+                _emit(
+                    on_progress,
+                    f"  skipping {len(already_migrated)} already-migrated file(s): "
+                    f"{', '.join(e.path for e in already_migrated)}",
+                )
+            for entry in to_import:
+                try:
+                    source_path = project_root / entry.path
+                    if not source_path.exists():
+                        # entry.migrated_at is None here (to_import excludes already-migrated
+                        # entries above), so this is not the ordinary "already cut over by an
+                        # earlier --write" case — the source is genuinely missing for an entry
+                        # this run believes still needs importing. Fail with a specific,
+                        # actionable message (still caught by this loop's own except clause
+                        # below, so it contributes to `reasons`/rollback exactly like any other
+                        # per-entry import failure) instead of a bare FileNotFoundError only
+                        # discoverable via the rollback reasons list.
+                        raise ValueError(
+                            f"{entry.path}: marked db-owned with no migrated_at, but its source "
+                            f"file does not exist at {source_path} — if this entry was already "
+                            f"migrated by another means, set its classification to folder-owned "
+                            f"(or otherwise correct the manifest) before running --write again"
+                        )
+                    _emit(on_progress, f"  importing {entry.path} -> group={entry.db_group()}...")
+                    for spec in entry.fields:
+                        service.schema_add_field(
+                            project=project, record_group=entry.db_group(),
+                            field_name=spec.name, sql_type=spec.sql_type,
+                            description=spec.description, default=spec.default,
+                        )
+                    rows_for_entry: list[tuple[int, ImportRow]] = []
+                    for row in import_entry(project_root, entry):
+                        record = service.add_record(
+                            project=project, record_group=entry.db_group(),
+                            content=row.content, file_path=row.file_path,
+                            fields=row.fields, created_at=row.created_at,
+                        )
+                        created_ids.append(record.id)
+                        rows_for_entry.append((record.id, row))
+                    entry_rows[entry.path] = rows_for_entry
+                    _emit(on_progress, f"    {len(rows_for_entry)} row(s) imported")
+                    written_entries.append(entry)
+                except (ValueError, OSError, csv.Error) as exc:
+                    reasons.append(f"{entry.path}: {exc}")
+
+            _emit(on_progress, "Verifying imported rows...")
+            reasons.extend(
+                _verify(project=project, project_root=project_root,
+                        written_entries=written_entries, entry_rows=entry_rows)
             )
-        for entry in to_import:
-            try:
-                source_path = project_root / entry.path
-                if not source_path.exists():
-                    # entry.migrated_at is None here (to_import excludes already-migrated
-                    # entries above), so this is not the ordinary "already cut over by an
-                    # earlier --write" case — the source is genuinely missing for an entry
-                    # this run believes still needs importing. Fail with a specific,
-                    # actionable message (still caught by this loop's own except clause
-                    # below, so it contributes to `reasons`/rollback exactly like any other
-                    # per-entry import failure) instead of a bare FileNotFoundError only
-                    # discoverable via the rollback reasons list.
-                    raise ValueError(
-                        f"{entry.path}: marked db-owned with no migrated_at, but its source "
-                        f"file does not exist at {source_path} — if this entry was already "
-                        f"migrated by another means, set its classification to folder-owned "
-                        f"(or otherwise correct the manifest) before running --write again"
-                    )
-                _emit(on_progress, f"  importing {entry.path} -> group={entry.db_group()}...")
-                for spec in entry.fields:
-                    service.schema_add_field(
-                        project=project, record_group=entry.db_group(),
-                        field_name=spec.name, sql_type=spec.sql_type,
-                        description=spec.description, default=spec.default,
-                    )
-                rows_for_entry: list[tuple[int, ImportRow]] = []
-                for row in import_entry(project_root, entry):
-                    record = service.add_record(
-                        project=project, record_group=entry.db_group(),
-                        content=row.content, file_path=row.file_path,
-                        fields=row.fields, created_at=row.created_at,
-                    )
-                    created_ids.append(record.id)
-                    rows_for_entry.append((record.id, row))
-                entry_rows[entry.path] = rows_for_entry
-                _emit(on_progress, f"    {len(rows_for_entry)} row(s) imported")
-                written_entries.append(entry)
-            except (ValueError, OSError, csv.Error) as exc:
-                reasons.append(f"{entry.path}: {exc}")
-
-        _emit(on_progress, "Verifying imported rows...")
-        reasons.extend(
-            _verify(project=project, project_root=project_root,
-                    written_entries=written_entries, entry_rows=entry_rows)
-        )
 
-        if reasons:
-            _emit(on_progress, "Verification failed — rolling back inserted rows...")
-            return WriteResult(
-                created_record_ids=[], entries_written=[], backup_path=None,
-                failure=WriteFailure(
-                    reasons=reasons + _rollback(project=project, created_ids=created_ids)
-                ),
+            if reasons:
+                _emit(on_progress, "Verification failed — rolling back inserted rows...")
+                return WriteResult(
+                    created_record_ids=[], entries_written=[], backup_path=None,
+                    failure=WriteFailure(
+                        reasons=reasons + _rollback(project=project, created_ids=created_ids)
+                    ),
+                )
+
+            # Still inside both overrides: a rehearsed run's backup must land in the
+            # rehearsal sandbox (backup_dir_override), never in the real backup dir.
+            _emit(on_progress, "Backing up project and database before cutover...")
+            try:
+                backup_path = backup.create_backup(
+                    project=project, project_root=project_root, on_progress=on_progress,
+                )
+                _emit(on_progress, f"Backup written: {backup_path}")
+            except backup.BackupError as exc:
+                _emit(on_progress, "Backup failed — rolling back inserted rows...")
+                return WriteResult(
+                    created_record_ids=[], entries_written=[], backup_path=None,
+                    failure=WriteFailure(
+                        reasons=[str(exc)] + _rollback(project=project, created_ids=created_ids)
+                    ),
+                )
+        except BaseException as exc:
+            _rollback_after_error(
+                exc, project=project, created_ids=created_ids, on_progress=on_progress,
             )
+            raise
 
-        # Still inside both overrides: a rehearsed run's backup must land in the
-        # rehearsal sandbox (backup_dir_override), never in the real backup dir.
-        _emit(on_progress, "Backing up project and database before cutover...")
+        _emit(on_progress, f"Cutting over {len(written_entries)} file(s)...")
+        archived: list[ManifestEntry] = []
         try:
-            backup_path = backup.create_backup(
-                project=project, project_root=project_root, on_progress=on_progress,
+            cutover.archive_entries(
+                project_root=project_root, entries=written_entries, project=project,
+                write_pointer_files=not leave_no_pointer_files, on_archived=archived.append,
             )
-            _emit(on_progress, f"Backup written: {backup_path}")
-        except backup.BackupError as exc:
-            _emit(on_progress, "Backup failed — rolling back inserted rows...")
-            return WriteResult(
-                created_record_ids=[], entries_written=[], backup_path=None,
-                failure=WriteFailure(
-                    reasons=[str(exc)] + _rollback(project=project, created_ids=created_ids)
-                ),
+            # Mark every entry this run actually cut over as migrated, and persist that back to
+            # the manifest — write() only ever `manifest.load`s otherwise, so without this a
+            # later --write would re-attempt (and, pre-fix, roll back) these same now-archived
+            # entries. written_entries holds the same ManifestEntry objects m.entries does (see
+            # the `to_import`/`written_entries.append(entry)` loop above), so mutating here
+            # mutates m.
+            migrated_at = datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
+            for entry in written_entries:
+                entry.migrated_at = migrated_at
+            manifest.save(m, proposal_path)
+        except BaseException as exc:
+            _recover_from_failed_cutover(
+                exc, project=project, m=m, proposal_path=proposal_path,
+                written_entries=written_entries, archived=archived, entry_rows=entry_rows,
+                on_progress=on_progress,
             )
-
-    _emit(on_progress, f"Cutting over {len(written_entries)} file(s)...")
-    cutover.archive_entries(
-        project_root=project_root, entries=written_entries, project=project,
-        write_pointer_files=not leave_no_pointer_files,
-    )
-    # Mark every entry this run actually cut over as migrated, and persist that back to
-    # the manifest — write() only ever `manifest.load`s otherwise, so without this a later
-    # --write would re-attempt (and, pre-fix, roll back) these same now-archived entries.
-    # written_entries holds the same ManifestEntry objects m.entries does (see the
-    # `to_import`/`written_entries.append(entry)` loop above), so mutating here mutates m.
-    migrated_at = datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
-    for entry in written_entries:
-        entry.migrated_at = migrated_at
-    manifest.save(m, proposal_path)
-    return WriteResult(
-        created_record_ids=created_ids,
-        entries_written=[e.path for e in written_entries],
-        backup_path=backup_path, failure=None,
-        report=_render_diff_report(written_entries=written_entries, entry_rows=entry_rows),
-    )
+            raise
+        return WriteResult(
+            created_record_ids=created_ids,
+            entries_written=[e.path for e in written_entries],
+            backup_path=backup_path, failure=None,
+            report=_render_diff_report(written_entries=written_entries, entry_rows=entry_rows),
+        )
 
 
 def _verify(
@@ -544,12 +627,18 @@ def _verify(
     reasons: list[str] = []
     for entry in written_entries:
         rows = entry_rows[entry.path]
-        expected_count = count_source_rows(project_root, entry)
-        if len(rows) != expected_count:
+        try:
+            expected_count = count_source_rows(project_root, entry)
+        except (ValueError, OSError, csv.Error) as exc:
             reasons.append(
-                f"{entry.path}: imported {len(rows)} row(s) but re-counting the source "
-                f"gives {expected_count} — entry-count parity check failed"
+                f"{entry.path}: could not re-count the source rows for the parity check: {exc}"
             )
+        else:
+            if len(rows) != expected_count:
+                reasons.append(
+                    f"{entry.path}: imported {len(rows)} row(s) but re-counting the source "
+                    f"gives {expected_count} — entry-count parity check failed"
+                )
         for record_id, import_row in rows:
             record = service.get_record(project=project, record_id=record_id)
             assert record is not None, (
@@ -562,7 +651,17 @@ def _verify(
                 )
             if record.file_path:
                 target = project_root / record.file_path
-                if not target.exists():
+                try:
+                    resolves = target.exists()
+                except OSError as exc:
+                    # A string the OS rejects outright (e.g. "File name too long") raises
+                    # instead of returning False; it is the same "does not resolve" outcome.
+                    reasons.append(
+                        f"{entry.path}: record {record_id} file_path "
+                        f"{record.file_path!r} cannot be checked under {project_root}: {exc}"
+                    )
+                    continue
+                if not resolves:
                     reasons.append(
                         f"{entry.path}: record {record_id} file_path "
                         f"{record.file_path!r} does not resolve under {project_root}"

{cc_session_tools-3.10.0 → cc_session_tools-3.10.2/src/cc_session_tools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-session-tools
-Version: 3.10.0
+Version: 3.10.2
 Summary: Claude Code session management CLI tools (ccd, ccr, ccs, claude-code-usage, ccst) and hook library (hooks package)
 Author: raffishquartan
 License: MIT License

{cc_session_tools-3.10.0 → cc_session_tools-3.10.2}/src/hooks/model_info.py

@@ -5,8 +5,8 @@ source of truth this table is migrating from). Consumed by
 context_window_warning to phrase its nudge in terms of "% of the model's
 actual window" and to estimate a per-model cache-read cost.
 
-Figures current as of 2026-08-13 (Claude 5 family). Context windows: Fable 5 /
-Mythos 5 / Opus 5 / Opus 4.6-4.8 / Sonnet 5 / Sonnet 4.6 all 1,000,000 tokens
+Figures current as of 2026-09-29 (Claude 5 family; 5.5/5.1 ids added). Context windows: Fable 5 /
+Mythos 5 / Opus 5 / Opus 4.6-4.8 / Sonnet 5 / Sonnet 5.5 / Opus 5.5 / Fable 5.1 / Sonnet 4.6 all 1,000,000 tokens
 (the default, not a beta long-context mode); Haiku 4.5 stays at 200,000.
 Prices are the standard (non-cached) input rate per million tokens.
 
@@ -25,50 +25,55 @@ design spec's section 2.
 """
 from __future__ import annotations
 
+import re
+
 _WINDOW_1M = {
     "claude-fable-5", "claude-mythos-5",
     "claude-opus-5", "claude-opus-4-8", "claude-opus-4-7", "claude-opus-4-6",
     "claude-sonnet-5", "claude-sonnet-4-6",
+    "claude-sonnet-5-5", "claude-opus-5-5", "claude-fable-5-1",
 }
 _PRICE = {
     "claude-fable-5": 10.00, "claude-mythos-5": 10.00,
     "claude-opus-5": 5.00, "claude-opus-4-8": 5.00, "claude-opus-4-7": 5.00, "claude-opus-4-6": 5.00,
     "claude-sonnet-5": 3.00, "claude-sonnet-4-6": 3.00,
+    # Assumed equal to the family's existing price (no published figure for these ids); the
+    # price only feeds the rough "~$/turn in cache reads" estimate.
+    "claude-sonnet-5-5": 3.00, "claude-opus-5-5": 5.00, "claude-fable-5-1": 10.00,
+    "claude-haiku-4-5": 1.00,
 }
 _NAME = {
     "claude-fable-5": "Fable 5", "claude-mythos-5": "Mythos 5",
     "claude-opus-5": "Opus 5", "claude-opus-4-8": "Opus 4.8",
     "claude-opus-4-7": "Opus 4.7", "claude-opus-4-6": "Opus 4.6",
     "claude-sonnet-5": "Sonnet 5", "claude-sonnet-4-6": "Sonnet 4.6",
+    "claude-sonnet-5-5": "Sonnet 5.5", "claude-opus-5-5": "Opus 5.5",
+    "claude-fable-5-1": "Fable 5.1", "claude-haiku-4-5": "Haiku 4.5",
 }
 _DEFAULT_WINDOW = 200_000
 _DEFAULT_PRICE = 5.00
 _DEFAULT_NAME = "an unrecognized model"
 
 
-def _is_haiku_4_5(model_id: str) -> bool:
-    return model_id.startswith("claude-haiku-4-5")
+_DATED_SNAPSHOT = re.compile(r"(.+)-\d{8}")
+
+
+def _canonical(model_id: str) -> str:
+    """A dated snapshot id (`<id>-YYYYMMDD`) resolves to its undated row. Applied once, and
+    only for an exactly-eight-digit suffix: any other suffix (or a snapshot of an unknown id)
+    stays unrecognised. `[1m]`/`-latest` are not handled - transcripts' `message.model` never
+    carries them."""
+    match = _DATED_SNAPSHOT.fullmatch(model_id)
+    return match.group(1) if match else model_id
 
 
 def context_window(model_id: str) -> int:
-    if model_id in _WINDOW_1M:
-        return 1_000_000
-    if _is_haiku_4_5(model_id):
-        return 200_000
-    return _DEFAULT_WINDOW
+    return 1_000_000 if _canonical(model_id) in _WINDOW_1M else _DEFAULT_WINDOW
 
 
 def input_price_per_mtok(model_id: str) -> float:
-    if model_id in _PRICE:
-        return _PRICE[model_id]
-    if _is_haiku_4_5(model_id):
-        return 1.00
-    return _DEFAULT_PRICE
+    return _PRICE.get(_canonical(model_id), _DEFAULT_PRICE)
 
 
 def display_name(model_id: str) -> str:
-    if model_id in _NAME:
-        return _NAME[model_id]
-    if _is_haiku_4_5(model_id):
-        return "Haiku 4.5"
-    return _DEFAULT_NAME
+    return _NAME.get(_canonical(model_id), _DEFAULT_NAME)

{cc_session_tools-3.10.0 → cc_session_tools-3.10.2}/tests/test_context_window_warning.py

@@ -180,3 +180,26 @@ def test_override_end_to_end_via_real_store(tmp_path, monkeypatch, capsys):
     out = capsys.readouterr()
     assert rc == 0
     assert out.out == ""
+
+
+@pytest.mark.parametrize(
+    ("model_id", "name", "cost"),
+    [
+        ("claude-sonnet-5-5", "Sonnet 5.5", "0.07"),
+        ("claude-opus-5-5", "Opus 5.5", "0.13"),
+        ("claude-fable-5-1", "Fable 5.1", "0.26"),
+    ],
+)
+def test_new_5x_models_are_measured_against_their_one_million_token_window(
+    tmp_path, monkeypatch, capsys, model_id, name, cost
+):
+    p = tmp_path / "t.jsonl"
+    _write_transcript(p, [{"type": "assistant", "message": {"model": model_id,
+        "usage": {"input_tokens": 266000, "cache_creation_input_tokens": 0, "cache_read_input_tokens": 0}}}])
+    monkeypatch.setattr(cww, "_is_overridden", lambda session_id: False)
+    rc, out = _run_main(monkeypatch, capsys, {"transcript_path": str(p), "session_id": "s1"})
+    reason = json.loads(out.out)["reason"]
+    assert "~27% of the 1M-token window" in reason
+    assert name in reason
+    assert f"~${cost}/turn" in reason
+    assert "unrecognized" not in reason

cc_session_tools-3.10.2/tests/test_model_info.py

@@ -0,0 +1,67 @@
+from hooks import model_info
+
+CASES = [
+    ("claude-fable-5", 1_000_000, 10.00, "Fable 5"),
+    ("claude-mythos-5", 1_000_000, 10.00, "Mythos 5"),
+    ("claude-opus-5", 1_000_000, 5.00, "Opus 5"),
+    ("claude-opus-4-8", 1_000_000, 5.00, "Opus 4.8"),
+    ("claude-opus-4-7", 1_000_000, 5.00, "Opus 4.7"),
+    ("claude-opus-4-6", 1_000_000, 5.00, "Opus 4.6"),
+    ("claude-sonnet-5", 1_000_000, 3.00, "Sonnet 5"),
+    ("claude-sonnet-4-6", 1_000_000, 3.00, "Sonnet 4.6"),
+    ("claude-sonnet-5-5", 1_000_000, 3.00, "Sonnet 5.5"),
+    ("claude-opus-5-5", 1_000_000, 5.00, "Opus 5.5"),
+    ("claude-fable-5-1", 1_000_000, 10.00, "Fable 5.1"),
+    ("claude-haiku-4-5-20251001", 200_000, 1.00, "Haiku 4.5"),
+]
+
+
+def test_known_models():
+    for model_id, window, price, name in CASES:
+        assert model_info.context_window(model_id) == window
+        assert model_info.input_price_per_mtok(model_id) == price
+        assert model_info.display_name(model_id) == name
+
+
+def test_unrecognized_model_falls_back():
+    assert model_info.context_window("claude-nonexistent-9") == 200_000
+    assert model_info.input_price_per_mtok("claude-nonexistent-9") == 5.00
+    assert model_info.display_name("claude-nonexistent-9") == "an unrecognized model"
+
+
+def test_empty_model_id_falls_back():
+    assert model_info.context_window("") == 200_000
+
+
+def test_dated_snapshot_ids_resolve_like_their_family_id():
+    """Claude Code can report a dated snapshot id (`<family>-YYYYMMDD`); it must resolve to the
+    same row as the undated id, not fall to the 200k default."""
+    for base, window, price, name in CASES:
+        if base.startswith("claude-haiku"):
+            continue
+        dated = f"{base}-20261001"
+        assert model_info.context_window(dated) == window
+        assert model_info.input_price_per_mtok(dated) == price
+        assert model_info.display_name(dated) == name
+
+
+def test_unknown_dated_and_decorated_ids_stay_unrecognised():
+    for model_id in (
+        "claude-sonnet-5-9-20261001",
+        "claude-nonexistent-9-20261001",
+        "claude-sonnet-5-5-2026100",      # 7 digits
+        "claude-sonnet-5-5-202610011",    # 9 digits
+        "claude-sonnet-5-5-latest",
+        "claude-sonnet-5-5[1m]",
+        "claude-sonnet-5-5-20261001-20261002",  # normalised once only
+        "claude-haiku-4-5-garbage",
+    ):
+        assert model_info.context_window(model_id) == 200_000, model_id
+        assert model_info.display_name(model_id) == "an unrecognized model", model_id
+
+
+def test_id_that_merely_starts_with_a_known_id_is_not_recognised():
+    """Guards against a future lazy prefix implementation (already true before the fix):
+    `claude-sonnet-5-9` must not inherit `claude-sonnet-5`'s row."""
+    assert model_info.context_window("claude-sonnet-5-9") == 200_000
+    assert model_info.display_name("claude-sonnet-5-9") == "an unrecognized model"

cc_session_tools-3.10.0/tests/test_model_info.py

@@ -1,30 +0,0 @@
-from hooks import model_info
-
-CASES = [
-    ("claude-fable-5", 1_000_000, 10.00, "Fable 5"),
-    ("claude-mythos-5", 1_000_000, 10.00, "Mythos 5"),
-    ("claude-opus-5", 1_000_000, 5.00, "Opus 5"),
-    ("claude-opus-4-8", 1_000_000, 5.00, "Opus 4.8"),
-    ("claude-opus-4-7", 1_000_000, 5.00, "Opus 4.7"),
-    ("claude-opus-4-6", 1_000_000, 5.00, "Opus 4.6"),
-    ("claude-sonnet-5", 1_000_000, 3.00, "Sonnet 5"),
-    ("claude-sonnet-4-6", 1_000_000, 3.00, "Sonnet 4.6"),
-    ("claude-haiku-4-5-20251001", 200_000, 1.00, "Haiku 4.5"),
-]
-
-
-def test_known_models():
-    for model_id, window, price, name in CASES:
-        assert model_info.context_window(model_id) == window
-        assert model_info.input_price_per_mtok(model_id) == price
-        assert model_info.display_name(model_id) == name
-
-
-def test_unrecognized_model_falls_back():
-    assert model_info.context_window("claude-nonexistent-9") == 200_000
-    assert model_info.input_price_per_mtok("claude-nonexistent-9") == 5.00
-    assert model_info.display_name("claude-nonexistent-9") == "an unrecognized model"
-
-
-def test_empty_model_id_falls_back():
-    assert model_info.context_window("") == 200_000