cctally 1.28.0 → 1.30.0

package/bin/_lib_conversation_query.py

@@ -13,6 +13,7 @@ deduped session_entries row (idx_entries_dedup), via the shared pricing helper
 from __future__ import annotations
 import json as _json
 import os
+import re
 import sqlite3
 
 # Public surface (Plan 2): shipped in the npm tarball + brew formula + public
@@ -21,6 +22,75 @@ import sqlite3
 from _lib_pricing import _calculate_entry_cost
 
 
+# Mirror of dashboard/web/src/conversations/systemMarkers.ts::MARKER_RE — anchored
+# whole-string (fullmatch), unrolled-lazy body for linear time (no ReDoS), \1
+# backref forces each close tag to match its open tag. Used to SKIP slash-command
+# plumbing when deriving a conversation title (#165 Q2). MUST stay equivalent to
+# the TS predicate over ASCII whitespace (parity-tested); exotic Unicode/control
+# whitespace is an explicit non-goal. See docs/dashboard-gotchas.md.
+_MARKER_TAGS = ("command-name", "command-message", "command-args", "local-command-caveat")
+_MARKER_RE = re.compile(
+    r"\s*(?:<(" + "|".join(_MARKER_TAGS) + r")>(?:(?!</\1>)[\s\S])*</\1>\s*)+"
+)
+
+
+def _is_system_marker(text) -> bool:
+    """True iff `text` is ONLY concatenated command-marker wrappers (slash-command
+    plumbing) — the title-derivation skip predicate. `fullmatch` reproduces the TS
+    `^\\s*…\\s*$` anchor (no `$`-before-trailing-`\\n` foot-gun)."""
+    return bool(text) and _MARKER_RE.fullmatch(text) is not None
+
+
+_TITLE_MAX = 120
+
+
+def _title_from_text(text) -> str:
+    """First non-blank LINE of `text`, trimmed, sliced to _TITLE_MAX with a
+    trailing '…' ONLY when truncated (rstrip before the ellipsis). '' if none.
+    Semantics IDENTICAL to the client deriveReaderTitle (#165 P2.5)."""
+    for line in (text or "").split("\n"):
+        s = line.strip()
+        if s:
+            return (s[:_TITLE_MAX].rstrip() + "…") if len(s) > _TITLE_MAX else s
+    return ""
+
+
+def _session_titles_map(conn, session_ids):
+    """{sid: title} for the first non-marker, non-blank MAIN-session human line
+    per session (read-time, no migration). Windowed to the earliest 12 human
+    rows/session (rides idx_conv_session_ts); Python skips system markers. A
+    session whose first 12 human rows are all markers/blank is simply absent
+    (caller falls back). NOTE (Codex P1.2): the window ranks the full per-session
+    human partition before rn<=12 — confirmed index-ordered + bounded by the page
+    (≤200 sessions); per-session human counts are modest. If EXPLAIN QUERY PLAN
+    ever shows a temp B-tree sort here, switch to a per-session correlated
+    LIMIT 12 candidate fetch."""
+    if not session_ids:
+        return {}
+    titles = {}
+    ph = ",".join("?" for _ in session_ids)
+    rows = conn.execute(
+        "SELECT session_id, text FROM ("
+        "  SELECT session_id, text, "
+        "         ROW_NUMBER() OVER (PARTITION BY session_id "
+        "                            ORDER BY timestamp_utc, id) AS rn "
+        f"  FROM conversation_messages "
+        f"  WHERE session_id IN ({ph}) AND entry_type='human' "
+        "        AND is_sidechain=0 AND COALESCE(text,'') <> ''"
+        ") WHERE rn <= 12 ORDER BY session_id, rn",
+        tuple(session_ids),
+    ).fetchall()
+    for sid, text in rows:
+        if sid in titles:
+            continue                 # already resolved to the first non-marker
+        if _is_system_marker(text):
+            continue
+        t = _title_from_text(text)
+        if t:
+            titles[sid] = t
+    return titles
+
+
 def _project_label(cwd) -> str:
     """Basename of the project cwd (dashboard label posture — no reveal). Falls
     back to the raw path for root-ish cwds, '' when absent."""
@@ -29,6 +99,25 @@ def _project_label(cwd) -> str:
     return os.path.basename(cwd.rstrip("/")) or cwd
 
 
+def _subagent_key(source_path):
+    """Privacy-safe subagent-thread identity for the reader. Each subagent (Task)
+    invocation writes its own ``agent-<hash>.jsonl``; the main session is
+    ``<session_id>.jsonl``. Returns the agent hash (``agent-`` prefix + ``.jsonl``
+    suffix stripped; an ``acompact-`` middle is kept), or ``None`` for the main
+    file / a non-agent path. We expose ONLY this derived key — never the raw
+    absolute ``source_path`` (which leaks home dir / username / encoded project,
+    and the conversation routes are LAN-exposable via dashboard.expose_transcripts)."""
+    if not source_path:
+        return None
+    base = os.path.basename(source_path)
+    if not base.startswith("agent-"):
+        return None
+    stem = base[len("agent-"):]
+    if stem.endswith(".jsonl"):
+        stem = stem[: -len(".jsonl")]
+    return stem or None
+
+
 def _entry_cost(model, inp, out, cc, cr, cost_usd_raw) -> float:
     """Cost for one session_entries row via the shared pricing helper. Tokens →
     the helper's usage dict. cost_usd_raw is passed as the optional override the
@@ -136,9 +225,11 @@ def list_conversations(conn, *, sort="recent", limit=50, offset=0) -> dict:
     models = _session_models_map(conn, session_ids)
     # cwd/git_branch as the latest non-null (reader posture), NOT a lexical MAX().
     meta = _session_latest_meta_map(conn, session_ids)
+    titles = _session_titles_map(conn, session_ids)
     conversations = [
         {
             "session_id": sid,
+            "title": titles.get(sid) or _project_label(meta.get(sid, (None, None))[0]) or sid,
             "project_label": _project_label(meta.get(sid, (None, None))[0]),
             "git_branch": meta.get(sid, (None, None))[1],
             "started_utc": started,
@@ -198,7 +289,7 @@ def get_conversation(conn, session_id, *, after=None, limit=500):
     # uuid, so the first occurrence in ascending order is canonical.
     raw = conn.execute(
         "SELECT id, uuid, timestamp_utc, entry_type, text, blocks_json, model, "
-        "       msg_id, req_id, is_sidechain, cwd, git_branch "
+        "       msg_id, req_id, is_sidechain, cwd, git_branch, source_path, parent_uuid "
         "FROM conversation_messages WHERE session_id=? "
         "ORDER BY timestamp_utc, id", (session_id,)).fetchall()
 
@@ -220,21 +311,92 @@ def get_conversation(conn, session_id, *, after=None, limit=500):
     # item. A turn → exactly ONE item → cost counted exactly once. Humans,
     # tool_results, and assistant rows with a null msg_id emit as simple items at
     # their own position.
+    # ---- Phase 1: build items + index every assistant item's tool_use ids ----
+    # A tool_result is NOT guaranteed to sort after its tool_use (a grounded
+    # transcript scan found a matched result ordered BEFORE its use, plus orphan
+    # results with no in-session use), so this is a build-and-index-ALL pass
+    # FOLLOWED by a fold pass — never a single forward pass. None ids are never
+    # indexed (the id-less degradation guard).
     items = []
-    turn_index = {}        # (msg_id, req_id) -> index into items
+    turn_index = {}                # (msg_id, req_id) -> index into items
+    tooluse_index = {}             # tool_use id -> (item, block_dict)
+    tool_result_items = []         # placeholder items deferred to Phase 2
+
+    def _index_tool_uses(item):
+        # Index every tool_use id -> its (item, block). Idempotent: re-scanning
+        # a turn's blocks re-maps the same id to the same (item, block). Anthropic
+        # tool_use ids are unique within a session; a collision would be
+        # last-writer-wins (a result then folds to one deterministic owner).
+        for b in item["blocks"]:
+            if b.get("kind") == "tool_use" and b.get("id") is not None:
+                tooluse_index[b["id"]] = (item, b)
+
     for row in logical:
         (rid, u, ts, etype, text, blocks, model, msg_id, req_id,
-         is_sc, cwd, branch) = row
+         is_sc, cwd, branch, source_path, parent_uuid) = row
         if etype == "assistant" and msg_id is not None:
             key = (msg_id, req_id)
             idx = turn_index.get(key)
             if idx is None:
                 turn_index[key] = len(items)
-                items.append(_build_turn([row]))
+                it = _build_turn([row])
+                items.append(it)
+                _index_tool_uses(it)
             else:
                 _extend_turn(items[idx], row)
+                _index_tool_uses(items[idx])     # re-index the turn (idempotent; new fragment may add ids)
+        elif etype == "tool_result":
+            it = _build_simple(row)
+            items.append(it)
+            tool_result_items.append(it)
         else:
-            items.append(_build_simple(row))
+            it = _build_simple(row)
+            items.append(it)
+            if etype == "assistant":             # null-msg_id assistant: index its uses too
+                _index_tool_uses(it)
+
+    # ---- Phase 2: fold each tool_result item into its owning assistant item ----
+    drop = set()                                 # id() of folded placeholder items
+    for tr in tool_result_items:
+        tr_blocks = [b for b in tr["blocks"] if b.get("kind") == "tool_result"]
+        non_result = [b for b in tr["blocks"] if b.get("kind") != "tool_result"]
+        owners = []
+        resolved = []
+        for b in tr_blocks:
+            tid = b.get("tool_use_id")
+            hit = tooluse_index.get(tid) if tid is not None else None
+            if hit is None:
+                owners = None                    # an unresolved block -> keep standalone
+                break
+            owners.append(hit[0])
+            resolved.append((hit[1], b))
+        # fold iff every result block resolved to exactly ONE owning item, no leftovers
+        owner_ids = {id(o) for o in owners} if owners is not None else set()
+        if owners and not non_result and len(owner_ids) == 1:
+            owner = owners[0]
+            for use_block, res_block in resolved:
+                use_block["result"] = {"text": res_block.get("text", ""),
+                                       "truncated": bool(res_block.get("truncated")),
+                                       "is_error": bool(res_block.get("is_error"))}
+            owner["member_uuids"].append(tr["anchor"]["uuid"])
+            drop.add(id(tr))
+        # else: leave tr standalone (orphan / multi-owner / mixed) — a folded
+        # row's uuid then joins EXACTLY ONE item's member_uuids (the #160 anchor).
+
+    if drop:
+        items = [it for it in items if id(it) not in drop]
+
+    # ---- Phase 3: sweep every assistant item's tool_use -> tool_call ----
+    # Covers turn items AND _build_simple null-msg_id assistant items. Matched
+    # requests already carry `result`; unmatched get `result: None`
+    # (request-only). Post-migration the client never receives a bare tool_use.
+    for it in items:
+        if it["kind"] == "assistant":
+            for b in it["blocks"]:
+                if b.get("kind") == "tool_use":
+                    b["kind"] = "tool_call"
+                    b["tool_use_id"] = b.pop("id", None)
+                    b.setdefault("result", None)
 
     costs = _turn_cost_map(conn, list(turn_index))
     # Stamp per-item cost first, then derive the header from the SUM of the
@@ -327,6 +489,12 @@ def _build_turn(members):
         "blocks": [],
         "model": first[6],
         "is_sidechain": bool(first[9]),
+        # subagent_key / parent_uuid are SEED-sourced (the first fragment, the
+        # turn's entry point) and NOT re-promoted in _fold_fragment — the prose
+        # anchor's parent_uuid is an intra-turn link, not the entry point (Codex
+        # P1). subagent_key is uniform across a turn's fragments (one file).
+        "subagent_key": _subagent_key(first[12]),
+        "parent_uuid": first[13],
         "_msg_id": first[7],
         "_req_id": first[8],
         "_has_prose": False,
@@ -374,7 +542,8 @@ def _build_simple(row):
     key → no session_entries join); it carries an explicit cost_usd of 0.0 and NO
     internal _msg_id/_req_id keys, so the cost loop's KeyError path can never fire
     (I2). The model is preserved for assistant rows."""
-    (rid, u, ts, etype, text, blocks, model, msg_id, req_id, is_sc, cwd, branch) = row
+    (rid, u, ts, etype, text, blocks, model, msg_id, req_id, is_sc, cwd, branch,
+     source_path, parent_uuid) = row
     try:
         parsed = _json.loads(blocks or "[]")
     except (ValueError, TypeError):
@@ -387,6 +556,8 @@ def _build_simple(row):
         "text": text,
         "blocks": parsed,
         "is_sidechain": bool(is_sc),
+        "subagent_key": _subagent_key(source_path),
+        "parent_uuid": parent_uuid,
     }
     if etype == "assistant":
         item["model"] = model
@@ -440,19 +611,6 @@ def _row_to_hit(uuid_, sid, ts, cwd, snippet, msg_id, req_id):
     }
 
 
-def _dedup_hits(hits, limit, offset):
-    seen = set()
-    out = []
-    for h in hits:
-        key = (h["session_id"], h["uuid"])
-        if key in seen:
-            continue
-        seen.add(key)
-        out.append(h)
-    total = len(out)
-    return out[offset:offset + limit], total
-
-
 def _attach_costs(conn, page):
     """Compute turn cost for the FINAL page's hits in ONE _turn_cost_map call,
     then map it onto each hit and drop the private `_turn_key`. Off-page and
@@ -465,45 +623,141 @@ def _attach_costs(conn, page):
     return page
 
 
-def _search_fts(conn, q, limit, offset):
-    sql = (
-        "SELECT cm.session_id, cm.uuid, cm.timestamp_utc, cm.cwd, "
-        "       cm.msg_id, cm.req_id, "
-        "       snippet(conversation_fts, 0, '[', ']', ' … ', 12) AS snip "
+def _attach_titles(conn, page):
+    """Stamp each final-page hit with its session's derived title — ONE batched
+    _session_titles_map over the distinct page session_ids (parallel to
+    _attach_costs). Fallback project_label → session_id, matching
+    list_conversations (#165 Q4)."""
+    sids = list({h["session_id"] for h in page})
+    titles = _session_titles_map(conn, sids)
+    for h in page:
+        sid = h["session_id"]
+        h["title"] = titles.get(sid) or h.get("project_label") or sid
+    return page
+
+
+def _like_pattern(q):
+    """Build the LIKE pattern for `q`. Escape the ESCAPE char (\\) FIRST, then
+    the wildcards — otherwise a query containing a backslash (incl. a trailing
+    one) mis-escapes the appended '%' and the LIKE silently matches nothing
+    (paired with ESCAPE '\\' in the queries below)."""
+    return ("%" + q.replace("\\", "\\\\").replace("%", r"\%").replace("_", r"\_")
+            + "%")
+
+
+def _fts_snippets(conn, fts_q, ids):
+    """{rowid: snippet} for the page rowids ONLY (#149). snippet() needs an
+    active MATCH, so it can't be deferred to an outer query over the page CTE;
+    a second bounded MATCH restricted to the page rowids generates snippets for
+    at most one page of hits instead of every corpus match."""
+    if not ids:
+        return {}
+    ph = ",".join("?" for _ in ids)
+    rows = conn.execute(
+        "SELECT cm.id, snippet(conversation_fts, 0, '[', ']', ' … ', 12) "
         "FROM conversation_fts "
         "JOIN conversation_messages cm ON cm.id = conversation_fts.rowid "
-        "WHERE conversation_fts MATCH ? "
-        # cm.id is the final tiebreaker so equal (rank, timestamp) hits order
-        # deterministically — _dedup_hits keeps the FIRST occurrence, so without
-        # it the surviving snippet/cost (and page boundary) would flip run-to-run.
-        "ORDER BY bm25(conversation_fts), cm.timestamp_utc DESC, cm.id DESC"
-    )
-    raw = conn.execute(sql, (_fts_query(q),)).fetchall()
-    hits = [_row_to_hit(u, sid, ts, cwd, snip, mid, rqd)
-            for (sid, u, ts, cwd, mid, rqd, snip) in raw]
-    page, total = _dedup_hits(hits, limit, offset)
-    return {"query": q, "mode": "fts", "hits": _attach_costs(conn, page),
+        f"WHERE conversation_fts MATCH ? AND cm.id IN ({ph})",
+        (fts_q, *ids),
+    ).fetchall()
+    return {r[0]: r[1] for r in rows}
+
+
+def _texts_for_ids(conn, ids):
+    """{rowid: text} for the page rowids ONLY (#149) — the LIKE page query omits
+    `text` so we never pull every matched row's body into Python; this fetches
+    it for just the page so `_manual_snippet` runs at most `limit` times."""
+    if not ids:
+        return {}
+    ph = ",".join("?" for _ in ids)
+    rows = conn.execute(
+        f"SELECT id, text FROM conversation_messages WHERE id IN ({ph})",
+        tuple(ids),
+    ).fetchall()
+    return {r[0]: r[1] for r in rows}
+
+
+def _search_fts(conn, q, limit, offset):
+    # All of dedup + paging + total live in SQL (#149) so Python never holds
+    # more than one page of hits/snippets, regardless of corpus match count.
+    fts_q = _fts_query(q)
+    # Exact post-dedup logical total — counted in C with no snippet generation
+    # and no Python row materialization.
+    total = conn.execute(
+        "SELECT COUNT(*) FROM ("
+        "  SELECT DISTINCT cm.session_id, cm.uuid "
+        "  FROM conversation_fts "
+        "  JOIN conversation_messages cm ON cm.id = conversation_fts.rowid "
+        "  WHERE conversation_fts MATCH ?)",
+        (fts_q,),
+    ).fetchone()[0]
+    # One row per logical (session_id, uuid): ROW_NUMBER()=1 keeps the SAME row
+    # the old Python dedup kept as its FIRST occurrence (order: bm25, ts DESC,
+    # id DESC — cm.id is the final deterministic tiebreaker), so the surviving
+    # snippet/cost and the page boundary stay byte-stable. bm25 still ranks
+    # across all matches (inherent to relevance ordering).
+    #
+    # bm25 is materialized as a plain `rank` column in the inner `matched` CTE
+    # before the window function runs: FTS5 auxiliary functions (bm25/snippet)
+    # may only be used directly against the MATCH query, NOT inside a window
+    # ORDER BY ("unable to use function bm25 in the requested context").
+    page = conn.execute(
+        "WITH matched AS ("
+        "  SELECT cm.id AS rid, cm.session_id AS sid, cm.uuid AS uuid, "
+        "         cm.timestamp_utc AS ts, cm.cwd AS cwd, "
+        "         cm.msg_id AS mid, cm.req_id AS rqd, "
+        "         bm25(conversation_fts) AS rank "
+        "  FROM conversation_fts "
+        "  JOIN conversation_messages cm ON cm.id = conversation_fts.rowid "
+        "  WHERE conversation_fts MATCH ?), "
+        "ranked AS ("
+        "  SELECT *, ROW_NUMBER() OVER ("
+        "             PARTITION BY sid, uuid ORDER BY rank, ts DESC, rid DESC"
+        "           ) AS rn "
+        "  FROM matched) "
+        "SELECT rid, sid, uuid, ts, cwd, mid, rqd FROM ranked WHERE rn = 1 "
+        "ORDER BY rank, ts DESC, rid DESC LIMIT ? OFFSET ?",
+        (fts_q, limit, offset),
+    ).fetchall()
+    snips = _fts_snippets(conn, fts_q, [r[0] for r in page])
+    hits = [_row_to_hit(uuid, sid, ts, cwd, snips.get(rid, ""), mid, rqd)
+            for (rid, sid, uuid, ts, cwd, mid, rqd) in page]
+    return {"query": q, "mode": "fts",
+            "hits": _attach_titles(conn, _attach_costs(conn, hits)),
             "total": total}
 
 
 def _search_like(conn, q, limit, offset):
-    # Escape the ESCAPE char (\) FIRST, then the wildcards — otherwise a query
-    # containing a backslash (incl. a trailing one) mis-escapes the appended
-    # '%' and the LIKE silently matches nothing (ESCAPE '\' below).
-    like = ("%" + q.replace("\\", "\\\\").replace("%", r"\%").replace("_", r"\_")
-            + "%")
-    sql = (
-        "SELECT session_id, uuid, timestamp_utc, cwd, msg_id, req_id, text "
-        "FROM conversation_messages "
-        "WHERE text LIKE ? ESCAPE '\\' AND text != '' "
-        "ORDER BY timestamp_utc DESC, id DESC"
-    )
-    hits = []
-    for sid, u, ts, cwd, mid, rqd, text in conn.execute(sql, (like,)):
-        hits.append(_row_to_hit(u, sid, ts, cwd,
-                                _manual_snippet(text, q), mid, rqd))
-    page, total = _dedup_hits(hits, limit, offset)
-    return {"query": q, "mode": "like", "hits": _attach_costs(conn, page),
+    # SQL-bounded mirror of _search_fts for the no-FTS5 fallback (#149); the
+    # COUNT + page each scan the table once (the degraded path already lacks an
+    # index for the substring match).
+    like = _like_pattern(q)
+    total = conn.execute(
+        "SELECT COUNT(*) FROM ("
+        "  SELECT DISTINCT session_id, uuid FROM conversation_messages "
+        "  WHERE text LIKE ? ESCAPE '\\' AND text != '')",
+        (like,),
+    ).fetchone()[0]
+    page = conn.execute(
+        "WITH ranked AS ("
+        "  SELECT id AS rid, session_id AS sid, uuid AS uuid, "
+        "         timestamp_utc AS ts, cwd AS cwd, msg_id AS mid, req_id AS rqd, "
+        "         ROW_NUMBER() OVER ("
+        "           PARTITION BY session_id, uuid "
+        "           ORDER BY timestamp_utc DESC, id DESC"
+        "         ) AS rn "
+        "  FROM conversation_messages "
+        "  WHERE text LIKE ? ESCAPE '\\' AND text != '') "
+        "SELECT rid, sid, uuid, ts, cwd, mid, rqd FROM ranked WHERE rn = 1 "
+        "ORDER BY ts DESC, rid DESC LIMIT ? OFFSET ?",
+        (like, limit, offset),
+    ).fetchall()
+    texts = _texts_for_ids(conn, [r[0] for r in page])
+    hits = [_row_to_hit(uuid, sid, ts, cwd,
+                        _manual_snippet(texts.get(rid, ""), q), mid, rqd)
+            for (rid, sid, uuid, ts, cwd, mid, rqd) in page]
+    return {"query": q, "mode": "like",
+            "hits": _attach_titles(conn, _attach_costs(conn, hits)),
             "total": total}
 
 

package/bin/_lib_jsonl.py

@@ -201,6 +201,68 @@ def _parse_usage_entries(
     return no_key_entries
 
 
+def parse_cost_entry(obj, path_str: str):
+    """Pure per-line cost parser: given a parsed JSONL object, return
+    ``(UsageEntry, msg_id, req_id)`` when it is a billable assistant entry, or
+    ``None`` otherwise (non-assistant, missing/invalid usage, model, or
+    timestamp, or a ``<synthetic>`` placeholder). No I/O, no byte offset — the
+    caller owns the readline()+tell() loop.
+
+    Extracted (#138) so the streaming ``_iter_jsonl_entries_with_offsets`` reader
+    and the fused single-pass sync walker (``_cctally_cache._iter_sync_entries``)
+    share ONE gating implementation — each JSONL line is ``json.loads``-parsed
+    once and classified once, never re-parsed for a separate second walk.
+    """
+    if obj.get("type") != "assistant":
+        return None
+
+    ts_raw = obj.get("timestamp")
+    if not isinstance(ts_raw, str) or not ts_raw.strip():
+        return None
+
+    msg = obj.get("message")
+    if not isinstance(msg, dict):
+        msg = obj
+
+    usage = msg.get("usage")
+    if not isinstance(usage, dict):
+        return None
+
+    model = msg.get("model") or obj.get("model")
+    if not isinstance(model, str) or not model.strip():
+        return None
+    model = model.strip()
+    if model == "<synthetic>":
+        # Matches ccusage's claude_loader.rs:454. Filtered here so the cache
+        # ingest path can't accidentally store these rows even if a downstream
+        # loop forgets to double-check (see `sync_cache` in _cctally_cache.py).
+        return None
+
+    try:
+        ts = dt.datetime.fromisoformat(ts_raw.strip().replace("Z", "+00:00"))
+        if ts.tzinfo is None:
+            ts = ts.replace(tzinfo=dt.timezone.utc)
+    except ValueError:
+        return None
+
+    msg_id = msg.get("id")
+    req_id = obj.get("requestId")
+    cost_usd_raw = obj.get("costUSD")
+    cost_usd = float(cost_usd_raw) if cost_usd_raw is not None else None
+
+    return (
+        UsageEntry(
+            timestamp=ts,
+            model=model,
+            usage=usage,
+            cost_usd=cost_usd,
+            source_path=path_str,
+        ),
+        msg_id,
+        req_id,
+    )
+
+
 def _iter_jsonl_entries_with_offsets(fh, path_str: str):
     """Yield (byte_offset, UsageEntry, msg_id, req_id) for each assistant
     entry starting from fh's current position.
@@ -209,7 +271,9 @@ def _iter_jsonl_entries_with_offsets(fh, path_str: str):
     accurate for resume-from-offset after partial ingests. Malformed JSON
     and non-assistant lines are skipped, but the offset still advances past
     them so they are never re-read. Range filtering is intentionally NOT
-    done here — filters are applied at query time by iter_entries().
+    done here — filters are applied at query time by iter_entries(). The
+    per-line gating lives in ``parse_cost_entry`` (shared with the fused
+    single-pass sync walker, #138).
     """
     while True:
         offset = fh.tell()
@@ -230,56 +294,11 @@ def _iter_jsonl_entries_with_offsets(fh, path_str: str):
             obj = json.loads(stripped)
         except json.JSONDecodeError:
             continue
-        if obj.get("type") != "assistant":
-            continue
-
-        ts_raw = obj.get("timestamp")
-        if not isinstance(ts_raw, str) or not ts_raw.strip():
-            continue
-
-        msg = obj.get("message")
-        if not isinstance(msg, dict):
-            msg = obj
-
-        usage = msg.get("usage")
-        if not isinstance(usage, dict):
-            continue
-
-        model = msg.get("model") or obj.get("model")
-        if not isinstance(model, str) or not model.strip():
+        parsed = parse_cost_entry(obj, path_str)
+        if parsed is None:
             continue
-        model = model.strip()
-        if model == "<synthetic>":
-            # Matches ccusage's claude_loader.rs:454. Filtered at the
-            # iterator level so the cache ingest path can't accidentally
-            # store these rows even if a downstream loop forgets to
-            # double-check (see `sync_cache` in _cctally_cache.py).
-            continue
-
-        try:
-            ts = dt.datetime.fromisoformat(ts_raw.strip().replace("Z", "+00:00"))
-            if ts.tzinfo is None:
-                ts = ts.replace(tzinfo=dt.timezone.utc)
-        except ValueError:
-            continue
-
-        msg_id = msg.get("id")
-        req_id = obj.get("requestId")
-        cost_usd_raw = obj.get("costUSD")
-        cost_usd = float(cost_usd_raw) if cost_usd_raw is not None else None
-
-        yield (
-            offset,
-            UsageEntry(
-                timestamp=ts,
-                model=model,
-                usage=usage,
-                cost_usd=cost_usd,
-                source_path=path_str,
-            ),
-            msg_id,
-            req_id,
-        )
+        entry, msg_id, req_id = parsed
+        yield (offset, entry, msg_id, req_id)
 
 
 _CODEX_FILENAME_UUID_RE = re.compile(

package/bin/cctally

@@ -2100,18 +2100,18 @@ get_max_milestone_for_week          = _cctally_milestones.get_max_milestone_for_
 get_milestone_cost_for_week         = _cctally_milestones.get_milestone_cost_for_week         # record shim
 get_milestones_for_week             = _cctally_milestones.get_milestones_for_week             # forecast c.; tui shim; percent-breakdown c.
 insert_percent_milestone            = _cctally_milestones.insert_percent_milestone            # record shim; idempotency-test mod.
-insert_budget_milestone             = _cctally_milestones.insert_budget_milestone             # record shim
+insert_budget_milestone             = _cctally_milestones.insert_budget_milestone             # record shim; test_budget_alerts / test_project_budget_dashboard ns[] (+ test_codex_budget_alerts / test_projected_alerts post-#143 vendor-param unification)
 insert_project_budget_milestone     = _cctally_milestones.insert_project_budget_milestone     # record shim; project-budget-config-test ns[]
-insert_codex_budget_milestone       = _cctally_milestones.insert_codex_budget_milestone       # record shim; test_codex_budget_alerts ns[]
-_codex_budget_crossings             = _cctally_milestones._codex_budget_crossings             # record shim (shared INSERT-and-arm core for the codex_budget axis)
+_budget_crossings                   = _cctally_milestones._budget_crossings                   # record shim (shared INSERT-and-arm core for the budget axis, both vendors, #143)
 _resolve_codex_budget_period_window = _cctally_milestones._resolve_codex_budget_period_window # record shim; milestones c. (codex period window)
-_reconcile_codex_budget_milestones_on_set = _cctally_milestones._reconcile_codex_budget_milestones_on_set  # test_codex_budget_alerts ns[]; forecast set/reconcile
+_resolve_budget_window              = _cctally_milestones._resolve_budget_window              # record shim; milestones c. (per-vendor cheap budget window dispatcher, #143)
+_budget_spend_for_vendor            = _cctally_milestones._budget_spend_for_vendor            # record shim; milestones c. (per-vendor budget spend dispatcher, #143)
 _reconcile_codex_budget_on_config_write = _cctally_milestones._reconcile_codex_budget_on_config_write  # forecast/config c. (forward-only codex-budget reconcile)
 _resolve_claude_budget_window       = _cctally_milestones._resolve_claude_budget_window       # record shim; milestones c. (period-aware Claude budget window)
 _project_crossings                  = _cctally_milestones._project_crossings                  # record shim; milestones c. (#130 firing/reconcile shared crossing arithmetic)
 insert_projected_milestone          = _cctally_milestones.insert_projected_milestone          # record shim
 _projected_levels_already_latched   = _cctally_milestones._projected_levels_already_latched   # record shim
-_reconcile_budget_milestones_on_set = _cctally_milestones._reconcile_budget_milestones_on_set # test_budget_alerts ns[]
+_reconcile_budget_milestones_on_set = _cctally_milestones._reconcile_budget_milestones_on_set # test_budget_alerts / test_codex_budget_alerts ns[] (vendor-param, #143)
 _reconcile_budget_on_config_write   = _cctally_milestones._reconcile_budget_on_config_write   # forecast/config/dashboard c.; test_forecast_ns_patch mod. patch
 _reconcile_project_budget_milestones_on_write = _cctally_milestones._reconcile_project_budget_milestones_on_write  # forecast/config/dashboard c. (forward-only project-budget reconcile)