capt-hook 4.5.0__tar.gz → 5.1.0__tar.gz

{capt_hook-4.5.0 → capt_hook-5.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: capt-hook
-Version: 4.5.0
+Version: 5.1.0
 Summary: Declarative hook framework for Claude Code
 Keywords: claude,claude-code,hooks,llm,agents,guardrails,cli
 Author: Yasyf Mohamedali

{capt_hook-4.5.0 → capt_hook-5.1.0}/captain_hook/__init__.py

@@ -20,8 +20,8 @@ from cc_transcript.tools import (
 )
 
 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.app import hook, on
+from captain_hook.command import CommandLine, ParsedCommand, Redirect
 from captain_hook.context import HookContext
 from captain_hook.durable import DurableSlot, DurableState, DurableStore
 from captain_hook.events import (
@@ -73,6 +73,8 @@ from captain_hook.testing import Allow, Block, FileFixture, InlineTests, Input,
 from captain_hook.types import (
     Action,
     Agent,
+    And,
+    Command,
     Content,
     CustomCommandLineCondition,
     CustomCondition,
@@ -82,9 +84,12 @@ from captain_hook.types import (
     HookResponse,
     HookResult,
     InPlanMode,
+    Not,
+    Or,
     Pattern,
     RanCommand,
     ReadFile,
+    Runs,
     Signal,
     Signals,
     SourceEdits,

{capt_hook-4.5.0 → capt_hook-5.1.0}/captain_hook/app.py

@@ -9,12 +9,23 @@ from typing import TYPE_CHECKING, get_args
 
 from captain_hook.conditions import matches_conditions
 from captain_hook.types import (
+    Agent,
+    Command,
+    Content,
     CustomCondition,
     Event,
+    FilePath,
     HookSpec,
     InlineTests,
+    Pattern,
     RegisteredHook,
+    Runs,
+    SourceEdits,
     TCondition,
+    TestFile,
+    Tool,
+    ToolInput,
+    WorkflowScript,
 )
 
 if TYPE_CHECKING:
@@ -29,14 +40,38 @@ HookHandler = Callable[["BaseHookEvent"], "HookResult | None"]
 VALID_CONDITION_TYPES = tuple(t for t in get_args(TCondition) if t is not CustomCondition)
 VALID_CONDITION_NAMES = ", ".join(t.__name__ for t in VALID_CONDITION_TYPES) + ", or a CustomCondition"
 
-
-def validate_conditions(conditions: Sequence[TCondition], label: str) -> None:
+_TOOL_EVENTS = Event.PreToolUse | Event.PostToolUse | Event.PostToolUseFailure
+
+# Conditions that read the current event's tool input can only match on a tool event; a
+# condition absent from this map (transcript-history conditions, InPlanMode, Waiting,
+# combinators, CustomCondition) reads session state and is valid on every event.
+_CONDITION_EVENTS: dict[type, Event] = {
+    Tool: _TOOL_EVENTS,
+    ToolInput: _TOOL_EVENTS,
+    WorkflowScript: _TOOL_EVENTS,
+    Command: _TOOL_EVENTS,
+    Runs: _TOOL_EVENTS,
+    FilePath: _TOOL_EVENTS,
+    Content: _TOOL_EVENTS,
+    Pattern: _TOOL_EVENTS,
+    TestFile: _TOOL_EVENTS,
+    SourceEdits: _TOOL_EVENTS,
+    Agent: _TOOL_EVENTS | Event.SubagentStart | Event.SubagentStop,
+}
+
+
+def validate_conditions(conditions: Sequence[TCondition], label: str, events: Event | None = None) -> None:
     for c in conditions:
         if not isinstance(c, (*VALID_CONDITION_TYPES, CustomCondition)):
             raise TypeError(
                 f"Invalid condition in {label}: {c!r} (type {type(c).__name__}). "
                 f"Expected one of: {VALID_CONDITION_NAMES}."
             )
+        if events is not None and (valid := _CONDITION_EVENTS.get(type(c))) is not None and not (events & valid):
+            raise TypeError(
+                f"{c!r} in {label} can never match on {events!r} — it reads the current tool input, "
+                f"which only exists on {valid!r}."
+            )
 
 
 def validate_handler_signature(fn: HookHandler) -> None:
@@ -70,6 +105,7 @@ class State:
     gitignore_patterns: list[str] = field(default_factory=list)
     settings: HooksSettings | None = None
     classifier: UserClassifier | None = None
+    load_errors: list[tuple[str, BaseException]] = field(default_factory=list)
     counter: int = field(default=0, repr=False)
 
 
@@ -79,6 +115,7 @@ _state = State()
 def reset() -> None:
     _state.hooks.clear()
     _state.gitignore_patterns.clear()
+    _state.load_errors.clear()
     _state.counter = 0
     _state.settings = None
     _state.classifier = None
@@ -104,10 +141,10 @@ def is_gitignored(path_str: str) -> bool:
 
 def hook(
     events: Event,
+    message: str,
     *,
     only_if: Sequence[TCondition] = (),
     skip_if: Sequence[TCondition] = (),
-    message: str | None = None,
     block: bool = False,
     respect_gitignore: bool = True,
     max_fires: int | None = None,
@@ -115,13 +152,8 @@ def hook(
     async_: bool = False,
     skip_planning_agents: bool = True,
 ) -> None:
-    if message is None:
-        raise TypeError(
-            "hook() requires message= for declarative hooks. "
-            "Provide message='...' or use @on() for handler-based hooks."
-        )
-    validate_conditions(only_if, "only_if")
-    validate_conditions(skip_if, "skip_if")
+    validate_conditions(only_if, "only_if", events)
+    validate_conditions(skip_if, "skip_if", events)
     _state.counter += 1
     _state.hooks.append(
         RegisteredHook(
@@ -153,77 +185,12 @@ def on(
     async_: bool = False,
     skip_planning_agents: bool = True,
 ) -> Callable[[HookHandler], HookHandler]:
-    validate_conditions(only_if, "only_if")
-    validate_conditions(skip_if, "skip_if")
-    spec = HookSpec(
-        events=events,
-        only_if=tuple(only_if),
-        skip_if=tuple(skip_if),
-        respect_gitignore=respect_gitignore,
-        max_fires=max_fires,
-        tests=tests,
-        async_=async_,
-        skip_planning_agents=skip_planning_agents,
-    )
-
-    def decorator(fn: HookHandler) -> HookHandler:
-        validate_handler_signature(fn)
-        _state.hooks.append(
-            RegisteredHook(
-                spec=spec,
-                handler=fn,
-                name=fn.__name__,
-                source_file=fn.__code__.co_filename,
-            )
-        )
-        return fn
-
-    return decorator
-
-
-def register(
-    events: Event,
-    *,
-    only_if: Sequence[TCondition] = (),
-    skip_if: Sequence[TCondition] = (),
-    message: str | None = None,
-    block: bool = False,
-    respect_gitignore: bool = True,
-    max_fires: int | None = None,
-    tests: InlineTests | None = None,
-    async_: bool = False,
-    skip_planning_agents: bool = True,
-) -> Callable[[HookHandler], HookHandler] | None:
-    validate_conditions(only_if, "only_if")
-    validate_conditions(skip_if, "skip_if")
-
-    if message is not None:
-        hook(
-            events,
-            only_if=only_if,
-            skip_if=skip_if,
-            message=message,
-            block=block,
-            respect_gitignore=respect_gitignore,
-            max_fires=max_fires,
-            tests=tests,
-            async_=async_,
-            skip_planning_agents=skip_planning_agents,
-        )
-        return None
-
-    if block:
-        raise TypeError(
-            "hook() called with block=True but no message= provided. "
-            "Declarative hooks require message= to specify the block reason. "
-            "Either provide message='...' or use @on() for handler-based hooks."
-        )
-
+    validate_conditions(only_if, "only_if", events)
+    validate_conditions(skip_if, "skip_if", events)
     spec = HookSpec(
         events=events,
         only_if=tuple(only_if),
         skip_if=tuple(skip_if),
-        block=block,
         respect_gitignore=respect_gitignore,
         max_fires=max_fires,
         tests=tests,

{capt_hook-4.5.0 → capt_hook-5.1.0}/captain_hook/classifiers/__init__.py

@@ -9,8 +9,6 @@ if TYPE_CHECKING:
     from cc_transcript.activity import UserClassifier
     from cc_transcript.models import TranscriptEvent
 
-CLASSIFIER_MODULES = ("droid", "conductor", "native")
-
 
 def detect(
     cwd: str | None = None,
@@ -20,7 +18,7 @@ def detect(
     """Auto-detect the environment and return the user classifier for turn segmentation."""
     return next(
         mod.classifier
-        for name in CLASSIFIER_MODULES
+        for name in ("droid", "conductor", "native")
         if (mod := importlib.import_module(f".{name}", __package__))
         and mod.detect(cwd=cwd, transcript_path=transcript_path, events=events)
     )

{capt_hook-4.5.0 → capt_hook-5.1.0}/captain_hook/classifiers/conductor.py

@@ -10,16 +10,16 @@ if TYPE_CHECKING:
 
     from cc_transcript.models import TranscriptEvent
 
-SYNTHETIC_PREFIXES = (
-    "<system_instruction>",
-    "<task-notification>",
-    "<local-command-caveat>",
-    "<command-name>",
-)
-
 
 def classifier(event: UserEvent) -> bool:
-    return native_user_classifier(event) and not event.text.strip().startswith(SYNTHETIC_PREFIXES)
+    return native_user_classifier(event) and not event.text.strip().startswith(
+        (
+            "<system_instruction>",
+            "<task-notification>",
+            "<local-command-caveat>",
+            "<command-name>",
+        )
+    )
 
 
 def detect(

{capt_hook-4.5.0 → capt_hook-5.1.0}/captain_hook/cli.py

@@ -27,7 +27,6 @@ from captain_hook.types import Event
 
 DIST_NAME = "capt-hook"
 EVENT_NAMES = ", ".join(n for e in Event if (n := e.name))
-MARKETPLACE = {"captain-hook": {"source": {"source": "github", "repo": "yasyf/captain-hook"}}}
 PLUGIN_ID = "captain-hook@captain-hook"
 
 
@@ -79,7 +78,8 @@ def register_marketplace(root: Path) -> None:
         settings_path,
         existing
         | {
-            "extraKnownMarketplaces": existing.get("extraKnownMarketplaces", {}) | MARKETPLACE,
+            "extraKnownMarketplaces": existing.get("extraKnownMarketplaces", {})
+            | {"captain-hook": {"source": {"source": "github", "repo": "yasyf/captain-hook"}}},
             "enabledPlugins": existing.get("enabledPlugins", {}) | {PLUGIN_ID: True},
         },
     )
@@ -402,10 +402,23 @@ def expected_kinds_from_state() -> dict[str, str]:
 
 
 def run_tests(json_output: bool = False) -> None:
+    from captain_hook.app import _state
     from captain_hook.testing.helpers import run_inline_tests
 
+    load_errors = list(_state.load_errors)
+    for source, exc in load_errors:
+        line = f"{type(exc).__name__}: {exc}"
+        if json_output:
+            print(json.dumps({"id": source, "status": "load_error", "reason": line}))
+        else:
+            print(f"  ERROR {source} failed to import: {line}")
+
     results = run_inline_tests()
     if not results:
+        if load_errors:
+            if not json_output:
+                print(f"\n{len(load_errors)} hook file(s) failed to import.")
+            sys.exit(1)
         if json_output:
             print(json.dumps({"status": "empty", "reason": "no inline tests"}))
         else:
@@ -448,8 +461,11 @@ def run_tests(json_output: bool = False) -> None:
 
     if not json_output:
         total = passed + failed + errors + skipped
-        print(f"\n{total} tests: {passed} passed, {failed} failed, {errors} errors, {skipped} skipped")
-    if failed or errors:
+        summary = f"\n{total} tests: {passed} passed, {failed} failed, {errors} errors, {skipped} skipped"
+        if load_errors:
+            summary += f", {len(load_errors)} import errors"
+        print(summary)
+    if failed or errors or load_errors:
         sys.exit(1)
 
 

{capt_hook-4.5.0 → capt_hook-5.1.0}/captain_hook/command.py

@@ -12,10 +12,7 @@ from tree_sitter import Language, Node, Parser
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterator
 
-BASH_LANGUAGE = Language(tsbash.language())  # pyright: ignore[reportDeprecated]
-BASH_PARSER = Parser(BASH_LANGUAGE)
-
-COMPOUND_OPS = frozenset({"&&", "||", ";", "|", "&"})
+BASH_PARSER = Parser(Language(tsbash.language()))  # pyright: ignore[reportDeprecated]
 
 
 @dataclass(frozen=True)
@@ -28,10 +25,10 @@ class Redirect:
 
 
 @dataclass(frozen=True)
-class Command:
+class ParsedCommand:
     """A single parsed shell command with executable, arguments, env vars, and redirects.
 
-    Use ``Command.parse(raw)`` to parse a command string, or access via ``CommandLine``.
+    Use ``ParsedCommand.parse(raw)`` to parse a command string, or access via ``CommandLine``.
     """
 
     raw: str
@@ -41,11 +38,11 @@ class Command:
     redirects: tuple[Redirect, ...] = ()
 
     @classmethod
-    def parse(cls, raw: str) -> Command:
+    def parse(cls, raw: str) -> ParsedCommand:
         return CommandLine.parse(raw).primary
 
     @classmethod
-    def empty(cls) -> Command:
+    def empty(cls) -> ParsedCommand:
         return cls(raw="", executable="", args=())
 
     @cached_property
@@ -89,7 +86,7 @@ class CommandLine:
     """
 
     raw: str
-    parts: tuple[tuple[Command, str | None], ...]
+    parts: tuple[tuple[ParsedCommand, str | None], ...]
 
     @classmethod
     def parse(cls, raw: str) -> CommandLine:
@@ -100,18 +97,18 @@ class CommandLine:
         return cls(raw=raw, parts=((cls.fallback(raw), None),))
 
     @cached_property
-    def commands(self) -> tuple[Command, ...]:
+    def commands(self) -> tuple[ParsedCommand, ...]:
         return tuple(cmd for cmd, _ in self.parts)
 
     @cached_property
-    def primary(self) -> Command:
-        return self.parts[-1][0] if self.parts else Command.empty()
+    def primary(self) -> ParsedCommand:
+        return self.parts[-1][0] if self.parts else ParsedCommand.empty()
 
     @cached_property
-    def head(self) -> Command:
-        return self.parts[0][0] if self.parts else Command.empty()
+    def head(self) -> ParsedCommand:
+        return self.parts[0][0] if self.parts else ParsedCommand.empty()
 
-    def __iter__(self) -> Iterator[Command]:
+    def __iter__(self) -> Iterator[ParsedCommand]:
         return iter(self.commands)
 
     def __len__(self) -> int:
@@ -197,7 +194,7 @@ class CommandLine:
         return Redirect(op=op, target=target, fd=fd)
 
     @staticmethod
-    def extract_command(node: Node) -> Command:
+    def extract_command(node: Node) -> ParsedCommand:
         executable = ""
         args: list[str] = []
         env: list[tuple[str, str]] = []
@@ -235,7 +232,7 @@ class CommandLine:
                 case _:
                     pass
 
-        return Command(
+        return ParsedCommand(
             raw=CommandLine.node_text(node),
             executable=executable,
             args=tuple(args),
@@ -244,8 +241,8 @@ class CommandLine:
         )
 
     @staticmethod
-    def collect_parts(children: list[Node], ops: frozenset[str]) -> list[tuple[Command, str | None]]:
-        parts: list[tuple[Command, str | None]] = []
+    def collect_parts(children: list[Node], ops: frozenset[str]) -> list[tuple[ParsedCommand, str | None]]:
+        parts: list[tuple[ParsedCommand, str | None]] = []
         for child in children:
             text = CommandLine.node_text(child)
             if child.type in ops or text in ops:
@@ -258,9 +255,9 @@ class CommandLine:
         return parts
 
     @staticmethod
-    def walk_redirected(node: Node) -> list[tuple[Command, str | None]]:
+    def walk_redirected(node: Node) -> list[tuple[ParsedCommand, str | None]]:
         redirects: list[Redirect] = []
-        inner_parts: list[tuple[Command, str | None]] = []
+        inner_parts: list[tuple[ParsedCommand, str | None]] = []
         for child in node.children:
             if child.type == "file_redirect":
                 redirects.append(CommandLine.extract_redirect(child))
@@ -269,7 +266,7 @@ class CommandLine:
         if redirects and inner_parts:
             inner_parts = [
                 (
-                    Command(
+                    ParsedCommand(
                         raw=cmd.raw,
                         executable=cmd.executable,
                         args=cmd.args,
@@ -282,7 +279,7 @@ class CommandLine:
             ]
         return inner_parts or [
             (
-                Command(
+                ParsedCommand(
                     raw=CommandLine.node_text(node),
                     executable="",
                     args=(),
@@ -293,12 +290,12 @@ class CommandLine:
         ]
 
     @staticmethod
-    def walk_node(node: Node) -> list[tuple[Command, str | None]]:
+    def walk_node(node: Node) -> list[tuple[ParsedCommand, str | None]]:
         match node.type:
             case "program":
                 return CommandLine.collect_parts(node.children, frozenset({";"}))
             case "list":
-                return CommandLine.collect_parts(node.children, COMPOUND_OPS)
+                return CommandLine.collect_parts(node.children, frozenset({"&&", "||", ";", "|", "&"}))
             case "pipeline":
                 return CommandLine.collect_parts(node.children, frozenset({"|"}))
             case "command":
@@ -306,14 +303,14 @@ class CommandLine:
             case "redirected_statement":
                 return CommandLine.walk_redirected(node)
             case _:
-                parts: list[tuple[Command, str | None]] = []
+                parts: list[tuple[ParsedCommand, str | None]] = []
                 for child in node.children:
                     parts.extend(CommandLine.walk_node(child))
                 return parts
 
     @staticmethod
-    def fallback(raw: str) -> Command:
-        return Command(raw=raw, executable=raw.split()[0] if raw.split() else raw, args=())
+    def fallback(raw: str) -> ParsedCommand:
+        return ParsedCommand(raw=raw, executable=raw.split()[0] if raw.split() else raw, args=())
 
 
 @dataclass(frozen=True)
@@ -350,11 +347,11 @@ class CommandLineQuery:
         """
         return any(name in cmd.args for cmd in self.line.commands)
 
-    def any_command(self, pred: Callable[[Command], bool]) -> bool:
+    def any_command(self, pred: Callable[[ParsedCommand], bool]) -> bool:
         """Return whether any command in the line satisfies ``pred``.
 
         Args:
-            pred: Predicate applied to each parsed ``Command``.
+            pred: Predicate applied to each parsed ``ParsedCommand``.
 
         Returns:
             ``True`` if ``pred`` returns truthy for at least one command.

{capt_hook-4.5.0 → capt_hook-5.1.0}/captain_hook/conditions.py

@@ -7,19 +7,22 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 from cc_transcript.models import OtherEvent
-from cc_transcript.tools import WorkflowCall, tool_name_matches
+from cc_transcript.tools import SkillCall, WorkflowCall, tool_name_matches
 
 from captain_hook.types import (
     Agent,
+    And,
     Command,
     Content,
     CustomCondition,
     FilePath,
     InPlanMode,
+    Not,
     Or,
     Pattern,
     RanCommand,
     ReadFile,
+    Runs,
     SourceEdits,
     TCondition,
     TestFile,
@@ -99,16 +102,65 @@ def workflow_script_source(evt: BaseHookEvent) -> str | None:
         return None
 
 
+_WF_OPT_VALUE = r"""(?:'([^'\n]*)'|"([^"\n]*)"|`([^`\n]*)`|([$\w][\w.$]*))"""
+
+
+def workflow_opt_values(source: str, key: str) -> list[str]:
+    """Best-effort raw-source scan for values pinned to `key` in agent() opts. Never raises.
+
+    Values are single-line: the whitespace around the colon is horizontal only, so a valueless
+    ``key:`` at end of line does not swallow the next line's token.
+    """
+    return [
+        next(g for g in m.groups() if g is not None)
+        for m in re.finditer(rf"\b{re.escape(key)}[ \t]*:[ \t]*{_WF_OPT_VALUE}", source)
+    ]
+
+
 def matches_workflow_script(cond: WorkflowScript, evt: BaseHookEvent) -> bool:
     if (source := workflow_script_source(evt)) is None:
         return False
-    if cond.pattern is not None:
-        return bool(re.search(cond.pattern, source, re.MULTILINE))
-    return cond.model is not None and any(
-        re.search(cond.model, pinned) for pinned in re.findall(r"""model\s*:\s*['"]([^'"]*)['"]""", source)
+    if cond.pattern is not None and not re.search(cond.pattern, source, re.MULTILINE):
+        return False
+    return all(
+        any(re.search(pattern, value) for value in workflow_opt_values(source, key)) for key, pattern in cond.opts
     )
 
 
+def coerce_tool_input(value: object) -> str | None:
+    """Coerce a scalar raw tool-input value to matchable text; None for non-scalars."""
+    match value:
+        case str():
+            return value
+        case bool():
+            return "true" if value else "false"
+        case int() | float():
+            return str(value)
+        case _:
+            return None
+
+
+def has_read_glob(t: Session, *globs: str, subagents: bool = True) -> bool:
+    from cc_transcript.query import sidechain_sessions
+
+    return any(f.matches(*globs) for f in t.tool_calls.named("Read").files()) or (
+        subagents and any(has_read_glob(sub, *globs) for sub in sidechain_sessions(t.path))
+    )
+
+
+def skill_name_matches(skill: str, names: tuple[str, ...]) -> bool:
+    return skill in names or skill.split(":", 1)[-1] in names
+
+
+def has_used_skill(t: Session, names: tuple[str, ...], *, subagents: bool = True) -> bool:
+    from cc_transcript.query import sidechain_sessions
+
+    return any(
+        isinstance(call := use.call, SkillCall) and skill_name_matches(call.skill, names)
+        for use in t.tool_calls.named("Skill")
+    ) or (subagents and any(has_used_skill(sub, names) for sub in sidechain_sessions(t.path)))
+
+
 def is_project_file(evt: BaseHookEvent) -> bool:
     if not (file := evt.file):
         return False
@@ -121,23 +173,25 @@ def is_project_file(evt: BaseHookEvent) -> bool:
 
 def check_condition(c: TCondition, evt: BaseHookEvent) -> bool:
     match c:
-        case Tool(pattern):
-            return bool(evt.tool_name) and tool_name_matches(evt.tool_name, pattern)
+        case Tool(names):
+            return bool(evt.tool_name) and tool_name_matches(evt.tool_name, "|".join(names))
         case FilePath(patterns, project_only):
             return bool(evt.file and (not project_only or is_project_file(evt)) and evt.file.matches(*patterns))
         case Command(pattern):
-            return bool((cl := evt.command_line) and any(re.search(pattern, str(cmd)) for cmd in cl.commands))
+            return bool(
+                (cl := evt.command_line) and any(re.search(pattern, s) for s in (cl.raw, *map(str, cl.commands)))
+            )
         case Content(pattern, project_only):
             return bool(
                 (not project_only or is_project_file(evt))
                 and evt.content
                 and re.search(pattern, evt.content, re.MULTILINE)
             )
-        case ToolInput(field, pattern):
-            return bool(
-                evt.tool_name
-                and isinstance(value := evt.input.raw.get(field), str)
+        case ToolInput(fields):
+            return bool(evt.tool_name) and all(
+                (value := coerce_tool_input(evt.input.raw.get(field))) is not None
                 and re.search(pattern, value, re.MULTILINE)
+                for field, pattern in fields
             )
         case WorkflowScript() as workflow_script:
             return matches_workflow_script(workflow_script, evt)
@@ -149,8 +203,8 @@ def check_condition(c: TCondition, evt: BaseHookEvent) -> bool:
                 return False
             resolved = lang or (lang_for_path(evt.file.path) if evt.file else None)
             return bool(resolved and ast_grep_matches(evt.content, resolved, pattern))
-        case Agent(name):
-            return bool(evt.agent_type) and evt.agent_type in name.split("|")
+        case Agent(names):
+            return bool(evt.agent_type) and evt.agent_type in names
         case TestFile(project_only):
             return bool(evt.file and (not project_only or is_project_file(evt)) and evt.file.is_test)
         case SourceEdits(lang, include_tests, paths):
@@ -160,16 +214,18 @@ def check_condition(c: TCondition, evt: BaseHookEvent) -> bool:
                 and (f := evt.file)
                 and f.matches(*SourceEdits(lang=lang).globs)
                 and (include_tests or not f.is_test)
-                and (paths is None or f.matches(paths))
+                and (not paths or f.matches(*paths))
             )
-        case UsedSkill(name, subagents):
-            return evt.ctx.transcript.has_skill(*name.split("|"), subagents=subagents)
+        case UsedSkill(names, subagents):
+            return has_used_skill(evt.ctx.transcript, names, subagents=subagents)
         case ReadFile(patterns, subagents):
-            return any(evt.ctx.transcript.has_read(p, subagents=subagents) for p in patterns)
+            return has_read_glob(evt.ctx.transcript, *patterns, subagents=subagents)
         case TouchedFile(patterns, subagents):
             return evt.ctx.transcript.has_edit_to(*patterns, subagents=subagents)
         case RanCommand(pattern, subagents):
             return evt.ctx.transcript.has_command(pattern, subagents=subagents)
+        case Runs(argv):
+            return bool(argv and (cl := evt.command_line) and any(cmd.argv[: len(argv)] == argv for cmd in cl.commands))
         case InPlanMode():
             return evt.permission_mode == "plan" or (
                 (t := evt.ctx.transcript).tool_calls.named("EnterPlanMode").count()
@@ -177,6 +233,10 @@ def check_condition(c: TCondition, evt: BaseHookEvent) -> bool:
             )
         case Waiting():
             return is_waiting(evt)
+        case And(conditions):
+            return all(check_condition(sub, evt) for sub in conditions)
+        case Not(condition):
+            return not check_condition(condition, evt)
         case Or(conditions):
             return any(check_condition(sub, evt) for sub in conditions)
         case CustomCondition():