@devrik-tools/claude-gates 0.2.0 → 0.3.0

package/plugins/gates/hooks/gates/no-memory-dependency/index.mjs

@@ -1,123 +1,138 @@
-// no-memory-dependency — warns (never denies) when a delegation prompt leans on the
-// subagent "remembering" something said earlier in conversation instead of carrying
-// the data itself. A fresh subagent has no access to the delegator's conversation
-// history: if the data matters, it must travel IN the prompt, in a file the subagent
-// reads, or in an already-persisted decision.
-//
-// ── Two stages, same pattern as intent-flow ─────────────────────────────────────────
-// Stage 1 (cheap): does any memory-dependency phrase appear anywhere? If not, allow.
-// Stage 2 (confirmation, only on candidates): strip quoted text, then discard a phrase
-// that has a REAL deterministic persistence INSTRUCTION nearby (not just a noun/verb
-// mentioned in passing) — "no te olvides de guardar la decision en .ai/decision.md"
-// genuinely depends on a file, not on model memory. A persistence noun/verb that merely
-// co-occurs in the window without forming an instruction TO persist THIS remembered
-// thing (e.g. an unrelated file named elsewhere in the same sentence) does not suppress
-// the warning. This stays a soft signal (warn), never a hard block: whether the brief
-// truly needs the data or is just referencing prior agreement needs judgment this gate
-// can't supply on its own.
-
-import {
-  runGate,
-  warn,
-  toolInGroups,
-  delegationPromptOf,
-} from '../../lib/hook-io.mjs';
-import { PERSISTENCE_VERB } from '../../lib/signals.mjs';
-
-const GATE_ID = 'no-memory-dependency';
-const CONFIG_KEY = 'warnMemoryDependencyInBrief';
-
-const DEFAULT_MEMORY_DEPENDENCY_PATTERNS = [
-  'acordate de|acu[eé]rdate de',
-  'no olvides|no te olvides',
-  'record[aá] que|ten[eé] en cuenta que',
-  'como te dije|como ya te dije|ya te dije|te lo dije antes|ya te ped[ií]',
-  "remember to|don'?t forget|keep in mind",
-];
-
-// A real persistence INSTRUCTION requires an imperative persistence VERB (an actual
-// directive to save/persist/write THIS remembered thing), not merely a persistence-
-// related NOUN mentioned somewhere nearby (a stray "incident.md" in the same sentence
-// names a file without instructing anything be saved to it). Centralized in
-// lib/signals.mjs (ES+EN) so this class of signal is not duplicated per gate.
-const PERSISTENCE_VERB_PATTERN = PERSISTENCE_VERB;
-
-const PERSISTENCE_WINDOW = 80;
-
-function withUnicodeWordBoundary(alternatives) {
-  return new RegExp(
-    `(?<![\\p{L}\\p{N}_])(${alternatives})(?![\\p{L}\\p{N}_])`,
-    'iu',
-  );
-}
-
-function stripQuoted(text) {
-  return text
-    .replace(/```[\s\S]*?```/g, ' ')
-    .replace(/"[^"\n]{0,300}"/g, ' ')
-    .replace(/'[^'\n]{0,300}'/g, ' ');
-}
-
-function allMatches(pattern, text) {
-  const flags = pattern.flags.includes('g')
-    ? pattern.flags
-    : `${pattern.flags}g`;
-  return [...text.matchAll(new RegExp(pattern.source, flags))];
-}
-
-/** True only when the window around a memory phrase carries a real persistence
- * INSTRUCTION — an imperative persistence verb — not merely a persistence-related noun
- * mentioned in passing. A noun alone ("el reporte esta en incident.md") names a file
- * without instructing anything be saved to it, so it must NOT suppress the warning. */
-function hasPersistenceInstructionNearby(text, match) {
-  const from = Math.max(0, match.index - PERSISTENCE_WINDOW);
-  const to = Math.min(
-    text.length,
-    match.index + match[0].length + PERSISTENCE_WINDOW,
-  );
-  const window = text.slice(from, to);
-  return PERSISTENCE_VERB_PATTERN.test(window);
-}
-
-function unresolvedMemoryPhrases(prompt, memoryPattern) {
-  if (!memoryPattern.test(prompt)) return []; // stage 1: no candidate, allow cheap
-
-  const text = stripQuoted(prompt); // stage 2(a)
-  const matches = allMatches(memoryPattern, text);
-
-  return matches
-    .filter((match) => !hasPersistenceInstructionNearby(text, match))
-    .map((match) => match[0].trim());
-}
-
-runGate(
-  {
-    id: GATE_ID,
-    configKey: CONFIG_KEY,
-    enabledByDefault: false,
-    defaultParams: {
-      memoryDependencyPatterns: DEFAULT_MEMORY_DEPENDENCY_PATTERNS,
-    },
-  },
-  ({ toolName, toolInput, parameters }) => {
-    if (!toolInGroups(toolName, ['delegation'])) return;
-
-    const prompt = delegationPromptOf(toolInput);
-    if (!prompt.trim()) return;
-
-    const memoryPattern = withUnicodeWordBoundary(
-      (parameters.memoryDependencyPatterns ?? []).join('|'),
-    );
-
-    const phrases = unresolvedMemoryPhrases(prompt, memoryPattern);
-    if (phrases.length === 0) return;
-
-    const quotedPhrases = phrases.map((phrase) => `"${phrase}"`).join(', ');
-    warn(
-      GATE_ID,
-      `This delegation depends on the model remembering something (${quotedPhrases}). ` +
-        'If it matters, it should live in a file, a flag, an environment variable, or a deterministic gate — ' +
-        "not in the model's memory.",
-    );
-  },
-);
+// no-memory-dependency — denies when a delegation prompt leans on the subagent
+// "remembering" something said earlier in conversation instead of carrying the data itself.
+// A fresh subagent has no access to the delegator's conversation history: if the data
+// matters, it must travel IN the prompt, in a file the subagent reads, or in an
+// already-persisted decision. The dependency on unavailable memory is a complete, objective
+// fact once stage 2 has ruled out a real persistence instruction — so this blocks.
+//
+// ── Two stages, same pattern as intent-flow ─────────────────────────────────────────
+// Stage 1 (cheap): does any memory-dependency phrase appear anywhere? If not, allow.
+// Stage 2 (confirmation, only on candidates): strip quoted text, then discard a phrase
+// that has a REAL deterministic persistence INSTRUCTION nearby (not just a noun/verb
+// mentioned in passing) — "no te olvides de guardar la decision en .ai/decision.md"
+// genuinely depends on a file, not on model memory. A persistence noun/verb that merely
+// co-occurs in the window without forming an instruction TO persist THIS remembered
+// thing (e.g. an unrelated file named elsewhere in the same sentence) does not suppress
+// the deny.
+//
+// ── Escape hatch ─────────────────────────────────────────────────────────────────────
+// A memory phrase can be a false positive: "no te olvides de cerrar el server al final"
+// directs the SUBAGENT'S own future action, not data it must recall from the delegator. For
+// that case the author adds the escapeHatch marker to the prompt to state, explicitly, that
+// no cross-conversation memory is actually required.
+
+import {
+  runGate,
+  deny,
+  toolInGroups,
+  delegationPromptOf,
+} from '../../lib/hook-io.mjs';
+import { PERSISTENCE_VERB } from '../../lib/signals.mjs';
+
+const GATE_ID = 'no-memory-dependency';
+const CONFIG_KEY = 'warnMemoryDependencyInBrief';
+
+const DEFAULT_ESCAPE_HATCH = 'memory-not-needed';
+
+const DEFAULT_MEMORY_DEPENDENCY_PATTERNS = [
+  'acordate de|acu[eé]rdate de',
+  'no olvides|no te olvides',
+  'record[aá] que|ten[eé] en cuenta que',
+  'como te dije|como ya te dije|ya te dije|te lo dije antes|ya te ped[ií]',
+  "remember to|don'?t forget|keep in mind",
+];
+
+// A real persistence INSTRUCTION requires an imperative persistence VERB (an actual
+// directive to save/persist/write THIS remembered thing), not merely a persistence-
+// related NOUN mentioned somewhere nearby (a stray "incident.md" in the same sentence
+// names a file without instructing anything be saved to it). Centralized in
+// lib/signals.mjs (ES+EN) so this class of signal is not duplicated per gate.
+const PERSISTENCE_VERB_PATTERN = PERSISTENCE_VERB;
+
+const PERSISTENCE_WINDOW = 80;
+
+function withUnicodeWordBoundary(alternatives) {
+  return new RegExp(
+    `(?<![\\p{L}\\p{N}_])(${alternatives})(?![\\p{L}\\p{N}_])`,
+    'iu',
+  );
+}
+
+function stripQuoted(text) {
+  return text
+    .replace(/```[\s\S]*?```/g, ' ')
+    .replace(/"[^"\n]{0,300}"/g, ' ')
+    .replace(/'[^'\n]{0,300}'/g, ' ');
+}
+
+function allMatches(pattern, text) {
+  const flags = pattern.flags.includes('g')
+    ? pattern.flags
+    : `${pattern.flags}g`;
+  return [...text.matchAll(new RegExp(pattern.source, flags))];
+}
+
+/** True only when the window around a memory phrase carries a real persistence
+ * INSTRUCTION — an imperative persistence verb — not merely a persistence-related noun
+ * mentioned in passing. A noun alone ("el reporte esta en incident.md") names a file
+ * without instructing anything be saved to it, so it must NOT suppress the warning. */
+function hasPersistenceInstructionNearby(text, match) {
+  const from = Math.max(0, match.index - PERSISTENCE_WINDOW);
+  const to = Math.min(
+    text.length,
+    match.index + match[0].length + PERSISTENCE_WINDOW,
+  );
+  const window = text.slice(from, to);
+  return PERSISTENCE_VERB_PATTERN.test(window);
+}
+
+function unresolvedMemoryPhrases(prompt, memoryPattern) {
+  if (!memoryPattern.test(prompt)) return []; // stage 1: no candidate, allow cheap
+
+  const text = stripQuoted(prompt); // stage 2(a)
+  const matches = allMatches(memoryPattern, text);
+
+  return matches
+    .filter((match) => !hasPersistenceInstructionNearby(text, match))
+    .map((match) => match[0].trim());
+}
+
+runGate(
+  {
+    id: GATE_ID,
+    configKey: CONFIG_KEY,
+    enabledByDefault: false,
+    defaultParams: {
+      memoryDependencyPatterns: DEFAULT_MEMORY_DEPENDENCY_PATTERNS,
+      escapeHatch: DEFAULT_ESCAPE_HATCH,
+    },
+  },
+  ({ toolName, toolInput, parameters }) => {
+    if (!toolInGroups(toolName, ['delegation'])) return;
+
+    const prompt = delegationPromptOf(toolInput);
+    if (!prompt.trim()) return;
+
+    // Explicit opt-out: the author states no cross-conversation memory is actually required.
+    const escapeHatch = (
+      parameters.escapeHatch ?? DEFAULT_ESCAPE_HATCH
+    ).toLowerCase();
+    if (escapeHatch && prompt.toLowerCase().includes(escapeHatch)) return;
+
+    const memoryPattern = withUnicodeWordBoundary(
+      (parameters.memoryDependencyPatterns ?? []).join('|'),
+    );
+
+    const phrases = unresolvedMemoryPhrases(prompt, memoryPattern);
+    if (phrases.length === 0) return;
+
+    const quotedPhrases = phrases.map((phrase) => `"${phrase}"`).join(', ');
+    deny(
+      GATE_ID,
+      `This delegation depends on the subagent remembering something (${quotedPhrases}), but a ` +
+        'fresh subagent has none of this conversation. Put the data IN the prompt, in a file it ' +
+        'reads, a flag, or an already-persisted decision. If the phrase directs the subagent’s ' +
+        `own future action and needs no recalled data, add the marker "${parameters.escapeHatch ?? DEFAULT_ESCAPE_HATCH}" to the prompt.`,
+    );
+  },
+);

package/plugins/gates/hooks/gates/root-whitelist/index.mjs

@@ -14,7 +14,13 @@
 // dotfiles are a different, well-known convention this gate does not police.
 
 import { basename, isAbsolute, resolve, sep } from 'node:path';
-import { runGate, deny, toolInGroups, writtenPathOf } from '../../lib/hook-io.mjs';
+import {
+  runGate,
+  deny,
+  toolInGroups,
+  writtenPathOf,
+  shellWrittenPaths,
+} from '../../lib/hook-io.mjs';
 
 const GATE_ID = 'root-whitelist';
 const CONFIG_KEY = 'blockPathsOutsideRootWhitelist';
@@ -49,6 +55,40 @@ const DEFAULT_ROOT_FOLDERS_WHITELIST = [
   'plugins',
 ];
 
+// The whitelist verdict for one target path. Returns a deny reason string when the path is a
+// non-whitelisted new thing at the project root, or null when it is allowed (outside the root,
+// a dotfile, or whitelisted). Shared by the write-tool path and every shell-created path, so a
+// `printf x > basura.txt` is judged by the same rule as a Write to basura.txt.
+function rootWhitelistViolation(target, filesWhitelist, foldersWhitelist) {
+  if (!target) return null;
+
+  // Some tools send a path relative to cwd rather than absolute. resolve() leaves an
+  // already-absolute path merely normalized ('..' collapsed, separators fixed), and resolves
+  // a relative one against process.cwd() — so either shape lands on the same absolute path.
+  const normalized = isAbsolute(target)
+    ? resolve(target)
+    : resolve(process.cwd(), target);
+  const projectRoot = process.cwd() + sep;
+
+  // A path outside the project (scratchpad, temp, another repo) is not at its root — not this
+  // rule's business. Judged AFTER resolving, so a relative path is judged by where it lands.
+  if (!normalized.startsWith(projectRoot)) return null;
+
+  const relativePath = normalized.slice(projectRoot.length);
+
+  if (!relativePath.includes(sep)) {
+    const fileName = basename(relativePath);
+    if (fileName.startsWith('.') || filesWhitelist.has(fileName.toLowerCase())) return null;
+    return `'${fileName}' at the project root is not on the whitelist (${[...filesWhitelist].join(', ')}).`;
+  }
+
+  const topDirectory = relativePath.split(sep)[0];
+  if (topDirectory.startsWith('.') || foldersWhitelist.has(topDirectory.toLowerCase())) {
+    return null;
+  }
+  return `Folder '${topDirectory}' at the project root is not on the whitelist (${[...foldersWhitelist].join(', ')}).`;
+}
+
 runGate(
   {
     id: GATE_ID,
@@ -60,30 +100,12 @@ runGate(
     },
   },
   ({ toolName, toolInput, parameters }) => {
-    if (!toolInGroups(toolName, ['write'])) return;
+    const isWrite = toolInGroups(toolName, ['write']);
+    const isShell = toolInGroups(toolName, ['shell']);
+    if (!isWrite && !isShell) return;
 
-    const target = writtenPathOf(toolInput);
-    if (!target) return;
-
-    // Some tools send a path relative to cwd rather than absolute. resolve() leaves an
-    // already-absolute path merely normalized ('..' collapsed, separators fixed), and
-    // resolves a relative one against process.cwd() — so either shape lands on the same
-    // absolute path the root check below expects.
-    const normalized = isAbsolute(target)
-      ? resolve(target)
-      : resolve(process.cwd(), target);
-    const projectRoot = process.cwd() + sep;
-
-    // The whitelist describes the project's ROOT. A file outside the project (session
-    // scratchpad, system temp, another repo) is not at its root, and this rule does not
-    // govern it: letting it through is correct, not an exception. This check runs AFTER
-    // resolving relative paths, so a relative path is judged by where it actually lands.
-    if (!normalized.startsWith(projectRoot)) return;
-
-    const relativePath = normalized.slice(projectRoot.length);
-    // Windows filesystems are case-insensitive: 'Package.json' and 'package.json' are the
-    // same file. Comparing lowercase on both sides avoids denying a whitelisted name that
-    // merely differs in case (a false positive, not a real gap).
+    // Windows filesystems are case-insensitive: 'Package.json' and 'package.json' are the same
+    // file. Comparing lowercase on both sides avoids a false positive on a case difference.
     const filesWhitelist = new Set(
       (parameters.rootFilesWhitelist ?? []).map((name) => name.toLowerCase()),
     );
@@ -91,26 +113,19 @@ runGate(
       (parameters.rootFoldersWhitelist ?? []).map((name) => name.toLowerCase()),
     );
 
-    if (!relativePath.includes(sep)) {
-      const fileName = basename(relativePath);
-      if (fileName.startsWith('.') || filesWhitelist.has(fileName.toLowerCase()))
-        return;
-      deny(
-        GATE_ID,
-        `'${fileName}' at the project root is not on the whitelist (${[...filesWhitelist].join(', ')}).`,
-      );
-      return;
-    }
+    // The paths to judge: a write tool's target, OR every path a shell command creates via a
+    // redirection / touch / tee / cp / mv. The latter closes the hole where `> basura.txt`
+    // created a root file that a Write to the same name would have been denied. This does not
+    // resolve a dynamically built path (`> "$f"`) — that honest limitation is the boundary of
+    // a regex, and is why the write-tool path (which carries a concrete file_path) stays the
+    // primary, most reliable surface.
+    const targets = isShell
+      ? shellWrittenPaths(String(toolInput?.command ?? toolInput?.CommandLine ?? ''))
+      : [writtenPathOf(toolInput)];
 
-    const topDirectory = relativePath.split(sep)[0];
-    if (
-      topDirectory.startsWith('.') ||
-      foldersWhitelist.has(topDirectory.toLowerCase())
-    )
-      return;
-    deny(
-      GATE_ID,
-      `Folder '${topDirectory}' at the project root is not on the whitelist (${[...foldersWhitelist].join(', ')}).`,
-    );
+    for (const target of targets) {
+      const reason = rootWhitelistViolation(target, filesWhitelist, foldersWhitelist);
+      if (reason) deny(GATE_ID, reason);
+    }
   },
 );

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

@@ -1,101 +1,124 @@
-import { execFileSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { basename, dirname, relative } from 'node:path';
-import { runGate, warn, toolInGroups, writtenPathOf } from '../../lib/hook-io.mjs';
-
-const GATE_ID = 'test-after-implementation';
-const CONFIG_KEY = 'warnTestWrittenAfterImplementation';
-
-const DEFAULT_IMPLEMENTATION_EXTENSIONS = [
-  '.ts',
-  '.tsx',
-  '.js',
-  '.jsx',
-  '.mjs',
-  '.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, '');
-}
-
-function gitStatusPorcelain(cwd) {
-  try {
-    const output = execFileSync('git', ['status', '--porcelain'], {
-      cwd,
-      timeout: 5000,
-    }).toString();
-    return output
-      .split('\n')
-      .map((line) => line.trim())
-      .filter(Boolean);
-  } catch {
-    // Not a git repo, or git unavailable — nothing to cross-check against.
-    return [];
-  }
-}
-
-runGate(
-  {
-    id: GATE_ID,
-    configKey: CONFIG_KEY,
-    enabledByDefault: false,
-    defaultParams: {
-      implementationExtensions: DEFAULT_IMPLEMENTATION_EXTENSIONS,
-    },
-  },
-  ({ toolName, toolInput, parameters }) => {
-    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 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(
-        changedPath,
-        lastDot >= 0 ? changedPath.slice(lastDot) : '',
-      );
-      return (
-        changedBase === stem &&
-        (dirname(changedPath) || '.') === testDirectoryRelativeToRepo
-      );
-    });
-
-    if (!pairedImplementationChanged) return;
-
-    warn(
-      GATE_ID,
-      `Creating test ${testFileName} after its paired implementation was already modified (uncommitted). Consider writing tests before or alongside the implementation, not after.`,
-    );
-  },
-);
-
-// Note: the source guard (guard-test-despues-de-implementar.mjs) denies this
-// case outright. This gate warns instead, because registry.json names the
-// config key warnTestWrittenAfterImplementation, which declares warn as the
-// intended severity for this migration.
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { basename, dirname, relative } from 'node:path';
+import {
+  runGate,
+  deny,
+  toolInGroups,
+  writtenPathOf,
+  writtenContentOf,
+} from '../../lib/hook-io.mjs';
+
+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',
+  '.js',
+  '.jsx',
+  '.mjs',
+  '.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, '');
+}
+
+function gitStatusPorcelain(cwd) {
+  try {
+    const output = execFileSync('git', ['status', '--porcelain'], {
+      cwd,
+      timeout: 5000,
+    }).toString();
+    return output
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean);
+  } catch {
+    // Not a git repo, or git unavailable — nothing to cross-check against.
+    return [];
+  }
+}
+
+runGate(
+  {
+    id: GATE_ID,
+    configKey: CONFIG_KEY,
+    enabledByDefault: false,
+    defaultParams: {
+      implementationExtensions: DEFAULT_IMPLEMENTATION_EXTENSIONS,
+      escapeHatch: DEFAULT_ESCAPE_HATCH,
+    },
+  },
+  ({ toolName, toolInput, parameters }) => {
+    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
+
+    // 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(
+        changedPath,
+        lastDot >= 0 ? changedPath.slice(lastDot) : '',
+      );
+      return (
+        changedBase === stem &&
+        (dirname(changedPath) || '.') === testDirectoryRelativeToRepo
+      );
+    });
+
+    if (!pairedImplementationChanged) return;
+
+    deny(
+      GATE_ID,
+      `Creating test ${testFileName} after its paired implementation was already modified ` +
+        '(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.`,
+    );
+  },
+);
+
+// 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.