@devrik-tools/claude-gates 0.7.2 → 0.8.0

package/plugins/gates/hooks/gates/stop-pending/index.mjs

@@ -1,92 +1,25 @@
-// stop-pending — the hook that obliges the assistant not to leave pending tasks behind.
-// On the Stop event, if the project's task store (`.ai/tasks/active.json`) has ACTIVE
-// tasks (status open/in_forge — see allowStopWithBlockedTasks for `blocked`), this BLOCKS
-// the stop and lists them with how to close each: `task close --evidence` or `task
-// abandon`.
-//
-// justification: no existing tool covers this. The tasks plugin (register-requests.mjs,
-// session-tasks.mjs) reminds and recites; nothing in this repo stops the agent from ending
-// a turn while a task is still open — that requires a Stop hook that can BLOCK, which only
-// this event shape supports.
-//
-// ── Stop hook event shape (Claude Code) ──────────────────────────────────────────────
-// stdin carries JSON: { session_id, stop_hook_active, ... }. To block the stop (make the
-// agent continue instead of ending the turn), print {"decision":"block","reason":"..."}
-// and exit 0 — `reason` is shown to the model so it knows what to do next. To allow the
-// stop, print nothing (or {}) and exit 0.
-//
-// ── stop_hook_active loop-guard (mandatory) ──────────────────────────────────────────
-// If a Stop hook already blocked once in this cycle, Claude Code re-invokes Stop hooks
-// with stop_hook_active=true. Blocking AGAIN here would never let the turn end — an
-// infinite loop. So: whenever stop_hook_active === true, this gate unconditionally allows
-// the stop, even if pending tasks remain. That trades "always caught" for "never hangs the
-// session" — a single missed reminder is recoverable, a frozen session is not.
-//
-// ── Why this re-reads active.json directly instead of importing task-store.mjs ──────
-// The task store lives in a DIFFERENT plugin (plugins/tasks/hooks/lib/task-store.mjs).
-// Importing across plugin boundaries makes each plugin's installability depend on the
-// other being present at a specific relative path — exactly the coupling every other gate
-// in this repo avoids by being self-contained (Node built-ins only). This gate instead
-// re-reads the on-disk JSON shape directly: `{ tasks: [ { id, title, status, ... } ] }`
-// with status one of open/blocked/in_forge/done/abandoned (done/abandoned already live
-// only in history.json, never in active.json, by task-store's own close() contract — so
-// active.json is never filtered by status here beyond blocked/allowStopWithBlockedTasks).
-// A change to that shape would need updating in two places, but a cross-plugin import
-// would need the OTHER plugin installed at all, which is worse for a gate meant to work
-// standalone.
-//
-// ── What a project can configure (params) ───────────────────────────────────────────
-//   allowStopWithBlockedTasks   when true (default), a task with status 'blocked' (a
-//                               declared cause + a next condition) does NOT prevent stop —
-//                               only open/in_forge do. Set false to also block on 'blocked'.
-//
-// ── Fail-safe shape (mandatory for a Stop hook) ──────────────────────────────────────
-// Everything below is wrapped in try/catch. No plugin/tasks installed, no .ai/tasks/, a
-// corrupt active.json, or ANY unexpected error: allow the stop. A broken Stop hook must
-// never hang a session — that is worse than one missed reminder.
-
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { isGateEnabled, gateParameters } from '../../lib/config.mjs';
-import { readHookPayload } from '../../lib/hook-io.mjs';
-
+// stop-pending — the Stop hook that keeps the assistant from ending a turn while the
+// project's task store still has ACTIVE tasks (open/in_forge; `blocked` only when
+// allowStopWithBlockedTasks is false). It re-reads .ai/tasks/active.json directly rather
+// than importing the tasks plugin: a cross-plugin import would make this gate depend on the
+// other plugin being installed at a fixed relative path. Loop guard and fail-open come from
+// runStopHook — a broken Stop hook must never hang a session.
+
+import { join } from 'node:path';
+import { projectRootOf, readJsonOrNull } from '../../lib/config.mjs';
+import { block, runStopHook } from '../../lib/hook-io.mjs';
+
+const GATE_ID = 'stop-pending';
 const CONFIG_KEY = 'blockStopWithPendingTasks';
 
-const PROJECT_ROOT_MARKERS = ['.git', '.ai'];
 const ACTIVE_TASKS_FILE = join('.ai', 'tasks', 'active.json');
 const BLOCKING_STATUSES = new Set(['open', 'in_forge']);
 const BLOCKED_STATUS = 'blocked';
 
-const BOM_CODE_POINT = 0xfeff;
-
-function stripBom(text) {
-  return text.charCodeAt(0) === BOM_CODE_POINT ? text.slice(1) : text;
-}
-
-function projectRootOf(startDirectory) {
-  let current = startDirectory;
-  while (true) {
-    if (
-      PROJECT_ROOT_MARKERS.some((marker) => existsSync(join(current, marker)))
-    ) {
-      return current;
-    }
-    const parent = dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}
-
-/** Reads .ai/tasks/active.json's task list directly. [] on any absence/corruption. */
 function readActiveTasks(root) {
-  const path = join(root, ACTIVE_TASKS_FILE);
-  if (!existsSync(path)) return [];
-  try {
-    const parsed = JSON.parse(stripBom(readFileSync(path, 'utf8')));
-    return Array.isArray(parsed.tasks) ? parsed.tasks : [];
-  } catch {
-    return [];
-  }
+  const parsed = readJsonOrNull(join(root, ACTIVE_TASKS_FILE));
+  const tasks = Array.isArray(parsed?.tasks) ? parsed.tasks : [];
+  return tasks.filter((task) => task && typeof task === 'object');
 }
 
 function blockingTasksFrom(tasks, allowBlocked) {
@@ -96,73 +29,39 @@ function blockingTasksFrom(tasks, allowBlocked) {
   });
 }
 
-function describeTasks(tasks) {
-  return tasks
-    .map(
-      (task) =>
-        `  - [${task.status}] ${task.id}: ${task.title ?? '(untitled)'}${
-          task.status === BLOCKED_STATUS && task.blockedReason
-            ? ` (blocked: ${task.blockedReason})`
-            : ''
-        }`,
-    )
-    .join('\n');
-}
-
-function block(reason) {
-  process.stdout.write(JSON.stringify({ decision: 'block', reason }));
-  process.exit(0);
-}
-
-function allow() {
-  process.exit(0);
+function describeTask(task) {
+  const blockedNote =
+    task.status === BLOCKED_STATUS && task.blockedReason
+      ? ` (blocked: ${task.blockedReason})`
+      : '';
+  return `  - [${task.status}] ${task.id ?? '(no id)'}: ${task.title ?? '(untitled)'}${blockedNote}`;
 }
 
-function main() {
-  try {
-    const rawPayload = readHookPayload();
-    if (rawPayload === null) return allow();
-
-    let payload;
-    try {
-      payload = JSON.parse(rawPayload);
-    } catch {
-      return allow(); // unparseable Stop payload: fail-safe, never hang the session
-    }
-
-    // Loop-guard: a Stop hook already blocked once this cycle. Never block again.
-    if (payload?.stop_hook_active === true) return allow();
-
-    const cwd = process.cwd();
-    // registryDefault MUST match this gate's `default` in registry.json (true). The gate
-    // does not read the registry — this literal IS its default when a project config is
-    // silent about the key. It was false while the registry said false; both moved to true
-    // so the pending-task reminder actually fires on a fresh install, not only when the
-    // user's config names the key explicitly.
-    if (!isGateEnabled(CONFIG_KEY, true, cwd)) return allow();
-
-    const root = projectRootOf(cwd);
-    if (!root) return allow(); // no project: nothing to check
-
-    const parameters = gateParameters(CONFIG_KEY, cwd);
-    const allowBlocked = parameters.allowStopWithBlockedTasks !== false; // default true
-
-    const tasks = readActiveTasks(root);
-    const blockingTasks = blockingTasksFrom(tasks, allowBlocked);
-    if (blockingTasks.length === 0) return allow();
-
-    return block(
-      `[${CONFIG_KEY}] There are ${blockingTasks.length} pending task(s) still active for this ` +
-        `project:\n${describeTasks(blockingTasks)}\n` +
-        'Close each before ending the turn: `task close <id> --evidence "..."` when done, ' +
-        'or `task abandon <id> --reason "..."` when it will not be finished. A task left ' +
-        '`blocked` with a stated cause does not require closing unless ' +
+runStopHook(
+  {
+    id: GATE_ID,
+    configKey: CONFIG_KEY,
+    enabledByDefault: true,
+    defaultParams: { allowStopWithBlockedTasks: true },
+  },
+  ({ parameters, cwd }) => {
+    const root = projectRootOf(cwd) ?? cwd;
+    const blockingTasks = blockingTasksFrom(
+      readActiveTasks(root),
+      parameters.allowStopWithBlockedTasks !== false,
+    );
+    if (blockingTasks.length === 0) return;
+
+    block(
+      CONFIG_KEY,
+      `There are ${blockingTasks.length} pending task(s) still active for this ` +
+        `project:\n${blockingTasks.map(describeTask).join('\n')}\n` +
+        'Close each before ending the turn, with VERIFIED evidence (free text is not ' +
+        'accepted): `task close <id> --check "<command that must exit 0>" [--expect <text>]` ' +
+        'or `task close <id> --exists <path> [--contains <text>]` (add `--note "..."` for ' +
+        'context), or `task abandon <id> --reason "..."` when it will not be finished. A task ' +
+        'left `blocked` with a stated cause does not require closing unless ' +
         'allowStopWithBlockedTasks is set to false.',
     );
-  } catch {
-    // A broken Stop hook must never hang the session.
-    return allow();
-  }
-}
-
-main();
+  },
+);

package/plugins/gates/hooks/gates/test-after-implementation/index.mjs

@@ -1,6 +1,21 @@
-import { execFileSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { basename, dirname, relative } from 'node:path';
+// test-after-implementation — creating a test whose paired implementation is already
+// modified and uncommitted is denied: a test that passes the first time it runs proves
+// nothing about the change. A regression test written after reproducing a bug is the
+// legitimate exception, opted into with the escape-hatch marker. Only creation is judged;
+// editing an existing test is maintenance. Pairing is same directory + same stem, on
+// purpose narrow: a sibling __tests__/ layout is not paired (documented in the tests).
+
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import {
+  basename,
+  dirname,
+  extname,
+  isAbsolute,
+  join,
+  relative,
+} from 'node:path';
+import { projectRootOf } from '../../lib/config.mjs';
+import { workingTreeChanges } from '../../lib/git.mjs';
 import {
   runGate,
   deny,
@@ -12,12 +27,7 @@ import {
 const GATE_ID = 'test-after-implementation';
 const CONFIG_KEY = 'warnTestWrittenAfterImplementation';
 
-// Escape hatch: a regression test written AFTER reproducing a bug is a legitimate
-// test-after-implementation case (the project's own rule: reproduce the bug, then write the
-// test that pins it). A deny cannot advise-and-pass, so that legitimate case needs an
-// explicit opt-out — this marker anywhere in the test file's content lets it through.
 const DEFAULT_ESCAPE_HATCH = 'test-after-impl:allow';
-
 const DEFAULT_IMPLEMENTATION_EXTENSIONS = [
   '.ts',
   '.tsx',
@@ -27,27 +37,53 @@ const DEFAULT_IMPLEMENTATION_EXTENSIONS = [
   '.vue',
 ];
 const TEST_FILE_PATTERN = /\.(spec|test)\.[cm]?[jt]sx?$/i;
-// `git status --porcelain` prefixes each line with a 2-character status code plus a space.
-const PORCELAIN_STATUS_PREFIX_LENGTH = 3;
-
-function baseNameWithoutTestSuffix(fileName) {
-  return fileName.replace(TEST_FILE_PATTERN, '');
-}
+// An untracked directory is one porcelain entry; expanding it is bounded so a stray huge
+// tree cannot stall the hook.
+const MAX_EXPANDED_FILES = 5000;
 
-function gitStatusPorcelain(cwd) {
+function filesUnder(root, directory, collected) {
+  let entries;
   try {
-    const output = execFileSync('git', ['status', '--porcelain'], {
-      cwd,
-      timeout: 5000,
-    }).toString();
-    return output
-      .split('\n')
-      .map((line) => line.trim())
-      .filter(Boolean);
+    entries = readdirSync(join(root, directory));
   } catch {
-    // Not a git repo, or git unavailable — nothing to cross-check against.
-    return [];
+    return collected;
   }
+  for (const name of entries) {
+    if (collected.length >= MAX_EXPANDED_FILES) break;
+    const relativePath = `${directory}${name}`;
+    let isDirectory;
+    try {
+      isDirectory = statSync(join(root, relativePath)).isDirectory();
+    } catch {
+      continue;
+    }
+    if (isDirectory) filesUnder(root, `${relativePath}/`, collected);
+    else collected.push(relativePath);
+  }
+  return collected;
+}
+
+function changedPaths(root) {
+  const changes = workingTreeChanges(root);
+  if (changes === null) return [];
+  return changes.flatMap((entry) =>
+    entry.path.endsWith('/') ? filesUnder(root, entry.path, []) : [entry.path],
+  );
+}
+
+function normalizeDirectory(path) {
+  const directory = dirname(path).replace(/\\/g, '/');
+  return directory === '' || directory === '.' ? '.' : directory;
+}
+
+function isPairedImplementation(changedPath, stem, testDirectory, extensions) {
+  if (!extensions.some((extension) => changedPath.endsWith(extension)))
+    return false;
+  if (TEST_FILE_PATTERN.test(changedPath)) return false;
+  const changedStem = basename(changedPath, extname(changedPath));
+  return (
+    changedStem === stem && normalizeDirectory(changedPath) === testDirectory
+  );
 }
 
 runGate(
@@ -60,51 +96,31 @@ runGate(
       escapeHatch: DEFAULT_ESCAPE_HATCH,
     },
   },
-  ({ toolName, toolInput, parameters }) => {
+  ({ toolName, toolInput, parameters, cwd }) => {
     if (!toolInGroups(toolName, ['write'])) return;
 
-    const filePath = writtenPathOf(toolInput);
-    if (!TEST_FILE_PATTERN.test(filePath)) return;
-    if (existsSync(filePath)) return; // only new test file creation, not edits
+    const rawPath = writtenPathOf(toolInput);
+    if (!TEST_FILE_PATTERN.test(rawPath)) return;
+    const root = projectRootOf(cwd) ?? cwd;
+    const filePath = isAbsolute(rawPath) ? rawPath : join(root, rawPath);
+    if (existsSync(filePath)) return;
 
-    // Explicit opt-out for a legitimate regression test (bug reproduced first, then pinned).
     const escapeHatch = parameters.escapeHatch ?? DEFAULT_ESCAPE_HATCH;
     if (escapeHatch && writtenContentOf(toolInput).includes(escapeHatch))
       return;
 
-    const cwd = process.cwd();
-    const statusLines = gitStatusPorcelain(cwd);
-    if (statusLines.length === 0) return;
-
     const testFileName = basename(filePath);
-    const stem = baseNameWithoutTestSuffix(testFileName);
-    // `git status --porcelain` reports paths relative to `cwd`; the test's own
-    // directory (relative to `cwd`) is the fair comparison, not its absolute path.
-    // `relative()` returns '' for the repo root itself, while `dirname()` on a
-    // bare file name returns '.' — normalize both to '.' so root-level files compare equal.
-    const testDirectoryRelativeToRepo = relative(cwd, dirname(filePath)) || '.';
-
-    const pairedImplementationChanged = statusLines.some((line) => {
-      const changedPath = line.slice(PORCELAIN_STATUS_PREFIX_LENGTH).trim();
-      if (
-        !parameters.implementationExtensions.some((extension) =>
-          changedPath.endsWith(extension),
-        )
-      )
-        return false;
-      if (TEST_FILE_PATTERN.test(changedPath)) return false;
-      const lastDot = changedPath.lastIndexOf('.');
-      const changedBase = basename(
+    const stem = testFileName.replace(TEST_FILE_PATTERN, '');
+    const testDirectory = normalizeDirectory(relative(root, filePath));
+    const paired = changedPaths(root).some((changedPath) =>
+      isPairedImplementation(
         changedPath,
-        lastDot >= 0 ? changedPath.slice(lastDot) : '',
-      );
-      return (
-        changedBase === stem &&
-        (dirname(changedPath) || '.') === testDirectoryRelativeToRepo
-      );
-    });
-
-    if (!pairedImplementationChanged) return;
+        stem,
+        testDirectory,
+        parameters.implementationExtensions,
+      ),
+    );
+    if (!paired) return;
 
     deny(
       CONFIG_KEY,
@@ -112,13 +128,7 @@ runGate(
         '(uncommitted). Write the test before or alongside the implementation, not after — a ' +
         'test that passes the first time it runs proves nothing about the change. If this is a ' +
         'regression test for a bug you already reproduced (reproduce first, then pin it), add ' +
-        `the marker "${parameters.escapeHatch ?? DEFAULT_ESCAPE_HATCH}" in the test content to allow it.`,
+        `the marker "${escapeHatch}" in the test content to allow it.`,
     );
   },
 );
-
-// Note: this restores the source guard's (guard-test-despues-de-implementar.mjs) original
-// deny severity. It was warn during the config-key migration; the user's directive is that a
-// gate stays warn only when the defect is genuinely invisible to a hook. Here the defect is a
-// complete, git-verifiable fact, so it denies — with an escape hatch for the legitimate
-// regression-test case. The config key still reads warn* for backward compatibility.

package/plugins/gates/hooks/gates/test-matrix/index.mjs

@@ -1,112 +1,81 @@
-// test-matrix — denies an implementation delegation whose brief touches a domain that
-// makes a test type mandatory (money/auth/persistence → E2E; UI → visual/QA; always →
-// unit/mutation) without that type declared in the prompt. Migrated from
-// ~/.claude/hooks/guard-matriz-de-tests.mjs.
+// test-matrix — denies a STANDARD/HIGH-RISK implementation delegation whose brief touches a
+// domain that makes a test type mandatory (money/auth/persistence → E2E; UI → visual/QA;
+// always → unit/mutation) without that type declared in the prompt.
 //
-// ── What a project can configure (params) ───────────────────────────────────────────
-//   e2eSignals       regex sources (matched case-insensitively) that make an E2E row
-//                     mandatory when found in the brief (money, auth, persistence...).
-//                     Replaces the built-in list wholesale.
-//   visualSignals    regex sources that make a visual/QA row mandatory (UI signals).
-//                     Replaces the built-in list wholesale.
-// The defaults live here, in the source, so a project reads them and knows exactly what
-// its override replaces.
-//
-// ── Off by default, and quiet outside its narrow trigger ───────────────────────────
-// Only STANDARD/HIGH-RISK implementation delegations on builder subagents, not about
-// the harness itself, reach the check. A brief that only describes work never triggers.
+// Decisions: the E2E signals are the terms that name a money/auth/data-loss domain; generic
+// words (role, balance, amount, session, token) were dropped because they fire on ordinary
+// briefs. An empty `e2eSignals`/`visualSignals` means that row is never mandatory. A file
+// extension signal (`.tsx`) matches a real path, so it is compiled without a leading word
+// boundary. "QA:" counts as a visual row only when something follows it. Only the exempt
+// list exempts a subagent type; harness work (.claude/, .ai/...) is exempt.
 
+import {
+  DEFAULT_EXEMPT_SUBAGENTS,
+  DEMANDING_LEVELS,
+  isHarnessWork,
+  isImplementationRequest,
+  isSubagentNamedIn,
+  operativeLevelOf,
+} from '../../lib/delegation.mjs';
 import {
   runGate,
   deny,
+  compileRegex,
   toolInGroups,
   delegationPromptOf,
 } from '../../lib/hook-io.mjs';
-import { RISK_SIGNAL_SOURCES } from '../../lib/signals.mjs';
+import { withUnicodeWordBoundary } from '../../lib/signals.mjs';
 
 const GATE_ID = 'test-matrix';
 const CONFIG_KEY = 'requireTestMatrixWhenImplementing';
 
-const DEFAULT_EXEMPT_SUBAGENTS = [
-  'scout',
-  'explore',
-  'plan',
-  'revision',
-  'contraste',
-  'test-planner',
-  'qa',
-  'ui',
-  'ux',
-];
-
-// Money/auth signals shared with RISK_SIGNAL (lib/signals.mjs, ES+EN), plus this gate's
-// own persistence-domain terms (also bilingual) — a project override still replaces the
-// whole list wholesale, same as before.
 const DEFAULT_E2E_SIGNALS = [
-  ...RISK_SIGNAL_SOURCES.slice(0, 2), // money terms, auth terms
-  'login|session|token|permission|role|sesi[oó]n|permiso|rol',
+  'money|payment|pago|dinero|cobro|charge|invoice|factura|precio|price|saldo|monto|cuota|checkout',
+  'auth|autenticaci[oó]n|authentication|login|password|contrase[nñ]a|credencial|credential',
   'persist|database|migration|transaction|persistencia|base de datos|migraci[oó]n|transacci[oó]n',
+  'data loss|p[eé]rdida de datos|delete|borrar|drop',
 ];
 
 const DEFAULT_VISUAL_SIGNALS = [
   'ui|interface|interfaz|component|componente|screen|pantalla|view|vista',
   'form|formulario|button|bot[oó]n|modal|layout|style|estilo',
-  'responsive|mobile|m[oó]vil|visual|\\.vue|\\.tsx?|\\.jsx?',
+  'responsive|mobile|m[oó]vil|visual',
+  '\\.(vue|tsx?|jsx?)(?!\\w)',
 ];
 
-function withWordBoundary(alternation) {
-  return new RegExp(
-    `(?:^|[^\\p{L}\\p{N}_])(?:${alternation})(?:[^\\p{L}\\p{N}_]|$)`,
-    'iu',
-  );
-}
-
-const IMPLEMENTATION_VERBS = withWordBoundary(
-  'implementa|implementar|implement(á|é)|agreg(a|á)|agregar|añad(e|í)|añadir|cre(a|á)|crear|' +
-    'arregl(a|á)|arreglar|cambi(a|á)|cambiar|migr(a|á)|migrar|' +
-    'corrige|corregir|correg(í|ir)|constru(ye|í)|construir|modific(a|á)|modificar|' +
-    'refactoriz(a|á)|refactorizar|elimin(a|á)|eliminar|reescrib(e|í)|reescribir|desplieg(a|á)|desplegar|' +
-    'escrib(í|e)|escribir|implement\\w*|writ(?:e|ing)|creat\\w*|fix\\w*|build\\w*|refactor\\w*|migrat\\w*|' +
-    'add\\w*|remov\\w*|delet\\w*|modify|modifies|modifying|rewrit\\w*',
-);
-
-/** Declared LEVEL near the word "level"/"classification" in Spanish or English, matching
- * the plugin-wide convention (see risk-level.mjs). */
-const DEMANDING_LEVEL_PATTERN =
-  /(nivel|level|clasificaci[oó]n|classification)[^\n]{0,25}?\b(STANDARD|HIGH-RISK)\b/iu;
-const EXEMPT_LEVEL_PATTERN =
-  /(nivel|level|clasificaci[oó]n|classification)[^\n]{0,25}?\b(QUESTION|MICRO)\b/iu;
-
-const HARNESS_PATTERN =
-  /(\.claude[\\/]|hooks[\\/]|plugins[\\/]gates|settings\.json|[\\/]agents[\\/]\w|[\\/]rules[\\/]\w|[\\/]skills[\\/]\w)/i;
-
 const DETECTS_E2E = /\b(e2e|end[- ]to[- ]end|playwright)\b/i;
-const DETECTS_VISUAL = /\b(visual|qa\b|screenshot|snapshot)\b/i;
+const DETECTS_VISUAL = /\b(visual|qa\s*:\s*\p{L}|screenshot|snapshot)/iu;
 const DETECTS_UNIT_OR_MUTATION =
   /\b(unit\b|units\b|unitari[ao]s?|vitest|jest|mutation|mutaci[oó]n|mutant|stryker)\b/i;
-const DETECTS_NEGATIVE_CASES = withWordBoundary(
+const DETECTS_NEGATIVE_CASES = withUnicodeWordBoundary(
   'negative|edge|empty|error|no data|zero|count 0|failure|invalid|limit|' +
     'negativ[ao]s?|borde|vac[ií]o|sin datos|cero|falla|inv[aá]lid[ao]|l[ií]mite',
 );
 
-function joinSignals(signals) {
-  return withWordBoundary(signals.join('|'));
+// A source that starts with an escaped dot is a file-extension shape and must match inside
+// a path; every other source is a word and gets the Unicode word boundary.
+function compileSignal(source) {
+  if (typeof source !== 'string' || !compileRegex(source, 'iu')) return null;
+  return source.startsWith('\\.')
+    ? compileRegex(source, 'iu')
+    : withUnicodeWordBoundary(source);
+}
+
+function anySignalMatches(sources, prompt) {
+  return sources
+    .map(compileSignal)
+    .filter(Boolean)
+    .some((pattern) => pattern.test(prompt));
 }
 
 function isExempt(toolInput, prompt, exemptSubagents) {
-  const subagentType = String(
-    toolInput.subagent_type ?? toolInput.subagentType ?? '',
-  ).toLowerCase();
-  if (exemptSubagents.includes(subagentType)) return true;
-  if (EXEMPT_LEVEL_PATTERN.test(prompt)) return true;
-  if (!DEMANDING_LEVEL_PATTERN.test(prompt)) return true;
-  if (!IMPLEMENTATION_VERBS.test(prompt)) return true;
-  if (HARNESS_PATTERN.test(prompt)) return true;
-  return false;
+  if (isSubagentNamedIn(toolInput, exemptSubagents)) return true;
+  if (!DEMANDING_LEVELS.has(operativeLevelOf(prompt))) return true;
+  if (!isImplementationRequest(prompt)) return true;
+  return isHarnessWork(prompt);
 }
 
-/** Which mandatory test types are missing from the prompt, given the brief text. */
-function missingTypes(prompt, e2ePattern, visualPattern) {
+function missingTypes(prompt, e2eSignals, visualSignals) {
   const missing = [];
 
   if (!DETECTS_UNIT_OR_MUTATION.test(prompt)) {
@@ -116,14 +85,14 @@ function missingTypes(prompt, e2ePattern, visualPattern) {
     });
   }
 
-  if (e2ePattern.test(prompt) && !DETECTS_E2E.test(prompt)) {
+  if (anySignalMatches(e2eSignals, prompt) && !DETECTS_E2E.test(prompt)) {
     missing.push({
       type: 'E2E',
       line: '- E2E: yes — <end-to-end flow verified>  (mandatory: the requirement touches money/auth/persistence)',
     });
   }
 
-  if (visualPattern.test(prompt) && !DETECTS_VISUAL.test(prompt)) {
+  if (anySignalMatches(visualSignals, prompt) && !DETECTS_VISUAL.test(prompt)) {
     missing.push({
       type: 'visual/QA',
       line: '- visual/QA: yes — <screen/state reviewed in the browser>  (mandatory: the requirement touches UI)',
@@ -160,17 +129,13 @@ runGate(
 
     const prompt = delegationPromptOf(toolInput);
     if (!prompt.trim()) return;
+    if (isExempt(toolInput, prompt, parameters.exemptSubagents)) return;
 
-    const exemptSubagents =
-      parameters.exemptSubagents ?? DEFAULT_EXEMPT_SUBAGENTS;
-    if (isExempt(toolInput, prompt, exemptSubagents)) return;
-
-    const e2eSignals = parameters.e2eSignals ?? DEFAULT_E2E_SIGNALS;
-    const visualSignals = parameters.visualSignals ?? DEFAULT_VISUAL_SIGNALS;
-    const e2ePattern = joinSignals(e2eSignals);
-    const visualPattern = joinSignals(visualSignals);
-
-    const missing = missingTypes(prompt, e2ePattern, visualPattern);
+    const missing = missingTypes(
+      prompt,
+      parameters.e2eSignals,
+      parameters.visualSignals,
+    );
     if (missing.length === 0) return;
 
     const lines = missing.map((entry) => `  ${entry.line}`).join('\n');