cc-transcript 10.7.0__tar.gz → 11.0.0__tar.gz

{cc_transcript-10.7.0 → cc_transcript-11.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-transcript
-Version: 10.7.0
+Version: 11.0.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{cc_transcript-10.7.0 → cc_transcript-11.0.0}/cc_transcript/__init__.py

@@ -30,8 +30,11 @@ EXPORTS: dict[str, str] = {
         ),
         "cc_transcript.tools": (
             "TOOL_ALIASES",
+            "AskUserQuestionResult",
             "BashCall",
+            "BashResult",
             "EditCall",
+            "EditResult",
             "EditSpan",
             "ExitPlanModeCall",
             "GlobCall",
@@ -40,16 +43,27 @@ EXPORTS: dict[str, str] = {
             "MultiEditCall",
             "NotebookEditCall",
             "OtherCall",
+            "OtherResult",
+            "QuestionAnnotation",
             "ReadCall",
+            "ReadResult",
             "SkillCall",
+            "SkillResult",
             "TaskCall",
             "TaskCreateCall",
+            "TaskLaunchResult",
+            "TaskResult",
             "TaskUpdateCall",
+            "TextResult",
             "ToolCall",
             "ToolCallBase",
             "ToolInputError",
+            "ToolResult",
+            "ToolResultBase",
+            "ToolResultError",
             "WorkflowCall",
             "WriteCall",
+            "WriteResult",
             "expand_tool_names",
             "file_path_of",
             "hunks_of",
@@ -57,6 +71,7 @@ EXPORTS: dict[str, str] = {
             "mcp_access",
             "mcp_parts",
             "parse_tool_call",
+            "parse_tool_result",
             "tool_name_matches",
         ),
         "cc_transcript.command": (
@@ -68,29 +83,50 @@ EXPORTS: dict[str, str] = {
             "parse_command_line",
         ),
         "cc_transcript.models": (
+            "ApiError",
             "AssistantEvent",
+            "AsyncHookResponse",
+            "AttachmentDetail",
+            "AttachmentEvent",
+            "Attribution",
             "CacheCreation",
             "CcVersion",
+            "CompactBoundary",
             "ContentBlock",
             "EntryMeta",
             "FallbackBlock",
+            "HookAdditionalContext",
+            "HookBlockingError",
+            "HookCancelled",
+            "HookInfo",
+            "HookNonBlockingError",
+            "HookSuccess",
             "InitInfo",
             "McpServer",
+            "ModelRefusalFallback",
             "ModeEvent",
             "ModelUsage",
+            "OtherAttachment",
             "OtherBlock",
             "OtherEvent",
+            "OtherSystemDetail",
             "Plugin",
+            "PreservedMessages",
+            "PreservedSegment",
             "PrintMessage",
             "PrintResult",
             "Question",
+            "QueuedCommand",
             "ServerToolUse",
+            "StopHookSummary",
+            "SystemDetail",
             "SystemEvent",
             "TextBlock",
             "ThinkingBlock",
             "ToolResultBlock",
             "ToolUseBlock",
             "TranscriptEvent",
+            "TurnDuration",
             "Usage",
             "UserEvent",
             "thinking_chars",
@@ -478,15 +514,33 @@ if TYPE_CHECKING:
     from cc_transcript.ids import (
         tool_digest as tool_digest,
     )
+    from cc_transcript.models import (
+        ApiError as ApiError,
+    )
     from cc_transcript.models import (
         AssistantEvent as AssistantEvent,
     )
+    from cc_transcript.models import (
+        AsyncHookResponse as AsyncHookResponse,
+    )
+    from cc_transcript.models import (
+        AttachmentDetail as AttachmentDetail,
+    )
+    from cc_transcript.models import (
+        AttachmentEvent as AttachmentEvent,
+    )
+    from cc_transcript.models import (
+        Attribution as Attribution,
+    )
     from cc_transcript.models import (
         CacheCreation as CacheCreation,
     )
     from cc_transcript.models import (
         CcVersion as CcVersion,
     )
+    from cc_transcript.models import (
+        CompactBoundary as CompactBoundary,
+    )
     from cc_transcript.models import (
         ContentBlock as ContentBlock,
     )
@@ -496,6 +550,24 @@ if TYPE_CHECKING:
     from cc_transcript.models import (
         FallbackBlock as FallbackBlock,
     )
+    from cc_transcript.models import (
+        HookAdditionalContext as HookAdditionalContext,
+    )
+    from cc_transcript.models import (
+        HookBlockingError as HookBlockingError,
+    )
+    from cc_transcript.models import (
+        HookCancelled as HookCancelled,
+    )
+    from cc_transcript.models import (
+        HookInfo as HookInfo,
+    )
+    from cc_transcript.models import (
+        HookNonBlockingError as HookNonBlockingError,
+    )
+    from cc_transcript.models import (
+        HookSuccess as HookSuccess,
+    )
     from cc_transcript.models import (
         InitInfo as InitInfo,
     )
@@ -505,18 +577,33 @@ if TYPE_CHECKING:
     from cc_transcript.models import (
         ModeEvent as ModeEvent,
     )
+    from cc_transcript.models import (
+        ModelRefusalFallback as ModelRefusalFallback,
+    )
     from cc_transcript.models import (
         ModelUsage as ModelUsage,
     )
+    from cc_transcript.models import (
+        OtherAttachment as OtherAttachment,
+    )
     from cc_transcript.models import (
         OtherBlock as OtherBlock,
     )
     from cc_transcript.models import (
         OtherEvent as OtherEvent,
     )
+    from cc_transcript.models import (
+        OtherSystemDetail as OtherSystemDetail,
+    )
     from cc_transcript.models import (
         Plugin as Plugin,
     )
+    from cc_transcript.models import (
+        PreservedMessages as PreservedMessages,
+    )
+    from cc_transcript.models import (
+        PreservedSegment as PreservedSegment,
+    )
     from cc_transcript.models import (
         PrintMessage as PrintMessage,
     )
@@ -526,9 +613,18 @@ if TYPE_CHECKING:
     from cc_transcript.models import (
         Question as Question,
     )
+    from cc_transcript.models import (
+        QueuedCommand as QueuedCommand,
+    )
     from cc_transcript.models import (
         ServerToolUse as ServerToolUse,
     )
+    from cc_transcript.models import (
+        StopHookSummary as StopHookSummary,
+    )
+    from cc_transcript.models import (
+        SystemDetail as SystemDetail,
+    )
     from cc_transcript.models import (
         SystemEvent as SystemEvent,
     )
@@ -547,6 +643,9 @@ if TYPE_CHECKING:
     from cc_transcript.models import (
         TranscriptEvent as TranscriptEvent,
     )
+    from cc_transcript.models import (
+        TurnDuration as TurnDuration,
+    )
     from cc_transcript.models import (
         Usage as Usage,
     )
@@ -606,12 +705,21 @@ if TYPE_CHECKING:
     from cc_transcript.tools import (
         TOOL_ALIASES as TOOL_ALIASES,
     )
+    from cc_transcript.tools import (
+        AskUserQuestionResult as AskUserQuestionResult,
+    )
     from cc_transcript.tools import (
         BashCall as BashCall,
     )
+    from cc_transcript.tools import (
+        BashResult as BashResult,
+    )
     from cc_transcript.tools import (
         EditCall as EditCall,
     )
+    from cc_transcript.tools import (
+        EditResult as EditResult,
+    )
     from cc_transcript.tools import (
         EditSpan as EditSpan,
     )
@@ -636,21 +744,42 @@ if TYPE_CHECKING:
     from cc_transcript.tools import (
         OtherCall as OtherCall,
     )
+    from cc_transcript.tools import (
+        OtherResult as OtherResult,
+    )
+    from cc_transcript.tools import (
+        QuestionAnnotation as QuestionAnnotation,
+    )
     from cc_transcript.tools import (
         ReadCall as ReadCall,
     )
+    from cc_transcript.tools import (
+        ReadResult as ReadResult,
+    )
     from cc_transcript.tools import (
         SkillCall as SkillCall,
     )
+    from cc_transcript.tools import (
+        SkillResult as SkillResult,
+    )
     from cc_transcript.tools import (
         TaskCall as TaskCall,
     )
     from cc_transcript.tools import (
         TaskCreateCall as TaskCreateCall,
     )
+    from cc_transcript.tools import (
+        TaskLaunchResult as TaskLaunchResult,
+    )
+    from cc_transcript.tools import (
+        TaskResult as TaskResult,
+    )
     from cc_transcript.tools import (
         TaskUpdateCall as TaskUpdateCall,
     )
+    from cc_transcript.tools import (
+        TextResult as TextResult,
+    )
     from cc_transcript.tools import (
         ToolCall as ToolCall,
     )
@@ -660,12 +789,24 @@ if TYPE_CHECKING:
     from cc_transcript.tools import (
         ToolInputError as ToolInputError,
     )
+    from cc_transcript.tools import (
+        ToolResult as ToolResult,
+    )
+    from cc_transcript.tools import (
+        ToolResultBase as ToolResultBase,
+    )
+    from cc_transcript.tools import (
+        ToolResultError as ToolResultError,
+    )
     from cc_transcript.tools import (
         WorkflowCall as WorkflowCall,
     )
     from cc_transcript.tools import (
         WriteCall as WriteCall,
     )
+    from cc_transcript.tools import (
+        WriteResult as WriteResult,
+    )
     from cc_transcript.tools import (
         expand_tool_names as expand_tool_names,
     )
@@ -687,6 +828,9 @@ if TYPE_CHECKING:
     from cc_transcript.tools import (
         parse_tool_call as parse_tool_call,
     )
+    from cc_transcript.tools import (
+        parse_tool_result as parse_tool_result,
+    )
     from cc_transcript.tools import (
         tool_name_matches as tool_name_matches,
     )

{cc_transcript-10.7.0 → cc_transcript-11.0.0}/cc_transcript/activity.py

@@ -21,7 +21,7 @@ from cc_transcript.filterspec import event_meta
 from cc_transcript.ids import EventRef
 from cc_transcript.models import AssistantEvent, ToolResultBlock, ToolUseBlock, UserEvent
 from cc_transcript.parser import TranscriptParser
-from cc_transcript.tools import file_path_of, hunks_of, parse_tool_call
+from cc_transcript.tools import file_path_of, hunks_of, parse_tool_call, parse_tool_result
 
 if TYPE_CHECKING:
     from collections.abc import Mapping, Sequence
@@ -30,7 +30,7 @@ if TYPE_CHECKING:
 
     from cc_transcript.ids import SessionId, ToolUseId
     from cc_transcript.models import TranscriptEvent
-    from cc_transcript.tools import Hunk, ToolCall
+    from cc_transcript.tools import Hunk, ToolCall, ToolResult
 
 UserClassifier = Callable[["UserEvent"], bool]
 """Decides which :class:`~cc_transcript.models.UserEvent` objects open a turn."""
@@ -78,6 +78,18 @@ class ToolUse:
         """Milliseconds from the call to its result, or None without a result."""
         return None if self.result_ts is None else round((self.result_ts - self.ts).total_seconds() * 1000)
 
+    @property
+    def typed_result(self) -> ToolResult | None:
+        """The result parsed into the typed result hierarchy, or None without a result.
+
+        The join point for :func:`~cc_transcript.tools.parse_tool_result`: pairs
+        this use's tool name with its result block's ``tool_use_result`` payload,
+        degrading to :class:`~cc_transcript.tools.OtherResult` on any shape drift.
+        """
+        if self.result is None:
+            return None
+        return parse_tool_result(self.call.name, self.result.tool_use_result, on_error="other")
+
 
 @dataclass(frozen=True, slots=True)
 class Edit:

{cc_transcript-10.7.0 → cc_transcript-11.0.0}/cc_transcript/activity_probe.py

@@ -23,6 +23,7 @@ from typing import TYPE_CHECKING, Literal
 from cc_transcript.activity import native_user_classifier
 from cc_transcript.models import (
     AssistantEvent,
+    AttachmentEvent,
     SystemEvent,
     ToolResultBlock,
     ToolUseBlock,
@@ -170,7 +171,7 @@ def probe_events(
             (
                 int(event.meta.timestamp.timestamp())
                 for event in events
-                if isinstance(event, UserEvent | AssistantEvent | SystemEvent)
+                if isinstance(event, UserEvent | AssistantEvent | SystemEvent | AttachmentEvent)
             ),
             default=None,
         ),

{cc_transcript-10.7.0 → cc_transcript-11.0.0}/cc_transcript/discovery.py

@@ -14,6 +14,15 @@ if TYPE_CHECKING:
 
 CLAUDE_PROJECTS_DIR = Path.home() / ".claude" / "projects"
 
+TRANSCRIPT_MEMO: dict[tuple[SessionId, Path], Path] = {}
+"""Positive-hit memo for :func:`find_transcript_sync`, keyed by ``(session_id, resolved root)``.
+
+Only successful lookups are cached: a miss may become a hit once Claude Code
+writes the file, so ``None`` is never stored. A cached hit is revalidated with
+``Path.exists`` before it is reused — a transcript file can be pruned from disk —
+and a stale entry falls through to a fresh scan.
+"""
+
 
 class TranscriptExpiredError(RuntimeError):
     """A session's transcript file is gone from disk.
@@ -106,10 +115,18 @@ def find_transcript_sync(session_id: SessionId, *, root: Path | None = None) ->
     :data:`CLAUDE_PROJECTS_DIR`), resolving symlinks — cc-pool gives one
     transcript several path spellings — and deduping by resolved real path.
 
+    A successful lookup is memoized in ``TRANSCRIPT_MEMO`` under
+    ``(session_id, resolved root)`` and revalidated on the next hit, so a
+    repeated probe skips the recursive glob while a pruned transcript still
+    forces a fresh scan.
+
     Returns:
         The newest-mtime real path, or None when no transcript exists.
     """
     base = root or CLAUDE_PROJECTS_DIR
+    key = (session_id, base.resolve())
+    if (cached := TRANSCRIPT_MEMO.get(key)) is not None and cached.exists():
+        return cached
     if not base.exists():
         return None
     candidates: dict[Path, float] = {}
@@ -120,7 +137,9 @@ def find_transcript_sync(session_id: SessionId, *, root: Path | None = None) ->
             candidates[real] = real.stat().st_mtime
         except OSError:
             continue
-    return max(candidates, key=candidates.__getitem__, default=None)
+    if (hit := max(candidates, key=candidates.__getitem__, default=None)) is not None:
+        TRANSCRIPT_MEMO[key] = hit
+    return hit
 
 
 async def find_transcript(session_id: SessionId, *, root: Path | None = None) -> Path | None:

{cc_transcript-10.7.0 → cc_transcript-11.0.0}/cc_transcript/facts.py

@@ -16,7 +16,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Literal
 
 from cc_transcript.activity import SessionActivity
-from cc_transcript.filterspec import DENIAL_PREFIX, embedded_user_text, session_id_of
+from cc_transcript.filterspec import DENIAL_KIND_USER_REJECTED, embedded_user_text, session_id_of
 from cc_transcript.tools import BashCall, file_path_of, mcp_access, mcp_parts
 
 if TYPE_CHECKING:
@@ -31,7 +31,7 @@ if TYPE_CHECKING:
 
 
 def is_denial(block: ToolResultBlock) -> bool:
-    return block.is_error and block.content.startswith(DENIAL_PREFIX)
+    return block.denial_kind == DENIAL_KIND_USER_REJECTED
 
 
 def denial_fields(result: ToolResultBlock | None) -> tuple[bool, str | None]:
@@ -67,6 +67,8 @@ class ToolFact:
         file_path: The file the call targets, when it targets one.
         is_error: Whether the call's result reported a failure.
         denied: Whether the result is a user rejection of the tool use.
+        denial_kind: The structured tool-denial kind (``user-rejected`` for a human
+            rejection, ``permission-rule`` for a hook/guard block), or None.
         user_said: The user's verbatim instruction embedded in a denial, else None.
         duration_ms: Milliseconds from the call to its result, or None without one.
     """
@@ -84,6 +86,7 @@ class ToolFact:
     file_path: str | None
     is_error: bool
     denied: bool
+    denial_kind: str | None
     user_said: str | None
     duration_ms: int | None
 
@@ -106,6 +109,7 @@ def fact_of(use: ToolUse, session_id: SessionId, path: Path, prefixes: tuple[str
         file_path=file_path_of(call),
         is_error=use.result.is_error if use.result is not None else False,
         denied=denied,
+        denial_kind=use.result.denial_kind if use.result is not None else None,
         user_said=user_said,
         duration_ms=use.duration_ms,
     )

{cc_transcript-10.7.0 → cc_transcript-11.0.0}/cc_transcript/filterspec.py

@@ -27,7 +27,15 @@ from typing import TYPE_CHECKING, Literal
 
 import orjson
 
-from cc_transcript.models import AssistantEvent, ModeEvent, OtherEvent, SystemEvent, ToolUseBlock, UserEvent
+from cc_transcript.models import (
+    AssistantEvent,
+    AttachmentEvent,
+    ModeEvent,
+    OtherEvent,
+    SystemEvent,
+    ToolUseBlock,
+    UserEvent,
+)
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Iterator, Sequence
@@ -35,7 +43,7 @@ if TYPE_CHECKING:
 
     from cc_transcript.models import EntryMeta, SessionId, ToolUseId, TranscriptEvent
 
-EventKind = Literal["user", "assistant", "system", "mode", "other"]
+EventKind = Literal["user", "assistant", "system", "mode", "other", "attachment"]
 MetaFlagName = Literal["is_sidechain", "is_meta", "is_compact_summary", "is_visible_in_transcript_only"]
 
 TRAILING_PUNCT = ".!?…,;:"
@@ -77,6 +85,9 @@ STOP_HOOK_GROUPS: tuple[tuple[str, str], ...] = (("stop_hook", r"Stop hook feedb
 
 # Raw CC-injected protocol strings carried in tool-result content, not user-authored text.
 DENIAL_PREFIX = "The user doesn't want to proceed with this tool use. The tool use was rejected"
+# Record-level ``toolDenialKind`` values: a human rejection versus a hook/guard block.
+DENIAL_KIND_USER_REJECTED = "user-rejected"
+DENIAL_KIND_PERMISSION_RULE = "permission-rule"
 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: "
@@ -371,6 +382,8 @@ def event_kind(event: TranscriptEvent) -> EventKind:
             return "mode"
         case OtherEvent():
             return "other"
+        case AttachmentEvent():
+            return "attachment"
 
 
 def event_text(event: TranscriptEvent) -> str:
@@ -383,7 +396,7 @@ def event_text(event: TranscriptEvent) -> str:
 
 def event_meta(event: TranscriptEvent) -> EntryMeta | None:
     match event:
-        case UserEvent(meta=meta) | AssistantEvent(meta=meta) | SystemEvent(meta=meta):
+        case UserEvent(meta=meta) | AssistantEvent(meta=meta) | SystemEvent(meta=meta) | AttachmentEvent(meta=meta):
             return meta
         case _:
             return None

{cc_transcript-10.7.0 → cc_transcript-11.0.0}/cc_transcript/judge/verdicts.py

@@ -282,6 +282,7 @@ class VerdictStoreMixin:
         prompt_version: int,
         limit: int | None = None,
         refresh_summary: bool = False,
+        probe_hydration: bool = True,
     ) -> list[dict[str, object]]:
         """Returns events lacking a verdict for ``(role, prompt_version)``, unjudged first.
 
@@ -298,7 +299,15 @@ class VerdictStoreMixin:
                 full fidelity once their windows hydrate again. A summary row
                 whose context window no longer hydrates — its transcript expired
                 or a ref was compacted away — is dropped, so a dead transcript
-                stops burning the cap.
+                stops burning the cap (unless ``probe_hydration`` is False).
+            probe_hydration: When True (default), each summary-refresh row is
+                probed with a transcript-discovery hydration check and dropped
+                when its window no longer hydrates. When False, that per-row
+                probe — and the recursive transcript scan behind it — is skipped
+                entirely: every summary-refresh row is returned unprobed, so some
+                may name a transcript that is no longer discoverable. Only the
+                ``refresh_summary`` path probes, so this flag is a no-op
+                otherwise. The default preserves the probing behavior exactly.
 
         Returns:
             One dict per event with the columns needed to build its prompt.
@@ -327,7 +336,8 @@ class VerdictStoreMixin:
         ) as cur:
             async for raw in cur:
                 row = dict(raw)
-                if row.pop("verdict_id") is None or await hydratable(str(row["context_json"])):
+                fresh = row.pop("verdict_id") is None
+                if not probe_hydration or fresh or await hydratable(str(row["context_json"])):
                     kept.append(row)
                     if limit is not None and len(kept) >= limit:
                         break

{cc_transcript-10.7.0 → cc_transcript-11.0.0}/cc_transcript/mining/__init__.py

@@ -24,6 +24,8 @@ from __future__ import annotations
 from cc_transcript.filterspec import (
     ANSWERED_PREFIX,
     ANSWERED_TRAILER,
+    DENIAL_KIND_PERMISSION_RULE,
+    DENIAL_KIND_USER_REJECTED,
     DENIAL_PREFIX,
     USER_SAID_MARKER,
     USER_SAID_TRAILER,

{cc_transcript-10.7.0 → cc_transcript-11.0.0}/cc_transcript/mining/signals.py

@@ -20,6 +20,7 @@ and reasons instead of re-deriving them.
 
 from __future__ import annotations
 
+from collections.abc import Mapping
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, NamedTuple
 
@@ -61,12 +62,19 @@ from cc_transcript.mining.spec import (
     regex_review_comments,
     score_user_message,
 )
-from cc_transcript.models import AssistantEvent, ModeEvent, ToolResultBlock, ToolUseBlock, UserEvent
-from cc_transcript.tools import matches_names
+from cc_transcript.models import (
+    AssistantEvent,
+    ModeEvent,
+    ToolResultBlock,
+    ToolUseBlock,
+    UserEvent,
+    parse_questions,
+)
+from cc_transcript.tools import AskUserQuestionResult, matches_names
 
 if TYPE_CHECKING:
     import re
-    from collections.abc import Iterator, Mapping, Sequence
+    from collections.abc import Iterator, Sequence
     from datetime import datetime
     from typing import Any
 
@@ -416,16 +424,6 @@ class AnsweredPair(NamedTuple):
     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) :]
@@ -534,18 +532,47 @@ def question_answer_signal(
     )
 
 
+def structured_answered_pairs(payload: Mapping[str, Any], use: ToolUseBlock) -> Iterator[AnsweredPair]:
+    result = AskUserQuestionResult.from_raw("AskUserQuestion", payload)
+    questions = parse_questions(payload.get("questions"))
+    for question in use.questions or () if questions is None else questions:
+        annotation = result.annotations.get(question.question)
+        yield AnsweredPair(
+            question,
+            result.answers.get(question.question),
+            annotation.preview if annotation is not None else None,
+            annotation.notes if annotation is not None else None,
+        )
+
+
+def banner_answered_pairs(block: ToolResultBlock, use: ToolUseBlock) -> Iterator[AnsweredPair]:
+    if (
+        block.is_error
+        or not block.content.startswith(ANSWERED_PREFIX)
+        or not block.content.endswith(ANSWERED_TRAILER)
+        or (questions := use.questions) is None
+    ):
+        return
+    yield from answered_pairs(block.content[len(ANSWERED_PREFIX) : -len(ANSWERED_TRAILER)], questions)
+
+
+def question_pairs(block: ToolResultBlock, use: ToolUseBlock) -> Iterator[AnsweredPair]:
+    if not block.is_error and isinstance(payload := block.tool_use_result, Mapping) and "answers" in payload:
+        return structured_answered_pairs(payload, use)
+    return banner_answered_pairs(block, use)
+
+
 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)
+        for block in event.blocks
+        if isinstance(block, ToolResultBlock)
         if (use := uses.get(block.tool_use_id)) is not None
         if use.name == "AskUserQuestion"
-        if block.content.endswith(ANSWERED_TRAILER)
-        if (questions := use.questions) is not None
-        for pair in answered_pairs(block.content[len(ANSWERED_PREFIX) : -len(ANSWERED_TRAILER)], questions)
+        for pair in question_pairs(block, use)
         if (signal := question_answer_signal(events, event, index, pair, spec)) is not None
     )