capt-hook 12.2.0__tar.gz → 12.3.0__tar.gz

{capt_hook-12.2.0 → capt_hook-12.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: capt-hook
-Version: 12.2.0
+Version: 12.3.0
 Summary: Stop repeating yourself to Claude.
 Project-URL: Homepage, https://github.com/yasyf/captain-hook
 Project-URL: Documentation, https://yasyf.github.io/captain-hook/

{capt_hook-12.2.0 → capt_hook-12.3.0}/capt_hook_client/client.py

@@ -140,7 +140,6 @@ def build_request(event: str, root: str, payload_raw: str, *, async_: bool) -> d
         "async": async_,
         "root": root,
         "cwd": os.getcwd(),
-        "hooks": None,
         "env": key.request_env(),
         "payload_raw": payload_raw,
     }

{capt_hook-12.2.0 → capt_hook-12.3.0}/captain_hook/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "captain-hook",
-  "version": "12.1.0",
+  "version": "12.2.0",
   "displayName": "Captain Hook",
   "description": "Skills for the capt-hook declarative hook framework: bootstrap gates and nudges from a repo's conventions, and translate style guides into enforced StyleRules.",
   "author": {

{capt_hook-12.2.0 → capt_hook-12.3.0}/captain_hook/__init__.py

@@ -46,6 +46,7 @@ EXPORTS: dict[str, str] = {
     "Redirects": "captain_hook.conditions",
     "RewritingExistingPlan": "captain_hook.conditions",
     "ScratchPath": "captain_hook.conditions",
+    "UserSaid": "captain_hook.conditions",
     "workflow_opt_matches": "captain_hook.conditions",
     "workflow_opt_values": "captain_hook.conditions",
     "workflow_script_source": "captain_hook.conditions",
@@ -122,6 +123,7 @@ EXPORTS: dict[str, str] = {
     "Phrase": "captain_hook.signals.nlp",
     "has_nominal_subject": "captain_hook.signals.nlp",
     "is_past_predicate": "captain_hook.signals.nlp",
+    "subject_kind": "captain_hook.signals.nlp",
     "HookState": "captain_hook.state",
     "PrimitiveState": "captain_hook.state",
     "WorkflowState": "captain_hook.state",
@@ -129,6 +131,7 @@ EXPORTS: dict[str, str] = {
     "Task": "captain_hook.tasks",
     "Tasks": "captain_hook.tasks",
     "Allow": "captain_hook.testing.types",
+    "Turn": "captain_hook.turn",
     "Ask": "captain_hook.testing.types",
     "Block": "captain_hook.testing.types",
     "FileFixture": "captain_hook.testing.types",
@@ -167,6 +170,7 @@ EXPORTS: dict[str, str] = {
     "ToolInput": "captain_hook.types",
     "TouchedFile": "captain_hook.types",
     "UsedSkill": "captain_hook.types",
+    "UsedTool": "captain_hook.types",
     "Waiting": "captain_hook.types",
     "WorkflowScript": "captain_hook.types",
     "binary_supports": "captain_hook.util.fs",

{capt_hook-12.2.0 → capt_hook-12.3.0}/captain_hook/__init__.pyi

@@ -42,6 +42,7 @@ from captain_hook.conditions import Headless as Headless
 from captain_hook.conditions import Redirects as Redirects
 from captain_hook.conditions import RewritingExistingPlan as RewritingExistingPlan
 from captain_hook.conditions import ScratchPath as ScratchPath
+from captain_hook.conditions import UserSaid as UserSaid
 from captain_hook.conditions import workflow_opt_matches as workflow_opt_matches
 from captain_hook.conditions import workflow_opt_values as workflow_opt_values
 from captain_hook.conditions import workflow_script_source as workflow_script_source
@@ -118,6 +119,7 @@ from captain_hook.signals.nlp import NlpSignal as NlpSignal
 from captain_hook.signals.nlp import Phrase as Phrase
 from captain_hook.signals.nlp import has_nominal_subject as has_nominal_subject
 from captain_hook.signals.nlp import is_past_predicate as is_past_predicate
+from captain_hook.signals.nlp import subject_kind as subject_kind
 from captain_hook.state import HookState as HookState
 from captain_hook.state import PrimitiveState as PrimitiveState
 from captain_hook.state import WorkflowState as WorkflowState
@@ -133,6 +135,7 @@ from captain_hook.testing.types import Input as Input
 from captain_hook.testing.types import Rewrite as Rewrite
 from captain_hook.testing.types import TranscriptFixture as TranscriptFixture
 from captain_hook.testing.types import Warn as Warn
+from captain_hook.turn import Turn as Turn
 from captain_hook.types import Action as Action
 from captain_hook.types import Agent as Agent
 from captain_hook.types import And as And
@@ -163,6 +166,7 @@ from captain_hook.types import Tool as Tool
 from captain_hook.types import ToolInput as ToolInput
 from captain_hook.types import TouchedFile as TouchedFile
 from captain_hook.types import UsedSkill as UsedSkill
+from captain_hook.types import UsedTool as UsedTool
 from captain_hook.types import Waiting as Waiting
 from captain_hook.types import WorkflowScript as WorkflowScript
 from captain_hook.util.fs import binary_supports as binary_supports

{capt_hook-12.2.0 → capt_hook-12.3.0}/captain_hook/builtin_packs/general/hooks/tombstones.py

@@ -82,7 +82,7 @@ def is_tombstone(text: str) -> bool:
                         "deprecate",
                     ),
                     tense="completed",
-                    subject="no_nominal",
+                    subject=("unnamed", "passive"),
                 ),
                 Clause(
                     verb=Phrase("be"), adj=Phrase("previously", "formerly", "originally", "here"), tense="completed"

{capt_hook-12.2.0 → capt_hook-12.3.0}/captain_hook/conditions.py

@@ -33,6 +33,7 @@ from captain_hook.types import (
     ToolInput,
     TouchedFile,
     UsedSkill,
+    UsedTool,
     Waiting,
     WorkflowScript,
 )
@@ -44,6 +45,7 @@ if TYPE_CHECKING:
     from cc_transcript.query import Session
 
     from captain_hook.events import BaseHookEvent
+    from captain_hook.signals.nlp import Clause
     from captain_hook.types import HookSpec
 
 # Prose and config file extensions that shouldn't, on their own, demand a code-review pass.
@@ -183,13 +185,24 @@ def is_project_file(evt: BaseHookEvent) -> bool:
 
 
 class UserSaid(CustomCondition):
-    """Matches when the user's messages contain any of the given keywords."""
+    """Matches when any user prompt in the session matches one of ``patterns``.
 
-    def __init__(self, *keywords: str) -> None:
-        self.keywords = keywords
+    A string pattern is a case-insensitive regex, so plain keywords keep their
+    substring behavior; a :class:`~captain_hook.Clause` runs the dependency-clause
+    scan against each prompt. To match only the current turn's prompt, use
+    ``evt.ctx.turn.matches`` instead.
+
+    Example:
+        >>> UserSaid("just commit", Clause(noun=Phrase("test"), verb=Phrase("skip")))
+    """
+
+    def __init__(self, *patterns: str | Clause) -> None:
+        self.patterns = patterns
 
     def check(self, evt: BaseHookEvent) -> bool:
-        return evt.ctx.t.user_said(*self.keywords)
+        from captain_hook.signals.nlp import scan_text
+
+        return any(scan_text(turn.prompt, self.patterns) for turn in evt.ctx.t.turns if turn.prompt)
 
 
 class AllEditsUnder(CustomCondition):
@@ -393,6 +406,10 @@ def check_condition(c: TCondition, evt: BaseHookEvent) -> bool:
             )
         case UsedSkill(names, subagents):
             return has_used_skill(evt.ctx.transcript, names, subagents=subagents)
+        case UsedTool(names, subagents, scope):
+            return (evt.ctx.turn if scope == "turn" else evt.ctx.transcript).has_tool(
+                "|".join(names), subagents=subagents
+            )
         case ReadFile(patterns, subagents):
             return has_read_glob(evt.ctx.transcript, *patterns, subagents=subagents)
         case TouchedFile(patterns, subagents):

{capt_hook-12.2.0 → capt_hook-12.3.0}/captain_hook/context.py

@@ -17,6 +17,8 @@ if TYPE_CHECKING:
     from spawnllm import TModel, TSpecialty
 
     from captain_hook.settings import HooksSettings
+    from captain_hook.signals.nlp import Clause
+    from captain_hook.turn import Turn
 
 
 RECENT_WINDOW = 15
@@ -70,15 +72,31 @@ class HookContext:
         return self.conf
 
     @cached_property
-    def turn(self) -> Session:
-        """The one-turn view of the current turn (cached)."""
-        return self.transcript.current_turn
+    def turn(self) -> Turn:
+        """The one-turn view of the current turn (cached), with prompt matching via ``matches``."""
+        from captain_hook.turn import Turn
+
+        return Turn((current := self.transcript.current_turn).turns, current.path)
 
     @cached_property
     def prior(self) -> Session:
         """The session window before the current turn's last exchange (cached)."""
         return self.transcript.prior()
 
+    def nlp(self, text: str, *patterns: str | Clause) -> bool:
+        """Whether ``text`` matches any pattern — the escape hatch for matching arbitrary prose.
+
+        A string pattern is a case-insensitive regex; a :class:`~captain_hook.Clause`
+        runs the dependency-clause scan. For the current turn's prompt, prefer
+        ``evt.ctx.turn.matches(*patterns)``.
+
+        Example:
+            >>> evt.ctx.nlp(evt.ctx.t.assistant_text(), Clause(noun=Phrase("test"), verb=Phrase("skip")))
+        """
+        from captain_hook.signals.nlp import scan_text
+
+        return scan_text(text, patterns)
+
     def transcript_text(self, *, window: int | None = None) -> str:
         """The transcript rendered turn by turn under the default budget.
 

{capt_hook-12.2.0 → capt_hook-12.3.0}/captain_hook/daemon/protocol.py

@@ -104,7 +104,6 @@ class Request:
     async_: bool = False
     root: str | None = None
     cwd: str | None = None
-    hooks: str | None = None
     env: dict[str, str] = field(default_factory=dict)
     payload_raw: str = ""
 
@@ -132,26 +131,50 @@ def decode_request(line: bytes) -> Request:
         data = json.loads(line)
     except (ValueError, UnicodeDecodeError) as exc:
         raise ProtocolError(f"malformed request JSON: {exc}") from exc
-    match data:
-        case {
-            "v": int() as v,
-            "kind": str() as kind,
-            "client": {"version": str() as cv, "build": str() as cb, "pid": int() as cpid, "ppid": int() as cppid},
-        } if kind in REQUEST_KINDS:
-            return Request(
-                v=v,
-                kind=kind,
-                client=ClientInfo(version=cv, build=cb, pid=cpid, ppid=cppid),
-                event=data.get("event"),
-                async_=bool(data.get("async", False)),
-                root=data.get("root"),
-                cwd=data.get("cwd"),
-                hooks=data.get("hooks"),
-                env=data.get("env") or {},
-                payload_raw=data.get("payload_raw", ""),
-            )
-        case _:
-            raise ProtocolError(f"invalid request shape: {data!r}")
+    if type(data) is not dict:
+        raise ProtocolError(f"invalid request shape: {data!r}")
+    kind = data.get("kind")
+    keys = {"v", "kind", "client"}
+    if kind == "event":
+        keys |= {"event", "async", "root", "cwd", "env", "payload_raw"}
+    if kind not in REQUEST_KINDS or set(data) != keys:
+        raise ProtocolError(f"invalid request shape: {data!r}")
+    client = data["client"]
+    if type(client) is not dict or set(client) != {"version", "build", "pid", "ppid"}:
+        raise ProtocolError(f"invalid request shape: {data!r}")
+    if not (
+        type(data["v"]) is int
+        and type(client["version"]) is str
+        and type(client["build"]) is str
+        and type(client["pid"]) is int
+        and type(client["ppid"]) is int
+    ):
+        raise ProtocolError(f"invalid request shape: {data!r}")
+    info = ClientInfo(version=client["version"], build=client["build"], pid=client["pid"], ppid=client["ppid"])
+    if kind != "event":
+        return Request(v=data["v"], kind=kind, client=info)
+    env = data["env"]
+    if not (
+        type(data["event"]) is str
+        and type(data["async"]) is bool
+        and type(data["root"]) is str
+        and type(data["cwd"]) is str
+        and type(env) is dict
+        and all(type(key) is str and type(value) is str for key, value in env.items())
+        and type(data["payload_raw"]) is str
+    ):
+        raise ProtocolError(f"invalid request shape: {data!r}")
+    return Request(
+        v=data["v"],
+        kind=kind,
+        client=info,
+        event=data["event"],
+        async_=data["async"],
+        root=data["root"],
+        cwd=data["cwd"],
+        env=env,
+        payload_raw=data["payload_raw"],
+    )
 
 
 def encode_response(response: Response) -> bytes:

{capt_hook-12.2.0 → capt_hook-12.3.0}/captain_hook/signals/nlp.py

@@ -1,13 +1,16 @@
 from __future__ import annotations
 
 import functools
+import re
 from collections.abc import Sequence
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Literal, get_args
 
 if TYPE_CHECKING:
     from spacy.tokens import Doc, Span, Token
 
+SubjectKind = Literal["unnamed", "passive", "actor"]
+
 
 @dataclass(frozen=True, slots=True)
 class PhraseFields:
@@ -96,18 +99,21 @@ class Clause:
             are *not* past predicates and *not* counterfactual modal-perfects —
             "will leave"/"leaving"/"leave it"/"will have left" but not
             "left the workspace", "left to clean up", or "should have left".
-        subject: ``"no_nominal"`` vetoes verbs with both a substantive active
-            subject (see ``has_nominal_subject``) and a direct object — "the
-            parser removed the node" is vetoed while "we removed it", passives,
-            and objectless elliptical passives ("config moved to settings.py",
-            "logic migrated to the worker") still match. ``"none"`` vetoes any
-            verb with a substantive active subject, transitive or not —
-            imperatives and pronoun subjects ("switch back to plan mode",
-            "we should replan") still match while described behavior
-            ("the daemon switches to degraded mode") does not.
+        subject: The subject shapes the verb may have (see ``subject_kind``), as
+            a tuple — ``()`` (default) applies no constraint, and a bare string
+            means that one shape. ``"unnamed"``: no substantive active subject —
+            imperatives ("switch back to plan mode"), pronoun subjects
+            ("we should replan"), and true passives ("the file was removed").
+            ``"passive"``: a substantive subject but no direct object —
+            elliptical passives ("config moved to settings.py") and intransitive
+            actives ("the parser crashed"). ``"actor"``: a substantive subject
+            acting on a direct object — described behavior like "the parser
+            removed the node". ``("unnamed",)`` matches directives but not
+            descriptions; ``("unnamed", "passive")`` also admits statements
+            about the thing acted on.
 
     Example:
-        >>> Clause(verb=Phrase("remove", "delete"), tense="completed", subject="no_nominal")
+        >>> Clause(verb=Phrase("remove", "delete"), tense="completed", subject=("unnamed", "passive"))
     """
 
     noun: Phrase | None = None
@@ -115,19 +121,23 @@ class Clause:
     adj: Phrase | None = None
     negated: bool = False
     tense: Literal["any", "completed", "prospective"] = "any"
-    subject: Literal["any", "no_nominal", "none"] = "any"
+    subject: SubjectKind | tuple[SubjectKind, ...] = ()
 
     def __post_init__(self) -> None:
+        if isinstance(self.subject, str):
+            object.__setattr__(self, "subject", (self.subject,))
+        if invalid := set(self.subject) - set(get_args(SubjectKind)):
+            raise ValueError(f"Unknown subject kinds: {sorted(invalid)}")
         if (anchor := self.noun or self.verb) is None:
             raise ValueError("Clause needs a noun or verb anchor")
-        if self.verb is None and (self.tense != "any" or self.subject != "any"):
+        if self.verb is None and (self.tense != "any" or self.subject):
             raise ValueError("Clause tense and subject constraints require a verb")
         if not (
             (self.noun and self.verb)
             or self.adj
             or self.negated
             or self.tense != "any"
-            or self.subject != "any"
+            or self.subject
             or any(" " in lemma for lemma in anchor.lemmas)
         ):
             raise ValueError("Clause needs a second constraint or a compound anchor phrase")
@@ -234,14 +244,18 @@ def tense_matches(tense: Literal["any", "completed", "prospective"], tok: Token)
             return not is_past_predicate(tok) and not is_modal_perfect(tok)
 
 
-def subject_matches(subject: Literal["any", "no_nominal", "none"], tok: Token) -> bool:
-    match subject:
-        case "any":
-            return True
-        case "no_nominal":
-            return not (has_nominal_subject(tok) and any(c.dep_ == "dobj" for c in tok.children))
-        case "none":
-            return not has_nominal_subject(tok)
+def subject_kind(tok: Token) -> SubjectKind:
+    """The shape of ``tok``'s subject, as :class:`Clause`'s ``subject`` constraint sees it.
+
+    ``"unnamed"`` — no substantive active subject (see ``has_nominal_subject``);
+    ``"actor"`` — a substantive subject plus a direct object; ``"passive"`` — a
+    substantive subject without one.
+    """
+    if not has_nominal_subject(tok):
+        return "unnamed"
+    if any(c.dep_ == "dobj" for c in tok.children):
+        return "actor"
+    return "passive"
 
 
 def verb_candidates(clause: Clause, sent: Span) -> list[Token]:
@@ -251,7 +265,7 @@ def verb_candidates(clause: Clause, sent: Span) -> list[Token]:
         v
         for v in find_lemma_matches(clause.verb, sent, {"VERB", "AUX"})
         if tense_matches(clause.tense, v)
-        and subject_matches(clause.subject, v)
+        and (not clause.subject or subject_kind(v) in clause.subject)
         and not (
             clause.tense == "prospective"
             and not clause.negated
@@ -278,3 +292,10 @@ def nlp_scan(clauses: Sequence[Clause], text: str) -> list[str]:
     if not text.strip():
         return []
     return [sent.text.strip() for sent in parse(text).sents if any(match_clause(clause, sent) for clause in clauses)]
+
+
+def scan_text(text: str, patterns: Sequence[str | Clause]) -> bool:
+    clauses = [p for p in patterns if isinstance(p, Clause)]
+    return any(isinstance(p, str) and re.search(p, text, re.IGNORECASE) for p in patterns) or bool(
+        clauses and nlp_scan(clauses, text)
+    )

{capt_hook-12.2.0 → capt_hook-12.3.0}/captain_hook/skills/authoring-hooks/references/capt-hook-api.md

@@ -22,7 +22,7 @@ from captain_hook import (
     Allow, And, Agent, Ask, BaseHookEvent, Block, Event, FilePath, FromSubagent,
     HookResult, InlineTests, Input, Not, Or, Prompt, RanCommand, ReadFile, Rewrite, Runs,
     Signal, Signals, SkipPermissions, SourceEdits, TestFile, Tool, ToolInput, TouchedFile,
-    TranscriptFixture, UsedSkill, Warn, WorkflowScript,
+    TranscriptFixture, UsedSkill, UsedTool, UserSaid, Warn, WorkflowScript,
     approve, block_command, deny, gate, hook, lint, llm_approve, llm_gate, llm_nudge, nudge, on,
     prompt_check, rewrite_command, set_tool_input, warn_command, workflow, Artifact, Step, text_matches,
 )
@@ -165,6 +165,8 @@ evaluated first.
 | Event comes from a subagent/teammate | `FromSubagent()` — the payload carries an `agent_id`; matches the ask's *origin*, where `Agent` matches its *type* |
 | Session launched with bypass available | `SkipPermissions()` — walks to the nearest `claude` ancestor process and matches `--dangerously-skip-permissions` **or** `--allow-dangerously-skip-permissions`; availability counts as consent, whatever the active `permission_mode` |
 | Skill was invoked | `UsedSkill("codex")` — bare name also matches `plugin:name` |
+| Tool was previously used | `UsedTool("EnterPlanMode", scope="turn")` — exact names (a `\|`-joined string works); `scope="turn"` searches only the current turn |
+| User said something | `UserSaid("just commit")` — case-insensitive regexes and/or `Clause`s over every user prompt |
 | File was previously read | `ReadFile("TESTING.md")` — fnmatch globs; anchor dirs with `**/` |
 | Match only test files | `TestFile()` (`**/test_*.py`, `**/*_test.py`, `**/conftest.py`, `**/tests/**/*.py`, `**/*_test.go`, `**/*.test.*`, `**/*.spec.*`) |
 | Python source edits (skips tests by default, in-repo only) | `SourceEdits(lang="py")`; `lang` also `ts`, `go`, `rs`, ...; `project_only=False` to also match out-of-repo files |
@@ -177,7 +179,7 @@ evaluated first.
 | Custom logic | implement `CustomCondition` |
 <!-- /gen:conditions -->
 
-`ReadFile`/`TouchedFile`/`RanCommand`/`UsedSkill` inspect the session transcript — they are
+`ReadFile`/`TouchedFile`/`RanCommand`/`UsedSkill`/`UsedTool` inspect the session transcript — they are
 how Stop gates know what already happened. Custom conditions are any object with a
 `check(self, evt: BaseHookEvent) -> bool` method (a Protocol — no inheritance needed):
 

{capt_hook-12.2.0 → capt_hook-12.3.0}/captain_hook/skills/authoring-hooks/references/testing-hooks.md

@@ -50,7 +50,7 @@ All fields are keyword-only — `Block(pattern="...")`, never `Block("...")`.
 
 ## TranscriptFixture recipe
 
-Transcript-history conditions (`TouchedFile`, `RanCommand`, `ReadFile`, `UsedSkill`) read
+Transcript-history conditions (`TouchedFile`, `RanCommand`, `ReadFile`, `UsedSkill`, `UsedTool`) read
 the session transcript, so their tests supply one. The message shape is Claude Code JSONL:
 `{"type": "assistant", "message": {"content": [<tool_use blocks>]}}`.
 

capt_hook-12.3.0/captain_hook/turn.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from cc_transcript.query import Session
+
+if TYPE_CHECKING:
+    from captain_hook.signals.nlp import Clause
+
+
+class Turn(Session):
+    """The current turn as a one-turn :class:`~cc_transcript.query.Session` view.
+
+    What ``evt.ctx.turn`` returns: the full windowed transcript surface
+    (``user_text``, ``has_tool``, ``tool_calls``, …) plus prompt matching, so
+    hooks can test the turn's opening prompt without importing the NLP machinery.
+    """
+
+    __slots__ = ()
+
+    def matches(self, *patterns: str | Clause) -> bool:
+        """Whether the turn's opening prompt matches any pattern.
+
+        A string pattern is a case-insensitive regex; a
+        :class:`~captain_hook.Clause` runs the dependency-clause scan.
+
+        Example:
+            >>> evt.ctx.turn.matches(Clause(noun=Phrase("work"), verb=Phrase("stop", "halt")))
+        """
+        from captain_hook.signals.nlp import scan_text
+
+        return scan_text(self.user_text, patterns)

{capt_hook-12.2.0 → capt_hook-12.3.0}/captain_hook/types.py

@@ -328,6 +328,28 @@ class UsedSkill:
         object.__setattr__(self, "subagents", subagents)
 
 
+@dataclass(frozen=True, slots=True)
+class UsedTool:
+    """Transcript-history condition: true when a tool use named one of ``names`` exists.
+
+    Pass names variadically; a single ``|``-joined string still works for back-compat.
+    ``scope="turn"`` restricts the search to the current turn — the idiom for skipping
+    a guard once the agent has complied.
+
+    Example:
+        >>> hook(Event.PreToolUse, skip_if=[UsedTool("EnterPlanMode", scope="turn")], message="...", block=True)
+    """
+
+    names: tuple[str, ...]
+    subagents: bool = True
+    scope: Literal["session", "turn"] = "session"
+
+    def __init__(self, *names: str, subagents: bool = True, scope: Literal["session", "turn"] = "session") -> None:
+        object.__setattr__(self, "names", _split_names(names))
+        object.__setattr__(self, "subagents", subagents)
+        object.__setattr__(self, "scope", scope)
+
+
 @dataclass(frozen=True, slots=True)
 class ReadFile(PatternsCondition):
     """Transcript-history condition: true when a Read tool use targeted a matching file.
@@ -676,6 +698,7 @@ TCondition = (
     | FromSubagent
     | SkipPermissions
     | UsedSkill
+    | UsedTool
     | ReadFile
     | TestFile
     | SourceEdits

{capt_hook-12.2.0 → capt_hook-12.3.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "capt-hook"
 # Inert sentinel — the real version is stamped from the release tag (uv version --frozen).
-version = "12.2.0"
+version = "12.3.0"
 description = "Stop repeating yourself to Claude."
 readme = "README.md"
 license = "PolyForm-Noncommercial-1.0.0"