fix(parser,test): harden token arithmetic and wire fuzz CI profile

Add _safe_int() so non-numeric usage fields coerce to 0 instead of raising
TypeError during token accumulation; apply to all token fields. Drop
max_examples/deadline from the test decorator so the conftest ci/dev profile
actually governs fuzz runtime. Inline _fuzz_jsonl_path, tighten truncation
model and unknown-type assertion, simplify ALLOWED_EXCEPTIONS, and note macOS
in the CONTRIBUTING PR checklist.

Author: clean6378-max-it

CONTRIBUTING.md

@@ -112,7 +112,7 @@ npm run test:coverage   # optional
   - [ ] `ruff check .` and `ruff format --check .` green locally
   - [ ] `pytest -q` green locally
   - [ ] `npm test` green if JS changed
-  - [ ] CI jobs green (`lint-and-audit`, `pytest`, `integration-tests`, `js-tests` on Ubuntu + Windows; `mypy`, `prod-install-smoke` on Ubuntu)
+  - [ ] CI jobs green (`lint-and-audit`, `pytest`, `integration-tests`, `js-tests` on Ubuntu + Windows + macOS; `mypy`, `prod-install-smoke` on Ubuntu)
   - [ ] PR description includes a **Test plan** section
   - [ ] API changes update [`docs/api-reference.md`](docs/api-reference.md) if behavior or errors change
 

tests/conftest.py

@@ -12,9 +12,11 @@
 
 from app import create_app
 
-if os.environ.get("CI"):
-    settings.register_profile("ci", max_examples=100, deadline=None)
-    settings.load_profile("ci")
+# Hypothesis profiles drive fuzz example counts/deadlines (deadline disabled to
+# avoid timing flakiness on slow/CI runners). CI runs fewer examples for speed.
+settings.register_profile("dev", max_examples=200, deadline=None)
+settings.register_profile("ci", max_examples=100, deadline=None)
+settings.load_profile("ci" if os.environ.get("CI") else "dev")
 
 FIXTURES = Path(__file__).parent / "fixtures"
 

tests/test_parser_fuzz.py

@@ -13,25 +13,21 @@
 
 from utils.jsonl_parser import parse_session
 
-FUZZ_SETTINGS = settings(
-    max_examples=200,
-    deadline=5000,
-    suppress_health_check=[HealthCheck.function_scoped_fixture],
-)
+# Only suppress the tmp_path health check; max_examples and deadline come from
+# the active Hypothesis profile (ci/dev) registered in conftest.py.
+FUZZ_SETTINGS = settings(suppress_health_check=[HealthCheck.function_scoped_fixture])
 
+# Structured errors that are acceptable instead of a clean parse. Empty for now —
+# the invariant is that parse_session never raises an unhandled exception.
 ALLOWED_EXCEPTIONS: tuple[type[BaseException], ...] = ()
 
 
-def _fuzz_jsonl_path(tmp_path: Path, name: str) -> Path:
-    return tmp_path / name
-
-
 def _parse_file_without_crash(path: str) -> None:
     try:
         parse_session(path)
+    except ALLOWED_EXCEPTIONS:
+        return
     except Exception as exc:
-        if ALLOWED_EXCEPTIONS and isinstance(exc, ALLOWED_EXCEPTIONS):
-            return
         raise AssertionError(f"unhandled {type(exc).__name__}: {exc}") from exc
 
 
@@ -151,17 +147,17 @@ def structured_entry(draw: st.DrawFn) -> dict:
 @given(st.lists(st.text(min_size=0, max_size=500), min_size=0, max_size=30))
 def test_raw_line_soup_does_not_crash(tmp_path: Path, lines: list[str]) -> None:
     """Malformed JSON lines, garbage text, and empty lines."""
-    path = _write_jsonl(_fuzz_jsonl_path(tmp_path, "soup.jsonl"), lines)
+    path = _write_jsonl(tmp_path / "soup.jsonl", lines)
     _parse_file_without_crash(path)
 
 
 @FUZZ_SETTINGS
 @given(st.text(min_size=1, max_size=500))
 def test_truncated_json_line(tmp_path: Path, prefix: str) -> None:
-    """Partial JSON simulating concurrent writes."""
-    half = json.dumps(prefix)[: max(1, len(prefix) // 2)]
-    line = '{"type": "user", "message": {"content": ' + half
-    path = _write_jsonl(_fuzz_jsonl_path(tmp_path, "trunc.jsonl"), [line])
+    """Partial JSON simulating concurrent writes (object cut mid-serialization)."""
+    full_line = json.dumps({"type": "user", "message": {"content": prefix}})
+    truncated = full_line[: max(1, len(full_line) // 2)]
+    path = _write_jsonl(tmp_path / "trunc.jsonl", [truncated])
     _parse_file_without_crash(path)
 
 
@@ -170,7 +166,7 @@ def test_truncated_json_line(tmp_path: Path, prefix: str) -> None:
 def test_structured_entries_with_fuzzed_fields(tmp_path: Path, entries: list[dict]) -> None:
     """Unknown types, missing/extra fields, wrong-typed nested values."""
     lines = [json.dumps(e, default=str) for e in entries]
-    path = _write_jsonl(_fuzz_jsonl_path(tmp_path, "structured.jsonl"), lines)
+    path = _write_jsonl(tmp_path / "structured.jsonl", lines)
     _parse_file_without_crash(path)
 
 
@@ -182,7 +178,7 @@ def test_deep_nesting_in_message_content(tmp_path: Path, nested_values: list) ->
         "timestamp": "2026-06-11T00:00:00Z",
         "message": {"content": nested_values},
     }
-    path = _write_jsonl(_fuzz_jsonl_path(tmp_path, "nest.jsonl"), [json.dumps(entry, default=str)])
+    path = _write_jsonl(tmp_path / "nest.jsonl", [json.dumps(entry, default=str)])
     _parse_file_without_crash(path)
 
 
@@ -195,7 +191,7 @@ def test_long_line_payload(tmp_path: Path, length: int) -> None:
         "timestamp": "2026-06-11T00:00:00Z",
         "message": {"content": [{"type": "text", "text": payload}]},
     }
-    path = _write_jsonl(_fuzz_jsonl_path(tmp_path, "long.jsonl"), [json.dumps(entry)])
+    path = _write_jsonl(tmp_path / "long.jsonl", [json.dumps(entry)])
     _parse_file_without_crash(path)
 
 
@@ -215,7 +211,7 @@ def test_empty_lines_between_records(tmp_path: Path, texts: list[str]) -> None:
             )
         )
         lines.append("   ")
-    path = _write_jsonl(_fuzz_jsonl_path(tmp_path, "empty.jsonl"), lines)
+    path = _write_jsonl(tmp_path / "empty.jsonl", lines)
     _parse_file_without_crash(path)
 
 
@@ -243,4 +239,27 @@ def test_unknown_record_type_is_graceful(tmp_path: Path) -> None:
     path = _write_jsonl(tmp_path / "unknown.jsonl", lines)
     session = parse_session(path)
     assert session["metadata"]["entry_counts"].get("totally-new-claude-record") == 1
-    assert len(session["messages"]) >= 1
+    # Unknown type produces no message; only the valid user line does.
+    assert len(session["messages"]) == 1
+
+
+def test_non_numeric_usage_tokens_do_not_crash(tmp_path: Path) -> None:
+    """Non-numeric usage fields must coerce to 0, not raise TypeError on +=."""
+    entry = {
+        "type": "assistant",
+        "timestamp": "2026-06-11T00:00:00Z",
+        "message": {
+            "model": "claude-test",
+            "content": [{"type": "text", "text": "hi"}],
+            "usage": {
+                "input_tokens": "five",
+                "output_tokens": ["not", "a", "number"],
+                "cache_creation": {"ephemeral_5m_input_tokens": "lots"},
+            },
+        },
+    }
+    path = _write_jsonl(tmp_path / "bad_usage.jsonl", [json.dumps(entry)])
+    session = parse_session(path)
+    assert session["metadata"]["total_input_tokens"] == 0
+    assert session["metadata"]["total_output_tokens"] == 0
+    assert session["metadata"]["total_ephemeral_5m_tokens"] == 0

utils/jsonl_parser.py

@@ -40,6 +40,16 @@
 ]
 
 
+def _safe_int(val: Any) -> int:
+    """Coerce a value to int for token accounting; non-numeric input becomes 0
+    so fuzzed/malformed usage fields never raise during arithmetic."""
+    if isinstance(val, bool):
+        return 0
+    if isinstance(val, (int, float)):
+        return int(val)
+    return 0
+
+
 def parse_session(filepath: str) -> SessionDict:
     """Main entry point. Reads every line from a .jsonl file and builds up
     a session dict with messages, metadata (tokens, models, tool counts),
@@ -223,19 +233,19 @@ def _process_assistant(
     usage = msg.get("usage", {})
     if not isinstance(usage, dict):
         usage = {}
-    metadata["total_input_tokens"] += usage.get("input_tokens") or 0
-    metadata["total_output_tokens"] += usage.get("output_tokens") or 0
-    metadata["total_cache_read_tokens"] += usage.get("cache_read_input_tokens") or 0
-    metadata["total_cache_creation_tokens"] += usage.get("cache_creation_input_tokens") or 0
+    metadata["total_input_tokens"] += _safe_int(usage.get("input_tokens"))
+    metadata["total_output_tokens"] += _safe_int(usage.get("output_tokens"))
+    metadata["total_cache_read_tokens"] += _safe_int(usage.get("cache_read_input_tokens"))
+    metadata["total_cache_creation_tokens"] += _safe_int(usage.get("cache_creation_input_tokens"))
 
     # Extended cache metrics
     cache_creation = usage.get("cache_creation", {})
     if isinstance(cache_creation, dict):
-        metadata["total_ephemeral_5m_tokens"] += (
-            cache_creation.get("ephemeral_5m_input_tokens") or 0
+        metadata["total_ephemeral_5m_tokens"] += _safe_int(
+            cache_creation.get("ephemeral_5m_input_tokens")
         )
-        metadata["total_ephemeral_1h_tokens"] += (
-            cache_creation.get("ephemeral_1h_input_tokens") or 0
+        metadata["total_ephemeral_1h_tokens"] += _safe_int(
+            cache_creation.get("ephemeral_1h_input_tokens")
         )
 
     # Service tier
@@ -292,10 +302,10 @@ def _process_assistant(
             "is_sidechain": entry.get("isSidechain", False),
             "is_api_error": entry.get("isApiErrorMessage", False),
             "usage": {
-                "input_tokens": usage.get("input_tokens") or 0,
-                "output_tokens": usage.get("output_tokens") or 0,
-                "cache_read": usage.get("cache_read_input_tokens") or 0,
-                "cache_creation": usage.get("cache_creation_input_tokens") or 0,
+                "input_tokens": _safe_int(usage.get("input_tokens")),
+                "output_tokens": _safe_int(usage.get("output_tokens")),
+                "cache_read": _safe_int(usage.get("cache_read_input_tokens")),
+                "cache_creation": _safe_int(usage.get("cache_creation_input_tokens")),
                 "service_tier": usage.get("service_tier"),
             },
         }