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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: capt-hook
-Version: 5.0.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-5.0.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-5.0.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-5.0.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},
         },
     )

{capt_hook-5.0.0 → capt_hook-5.1.0}/captain_hook/loader.py

@@ -17,8 +17,6 @@ from captain_hook.settings import build_settings
 
 CONF_MODULE = "conf"
 PACK_PACKAGE_PREFIX = "captain_hook._packs"
-SKIP_MARKER = "__capt_hook_skip__"
-SKIP_MARKER_RE = re.compile(rf"^{SKIP_MARKER}\s*=\s*True\b", re.MULTILINE)
 
 
 def is_test_module(fqn: str) -> bool:
@@ -28,7 +26,7 @@ def is_test_module(fqn: str) -> bool:
 
 def is_skip_marked(path: Path) -> bool:
     """True when the module declares ``__capt_hook_skip__ = True`` — a library, not an auto-loaded hook."""
-    return path.is_file() and bool(SKIP_MARKER_RE.search(path.read_text()))
+    return path.is_file() and bool(re.search(r"^__capt_hook_skip__\s*=\s*True\b", path.read_text(), re.MULTILINE))
 
 
 def import_or_reload(fqn: str, fresh_this_pass: set[str]) -> ModuleType:

{capt_hook-5.0.0 → capt_hook-5.1.0}/captain_hook/packs/general/capt-hook.toml

@@ -1,4 +1,4 @@
 name = "general"
-version = "0.2.0"
+version = "0.3.0"
 description = "Language-agnostic guards: git/command safety, doc & prompt nudges, task & plan discipline, and a code-review gate."
 hooks = "."

capt_hook-5.1.0/captain_hook/packs/general/models.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+from captain_hook import (
+    Agent,
+    Allow,
+    Block,
+    Event,
+    Input,
+    Rewrite,
+    Tool,
+    ToolInput,
+    Warn,
+    WorkflowScript,
+    hook,
+    nudge,
+    set_tool_input,
+)
+
+hook(
+    Event.PreToolUse,
+    only_if=[Tool("Agent|Task"), ToolInput("model", r"(?i)\bhaiku\b")],
+    skip_if=[
+        ToolInput(
+            "prompt",
+            r"(?i)\b(classif|label|tag|categoriz|per.file|one (fact|thing)|mechanical|probe|ping"
+            r"|echo|smoke|count|capacit|extract)",
+        )
+    ],
+    message=(
+        "This subagent is pinned to haiku. Route a subagent to haiku only for a single-fact "
+        "mechanical step — classifying, labeling, tagging, counting, or probing one thing per "
+        "item. Anything that carries judgment should run on sonnet; use model='sonnet', or drop "
+        "model entirely to inherit the session model. If this genuinely is a mechanical "
+        "single-fact step, say 'mechanical' in the prompt and retry — the haiku pin will be "
+        "allowed. See CLAUDE.md § Plan Execution & Orchestration (Models)."
+    ),
+    block=True,
+    tests={
+        Input(model="haiku", prompt="implement the retry backoff in the client"): Block(),
+        Input(model="haiku", prompt="classify each file's language"): Allow(),
+        Input(model="haiku", prompt="Probe subagent capacity: spawn and return the word ok"): Allow(),
+        Input(model="haiku", prompt="mechanical step: return the repo's default branch name"): Allow(),
+        Input(model="haiku", prompt="count the TODO markers in src/"): Allow(),
+        Input(prompt="implement the retry backoff in the client"): Allow(),
+        Input(model="sonnet", prompt="implement the retry backoff in the client"): Allow(),
+    },
+)
+
+hook(
+    Event.PreToolUse,
+    only_if=[
+        Tool("Agent|Task"),
+        ToolInput("model", r"(?i)\b(haiku|sonnet|opus)\b"),
+        ToolInput("prompt", r"(?i)\b(writ(e|es|ing|ten)|draft|redraft|rewrit|revis|polish|copyedit|compose|author|update|edit)"),
+        ToolInput(
+            "prompt",
+            r"(?i)\b(readme|docs?|documentation|blog|changelog|release notes|announcement"
+            r"|tutorial|guide|prose|copywrit|marketing copy|article|newsletter|email"
+            r"|pr description|commit message)\b",
+        ),
+    ],
+    skip_if=[ToolInput("prompt", r"(?i)\b(classif|label|tag|categoriz|count|extract|mechanical)")],
+    message=(
+        "This subagent is pinned to a non-fable model but its prompt is prose/writing work. "
+        "All writing — docs, READMEs, release notes, any user-facing text — routes to fable: "
+        "drop model to inherit the session model, or pass model='fable'. "
+        "See CLAUDE.md § Plan Execution & Orchestration (Models)."
+    ),
+    block=True,
+    tests={
+        Input(model="sonnet", prompt="Write the README quickstart for this repo"): Block(),
+        Input(model="opus", prompt="draft the release notes for v2"): Block(),
+        Input(model="haiku", prompt="update the CHANGELOG entry for the fix"): Block(),
+        Input(model="fable", prompt="write the README quickstart"): Allow(),
+        Input(prompt="write the README quickstart"): Allow(),
+        Input(model="sonnet", prompt="review the README for factual errors"): Allow(),
+        Input(model="sonnet", prompt="update the retry backoff config"): Allow(),
+        Input(model="haiku", prompt="label each README section with its Diataxis mode"): Allow(),
+    },
+)
+
+set_tool_input(
+    "model",
+    "sonnet",
+    tool="Agent|Task",
+    only_if=[Agent("Explore|claude-code-guide")],
+    note=(
+        "Upgraded this recon subagent from the silent haiku default to sonnet, per the Models "
+        "table in CLAUDE.md § Plan Execution & Orchestration (Models)."
+    ),
+    tests={
+        Input(agent_type="Explore"): Rewrite(model="sonnet"),
+        Input(agent_type="Explore", model="haiku"): Allow(),
+        Input(agent_type="general-purpose"): Allow(),
+    },
+)
+
+nudge(
+    """
+    This workflow script pins agent() steps to haiku. Reserve haiku for mechanical single-fact
+    map steps; a judgment-bearing stage should inherit the session model or route up. See
+    CLAUDE.md § Plan Execution & Orchestration (Models).
+    """,
+    only_if=[Tool("Workflow"), WorkflowScript(model="haiku")],
+    events=Event.PreToolUse,
+    max_fires=2,
+    tests={
+        Input(script="steps:\n  - agent: reviewer\n    model: 'haiku'\n"): Warn(),
+        Input(script="steps:\n  - agent: reviewer\n    model: 'sonnet'\n"): Allow(),
+    },
+)
+
+nudge(
+    """
+    This workflow script pins a non-fable model on what looks like prose/writing stages. All
+    writing — docs, READMEs, release notes, any user-facing text — routes to fable: inherit the
+    session model or pin model: 'fable'. See CLAUDE.md § Plan Execution & Orchestration (Models).
+    """,
+    only_if=[
+        Tool("Workflow"),
+        WorkflowScript(
+            pattern=r"(?i)\b(readme|docs?|documentation|blog|changelog|release notes|prose)\b",
+            model="haiku|sonnet|opus",
+        ),
+    ],
+    events=Event.PreToolUse,
+    max_fires=2,
+    tests={
+        Input(script="steps:\n  - agent: write the README intro\n    model: 'sonnet'\n"): Warn(),
+        Input(script="steps:\n  - agent: write the README intro\n    model: 'fable'\n"): Allow(),
+        Input(script="steps:\n  - agent: fix the retry backoff\n    model: 'sonnet'\n"): Allow(),
+    },
+)

{capt_hook-5.0.0 → capt_hook-5.1.0}/captain_hook/packs/general/tasks.py

@@ -22,8 +22,6 @@ from captain_hook import (
 OVERRIDE_TOKEN = "REMAINING_TASKS_ACKNOWLEDGED"
 TASK_DRIFT_THRESHOLD = 8
 
-EXPLORATION_TOOLS = "Bash|Grep|Glob|WebSearch|WebFetch|LSP|Skill"
-
 IMPERATIVES = (
     r"\b(?:add|fix|update|change|remove|create|implement|refactor|"
     r"move|rename|delete|replace|extract|split|merge|convert|migrate)\b"
@@ -54,7 +52,7 @@ class DriftedFromTasks(CustomCondition):
         if not evt.tasks.open:
             return False
         since = evt.ctx.t.after(tool="TaskCreate|TaskUpdate|TaskList|TaskGet")
-        return since.tool_calls.named(EXPLORATION_TOOLS).count() >= TASK_DRIFT_THRESHOLD
+        return since.tool_calls.named("Bash|Grep|Glob|WebSearch|WebFetch|LSP|Skill").count() >= TASK_DRIFT_THRESHOLD
 
 
 gate(

{capt_hook-5.0.0 → capt_hook-5.1.0}/captain_hook/packs/manager.py

@@ -35,23 +35,13 @@ from filelock import FileLock
 from captain_hook import state
 from captain_hook.util import http
 
-PACKS_TOML = "packs.toml"
 PACK_MANIFEST = "capt-hook.toml"
-# A pack's manifest may sit in .claude/ (preferred) or at the repo root.
-MANIFEST_MEMBERS = (f".claude/{PACK_MANIFEST}", PACK_MANIFEST)
 SHA_MARKER = ".sha"
-META_SUFFIX = ".meta"
-FASTPATH_NAME = ".resolve-fastpath"
 LATEST_REF = "latest"
 # Moving refs (@latest / a branch / a bare default-branch source) re-resolve to a fresh
 # commit at most once per this window; within it the cached commit is used with no network.
 REFRESH_TTL_SECONDS = 24 * 60 * 60
-SOURCE_RE = re.compile(r"^github:(?P<owner>[\w.-]+)/(?P<repo>[\w.-]+?)(?:@(?P<ref>[\w./-]+))?$")
 PACK_NAME_RE = re.compile(r"[a-z][a-z0-9-]*")
-GITHUB_REPO = "https://api.github.com/repos/{owner}/{repo}"
-GITHUB_COMMIT = "https://api.github.com/repos/{owner}/{repo}/commits/{ref}"
-GITHUB_LATEST_RELEASE = "https://api.github.com/repos/{owner}/{repo}/releases/latest"
-GITHUB_TARBALL = "https://github.com/{owner}/{repo}/archive/{sha}.tar.gz"
 
 
 class PackError(Exception):
@@ -66,7 +56,7 @@ class PackSource:
 
     @classmethod
     def parse(cls, raw: str) -> PackSource:
-        if not (m := SOURCE_RE.match(raw)):
+        if not (m := re.match(r"^github:(?P<owner>[\w.-]+)/(?P<repo>[\w.-]+?)(?:@(?P<ref>[\w./-]+))?$", raw)):
             raise PackError(f"invalid pack source {raw!r}; expected github:owner/repo[@ref]")
         return cls(owner=m["owner"], repo=m["repo"], ref=m["ref"])
 
@@ -147,7 +137,7 @@ class PackMeta:
 
 
 def packs_toml_path(root: Path) -> Path:
-    return root / ".claude" / "hooks" / PACKS_TOML
+    return root / ".claude" / "hooks" / "packs.toml"
 
 
 def manifest_in(root: Path) -> Path:
@@ -215,24 +205,25 @@ def packs_cache_root() -> Path:
 
 
 def meta_path(name: str) -> Path:
-    return packs_cache_root() / f"{name}{META_SUFFIX}"
+    return packs_cache_root() / f"{name}.meta"
 
 
 def resolve_ref(source: PackSource) -> str:
     """Resolve a source's effective git ref: @latest via the latest release, else the ref or default branch."""
     match source.ref:
         case None:
-            return http.github_get_json(GITHUB_REPO.format(owner=source.owner, repo=source.repo))["default_branch"]
+            url = f"https://api.github.com/repos/{source.owner}/{source.repo}"
+            return http.github_get_json(url)["default_branch"]
         case ref if ref == LATEST_REF:
-            return http.github_get_json(GITHUB_LATEST_RELEASE.format(owner=source.owner, repo=source.repo))["tag_name"]
+            url = f"https://api.github.com/repos/{source.owner}/{source.repo}/releases/latest"
+            return http.github_get_json(url)["tag_name"]
         case ref:
             return ref
 
 
 def resolve_commit(source: PackSource) -> str:
-    return http.github_get_json(GITHUB_COMMIT.format(owner=source.owner, repo=source.repo, ref=resolve_ref(source)))[
-        "sha"
-    ]
+    url = f"https://api.github.com/repos/{source.owner}/{source.repo}/commits/{resolve_ref(source)}"
+    return http.github_get_json(url)["sha"]
 
 
 def strip_top_level(tf: tarfile.TarFile) -> Iterator[tarfile.TarInfo]:
@@ -266,14 +257,17 @@ def fetch_commit(source: PackSource, sha: str) -> ResolvedPack:
     root.mkdir(parents=True, exist_ok=True)
     with FileLock(str(root / f"{sha}.lock")):
         tarball = root / f".tarball-{sha}.tar.gz"
-        http.github_download(GITHUB_TARBALL.format(owner=source.owner, repo=source.repo, sha=sha), tarball)
+        url = f"https://github.com/{source.owner}/{source.repo}/archive/{sha}.tar.gz"
+        http.github_download(url, tarball)
         staging = root / f".staging-{sha}"
         if staging.exists():
             shutil.rmtree(staging)
         with tarfile.open(tarball) as tf:
             members = list(strip_top_level(tf))
             by_path = {m.path: m for m in members}
-            manifest_member = next((by_path[p] for p in MANIFEST_MEMBERS if p in by_path), None)
+            manifest_member = next(
+                (by_path[p] for p in (f".claude/{PACK_MANIFEST}", PACK_MANIFEST) if p in by_path), None
+            )
             if manifest_member is None:
                 raise PackError(f"pack manifest {PACK_MANIFEST} missing in {source}")
             tf.extract(manifest_member, staging, filter="data")
@@ -414,7 +408,7 @@ def all_cached_and_fresh(entries: Sequence[PackEntry], now: float) -> bool:
 
 
 def fastpath_path(root: Path) -> Path:
-    return packs_cache_root() / f"{sha256(str(root.resolve()).encode()).hexdigest()[:16]}{FASTPATH_NAME}"
+    return packs_cache_root() / f"{sha256(str(root.resolve()).encode()).hexdigest()[:16]}.resolve-fastpath"
 
 
 def fastpath_unchanged(root: Path, entries: Sequence[PackEntry], now: float) -> bool:

{capt_hook-5.0.0 → capt_hook-5.1.0}/captain_hook/review/dashboard.py

@@ -31,8 +31,6 @@ if TYPE_CHECKING:
     from captain_hook.review.settings import ReviewSettings
     from captain_hook.review.store import CandidateView, SpawnHealth
 
-BAR_FILLED = "█"
-BAR_EMPTY = "░"
 DETAIL_WIDTH = 80
 KIND_STYLE = {CandidateKind.CREATE: "cyan", CandidateKind.FIX: "magenta"}
 SPAWN_STALE_AFTER = timedelta(days=7)
@@ -81,7 +79,7 @@ def trim(text: str, *, width: int = DETAIL_WIDTH) -> str:
 def bar(done: int, need: int, *, width: int = 5) -> str:
     cells = min(need, width)
     filled = min(cells, round(done / need * cells)) if need else cells
-    return BAR_FILLED * filled + BAR_EMPTY * (cells - filled)
+    return "█" * filled + "░" * (cells - filled)
 
 
 def targets(view: CandidateView, settings: ReviewSettings) -> tuple[tuple[str, int, int], ...]:

{capt_hook-5.0.0 → capt_hook-5.1.0}/captain_hook/review/fix.py

@@ -62,12 +62,8 @@ HOOK_COMPLAINT = SourceKind("hook_complaint")
 PROXIMITY_TURNS = 3
 TIGHT_PROXIMITY_TURNS = 1
 STOP_FEEDBACK_PREFIX = "Stop hook feedback:\n"
-PRIMITIVES_DIR = "captain_hook/primitives/"
-HOOKS_DIR = ".claude/hooks"
 PACKS_DIR = "captain_hook/packs"
 
-HOOK_VOCAB_RE = re.compile(r"\b(?:hook|reminder|nudge|gate|guard)s?\b", re.IGNORECASE)
-
 STRONG_MARKERS: tuple[tuple[str, re.Pattern[str]], ...] = tuple(
     (misfire_class, re.compile(pattern, re.IGNORECASE))
     for misfire_class, pattern in (
@@ -82,12 +78,6 @@ STRONG_MARKERS: tuple[tuple[str, re.Pattern[str]], ...] = tuple(
     )
 )
 
-HEDGED_MARKER_RE = re.compile(
-    r"(?:\bi think\b|\bseems?\b|\bmay\b|\bmight\b|\blooks like\b)"
-    r"[\s\S]{0,80}?(?:false[ -]positive|misfir|re-?fir|shouldn'?t have fired|spurious|unnecessar|wrong(?:ly)?)",
-    re.IGNORECASE,
-)
-
 COMPLIANCE_RE = re.compile(
     r"(?:\bI'?ll\b|\blet me\b|\bgoing to\b|\bgood (?:point|catch)\b|\bnoted\b)"
     r"[\s\S]{0,40}?(?:hook|reminder|gate|nudge)",
@@ -127,9 +117,14 @@ class Fingerprint:
 
 
 def classify_marker(text: str) -> Marker | None:
-    if not HOOK_VOCAB_RE.search(text):
+    if not re.search(r"\b(?:hook|reminder|nudge|gate|guard)s?\b", text, re.IGNORECASE):
         return None
-    hedged = HEDGED_MARKER_RE.search(text)
+    hedged = re.search(
+        r"(?:\bi think\b|\bseems?\b|\bmay\b|\bmight\b|\blooks like\b)"
+        r"[\s\S]{0,80}?(?:false[ -]positive|misfir|re-?fir|shouldn'?t have fired|spurious|unnecessar|wrong(?:ly)?)",
+        text,
+        re.IGNORECASE,
+    )
     strong = next(((cls, m) for cls, rx in STRONG_MARKERS if (m := rx.search(text))), None)
     if strong is not None and hedged is None:
         return Marker("strong", strong[0], strong[1].group(0))
@@ -207,7 +202,7 @@ def attribute_fingerprint(
 def resolve_target(decision: Decision) -> tuple[str, str] | None:
     from captain_hook.packs.manager import builtin_packs
 
-    if PRIMITIVES_DIR not in decision.source_file:
+    if "captain_hook/primitives/" not in decision.source_file:
         return decision.source_file, decision.kind
     module, sep, _ = decision.kind.partition(":")
     if not sep or not module:
@@ -216,7 +211,7 @@ def resolve_target(decision: Decision) -> tuple[str, str] | None:
         case [pack, mod] if (pack_dir := builtin_packs().get(pack)) and (pack_dir / f"{mod}.py").is_file():
             return f"{PACKS_DIR}/{pack}/{mod}.py", decision.kind
         case parts if all(part.isidentifier() for part in parts):
-            return f"{HOOKS_DIR}/{parts[-1]}.py", decision.kind
+            return f".claude/hooks/{parts[-1]}.py", decision.kind
         case _:
             return None
 

{capt_hook-5.0.0 → capt_hook-5.1.0}/captain_hook/review/formats.py

@@ -27,7 +27,6 @@ CONDUCTOR_WORKSTREAM_HEADER_RE = re.compile(
     r"^### (?P<id>[A-Z][\w-]*\d*)\s*\[(?P<kind>[A-Z]+)\]\s*—\s*(?P<title>.+)$",
     re.MULTILINE,
 )
-WORKSTREAM_BODY_RE = re.compile(r"^(?:FIX|Tests): .+$", re.MULTILINE)
 CONDUCTOR_FINDING_FMT = RegexReviewFormat(
     name="conductor-finding",
     groups=(
@@ -70,7 +69,10 @@ def extract_conductor_workstream(text: str) -> tuple[ReviewComment, ...]:
             line_end=None,
             comment=" ".join(
                 [f"{header.group('id')} [{header.group('kind')}] {header.group('title').strip()}"]
-                + [line.group(0).strip() for line in WORKSTREAM_BODY_RE.finditer(text[header.end() : end])]
+                + [
+                    line.group(0).strip()
+                    for line in re.finditer(r"^(?:FIX|Tests): .+$", text[header.end() : end], re.MULTILINE)
+                ]
             ),
         )
         for header, end in zip(

{capt_hook-5.0.0 → capt_hook-5.1.0}/captain_hook/review/judge.py

@@ -47,7 +47,6 @@ TRIGGER_BUDGET = Budget(turn_chars=2000, tool_chars=6000)
 CONTEXT_BUDGET = Budget()
 
 DURABLE_CATEGORIES = frozenset({"durable_style_rule", "workflow_rule", "tooling_rule", "safety_guard"})
-ACCEPTED_CATEGORIES = DURABLE_CATEGORIES | {"misfire_confirmed"}
 
 Category = Literal[
     "durable_style_rule",
@@ -63,81 +62,6 @@ Category = Literal[
     "ambient_mention",
 ]
 
-JUDGE_PROMPT = """\
-You are auditing one piece of feedback a developer gave an AI coding assistant
-(Claude), deciding whether it is a DURABLE correction worth encoding as an
-automated hook — a rule that should fire in every future session of this
-repository — or feedback that only mattered in the moment.
-
-Pick exactly one category:
-- durable_style_rule: a standing code-style or API-design rule ("never use a
-  bare except", "always frozen dataclasses") that future code must follow.
-- workflow_rule: a standing rule about process — how to plan, commit, test,
-  review, or communicate ("always run the tests before claiming done").
-- tooling_rule: a standing rule about which tool or command to use ("use uv,
-  not pip", "search with rg, not grep").
-- safety_guard: a standing guard against a dangerous action ("never force-push
-  to main", "never edit generated files").
-- one_off_correction: fixes the assistant's current output without stating a
-  reusable rule ("rename this one", "the test you broke is test_foo").
-- task_specific: a rule scoped to the current task or file, not the repository
-  ("for this migration keep both columns").
-- preference_unclear: corrective in tone, but the underlying rule cannot be
-  stated precisely enough to automate.
-- ambient_noise: not corrective at all — status updates, questions, new tasks.
-
-The first four categories are durable; the rest are not. A durable correction
-states (or clearly implies) a rule that would be violated again and could be
-checked mechanically. Words like "always", "never", or "stop doing X" are
-strong durability signals; a rule that names one specific line, variable, or
-test is task-scoped, not durable.
-
-summary: ONE neutral sentence naming the rule the feedback implies (or what the
-user reacted to when there is no rule). Write it for every category.
-confidence: your probability (0 to 1) that your durable-vs-not call is correct.
-rationale: one short clause.
-
-Respond with strict JSON matching the schema — no extra keys, no prose.
-
-[source: {source_kind}]
-{context}
-=== FEEDBACK TO CLASSIFY ===
-{text}"""
-
-FIX_JUDGE_PROMPT = """\
-You are auditing one remark an AI coding assistant (Claude) made about an
-automated hook that fired during its session, deciding whether the remark
-REPORTS A MISFIRE — the hook firing wrongly or redundantly — or something else.
-
-Pick exactly one category:
-- misfire_confirmed: the remark asserts the hook fired wrongly — it re-fired on
-  content already addressed, flagged a false positive, or fired outside its
-  intended scope — and the surrounding conversation is consistent with that
-  claim.
-- compliance: the remark acknowledges the hook's message and follows it (or
-  promises to follow it going forward).
-- ambient_mention: the hook is merely described, quoted, or referenced in
-  passing, with no claim that it fired wrongly.
-
-Only misfire_confirmed marks the hook as worth amending. A remark that both
-complies and dismisses ("noted, but this re-fired on text I already fixed") is
-misfire_confirmed — the dismissal is the signal. A remark that merely reports
-the hook fired, or works around it without disputing it, is not.
-
-summary: ONE neutral sentence naming what the hook did and what Claude claims
-about it. Write it for every category.
-confidence: your probability (0 to 1) that your misfire-vs-not call is correct.
-rationale: one short clause.
-
-Respond with strict JSON matching the schema — no extra keys, no prose.
-
-[hook: {hook_name} ({event}/{action})]
-=== the hook's fire message ===
-{fire_message}
-{context}
-=== REMARK TO CLASSIFY ===
-{text}"""
-
 
 class ReviewVerdict(BaseModel):
     """One judge verdict on a stored correction.
@@ -157,7 +81,7 @@ class ReviewVerdict(BaseModel):
     @property
     def accepted(self) -> bool:
         """Whether the category marks a durable correction or a confirmed misfire."""
-        return self.category in ACCEPTED_CATEGORIES
+        return self.category in DURABLE_CATEGORIES | {"misfire_confirmed"}
 
 
 @dataclass(frozen=True, slots=True)
@@ -208,19 +132,83 @@ async def render_context(window: ContextWindow) -> tuple[str, Fidelity]:
 
 
 def build_create_prompt(row: Mapping[str, object], context: str) -> str:
-    return JUDGE_PROMPT.format(source_kind=row["source_kind"], context=context, text=row["text"])
+    return f"""\
+You are auditing one piece of feedback a developer gave an AI coding assistant
+(Claude), deciding whether it is a DURABLE correction worth encoding as an
+automated hook — a rule that should fire in every future session of this
+repository — or feedback that only mattered in the moment.
+
+Pick exactly one category:
+- durable_style_rule: a standing code-style or API-design rule ("never use a
+  bare except", "always frozen dataclasses") that future code must follow.
+- workflow_rule: a standing rule about process — how to plan, commit, test,
+  review, or communicate ("always run the tests before claiming done").
+- tooling_rule: a standing rule about which tool or command to use ("use uv,
+  not pip", "search with rg, not grep").
+- safety_guard: a standing guard against a dangerous action ("never force-push
+  to main", "never edit generated files").
+- one_off_correction: fixes the assistant's current output without stating a
+  reusable rule ("rename this one", "the test you broke is test_foo").
+- task_specific: a rule scoped to the current task or file, not the repository
+  ("for this migration keep both columns").
+- preference_unclear: corrective in tone, but the underlying rule cannot be
+  stated precisely enough to automate.
+- ambient_noise: not corrective at all — status updates, questions, new tasks.
+
+The first four categories are durable; the rest are not. A durable correction
+states (or clearly implies) a rule that would be violated again and could be
+checked mechanically. Words like "always", "never", or "stop doing X" are
+strong durability signals; a rule that names one specific line, variable, or
+test is task-scoped, not durable.
+
+summary: ONE neutral sentence naming the rule the feedback implies (or what the
+user reacted to when there is no rule). Write it for every category.
+confidence: your probability (0 to 1) that your durable-vs-not call is correct.
+rationale: one short clause.
+
+Respond with strict JSON matching the schema — no extra keys, no prose.
+
+[source: {row["source_kind"]}]
+{context}
+=== FEEDBACK TO CLASSIFY ===
+{row["text"]}"""
 
 
 def build_fix_prompt(row: Mapping[str, object], context: str) -> str:
     payload: dict[str, object] = json.loads(str(row["payload_json"]))
-    return FIX_JUDGE_PROMPT.format(
-        hook_name=payload["target_hook_name"],
-        event=payload["event"],
-        action=payload["action"],
-        fire_message=payload["fire_message"],
-        context=context,
-        text=row["text"],
-    )
+    return f"""\
+You are auditing one remark an AI coding assistant (Claude) made about an
+automated hook that fired during its session, deciding whether the remark
+REPORTS A MISFIRE — the hook firing wrongly or redundantly — or something else.
+
+Pick exactly one category:
+- misfire_confirmed: the remark asserts the hook fired wrongly — it re-fired on
+  content already addressed, flagged a false positive, or fired outside its
+  intended scope — and the surrounding conversation is consistent with that
+  claim.
+- compliance: the remark acknowledges the hook's message and follows it (or
+  promises to follow it going forward).
+- ambient_mention: the hook is merely described, quoted, or referenced in
+  passing, with no claim that it fired wrongly.
+
+Only misfire_confirmed marks the hook as worth amending. A remark that both
+complies and dismisses ("noted, but this re-fired on text I already fixed") is
+misfire_confirmed — the dismissal is the signal. A remark that merely reports
+the hook fired, or works around it without disputing it, is not.
+
+summary: ONE neutral sentence naming what the hook did and what Claude claims
+about it. Write it for every category.
+confidence: your probability (0 to 1) that your misfire-vs-not call is correct.
+rationale: one short clause.
+
+Respond with strict JSON matching the schema — no extra keys, no prose.
+
+[hook: {payload["target_hook_name"]} ({payload["event"]}/{payload["action"]})]
+=== the hook's fire message ===
+{payload["fire_message"]}
+{context}
+=== REMARK TO CLASSIFY ===
+{row["text"]}"""
 
 
 async def build_prompt(row: Mapping[str, object]) -> tuple[str, Fidelity]: