cc-transcript 14.35.0__tar.gz → 14.37.0__tar.gz

{cc_transcript-14.35.0 → cc_transcript-14.37.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-transcript
-Version: 14.35.0
+Version: 14.37.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -18,7 +18,7 @@ Requires-Dist: ruff>=0.8 ; extra == 'dev'
 Requires-Dist: sqlite-vec>=0.1.9 ; extra == 'judge'
 Requires-Dist: model2vec>=0.8.2 ; extra == 'judge'
 Requires-Dist: numpy>=1.26 ; extra == 'judge'
-Requires-Dist: spawnllm>=0.5.4,<0.6 ; extra == 'llm'
+Requires-Dist: spawnllm>=0.17.1,<0.18 ; extra == 'llm'
 Provides-Extra: dev
 Provides-Extra: judge
 Provides-Extra: llm

{cc_transcript-14.35.0 → cc_transcript-14.37.0}/cc_transcript/extract/correct.py

@@ -3,11 +3,12 @@
 :func:`extract_correction` harvests the candidate incorrect edits around a
 feedback anchor (deterministically, via :mod:`cc_transcript.evidence`), then picks
 the single edit the feedback faults and appends that one row to the shared
-ledger. The pick is an LLM call by default — lifted from cc-steer's enrich
-prompt — and degrades to the best-overlap candidate when no LLM backend is ready
-(:func:`usable_backend` returns None). The pick keys to the candidate's index, so
-the row carries the real cross-language ``incorrect_digest`` from the harvested
-tool call, never reconstructed content.
+ledger. The pick is a Jev label decision by default; when Jev errors or refuses
+it falls back to an LLM call — lifted from cc-steer's enrich prompt — and to the
+best-overlap candidate when no LLM backend is ready either (:func:`usable_backend`
+returns None). The pick keys to the candidate's index, so the row carries the
+real cross-language ``incorrect_digest`` from the harvested tool call, never
+reconstructed content.
 
 Behind the ``[llm]`` extra: this module imports pydantic at definition time and
 ``spawnllm`` lazily, so only LLM-capable consumers import it. A hook that merely
@@ -29,7 +30,7 @@ if TYPE_CHECKING:
     from collections.abc import Sequence
     from pathlib import Path
 
-    from spawnllm import LlmBackend, TModel
+    from spawnllm import Label, LlmBackend, TModel
 
     from cc_transcript.activity import SessionActivity
     from cc_transcript.corrections import Correction, CorrectionLog
@@ -38,6 +39,13 @@ if TYPE_CHECKING:
     from cc_transcript.tools import Hunk
 
 HUNK_BUDGET = Budget(tool_chars=600)
+NO_CANDIDATE = "none"
+
+PICK_QUESTION = """\
+Which single candidate edit does the developer FEEDBACK fault? The candidates are edits an AI coding \
+assistant made shortly before the feedback, newest first, each with the correction that later overwrote \
+it when one was found; the correction ranked most likely by content overlap is tagged [likely fix]. \
+Answer none when the feedback faults the approach, a command, or work outside these edits."""
 
 PICK_PROMPT = """\
 You are grounding one piece of developer FEEDBACK on an AI coding assistant's work
@@ -107,17 +115,37 @@ def candidate_block(index: int, pair: CandidatePair, *, anchor_turn: int, likely
     )
 
 
-def build_pick_prompt(feedback: str, pairs: Sequence[CandidatePair], *, anchor_turn: int) -> str:
+def candidate_blocks(pairs: Sequence[CandidatePair], *, anchor_turn: int) -> str:
     likely = likely_fix(pairs)
-    return PICK_PROMPT.format(
-        candidates="\n\n".join(
-            candidate_block(index, pair, anchor_turn=anchor_turn, likely=pair is likely)
-            for index, pair in enumerate(pairs, 1)
-        ),
-        feedback=feedback,
+    return "\n\n".join(
+        candidate_block(index, pair, anchor_turn=anchor_turn, likely=pair is likely)
+        for index, pair in enumerate(pairs, 1)
+    )
+
+
+def build_pick_prompt(feedback: str, pairs: Sequence[CandidatePair], *, anchor_turn: int) -> str:
+    return PICK_PROMPT.format(candidates=candidate_blocks(pairs, anchor_turn=anchor_turn), feedback=feedback)
+
+
+def pick_label(pairs: Sequence[CandidatePair]) -> Label:
+    from spawnllm import Label
+
+    return Label(
+        PICK_QUESTION,
+        {
+            NO_CANDIDATE: "The feedback is not about any of these edits",
+            **{
+                str(index): f"candidate {index}: {pair.incorrect.file_path} ({pair.incorrect.tool})"
+                for index, pair in enumerate(pairs, 1)
+            },
+        },
     )
 
 
+def pair_for(choice: str, pairs: Sequence[CandidatePair]) -> CandidatePair | None:
+    return None if choice == NO_CANDIDATE else pairs[int(choice) - 1]
+
+
 def usable_backend() -> LlmBackend | None:
     """The first ready spawnllm backend for the ``review`` specialty, or None when none is ready.
 
@@ -132,11 +160,27 @@ def usable_backend() -> LlmBackend | None:
         return None
 
 
+async def jev_choice(pairs: Sequence[CandidatePair], *, feedback: str, anchor_turn: int) -> str | None:
+    from spawnllm import DecideError, DecideKeyMissing, LabelAnswer, decide
+
+    try:
+        decision = await decide(
+            {"candidate_edits": candidate_blocks(pairs, anchor_turn=anchor_turn), "feedback": feedback},
+            {"pick": pick_label(pairs)},
+        )
+    except (DecideError, DecideKeyMissing, TimeoutError):
+        return None
+    answer = decision.answers["pick"]
+    return answer.choice if isinstance(answer, LabelAnswer) else None
+
+
 async def choose_pair(
     pairs: Sequence[CandidatePair], *, feedback: str, anchor_turn: int, tier: TModel, backend: LlmBackend | None
 ) -> CandidatePair | None:
     from spawnllm import extract
 
+    if (choice := await jev_choice(pairs, feedback=feedback, anchor_turn=anchor_turn)) is not None:
+        return pair_for(choice, pairs)
     if backend is None:
         return max(pairs, key=lambda pair: pair.overlap)
     pick = await extract(
@@ -158,9 +202,10 @@ async def extract_correction(
 ) -> Correction | None:
     """Harvests around ``anchor`` and appends the one correction ``feedback`` faults.
 
-    The faulted candidate is the LLM's pick when ``backend`` is given, else the
-    best-overlap candidate. Idempotent per anchor: a no-op when this anchor
-    already has a row, so re-runs and overlapping producers never duplicate.
+    The faulted candidate is Jev's pick; when Jev errors or refuses, it is the
+    LLM's pick when ``backend`` is given, else the best-overlap candidate.
+    Idempotent per anchor: a no-op when this anchor already has a row, so
+    re-runs and overlapping producers never duplicate.
     Returns the appended correction, or None when nothing is harvested or picked.
     """
     if await log.for_anchor(anchor.session_id, anchor.event_uuid):

{cc_transcript-14.35.0 → cc_transcript-14.37.0}/cc_transcript/snapshot_schema/config.schema.json

@@ -81,6 +81,7 @@
     },
     "max_retained_bytes": {
       "default": 1073741824,
+      "description": "Hard cap on retained accounted bytes. It must be at least the store's startup footprint (the pre-sized delivery and expired-query tables plus the default tool registries); a smaller value is rejected as an invalid configuration. Background admissions are capped at max_retained_bytes - reserved_hook_accounted_bytes, so a footprint above that difference refuses every background admission while foreground hook admissions proceed.",
       "exclusiveMinimum": 0,
       "maximum": 9007199254740991,
       "title": "Max Retained Bytes",

{cc_transcript-14.35.0 → cc_transcript-14.37.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "14.35.0" # informational — releases stamp the version from the git tag
+version = "14.37.0" # informational — releases stamp the version from the git tag
 description = "Grep every Claude Code session you've ever run."
 readme = "README.md"
 license = "PolyForm-Noncommercial-1.0.0"
@@ -41,7 +41,7 @@ dev = [
     "ty>=0.0.44",
     "ruff>=0.8",
 ]
-llm = ["spawnllm>=0.5.4,<0.6"]
+llm = ["spawnllm>=0.17.1,<0.18"]
 judge = [
     "sqlite-vec>=0.1.9",
     "model2vec>=0.8.2",

{cc_transcript-14.35.0 → cc_transcript-14.37.0}/rust/crates/core/src/codex/lower.rs

@@ -9,6 +9,7 @@ use crate::codex::types::{
     CodexEntry, CodexItem, CodexSession, EventMsg, ResponseItem, ResponseItemPayload,
 };
 use crate::pystr;
+use crate::snapshot_memory::{pins_arena, SourceArena};
 use crate::types::{
     AssistantEntry, ContentBlock, Entry, EntryMeta, OtherEntry, ToolResultBlock, ToolUseBlock,
     UserContent, UserEntry,
@@ -547,15 +548,17 @@ fn payload_tag(payload: &ResponseItemPayload) -> &str {
 }
 
 fn payload_raw(payload: &ResponseItemPayload) -> Value {
+    payload_dom(payload).cloned().unwrap_or_default()
+}
+
+fn payload_dom(payload: &ResponseItemPayload) -> Option<&Value> {
     use ResponseItemPayload as R;
     match payload {
-        R::ToolSearchCall { arguments, .. } => arguments.clone(),
-        R::LocalShellCall { action, .. } | R::WebSearchCall { action, .. } => {
-            action.clone().unwrap_or_default()
-        }
-        R::GhostSnapshot(v) => v.clone(),
-        R::Other { raw, .. } => raw.clone(),
-        _ => Value::default(),
+        R::ToolSearchCall { arguments, .. } => Some(arguments),
+        R::LocalShellCall { action, .. } | R::WebSearchCall { action, .. } => action.as_ref(),
+        R::GhostSnapshot(v) => Some(v),
+        R::Other { raw, .. } => Some(raw),
+        _ => None,
     }
 }
 
@@ -592,6 +595,10 @@ fn event_tag(em: &EventMsg) -> &str {
 }
 
 fn event_raw(em: &EventMsg) -> Value {
+    event_dom(em).cloned().unwrap_or_default()
+}
+
+fn event_dom(em: &EventMsg) -> Option<&Value> {
     use EventMsg as E;
     match em {
         E::ExecCommandEnd(v)
@@ -607,11 +614,75 @@ fn event_raw(em: &EventMsg) -> Value {
         | E::CollabAgentSpawnEnd(v)
         | E::CollabWaitingEnd(v)
         | E::CollabCloseEnd(v)
-        | E::Other { raw: v, .. } => v.clone(),
-        _ => Value::default(),
+        | E::Other { raw: v, .. } => Some(v),
+        _ => None,
+    }
+}
+
+pub(crate) fn line_dom(item: &CodexItem) -> Option<&Value> {
+    use ResponseItemPayload as R;
+    match item {
+        CodexItem::SessionMeta(m) => Some(&m.raw),
+        CodexItem::TurnContext(v) => Some(v),
+        CodexItem::WorldState(w) => Some(&w.state),
+        CodexItem::ResponseItem(ri) => match &ri.payload {
+            R::FunctionCallOutput { output, .. } | R::CustomToolCallOutput { output, .. } => {
+                Some(output)
+            }
+            payload => payload_dom(payload),
+        },
+        CodexItem::EventMsg(em) => event_dom(em),
+        CodexItem::Compacted(_)
+        | CodexItem::InterAgentCommunicationMetadata { .. }
+        | CodexItem::Other(_) => None,
+    }
+}
+
+fn retains_line(entry: &Entry) -> bool {
+    match entry {
+        Entry::Other(other) => pins_arena(&other.raw),
+        _ => entry
+            .tool_results()
+            .any(|result| result.tool_use_result.as_ref().is_some_and(pins_arena)),
+    }
+}
+
+fn lowered_arenas(source: &CodexEntry, entry: &Entry) -> Vec<SourceArena> {
+    match (&source.item, entry) {
+        (CodexItem::Other(other), Entry::Other(lowered)) => pins_arena(&lowered.raw)
+            .then(|| SourceArena {
+                root: lowered.raw.clone(),
+                source_len: other.raw.len(),
+            })
+            .into_iter()
+            .collect(),
+        _ => source
+            .source
+            .iter()
+            .filter(|_| retains_line(entry))
+            .cloned()
+            .collect(),
     }
 }
 
+pub(crate) fn session_arenas(
+    session: &CodexSession,
+    entries: &[Entry],
+) -> Vec<(usize, SourceArena)> {
+    assert_eq!(session.entries.len(), entries.len());
+    session
+        .entries
+        .iter()
+        .zip(entries)
+        .enumerate()
+        .flat_map(|(index, (source, entry))| {
+            lowered_arenas(source, entry)
+                .into_iter()
+                .map(move |arena| (index, arena))
+        })
+        .collect()
+}
+
 #[cfg(test)]
 mod tests {
     use std::collections::HashSet;
@@ -1339,4 +1410,44 @@ mod tests {
             "050b lifted turns must expose the interrupted user entry"
         );
     }
+
+    #[test]
+    fn lowered_entries_record_the_arenas_they_keep() {
+        let lines = [
+            r#"{"timestamp":"2026-07-19T00:00:00Z","type":"response_item","payload":{"type":"function_call_output","call_id":"c","output":{"stdout":"x"}}}"#,
+            r#"{"timestamp":"2026-07-19T00:00:01Z","type":"response_item","payload":{"type":"function_call","call_id":"c","name":"exec","arguments":"{}"}}"#,
+            r#"{"timestamp":"2026-07-19T00:00:02Z","type":"event_msg","payload":{"type":"task_started","turn_id":"t"}}"#,
+            r#"{"timestamp":"2026-07-19T00:00:03Z","type":"turn_context","payload":{"cwd":"/w","model":"m"}}"#,
+            r#"{"timestamp":"2026-07-19T00:00:04Z","type":"mystery","payload":{"k":1}}"#,
+            r#"{"timestamp":"2026-07-19T00:00:05Z","type":"response_item","payload":{"type":"function_call_output","call_id":"d","output":"plain"}}"#,
+        ];
+        let session = parse_codex_bytes(lines.join("\n").as_bytes());
+        let entries = lower(&session).entries;
+        assert_eq!(
+            session
+                .entries
+                .iter()
+                .map(|entry| entry.source.as_ref().map(|source| source.source_len))
+                .collect::<Vec<_>>(),
+            [
+                Some(lines[0].len()),
+                None,
+                None,
+                Some(lines[3].len()),
+                None,
+                Some(lines[5].len())
+            ]
+        );
+        assert_eq!(
+            session_arenas(&session, &entries)
+                .iter()
+                .map(|(entry, arena)| (*entry, arena.source_len))
+                .collect::<Vec<_>>(),
+            [
+                (0, lines[0].len()),
+                (3, lines[3].len()),
+                (4, lines[4].len())
+            ]
+        );
+    }
 }

{cc_transcript-14.35.0 → cc_transcript-14.37.0}/rust/crates/core/src/codex/parse.rs

@@ -1,12 +1,14 @@
 use memchr::memchr_iter;
 use sonic_rs::{JsonContainerTrait, JsonValueTrait, Value};
 
+use crate::codex::lower::line_dom;
 use crate::codex::types::{
     CodexEntry, CodexItem, CodexOther, CodexSession, Compacted, EventMsg, ResponseItem,
     ResponseItemPayload, SessionMeta, TokenUsage, TokenUsageInfo, WorldState,
 };
 use crate::parse::parse_timestamp;
-use crate::value::{field, field_str, normalize_last_wins};
+use crate::snapshot_memory::{pins_arena, SourceArena};
+use crate::value::{deduplicated, field, field_str};
 
 const AVG_CODEX_LINE_BYTES: usize = 700;
 
@@ -65,14 +67,21 @@ fn parse_codex_line(line: &[u8], line_index: usize, entries: &mut Vec<CodexEntry
         return;
     }
     match sonic_rs::from_slice::<Value>(line) {
-        Ok(mut value) => {
-            normalize_last_wins(&mut value);
+        Ok(parsed) => {
+            let (value, source_len) = deduplicated(&parsed).unwrap_or_else(|| (parsed, line.len()));
             let timestamp = field_str(&value, "timestamp").and_then(|s| parse_timestamp(s).ok());
             let item = parse_codex_item(&value, line);
+            let source = line_dom(&item)
+                .is_some_and(pins_arena)
+                .then(|| SourceArena {
+                    root: value,
+                    source_len,
+                });
             entries.push(CodexEntry {
                 line_index,
                 timestamp,
                 item,
+                source,
             });
         }
         Err(_) => entries.push(CodexEntry {
@@ -82,6 +91,7 @@ fn parse_codex_line(line: &[u8], line_index: usize, entries: &mut Vec<CodexEntry
                 ty: None,
                 raw: String::from_utf8_lossy(line).into_owned(),
             }),
+            source: None,
         }),
     }
 }

{cc_transcript-14.35.0 → cc_transcript-14.37.0}/rust/crates/core/src/codex/types.rs

@@ -1,11 +1,14 @@
 use chrono::{DateTime, FixedOffset};
 use sonic_rs::Value;
 
+use crate::snapshot_memory::SourceArena;
+
 #[derive(Debug)]
 pub struct CodexEntry {
     pub line_index: usize,
     pub timestamp: Option<DateTime<FixedOffset>>,
     pub item: CodexItem,
+    pub source: Option<SourceArena>,
 }
 
 #[derive(Debug)]

{cc_transcript-14.35.0 → cc_transcript-14.37.0}/rust/crates/core/src/lib.rs

@@ -40,6 +40,7 @@ pub mod snapshot;
 pub mod snapshot_activity;
 pub mod snapshot_codec;
 pub mod snapshot_labels;
+pub mod snapshot_ledger;
 pub mod snapshot_memory;
 pub mod snapshot_owned;
 pub mod snapshot_prepared;