@devrik-tools/claude-gates 0.2.1 → 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/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.

package/plugins/gates/hooks/hooks.json

@@ -11,6 +11,16 @@
           }
         ]
       },
+      {
+        "matcher": "Bash|run_command|Agent|Task|invoke_subagent|mcp__.*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/block-remote-publish/index.mjs\"",
+            "timeout": 30
+          }
+        ]
+      },
       {
         "matcher": "Write|Edit|NotebookEdit|write_to_file|replace_file_content|Bash|run_command|mcp__.*",
         "hooks": [
@@ -311,6 +321,15 @@
             "timeout": 30
           }
         ]
+      },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/gates/autonomous-mode/stop.mjs\"",
+            "timeout": 30
+          }
+        ]
       }
     ],
     "SessionStart": [

package/plugins/tasks/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "tasks",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Deterministic task tracking for Claude Code: persists tasks the model registers via the CLI, reminds of open tasks on a message counter, and lists active tasks on session start.",
   "author": {
     "name": "Devrik"

package/plugins/tasks/hooks/register-requests.mjs

@@ -81,9 +81,13 @@ function readPayload() {
 // make something OCCUR deterministically; it is depending on the model's judgment for a
 // judgment call (whether this message describes a new task), same shape as ask-adoption.
 const CLASSIFY_PROMPT =
-  '[tasks] If the user just described a new actionable task (not a question, not small talk), ' +
-  'register it now: run `claude-gates task add "<title>" [--description <text>] [--size <size>]` ' +
-  'from the project root. Skip this for messages that are not a new task.';
+  '[tasks] MANDATORY before you respond: judge whether the message you just received describes ' +
+  'a new actionable task (not a question, not small talk, not a follow-up on an already-registered ' +
+  'task). If it does, you MUST register it now, before writing your reply — run ' +
+  '`claude-gates task add "<title>" [--description <text>] [--size <size>]` from the project root ' +
+  '(or the CLI\'s absolute path if `claude-gates` is not on PATH). Do not defer this, do not decide ' +
+  'to register it "later", do not silently skip it because the answer seems obvious. If it is not a ' +
+  'new task, skip registration — do not fabricate one.';
 
 function formatReminder(tasks) {
   const shown = tasks.slice(0, MAX_TASKS_SHOWN);