@devrik-tools/claude-gates 0.8.0 → 0.9.0

package/.claude-plugin/marketplace.json

@@ -4,20 +4,20 @@
     "name": "claude-gates"
   },
   "metadata": {
-    "description": "Installable deterministic gates (hooks) for Claude Code, selectable per project or globally with `npx @devrik99/claude-gates init`."
+    "description": "Installable deterministic gates (hooks) for Claude Code, selectable per project or globally with `npx @devrik-tools/claude-gates init`."
   },
   "plugins": [
     {
       "name": "gates",
       "source": "./plugins/gates",
       "description": "PreToolUse gates: destructive-command blocks, protected paths, delegation/spec/quality rules, tool-discovery and forge-pipeline enforcement. Which gates run is decided by .ai/config.json (project) or ~/.claude/claude-gates/config.json (global).",
-      "version": "0.8.0"
+      "version": "0.9.0"
     },
     {
       "name": "tasks",
       "source": "./plugins/tasks",
       "description": "Deterministic task tracking: the model registers tasks via the CLI, a UserPromptSubmit hook reminds of open tasks every few messages, and a SessionStart hook lists active tasks when a session opens.",
-      "version": "0.8.0"
+      "version": "0.9.0"
     }
   ]
 }

package/README.es.md

@@ -30,7 +30,7 @@ npx @devrik-tools/claude-gates init
 
 Reinicia la sesión de Claude Code (o ejecuta `/plugin`) para que los hooks carguen.
 
-> **¿Por qué dos cosas?** El plugin **siempre trae los 44 gates**; la configuración decide
+> **¿Por qué dos cosas?** El plugin **siempre trae los 49 gates**; la configuración decide
 > **cuáles se ejecutan**. Así puedes prender uno sin reinstalar: es una línea en un JSON.
 
 ---
@@ -67,7 +67,7 @@ ejecución), así que funciona aunque instales uno suelto por fuera.
 
 ---
 
-## Los gates (44, en 10 familias)
+## Los gates (49, en 11 familias)
 
 `[on]` = encendidos por defecto; `[off]` = los prendes si los quieres.
 
@@ -79,6 +79,7 @@ ejecución), así que funciona aunque instales uno suelto por fuera.
 | `protected-paths` | on | Bloquea escrituras a `.env`, lockfiles y el propio harness. |
 | `root-whitelist` | on | Bloquea crear archivos/carpetas nuevos en la raíz fuera de la lista blanca. |
 | `no-blocking` | off | Bloquea `sleep`, `tail -f`, bucles de sondeo y servidores en primer plano. |
+| `require-monitor` | on | Bloquea un comando en background (`run_in_background: true`) que no declara su monitor con el marcador `MONITOR-PLANNED:`, y bloquea cualquier ejecución posterior mientras quede un background sin monitorear. |
 
 ### 🤝 Delegation — exigencias sobre el brief al delegar a un subagente
 | Gate | | Qué hace |
@@ -88,6 +89,7 @@ ejecución), así que funciona aunque instales uno suelto por fuera.
 | `risk-level` | off | Exige declarar el nivel (QUESTION/MICRO/STANDARD/HIGH-RISK). |
 | `circuit-breaker` | off | Corta la misma delegación reintentada sin cambios reales. |
 | `no-memory-dependency` | off | Bloquea un brief que depende de que el subagente "recuerde" la conversación (marcador `memory-not-needed` para un falso positivo). |
+| `force-parallel` | on | Bloquea la enésima delegación secuencial consecutiva dentro de una ventana de tiempo: las delegaciones independientes se lanzan juntas en un solo mensaje (marcador `SEQUENTIAL-JUSTIFIED` cuando la segunda depende de verdad de la primera). |
 
 ### 📋 Spec-driven flow — solo aplican si el proyecto adoptó desarrollo por specs
 | Gate | | Qué hace |
@@ -118,6 +120,7 @@ ejecución), así que funciona aunque instales uno suelto por fuera.
 | `no-coauthor` | on | Bloquea un `git commit` que lleve un trailer de atribución de IA (`Co-Authored-By`, `Generated with`, un trailer de sesión). Marcador `[allow-coauthor]` para un co-autor legítimo. |
 | `no-lint-suppression` | on | Bloquea una escritura que silencia el linter/type-checker (`eslint-disable`, `@ts-ignore`, una regla en `off`) en vez de arreglar el código. Marcador `lint-ok: <razón>` en la misma línea para un falso positivo documentado. |
 | `no-explanatory-comments`   | on  | Bloquea una escritura de código que agrega comentarios que narran qué hace el código. Solo pasan comentarios de decisión (el porqué, un trade-off, una limitación), directivas de herramientas, `TODO`/`FIXME` y etiquetas JSDoc con tipo. Juzga solo comentarios nuevos (diff contra disco). `comment-ok: <razón>` para una excepción documentada. |
+| `no-trivial-scripts` | on | Bloquea un script inline de intérprete que hace una operación de archivos que las herramientas `Edit`/`Write` resuelven directo (`node -e` con `writeFileSync`, `python -c` con `open(…, 'w')`, `sed -i`, `perl -i`, `Set-Content`/`Add-Content`). Los scripts inline que solo computan no caen. |
 
 ### 🔎 Tool discovery — no reinventar la rueda
 | Gate | | Qué hace |
@@ -137,6 +140,26 @@ ejecución), así que funciona aunque instales uno suelto por fuera.
 |---|---|---|
 | `forge-flow` | off | En un proyecto que adoptó [forge](https://github.com/DevRik99/forge-mcp), bloquea editar/ejecutar si no hay un run de forge activo. Cierra el hueco que el MCP no puede: te obliga a pasar por el pipeline. |
 
+### 🤖 Autonomy — que una corrida sin supervisión decida en vez de preguntar
+
+| Gate | | Qué hace |
+|---|---|---|
+| `autonomous-mode` | off | Con el modo autónomo prendido, bloquea `AskUserQuestion` y bloquea que el turno termine solo para esperar: reinyecta, una vez por ciclo, la instrucción de decidir y seguir, dejando pendiente solo lo que de verdad necesita al usuario. |
+
+### ⏹️ Completion — el turno no termina con trabajo abierto
+
+| Gate | | Qué hace |
+|---|---|---|
+| `stop-pending` | on | Bloquea el evento Stop mientras el proyecto tiene tareas activas (`open`/`in_forge`); las lista y explica cómo cerrarlas con evidencia verificada o abandonarlas. Las tareas `blocked` no retienen el turno por defecto. |
+| `require-task-split` | on | Bloquea escrituras y ejecución mientras una tarea activa más grande que `small` no tenga sub-tareas registradas: primero se parte en piezas verificables por separado (`task add --parent <id>`). |
+
+### 🗂️ Task tracking — el plugin de tareas
+
+| Gate | | Qué hace |
+|---|---|---|
+| `remind-open-tasks` | on | Hace que el asistente clasifique y registre el trabajo nuevo por el CLI, y recita las tareas activas cada N mensajes. |
+| `list-tasks-on-session-start` | on | Lista las tareas activas del proyecto al abrir una sesión. Silencioso si no hay ninguna. |
+
 ### 🩺 Sesión y contexto — validaciones al arrancar e inyección de capacidades
 | Gate | | Qué hace |
 |---|---|---|
@@ -160,7 +183,7 @@ ves y editas cada perilla:
 ```json
 {
   "adopted": "partial",
-  "gateVersion": "3.0.0",
+  "gateVersion": "3.1.0",
   "gates": {
     "blockDestructiveShellCommands": {
       "enabled": true,
@@ -194,7 +217,9 @@ ves y editas cada perilla:
   commit), `lint-ok: <razón>` (un falso positivo documentado del linter), `[skip-lint]`
   (saltea el chequeo de staged-lint por un commit), `[wip]` (permite un commit
   deliberadamente amplio, no atómico), `comment-ok: <razón>` (un comentario explicativo que
-  debe quedarse). `dependency-skills` se exime vía su lista `depsWithoutOwnApi`.
+  debe quedarse), `SEQUENTIAL-JUSTIFIED` (una delegación que sí depende de la anterior),
+  `MONITOR-PLANNED:` (el comando en background declara cómo se va a monitorear).
+  `dependency-skills` se exime vía su lista `depsWithoutOwnApi`.
 - **Inyección de capacidades:** `capability-map` (on por defecto) es totalmente ajustable —
   elegí qué tipos exponer (`"kinds": ["skills", "agents", "commands"]`), limitá cada blurb
   (`maxClauseChars`, default 120), agregá raíces extra por tipo, regulá cada cuánto se
@@ -231,17 +256,33 @@ El archivo rota una vez a los 5 MB (`gates-log.1.jsonl`). `CLAUDE_GATES_LOG=0` l
 
 ---
 
-## Tareas: cerrar exige evidencia verificada
+## Tareas: se registran con criterio y se cierran con evidencia verificada
 
-`task close` rechaza texto libre. Una tarea está hecha solo cuando una verificación pasa:
+Una tarea lleva su criterio de verificación **desde que se crea** — `task add` rechaza una
+tarea que nadie puede probar terminada — y `task close` rechaza texto libre: está hecha solo
+cuando la verificación pasa de verdad.
 
 ```bash
+# Registrar: el criterio es obligatorio (--verify-command o --verify-path)
+claude-gates task add "migrar el cargador de configuración" \
+  --size medium --verify-command "npm test" --verify-expect "fail 0"
+claude-gates task add "escribir la guía de migración" \
+  --parent <id> --verify-path docs/migration.md --verify-contains "## Upgrading"
+
+claude-gates task list [--all]        # tareas activas (o todo el historial)
+
+# Cerrar: sin --check/--exists, se vuelve a correr el criterio propio de la tarea
+claude-gates task close <id>
 claude-gates task close <id> --check "npm test" --expect "fail 0" --note "suite en verde"
 claude-gates task close <id> --exists dist/report.html --contains "All green"
 claude-gates task abandon <id> --reason "obsoleta"
+claude-gates task promote <id> <runId>   # vincula la tarea a un run de forge
 ```
 
-El resultado verificado (comando, código de salida, cola de la salida, fecha) queda guardado con la tarea.
+El resultado verificado (comando, código de salida, cola de la salida, fecha) queda guardado
+con la tarea. Dos gates se apoyan en este store: `require-task-split` bloquea implementar una
+tarea más grande que `small` sin sub-tareas, y `stop-pending` impide que el turno termine
+mientras queden tareas abiertas.
 
 ---
 
@@ -263,12 +304,28 @@ claude-gates status                   # on/off efectivo por gate y su origen (pr
 claude-gates log [--tail N] [--deny] [--gate id] [--since iso] [--json]
 claude-gates doctor                   # ¿Claude Code corre ESTA versión del paquete?
 
+# Tareas (el store que leen los gates de completion):
+claude-gates task add <título> --size <tamaño> --verify-command <cmd>|--verify-path <ruta> [--parent <id>]
+claude-gates task list [--all]
+claude-gates task close <id> [--check <cmd> --expect <texto>] [--exists <ruta> --contains <texto>]
+claude-gates task abandon <id> --reason <texto>
+claude-gates task promote <id> <runId>
+
 # Inspeccionar el catálogo:
 claude-gates registry --list          # lista familias y gates
 claude-gates registry --check         # valida registry.json y que hooks.json esté sincronizado
 claude-gates registry --sync-hooks    # regenera el hooks.json de cada plugin desde el registry
+
+# Verificar que los gates realmente reaccionan (no solo que están enganchados):
+claude-gates smoke                    # le da a cada gate una violación conocida; sale distinto de 0 si alguno no bloquea/avisa
 ```
 
+`smoke` es el chequeo de comportamiento que `registry --check` (estructura) y el hook doctor
+(que los archivos existan) no hacen: le da a cada gate una violación conocida y confirma que
+de verdad deniega o avisa. Los gates cuya violación necesita estado sembrado (una db, un repo
+git, estado entre llamadas) reportan `skip`, nunca un falso pase. Se corre después de
+instalar, o en CI, para detectar un gate enganchado que en silencio deja pasar todo.
+
 ---
 
 ## Estructura del repositorio
@@ -285,7 +342,8 @@ plugins/gates/                    El plugin de gates.
   hooks/hooks.json                Generado desde registry.json (`registry --sync-hooks`). Lo carga Claude Code.
   hooks/lib/                      Código compartido de los hooks (Node built-ins only).
   hooks/gates/<id>/               Un gate por carpeta: index.mjs (la regla) + test.mjs (su test).
-plugins/tasks/                    El plugin de tareas (en construcción): persiste tareas por proyecto.
+plugins/tasks/                    El plugin de tareas: persiste tareas por proyecto, recuerda las abiertas
+                                  y las lista al arrancar la sesión.
 .claude-plugin/marketplace.json   Lista los plugins del marketplace.
 ```
 

package/README.md

@@ -29,7 +29,7 @@ npx @devrik-tools/claude-gates init
 
 Restart the Claude Code session (or run `/plugin`) so the hooks load.
 
-> **Why two things?** The plugin **always ships all 44 gates**; the config decides **which
+> **Why two things?** The plugin **always ships all 49 gates**; the config decides **which
 > ones run**. So you can turn one on without reinstalling — it is one line in a JSON file.
 
 ---
@@ -65,7 +65,7 @@ works even if you install one on its own.
 
 ---
 
-## The gates (in families)
+## The gates (49, in 11 families)
 
 `[on]` = enabled by default; `[off]` = enable it if you want it.
 
@@ -78,6 +78,7 @@ works even if you install one on its own.
 | `protected-paths`      | on  | Blocks writes to `.env`, lockfiles and the harness itself.                                                                                        |
 | `root-whitelist`       | on  | Blocks new root-level files/folders outside a whitelist.                                                                                          |
 | `no-blocking`          | off | Blocks `sleep`, `tail -f`, polling loops and foreground servers.                                                                                  |
+| `require-monitor`      | on  | Blocks a background command (`run_in_background: true`) that does not declare its monitor with a `MONITOR-PLANNED:` marker, and blocks further execution while an unmonitored background command is still pending. |
 
 ### 🤝 Delegation — requirements on the brief when delegating to a subagent
 
@@ -88,6 +89,7 @@ works even if you install one on its own.
 | `risk-level`            | off | Requires a declared level (QUESTION/MICRO/STANDARD/HIGH-RISK).                                                         |
 | `circuit-breaker`       | off | Cuts the same delegation retried without real changes.                                                                 |
 | `no-memory-dependency`  | off | Blocks a brief that relies on the subagent "remembering" the chat (add `memory-not-needed` to allow a false positive). |
+| `force-parallel`        | on  | Blocks the Nth consecutive sequential delegation inside a time window: independent delegations must be launched together in one message (add `SEQUENTIAL-JUSTIFIED` when the second one really depends on the first). |
 
 ### 📋 Spec-driven flow — only relevant if the project adopted spec-driven development
 
@@ -120,6 +122,7 @@ works even if you install one on its own.
 | `no-coauthor`               | on  | Blocks a `git commit` carrying an AI/agent attribution trailer (`Co-Authored-By`, `Generated with`, a session trailer). Add `[allow-coauthor]` for one legitimate co-author. |
 | `no-lint-suppression`       | on  | Blocks a write that silences the linter/type-checker (`eslint-disable`, `@ts-ignore`, a rule set to `off`) instead of fixing the code. Add `lint-ok: <reason>` on the same line for a documented false positive. |
 | `no-explanatory-comments`   | on  | Blocks a code write that adds comments narrating what the code does. Only decision comments (why, trade-off, limitation), tool directives, `TODO`/`FIXME` and typed JSDoc tags pass. Judges only new comments (diff against disk). Add `comment-ok: <reason>` for a documented exception. |
+| `no-trivial-scripts`        | on  | Blocks an inline interpreter script that does a file operation the `Edit`/`Write` tool handles directly (`node -e` with `writeFileSync`, `python -c` with `open(…, 'w')`, `sed -i`, `perl -i`, `Set-Content`/`Add-Content`). Inline scripts that only compute are not caught. |
 
 ### 🔎 Tool discovery — don't reinvent the wheel
 
@@ -141,6 +144,26 @@ works even if you install one on its own.
 | ------------ | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `forge-flow` | off | In a project that adopted [forge](https://github.com/DevRik99/forge-mcp), blocks editing/running unless an active forge run exists. Closes the hole the MCP cannot: it forces you through the pipeline. |
 
+### 🤖 Autonomy — let an unattended run decide instead of asking
+
+| Gate               |     | What it does                                                                                                                                                                                                       |
+| ------------------ | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `autonomous-mode`  | off | With autonomous mode on, blocks `AskUserQuestion` and blocks a turn that ends only to wait: it re-injects, once per cycle, the instruction to decide and proceed, leaving pending only what genuinely needs the user. |
+
+### ⏹️ Completion — a turn does not end with work still open
+
+| Gate                 |     | What it does                                                                                                                                                                                     |
+| -------------------- | --- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `stop-pending`       | on  | Blocks the Stop event while this project has active tasks (`open`/`in_forge`); lists them and how to close them with verified evidence or abandon them. `blocked` tasks don't hold the turn by default. |
+| `require-task-split` | on  | Blocks writes and execution while an active task larger than `small` has no sub-tasks registered: split it into independently verifiable pieces first (`task add --parent <id>`).                     |
+
+### 🗂️ Task tracking — the tasks plugin
+
+| Gate                          |     | What it does                                                                                             |
+| ----------------------------- | --- | ---------------------------------------------------------------------------------------------------------- |
+| `remind-open-tasks`           | on  | Makes the assistant classify and register new work via the CLI, and recites the active tasks every N messages. |
+| `list-tasks-on-session-start` | on  | Lists this project's active tasks when a session opens. Silent when there are none.                          |
+
 ### 🩺 Session & context — startup checks and capability injection
 
 | Gate             |     | What it does                                                                                                                                                                                          |
@@ -165,7 +188,7 @@ see and edit every knob:
 ```json
 {
   "adopted": "partial",
-  "gateVersion": "3.0.0",
+  "gateVersion": "3.1.0",
   "gates": {
     "blockDestructiveShellCommands": {
       "enabled": true,
@@ -206,7 +229,9 @@ see and edit every knob:
   non-memory phrase), `[allow-coauthor]` (one legitimate co-author on a commit),
   `lint-ok: <reason>` (a documented linter false positive), `[skip-lint]` (skip the
   staged-lint check for one commit), `[wip]` (allow one deliberately broad,
-  non-atomic commit), `comment-ok: <reason>` (one explanatory comment that must stay).
+  non-atomic commit), `comment-ok: <reason>` (one explanatory comment that must stay),
+  `SEQUENTIAL-JUSTIFIED` (a delegation that genuinely depends on the previous one),
+  `MONITOR-PLANNED:` (the background command declares how it will be monitored).
   `dependency-skills` opts out via its `depsWithoutOwnApi` list.
 - **Capability injection:** `capability-map` (on by default) is fully tunable — pick which
   kinds to surface (`"kinds": ["skills", "agents", "commands"]`), cap each blurb
@@ -243,17 +268,33 @@ The file rotates once at 5 MB (`gates-log.1.jsonl`). Set `CLAUDE_GATES_LOG=0` to
 
 ---
 
-## Tasks: closing needs verified evidence
+## Tasks: registered with a criterion, closed with verified evidence
 
-`task close` refuses free text. A task is done only when a check passes:
+A task carries its verification criterion **from the moment it is created** — `task add`
+refuses a task nobody can prove done — and `task close` refuses free text: it is done only
+when the check actually passes.
 
 ```bash
+# Register: the criterion is mandatory (--verify-command or --verify-path)
+claude-gates task add "migrate the config loader" \
+  --size medium --verify-command "npm test" --verify-expect "fail 0"
+claude-gates task add "write the migration guide" \
+  --parent <id> --verify-path docs/migration.md --verify-contains "## Upgrading"
+
+claude-gates task list [--all]        # active tasks (or the whole history)
+
+# Close: with no --check/--exists, the task's own verify criterion is re-run
+claude-gates task close <id>
 claude-gates task close <id> --check "npm test" --expect "fail 0" --note "suite green"
 claude-gates task close <id> --exists dist/report.html --contains "All green"
 claude-gates task abandon <id> --reason "obsolete"
+claude-gates task promote <id> <runId>   # link the task to a forge run
 ```
 
 The verified result (command, exit code, output tail, timestamp) is stored with the task.
+Two gates lean on this store: `require-task-split` blocks implementing a task bigger than
+`small` that has no sub-tasks, and `stop-pending` blocks the turn from ending while tasks
+are still open.
 
 ---
 
@@ -275,6 +316,13 @@ claude-gates status                   # effective on/off per gate and its source
 claude-gates log [--tail N] [--deny] [--gate id] [--since iso] [--json]
 claude-gates doctor                   # is Claude Code running THIS package version of the plugins?
 
+# Tasks (the store the completion gates read):
+claude-gates task add <title> --size <size> --verify-command <cmd>|--verify-path <path> [--parent <id>]
+claude-gates task list [--all]
+claude-gates task close <id> [--check <cmd> --expect <text>] [--exists <path> --contains <text>]
+claude-gates task abandon <id> --reason <text>
+claude-gates task promote <id> <runId>
+
 # Inspect the catalog:
 claude-gates registry --list          # list families and gates
 claude-gates registry --check         # validate registry.json and that hooks.json is in sync
@@ -306,7 +354,8 @@ plugins/gates/                    The gates plugin.
   hooks/hooks.json                Generated from registry.json (`registry --sync-hooks`). Loaded by Claude Code.
   hooks/lib/                      Shared hook code (Node built-ins only).
   hooks/gates/<id>/               One gate per folder: index.mjs (the rule) + test.mjs (its test).
-plugins/tasks/                    The tasks plugin (work in progress): persists per-project tasks.
+plugins/tasks/                    The tasks plugin: persists per-project tasks, reminds of the open ones
+                                  and lists them on session start.
 .claude-plugin/marketplace.json   Lists the marketplace plugins.
 ```
 

package/cli/registry.mjs

@@ -21,6 +21,7 @@ export const TOOL_GROUPS = [
   'execution',
   'question',
   'research',
+  'monitor',
 ];
 
 /** The kinds of value a gate param can take, so the CLI can describe and validate it. */

package/cli/smoke-fixtures.json

@@ -136,8 +136,8 @@
     {
       "id": "force-parallel",
       "configKey": "warnSequentialDelegations",
-      "enabledByDefault": false,
-      "type": "warn",
+      "enabledByDefault": true,
+      "type": "deny",
       "payload": {
         "tool_name": "Task",
         "tool_input": {
@@ -145,7 +145,7 @@
         }
       },
       "needsState": true,
-      "note": "stateful: warns only on the 3rd consecutive delegation under one session."
+      "note": "stateful: denies only on the 3rd consecutive delegation under one session."
     },
     {
       "id": "feature-catalog",
@@ -542,6 +542,48 @@
         }
       },
       "needsState": false
+    },
+    {
+      "id": "require-task-split",
+      "configKey": "requireTaskSplitBeforeImplementing",
+      "enabledByDefault": true,
+      "type": "deny",
+      "payload": {
+        "tool_name": "Write",
+        "tool_input": {
+          "file_path": "src/x.js",
+          "content": "x"
+        }
+      },
+      "needsState": true,
+      "note": "needs an .ai/tasks/active.json with a medium+ task that has no children."
+    },
+    {
+      "id": "require-monitor",
+      "configKey": "requireMonitorForBackground",
+      "enabledByDefault": true,
+      "type": "deny",
+      "payload": {
+        "tool_name": "Bash",
+        "tool_input": {
+          "command": "npm run build",
+          "run_in_background": true
+        }
+      },
+      "needsState": false
+    },
+    {
+      "id": "no-trivial-scripts",
+      "configKey": "blockTrivialInlineScripts",
+      "enabledByDefault": true,
+      "type": "deny",
+      "payload": {
+        "tool_name": "Bash",
+        "tool_input": {
+          "command": "sed -i 's/old/new/' src/a.mjs"
+        }
+      },
+      "needsState": false
     }
   ]
 }

package/cli/task.mjs

@@ -16,6 +16,12 @@ import { verifyCommand, verifyPath } from './evidence.mjs';
 
 const DEFAULT_SIZE = 'unspecified';
 
+const VERIFY_USAGE =
+  'task add requires a deterministic verification criterion: ' +
+  '--verify-command "<command>" [--verify-expect <text>] (command that must exit 0 when done) ' +
+  'or --verify-path <path> [--verify-contains <text>] (file/dir that must exist when done). ' +
+  'This defines HOW the task will be verified as complete — free text is not enough.';
+
 function fail(message) {
   process.stderr.write(`${message}\n`);
   process.exit(EXIT_CODE.FAILURE);
@@ -31,18 +37,41 @@ function openStoreOrFail(cwd) {
   return store;
 }
 
+function buildVerifyCriteria(options) {
+  if (options.verifyCommand) {
+    return {
+      kind: 'command',
+      command: options.verifyCommand,
+      expect: options.verifyExpect ?? null,
+    };
+  }
+  if (options.verifyPath) {
+    return {
+      kind: 'path',
+      path: options.verifyPath,
+      contains: options.verifyContains ?? null,
+    };
+  }
+  return null;
+}
+
 function taskAdd(title, options, { cwd = process.cwd() } = {}) {
   if (!title || !title.trim()) fail('task add requires a non-empty title.');
+  const verify = buildVerifyCriteria(options);
+  if (!verify) fail(VERIFY_USAGE);
   const store = openStoreOrFail(cwd);
-  const task = store.add({
+  const task = {
     id: options.id || randomUUID(),
     title: title.trim(),
     description: options.description ?? '',
     status: STATUS.OPEN,
     size: options.size ?? DEFAULT_SIZE,
+    verify,
     createdAt: new Date().toISOString(),
     messages: [],
-  });
+  };
+  if (options.parent) task.parentId = options.parent;
+  store.add(task);
   process.stdout.write(`${JSON.stringify(task, null, 2)}\n`);
 }
 
@@ -80,9 +109,26 @@ function collectEvidence(options, cwd) {
   return null;
 }
 
+function autoVerifyFromTask(task, cwd) {
+  if (!task?.verify) return null;
+  const { kind, command, expect, path, contains } = task.verify;
+  if (kind === 'command' && command) {
+    return verifyCommand(command, { cwd, expect: expect ?? undefined });
+  }
+  if (kind === 'path' && path) {
+    return verifyPath(path, { cwd, contains: contains ?? undefined });
+  }
+  return null;
+}
+
 function taskClose(id, options, { cwd = process.cwd() } = {}) {
   const store = openStoreOrFail(cwd);
-  const evidence = collectEvidence(options, store.root);
+  let evidence = collectEvidence(options, store.root);
+  if (!evidence && options.evidence !== undefined) fail(EVIDENCE_USAGE);
+  if (!evidence) {
+    const task = store.active().find((entry) => entry.id === id);
+    evidence = autoVerifyFromTask(task, store.root);
+  }
   if (!evidence) fail(EVIDENCE_USAGE);
   if (!evidence.verified) {
     const output = evidence.outputTail ? `\n${evidence.outputTail}` : '';
@@ -121,10 +167,29 @@ export function registerTaskCommand(program) {
 
   task
     .command('add <title>')
-    .description('Register a new open task.')
+    .description(
+      'Register a new open task (requires a verification criterion).',
+    )
     .option('--id <id>', 'explicit task id (default: a generated uuid)')
     .option('--description <text>', 'longer description of the task')
     .option('--size <size>', 'rough size estimate (e.g. trivial, small, large)')
+    .option(
+      '--verify-command <command>',
+      'shell command that must exit 0 when the task is done',
+    )
+    .option(
+      '--verify-expect <text>',
+      'text the --verify-command output must contain',
+    )
+    .option(
+      '--verify-path <path>',
+      'file or directory that must exist when the task is done',
+    )
+    .option(
+      '--verify-contains <text>',
+      'text the --verify-path file must contain',
+    )
+    .option('--parent <id>', 'parent task id (makes this a sub-task)')
     .action((title, options) => taskAdd(title, options));
 
   task

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@devrik-tools/claude-gates",
-  "version": "0.8.0",
-  "description": "Installable, deterministic gates (hooks) for Claude Code: block destructive commands, protected paths, and enforce delegation/spec/quality rules. Configurable per project.",
+  "version": "0.9.0",
+  "description": "49 installable, deterministic gates (hooks) for Claude Code: block destructive commands and protected paths, enforce delegation/spec/quality/research rules, and track tasks that only close with verified evidence. Configurable per project.",
   "keywords": [
     "claude-code",
     "hooks",
@@ -9,7 +9,8 @@
     "guardrails",
     "pretooluse",
     "policy-enforcement",
-    "ai-agent"
+    "ai-agent",
+    "task-tracking"
   ],
   "type": "module",
   "bin": {

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

@@ -1,6 +1,6 @@
 {
   "name": "gates",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Deterministic gates for Claude Code: destructive-command blocks, protected paths, delegation briefs, spec-driven flow and session-start validation. Selection lives in config, not in code.",
   "author": {
     "name": "Devrik"

package/plugins/gates/hooks/gates/circuit-breaker/index.mjs

@@ -30,7 +30,6 @@ const CONFIG_KEY = 'requireCircuitBreakerOnDelegation';
 const DEFAULT_RETRY_THRESHOLD = 2;
 const MIN_RETRY_THRESHOLD = 2;
 const DEFAULT_SIMILARITY_THRESHOLD = 0.6;
-const MAX_ENTRIES_PER_KEY = 12;
 const MAX_OVERRIDE_SENTENCE_WORDS = 8;
 const MIN_TOKEN_LENGTH = 2;
 
@@ -391,18 +390,12 @@ runGate(
       return;
     }
 
+    // Count includes the current attempt (+1) against stored occurrences.
+    // Recording happens in the PostToolUse tracker (track.mjs), not here: a
+    // delegation rejected by ANOTHER gate (running in parallel) must not inflate
+    // the counter — only delegations that actually launched count as attempts.
     const count =
       1 + similarOccurrenceCount(state, signature, similarityThreshold);
-    const occurrences = [
-      ...occurrencesFor(state, key),
-      { signature, seenAt: Date.now() },
-    ].slice(-MAX_ENTRIES_PER_KEY);
-    writeSessionState(
-      GATE_ID,
-      sessionId,
-      { ...state, [key]: occurrences },
-      stateOptions,
-    );
 
     const retryThreshold = Math.max(
       MIN_RETRY_THRESHOLD,