cc-transcript 14.2.0__tar.gz → 14.5.0__tar.gz

{cc_transcript-14.2.0 → cc_transcript-14.5.0}/PKG-INFO

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

{cc_transcript-14.2.0 → cc_transcript-14.5.0}/cc_transcript/__init__.py

@@ -53,6 +53,7 @@ EXPORTS: dict[str, str] = {
             "ReadResult",
             "SkillCall",
             "SkillResult",
+            "SpanEditCall",
             "TaskCall",
             "TaskCreateCall",
             "TaskLaunchResult",
@@ -76,7 +77,9 @@ EXPORTS: dict[str, str] = {
             "mcp_parts",
             "parse_tool_call",
             "parse_tool_result",
+            "register_mcp_tool",
             "tool_name_matches",
+            "unregister_mcp_tool",
         ),
         "cc_transcript.command": (
             "Command",
@@ -142,10 +145,25 @@ EXPORTS: dict[str, str] = {
         "cc_transcript.parser": (
             "parse",
             "parse_event",
+            "parse_events",
             "parse_events_from_bytes",
             "parse_print_result",
             "stream",
         ),
+        "cc_transcript.synthetic": (
+            "assistant_line",
+            "meta_fields",
+            "mode_line",
+            "other_line",
+            "synthetic_assistant_event",
+            "synthetic_user_event",
+            "system_line",
+            "text_block",
+            "thinking_block",
+            "tool_result",
+            "tool_use",
+            "user_line",
+        ),
         "cc_transcript.cost": (
             "PRICING",
             "CostBreakdown",

{cc_transcript-14.2.0 → cc_transcript-14.5.0}/cc_transcript/__init__.pyi

@@ -187,6 +187,7 @@ from cc_transcript.notifications import (
 from cc_transcript.parser import (
     parse as parse,
     parse_event as parse_event,
+    parse_events as parse_events,
     parse_events_from_bytes as parse_events_from_bytes,
     parse_print_result as parse_print_result,
     stream as stream,
@@ -207,6 +208,21 @@ from cc_transcript.render import (
     render_turn as render_turn,
 )
 
+from cc_transcript.synthetic import (
+    assistant_line as assistant_line,
+    meta_fields as meta_fields,
+    mode_line as mode_line,
+    other_line as other_line,
+    synthetic_assistant_event as synthetic_assistant_event,
+    synthetic_user_event as synthetic_user_event,
+    system_line as system_line,
+    text_block as text_block,
+    thinking_block as thinking_block,
+    tool_result as tool_result,
+    tool_use as tool_use,
+    user_line as user_line,
+)
+
 from cc_transcript.tools import (
     AskUserQuestionResult as AskUserQuestionResult,
     BashCall as BashCall,
@@ -227,6 +243,7 @@ from cc_transcript.tools import (
     ReadResult as ReadResult,
     SkillCall as SkillCall,
     SkillResult as SkillResult,
+    SpanEditCall as SpanEditCall,
     TOOL_ALIASES as TOOL_ALIASES,
     TaskCall as TaskCall,
     TaskCreateCall as TaskCreateCall,
@@ -251,7 +268,9 @@ from cc_transcript.tools import (
     mcp_parts as mcp_parts,
     parse_tool_call as parse_tool_call,
     parse_tool_result as parse_tool_result,
+    register_mcp_tool as register_mcp_tool,
     tool_name_matches as tool_name_matches,
+    unregister_mcp_tool as unregister_mcp_tool,
 )
 
 from cc_transcript.watch import (
@@ -360,6 +379,7 @@ __all__ = [
     "SessionId",
     "SkillCall",
     "SkillResult",
+    "SpanEditCall",
     "StopHookSummary",
     "SubagentIndex",
     "SubagentSession",
@@ -406,6 +426,7 @@ __all__ = [
     "WriteResult",
     "annotate_spec",
     "apply_spec",
+    "assistant_line",
     "build_spec",
     "canonical_json",
     "capture_window",
@@ -440,15 +461,20 @@ __all__ = [
     "mcp_access",
     "mcp_parts",
     "mcp_summary",
+    "meta_fields",
+    "mode_line",
     "native_user_classifier",
+    "other_line",
     "parse",
     "parse_command_line",
     "parse_event",
+    "parse_events",
     "parse_events_from_bytes",
     "parse_print_result",
     "parse_tool_call",
     "parse_tool_result",
     "record_harvest",
+    "register_mcp_tool",
     "render_session",
     "render_tool_call",
     "render_turn",
@@ -457,9 +483,18 @@ __all__ = [
     "result_index",
     "stream",
     "subagent_paths",
+    "synthetic_assistant_event",
+    "synthetic_user_event",
+    "system_line",
+    "text_block",
+    "thinking_block",
     "thinking_chars",
     "tool_digest",
     "tool_facts",
     "tool_name_matches",
+    "tool_result",
+    "tool_use",
     "tool_uses",
+    "unregister_mcp_tool",
+    "user_line",
 ]

{cc_transcript-14.2.0 → cc_transcript-14.5.0}/cc_transcript/_native.pyi

@@ -1,6 +1,7 @@
 # This file is automatically generated by pyo3_stub_gen
 # ruff: noqa: E501, F401, F403, F405
 
+import asyncio
 import builtins
 from cc_transcript import command
 from cc_transcript import ids
@@ -72,6 +73,7 @@ __all__ = [
     "ServerToolUse",
     "SkillCall",
     "SkillResult",
+    "SpanEditCall",
     "SpecMatcher",
     "StopHookSummary",
     "SystemEvent",
@@ -133,6 +135,7 @@ __all__ = [
     "parse_bytes",
     "parse_print_result",
     "query_session",
+    "register_mcp_tool",
     "render_compact_lines",
     "render_haystacks",
     "render_stats",
@@ -147,6 +150,7 @@ __all__ = [
     "tool_name_matches",
     "toolcall_parse_view",
     "toolresult_parse_view",
+    "unregister_mcp_tool",
 ]
 
 @typing.final
@@ -1131,6 +1135,11 @@ class OtherCall(ToolCallBase):
     __match_args__: typing.ClassVar[tuple[str, ...]]
     @property
     def name(self) -> builtins.str: ...
+    @property
+    def error(self) -> typing.Optional[builtins.str]:
+        r"""
+        The strict-parse failure this call degraded from; None when the payload was well-formed but the tool has no typed model.
+        """
 
 @typing.final
 class OtherEvent:
@@ -1439,37 +1448,40 @@ class Redirect:
 @typing.final
 class RustCorrectionLog:
     def __new__(cls, path: builtins.str) -> RustCorrectionLog: ...
-    def append(self, ts_ms: builtins.int, session_id: builtins.str, source: builtins.str, anchor_uuid: builtins.str, incorrect_digest: typing.Optional[builtins.str], incorrect_file: builtins.str, incorrect_old: builtins.str, incorrect_new: builtins.str, correction_origin: typing.Optional[builtins.str], correction_file: typing.Optional[builtins.str], correction_old: typing.Optional[builtins.str], correction_new: typing.Optional[builtins.str], correction_commit: typing.Optional[builtins.str], correction_text: typing.Optional[builtins.str], overlap: builtins.float, detail: typing.Any) -> None: ...
-    def for_session(self, session_id: builtins.str) -> list[dict[str, typing.Any]]: ...
-    def for_repo(self, repo: builtins.str) -> list[dict[str, typing.Any]]: ...
-    def since(self, ts_ms: builtins.int, source: typing.Optional[builtins.str] = None) -> list[dict[str, typing.Any]]: ...
-    def for_anchor(self, session_id: builtins.str, anchor_uuid: builtins.str) -> list[dict[str, typing.Any]]: ...
-    def by_digest(self, session_id: builtins.str, incorrect_digest: builtins.str) -> list[dict[str, typing.Any]]: ...
-    def sql(self, statement: builtins.str) -> list[dict[str, typing.Any]]: ...
+    def open(self) -> asyncio.Future[None]: ...
+    def close(self) -> asyncio.Future[None]: ...
+    def append(self, ts_ms: builtins.int, session_id: builtins.str, source: builtins.str, anchor_uuid: builtins.str, incorrect_digest: typing.Optional[builtins.str], incorrect_file: builtins.str, incorrect_old: builtins.str, incorrect_new: builtins.str, correction_origin: typing.Optional[builtins.str], correction_file: typing.Optional[builtins.str], correction_old: typing.Optional[builtins.str], correction_new: typing.Optional[builtins.str], correction_commit: typing.Optional[builtins.str], correction_text: typing.Optional[builtins.str], overlap: builtins.float, detail: typing.Any) -> asyncio.Future[None]: ...
+    def for_session(self, session_id: builtins.str) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
+    def for_repo(self, repo: builtins.str) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
+    def since(self, ts_ms: builtins.int, source: typing.Optional[builtins.str] = None) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
+    def for_anchor(self, session_id: builtins.str, anchor_uuid: builtins.str) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
+    def by_digest(self, session_id: builtins.str, incorrect_digest: builtins.str) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
+    def sql(self, statement: builtins.str) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
 
 @typing.final
 class RustFeedbackStore:
     def __new__(cls, path: builtins.str, extra_ddl: typing.Sequence[builtins.str], event_columns: typing.Sequence[builtins.str], migrations: typing.Sequence[tuple[builtins.str, builtins.str, builtins.str, typing.Optional[builtins.str]]], verdict_table: builtins.str, accepted_column: builtins.str, summary_column: builtins.str, event_filter: typing.Optional[builtins.str], readonly: builtins.bool = False, busy_timeout_ms: typing.Optional[builtins.int] = None) -> RustFeedbackStore: ...
-    def close(self) -> None: ...
-    def sql(self, statement: builtins.str, params: typing.Optional[typing.Sequence[typing.Any]] = None) -> list[dict[str, typing.Any]]: ...
-    def execute(self, statement: builtins.str, params: typing.Optional[typing.Sequence[typing.Any]] = None) -> builtins.int: ...
-    def executemany(self, statement: builtins.str, seq: typing.Sequence[typing.Sequence[typing.Any]]) -> builtins.int: ...
-    def executescript(self, script: builtins.str) -> None: ...
-    def last_insert_rowid(self) -> builtins.int: ...
-    def load_extension(self, path: builtins.str) -> None: ...
-    def begin_immediate(self) -> None: ...
-    def commit(self) -> None: ...
-    def rollback(self) -> None: ...
-    def insert_candidates(self, rows: typing.Sequence[typing.Sequence[typing.Any]], extras: typing.Optional[typing.Sequence[typing.Sequence[typing.Any]]] = None) -> builtins.list[builtins.str]: ...
-    def record_file(self, path: builtins.str, mtime: builtins.float) -> None: ...
-    def file_mtimes(self) -> list[dict[str, typing.Any]]: ...
-    def stats(self) -> tuple[int, int, list[dict[str, typing.Any]]]: ...
-    def recent(self, source_kind: typing.Optional[builtins.str] = None, limit: builtins.int = 20) -> list[dict[str, typing.Any]]: ...
-    def events(self, source_kind: typing.Optional[builtins.str] = None) -> list[dict[str, typing.Any]]: ...
-    def dedup_keys(self) -> builtins.list[builtins.str]: ...
-    def record_verdict(self, dedup_key: builtins.str, role: builtins.str, prompt_version: builtins.int, model: builtins.str, category: builtins.str, accepted: builtins.bool, summary: builtins.str, confidence: builtins.float, rationale: builtins.str, canonical_key: typing.Optional[builtins.str], fidelity: builtins.str, judged_at: builtins.str) -> builtins.bool: ...
-    def unjudged(self, role: builtins.str, prompt_version: builtins.int, refresh_summary: builtins.bool = False, limit: typing.Optional[builtins.int] = None, offset: typing.Optional[builtins.int] = None) -> list[dict[str, typing.Any]]: ...
-    def judged(self, role: builtins.str, prompt_version: builtins.int) -> list[dict[str, typing.Any]]: ...
+    def open(self) -> asyncio.Future[None]: ...
+    def close(self) -> asyncio.Future[None]: ...
+    def sql(self, statement: builtins.str, params: typing.Optional[typing.Sequence[typing.Any]] = None) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
+    def execute(self, statement: builtins.str, params: typing.Optional[typing.Sequence[typing.Any]] = None) -> asyncio.Future[int]: ...
+    def executemany(self, statement: builtins.str, seq: typing.Sequence[typing.Sequence[typing.Any]]) -> asyncio.Future[int]: ...
+    def executescript(self, script: builtins.str) -> asyncio.Future[None]: ...
+    def last_insert_rowid(self) -> asyncio.Future[int]: ...
+    def load_extension(self, path: builtins.str) -> asyncio.Future[None]: ...
+    def begin_immediate(self) -> asyncio.Future[None]: ...
+    def commit(self) -> asyncio.Future[None]: ...
+    def rollback(self) -> asyncio.Future[None]: ...
+    def insert_candidates(self, rows: typing.Sequence[typing.Sequence[typing.Any]], extras: typing.Optional[typing.Sequence[typing.Sequence[typing.Any]]] = None) -> asyncio.Future[list[str]]: ...
+    def record_file(self, path: builtins.str, mtime: builtins.float) -> asyncio.Future[None]: ...
+    def file_mtimes(self) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
+    def stats(self) -> asyncio.Future[tuple[int, int, list[dict[str, typing.Any]]]]: ...
+    def recent(self, source_kind: typing.Optional[builtins.str] = None, limit: builtins.int = 20) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
+    def events(self, source_kind: typing.Optional[builtins.str] = None) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
+    def dedup_keys(self) -> asyncio.Future[list[str]]: ...
+    def record_verdict(self, dedup_key: builtins.str, role: builtins.str, prompt_version: builtins.int, model: builtins.str, category: builtins.str, accepted: builtins.bool, summary: builtins.str, confidence: builtins.float, rationale: builtins.str, canonical_key: typing.Optional[builtins.str], fidelity: builtins.str, judged_at: builtins.str) -> asyncio.Future[bool]: ...
+    def unjudged(self, role: builtins.str, prompt_version: builtins.int, refresh_summary: builtins.bool = False, limit: typing.Optional[builtins.int] = None, offset: typing.Optional[builtins.int] = None) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
+    def judged(self, role: builtins.str, prompt_version: builtins.int) -> asyncio.Future[list[dict[str, typing.Any]]]: ...
 
 @typing.final
 class ServerToolUse:
@@ -1514,6 +1526,27 @@ class SkillResult(ToolResultBase):
     @property
     def allowed_tools(self) -> tuple[str, ...] | None: ...
 
+@typing.final
+class SpanEditCall(ToolCallBase):
+    r"""
+    An in-place file edit addressed by an opaque locator.
+
+    A registered MCP tool whose spec carries a span-edit lowering. The payload
+    carries no pre-image, so :func:`hunks_of` yields no hunk; ``new`` is ``None``
+    when the call deletes rather than writes. Registrations are process-local.
+
+    Attributes:
+        file_path: The file the edit targets.
+        new: The written content, or ``None`` when the call is a deletion.
+    """
+    __match_args__: typing.ClassVar[tuple[str, ...]]
+    @property
+    def name(self) -> builtins.str: ...
+    @property
+    def file_path(self) -> builtins.str: ...
+    @property
+    def new(self) -> typing.Optional[builtins.str]: ...
+
 @typing.final
 class SpecMatcher:
     def __new__(cls, spec_json: builtins.str) -> SpecMatcher: ...
@@ -2147,6 +2180,8 @@ def hunks_of(call: tools.ToolCall | tools.FallbackCall) -> tuple[Hunk, ...]:
 
     MultiEdit yields one hunk per span in application order — never just the
     first. Write and NotebookEdit are pure additions with an empty old side.
+    :class:`~SpanEditCall` yields none: its payload carries no
+    pre-image, so no honest hunk can be derived.
     """
 
 def ids_canonical_json(value_json: builtins.str) -> builtins.str: ...
@@ -2166,19 +2201,16 @@ def matches_names(actual: builtins.str, names: collections.abc.Container[str]) -
     Whether ``actual`` is one of ``names``, exactly or as an MCP tool suffix.
 
     True when ``actual`` is in ``names``, or when it splits as
-    ``mcp__<server>__<tool>`` on the first two ``__`` and ``<tool>`` — or its
-    native built-in edit-gate equivalent — is in ``names``. That alias closes
-    the edit-gate bypass where cc-context's ``ccx_code_edit`` /
-    ``ccx_code_replace`` write through the MCP under names no ``Edit``/``Write``
-    gate would catch. Display-name aliases from
-    :data:`~tools.TOOL_ALIASES` are not closed over — ``names`` is
-    taken verbatim; pre-expand with :func:`expand_tool_names` for those.
+    ``mcp__<server>__<tool>`` on the first two ``__`` and ``<tool>`` — or the
+    built-in gate its registered spec ``behaves_like`` — is in ``names``. That
+    closure lets a registered MCP tool (e.g. one that gates as ``Edit``) match an
+    ``Edit`` gate even under a name no built-in gate would catch. Display-name
+    aliases from :data:`~tools.TOOL_ALIASES` are not closed over —
+    ``names`` is taken verbatim; pre-expand with :func:`expand_tool_names` for those.
 
     Example:
         >>> matches_names("mcp__github__Grep", {"Grep"})
         True
-        >>> matches_names("mcp__cc-context__ccx_code_edit", {"Edit"})
-        True
         >>> matches_names("Execute", {"Bash"})
         False
     """
@@ -2230,6 +2262,16 @@ def parse_print_result(raw: bytes) -> PrintResult: ...
 
 def query_session(path: builtins.str, max_events: builtins.int) -> dict[str, typing.Any]: ...
 
+def register_mcp_tool(tool: builtins.str, behaves_like: builtins.str, span_edit: collections.abc.Mapping[str, str] | None = None) -> None:
+    r"""
+    Register an MCP tool spec, keyed by its bare segment; last write wins.
+
+    ``behaves_like`` names the built-in gate the tool matches. ``span_edit``, when
+    given, maps the payload key names — ``path``, ``content``, and optionally
+    ``delete`` — the tool's :class:`~SpanEditCall` lowering
+    reads. Registrations are process-local.
+    """
+
 def render_compact_lines(raw: bytes, width: builtins.int, thinking: builtins.bool, uuids: builtins.bool) -> builtins.list[builtins.str]: ...
 
 def render_haystacks(raw: bytes, wheres: typing.Sequence[builtins.str]) -> builtins.list[builtins.str]: ...
@@ -2275,3 +2317,8 @@ def toolresult_parse_view(name: builtins.str, payload_json: builtins.str) -> too
     the typed view hierarchy; the ``cc_transcript.tools`` facade owns the public
     signature.
     """
+
+def unregister_mcp_tool(tool: builtins.str) -> builtins.bool:
+    r"""
+    Unregister an MCP tool by its bare segment; returns whether it was registered.
+    """

{cc_transcript-14.2.0 → cc_transcript-14.5.0}/cc_transcript/corrections.py

@@ -26,6 +26,7 @@ from cc_transcript.literals import literal_str
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
+    from types import TracebackType
     from typing import Any
 
     from cc_transcript.ids import EventUuid, SessionId, ToolDigest
@@ -93,16 +94,16 @@ class CorrectionLog:
     the module docstring).
 
     Example:
-        >>> log = CorrectionLog.open()
-        >>> log.append(correction)
-        >>> log.by_digest(session_id, incorrect_digest=digest)
+        >>> async with await CorrectionLog.open() as log:
+        ...     await log.append(correction)
+        ...     await log.by_digest(session_id, incorrect_digest=digest)
     """
 
     def __init__(self, engine: _native.RustCorrectionLog) -> None:
         self._engine = engine
 
     @classmethod
-    def open(cls, path: Path | None = None) -> Self:
+    async def open(cls, path: Path | None = None) -> Self:
         """Opens (creating if needed) the ledger at ``path``.
 
         Args:
@@ -113,17 +114,37 @@ class CorrectionLog:
             The opened log.
         """
         path = path or Path.home() / ".cc-transcript" / "corrections.db"
-        path.parent.mkdir(parents=True, exist_ok=True)
-        return cls(_native.RustCorrectionLog(str(path)))
-
-    def append(self, record: Correction) -> None:
+        engine = _native.RustCorrectionLog(str(path))
+        try:
+            await engine.open()
+        except BaseException:
+            await engine.close()
+            raise
+        return cls(engine)
+
+    async def close(self) -> None:
+        """Closes the underlying connection; a second close is a no-op."""
+        await self._engine.close()
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        await self.close()
+
+    async def append(self, record: Correction) -> None:
         """Appends ``record`` as a single ``INSERT OR IGNORE``.
 
         Idempotent on the table's UNIQUE key, so re-running a writer writes one
         row; SQLite treats NULL key columns as distinct, so rows whose key
         carries a NULL rely on the writer not repeating the same values.
         """
-        self._engine.append(
+        await self._engine.append(
             record.ts_ms,
             record.session_id,
             record.source,
@@ -142,39 +163,39 @@ class CorrectionLog:
             record.detail,
         )
 
-    def for_session(self, session_id: SessionId) -> tuple[Correction, ...]:
+    async def for_session(self, session_id: SessionId) -> tuple[Correction, ...]:
         """All records for ``session_id``, ordered by timestamp."""
-        return tuple(Correction(**row) for row in self._engine.for_session(session_id))
+        return tuple(Correction(**row) for row in await self._engine.for_session(session_id))
 
-    def for_repo(self, repo: str) -> tuple[Correction, ...]:
+    async def for_repo(self, repo: str) -> tuple[Correction, ...]:
         """All corrections whose ``detail.repo`` is ``repo``, ordered by timestamp.
 
         The repo key producers stamp into ``detail`` so a per-repo consumer (the
         captain-hook reviewer) can pull every correction for its repo at once.
         """
-        return tuple(Correction(**row) for row in self._engine.for_repo(repo))
+        return tuple(Correction(**row) for row in await self._engine.for_repo(repo))
 
-    def since(self, ts_ms: int, *, source: str | None = None) -> tuple[Correction, ...]:
+    async def since(self, ts_ms: int, *, source: str | None = None) -> tuple[Correction, ...]:
         """Corrections with ``ts_ms`` strictly greater than ``ts_ms``, oldest first.
 
         A cursor read for incremental consumers; pass ``source`` to scope to one
         producer.
         """
-        return tuple(Correction(**row) for row in self._engine.since(ts_ms, source))
+        return tuple(Correction(**row) for row in await self._engine.since(ts_ms, source))
 
-    def for_anchor(self, session_id: SessionId, anchor_uuid: EventUuid) -> tuple[Correction, ...]:
+    async def for_anchor(self, session_id: SessionId, anchor_uuid: EventUuid) -> tuple[Correction, ...]:
         """The corrections harvested around one feedback ``anchor_uuid``."""
-        return tuple(Correction(**row) for row in self._engine.for_anchor(session_id, anchor_uuid))
+        return tuple(Correction(**row) for row in await self._engine.for_anchor(session_id, anchor_uuid))
 
-    def by_digest(self, session_id: SessionId, *, incorrect_digest: ToolDigest) -> tuple[Correction, ...]:
+    async def by_digest(self, session_id: SessionId, *, incorrect_digest: ToolDigest) -> tuple[Correction, ...]:
         """Corrections of the tool call with ``incorrect_digest`` in ``session_id``.
 
         The cross-consumer join: pass the ``tool_digest`` a hook recorded in
         the ``decisions`` ledger to learn whether that exact edit was later
         corrected.
         """
-        return tuple(Correction(**row) for row in self._engine.by_digest(session_id, incorrect_digest))
+        return tuple(Correction(**row) for row in await self._engine.by_digest(session_id, incorrect_digest))
 
-    def sql(self, statement: str) -> list[dict[str, Any]]:
+    async def sql(self, statement: str) -> list[dict[str, Any]]:
         """Runs one raw SQL ``statement`` — the escape hatch behind ``corrections sql``."""
-        return self._engine.sql(statement)
+        return await self._engine.sql(statement)

{cc_transcript-14.2.0 → cc_transcript-14.5.0}/cc_transcript/decisions.py

@@ -14,7 +14,7 @@ import sqlite3
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Literal
 
-from cc_transcript.ledger import SyncLedger
+from cc_transcript.ledger import AsyncLedger
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
@@ -87,7 +87,7 @@ class Decision:
     detail: Mapping[str, Any] = field(default_factory=dict)
 
 
-class DecisionLog(SyncLedger[Decision]):
+class DecisionLog(AsyncLedger[Decision]):
     """The ``decisions`` ledger at ``~/.cc-transcript/decisions.db``.
 
     Opened in WAL mode with a busy timeout because cc-review's Go daemon
@@ -95,9 +95,10 @@ class DecisionLog(SyncLedger[Decision]):
     auto-dropped. Requires a local disk — WAL does not work over NFS.
 
     Example:
-        >>> log = DecisionLog.open()
-        >>> log.append(decision)
-        >>> log.attribute_tool(session_id, tool_digest=digest, near_ts_ms=ts)
+        >>> log = await DecisionLog.open()
+        >>> async with log:
+        ...     await log.append(decision)
+        ...     await log.attribute_tool(session_id, tool_digest=digest, near_ts_ms=ts)
     """
 
     DDL = DECISIONS_DDL
@@ -134,7 +135,7 @@ class DecisionLog(SyncLedger[Decision]):
             detail=json.loads(row["detail_json"]),
         )
 
-    def attribute_tool(
+    async def attribute_tool(
         self, session_id: SessionId, *, tool_digest: ToolDigest, near_ts_ms: int, window_ms: int = 300_000
     ) -> Decision | None:
         """The nearest decision preceding ``near_ts_ms`` with this digest.
@@ -148,14 +149,17 @@ class DecisionLog(SyncLedger[Decision]):
             The matching decision, or None when no digest-equal row lies in
             ``[near_ts_ms - window_ms, near_ts_ms]``.
         """
-        row = self.conn.execute(
-            "SELECT * FROM decisions WHERE session_id = ? AND tool_digest = ? AND ts_ms BETWEEN ? AND ?"
-            " ORDER BY ts_ms DESC, id DESC LIMIT 1",
-            (session_id, tool_digest, near_ts_ms - window_ms, near_ts_ms),
-        ).fetchone()
+        conn = self._actor.conn
+        row = await self._actor.run(
+            lambda: conn.execute(
+                "SELECT * FROM decisions WHERE session_id = ? AND tool_digest = ? AND ts_ms BETWEEN ? AND ?"
+                " ORDER BY ts_ms DESC, id DESC LIMIT 1",
+                (session_id, tool_digest, near_ts_ms - window_ms, near_ts_ms),
+            ).fetchone()
+        )
         return self.row_to_record(row) if row else None
 
-    def attribute_nearest(
+    async def attribute_nearest(
         self,
         session_id: SessionId,
         *,
@@ -175,10 +179,13 @@ class DecisionLog(SyncLedger[Decision]):
             The nearest matching decision, or None when none lies in
             ``[near_ts_ms - window_ms, near_ts_ms + window_ms]``.
         """
+        conn = self._actor.conn
         kind_clause, kind_params = ("AND kind = ? ", (kind,)) if kind is not None else ("", ())
-        row = self.conn.execute(
-            f"SELECT * FROM decisions WHERE session_id = ? AND event = ? {kind_clause}AND ts_ms BETWEEN ? AND ?"
-            " ORDER BY ABS(ts_ms - ?), id DESC LIMIT 1",
-            (session_id, event, *kind_params, near_ts_ms - window_ms, near_ts_ms + window_ms, near_ts_ms),
-        ).fetchone()
+        row = await self._actor.run(
+            lambda: conn.execute(
+                f"SELECT * FROM decisions WHERE session_id = ? AND event = ? {kind_clause}AND ts_ms BETWEEN ? AND ?"
+                " ORDER BY ABS(ts_ms - ?), id DESC LIMIT 1",
+                (session_id, event, *kind_params, near_ts_ms - window_ms, near_ts_ms + window_ms, near_ts_ms),
+            ).fetchone()
+        )
         return self.row_to_record(row) if row else None

{cc_transcript-14.2.0 → cc_transcript-14.5.0}/cc_transcript/evidence.py

@@ -199,7 +199,7 @@ def run_git(repo: Path, *args: str) -> str | None:
     return proc.stdout if proc.returncode == 0 else None
 
 
-def record_harvest(
+async def record_harvest(
     log: CorrectionLog,
     activity: SessionActivity,
     anchor: EventRef,
@@ -219,7 +219,7 @@ def record_harvest(
     """
     rows = [correction for pair in pairs if (correction := lower_pair(activity, anchor, pair, source=source))]
     for row in rows:
-        log.append(row)
+        await log.append(row)
     return len(rows)
 
 

{cc_transcript-14.2.0 → cc_transcript-14.5.0}/cc_transcript/extract/correct.py

@@ -163,7 +163,7 @@ async def extract_correction(
     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 log.for_anchor(anchor.session_id, anchor.event_uuid):
+    if await log.for_anchor(anchor.session_id, anchor.event_uuid):
         return None
     pairs = await asyncio.to_thread(harvest_pairs, activity, anchor, repo=repo)
     if not pairs or (turn := activity.turn_of(anchor)) is None:
@@ -173,5 +173,5 @@ async def extract_correction(
         return None
     if repo is not None:
         row = replace(row, detail={"repo": str(repo)})
-    log.append(row)
+    await log.append(row)
     return row