capt-hook 12.76.2__tar.gz → 12.77.0__tar.gz

{capt_hook-12.76.2 → capt_hook-12.77.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: capt-hook
-Version: 12.76.2
+Version: 12.77.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.76.2 → capt_hook-12.77.0}/captain_hook/__init__.py

@@ -30,6 +30,7 @@ EXPORTS: dict[str, str] = {
     "util": "captain_hook.util",
     "hook": "captain_hook.app",
     "on": "captain_hook.app",
+    "Annotated": "captain_hook.annotations",
     "COMMENT_TYPES": "captain_hook.ast_grep",
     "Edit": "captain_hook.ast_grep",
     "Match": "captain_hook.ast_grep",
@@ -59,6 +60,8 @@ EXPORTS: dict[str, str] = {
     "workflow_opt_matches": "captain_hook.conditions",
     "workflow_opt_values": "captain_hook.conditions",
     "workflow_script_source": "captain_hook.conditions",
+    "Confirm": "captain_hook.confirm",
+    "ConfirmVerdict": "captain_hook.confirm",
     "HookContext": "captain_hook.context",
     "AfterEdit": "captain_hook.contexts",
     "BeforeEdit": "captain_hook.contexts",

{capt_hook-12.76.2 → capt_hook-12.77.0}/captain_hook/__init__.pyi

@@ -24,6 +24,7 @@ from cc_transcript.tools import WriteCall as WriteCall
 from captain_hook import file as file
 from captain_hook import style as style
 from captain_hook import util as util
+from captain_hook.annotations import Annotated as Annotated
 from captain_hook.app import hook as hook
 from captain_hook.app import on as on
 from captain_hook.ast_grep import COMMENT_TYPES as COMMENT_TYPES
@@ -55,6 +56,8 @@ 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
+from captain_hook.confirm import Confirm as Confirm
+from captain_hook.confirm import ConfirmVerdict as ConfirmVerdict
 from captain_hook.context import HookContext as HookContext
 from captain_hook.contexts import AfterEdit as AfterEdit
 from captain_hook.contexts import BeforeEdit as BeforeEdit

capt_hook-12.77.0/captain_hook/annotations.py

@@ -0,0 +1,296 @@
+"""The ``ccx:`` annotation notation: one escape and intent grammar for every hook to read."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterator, Mapping
+from dataclasses import dataclass, field
+from itertools import chain
+from typing import TYPE_CHECKING, Literal
+
+from cc_transcript.command import PAYLOAD_DEPTH_LIMIT
+from cc_transcript.tools import SkillCall, TaskCall
+
+from captain_hook.cmd import Cmd
+from captain_hook.snapshots.client import RemoteSession
+from captain_hook.types import CustomCondition
+from captain_hook.util import reqenv
+
+if TYPE_CHECKING:
+    from captain_hook.cmd import Call
+    from captain_hook.events import BaseHookEvent
+
+WORD = r"[a-z0-9][a-z0-9:._-]*"
+COMMENT_TOKEN = re.compile(rf"ccx:({WORD})(?:=({WORD}))?")
+DISPATCH_LINE = re.compile(rf"ccx:((?:[ \t]+{WORD}(?:={WORD})?)+)")
+DISPATCH_PAIR = re.compile(rf"({WORD})(?:=({WORD}))?")
+RAW_ENV = "CAPT_HOOK_CCX_RAW"
+TRUTHY = frozenset({"1", "true", "yes"})
+BREAKS = frozenset(" \t\n;&|()<>")
+SHELLS = frozenset({"sh", "bash", "zsh", "dash", "ksh"})
+OPTION_VALUES = frozenset({"-o", "+o", "-O", "+O"})
+FENCE = re.compile(r"(`{3,}|~{3,})")
+
+type Annotations = Mapping[str, str | None]
+type Pair = tuple[str, str | None]
+
+
+def pair(key: str, value: str) -> Pair:
+    return key, value or None
+
+
+@dataclass
+class CommentScanner:
+    """Bash's own reading of where comments sit: quoting, line continuations, and every pending heredoc body."""
+
+    text: str
+    at: int = 0
+    found: list[str] = field(default_factory=list)
+    heredocs: list[tuple[str, bool]] = field(default_factory=list)
+
+    def peek(self, offset: int = 0) -> str:
+        return self.text[self.at + offset : self.at + offset + 1]
+
+    def scan(self, close: str = "") -> None:
+        word_start, depth = True, 0
+        while self.at < len(self.text):
+            char = self.peek()
+            if char == close and depth == 0:
+                self.at += 1
+                return
+            match char:
+                case "\\" if self.peek(1) == "\n":
+                    self.at += 2
+                case "\\":
+                    self.at += 2
+                    word_start = False
+                case "'":
+                    self.skip_to("'")
+                    word_start = False
+                case '"':
+                    self.skip_double()
+                    word_start = False
+                case "#" if word_start:
+                    end = self.text.find("\n", self.at)
+                    self.found.append(self.text[self.at : end if end >= 0 else None])
+                    self.at = end if end >= 0 else len(self.text)
+                case "\n":
+                    self.at += 1
+                    self.read_heredocs()
+                    word_start = True
+                case "$":
+                    self.expansion()
+                    word_start = False
+                case "`":
+                    self.at += 1
+                    self.scan("`")
+                    word_start = False
+                case "<" if self.text.startswith("<<", self.at) and not self.text.startswith("<<<", self.at):
+                    self.heredoc()
+                    word_start = False
+                case _:
+                    depth += (char == "(") - (char == ")") if close == ")" else 0
+                    self.at += 1
+                    word_start = char in BREAKS
+
+    def skip_to(self, quote: str) -> None:
+        end = self.text.find(quote, self.at + 1)
+        self.at = end + 1 if end >= 0 else len(self.text)
+
+    def skip_double(self) -> None:
+        self.at += 1
+        while self.at < len(self.text):
+            match self.peek():
+                case "\\":
+                    self.at += 2
+                case '"':
+                    self.at += 1
+                    return
+                case "$":
+                    self.expansion()
+                case "`":
+                    self.at += 1
+                    self.scan("`")
+                case _:
+                    self.at += 1
+
+    def expansion(self) -> None:
+        match self.peek(1), self.peek(2):
+            case "(", "(":
+                self.skip_balanced("(", ")")
+            case "(", _:
+                self.at += 2
+                self.scan(")")
+            case "{", _:
+                self.skip_balanced("{", "}")
+            case "'", _:
+                self.at += 1
+                self.skip_ansi()
+            case _:
+                self.at += 1
+
+    def skip_balanced(self, opener: str, closer: str) -> None:
+        self.at += 1
+        depth = 0
+        while self.at < len(self.text):
+            char = self.peek()
+            self.at += 1
+            depth += (char == opener) - (char == closer)
+            if depth == 0:
+                return
+
+    def skip_ansi(self) -> None:
+        self.at += 1
+        while self.at < len(self.text):
+            match self.peek():
+                case "\\":
+                    self.at += 2
+                case "'":
+                    self.at += 1
+                    return
+                case _:
+                    self.at += 1
+
+    def heredoc(self) -> None:
+        self.at += 2
+        strip = self.peek() == "-"
+        self.at += strip
+        while self.peek() in (" ", "\t"):
+            self.at += 1
+        delimiter: list[str] = []
+        while (char := self.peek()) and char not in BREAKS:
+            match char:
+                case "'" | '"':
+                    end = self.text.find(char, self.at + 1)
+                    delimiter.append(self.text[self.at + 1 : end if end >= 0 else None])
+                    self.at = end + 1 if end >= 0 else len(self.text)
+                case "\\":
+                    delimiter.append(self.peek(1))
+                    self.at += 2
+                case _:
+                    delimiter.append(char)
+                    self.at += 1
+        self.heredocs.append(("".join(delimiter), strip))
+
+    def read_heredocs(self) -> None:
+        for delimiter, strip in self.heredocs:
+            while self.at < len(self.text):
+                end = self.text.find("\n", self.at)
+                line = self.text[self.at : end if end >= 0 else None]
+                self.at = end + 1 if end >= 0 else len(self.text)
+                if (line.lstrip("\t") if strip else line) == delimiter:
+                    break
+        self.heredocs.clear()
+
+
+def payload(call: Call) -> str | None:
+    """The shell text ``call`` runs as code: an ``eval``'s joined arguments, or a shell's ``-c`` command string."""
+    if call.name == "eval":
+        return " ".join(call.args) or None
+    if call.name not in SHELLS:
+        return None
+    args, inline = iter(call.args), False
+    for arg in args:
+        if arg in OPTION_VALUES:
+            next(args, None)
+        elif arg.startswith(("-", "+")) and not arg.startswith("--"):
+            inline = inline or (arg.startswith("-") and "c" in arg[1:])
+        elif not arg.startswith("--"):
+            return arg if inline else None
+    return None
+
+
+def shell_comments(text: str, depth: int = 0) -> Iterator[str]:
+    """Every real shell comment in ``text``, the code of nested ``sh -c`` and ``eval`` payloads included."""
+    (scanner := CommentScanner(text)).scan()
+    yield from scanner.found
+    if depth >= PAYLOAD_DEPTH_LIMIT or (cmd := Cmd.parse(text)) is None:
+        return
+    for call in cmd.calls():
+        if call.occurrence.host is None and (code := payload(call)) is not None:
+            yield from shell_comments(code, depth + 1)
+
+
+def comment_pairs(text: str) -> Iterator[Pair]:
+    for comment in shell_comments(text):
+        for word in comment.lstrip("#").split():
+            if token := COMMENT_TOKEN.fullmatch(word):
+                yield pair(*token.groups(""))
+
+
+def header_lines(text: str) -> Iterator[str]:
+    """The lines of a dispatch prompt that speak for the prompt itself: none inside a fence or pasted content."""
+    fence, pasted = "", False
+    for line in map(str.strip, text.splitlines()):
+        if fence:
+            fence = "" if line.startswith(fence) else fence
+        elif pasted:
+            pasted = "</pasted_content>" not in line
+        elif opened := FENCE.match(line):
+            fence = opened.group(1)
+        elif line.startswith("<pasted_content"):
+            pasted = "</pasted_content>" not in line
+        else:
+            yield line
+
+
+def dispatch_pairs(text: str) -> Iterator[Pair]:
+    for line in header_lines(text):
+        if declared := DISPATCH_LINE.fullmatch(line):
+            yield from (pair(*found.groups("")) for found in DISPATCH_PAIR.finditer(declared.group(1)))
+
+
+def env_pairs() -> Iterator[Pair]:
+    if (reqenv.getenv(RAW_ENV) or "").strip().lower() in TRUTHY:
+        yield "raw", None
+
+
+def dispatch_text(evt: BaseHookEvent) -> str:
+    match evt.input:
+        case TaskCall(prompt=prompt):
+            return prompt or ""
+        case SkillCall(args=args):
+            return args or ""
+    return ""
+
+
+def event_annotations(evt: BaseHookEvent) -> Annotations:
+    return dict(chain(env_pairs(), comment_pairs(evt.cmd.raw), dispatch_pairs(dispatch_text(evt))))
+
+
+def dispatch_prompt(evt: BaseHookEvent) -> str:
+    t = evt.ctx.t
+    if isinstance(t, RemoteSession):
+        return next(iter(t.prompts(selection="first", count=1)), "")
+    return next((turn.prompt for turn in t.turns if turn.prompt), "")
+
+
+def session_annotations(evt: BaseHookEvent) -> Annotations:
+    """The annotations the session's dispatch prompt — its first prompt, a lane's brief — declares."""
+    return dict(dispatch_pairs(dispatch_prompt(evt)))
+
+
+class Annotated(CustomCondition):
+    """Matches when the event carries the ``ccx:`` annotation ``key``, set to ``value`` when one is given.
+
+    Three carriers feed :attr:`~captain_hook.BaseHookEvent.annotations`: a ``ccx:<key>[=<value>]`` token in a
+    real comment of a Bash command (``gt submit  # ccx:raw``), a whole ``ccx: <key>[=<value>] ...`` line in an
+    Agent or Task prompt or in Skill args, and ``CAPT_HOOK_CCX_RAW=1`` for ``raw``. ``scope="session"`` reads
+    only the session's dispatch prompt instead, so a lane briefed with ``ccx: role=fix`` matches on every call and
+    a command can never claim the role for itself.
+
+    Example:
+        >>> hook(Event.PreToolUse, only_if=[Runs("gt", "submit")], skip_if=[Annotated("raw")], message="...")
+        >>> Annotated("role", "evidence", scope="session")
+    """
+
+    def __init__(self, key: str, value: str | None = None, *, scope: Literal["event", "session"] = "event") -> None:
+        self.key = key
+        self.value = value
+        self.scope = scope
+
+    def matches(self, annotations: Annotations) -> bool:
+        return self.key in annotations and (self.value is None or annotations[self.key] == self.value)
+
+    def check(self, evt: BaseHookEvent) -> bool:
+        return self.matches(session_annotations(evt) if self.scope == "session" else evt.annotations)

{capt_hook-12.76.2 → capt_hook-12.77.0}/captain_hook/app.py

@@ -12,6 +12,7 @@ from typing import TYPE_CHECKING, Any, get_args
 from captain_hook.conditions import matches_conditions
 from captain_hook.state import caller_file, hook_name
 from captain_hook.types import (
+    TOOL_EVENTS,
     CustomCondition,
     Event,
     HookSpec,
@@ -24,6 +25,7 @@ from captain_hook.types import (
 if TYPE_CHECKING:
     from cc_transcript.activity import UserClassifier
 
+    from captain_hook.confirm import Confirm
     from captain_hook.events import BaseHookEvent
     from captain_hook.settings import HooksSettings
     from captain_hook.types import HookResult
@@ -69,6 +71,14 @@ def reject_async_fail_closed(async_: bool, on_incomplete: str | None) -> None:
         raise AsyncDecisionError("on_incomplete is invalid with async_=True: an async hook has no call to block.")
 
 
+def reject_confirm_misuse(events: Event, block: bool, confirm: Confirm | None) -> None:
+    """Reject a ``confirm`` with no block to confirm, or on an event with no tool call for the model to judge."""
+    if confirm is not None and not block:
+        raise ValueError("confirm needs block=True: it settles a block, and a warn has nothing to settle.")
+    if confirm is not None and events & ~TOOL_EVENTS:
+        raise ValueError("confirm judges a tool call, so it runs only on tool events.")
+
+
 def reject_transcript_events(transcript_events: int | None) -> None:
     """Reject a declared window the snapshot engine's ``tail`` operation cannot serve."""
     if transcript_events is not None and not 0 < transcript_events <= MAX_TRANSCRIPT_EVENTS:
@@ -216,6 +226,7 @@ def hook(
     only_if: Sequence[TCondition] = (),
     skip_if: Sequence[TCondition] = (),
     block: bool = False,
+    confirm: Confirm | None = None,
     advisory_on_deny: bool = False,
     respect_gitignore: bool = True,
     max_fires: int | None = None,
@@ -227,6 +238,7 @@ def hook(
 ) -> None:
     reject_async_decision(events, async_)
     reject_mandatory_misuse(events, async_, mandatory)
+    reject_confirm_misuse(events, block, confirm)
     reject_transcript_events(transcript_events)
     validate_conditions(only_if, "only_if", events)
     validate_conditions(skip_if, "skip_if", events)
@@ -238,6 +250,7 @@ def hook(
                 skip_if=tuple(skip_if),
                 message=message,
                 block=block,
+                confirm=confirm,
                 advisory_on_deny=advisory_on_deny,
                 respect_gitignore=respect_gitignore,
                 max_fires=max_fires,

{capt_hook-12.76.2 → capt_hook-12.77.0}/captain_hook/builtin_packs/graphite/hooks/_lib.py

@@ -8,15 +8,13 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from captain_hook import BaseHookEvent, CustomCommandLineCondition, CustomCondition, FileFixture, Input
-from captain_hook.util import reqenv
-from captain_hook.util.vcs import ccx_raw_marked, graphite_lane, graphite_lane_of_git_dir
+from captain_hook.util.vcs import graphite_lane, graphite_lane_of_git_dir
 
 if TYPE_CHECKING:
     from cc_transcript.command import CommandLine
 
     from captain_hook.cmd import Call
 
-RAW_ENV = "CAPT_HOOK_CCX_RAW"
 FIXTURE_GITDIR = Path(__file__).parents[1] / "gitdir"
 
 JJ_READS = frozenset(
@@ -167,14 +165,6 @@ class CcxInstalled(CustomCondition):
         return shutil.which("ccx") is not None
 
 
-class RawRequested(CustomCommandLineCondition):
-    """Matches a command that opts out of ccx steering: a ``# ccx:raw`` comment on the line, or
-    ``CAPT_HOOK_CCX_RAW`` set for the session. Either runs the raw command as written."""
-
-    def check_command_line(self, evt: BaseHookEvent, cl: CommandLine) -> bool:
-        return bool(reqenv.getenv(RAW_ENV)) or ccx_raw_marked(evt.cmd.raw)
-
-
 def git_probe(call: Call, session_cwd: Path | None, *args: str) -> str | None:
     """Run a read-only ``git`` query against the repository ``call`` targets; ``None`` when git exits non-zero."""
     cwd, git_dir = git_location(call, session_cwd)

{capt_hook-12.76.2 → capt_hook-12.77.0}/captain_hook/builtin_packs/graphite/hooks/queue.py

@@ -7,10 +7,9 @@ from typing import TYPE_CHECKING
 
 from loguru import logger
 
-from captain_hook import Allow, BaseHookEvent, Event, HookResult, Input, Tool, on
+from captain_hook import Allow, Annotated, BaseHookEvent, Event, HookResult, Input, Tool, on
 from captain_hook.builtin_packs.graphite.hooks._lib import (
     CcxInstalled,
-    RawRequested,
     git_location,
     git_probe,
     graphite_owns,
@@ -228,7 +227,7 @@ def holds(cwd: Path, planned: list[Push]) -> list[Push]:
 @on(
     Event.PreToolUse,
     only_if=[Tool("Bash"), CcxInstalled()],
-    skip_if=[RawRequested()],
+    skip_if=[Annotated("raw")],
     tests={
         Input(command="git push", cwd="/"): Allow(),
         Input(command="ccx vcs push", cwd="/"): Allow(),

{capt_hook-12.76.2 → capt_hook-12.77.0}/captain_hook/builtin_packs/graphite/hooks/vcs.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING
 
 from captain_hook import (
     Allow,
+    Annotated,
     BaseHookEvent,
     CommandSchema,
     CustomCommandLineCondition,
@@ -30,7 +31,6 @@ from captain_hook.builtin_packs.graphite.hooks._lib import (
     HasFlag,
     JJReads,
     PushesTagRef,
-    RawRequested,
     force_pushes,
     git_location,
     git_probe,
@@ -67,7 +67,7 @@ GH_PR_VIEW = CommandSchema(
 hook(
     Event.PreToolUse,
     only_if=[Tool("Bash"), GraphiteRuns(("jj",))],
-    skip_if=[JJReads(), RawRequested()],
+    skip_if=[JJReads(), Annotated("raw")],
     message=(
         "The repository this command targets keeps its stack in Graphite, which jj writes leave stale. "
         'Run `ccx vcs ship -m "<msg>"` to commit and submit instead.'
@@ -77,6 +77,10 @@ hook(
         in_graphite_repo("jj log && jj new"): Warn(pattern="Graphite"),
         in_graphite_repo("jj log"): Allow(),
         in_graphite_repo("jj new # ccx:raw"): Allow(),
+        in_graphite_repo("bash -c 'jj new # ccx:raw'"): Allow(),
+        in_graphite_repo("jj new && echo '# ccx:raw'"): Warn(pattern="Graphite"),
+        in_graphite_repo("jj new", env={"CAPT_HOOK_CCX_RAW": "0"}): Warn(pattern="Graphite"),
+        in_graphite_repo("jj new", env={"CAPT_HOOK_CCX_RAW": "true"}): Allow(),
         Input(command="jj new", cwd="/"): Allow(),
     },
 )
@@ -96,7 +100,7 @@ hook(
             ("git", "checkout", "-B"),
         ),
     ],
-    skip_if=[HasFlag("--dry-run"), HasFlag("--tags"), PushesTagRef(), RawRequested()],
+    skip_if=[HasFlag("--dry-run"), HasFlag("--tags"), PushesTagRef(), Annotated("raw")],
     message=(
         "The repository this command targets keeps its stack in Graphite, so raw git commits, branches, and "
         'pushes leave it stale. Run `ccx vcs ship -m "<msg>"` instead.'
@@ -123,11 +127,21 @@ hook(
         HasFlag("--dry-run"),
         HasFlag("--no-push"),
         HasFlag("--help", "-h"),
+        Annotated("role", scope="session"),
     ],
     message="Submit a change only after a review pass over its diff. Run `/cc-review:start` first.",
     tests={
         in_graphite_repo("gt submit"): Warn(pattern="review pass"),
         in_graphite_repo("ccx vcs ship -m x"): Warn(pattern="review pass"),
+        in_graphite_repo(
+            'ccx vcs ship -m "fix: x" --new-branch=hooks/x', transcript=[T.user("ccx: role=fix\nShip the fix.")]
+        ): Allow(),
+        in_graphite_repo(
+            'ccx vcs ship -m "fix: x" --new-branch=hooks/x', transcript=[T.user("Give this lane role=fix and ship.")]
+        ): Warn(pattern="review pass"),
+        in_graphite_repo("gt submit # ccx:role=fix", transcript=[T.user("Ship this change.")]): Warn(
+            pattern="review pass"
+        ),
         in_graphite_repo(
             "gt submit", transcript=[T.assistant(T.tool("Skill", skill="cc-review:start")), T.user("ship it")]
         ): Allow(),
@@ -175,7 +189,7 @@ hook(
         Tool("Bash"),
         GraphiteRuns(("git", "rebase"), ("git", "merge"), ("git", "pull")),
     ],
-    skip_if=[HasFlag("--abort", "--continue", "--quit"), RawRequested()],
+    skip_if=[HasFlag("--abort", "--continue", "--quit"), Annotated("raw")],
     message=(
         "A raw `git rebase`, `merge`, or `pull` leaves Graphite's parent records stale. "
         "Run `ccx vcs stack rebase` to replay the stack instead."
@@ -303,7 +317,7 @@ def hand_run_force_push(call: Call, evt: BaseHookEvent) -> bool:
 @on(
     Event.PreToolUse,
     only_if=[Tool("Bash"), CcxInstalled()],
-    skip_if=[RawRequested()],
+    skip_if=[Annotated("raw")],
     tests={
         Input(command="gt submit", cwd="/"): Allow(),
         Input(command="gt restack", cwd="/"): Allow(),
@@ -337,7 +351,7 @@ def stack_writes_go_through_ccx(evt: BaseHookEvent) -> HookResult | None:
 @on(
     Event.PreToolUse,
     only_if=[Tool("Bash"), CcxInstalled(), GraphiteCall(hand_run_submit)],
-    skip_if=[RawRequested()],
+    skip_if=[Annotated("raw")],
     tests={Input(command="gt submit --ai", cwd="/"): Allow(), Input(command="git status", cwd="/"): Allow()},
 )
 def gt_submit_through_ccx(evt: BaseHookEvent) -> HookResult | None:
@@ -349,7 +363,7 @@ def gt_submit_through_ccx(evt: BaseHookEvent) -> HookResult | None:
 @on(
     Event.PreToolUse,
     only_if=[Tool("Bash"), CcxInstalled(), GraphiteCall(hand_run_restack)],
-    skip_if=[RawRequested()],
+    skip_if=[Annotated("raw")],
     tests={Input(command="gt sync", cwd="/"): Allow(), Input(command="gt log", cwd="/"): Allow()},
 )
 def gt_restack_through_ccx(evt: BaseHookEvent) -> HookResult | None:
@@ -362,7 +376,7 @@ def gt_restack_through_ccx(evt: BaseHookEvent) -> HookResult | None:
 @on(
     Event.PreToolUse,
     only_if=[Tool("Bash"), CcxInstalled(), GraphiteCall(hand_run_create)],
-    skip_if=[RawRequested()],
+    skip_if=[Annotated("raw")],
     tests={Input(command="gt create feat -m x", cwd="/"): Allow(), Input(command="gt log", cwd="/"): Allow()},
 )
 def gt_create_through_ccx(evt: BaseHookEvent) -> HookResult | None:
@@ -375,7 +389,7 @@ def gt_create_through_ccx(evt: BaseHookEvent) -> HookResult | None:
 @on(
     Event.PreToolUse,
     only_if=[Tool("Bash"), CcxInstalled(), GraphiteCall(hand_run_modify)],
-    skip_if=[RawRequested()],
+    skip_if=[Annotated("raw")],
     tests={Input(command="gt modify -m x", cwd="/"): Allow(), Input(command="gt log", cwd="/"): Allow()},
 )
 def gt_modify_through_ccx(evt: BaseHookEvent) -> HookResult | None:
@@ -387,7 +401,7 @@ def gt_modify_through_ccx(evt: BaseHookEvent) -> HookResult | None:
 @on(
     Event.PreToolUse,
     only_if=[Tool("Bash"), CcxInstalled(), GraphiteCall(hand_run_rebase)],
-    skip_if=[RawRequested()],
+    skip_if=[Annotated("raw")],
     tests={Input(command="git rebase main", cwd="/"): Allow(), Input(command="git rebase --abort", cwd="/"): Allow()},
 )
 def git_rebase_through_ccx(evt: BaseHookEvent) -> HookResult | None:
@@ -400,7 +414,7 @@ def git_rebase_through_ccx(evt: BaseHookEvent) -> HookResult | None:
 @on(
     Event.PreToolUse,
     only_if=[Tool("Bash"), CcxInstalled(), GraphiteCall(conflict_rebase_control)],
-    skip_if=[RawRequested()],
+    skip_if=[Annotated("raw")],
     tests={
         Input(command="git rebase --continue", cwd="/"): Allow(),
         Input(command="git rebase main", cwd="/"): Allow(),
@@ -415,7 +429,7 @@ def conflict_workspace_finishes_through_ccx(evt: BaseHookEvent) -> HookResult |
 @on(
     Event.PreToolUse,
     only_if=[Tool("Bash"), CcxInstalled(), GraphiteCall(hand_run_force_push)],
-    skip_if=[RawRequested()],
+    skip_if=[Annotated("raw")],
     tests={Input(command="git push -f origin feat", cwd="/"): Allow(), Input(command="git push", cwd="/"): Allow()},
 )
 def force_push_through_ccx(evt: BaseHookEvent) -> HookResult | None: