capt-hook 4.2.0__tar.gz → 4.3.0__tar.gz

{capt_hook-4.2.0 → capt_hook-4.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: capt-hook
-Version: 4.2.0
+Version: 4.3.0
 Summary: Declarative hook framework for Claude Code
 Keywords: claude,claude-code,hooks,llm,agents,guardrails,cli
 Author: Yasyf Mohamedali
@@ -31,7 +31,7 @@ Requires-Dist: wn>=1.1.0
 Requires-Dist: lazy-object-proxy>=1.12.0
 Requires-Dist: filelock>=3
 Requires-Dist: loguru>=0.7.3
-Requires-Dist: spawnllm>=0.5.0
+Requires-Dist: spawnllm>=0.5.2,<0.6
 Requires-Dist: pytest>=8.0 ; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.24 ; extra == 'dev'
 Requires-Dist: pyright>=1.1 ; extra == 'dev'

{capt_hook-4.2.0 → capt_hook-4.3.0}/captain_hook/__init__.py

@@ -19,10 +19,11 @@ from cc_transcript.tools import (
     WriteCall,
 )
 
-from captain_hook import file, style, utils
+from captain_hook import file, style, util
 from captain_hook.app import hook, on, register
 from captain_hook.command import Command, CommandLine, Redirect
 from captain_hook.context import HookContext
+from captain_hook.durable import DurableSlot, DurableState, DurableStore
 from captain_hook.events import (
     BaseHookEvent,
     NotificationEvent,
@@ -37,6 +38,7 @@ from captain_hook.events import (
     ToolHookEvent,
     UserPromptSubmitEvent,
 )
+from captain_hook.fields import Deque
 from captain_hook.file import File, categorize_files
 from captain_hook.primitives import (
     GateVerdict,
@@ -92,4 +94,4 @@ from captain_hook.types import (
     UsedSkill,
     Waiting,
 )
-from captain_hook.utils import read_json, resolve_binary
+from captain_hook.util import read_json, resolve_binary

{capt_hook-4.2.0 → capt_hook-4.3.0}/captain_hook/context.py

@@ -5,7 +5,7 @@ import subprocess
 from dataclasses import dataclass, replace
 from functools import cached_property
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal
+from typing import TYPE_CHECKING, Any, Literal, overload
 
 from cc_transcript.activity import SessionActivity, meta_of
 from cc_transcript.ids import SessionId
@@ -15,11 +15,10 @@ from cc_transcript.query import Session
 from cc_transcript.render import Budget, render_turn
 from cc_transcript.tools import parse_tool_call
 from pydantic import BaseModel
-from spawnllm import call_sync, extract_sync
+from spawnllm import TModel, TSpecialty, call_sync, extract_sync
 from spawnllm.proc import run_cli
 
 from captain_hook.classifiers import detect
-from captain_hook.llm import LlmBackends, TModel, TSpecialty
 from captain_hook.prompt import Prompt
 from captain_hook.session import SessionStore
 
@@ -265,6 +264,36 @@ class HookContext:
     def current_branch(self) -> str | None:
         return out.strip() if (out := self.git("symbolic-ref", "--short", "HEAD")) else None
 
+    @overload
+    def call_llm[M: BaseModel](
+        self,
+        template: str | Prompt,
+        *args: Any,
+        specialty: TSpecialty = "general",
+        model: TModel = "small",
+        timeout: int = 180,
+        transcript: bool | int | Literal["recent", "full"] = False,
+        diff: bool | str = False,
+        agent: bool = False,
+        response_model: type[M],
+        **kwargs: Any,
+    ) -> M: ...
+
+    @overload
+    def call_llm(
+        self,
+        template: str | Prompt,
+        *args: Any,
+        specialty: TSpecialty = "general",
+        model: TModel = "small",
+        timeout: int = 180,
+        transcript: bool | int | Literal["recent", "full"] = False,
+        diff: bool | str = False,
+        agent: bool = False,
+        response_model: None = None,
+        **kwargs: Any,
+    ) -> str: ...
+
     def call_llm(
         self,
         template: str | Prompt,
@@ -279,21 +308,30 @@ class HookContext:
         **kwargs: Any,
     ) -> str | BaseModel:
         diff_text = self.diff("uncommitted" if diff is True else diff) if diff else None
-        if isinstance(template, Prompt):
-            prompt = str(template.context("diff", diff_text))
-            if transcript:
-                prompt = f"{self.transcript_block(window=transcript_window(transcript))}\n\n<task>\n{prompt}\n</task>"
-        else:
-            block = self.transcript_block(window=transcript_window(transcript)) if transcript else ""
-            if transcript:
-                template = f"{{transcript}}\n\n<task>\n{template}\n</task>"
-            prompt = template.format(*args, **kwargs, transcript=block)
-            if diff_text is not None:
-                prompt = f"<diff>\n{diff_text}\n</diff>\n\n{prompt}"
-        backend = LlmBackends.for_specialty(specialty)
+        prompt = self.assemble_prompt(template, args, kwargs, transcript=transcript, diff_text=diff_text)
         cwd = os.environ.get("CLAUDE_PROJECT_DIR") or os.environ.get("FACTORY_PROJECT_DIR")
         if response_model is not None:
             return extract_sync(
-                prompt, response_model, backend=backend, model=model, agent=agent, cwd=cwd, timeout=timeout
+                prompt, response_model, specialty=specialty, model=model, agent=agent, cwd=cwd, timeout=timeout
             )
-        return call_sync(prompt, backend=backend, model=model, agent=agent, cwd=cwd, timeout=timeout)
+        return call_sync(prompt, specialty=specialty, model=model, agent=agent, cwd=cwd, timeout=timeout)
+
+    def assemble_prompt(
+        self,
+        template: str | Prompt,
+        args: tuple[Any, ...],
+        kwargs: dict[str, Any],
+        *,
+        transcript: bool | int | Literal["recent", "full"],
+        diff_text: str | None,
+    ) -> str:
+        window = transcript_window(transcript) if transcript else None
+        match template:
+            case Prompt():
+                prompt = str(template.context("diff", diff_text))
+                return f"{self.transcript_block(window=window)}\n\n<task>\n{prompt}\n</task>" if transcript else prompt
+            case str():
+                block = self.transcript_block(window=window) if transcript else ""
+                wrapped = f"{{transcript}}\n\n<task>\n{template}\n</task>" if transcript else template
+                body = wrapped.format(*args, **kwargs, transcript=block)
+                return f"<diff>\n{diff_text}\n</diff>\n\n{body}" if diff_text is not None else body

{capt_hook-4.2.0 → capt_hook-4.3.0}/captain_hook/dispatch.py

@@ -23,6 +23,22 @@ def run_declarative(spec: HookSpec, evt: BaseHookEvent) -> HookResult | None:
     )
 
 
+def record_fire(
+    entry: RegisteredHook,
+    evt: BaseHookEvent,
+    result: HookResult,
+    store: SessionStore,
+    hook_state: HookState,
+) -> None:
+    """React to a hook firing: bump and persist the fire count, then record the decision."""
+    hook_state.fire_count += 1
+    store[HookState].set(hook_state)
+    try:
+        record_decision(entry, evt, result)
+    except Exception:
+        logger.bind(hook=entry.name).exception("decision write failed")
+
+
 def execute_hook(
     entry: RegisteredHook,
     evt: BaseHookEvent,
@@ -46,12 +62,7 @@ def execute_hook(
         return None
 
     if result:
-        hook_state.fire_count += 1
-        store[HookState].set(hook_state)
-        try:
-            record_decision(entry, evt, result)
-        except Exception:
-            logger.bind(hook=entry.name).exception("decision write failed")
+        record_fire(entry, evt, result, store, hook_state)
 
     return result
 

capt_hook-4.3.0/captain_hook/durable.py

@@ -0,0 +1,148 @@
+"""Durable, cross-session state: the durable twin of ``SessionStore``.
+
+Where :class:`~captain_hook.SessionStore` is scoped to one session, a
+:class:`DurableStore` persists across sessions, keyed by project (default) or globally.
+Its slots add a ``filelock``-guarded :meth:`DurableSlot.mutate` so concurrent writers
+across sessions never lose an update.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator, Sequence
+from contextlib import contextmanager
+from hashlib import sha256
+from typing import TYPE_CHECKING, Any, ClassVar, Literal, Self
+
+from filelock import FileLock
+from loguru import logger
+from pydantic import BaseModel
+
+from captain_hook.session import SessionSlot
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from captain_hook.events import BaseHookEvent
+
+Scope = Literal["project", "global"]
+
+
+def durable_root() -> Path:
+    from captain_hook.settings import resolve_state_dir
+
+    return resolve_state_dir() / "hooks" / "durable"
+
+
+def project_key(repo_root: Path) -> str:
+    return f"{repo_root.name}-{sha256(str(repo_root.resolve()).encode()).hexdigest()[:16]}"
+
+
+def durable_dir(scope: Scope, repo_root: Path | None) -> Path | None:
+    match scope:
+        case "global":
+            return durable_root() / "global"
+        case "project" if repo_root is not None:
+            return durable_root() / "projects" / project_key(repo_root)
+        case "project":
+            logger.warning("durable project state has no repo_root; not persisting")
+            return None
+        case _:
+            raise ValueError(f"scope must be 'project' or 'global', got {scope!r}")
+
+
+class DurableSlot[M: BaseModel](SessionSlot[M]):
+    """A :class:`SessionSlot` rooted in a durable directory, with a locked :meth:`mutate`."""
+
+    @contextmanager
+    def mutate(self) -> Iterator[M]:
+        """Yield the loaded model under an exclusive file lock; persist it on clean exit.
+
+        The lock is held for the whole ``with`` block, so concurrent writers across sessions
+        serialize rather than clobber. The body must be short — no slow work under the lock.
+        A null slot (project scope with no ``repo_root``) yields an in-memory model and
+        persists nothing.
+        """
+        if self._path is None:
+            yield self.get(self._model())
+            return
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        lock = self._path.with_name(self._path.name + ".lock")
+        with FileLock(str(lock)):
+            obj = self.get(self._model())
+            yield obj
+            self.set(obj)
+
+
+class DurableStore:
+    """Class-keyed durable store providing typed :class:`DurableSlot` access via ``store[Model]``."""
+
+    TRACKED: ClassVar[list[type[BaseModel]]] = []
+
+    def __init__(self, directory: Path | None) -> None:
+        self._dir = directory
+
+    def __getitem__[M: BaseModel](self, model: type[M]) -> DurableSlot[M]:
+        return DurableSlot(self._dir, model)
+
+    def load[M: BaseModel](self, model: type[M]) -> M:
+        return self[model].get(model())
+
+    @classmethod
+    def for_event(cls, evt: BaseHookEvent, *, scope: Scope = "project") -> DurableStore:
+        return cls(durable_dir(scope, evt.ctx.repo_root))
+
+    @classmethod
+    def track(cls, model: type[BaseModel]) -> None:
+        if model not in cls.TRACKED:
+            cls.TRACKED.append(model)
+
+    @classmethod
+    def untrack(cls, model: type[BaseModel]) -> None:
+        if model in cls.TRACKED:
+            cls.TRACKED.remove(model)
+
+    @classmethod
+    def tracked_models(cls) -> Sequence[type[BaseModel]]:
+        return tuple(cls.TRACKED)
+
+
+class DurableState(BaseModel):
+    """Base for a model persisted across sessions, scoped by the ``scope`` class keyword.
+
+    Declare the scope at subclass time — ``class Foo(DurableState, scope="global")``; it
+    defaults to ``"project"`` (keyed by the repo root). The subclass carries ``load``/``save``/
+    ``reset`` plus a locked :meth:`mutate` context manager. Reach for it when state must
+    outlive a single session; for within-session sharing use
+    [`workflow_state`][captain_hook.workflow_state] instead.
+
+    Example:
+        >>> from captain_hook import Deque
+        >>> class JsonShapes(DurableState, scope="global"):
+        ...     shapes: Deque[256]
+    """
+
+    __durable_scope__: ClassVar[Scope] = "project"
+
+    def __init_subclass__(cls, *, scope: Scope = "project", **kwargs: Any) -> None:
+        super().__init_subclass__(**kwargs)
+        if scope not in ("project", "global"):
+            raise ValueError(f"scope must be 'project' or 'global', got {scope!r}")
+        cls.__durable_scope__ = scope
+        DurableStore.track(cls)
+
+    @classmethod
+    def load(cls, evt: BaseHookEvent) -> Self:
+        return DurableStore.for_event(evt, scope=cls.__durable_scope__).load(cls)
+
+    def save(self, evt: BaseHookEvent) -> None:
+        DurableStore.for_event(evt, scope=type(self).__durable_scope__)[type(self)].set(self)
+
+    @classmethod
+    def reset(cls, evt: BaseHookEvent) -> None:
+        DurableStore.for_event(evt, scope=cls.__durable_scope__)[cls].delete()
+
+    @classmethod
+    @contextmanager
+    def mutate(cls, evt: BaseHookEvent) -> Iterator[Self]:
+        with DurableStore.for_event(evt, scope=cls.__durable_scope__)[cls].mutate() as obj:
+            yield obj

capt_hook-4.3.0/captain_hook/fields.py

@@ -0,0 +1,45 @@
+"""Reusable Pydantic field types for hook state models."""
+
+from __future__ import annotations
+
+from collections import deque
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Annotated, Any
+
+from pydantic_core import core_schema
+
+if TYPE_CHECKING:
+    from pydantic import GetCoreSchemaHandler
+
+
+@dataclass(frozen=True, slots=True)
+class Deque:
+    """A bounded ``deque`` field type whose ``maxlen`` survives JSON round-trips.
+
+    Subscript with the cap: ``Deque[256]`` is a ``deque[str]`` capped at 256, and
+    ``Deque[int, 256]`` sets the element type. A bare ``Deque`` field (no ``= Field(...)``)
+    defaults to an empty bounded deque, the cap is re-applied on every load, and the deque
+    auto-evicts its oldest item on append — so a growing collection stays bounded across
+    sessions. Unlike :class:`annotated_types.MaxLen`, which only rejects over-long input,
+    this caps the collection instead of raising.
+
+    Example:
+        >>> from captain_hook import DurableState, Deque
+        >>> class JsonShapes(DurableState, scope="global"):
+        ...     shapes: Deque[256]
+    """
+
+    maxlen: int
+
+    def __class_getitem__(cls, params: int | tuple[type, int]) -> Any:
+        match params:
+            case int(maxlen):
+                return Annotated[deque[str], cls(maxlen)]
+            case (item, int(maxlen)):
+                return Annotated[deque[item], cls(maxlen)]
+            case _:
+                raise TypeError(f"Deque[...] takes an int cap or (item, cap), got {params!r}")
+
+    def __get_pydantic_core_schema__(self, source: Any, handler: GetCoreSchemaHandler) -> core_schema.CoreSchema:
+        bounded = core_schema.no_info_after_validator_function(lambda d: deque(d, maxlen=self.maxlen), handler(source))
+        return core_schema.with_default_schema(bounded, default_factory=lambda: deque(maxlen=self.maxlen))

{capt_hook-4.2.0 → capt_hook-4.3.0}/captain_hook/primitives/llm.py

@@ -28,8 +28,9 @@ from captain_hook.types import (
 FAILURE_ROOT = state.CACHE_ROOT / "failures"
 
 if TYPE_CHECKING:
+    from spawnllm import TModel, TSpecialty
+
     from captain_hook.events import BaseHookEvent
-    from captain_hook.llm import TModel, TSpecialty
     from captain_hook.signals.nlp import NlpSignal
 
 
@@ -377,7 +378,6 @@ def prompt_check(
     if not verdict:
         return None
 
-    assert isinstance(verdict, response_model)
     match verdict.action:
         case "block":
             return HookResult(action=Action.block, message=f"{prefix}: {verdict.reason}{suffix}")

{capt_hook-4.2.0 → capt_hook-4.3.0}/captain_hook/review/cli.py

@@ -19,6 +19,7 @@ from typing import TYPE_CHECKING
 import click
 
 if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
     from typing import Any
 
     from cc_transcript.corrections import Correction
@@ -27,7 +28,7 @@ if TYPE_CHECKING:
     from captain_hook.review.judge import JudgeReport
     from captain_hook.review.repo import RepoKey
     from captain_hook.review.scan import ScanReport
-    from captain_hook.review.store import ThresholdStatus
+    from captain_hook.review.store import ReviewStore, ThresholdStatus
     from captain_hook.review.sync import SyncReport
 
 REVIEW_RUN_COMMAND = "capt-hook review run"
@@ -77,19 +78,24 @@ def ensure_review_wiring(settings_path: Path) -> bool:
     return True
 
 
-def watch_repo(repo: RepoKey) -> None:
-    """Flip the global watching bit for ``repo``.
-
-    The single persistence path shared by ``init`` and ``review enable``.
-    """
+def run_store[T](fn: Callable[[ReviewStore], Awaitable[T]]) -> T:
+    """Open the review store, run ``fn`` against it, and bridge with ``asyncio.run`` at the command boundary."""
     from captain_hook.review.settings import ReviewSettings
     from captain_hook.review.store import ReviewStore
 
-    async def go() -> None:
+    async def go() -> T:
         async with await ReviewStore.open(ReviewSettings().db_path) as store:
-            await store.enable(repo)
+            return await fn(store)
+
+    return asyncio.run(go())
 
-    asyncio.run(go())
+
+def watch_repo(repo: RepoKey) -> None:
+    """Flip the global watching bit for ``repo``.
+
+    The single persistence path shared by ``init`` and ``review enable``.
+    """
+    run_store(lambda store: store.enable(repo))
 
 
 def candidate_line(row: dict[str, object]) -> str:
@@ -141,16 +147,8 @@ def enable(state: CliState) -> None:
 @click.pass_obj
 def disable(state: CliState) -> None:
     """Stop watching the current repo (its candidates stay recorded)."""
-    from captain_hook.review.settings import ReviewSettings
-    from captain_hook.review.store import ReviewStore
-
     repo = current_repo(state.root)
-
-    async def go() -> None:
-        async with await ReviewStore.open(ReviewSettings().db_path) as store:
-            await store.disable(repo)
-
-    asyncio.run(go())
+    run_store(lambda store: store.disable(repo))
     click.echo(f"not watching {repo}")
 
 
@@ -173,17 +171,11 @@ def scan(transcripts: tuple[Path, ...], dirs: tuple[Path, ...]) -> None:
     """Scan explicit transcripts for corrections, incrementally."""
     from captain_hook.review.scan import scan as run_scan
     from captain_hook.review.settings import ReviewSettings
-    from captain_hook.review.store import ReviewStore
 
     if not transcripts and not dirs:
         raise click.UsageError("pass at least one --transcript or --dir")
     settings = ReviewSettings()
-
-    async def go() -> ScanReport:
-        async with await ReviewStore.open(settings.db_path) as store:
-            return await run_scan(store, settings=settings, transcripts=[*transcripts, *dirs])
-
-    report = asyncio.run(go())
+    report: ScanReport = run_store(lambda store: run_scan(store, settings=settings, transcripts=[*transcripts, *dirs]))
     click.echo(f"scanned {report.scanned} transcripts, {report.inserted} new corrections")
 
 
@@ -193,15 +185,9 @@ def triage(limit: int | None) -> None:
     """Judge stored corrections lacking a verdict (manual/backfill)."""
     from captain_hook.review.judge import judge_pass
     from captain_hook.review.settings import ReviewSettings
-    from captain_hook.review.store import ReviewStore
 
     settings = ReviewSettings()
-
-    async def go() -> JudgeReport:
-        async with await ReviewStore.open(settings.db_path) as store:
-            return await judge_pass(store, settings=settings, limit=limit)
-
-    report = asyncio.run(go())
+    report: JudgeReport = run_store(lambda store: judge_pass(store, settings=settings, limit=limit))
     click.echo(f"judged {report.judged}, failed {report.failed}, pending {report.pending}")
 
 
@@ -221,16 +207,8 @@ def status(state: CliState, repo_: str | None, sync: bool) -> None:
 @click.pass_obj
 def list_candidates(state: CliState, repo_: str | None) -> None:
     """List the repo's PR candidates."""
-    from captain_hook.review.settings import ReviewSettings
-    from captain_hook.review.store import ReviewStore
-
     repo = resolve_repo(repo_, state.root)
-
-    async def go() -> list[dict[str, object]]:
-        async with await ReviewStore.open(ReviewSettings().db_path) as store:
-            return await store.candidates(repo)
-
-    if not (rows := asyncio.run(go())):
+    if not (rows := run_store(lambda store: store.candidates(repo))):
         click.echo(f"no candidates for {repo}")
     for row in rows:
         click.echo(candidate_line(row))
@@ -267,21 +245,19 @@ def show(candidate_id: int) -> None:
     """Show one candidate's row, its threshold status, and the shared ledger's faulted edits."""
     from captain_hook.review.judge import REVIEW_PROMPT_VERSION
     from captain_hook.review.settings import ReviewSettings
-    from captain_hook.review.store import ReviewStore
 
     settings = ReviewSettings()
 
-    async def go() -> tuple[dict[str, object], ThresholdStatus, bool, tuple[Correction, ...]]:
-        async with await ReviewStore.open(settings.db_path) as store:
-            return (
-                await store.candidate(candidate_id),
-                await store.threshold_status(candidate_id, settings=settings, prompt_version=REVIEW_PROMPT_VERSION),
-                await store.eligible(candidate_id, settings=settings, prompt_version=REVIEW_PROMPT_VERSION),
-                await store.correction_evidence(candidate_id),
-            )
+    async def body(store: ReviewStore) -> tuple[dict[str, object], ThresholdStatus, bool, tuple[Correction, ...]]:
+        return (
+            await store.candidate(candidate_id),
+            await store.threshold_status(candidate_id, settings=settings, prompt_version=REVIEW_PROMPT_VERSION),
+            await store.eligible(candidate_id, settings=settings, prompt_version=REVIEW_PROMPT_VERSION),
+            await store.correction_evidence(candidate_id),
+        )
 
     try:
-        row, status, ok, evidence = asyncio.run(go())
+        row, status, ok, evidence = run_store(body)
     except LookupError as exc:
         raise click.ClickException(str(exc)) from exc
     for key, value in row.items():
@@ -304,29 +280,25 @@ def threshold_check(state: CliState, candidate_id: int | None, repo_: str | None
     """Report which candidates cross their PR thresholds."""
     from captain_hook.review.judge import REVIEW_PROMPT_VERSION
     from captain_hook.review.settings import ReviewSettings
-    from captain_hook.review.store import ReviewStore
 
     settings = ReviewSettings()
 
-    async def go() -> list[str]:
-        async with await ReviewStore.open(settings.db_path) as store:
-            ids = (
-                [candidate_id]
-                if candidate_id is not None
-                else [int(str(row["id"])) for row in await store.candidates(resolve_repo(repo_, state.root))]
-            )
-            return [
-                f"#{cid} eligible={await store.eligible(cid, settings=settings, prompt_version=REVIEW_PROMPT_VERSION)}"
-                f" sessions={status.sessions}/{settings.min_sessions} days={status.days}/{settings.min_days}"
-                f" open_prs={status.open_prs}/{settings.max_open_prs} watching={status.watching}"
-                for cid in ids
-                if (
-                    status := await store.threshold_status(cid, settings=settings, prompt_version=REVIEW_PROMPT_VERSION)
-                )
-            ]
+    async def body(store: ReviewStore) -> list[str]:
+        ids = (
+            [candidate_id]
+            if candidate_id is not None
+            else [int(str(row["id"])) for row in await store.candidates(resolve_repo(repo_, state.root))]
+        )
+        return [
+            f"#{cid} eligible={await store.eligible(cid, settings=settings, prompt_version=REVIEW_PROMPT_VERSION)}"
+            f" sessions={status.sessions}/{settings.min_sessions} days={status.days}/{settings.min_days}"
+            f" open_prs={status.open_prs}/{settings.max_open_prs} watching={status.watching}"
+            for cid in ids
+            if (status := await store.threshold_status(cid, settings=settings, prompt_version=REVIEW_PROMPT_VERSION))
+        ]
 
     try:
-        lines = asyncio.run(go())
+        lines = run_store(body)
     except LookupError as exc:
         raise click.ClickException(str(exc)) from exc
     if not lines:
@@ -341,20 +313,17 @@ def threshold_check(state: CliState, candidate_id: int | None, repo_: str | None
 @click.option("--pr-url", default=None, help="PR URL stamped with the move (also stamps pr_opened_at)")
 def update(candidate_id: int, status: str, pr_url: str | None) -> None:
     """Move a candidate to a new status."""
-    from captain_hook.review.settings import ReviewSettings
-    from captain_hook.review.store import CandidateStatus, InvalidTransition, ReviewStore
+    from captain_hook.review.store import CandidateStatus, InvalidTransition
 
-    async def go() -> None:
-        async with await ReviewStore.open(ReviewSettings().db_path) as store:
-            await store.transition(
+    try:
+        run_store(
+            lambda store: store.transition(
                 candidate_id,
                 CandidateStatus(status),
                 pr_url=pr_url,
                 pr_opened_at=datetime.now(UTC) if pr_url else None,
             )
-
-    try:
-        asyncio.run(go())
+        )
     except (InvalidTransition, LookupError) as exc:
         raise click.ClickException(str(exc)) from exc
     click.echo(f"#{candidate_id} -> {status}")
@@ -366,17 +335,11 @@ def update(candidate_id: int, status: str, pr_url: str | None) -> None:
 def sync_prs(state: CliState, repo_: str | None) -> None:
     """Fold open PR states back into candidate statuses."""
     from captain_hook.review.settings import ReviewSettings
-    from captain_hook.review.store import ReviewStore
     from captain_hook.review.sync import sync_open_prs
 
     settings = ReviewSettings()
     repo = resolve_repo(repo_, state.root)
-
-    async def go() -> SyncReport:
-        async with await ReviewStore.open(settings.db_path) as store:
-            return await sync_open_prs(store, repo, settings=settings)
-
-    report = asyncio.run(go())
+    report: SyncReport = run_store(lambda store: sync_open_prs(store, repo, settings=settings))
     click.echo(
         f"accepted {report.accepted}, rejected {report.rejected}, "
         f"stale {report.stale}, unreachable {report.unreachable}"

{capt_hook-4.2.0 → capt_hook-4.3.0}/captain_hook/review/pipeline.py

@@ -147,12 +147,11 @@ def brain_prompt(transcript: Path) -> str:
 
 
 def brain_argv(*, max_turns: int, max_budget_usd: float) -> list[str]:
-    from spawnllm import ClaudeConfig, RunSpec
+    from spawnllm import ClaudeCliBackend, ClaudeConfig, RunSpec
 
     from captain_hook.cli import plugin_dir
-    from captain_hook.llm import ClaudeBackend
 
-    backend = ClaudeBackend()
+    backend = ClaudeCliBackend()
     spec = RunSpec(
         prompt="",
         model=backend.models[BRAIN_TIER],

{capt_hook-4.2.0 → capt_hook-4.3.0}/captain_hook/style/types.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass
 from functools import cached_property
 from typing import TYPE_CHECKING, ClassVar
 
-from captain_hook.utils import kebab
+from captain_hook.util import kebab
 
 if TYPE_CHECKING:
     from captain_hook.style.matchers import Matcher