cc-transcript 8.0.0__tar.gz → 8.1.0__tar.gz

{cc_transcript-8.0.0 → cc_transcript-8.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-transcript
-Version: 8.0.0
+Version: 8.1.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -18,7 +18,7 @@ Requires-Dist: tree-sitter-bash>=0.25
 Requires-Dist: pytest>=8.0 ; extra == 'dev'
 Requires-Dist: ty>=0.0.44 ; extra == 'dev'
 Requires-Dist: ruff>=0.8 ; extra == 'dev'
-Requires-Dist: spawnllm>=0.5.1,<0.6 ; extra == 'llm'
+Requires-Dist: spawnllm>=0.5.4,<0.6 ; extra == 'llm'
 Requires-Dist: spacy>=3.8 ; extra == 'sentiment'
 Requires-Dist: afinn>=0.1 ; extra == 'sentiment'
 Provides-Extra: dev

{cc_transcript-8.0.0 → cc_transcript-8.1.0}/cc_transcript/filterspec.py

@@ -70,10 +70,13 @@ INTERRUPT_MARKER_GROUPS: tuple[tuple[str, str], ...] = (("interrupt", r"^\s*\[Re
 STOP_HOOK_GROUPS: tuple[tuple[str, str], ...] = (("stop_hook", r"Stop hook feedback:"),)
 
 # Raw CC-injected protocol strings carried in tool-result content: the denial banner
-# and the markers that wrap the user's verbatim instruction in a rejected tool use.
+# and the markers that wrap the user's verbatim instruction in a rejected tool use,
+# and the banner pair that wraps an answered AskUserQuestion round.
 DENIAL_PREFIX = "The user doesn't want to proceed with this tool use. The tool use was rejected"
 USER_SAID_MARKER = "To tell you how to proceed, the user said:\n"
 USER_SAID_TRAILER = "Note: The user's next message"
+ANSWERED_PREFIX = "Your questions have been answered: "
+ANSWERED_TRAILER = ". You can now continue with these answers in mind."
 
 # Approve-and-advance directives: a user telling the agent to proceed/commit/push or
 # to resume killed work. They follow an assistant turn but advance it rather than

{cc_transcript-8.0.0 → cc_transcript-8.1.0}/cc_transcript/mining/__init__.py

@@ -21,7 +21,13 @@ when :func:`mining_spec_is_portable` holds, the Rust backend both interpret.
 
 from __future__ import annotations
 
-from cc_transcript.filterspec import DENIAL_PREFIX, USER_SAID_MARKER, USER_SAID_TRAILER
+from cc_transcript.filterspec import (
+    ANSWERED_PREFIX,
+    ANSWERED_TRAILER,
+    DENIAL_PREFIX,
+    USER_SAID_MARKER,
+    USER_SAID_TRAILER,
+)
 from cc_transcript.mining.candidates import DedupKey, FeedbackCandidate, dedup_key
 from cc_transcript.mining.confidence import (
     HIGH,
@@ -64,6 +70,7 @@ from cc_transcript.mining.signals import (
 from cc_transcript.mining.sourcekind import (
     INTERRUPT_REJECTION,
     PLAN_REVIEW,
+    QUESTION_ANSWER,
     REVIEW_COMMENT,
     TRANSCRIPT_MESSAGE,
     SourceKind,

{cc_transcript-8.0.0 → cc_transcript-8.1.0}/cc_transcript/mining/signals.py

@@ -25,6 +25,8 @@ from typing import TYPE_CHECKING, NamedTuple
 
 from cc_transcript.facts import is_denial
 from cc_transcript.filterspec import (
+    ANSWERED_PREFIX,
+    ANSWERED_TRAILER,
     INTERRUPT_MARKER_RE,
     compile_groups,
     embedded_user_text,
@@ -39,10 +41,12 @@ from cc_transcript.mining.formats import extract_structured
 from cc_transcript.mining.sourcekind import (
     INTERRUPT_REJECTION,
     PLAN_REVIEW,
+    QUESTION_ANSWER,
     REVIEW_COMMENT,
     TRANSCRIPT_MESSAGE,
 )
 from cc_transcript.mining.spec import (
+    ASK_USER_QUESTION_DETECTOR,
     DENIAL_DETECTOR,
     EXIT_PLAN_REJECTION_DETECTOR,
     INTERRUPT_DETECTOR,
@@ -71,6 +75,13 @@ if TYPE_CHECKING:
     from cc_transcript.mining.spec import ReviewSpec
     from cc_transcript.models import CcVersion, EventUuid, SessionId, ToolUseId, TranscriptEvent
 
+# An answered AskUserQuestion round renders each pair as '"Q"="A"' (or
+# '"Q"=(no option selected)'), optionally followed by ' selected preview:\n<raw>'
+# and/or ' notes: <text>', with pairs joined by ', ' inside the ANSWERED banner.
+ANSWER_PREVIEW_SEP = " selected preview:\n"
+ANSWER_NOTES_SEP = " notes: "
+NO_OPTION_SELECTED = "(no option selected)"
+
 
 @dataclass(frozen=True, slots=True)
 class MiningSignal:
@@ -400,6 +411,154 @@ def iter_review_comment_signals(events: Sequence[TranscriptEvent], spec: MiningS
     )
 
 
+class AnsweredPair(NamedTuple):
+    question: Mapping[str, Any]
+    answer: str | None
+    preview: str | None
+    notes: str | None
+
+
+def answered_question_results(event: UserEvent) -> Iterator[ToolResultBlock]:
+    return (
+        block
+        for block in event.blocks
+        if isinstance(block, ToolResultBlock)
+        if not block.is_error
+        if block.content.startswith(ANSWERED_PREFIX)
+    )
+
+
+def split_answer_segment(segment: str) -> tuple[str, str | None, str | None]:
+    if (at := segment.find(ANSWER_PREVIEW_SEP)) != -1:
+        rest = segment[at + len(ANSWER_PREVIEW_SEP) :]
+        if (notes_at := rest.find(ANSWER_NOTES_SEP)) != -1:
+            return segment[:at], rest[:notes_at], rest[notes_at + len(ANSWER_NOTES_SEP) :]
+        return segment[:at], rest, None
+    if (at := segment.find(ANSWER_NOTES_SEP)) != -1:
+        return segment[:at], None, segment[at + len(ANSWER_NOTES_SEP) :]
+    return segment, None, None
+
+
+def find_anchor(body: str, anchor: str, pos: int) -> int:
+    while (at := body.find(anchor, pos)) != -1:
+        if at == 0 or body[:at].endswith(", "):
+            return at
+        pos = at + 1
+    return -1
+
+
+def answered_pairs(body: str, questions: Sequence[Mapping[str, Any]]) -> Iterator[AnsweredPair]:
+    found: list[tuple[Mapping[str, Any], int, int]] = []
+    pos = 0
+    for question in questions:
+        if not isinstance(text := question.get("question"), str):
+            continue
+        anchor = f'"{text}"='
+        if (at := find_anchor(body, anchor, pos)) == -1:
+            continue
+        found.append((question, at, at + len(anchor)))
+        pos = at + len(anchor)
+    for i, (question, _, value_at) in enumerate(found):
+        last = i + 1 == len(found)
+        segment = body[value_at : len(body) if last else found[i + 1][1]]
+        if not last:
+            segment = segment.removesuffix(", ")
+        head, preview, notes = split_answer_segment(segment)
+        if head.startswith('"'):
+            yield AnsweredPair(question, head[1:].removesuffix('"'), preview, notes)
+        elif head.startswith(NO_OPTION_SELECTED):
+            yield AnsweredPair(question, None, preview, notes)
+
+
+def join_labels(answer: str, labels: Sequence[str]) -> list[str] | None:
+    picked: list[str] = []
+    start = 0
+    acc: str | None = None
+    for part in answer.split(", "):
+        acc = part if acc is None else f"{acc}, {part}"
+        if (at := next((i for i in range(start, len(labels)) if labels[i] == acc), None)) is not None:
+            picked.append(labels[at])
+            start = at + 1
+            acc = None
+    return picked if picked and acc is None else None
+
+
+def ordinal_label(answer: str, labels: Sequence[str]) -> tuple[str, bool] | None:
+    rest = answer.lstrip("0123456789")
+    digits = answer[: len(answer) - len(rest)]
+    if not digits or not 1 <= (n := int(digits)) <= len(labels) or (rest and rest[0] not in ",. )"):
+        return None
+    return labels[n - 1], not rest
+
+
+def resolve_pick(answer: str | None, labels: Sequence[str]) -> tuple[list[str], bool]:
+    if answer is None:
+        return [], False
+    if (joined := join_labels(answer, labels)) is not None:
+        return joined, True
+    if (ordinal := ordinal_label(answer, labels)) is not None:
+        label, bare = ordinal
+        return [label], bare
+    return [], False
+
+
+def question_answer_signal(
+    events: Sequence[TranscriptEvent], event: UserEvent, index: int, pair: AnsweredPair, spec: MiningSpec
+) -> MiningSignal | None:
+    options = pair.question.get("options")
+    labels = [
+        label
+        for option in (options if isinstance(options, list) else ())
+        if isinstance(option, dict) and isinstance(label := option.get("label"), str)
+    ]
+    picked, option_pick = resolve_pick(pair.answer, labels)
+    text = pair.notes if pair.notes is not None else pair.answer
+    if text is None:
+        return None
+    evidence: dict[str, Any] = {
+        "question": question if isinstance(question := pair.question.get("question"), str) else None,
+        "header": header if isinstance(header := pair.question.get("header"), str) else None,
+        "multi_select": isinstance(multi := pair.question.get("multiSelect"), bool) and multi,
+        "option_pick": option_pick,
+        "picked_labels": picked,
+        "recommended_pick": any("(Recommended)" in label for label in picked),
+    }
+    if pair.preview is not None:
+        evidence["preview"] = pair.preview
+    if pair.notes is not None:
+        evidence["notes"] = pair.notes
+    return MiningSignal(
+        kind=QUESTION_ANSWER,
+        detector="ask_user_question",
+        session_id=event.meta.session_id,
+        event_index=index,
+        event_uuid=event.meta.uuid,
+        occurred_at=event.meta.timestamp,
+        text=text,
+        cc_version=event.meta.cc_version,
+        trigger_index=nearest_assistant_index(events, index),
+        signal=weak("option_pick") if option_pick else calibrated(spec.calibrated, text, seed="freeform_answer"),
+        evidence=evidence,
+    )
+
+
+def iter_ask_user_question_signals(events: Sequence[TranscriptEvent], spec: MiningSpec) -> Iterator[MiningSignal]:
+    uses = tool_uses(events)
+    return (
+        signal
+        for index, event in enumerate(events)
+        if isinstance(event, UserEvent)
+        for block in answered_question_results(event)
+        if (use := uses.get(block.tool_use_id)) is not None
+        if use.name == "AskUserQuestion"
+        if block.content.endswith(ANSWERED_TRAILER)
+        for pair in answered_pairs(
+            block.content[len(ANSWERED_PREFIX) : -len(ANSWERED_TRAILER)], use.input["questions"]
+        )
+        if (signal := question_answer_signal(events, event, index, pair, spec)) is not None
+    )
+
+
 def mine(events: Sequence[TranscriptEvent], spec: MiningSpec) -> Iterator[MiningSignal]:
     """Yields every :class:`MiningSignal` the enabled detectors recognize in ``events``.
 
@@ -423,3 +582,5 @@ def mine(events: Sequence[TranscriptEvent], spec: MiningSpec) -> Iterator[Mining
         yield from iter_interrupt_marker_signals(events, spec)
     if REVIEW_COMMENT_DETECTOR in spec.detectors:
         yield from iter_review_comment_signals(events, spec)
+    if ASK_USER_QUESTION_DETECTOR in spec.detectors:
+        yield from iter_ask_user_question_signals(events, spec)

{cc_transcript-8.0.0 → cc_transcript-8.1.0}/cc_transcript/mining/sourcekind.py

@@ -7,7 +7,7 @@ from typing import NewType
 SourceKind = NewType("SourceKind", str)
 """A descriptive category for a mined feedback fact.
 
-The four module constants are the common categories the fact-detectors emit; apps
+The five module constants are the common categories the fact-detectors emit; apps
 may define their own ``SourceKind`` values for categories the core does not name.
 """
 
@@ -15,3 +15,4 @@ TRANSCRIPT_MESSAGE = SourceKind("transcript_message")
 PLAN_REVIEW = SourceKind("plan_review")
 INTERRUPT_REJECTION = SourceKind("interrupt_rejection")
 REVIEW_COMMENT = SourceKind("review_comment")
+QUESTION_ANSWER = SourceKind("question_answer")

{cc_transcript-8.0.0 → cc_transcript-8.1.0}/cc_transcript/mining/spec.py

@@ -49,7 +49,7 @@ if TYPE_CHECKING:
     from cc_transcript.mining.signals import MiningSignal
 
 DetectorName = NewType("DetectorName", str)
-"""One of the six core detector identifiers a :class:`MiningSpec` may enable."""
+"""One of the seven core detector identifiers a :class:`MiningSpec` may enable."""
 
 TRANSCRIPT_MESSAGE_DETECTOR = DetectorName("transcript_message")
 EXIT_PLAN_REJECTION_DETECTOR = DetectorName("exit_plan_rejection")
@@ -57,6 +57,7 @@ PLAN_REENTRY_DETECTOR = DetectorName("plan_reentry")
 DENIAL_DETECTOR = DetectorName("denial")
 INTERRUPT_DETECTOR = DetectorName("interrupt")
 REVIEW_COMMENT_DETECTOR = DetectorName("review_comment")
+ASK_USER_QUESTION_DETECTOR = DetectorName("ask_user_question")
 
 ALL_DETECTORS: frozenset[DetectorName] = frozenset(
     {
@@ -66,6 +67,7 @@ ALL_DETECTORS: frozenset[DetectorName] = frozenset(
         DENIAL_DETECTOR,
         INTERRUPT_DETECTOR,
         REVIEW_COMMENT_DETECTOR,
+        ASK_USER_QUESTION_DETECTOR,
     }
 )
 

{cc_transcript-8.0.0 → cc_transcript-8.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cc-transcript"
-version = "8.0.0"
+version = "8.1.0"
 description = "Grep every Claude Code session you've ever run."
 readme = "README.md"
 license = "PolyForm-Noncommercial-1.0.0"
@@ -48,7 +48,7 @@ sentiment = [
     "spacy>=3.8",
     "afinn>=0.1",
 ]
-llm = ["spawnllm>=0.5.1,<0.6"]
+llm = ["spawnllm>=0.5.4,<0.6"]
 
 [project.scripts]
 cc-transcript = "cc_transcript.cli:cli"

{cc_transcript-8.0.0 → cc_transcript-8.1.0}/rust/src/mining.rs

@@ -10,8 +10,8 @@ use sonic_rs::{Index, JsonContainerTrait, JsonValueTrait, Value};
 use crate::event::{parse_timestamp, require_str, truthy_str};
 use crate::filter::{compile_group_array, Kind};
 use crate::protocol::{
-    embedded_user_text, interrupt_marker, is_bare_interrupt_marker, DENIAL_PREFIX,
-    INTERRUPT_MARKER_RE,
+    embedded_user_text, interrupt_marker, is_bare_interrupt_marker, ANSWERED_PREFIX, ANSWERED_TRAILER,
+    DENIAL_PREFIX, INTERRUPT_MARKER_RE,
 };
 use crate::value::{block_type, content_text, field, field_bool, field_str};
 
@@ -20,6 +20,7 @@ const TRANSCRIPT_MESSAGE: &str = "transcript_message";
 const PLAN_REVIEW: &str = "plan_review";
 const INTERRUPT_REJECTION: &str = "interrupt_rejection";
 const REVIEW_COMMENT: &str = "review_comment";
+const QUESTION_ANSWER: &str = "question_answer";
 
 // Detector ids (mining/spec.py TRANSCRIPT_MESSAGE_DETECTOR etc.).
 const DETECTOR_TRANSCRIPT_MESSAGE: &str = "transcript_message";
@@ -28,6 +29,12 @@ const DETECTOR_PLAN_REENTRY: &str = "plan_reentry";
 const DETECTOR_DENIAL: &str = "denial";
 const DETECTOR_INTERRUPT: &str = "interrupt";
 const DETECTOR_REVIEW_COMMENT: &str = "review_comment";
+const DETECTOR_ASK_USER_QUESTION: &str = "ask_user_question";
+
+// AskUserQuestion answered-round segment markers (mining/signals.py).
+const ANSWER_PREVIEW_SEP: &str = " selected preview:\n";
+const ANSWER_NOTES_SEP: &str = " notes: ";
+const NO_OPTION_SELECTED: &str = "(no option selected)";
 
 // Confidence bands (mining/confidence.py NONE / LOW); the hardcoded marker-correction seeds.
 const NONE: f64 = 0.0;
@@ -1164,6 +1171,233 @@ fn iter_review_comment<'py>(
 
 // ── dispatch (mining/signals.py mine) ────────────────────────────────────────
 
+/// The answered AskUserQuestion tool-result blocks of a user event
+/// (signals.py answered_question_results): non-error blocks whose flattened
+/// content starts with the answered banner.
+fn answered_results(event: &Value) -> Vec<&Value> {
+    message_content(event)
+        .and_then(JsonContainerTrait::as_array)
+        .into_iter()
+        .flatten()
+        .filter(|b| block_type(b) == Some("tool_result"))
+        .filter(|b| !field_bool(b, "is_error"))
+        .filter(|b| result_content_text(b).is_some_and(|c| c.starts_with(ANSWERED_PREFIX)))
+        .collect()
+}
+
+struct AnsweredPair<'a> {
+    question: &'a Value,
+    answer: Option<&'a str>,
+    preview: Option<&'a str>,
+    notes: Option<&'a str>,
+}
+
+/// split_answer_segment (signals.py split_answer_segment): the answer head plus
+/// the optional preview and notes parts, split on the first marker occurrence in
+/// render order (answer, preview, notes).
+fn split_answer_segment(segment: &str) -> (&str, Option<&str>, Option<&str>) {
+    if let Some(at) = segment.find(ANSWER_PREVIEW_SEP) {
+        let rest = &segment[at + ANSWER_PREVIEW_SEP.len()..];
+        return match rest.find(ANSWER_NOTES_SEP) {
+            Some(notes_at) => (
+                &segment[..at],
+                Some(&rest[..notes_at]),
+                Some(&rest[notes_at + ANSWER_NOTES_SEP.len()..]),
+            ),
+            None => (&segment[..at], Some(rest), None),
+        };
+    }
+    match segment.find(ANSWER_NOTES_SEP) {
+        Some(at) => (&segment[..at], None, Some(&segment[at + ANSWER_NOTES_SEP.len()..])),
+        None => (segment, None, None),
+    }
+}
+
+/// find_anchor (signals.py find_anchor): the next anchor at or after `pos` that
+/// renders at the body start or right after the ", " pair join, skipping the same
+/// literal embedded inside an earlier freeform answer.
+fn find_anchor(body: &str, anchor: &str, pos: usize) -> Option<usize> {
+    let mut from = pos;
+    while let Some(i) = body[from..].find(anchor) {
+        let at = from + i;
+        if at == 0 || body[..at].ends_with(", ") {
+            return Some(at);
+        }
+        from = at + 1;
+    }
+    None
+}
+
+/// answered_pairs (signals.py answered_pairs): anchors each question in order on
+/// '"<question>"=', slices each pair's segment to the next found anchor, strips
+/// the exact ', ' pair join on middle segments and the answer's exact closing '"',
+/// and skips questions whose anchor never rendered.
+fn answered_pairs<'a>(body: &'a str, questions: &'a sonic_rs::Array) -> Vec<AnsweredPair<'a>> {
+    let mut found: Vec<(&Value, usize, usize)> = Vec::new();
+    let mut pos = 0usize;
+    for question in questions.iter() {
+        let Some(text) = field_str(question, "question") else { continue };
+        let anchor = format!("\"{text}\"=");
+        let Some(at) = find_anchor(body, &anchor, pos) else { continue };
+        found.push((question, at, at + anchor.len()));
+        pos = at + anchor.len();
+    }
+    let mut pairs = Vec::new();
+    for (i, &(question, _, value_at)) in found.iter().enumerate() {
+        let end = found.get(i + 1).map_or(body.len(), |&(_, at, _)| at);
+        let mut segment = &body[value_at..end];
+        if i + 1 < found.len() {
+            segment = segment.strip_suffix(", ").unwrap_or(segment);
+        }
+        let (head, preview, notes) = split_answer_segment(segment);
+        let answer = if let Some(quoted) = head.strip_prefix('"') {
+            Some(quoted.strip_suffix('"').unwrap_or(quoted))
+        } else if head.starts_with(NO_OPTION_SELECTED) {
+            None
+        } else {
+            continue;
+        };
+        pairs.push(AnsweredPair { question, answer, preview, notes });
+    }
+    pairs
+}
+
+/// join_labels (signals.py join_labels): the multiSelect resolution — split the
+/// answer on ', ' and greedily re-join consecutive parts until each accumulation
+/// equals the next unused label in option order; succeeds only when every part is
+/// consumed.
+fn join_labels(answer: &str, labels: &[String]) -> Option<Vec<String>> {
+    let mut picked: Vec<String> = Vec::new();
+    let mut start = 0usize;
+    let mut acc: Option<String> = None;
+    for part in answer.split(", ") {
+        let joined = match acc {
+            None => part.to_string(),
+            Some(prior) => format!("{prior}, {part}"),
+        };
+        match (start..labels.len()).find(|&i| labels[i] == joined) {
+            Some(at) => {
+                picked.push(labels[at].clone());
+                start = at + 1;
+                acc = None;
+            }
+            None => acc = Some(joined),
+        }
+    }
+    (!picked.is_empty() && acc.is_none()).then_some(picked)
+}
+
+/// ordinal_label (signals.py ordinal_label): a leading ASCII-digit run in
+/// 1..=len(options), followed by nothing or one of ',' '.' ' ' ')', resolves to
+/// that option's label; the bool is whether the ordinal stood alone.
+fn ordinal_label(answer: &str, labels: &[String]) -> Option<(String, bool)> {
+    let rest = answer.trim_start_matches(|c: char| c.is_ascii_digit());
+    let digits = &answer[..answer.len() - rest.len()];
+    let n: usize = digits.parse().ok()?;
+    if !(1..=labels.len()).contains(&n) || (!rest.is_empty() && !rest.starts_with([',', '.', ' ', ')'])) {
+        return None;
+    }
+    Some((labels[n - 1].clone(), rest.is_empty()))
+}
+
+/// resolve_pick (signals.py resolve_pick): verbatim/multiSelect join → a full
+/// pick; leading ordinal → resolved label with option_pick only when bare; else
+/// pure freeform.
+fn resolve_pick(answer: Option<&str>, labels: &[String]) -> (Vec<String>, bool) {
+    let Some(answer) = answer else { return (Vec::new(), false) };
+    if let Some(joined) = join_labels(answer, labels) {
+        return (joined, true);
+    }
+    match ordinal_label(answer, labels) {
+        Some((label, bare)) => (vec![label], bare),
+        None => (Vec::new(), false),
+    }
+}
+
+/// iter_ask_user_question_signals (signals.py iter_ask_user_question_signals):
+/// one signal per answered question/answer pair, with the pick resolution facts
+/// as evidence (absent preview/notes keys are omitted, never None).
+fn iter_ask_user_question<'py>(
+    py: Python<'py>,
+    events: &Events,
+    spec: &CompiledMiningSpec,
+    uses: &HashMap<String, &Value>,
+    out: &mut Vec<Bound<'py, PyDict>>,
+) -> PyResult<()> {
+    for index in 0..events.len() {
+        if events.kinds[index] != Kind::User {
+            continue;
+        }
+        let event = &events.lines[index];
+        for block in answered_results(event) {
+            let Some(use_block) = field_str(block, "tool_use_id").and_then(|id| uses.get(id).copied())
+            else {
+                continue;
+            };
+            if field_str(use_block, "name") != Some("AskUserQuestion") {
+                continue;
+            }
+            let Some(content) = result_content_text(block) else { continue };
+            if !content.ends_with(ANSWERED_TRAILER)
+                || content.len() < ANSWERED_PREFIX.len() + ANSWERED_TRAILER.len()
+            {
+                continue;
+            }
+            let body = &content[ANSWERED_PREFIX.len()..content.len() - ANSWERED_TRAILER.len()];
+            let Some(questions) = field(use_block, "input")
+                .and_then(|input| field(input, "questions"))
+                .and_then(JsonContainerTrait::as_array)
+            else {
+                continue;
+            };
+            let trigger = events.nearest_assistant_index(index);
+            for pair in answered_pairs(body, questions) {
+                let labels: Vec<String> = field(pair.question, "options")
+                    .and_then(JsonContainerTrait::as_array)
+                    .into_iter()
+                    .flatten()
+                    .filter_map(|option| field_str(option, "label"))
+                    .map(String::from)
+                    .collect();
+                let (picked, option_pick) = resolve_pick(pair.answer, &labels);
+                let recommended = picked.iter().any(|label| label.contains("(Recommended)"));
+                let Some(text) = pair.notes.or(pair.answer) else { continue };
+                let sig = if option_pick {
+                    weak("option_pick")
+                } else {
+                    calibrated(&spec.calibrated, text, "freeform_answer")
+                };
+                let evidence = PyDict::new(py);
+                evidence.set_item("question", field_str(pair.question, "question"))?;
+                evidence.set_item("header", field_str(pair.question, "header"))?;
+                evidence.set_item("multi_select", field_bool(pair.question, "multiSelect"))?;
+                evidence.set_item("option_pick", option_pick)?;
+                evidence.set_item("picked_labels", picked)?;
+                evidence.set_item("recommended_pick", recommended)?;
+                if let Some(preview) = pair.preview {
+                    evidence.set_item("preview", preview)?;
+                }
+                if let Some(notes) = pair.notes {
+                    evidence.set_item("notes", notes)?;
+                }
+                out.push(build_signal_dict(
+                    py,
+                    QUESTION_ANSWER,
+                    DETECTOR_ASK_USER_QUESTION,
+                    event,
+                    index,
+                    text,
+                    trigger,
+                    &sig,
+                    None,
+                    evidence,
+                )?);
+            }
+        }
+    }
+    Ok(())
+}
+
 pub fn mine<'py>(
     py: Python<'py>,
     raw: &[u8],
@@ -1191,6 +1425,9 @@ pub fn mine<'py>(
     if spec.detectors.contains(DETECTOR_REVIEW_COMMENT) {
         iter_review_comment(py, &events, spec, &uses, &mut out)?;
     }
+    if spec.detectors.contains(DETECTOR_ASK_USER_QUESTION) {
+        iter_ask_user_question(py, &events, spec, &uses, &mut out)?;
+    }
     Ok(out)
 }
 
@@ -1224,4 +1461,53 @@ mod tests {
         let low = bump(CandidateSig { confidence: 0.1, reasons: vec![], durable: true }, -0.25, "r");
         assert_eq!(low.confidence, 0.0);
     }
+
+    #[test]
+    fn split_answer_segment_variants() {
+        assert_eq!(split_answer_segment("\"A\""), ("\"A\"", None, None));
+        assert_eq!(
+            split_answer_segment("\"A\" selected preview:\nraw text"),
+            ("\"A\"", Some("raw text"), None)
+        );
+        assert_eq!(
+            split_answer_segment("\"A\" selected preview:\nraw notes: typed"),
+            ("\"A\"", Some("raw"), Some("typed"))
+        );
+        assert_eq!(
+            split_answer_segment("(no option selected) notes: typed"),
+            ("(no option selected)", None, Some("typed"))
+        );
+    }
+
+    #[test]
+    fn answered_pairs_slices_segments_and_skips_omitted() {
+        let questions: Value =
+            sonic_rs::from_str(r#"[{"question": "Q1"}, {"question": "Q2"}, {"question": "Q3"}]"#).unwrap();
+        let body = "\"Q1\"=\"first, with comma\", \"Q3\"=\"he said \"hi\"\"";
+        let pairs = answered_pairs(body, questions.as_array().unwrap());
+        assert_eq!(pairs.len(), 2);
+        assert_eq!(pairs[0].answer, Some("first, with comma"));
+        assert_eq!(pairs[1].answer, Some("he said \"hi\""));
+    }
+
+    #[test]
+    fn join_labels_greedy_over_comma_containing_label() {
+        let labels = vec!["BeforeEdit / AfterEdit".to_string(), "One, Two".to_string(), "Three".to_string()];
+        assert_eq!(
+            join_labels("One, Two, Three", &labels),
+            Some(vec!["One, Two".to_string(), "Three".to_string()])
+        );
+        assert_eq!(join_labels("One, Two, Four", &labels), None);
+        assert_eq!(join_labels("Three", &labels), Some(vec!["Three".to_string()]));
+    }
+
+    #[test]
+    fn ordinal_label_bounds_and_separators() {
+        let labels = vec!["A".to_string(), "B".to_string(), "C".to_string()];
+        assert_eq!(ordinal_label("3, and more", &labels), Some(("C".to_string(), false)));
+        assert_eq!(ordinal_label("2", &labels), Some(("B".to_string(), true)));
+        assert_eq!(ordinal_label("2026 timeline works", &labels), None);
+        assert_eq!(ordinal_label("1x", &labels), None);
+        assert_eq!(ordinal_label("freeform", &labels), None);
+    }
 }

{cc_transcript-8.0.0 → cc_transcript-8.1.0}/rust/src/protocol.rs

@@ -8,6 +8,8 @@ pub(crate) const DENIAL_PREFIX: &str =
     "The user doesn't want to proceed with this tool use. The tool use was rejected";
 pub(crate) const USER_SAID_MARKER: &str = "To tell you how to proceed, the user said:\n";
 pub(crate) const USER_SAID_TRAILER: &str = "Note: The user's next message";
+pub(crate) const ANSWERED_PREFIX: &str = "Your questions have been answered: ";
+pub(crate) const ANSWERED_TRAILER: &str = ". You can now continue with these answers in mind.";
 const INTERRUPT_MARKER_PATTERN: &str = r"^\s*\[Request interrupted by user";
 
 /// The one interrupt-marker regex (filterspec.py INTERRUPT_MARKER_RE): the pattern