@devrik-tools/claude-gates 0.1.2 → 0.2.0

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

@@ -0,0 +1,159 @@
+// 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';
+
+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';
+
+function stripBom(text) {
+  return text.charCodeAt(0) === 0xfeff ? 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 [];
+  }
+}
+
+function blockingTasksFrom(tasks, allowBlocked) {
+  return tasks.filter((task) => {
+    if (BLOCKING_STATUSES.has(task.status)) return true;
+    return !allowBlocked && task.status === BLOCKED_STATUS;
+  });
+}
+
+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 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();
+    if (!isGateEnabled(CONFIG_KEY, false, 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(
+      `[${GATE_ID}] 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 ' +
+        'allowStopWithBlockedTasks is set to false.',
+    );
+  } catch {
+    // A broken Stop hook must never hang the session.
+    return allow();
+  }
+}
+
+main();

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

@@ -0,0 +1,114 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, mkdirSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const GATE = join(dirname(fileURLToPath(import.meta.url)), 'index.mjs');
+
+function setupProject({ enabled = true, tasks, allowStopWithBlockedTasks } = {}) {
+  const project = mkdtempSync(join(tmpdir(), 'stop-pending-'));
+  mkdirSync(join(project, '.git'), { recursive: true });
+  mkdirSync(join(project, '.ai'), { recursive: true });
+
+  const gateEntry = { enabled };
+  if (allowStopWithBlockedTasks !== undefined) {
+    gateEntry.allowStopWithBlockedTasks = allowStopWithBlockedTasks;
+  }
+  writeFileSync(
+    join(project, '.ai', 'config.json'),
+    JSON.stringify({ gates: { blockStopWithPendingTasks: gateEntry } }),
+  );
+
+  if (tasks) {
+    mkdirSync(join(project, '.ai', 'tasks'), { recursive: true });
+    writeFileSync(
+      join(project, '.ai', 'tasks', 'active.json'),
+      JSON.stringify({ tasks }),
+    );
+  }
+  return project;
+}
+
+function runGate(project, payload) {
+  const out = execFileSync(process.execPath, [GATE], {
+    input: JSON.stringify(payload),
+    encoding: 'utf8',
+    cwd: project,
+    env: { ...process.env, HOME: project, USERPROFILE: project },
+  });
+  return out.trim() ? JSON.parse(out.trim()) : null;
+}
+
+test('an open active task blocks the stop', () => {
+  const project = setupProject({
+    tasks: [{ id: 't-1', title: 'finish the thing', status: 'open' }],
+  });
+  const result = runGate(project, { session_id: 's1', stop_hook_active: false });
+  assert.equal(result.decision, 'block');
+  assert.match(result.reason, /t-1/);
+});
+
+test('no active tasks: stop is allowed', () => {
+  const project = setupProject({ tasks: [] });
+  const result = runGate(project, { session_id: 's1', stop_hook_active: false });
+  assert.equal(result, null);
+});
+
+test('no .ai/tasks directory at all: stop is allowed', () => {
+  const project = setupProject({});
+  const result = runGate(project, { session_id: 's1', stop_hook_active: false });
+  assert.equal(result, null);
+});
+
+test('stop_hook_active=true: always allow, even with an open task (loop guard)', () => {
+  const project = setupProject({
+    tasks: [{ id: 't-1', title: 'finish the thing', status: 'open' }],
+  });
+  const result = runGate(project, { session_id: 's1', stop_hook_active: true });
+  assert.equal(result, null);
+});
+
+test('a blocked task with allowStopWithBlockedTasks default (true): stop is allowed', () => {
+  const project = setupProject({
+    tasks: [{ id: 't-2', title: 'waiting on X', status: 'blocked', blockedReason: 'waiting on X' }],
+  });
+  const result = runGate(project, { session_id: 's1', stop_hook_active: false });
+  assert.equal(result, null);
+});
+
+test('a blocked task with allowStopWithBlockedTasks:false: stop is blocked', () => {
+  const project = setupProject({
+    tasks: [{ id: 't-2', title: 'waiting on X', status: 'blocked', blockedReason: 'waiting on X' }],
+    allowStopWithBlockedTasks: false,
+  });
+  const result = runGate(project, { session_id: 's1', stop_hook_active: false });
+  assert.equal(result.decision, 'block');
+  assert.match(result.reason, /t-2/);
+});
+
+test('gate disabled: stop is allowed even with an open task', () => {
+  const project = setupProject({
+    tasks: [{ id: 't-1', title: 'finish the thing', status: 'open' }],
+    enabled: false,
+  });
+  const result = runGate(project, { session_id: 's1', stop_hook_active: false });
+  assert.equal(result, null);
+});
+
+test('a done task in active.json (should not normally happen) never blocks', () => {
+  const project = setupProject({
+    tasks: [{ id: 't-3', title: 'already closed', status: 'done' }],
+  });
+  const result = runGate(project, { session_id: 's1', stop_hook_active: false });
+  assert.equal(result, null);
+});
+
+test('corrupt active.json: fail-safe allow', () => {
+  const project = setupProject({ tasks: [] });
+  writeFileSync(join(project, '.ai', 'tasks', 'active.json'), '{not json');
+  const result = runGate(project, { session_id: 's1', stop_hook_active: false });
+  assert.equal(result, null);
+});

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

@@ -1,101 +1,101 @@
-import { execFileSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { basename, dirname, relative } from 'node:path';
-import { runGate, warn, TOOL_GROUPS } 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 (!TOOL_GROUPS.write.includes(toolName)) return;
-
-    const filePath = toolInput?.file_path ?? '';
-    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, 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.

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

@@ -0,0 +1,72 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, mkdirSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const GATE = join(dirname(fileURLToPath(import.meta.url)), 'index.mjs');
+
+function newProject({ config, git = true } = {}) {
+  const project = mkdtempSync(join(tmpdir(), 'test-after-implementation-edge-'));
+  if (git) {
+    execFileSync('git', ['init', '-q'], { cwd: project });
+    execFileSync('git', ['config', 'user.email', 'a@b.c'], { cwd: project });
+    execFileSync('git', ['config', 'user.name', 'a'], { cwd: project });
+  }
+  if (config) {
+    mkdirSync(join(project, '.ai'));
+    writeFileSync(join(project, '.ai', 'config.json'), JSON.stringify(config));
+  }
+  return project;
+}
+
+function runGateIn(project, payload) {
+  const out = execFileSync(process.execPath, [GATE], {
+    input: JSON.stringify(payload),
+    encoding: 'utf8',
+    cwd: project,
+    env: { ...process.env, HOME: project, USERPROFILE: project },
+  });
+  return out.trim() ? JSON.parse(out.trim()) : null;
+}
+
+function writeTest(filePath) {
+  return { tool_name: 'Write', tool_input: { file_path: filePath, content: 'test content' } };
+}
+function isWarn(result) {
+  return result?.hookSpecificOutput?.additionalContext !== undefined;
+}
+
+const ENABLE = { gates: { warnTestWrittenAfterImplementation: true } };
+
+// EDGE CASE (BUG): the paired-implementation match requires the changed file's directory
+// (relative to cwd) to equal the test file's directory exactly (index.mjs line 83-86). A
+// common layout keeps tests in a sibling __tests__/ directory next to the implementation —
+// this gate then never pairs them, silently missing the exact case (tests-after-impl) it
+// exists to catch.
+test('BUG: false negative — implementation and test in different conventional directories (src/ vs __tests__/) are never paired', () => {
+  const project = newProject({ config: ENABLE });
+  mkdirSync(join(project, 'src'));
+  mkdirSync(join(project, '__tests__'));
+  writeFileSync(join(project, 'src', 'thing.js'), 'export const thing = 1;');
+  const testPath = join(project, '__tests__', 'thing.test.js');
+  const result = runGateIn(project, writeTest(testPath));
+  assert.equal(result, null, 'gate misses the exact case it targets because dirname(test) !== dirname(impl) under a __tests__/ layout');
+});
+
+// EDGE CASE (BUG): only `git status --porcelain` (uncommitted changes) is checked. If the
+// implementation was written AND COMMITTED before writing the test (a slightly worse
+// practice: commit-then-test rather than just write-then-test), git status shows nothing
+// changed and the gate never warns — the temporal violation it targets still happened but
+// leaves no trace once committed.
+test('BUG: false negative — once the paired implementation change is committed, the warning never fires even though tests were still written strictly after', () => {
+  const project = newProject({ config: ENABLE });
+  writeFileSync(join(project, 'thing.js'), 'export const thing = 1;');
+  execFileSync('git', ['add', '-A'], { cwd: project });
+  execFileSync('git', ['commit', '-q', '-m', 'implement thing'], { cwd: project });
+  const testPath = join(project, 'thing.test.js');
+  const result = runGateIn(project, writeTest(testPath));
+  assert.equal(result, null, 'committing the implementation first launders the same temporal violation past a git-status-based check');
+});

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

@@ -0,0 +1,63 @@
+// Edge-case probe for test-matrix. Previously the prompt was read only from
+// toolInput.prompt/Prompt/task, the same root cause shared by implementation-pipeline,
+// mandatory-flow and the sdd-specs delegation check: a Task delegation carrying its
+// brief in `description` was invisible. Migrated to delegationPromptOf()
+// (hook-io.mjs), so this is now caught.
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, mkdirSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+const GATE = join(dirname(fileURLToPath(import.meta.url)), 'index.mjs');
+
+function runGate(payload, { config } = {}) {
+  const project = mkdtempSync(join(tmpdir(), 'test-matrix-edge-'));
+  mkdirSync(join(project, '.git'));
+  if (config) {
+    mkdirSync(join(project, '.ai'));
+    writeFileSync(join(project, '.ai', 'config.json'), JSON.stringify(config));
+  }
+  const out = execFileSync(process.execPath, [GATE], {
+    input: JSON.stringify(payload),
+    encoding: 'utf8',
+    cwd: project,
+    env: { ...process.env, HOME: project, USERPROFILE: project },
+  });
+  return out.trim() ? JSON.parse(out.trim()) : null;
+}
+
+function isDeny(result) {
+  return result?.hookSpecificOutput?.permissionDecision === 'deny';
+}
+
+function enabledConfig() {
+  return { gates: { requireTestMatrixWhenImplementing: true } };
+}
+
+test('FIXED: a Task delegation carrying its brief in `description` is now checked', () => {
+  const payload = {
+    tool_name: 'Task',
+    tool_input: {
+      description: 'Nivel: STANDARD\nImplementá el cobro de la cuota.',
+      subagent_type: 'backend',
+    },
+  };
+  assert.ok(
+    isDeny(runGate(payload, { config: enabledConfig() })),
+    'delegationPromptOf reads description and the missing-test-matrix deny fires',
+  );
+});
+
+test('OK: the equivalent payload using `prompt` IS caught (control)', () => {
+  const payload = {
+    tool_name: 'Task',
+    tool_input: {
+      prompt: 'Nivel: STANDARD\nImplementá el cobro de la cuota.',
+      subagent_type: 'backend',
+    },
+  };
+  assert.ok(isDeny(runGate(payload, { config: enabledConfig() })), 'control failed');
+});