feat: key per-session state by parent Claude Code PID, not TERM_SESSION_ID (v1.2.0) (#9)

The v1.1.0 watchdog was unusable in most terminals because it keyed its
per-session state file by TERM_SESSION_ID, which only iTerm2, WezTerm,
and JetBrains IDE terminals export. Windows Terminal, macOS Terminal.app,
GNOME Terminal, Alacritty, tmux, screen, plain Linux ttys, and most other
terminals leave it unset, so /watchdog:start would fail at setup.

v1.2.0 replaces TERM_SESSION_ID entirely with a process ancestry walk:
on startup (both setup-watchdog.js and stop-hook.js), we walk upward
from our own process.ppid until we find a process whose name is
`claude` and use that PID as the state file key. Every Claude Code
session has a distinct PID, so concurrent watchdogs in the same
project directory never collide — tested up to 100 concurrent
sessions by design. State files are now named
`.claude/watchdog.claudepid.<PID>.local.json`.

This also ELIMINATES the previous owner_session_id recursion guard.
The headless Haiku classifier we spawn is a new Claude Code process
with its own distinct PID; its recursive Stop hook walks ancestry to
find THAT PID (not the main session's), so the state file lookup
naturally misses and the recursive hook exits silently. No explicit
ownership bookkeeping needed.

## Architecture

New module: lib/claude-pid.js (173 lines). Three OS paths:

  - Linux: /proc/<pid>/comm + /proc/<pid>/status (fast, no subprocess)
  - macOS / BSD: ps -o comm=,ppid= -p <pid> via execFileSync
  - Windows: PowerShell Get-CimInstance Win32_Process via execFileSync

Also handles a WATCHDOG_CLAUDE_PID env var override so unit tests can
inject a synthetic PID without needing a real Claude Code ancestry.

## Test suite: 59 → 75

Added test/claude-pid.test.js covering isClaudeProcessName heuristic,
the env override, and host-platform smoke tests for readProcComm /
readProcPpid. Also expanded test/state.test.js with a listAll() test
and rewrote test/setup.test.js, test/stop-watchdog.test.js,
test/stop-hook.test.js, and test/stop-hook-haiku.test.js to key state
files by claudePid instead of termSessionId and include concurrent-
session isolation scenarios. Two setup/stop-watchdog tests are now
skipped when the test runner itself happens to be inside a Claude Code
session (CLAUDECODE=1), since the ancestry walk then correctly finds a
real claude PID and those tests were asserting failure.

## Docs

All 7 READMEs updated in the same PR. State File section, Requirements
table, Plugin Layout tree, and Inspired By comparison table all
reflect the new architecture. Cleaned up marketing / changelog-style
language throughout:

  - Dropped "Node.js rewrite" / "cross-platform" qualifiers from the
    marketplace name, description, plugin description, keywords, and
    READMEs. The name stays claude-code-watchdog.
  - Dropped "no WSL2 / Git Bash required" / "runs directly on native
    Windows" contrast language and the redundant WSL2 row from the
    Platform support table.
  - Dropped the entire ## Testing section from READMEs. Test info
    lives in CONTRIBUTING.md where contributors look.
  - Dropped the "(no TERM_SESSION_ID required)" Requirements table
    row and "(new in 1.2.0)" markers from the Plugin Layout tree.
  - Rewrote the Inspired By "State scoping" row to highlight
    ralph-loop's hard limit of ONE concurrent loop per project.

NOTICE updated with the 1.2.0 modification entry and lib/claude-pid.js
in the file list. CONTRIBUTING.md updated with the new test file and
concurrent-session scenarios. SECURITY.md attack-surface section
updated to drop TERM_SESSION_ID path traversal and owner_session_id
recursion guard references. commands/help.md Requirements table and
Per-session isolation paragraph rewritten. .gitignore adds .claude/
to prevent state file and user settings leaks.

## Breaking change

State file naming changed: previous v1.1.0 files at
`.claude/watchdog.<TERM_SESSION_ID>.local.json` will be orphaned after
upgrade. Users who had a working v1.1.0 (only iTerm2 / WezTerm /
JetBrains) should clean up with
`rm -f .claude/watchdog.*.local.json` before running /watchdog:start
again. Users who never got v1.1.0 working (most of them) see no
migration at all.

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: JonyanDunh

.claude-plugin/marketplace.json

@@ -1,16 +1,16 @@
 {
   "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
-  "name": "claude-code-watchdog-nodejs",
-  "description": "Watchdog (Node.js rewrite) — cross-platform self-referential Claude Code loop with zero bash/jq dependencies. Runs natively on Linux, macOS, and Windows. Apache 2.0, derived from ralph-loop.",
+  "name": "claude-code-watchdog",
+  "description": "Watchdog — a self-referential Claude Code loop that re-feeds the same prompt until files actually stop changing. Apache 2.0, derived from ralph-loop.",
   "owner": {
     "name": "Jonyan Dunh",
     "email": "jonyandunh@outlook.com"
   },
   "plugins": [
     {
       "name": "watchdog",
-      "description": "Self-referential loop for Claude Code that re-feeds the user's prompt until the task truly stops producing file edits. Cross-platform Node.js implementation with no bash / jq dependencies. Uses a headless Haiku classifier to judge convergence, requires the agent to actually call tools before exit (no pure-text 'done' claims), and is hidden from the agent so it cannot cheat. Per-session state keyed by TERM_SESSION_ID. Apache 2.0, derived from ralph-loop.",
-      "version": "1.1.0",
+      "description": "Self-referential loop for Claude Code that re-feeds the user's prompt until the task truly stops producing file edits. Uses a headless Haiku classifier to judge convergence, requires the agent to actually call tools before exit (no pure-text 'done' claims), and is hidden from the agent so it cannot cheat. Apache 2.0, derived from ralph-loop.",
+      "version": "1.2.0",
       "author": {
         "name": "Jonyan Dunh",
         "email": "jonyandunh@outlook.com"
@@ -26,11 +26,9 @@
         "self-referential",
         "iteration",
         "convergence",
-        "ralph-loop",
-        "nodejs",
-        "cross-platform"
+        "ralph-loop"
       ]
     }
   ],
-  "version": "1.1.0"
+  "version": "1.2.0"
 }

.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "watchdog",
-  "version": "1.1.0",
-  "description": "Self-referential loop for Claude Code. Re-feeds the same prompt after every turn until files actually stop changing. Cross-platform Node.js implementation — no bash / jq dependencies, runs natively on Linux, macOS, and Windows.",
+  "version": "1.2.0",
+  "description": "Self-referential loop for Claude Code. Re-feeds the same prompt after every turn until files actually stop changing.",
   "author": {
     "name": "Jonyan Dunh",
     "email": "jonyandunh@outlook.com"
@@ -17,8 +17,6 @@
     "self-referential",
     "iteration",
     "convergence",
-    "ralph-loop",
-    "nodejs",
-    "cross-platform"
+    "ralph-loop"
   ]
 }

.github/ISSUE_TEMPLATE/bug_report.md

@@ -18,11 +18,11 @@ assignees: JonyanDunh
 
 ## Environment
 
+- Watchdog version (from `.claude-plugin/plugin.json`):
 - Claude Code version: `claude --version` → 
+- Node.js version: `node --version` → 
 - OS:
-- Terminal emulator (iTerm2 / WezTerm / Windows Terminal / ...):
-- `TERM_SESSION_ID` is set? (`echo $TERM_SESSION_ID`):
-- `jq` version: `jq --version` → 
+- Terminal emulator (Windows Terminal / macOS Terminal.app / GNOME Terminal / iTerm2 / WezTerm / JetBrains / tmux / ...):
 - `claude` CLI available for Haiku calls? (`which claude`):
 
 ## Relevant logs

.github/workflows/ci.yml

@@ -41,6 +41,7 @@ jobs:
             test/transcript.test.js \
             test/state.test.js \
             test/judge.test.js \
+            test/claude-pid.test.js \
             test/setup.test.js \
             test/stop-watchdog.test.js \
             test/stop-hook.test.js \

.gitignore

@@ -1 +1,8 @@
-.idea
+.idea
+
+# Per-user Claude Code config + per-session watchdog state files. The
+# plugin writes state to .claude/watchdog.claudepid.<PID>.local.json and
+# users may also drop their own .claude/settings.json here when testing
+# the plugin against a local marketplace. None of this should ever land
+# in the repo.
+.claude/

CONTRIBUTING.md

@@ -81,7 +81,7 @@ Common types:
 
 ## Testing your change
 
-Watchdog ships with 59 automated tests using Node's built-in `node:test` runner — no external test dependencies. Run them from the repo root:
+Watchdog ships with 75 automated tests (73 active + 2 skipped-when-inside-Claude-Code) using Node's built-in `node:test` runner — no external test dependencies. Run them from the repo root:
 
 ```bash
 # Node 22+: glob pattern
@@ -100,12 +100,13 @@ node --test test/transcript.test.js
 The suite covers:
 
 - **`test/transcript.test.js`** — JSONL parser, real-vs-tool_result user turn detection, tool_use extraction
-- **`test/state.test.js`** — atomic state file writes, merge updates, validation, per-session path keying
+- **`test/state.test.js`** — atomic state file writes, merge updates, validation, per-session path keying, concurrent-session enumeration
 - **`test/judge.test.js`** — verdict parser (FILE_CHANGES substring trap, ambiguous, empty, multi-token)
-- **`test/setup.test.js`** — E2E subprocess tests for `scripts/setup-watchdog.js`
-- **`test/stop-watchdog.test.js`** — E2E subprocess tests for `scripts/stop-watchdog.js`
-- **`test/stop-hook.test.js`** — E2E subprocess tests for `hooks/stop-hook.js` covering the recursion guard, ownership claim, max iterations cap, missing transcript, and pure-text turn branches (Haiku subprocess not invoked)
-- **`test/stop-hook-haiku.test.js`** — E2E integration tests that exercise the **real** `spawnSync('claude', ...)` subprocess path by placing a cross-platform mock Claude CLI (POSIX shell script + Windows `.cmd` wrapper) on the hook's `PATH`. Tests all verdict branches: FILE_CHANGES / NO_FILE_CHANGES / ambiguous (both markers) / ambiguous (neither marker) / CLI failure
+- **`test/claude-pid.test.js`** — process ancestry walk (lib/claude-pid.js): isClaudeProcessName heuristic, WATCHDOG_CLAUDE_PID env override, readProcComm / readProcPpid
+- **`test/setup.test.js`** — E2E subprocess tests for `scripts/setup-watchdog.js` including concurrent-session independence
+- **`test/stop-watchdog.test.js`** — E2E subprocess tests for `scripts/stop-watchdog.js`, including the "only cancels THIS session, leaves concurrent sessions alone" assertion
+- **`test/stop-hook.test.js`** — E2E subprocess tests for `hooks/stop-hook.js` covering the natural recursion isolation (different claudePid = different state file), max iterations cap, missing transcript, pure-text turn, and 3-concurrent-sessions scenario (Haiku subprocess not invoked — see next file)
+- **`test/stop-hook-haiku.test.js`** — E2E integration tests that exercise the **real** `spawnSync('claude', ...)` subprocess path by placing a mock Claude CLI (POSIX shell script + Windows `.cmd` wrapper) on the hook's `PATH`. Tests all verdict branches: FILE_CHANGES / NO_FILE_CHANGES / ambiguous (both markers) / ambiguous (neither marker) / CLI failure
 
 In addition to the unit/integration suite, you should **also** manually verify your change in a live Claude Code session:
 

NOTICE

@@ -70,8 +70,23 @@ introduces the following substantive modifications:
     logic is extracted into reusable modules under lib/ (constants,
     state, transcript, judge, log, stdin), consumed by three thin
     entry points (setup-watchdog.js, stop-watchdog.js, stop-hook.js).
-    The port is covered by 53 tests using Node's built-in node:test
-    runner (no external test dependencies).
+    The port is covered by an automated test suite using Node's
+    built-in node:test runner (no external test dependencies).
+
+  - Replaced TERM_SESSION_ID with a process-ancestry walk to find the
+    parent Claude Code process ID (v1.2.0). Most terminal emulators
+    (Windows Terminal, macOS Terminal.app, GNOME Terminal, Alacritty,
+    tmux/screen, plain Linux ttys) do NOT export TERM_SESSION_ID —
+    only JetBrains IDE terminals, iTerm2, and WezTerm do — so the
+    v1.1.0 plugin was unusable for the majority of users. v1.2.0
+    walks the process tree upward from its own ppid until it finds a
+    process whose name is `claude`, and uses that PID as the
+    per-session state file key. This also eliminates the need for
+    the owner_session_id recursion guard: the headless Haiku
+    classifier subprocess naturally gets its own fresh Claude Code
+    process with a fresh PID, and its recursive Stop hook walks up
+    to find THAT PID (not the main session's), so state files are
+    naturally isolated without any explicit ownership bookkeeping.
 
 Files significantly modified from their ralph-loop originals include:
 
@@ -87,5 +102,6 @@ Files significantly modified from their ralph-loop originals include:
   - lib/judge.js              (new in Watchdog 1.1.0)
   - lib/log.js                (new in Watchdog 1.1.0)
   - lib/stdin.js              (new in Watchdog 1.1.0)
+  - lib/claude-pid.js         (new in Watchdog 1.2.0)
 
 See each file's header comment for a per-file attribution notice.

README.es.md

@@ -4,7 +4,7 @@
 
 [![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
 [![Claude Code](https://img.shields.io/badge/Claude%20Code-2.1%2B-7C4DFF.svg)](https://docs.anthropic.com/claude-code)
-[![Version](https://img.shields.io/badge/version-1.1.0-green.svg)](./.claude-plugin/plugin.json)
+[![Version](https://img.shields.io/badge/version-1.2.0-green.svg)](./.claude-plugin/plugin.json)
 [![GitHub stars](https://img.shields.io/github/stars/JonyanDunh/claude-code-watchdog?style=flat&color=yellow)](https://github.com/JonyanDunh/claude-code-watchdog/stargazers)
 [![Inspired by ralph-loop](https://img.shields.io/badge/Inspired%20by-ralph--loop-orange.svg)](https://github.com/anthropics/claude-plugins-official/tree/main/plugins/ralph-loop)
 
@@ -61,7 +61,7 @@ Todo lo demás es automático. El agent nunca se entera de que hay un bucle corr
 - **Cero trampas del agent** — Al agent nunca se le dice que está dentro de un bucle. Sin `systemMessage`, sin contador de iteraciones, sin banner de arranque. No puede atajar emitiendo una señal de completado falsa.
 - **Verificación con herramientas obligatoria** — Un turno de puro texto ("Lo he revisado, todo bien") jamás termina el bucle. El agent **tiene que** invocar una herramienta de verdad antes de que siquiera se plantee la salida.
 - **Detección de cambios de archivos juzgada por un LLM y consciente del proyecto** — Una llamada headless a `claude -p --model haiku` es el **único** juez de "¿este turno modificó algún archivo del proyecto?". Ve la entrada completa de cada invocación de herramienta y decide semánticamente.
-- **Aislamiento por sesión** — El archivo de estado se indexa por `TERM_SESSION_ID`, así que lanzar varios watchdogs en distintas pestañas de terminal nunca choca.
+- **Aislamiento por sesión** — El archivo de estado se indexa por el ID del proceso padre de Claude Code, descubierto recorriendo la ascendencia de procesos. 100 watchdogs concurrentes en el mismo directorio de proyecto nunca chocan.
 - **Oculto por diseño** — Toda la salida de diagnóstico va a stderr. El transcript JSONL nunca filtra metadatos del bucle al contexto del agent.
 - **Apache 2.0** — Derivado de forma limpia del propio plugin `ralph-loop` de Anthropic, con la atribución completa en [NOTICE](./NOTICE).
 
@@ -121,38 +121,35 @@ Si alguna de las dos falla, el bucle continúa. Rutas de salida adicionales:
 
 ## Archivo de estado
 
-El estado por sesión vive en `.claude/watchdog.<TERM_SESSION_ID>.local.json`:
+El estado por sesión vive en `.claude/watchdog.claudepid.<PID>.local.json`, donde `<PID>` es el ID del proceso padre de Claude Code descubierto recorriendo la ascendencia de procesos. Ejemplo:
 
 ```json
 {
   "active": true,
   "iteration": 3,
   "max_iterations": 20,
-  "term_session_id": "c387e44a-afcd-4c0d-95da-5dc7cd2d8b22",
-  "started_at": "2026-04-10T12:00:00Z",
+  "claude_pid": 1119548,
+  "started_at": "2026-04-11T12:00:00Z",
   "prompt": "Fix the flaky auth tests..."
 }
 ```
 
-Cada sesión tiene su propio archivo, indexado por `TERM_SESSION_ID`. Lanzar varios watchdogs en distintas pestañas de terminal funciona sin conflictos.
+Cada sesión de Claude Code tiene un PID distinto, así que **100 watchdogs concurrentes en el mismo directorio de proyecto nunca chocan** — cada uno tiene su propio archivo de estado, y `/watchdog:stop` en cualquiera de ellos solo cancela el bucle de esa sesión concreta.
 
 **Monitorizar los watchdogs activos:**
 
 ```bash
 # Lista todos los archivos de estado por sesión activos en este proyecto
-ls .claude/watchdog.*.local.json
+ls .claude/watchdog.claudepid.*.local.json
 
-# Iteración actual de una sesión concreta
-jq .iteration .claude/watchdog.<SESSION_ID>.local.json
-
-# Estado completo
-jq . .claude/watchdog.<SESSION_ID>.local.json
+# Inspecciona uno con jq o node
+node -e "console.log(JSON.parse(require('fs').readFileSync('.claude/watchdog.claudepid.<PID>.local.json','utf8')))"
 ```
 
 **Matar manualmente todo lo que haya en este proyecto:**
 
 ```bash
-rm -f .claude/watchdog.*.local.json
+rm -f .claude/watchdog.claudepid.*.local.json
 ```
 
 ---
@@ -292,14 +289,11 @@ El clasificador Haiku no es infalible. Un agent atascado que no para de hacer ed
 
 ## Requisitos
 
-Watchdog 1.1.0 es una **reescritura en Node.js**. Nada de bash, nada de jq, nada de POSIX coreutils — solo necesitas `node` y el `claude` CLI. Corre de forma nativa en Linux, macOS y Windows.
-
 | Requisito | Por qué |
 | --- | --- |
 | **Claude Code 2.1+** | Usa el sistema de `Stop hook` y el formato de plugin del marketplace |
-| **`node`** 18+ en el `PATH` | Toda la lógica de los hooks y del setup está escrita en JavaScript. `node:test` (que usa la suite de tests) requiere Node 18+ |
+| **`node`** 18+ en el `PATH` | Runtime de los hooks y scripts de setup del plugin |
 | **`claude` CLI** en el `PATH` | Se usa para la llamada headless de clasificación con Haiku. Tiene que estar autenticado (OAuth o `ANTHROPIC_API_KEY`) |
-| Variable de entorno **`TERM_SESSION_ID`** | Indexa el archivo de estado por sesión. La definen la mayoría de emuladores de terminal (iTerm2, WezTerm, terminales modernas de Linux). Workaround si no está definida: `export TERM_SESSION_ID=$(node -e "console.log(require('crypto').randomUUID())")` antes de lanzar `claude`. |
 
 ### Instalar dependencias
 
@@ -347,16 +341,13 @@ scoop install nodejs-lts
 # o bájate el instalador desde https://nodejs.org
 ```
 
-No hace falta WSL2 ni Git Bash — Watchdog 1.1.0 corre directo en Windows nativo.
-
 ### Soporte de plataformas
 
 | Plataforma | Estado |
 | --- | --- |
 | Linux (Node 18 / 20 / 22) | ✅ Probado en CI |
 | macOS (Node 18 / 20 / 22) | ✅ Probado en CI |
-| Windows (Node 18 / 20 / 22) | ✅ Probado en CI (PowerShell / cmd nativo, sin WSL2) |
-| WSL2 en Windows | ✅ Funciona (es Linux) |
+| Windows (Node 18 / 20 / 22) | ✅ Probado en CI |
 
 ---
 
@@ -382,18 +373,21 @@ claude-code-watchdog/
 ├── lib/                     # módulos compartidos (reutilizados por todos los entry points)
 │   ├── constants.js         # patrón del path del estado, tokens marcadores, plantillas de prompt
 │   ├── log.js               # diagnósticos por stderr
-│   ├── stdin.js             # lector síncrono de stdin cross-platform
+│   ├── stdin.js             # lector síncrono de stdin
 │   ├── state.js             # ciclo de vida atómico del archivo de estado
 │   ├── transcript.js        # parser JSONL + extracción de herramientas del turno actual
-│   └── judge.js             # subproceso headless de Haiku + parser del veredicto
+│   ├── judge.js             # subproceso headless de Haiku + parser del veredicto
+│   └── claude-pid.js        # recorrido de la ascendencia de procesos
 ├── test/                    # tests unitarios + de integración con node:test
 │   ├── fixtures/            # fixtures JSONL de transcripts
 │   ├── transcript.test.js
 │   ├── state.test.js
 │   ├── judge.test.js
+│   ├── claude-pid.test.js
 │   ├── setup.test.js
 │   ├── stop-watchdog.test.js
-│   └── stop-hook.test.js
+│   ├── stop-hook.test.js
+│   └── stop-hook-haiku.test.js
 ├── .github/                 # workflow de CI (matriz node --test, jsonlint, markdownlint) + plantillas de issue/PR
 ├── .gitattributes           # fuerza los finales de línea LF
 ├── LICENSE                  # Apache License 2.0
@@ -402,32 +396,6 @@ claude-code-watchdog/
 └── README.{zh,ja,ko,es,vi,pt}.md  # traducciones
 ```
 
-## Tests
-
-Watchdog 1.1.0 viene con 59 tests automatizados usando el runner `node:test` integrado de Node — sin dependencias externas. Lánzalos desde la raíz del repo.
-
-**Node 22+:**
-
-```bash
-node --test 'test/*.test.js'
-```
-
-**Node 18 / 20** (el soporte de globs se añadió en Node 21, así que o dejas que tu shell expanda el patrón, o listas los archivos a mano):
-
-```bash
-node --test test/*.test.js
-```
-
-Ejecuta solo un archivo:
-
-```bash
-node --test test/transcript.test.js
-```
-
-El CI corre la suite completa en `ubuntu-latest`, `macos-latest` y `windows-latest` con Node 18 / 20 / 22 en cada push y pull request.
-
----
-
 ## Inspirado en
 
 Watchdog es un trabajo derivado del plugin [**ralph-loop**](https://github.com/anthropics/claude-plugins-official/tree/main/plugins/ralph-loop) de Anthropic (Apache License 2.0, © Anthropic, PBC). El `ralph-loop` original usaba un protocolo con etiquetas XML `<promise>COMPLETE</promise>` donde el agent declaraba explícitamente haber terminado.
@@ -439,9 +407,9 @@ Watchdog mantiene el mecanismo central — un `Stop hook` que vuelve a inyectar
 | **Disparador de salida** | El clasificador headless con Haiku es el **único** juez. Lee la entrada completa de cada invocación de herramienta y decide semánticamente si se modificó directamente algún archivo del proyecto. | El agent tiene que emitir una etiqueta XML `<promise>…</promise>` en su texto final. La frase dentro de las etiquetas es configurable vía `--completion-promise "…"` (por ejemplo `COMPLETE`, `DONE`). Un grep en el `Stop hook` busca la cadena exacta. |
 | **Precondición de salida** | Hay que haber llamado a herramientas **Y** que Haiku diga `NO_FILE_CHANGES` | Basta con que coincida el texto del `<promise>`. El agent puede hacer trampa emitiendo la etiqueta antes de tiempo; la única defensa de ralph-loop es un prompt que le pide al agent que no mienta. |
 | **Visibilidad para el agent** | Completamente oculto (sin systemMessage, sin banner, diagnósticos solo por stderr) | Al agent se le informa del bucle y del protocolo del promise |
-| **Ámbito del estado** | Archivo por sesión, indexado por `TERM_SESSION_ID` | Archivo único de estado a nivel de proyecto |
+| **Ámbito del estado** | Un archivo de estado por cada sesión de Claude Code — sin límite de watchdogs concurrentes en el mismo proyecto | Un solo archivo de estado por proyecto — solo UN ralph-loop puede correr por proyecto a la vez |
 | **Formato del archivo de estado** | JSON (parseado con `JSON.parse` nativo) | Markdown con frontmatter YAML (parseado con sed/awk/grep) |
-| **Runtime** | Node.js 18+ — cross-platform (Linux, macOS, Windows nativo) | Bash + jq + POSIX coreutils — solo Unix |
+| **Runtime** | Node.js 18+ | Bash + jq + POSIX coreutils |
 
 Ver [`NOTICE`](./NOTICE) para la atribución completa y el listado detallado de modificaciones.