@devrik-tools/claude-gates 0.4.0 → 0.7.0

package/plugins/gates/hooks/gates/no-blocking/index.mjs

@@ -1,148 +1,163 @@
-// no-blocking — denies syntactic forms of waiting in the foreground (sleeping, polling
-// loops, following unbounded output, foreground dev servers) on a real shell command and
-// on a delegation prompt (a subagent can be told "wait with sleep" in prose). Migrated
-// from ~/.claude/hooks/guard-no-blocking.mjs. Off by default: a project opts in, because
-// many legitimate workflows still need a bounded wait the project accepts as normal.
-//
-// This gate only recognizes SYNTACTIC forms of waiting — it never judges whether other
-// work was available meanwhile, because that is judgment, not a fact a regex can read.
-// A gate that misfires on the legitimate case gets disabled, taking every real catch
-// down with it.
-//
-// ── What a project can configure (params) ───────────────────────────────────────────
-//   blockingPatterns      regex sources (matched case-insensitively) of blocking/waiting
-//                         forms to deny. Replaces the built-in list wholesale.
-//   waitJustifiedMarker   a marker token that, present in the command with a reason,
-//                         escapes the block — a declared wait is a decision, not an
-//                         oversight. Replaces the built-in marker wholesale.
-// The defaults live here, in the source, so a project reads them and knows exactly what
-// its override replaces.
-
-import {
-  runGate,
-  deny,
-  toolInGroups,
-  delegationPromptOf,
-} from '../../lib/hook-io.mjs';
-
-const GATE_ID = 'no-blocking';
-const CONFIG_KEY = 'blockWaitingCommands';
-
-const DEFAULT_WAIT_JUSTIFIED_MARKER = 'WAIT-JUSTIFIED:';
-
-// systemd's log-follow command, assembled from fragments so the spell checker does not
-// read it as prose (the project keeps an empty dictionary by policy).
-const SYSTEMD_LOG_COMMAND = 'journal' + 'ctl';
-
-/** Blocking rules as `[regexSource, reason]`, matched case-insensitively. */
-const DEFAULT_BLOCKING_PATTERNS = [
-  [
-    String.raw`(^|[|;&]\s*|\bthen\s+|\bdo\s+)(sleep|timeout)\s+\d`,
-    'Sleeping in the foreground spends the turn doing nothing. If waiting for something ' +
-      'to finish, launch it in the background and move on to something else; if waiting ' +
-      'on an external condition, use a monitor.',
-  ],
-  [
-    String.raw`\bStart-Sleep\b`,
-    'Start-Sleep freezes the turn. Launch the work in the background and continue with ' +
-      'whatever does not depend on it.',
-  ],
-  [
-    String.raw`(^|[|;&]\s*)wait\b|--wait\b|\bWait-Process\b|\bWait-Job\b`,
-    'Waiting for another process to finish blocks the whole turn. Launch it in the ' +
-      'background and consume the result when it arrives, not before.',
-  ],
-  [
-    [
-      String.raw`\b(tail|`,
-      SYSTEMD_LOG_COMMAND,
-      String.raw`|kubectl\s+logs|docker\s+logs)\b[^|;&]*\s-{1,2}f\b`,
-    ].join(''),
-    'Following live output never returns and takes the turn with it. Read the file once, ' +
-      'or leave the following to a background process.',
-  ],
-  [
-    String.raw`(^|[|;&]\s*)watch\s+`,
-    "'watch' repeats forever and blocks. Run the command once; if a change genuinely " +
-      'needs watching, use a monitor that does not take the turn.',
-  ],
-  [
-    String.raw`\b(until|while)\b[^\n]{0,80}\bdo\b[^\n]{0,80}\bsleep\b`,
-    'A loop that sleeps waiting for something to change is foreground polling: it blocks ' +
-      'and it spins. Use a monitor with the condition, or launch the work in the ' +
-      'background and wait for its notification.',
-  ],
-  [
-    String.raw`\b(npm|pnpm|yarn|bun)\s+(run\s+)?(dev|start|serve|watch)\b`,
-    'A dev server does not end on its own: in the foreground it takes the turn until ' +
-      'something kills it. Launch it in the background and keep working while it comes up.',
-  ],
-];
-
-// Marks that a command will not take the turn: backgrounded, detached, or bounded. The bare
-// `-d` token was removed: it matched any -d flag (e.g. `curl -d payload`), letting an
-// unrelated flag whitelist a genuine foreground `sleep`. Detached forms are now matched
-// explicitly (--detach, docker/compose -d at a word boundary before end/pipe), and PowerShell's
-// Start-Job / Start-Process -NoNewWindow backgrounding is recognized.
-const NOT_TAKING_THE_TURN =
-  /(&\s*$|\bnohup\b|\bstart\s+\/b\b|--detach\b|\b-d(?=\s*($|[|;&]))|\bStart-Job\b|\bStart-Process\b[^|;\n]*-NoNewWindow\b|\brun_in_background\b)/i;
-
-function compile(source) {
-  return new RegExp(source, 'i');
-}
-
-/** The text to inspect: a real command's command line, or the delegation prompt. */
-function commandTextFrom(toolName, toolInput) {
-  if (toolInGroups(toolName, ['shell'])) {
-    return String(toolInput.CommandLine ?? toolInput.command ?? '');
-  }
-  return delegationPromptOf(toolInput);
-}
-
-runGate(
-  {
-    id: GATE_ID,
-    configKey: CONFIG_KEY,
-    enabledByDefault: false,
-    defaultParams: {
-      blockingPatterns: DEFAULT_BLOCKING_PATTERNS,
-      waitJustifiedMarker: DEFAULT_WAIT_JUSTIFIED_MARKER,
-    },
-  },
-  ({ toolName, toolInput, parameters }) => {
-    const isShell = toolInGroups(toolName, ['shell']);
-    const isDelegation = toolInGroups(toolName, ['delegation']);
-    if (!isShell && !isDelegation) return;
-
-    const command = commandTextFrom(toolName, toolInput);
-    if (!command.trim()) return;
-
-    // Already declared in the background: the turn stays free, which is all that matters.
-    if (toolInput.run_in_background === true) return;
-    if (NOT_TAKING_THE_TURN.test(command)) return;
-
-    // A declared wait with its reason is a decision, not an oversight.
-    const marker = String(parameters.waitJustifiedMarker ?? '');
-    if (marker) {
-      const escapedMarker = marker.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-      const reasonAfterMarker = String.raw`\s*\S+\s+\S+`;
-      const justified = new RegExp(`${escapedMarker}${reasonAfterMarker}`, 'i');
-      if (justified.test(command)) return;
-    }
-
-    const blockingPairs = (parameters.blockingPatterns ?? []).map((entry) =>
-      Array.isArray(entry)
-        ? entry
-        : [entry, 'Blocking/waiting command is not allowed.'],
-    );
-    for (const [source, reason] of blockingPairs) {
-      if (compile(source).test(command)) {
-        deny(
-          GATE_ID,
-          `${reason} If this wait is genuinely justified, add "${marker} <concrete reason>" ` +
-            'to the command and try again. A declared wait is a decision; a silent one is an oversight.',
-        );
-      }
-    }
-  },
-);
+// no-blocking — denies syntactic forms of waiting in the foreground (sleeping, polling
+// loops, following unbounded output, foreground dev servers) on a real shell command and
+// on a delegation prompt (a subagent can be told "wait with sleep" in prose). Migrated
+// from ~/.claude/hooks/guard-no-blocking.mjs. Off by default: a project opts in, because
+// many legitimate workflows still need a bounded wait the project accepts as normal.
+//
+// This gate only recognizes SYNTACTIC forms of waiting — it never judges whether other
+// work was available meanwhile, because that is judgment, not a fact a regex can read.
+// A gate that misfires on the legitimate case gets disabled, taking every real catch
+// down with it.
+//
+// ── What a project can configure (params) ───────────────────────────────────────────
+//   blockingPatterns      regex sources (matched case-insensitively) of blocking/waiting
+//                         forms to deny. Replaces the built-in list wholesale.
+//   waitJustifiedMarker   a marker token that, present in the command with a reason,
+//                         escapes the block — a declared wait is a decision, not an
+//                         oversight. Replaces the built-in marker wholesale.
+// The defaults live here, in the source, so a project reads them and knows exactly what
+// its override replaces.
+
+import {
+  runGate,
+  deny,
+  toolInGroups,
+  delegationPromptOf,
+} from '../../lib/hook-io.mjs';
+
+const GATE_ID = 'no-blocking';
+const CONFIG_KEY = 'blockWaitingCommands';
+
+const DEFAULT_WAIT_JUSTIFIED_MARKER = 'WAIT-JUSTIFIED:';
+
+// systemd's log-follow command, assembled from fragments so the spell checker does not
+// read it as prose (the project keeps an empty dictionary by policy).
+const SYSTEMD_LOG_COMMAND = 'journal' + 'ctl';
+
+/** Blocking rules as `[regexSource, reason]`, matched case-insensitively. */
+const DEFAULT_BLOCKING_PATTERNS = [
+  [
+    String.raw`(^|[|;&]\s*|\bthen\s+|\bdo\s+)(sleep|timeout)\s+\d`,
+    'Sleeping in the foreground spends the turn doing nothing. If waiting for something ' +
+      'to finish, launch it in the background and move on to something else; if waiting ' +
+      'on an external condition, use a monitor.',
+  ],
+  [
+    String.raw`\bStart-Sleep\b`,
+    'Start-Sleep freezes the turn. Launch the work in the background and continue with ' +
+      'whatever does not depend on it.',
+  ],
+  [
+    String.raw`(^|[|;&]\s*)wait\b|--wait\b|\bWait-Process\b|\bWait-Job\b`,
+    'Waiting for another process to finish blocks the whole turn. Launch it in the ' +
+      'background and consume the result when it arrives, not before.',
+  ],
+  [
+    [
+      String.raw`\b(tail|`,
+      SYSTEMD_LOG_COMMAND,
+      String.raw`|kubectl\s+logs|docker\s+logs)\b[^|;&]*\s-{1,2}f\b`,
+    ].join(''),
+    'Following live output never returns and takes the turn with it. Read the file once, ' +
+      'or leave the following to a background process.',
+  ],
+  [
+    String.raw`(^|[|;&]\s*)watch\s+`,
+    "'watch' repeats forever and blocks. Run the command once; if a change genuinely " +
+      'needs watching, use a monitor that does not take the turn.',
+  ],
+  [
+    String.raw`\b(until|while)\b[^\n]{0,80}\bdo\b[^\n]{0,80}\bsleep\b`,
+    'A loop that sleeps waiting for something to change is foreground polling: it blocks ' +
+      'and it spins. Use a monitor with the condition, or launch the work in the ' +
+      'background and wait for its notification.',
+  ],
+  [
+    String.raw`\b(npm|pnpm|yarn|bun)\s+(run\s+)?(dev|start|serve|watch)\b`,
+    'A dev server does not end on its own: in the foreground it takes the turn until ' +
+      'something kills it. Launch it in the background and keep working while it comes up.',
+  ],
+];
+
+// Marks that a command will not take the turn: backgrounded, detached, or bounded. The bare
+// `-d` token was removed: it matched any -d flag (e.g. `curl -d payload`), letting an
+// unrelated flag whitelist a genuine foreground `sleep`. Detached forms are now matched
+// explicitly (--detach, docker/compose -d at a word boundary before end/pipe), and PowerShell's
+// Start-Job / Start-Process -NoNewWindow backgrounding is recognized.
+// One big alternation trips the linter's regex-complexity check, so each background form is
+// its own short regex tested with `.some()` — matching EXACTLY what the combined pattern did
+// (verified case-by-case). Order does not matter: any one match means the command detaches.
+const NOT_TAKING_THE_TURN_FORMS = [
+  /&\s*$/i,
+  /\bnohup\b/i,
+  /\bstart\s+\/b\b/i,
+  /--detach\b/i,
+  /\b-d(?=\s*($|[|;&]))/i,
+  /\bStart-Job\b/i,
+  /\bStart-Process\b[^|;\n]*-NoNewWindow\b/i,
+  /\brun_in_background\b/i,
+];
+
+function detachesFromTurn(command) {
+  return NOT_TAKING_THE_TURN_FORMS.some((pattern) => pattern.test(command));
+}
+
+function compile(source) {
+  return new RegExp(source, 'i');
+}
+
+/** The text to inspect: a real command's command line, or the delegation prompt. */
+function commandTextFrom(toolName, toolInput) {
+  if (toolInGroups(toolName, ['shell'])) {
+    return String(toolInput.CommandLine ?? toolInput.command ?? '');
+  }
+  return delegationPromptOf(toolInput);
+}
+
+runGate(
+  {
+    id: GATE_ID,
+    configKey: CONFIG_KEY,
+    enabledByDefault: false,
+    defaultParams: {
+      blockingPatterns: DEFAULT_BLOCKING_PATTERNS,
+      waitJustifiedMarker: DEFAULT_WAIT_JUSTIFIED_MARKER,
+    },
+  },
+  ({ toolName, toolInput, parameters }) => {
+    const isShell = toolInGroups(toolName, ['shell']);
+    const isDelegation = toolInGroups(toolName, ['delegation']);
+    if (!isShell && !isDelegation) return;
+
+    const command = commandTextFrom(toolName, toolInput);
+    if (!command.trim()) return;
+
+    // Already declared in the background: the turn stays free, which is all that matters.
+    if (toolInput.run_in_background === true) return;
+    if (detachesFromTurn(command)) return;
+
+    // A declared wait with its reason is a decision, not an oversight.
+    const marker = String(parameters.waitJustifiedMarker ?? '');
+    if (marker) {
+      const escapedMarker = marker.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      const reasonAfterMarker = String.raw`\s*\S+\s+\S+`;
+      const justified = new RegExp(`${escapedMarker}${reasonAfterMarker}`, 'i');
+      if (justified.test(command)) return;
+    }
+
+    const blockingPairs = (parameters.blockingPatterns ?? []).map((entry) =>
+      Array.isArray(entry)
+        ? entry
+        : [entry, 'Blocking/waiting command is not allowed.'],
+    );
+    for (const [source, reason] of blockingPairs) {
+      if (compile(source).test(command)) {
+        deny(
+          GATE_ID,
+          `${reason} If this wait is genuinely justified, add "${marker} <concrete reason>" ` +
+            'to the command and try again. A declared wait is a decision; a silent one is an oversight.',
+        );
+      }
+    }
+  },
+);

package/plugins/gates/hooks/gates/no-coauthor/index.mjs

@@ -0,0 +1,127 @@
+// no-coauthor — denies a `git commit` that carries an AI/agent attribution trailer
+// (Co-Authored-By, "Generated with", "Claude-Session", and the like). The defect is fully
+// visible in the command text the tool is about to run, so this is a deterministic deny with
+// an escape hatch, never a prose reminder: the offending trailer is right there to point at.
+//
+// justification: no existing gate covers this. bash-commands denies destructive commands and
+// block-remote-publish denies pushes; neither inspects the commit MESSAGE for attribution.
+// lint-commit runs the linter on a commit but never reads the message text. This is the first
+// gate that reads what a commit says, not just that it is a commit.
+//
+// ── What a project can configure (params) ───────────────────────────────────────────
+//   attributionPatterns  regex sources (matched case-insensitively) of trailers/phrases
+//                        that must not appear in a commit message. Replaces the built-in
+//                        list wholesale, so a project that wants a different policy states
+//                        its full list.
+//   escapeHatch          a substring the author can put in the command to bypass this gate
+//                        for one legitimate commit (e.g. importing external history that
+//                        genuinely carries a co-author). Default '[allow-coauthor]'.
+//
+// ── How it detects a commit and reads its message ────────────────────────────────────
+// Reuses lint-commit's git-global-option normalization so `git -C /repo -c x=y commit` is
+// recognized as a commit. It then scans the WHOLE command text (which contains the -m value
+// or the heredoc body) for any attribution pattern — this over-includes on purpose (a match
+// inside an unrelated string is a rare false block the author clears with the escape hatch)
+// rather than under-includes (a real trailer slipping through in a shape we did not parse).
+//
+// ── Fail-safe shape ──────────────────────────────────────────────────────────────────
+// Not a commit: allow (silent). A commit with no attribution pattern: allow. A commit whose
+// text matches a pattern and does NOT contain the escape hatch: deny, naming the match.
+
+import { runGate, deny, toolInGroups } from '../../lib/hook-io.mjs';
+
+const GATE_ID = 'no-coauthor';
+const CONFIG_KEY = 'blockCoauthorTrailers';
+
+const SHELL_GROUPS = ['shell', 'delegation'];
+
+// Attribution trailers/phrases an AI agent tends to append. Sources, compiled case-insensitively.
+const DEFAULT_ATTRIBUTION_PATTERNS = [
+  String.raw`co-authored-by:`,
+  String.raw`generated with`,
+  String.raw`generated by`,
+  String.raw`🤖 generated`,
+  String.raw`claude-session:`,
+  String.raw`assisted-by:`,
+  String.raw`authored-with:`,
+  String.raw`with claude code`,
+];
+
+const DEFAULT_ESCAPE_HATCH = '[allow-coauthor]';
+
+// One global git option at a time, stripped repeatedly — same normalization lint-commit and
+// bash-commands use, so `git -C /repo -c x=y commit` reduces to `git commit` before matching.
+const GIT_OPTION_WITH_VALUE = String.raw`(?:-[Cc]|--git-dir|--work-tree|--namespace|--exec-path|--config-env)(?:\s+|=)\S+`;
+const GIT_FLAG_OPTION = String.raw`--(?:paginate|no-pager|bare|no-optional-locks)|-p`;
+const GIT_GLOBAL_OPTION_PATTERN = new RegExp(
+  String.raw`\bgit\s+(?:${GIT_OPTION_WITH_VALUE}|${GIT_FLAG_OPTION})\s+`,
+  'i',
+);
+const GIT_COMMIT_PATTERN = /\bgit\s+commit\b/i;
+
+function normalizeGitOptions(command) {
+  let previous;
+  let normalized = command;
+  do {
+    previous = normalized;
+    normalized = normalized.replace(GIT_GLOBAL_OPTION_PATTERN, 'git ');
+  } while (normalized !== previous);
+  return normalized;
+}
+
+function isGitCommit(command) {
+  return GIT_COMMIT_PATTERN.test(normalizeGitOptions(command));
+}
+
+function commandTextFrom(toolInput) {
+  return String(toolInput.CommandLine ?? toolInput.command ?? '');
+}
+
+/** The first attribution pattern the command text matches, or null when none does. */
+function matchedAttribution(command, attributionPatterns) {
+  for (const source of attributionPatterns) {
+    let pattern;
+    try {
+      pattern = new RegExp(source, 'i');
+    } catch {
+      // A malformed override pattern is skipped rather than crashing the gate; the rest of
+      // the list still protects.
+      continue;
+    }
+    if (pattern.test(command)) return source;
+  }
+  return null;
+}
+
+runGate(
+  {
+    id: GATE_ID,
+    configKey: CONFIG_KEY,
+    enabledByDefault: true,
+    defaultParams: {
+      attributionPatterns: DEFAULT_ATTRIBUTION_PATTERNS,
+      escapeHatch: DEFAULT_ESCAPE_HATCH,
+    },
+  },
+  ({ toolName, toolInput, parameters }) => {
+    if (!toolInGroups(toolName, SHELL_GROUPS)) return;
+
+    const command = commandTextFrom(toolInput);
+    if (!isGitCommit(command)) return;
+
+    const escapeHatch = parameters.escapeHatch ?? DEFAULT_ESCAPE_HATCH;
+    if (escapeHatch && command.includes(escapeHatch)) return;
+
+    const match = matchedAttribution(command, parameters.attributionPatterns);
+    if (!match) return;
+
+    deny(
+      GATE_ID,
+      `This commit message carries an AI/agent attribution trailer (matched "${match}"). ` +
+        'Remove it — no Co-Authored-By, no "Generated with", no session trailer. If this ' +
+        `commit legitimately must keep a co-author (e.g. importing external history), add ` +
+        `"${escapeHatch}" to the command to allow it once, or set attributionPatterns/` +
+        'blockCoauthorTrailers in .ai/config.json.',
+    );
+  },
+);

package/plugins/gates/hooks/gates/no-lint-suppression/index.mjs

@@ -0,0 +1,183 @@
+// no-lint-suppression — denies a write that SILENCES the linter/type-checker instead of
+// fixing the code it complains about. Turning a rule off, adding an inline disable, or
+// widening an ignore list is the lazy path ("it is easier to disable the linter than to fix
+// it"); this gate makes that path a deliberate, escape-hatched choice rather than a default.
+//
+// justification: no existing gate covers this. lint-commit RUNS the linter and blocks a
+// commit when it fails, but a suppression makes the linter pass — so lint-commit goes green
+// precisely when the code got worse. This gate reads the WRITE, not the lint result, and is
+// the only one that catches "made it pass by turning the check off".
+//
+// The defect is fully visible in the content being written (the disable directive, the rule
+// set to "off", the added @ts-ignore), so this is a deterministic deny with an escape hatch —
+// not a prose reminder. A legitimate suppression (a documented false positive) is allowed by
+// putting the escape hatch on the SAME line as the directive, which also forces a reason to
+// live next to it in the diff.
+//
+// ── What this catches ────────────────────────────────────────────────────────────────
+//   inline directives in any source file:
+//     // eslint-disable, /* eslint-disable */, // eslint-disable-next-line,
+//     // @ts-ignore, // @ts-nocheck, # type: ignore, # noqa, // prettier-ignore,
+//     // biome-ignore, // stylelint-disable, // NOSONAR
+//   config edits that weaken the ruleset, in eslint/tsconfig/prettier/biome/stylelint config:
+//     a rule set to "off" / 0, "@ts-nocheck", disabling strict, or "ignore" additions.
+//
+// ── What a project can configure (params) ───────────────────────────────────────────
+//   suppressionPatterns  regex sources (case-insensitive) that mark a line as a
+//                        suppression. Replaces the built-in list wholesale.
+//   escapeHatch          substring that, present on the same line as a suppression, allows
+//                        it — so a real false positive is annotated, not smuggled. Default
+//                        'lint-ok:' (write e.g. `// eslint-disable-next-line ... lint-ok: <reason>`).
+//   watchedConfigFiles   basenames whose edits are also scanned for rule-weakening. Replaces
+//                        the built-in list.
+//
+// ── Fail-safe shape ──────────────────────────────────────────────────────────────────
+// A non-write tool, or a write with no suppression line: allow (silent). A write that adds a
+// suppression line WITHOUT the escape hatch on that same line: deny, naming the line.
+
+import { extname } from 'node:path';
+import {
+  runGate,
+  deny,
+  toolInGroups,
+  writtenContentOf,
+  writtenPathOf,
+} from '../../lib/hook-io.mjs';
+
+const GATE_ID = 'no-lint-suppression';
+const CONFIG_KEY = 'blockLintSuppression';
+
+// Inline suppression directives across the common linters/type-checkers. Sources, compiled
+// case-insensitively and matched one line at a time.
+const DEFAULT_SUPPRESSION_PATTERNS = [
+  String.raw`eslint-disable`,
+  String.raw`@ts-ignore`,
+  String.raw`@ts-nocheck`,
+  String.raw`@ts-expect-error`,
+  String.raw`prettier-ignore`,
+  String.raw`biome-ignore`,
+  String.raw`stylelint-disable`,
+  String.raw`nosonar`,
+  String.raw`#\s*noqa`,
+  String.raw`#\s*type:\s*ignore`,
+  String.raw`//\s*@flow-ignore`,
+  String.raw`istanbul ignore`,
+];
+
+// Config files whose edits are scanned for rule-weakening (a rule set off, strict disabled).
+const DEFAULT_WATCHED_CONFIG_FILES = [
+  'eslint.config.mjs',
+  'eslint.config.js',
+  'eslint.config.cjs',
+  '.eslintrc',
+  '.eslintrc.js',
+  '.eslintrc.cjs',
+  '.eslintrc.json',
+  '.eslintrc.yml',
+  '.eslintrc.yaml',
+  'tsconfig.json',
+  '.prettierrc',
+  'biome.json',
+  '.stylelintrc',
+  '.stylelintrc.json',
+];
+
+// Inside a watched config file, these mark a rule being turned off or a check being weakened.
+const CONFIG_WEAKENING_PATTERNS = [
+  // a rule mapped to "off" or 0:  "no-unused-vars": "off"   'rule': 0
+  // (no trailing \b: the value can end in a quote, which is a non-word char, so \b would
+  // never match after "off" and silently miss every quoted "off")
+  String.raw`["'][^"']+["']\s*:\s*(?:["']off["']|0)(?:\s|,|}|$)`,
+  // strict / type-checking disabled in tsconfig
+  String.raw`"(?:strict|noImplicitAny|strictNullChecks|checkJs)"\s*:\s*false`,
+  String.raw`@ts-nocheck`,
+];
+
+const DEFAULT_ESCAPE_HATCH = 'lint-ok:';
+
+function compile(sources) {
+  const compiled = [];
+  for (const source of sources) {
+    try {
+      compiled.push(new RegExp(source, 'i'));
+    } catch {
+      // Skip a malformed override pattern rather than crashing; the rest still protect.
+    }
+  }
+  return compiled;
+}
+
+function baseNameOf(filePath) {
+  const normalized = filePath.replace(/\\/g, '/');
+  return normalized.slice(normalized.lastIndexOf('/') + 1);
+}
+
+function isWatchedConfig(filePath, watchedConfigFiles) {
+  return watchedConfigFiles.includes(baseNameOf(filePath));
+}
+
+// A code file's inline directives count everywhere; a config file's edits are read with the
+// rule-weakening patterns instead. We never guess a language — the directives are recognizable
+// on their own.
+const NON_SOURCE_EXTENSIONS = new Set(['.md', '.txt', '.lock', '.log']);
+
+function isPlausibleSource(filePath) {
+  return !NON_SOURCE_EXTENSIONS.has(extname(filePath).toLowerCase());
+}
+
+/** The first written line matching any pattern and lacking the escape hatch, or null. */
+function offendingLine(content, patterns, escapeHatch) {
+  for (const line of content.split('\n')) {
+    if (escapeHatch && line.includes(escapeHatch)) continue;
+    if (patterns.some((pattern) => pattern.test(line))) return line.trim();
+  }
+  return null;
+}
+
+runGate(
+  {
+    id: GATE_ID,
+    configKey: CONFIG_KEY,
+    enabledByDefault: true,
+    defaultParams: {
+      suppressionPatterns: DEFAULT_SUPPRESSION_PATTERNS,
+      watchedConfigFiles: DEFAULT_WATCHED_CONFIG_FILES,
+      escapeHatch: DEFAULT_ESCAPE_HATCH,
+    },
+  },
+  ({ toolName, toolInput, parameters }) => {
+    if (!toolInGroups(toolName, ['write'])) return;
+
+    const filePath = writtenPathOf(toolInput);
+    if (!filePath) return;
+
+    const content = writtenContentOf(toolInput);
+    if (!content) return;
+
+    const escapeHatch = parameters.escapeHatch ?? DEFAULT_ESCAPE_HATCH;
+
+    // Config files: scan for rule-weakening. Any source file: scan for inline suppressions.
+    const isConfig = isWatchedConfig(filePath, parameters.watchedConfigFiles);
+    const inlinePatterns = compile(parameters.suppressionPatterns);
+    const configPatterns = compile(CONFIG_WEAKENING_PATTERNS);
+
+    // A config file is scanned for both inline directives and rule-weakening; any other
+    // plausible source file only for inline directives; a non-source file (docs, lockfiles)
+    // is not scanned at all.
+    let patterns = [];
+    if (isConfig) patterns = [...inlinePatterns, ...configPatterns];
+    else if (isPlausibleSource(filePath)) patterns = inlinePatterns;
+    if (patterns.length === 0) return;
+
+    const offender = offendingLine(content, patterns, escapeHatch);
+    if (!offender) return;
+
+    deny(
+      GATE_ID,
+      `This write silences the linter/type-checker instead of fixing the code: "${offender}". ` +
+        'Fix the underlying issue rather than turning the check off. If this is a genuine, ' +
+        `documented false positive, put "${escapeHatch} <reason>" on the same line so the ` +
+        'reason lives next to the suppression, or set blockLintSuppression in .ai/config.json.',
+    );
+  },
+);