cc-transcript 14.4.0__tar.gz → 14.6.0__tar.gz

{cc_transcript-14.4.0 → cc_transcript-14.6.0}/PKG-INFO

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

{cc_transcript-14.4.0 → cc_transcript-14.6.0}/cc_transcript/__init__.py

@@ -87,6 +87,7 @@ EXPORTS: dict[str, str] = {
             "CommandLineQuery",
             "Occurrence",
             "Redirect",
+            "Word",
             "command_prefixes",
             "parse_command_line",
         ),

{cc_transcript-14.4.0 → cc_transcript-14.6.0}/cc_transcript/__init__.pyi

@@ -33,6 +33,7 @@ from cc_transcript.command import (
     CommandLineQuery as CommandLineQuery,
     Occurrence as Occurrence,
     Redirect as Redirect,
+    Word as Word,
     command_prefixes as command_prefixes,
     parse_command_line as parse_command_line,
 )
@@ -421,6 +422,7 @@ __all__ = [
     "UserEvent",
     "WatchEvent",
     "Watcher",
+    "Word",
     "WorkflowCall",
     "WriteCall",
     "WriteResult",

{cc_transcript-14.4.0 → cc_transcript-14.6.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
@@ -94,6 +95,7 @@ __all__ = [
     "Usage",
     "UserEvent",
     "WatchTailer",
+    "Word",
     "WorkflowCall",
     "WriteCall",
     "WriteResult",
@@ -410,6 +412,11 @@ class Command:
     @property
     def span(self) -> typing.Optional[tuple[builtins.int, builtins.int]]: ...
     @property
+    def words(self) -> tuple[Word, ...]:
+        r"""
+        The structural words: ``words[0]`` is the executable, ``words[1:]`` parallel ``args``.
+        """
+    @property
     def argv(self) -> tuple[str, ...]: ...
     @property
     def program(self) -> builtins.str: ...
@@ -469,6 +476,11 @@ class CommandLine:
     def parse(cls, raw: builtins.str) -> CommandLine: ...
     @staticmethod
     def dequote(text: builtins.str) -> builtins.str: ...
+    @staticmethod
+    def quote(text: builtins.str) -> builtins.str:
+        r"""
+        Quote ``text`` as one POSIX-sh word, with Python ``shlex.quote`` semantics.
+        """
     def splice(self, replacements: typing.Mapping[builtins.int, builtins.str]) -> builtins.str: ...
     def rewrite_occurrences(self, to: collections.abc.Callable[[Occurrence], str | None]) -> typing.Optional[builtins.str]: ...
     def __iter__(self) -> collections.abc.Iterator[Command]: ...
@@ -1086,7 +1098,30 @@ class Occurrence:
     def next_op(self) -> typing.Optional[builtins.str]: ...
     @property
     def piped(self) -> builtins.bool: ...
+    @property
+    def nesting(self) -> builtins.int:
+        r"""
+        Substitution/payload hops below top level; 0 for a top-level command.
+        """
+    @property
+    def host(self) -> Occurrence | None:
+        r"""
+        The occurrence hosting this nested part, or None at top level.
+        """
+    @property
+    def quote_contexts(self) -> tuple[str, ...]:
+        r"""
+        Enclosing payload quote layers outermost-first: ``"'"``, ``'"'``, or ``""`` (bare).
+        """
     def __new__(cls, line: CommandLine, index: builtins.int) -> Occurrence: ...
+    def embeddable(self, text: builtins.str) -> builtins.bool:
+        r"""
+        Whether splicing ``text`` at this occurrence survives every enclosing quote layer.
+        """
+    def quote_for(self, text: builtins.str) -> typing.Optional[builtins.str]:
+        r"""
+        One shell-word spelling of ``text`` that survives every enclosing layer, or None.
+        """
 
 @typing.final
 class OtherAttachment:
@@ -1447,37 +1482,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:
@@ -2059,6 +2097,27 @@ class WatchTailer:
         size, mtime, session_id, seen}}}`, the Python `TailState` projection.
         """
 
+@typing.final
+class Word:
+    r"""
+    One structural word of a parsed command (``Command.words``).
+    Attributes:
+        raw: verbatim source text.
+        value: literal with quotes/escapes removed; None when an expansion taints it.
+        span: byte span in the owning ``CommandLine.raw``; None without verbatim source.
+        expandable: bash would glob/brace/tilde-expand despite the literal value.
+    """
+    __match_args__: typing.ClassVar[tuple[str, ...]]
+    @property
+    def raw(self) -> builtins.str: ...
+    @property
+    def value(self) -> typing.Optional[builtins.str]: ...
+    @property
+    def span(self) -> typing.Optional[tuple[builtins.int, builtins.int]]: ...
+    @property
+    def expandable(self) -> builtins.bool: ...
+    def __new__(cls, raw: builtins.str, value: typing.Optional[builtins.str] = None, span: typing.Optional[tuple[builtins.int, builtins.int]] = None, expandable: builtins.bool = False) -> Word: ...
+
 @typing.final
 class WorkflowCall(ToolCallBase):
     r"""
@@ -2158,7 +2217,7 @@ def discovery_subagent_paths(path: builtins.str | os.PathLike | pathlib.Path) ->
 
 def discovery_subagent_transcripts(path: builtins.str | os.PathLike | pathlib.Path) -> dict[str, pathlib.Path]: ...
 
-def embedded_literals() -> dict[str, str | float | list[str]]: ...
+def embedded_literals() -> dict[str, str | float | int | list[str]]: ...
 
 def expand_tool_names(spec: builtins.str) -> frozenset[str]:
     r"""

{cc_transcript-14.4.0 → cc_transcript-14.6.0}/cc_transcript/command.py

@@ -18,6 +18,10 @@ from cc_transcript._native import CommandLine as CommandLine
 from cc_transcript._native import CommandLineQuery as CommandLineQuery
 from cc_transcript._native import Occurrence as Occurrence
 from cc_transcript._native import Redirect as Redirect
+from cc_transcript._native import Word as Word
+from cc_transcript.literals import literal_int
+
+PAYLOAD_DEPTH_LIMIT: int = literal_int("command.PAYLOAD_DEPTH_LIMIT")
 
 parse_command_line = lru_cache(maxsize=4096)(CommandLine.parse)
 

{cc_transcript-14.4.0 → cc_transcript-14.6.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.4.0 → cc_transcript-14.6.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.4.0 → cc_transcript-14.6.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.4.0 → cc_transcript-14.6.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

{cc_transcript-14.4.0 → cc_transcript-14.6.0}/cc_transcript/heartbeats.py

@@ -12,15 +12,15 @@ most one row per ``(session, event)``, so the table stays small however hot the
 
 from __future__ import annotations
 
-import sqlite3
 from dataclasses import dataclass
-from pathlib import Path
 from typing import TYPE_CHECKING, Self
 
 from cc_transcript.decisions import DecisionLog
-from cc_transcript.ledger import open_sqlite
+from cc_transcript.ledger import ConnectionActor, open_sqlite
 
 if TYPE_CHECKING:
+    from pathlib import Path
+
     from cc_transcript.ids import SessionId
 
 HEARTBEATS_DDL = """\
@@ -63,30 +63,42 @@ class HeartbeatLog:
     most one row per event. Requires a local disk — WAL does not work over NFS.
 
     Example:
-        >>> log = HeartbeatLog.open()
-        >>> log.beat(session_id, "PreToolUse", ts_ms)
-        >>> log.for_session(session_id)
+        >>> log = await HeartbeatLog.open()
+        >>> async with log:
+        ...     await log.beat(session_id, "PreToolUse", ts_ms)
+        ...     await log.for_session(session_id)
     """
 
-    def __init__(self, conn: sqlite3.Connection) -> None:
-        self.conn = conn
+    def __init__(self, actor: ConnectionActor) -> None:
+        self._actor = actor
 
     @classmethod
-    def open(cls, path: Path | None = None) -> Self:
+    async def open(cls, path: Path | None = None) -> Self:
         """Opens (creating if needed) the heartbeat table at ``path`` (defaults to ``decisions.db``)."""
-        return cls(open_sqlite(path, filename=DecisionLog.FILENAME, ddl=HEARTBEATS_DDL))
+        actor = ConnectionActor()
+        await actor.start(lambda: open_sqlite(path, filename=DecisionLog.FILENAME, ddl=HEARTBEATS_DDL))
+        return cls(actor)
 
-    def beat(self, session_id: SessionId, event: str, ts_ms: int) -> None:
+    async def beat(self, session_id: SessionId, event: str, ts_ms: int) -> None:
         """Records one dispatch of ``event`` in ``session_id`` at ``ts_ms`` (upsert; ``count += 1``)."""
-        self.conn.execute(
-            "INSERT INTO dispatch_heartbeats (session_id, event, first_ts_ms, last_ts_ms, count) "
-            "VALUES (?, ?, ?, ?, 1) "
-            "ON CONFLICT (session_id, event) DO UPDATE SET last_ts_ms = excluded.last_ts_ms, count = count + 1",
-            (session_id, event, ts_ms, ts_ms),
+        conn = self._actor.conn
+        await self._actor.run(
+            lambda: conn.execute(
+                "INSERT INTO dispatch_heartbeats (session_id, event, first_ts_ms, last_ts_ms, count) "
+                "VALUES (?, ?, ?, ?, 1) "
+                "ON CONFLICT (session_id, event) DO UPDATE SET last_ts_ms = excluded.last_ts_ms, count = count + 1",
+                (session_id, event, ts_ms, ts_ms),
+            )
         )
 
-    def for_session(self, session_id: SessionId) -> tuple[Heartbeat, ...]:
+    async def for_session(self, session_id: SessionId) -> tuple[Heartbeat, ...]:
         """Every ``(session, event)`` beat for ``session_id``, ordered by first dispatch."""
+        conn = self._actor.conn
+        rows = await self._actor.run(
+            lambda: conn.execute(
+                "SELECT * FROM dispatch_heartbeats WHERE session_id = ? ORDER BY first_ts_ms, event", (session_id,)
+            ).fetchall()
+        )
         return tuple(
             Heartbeat(
                 session_id=row["session_id"],
@@ -95,7 +107,15 @@ class HeartbeatLog:
                 last_ts_ms=row["last_ts_ms"],
                 count=row["count"],
             )
-            for row in self.conn.execute(
-                "SELECT * FROM dispatch_heartbeats WHERE session_id = ? ORDER BY first_ts_ms, event", (session_id,)
-            )
+            for row in rows
         )
+
+    async def close(self) -> None:
+        """Closes the underlying connection; a second call is a no-op."""
+        await self._actor.close()
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(self, *exc: object) -> None:
+        await self.close()