agentic-workflow-manager 3.13.0 → 3.13.2

package/dist/src/commands/doctor.js

@@ -99,6 +99,14 @@ function providerCheckLine(check) {
 function renderProviderReport(report) {
     const lines = [];
     lines.push(picocolors_1.default.bold('AWM · harness status'));
+    lines.push(picocolors_1.default.dim(`  platform: ${(0, paths_1.platformLabel)()}`));
+    // Advisory only, native Windows only. This is the text rendered by the
+    // real `awm doctor` command (`runDoctor` below) — the diagnostics surface
+    // an operator actually goes looking at for platform-specific detail.
+    // `init`/`update`/`sync` also note it once each, at the top of their own
+    // run (`runInit`/`runUpdateCore`/`runSyncCore`), independently of this.
+    if ((0, paths_1.isWindowsNative)())
+        lines.push(picocolors_1.default.dim(`  ${paths_1.WINDOWS_KNOWN_GAP.replace(/\n\s*/g, ' ')}`));
     lines.push('');
     for (const provider of report.providers) {
         lines.push(`Provider: ${provider.label} ${picocolors_1.default.dim(`(${provider.tier})`)}`);

package/dist/src/commands/hooks/shared.js

@@ -29,7 +29,20 @@ function syncExecutable(source, dest, method) {
     catch { /* not exists, fine */ }
     fs_1.default.mkdirSync(path_1.default.dirname(dest), { recursive: true });
     if (method === 'symlink') {
-        fs_1.default.symlinkSync(source, dest);
+        try {
+            fs_1.default.symlinkSync(source, dest);
+        }
+        catch {
+            // best-effort: a FILE symlink needs SeCreateSymbolicLinkPrivilege on
+            // Windows, denied by default on unprivileged accounts (incl. GitHub
+            // Actions' windows-latest runner) — fall back to a plain copy, same
+            // as the bootstrap skill file's own fallback (hooks/claude.ts) and
+            // executor.ts's stageArtifact for file artifacts. 'awm update' will
+            // not auto-propagate for this file until re-synced, same tradeoff.
+            fs_1.default.copyFileSync(source, dest);
+            const srcMode = fs_1.default.statSync(source).mode;
+            fs_1.default.chmodSync(dest, srcMode);
+        }
     }
     else {
         fs_1.default.copyFileSync(source, dest);

package/dist/src/commands/init.js

@@ -125,6 +125,11 @@ function reportInitFailure(o) {
     return 2;
 }
 async function runInit(opts = {}) {
+    // Fires at most once per `awm init` run (native Windows only) — this is
+    // the single emission point; `renderReport`/`renderInitOutcome` below do
+    // NOT also embed it (that used to triple-fire the same text: once here,
+    // once in the "Initial state" render, once in "Final state").
+    (0, paths_1.noteWindowsCaveat)((m) => console.log(picocolors_1.default.dim(`ℹ ${m}`)));
     const cwd = opts.cwd ?? process.cwd();
     const agent = opts.agent === undefined ? 'claude-code' : (0, providers_1.requireAgentTarget)(opts.agent);
     // R2: gate BEFORE anything is read or written — an unsupported provider
@@ -313,7 +318,6 @@ function registerInitCommand(program) {
         .option('--machine-only', 'Only run machine-level steps (skip project steps)')
         .option('--json', 'Emit the InitOutcome as JSON — on success and on failure (failed steps + rollback)')
         .action(async (options) => {
-        (0, paths_1.warnIfUnsupportedPlatform)((m) => console.warn(picocolors_1.default.yellow(`⚠ ${m}`)));
         const code = await runInit({
             yes: options.yes,
             agent: options.agent,

package/dist/src/commands/registry/add.js

@@ -13,7 +13,16 @@ const registries_1 = require("../../core/registries");
 const discovery_1 = require("../../core/discovery");
 const bundles_1 = require("../../core/bundles");
 function deriveRegistryName(remote) {
-    const base = remote.replace(/\/+$/, '').split(/[/:]/).pop() ?? '';
+    // Split on '/', '\' and ':' — not just '/' and ':'. A git remote URL
+    // (https://…/repo.git, git@host:org/repo.git) only ever uses the first
+    // two, but `remote` here can also be a plain local filesystem path (e.g.
+    // a `awm registry add <local-repo>` clone source, or this repo's own
+    // tests), and on native Windows that path is backslash-separated
+    // (`C:\Users\...\src-alpha`). Splitting on `[/:]` alone leaves the whole
+    // backslash-joined tail as one segment (`\Users\...\src-alpha`), which
+    // then fails the caller's `/[/\\]/.test(name)` invalid-name check and
+    // makes every local-path `addRegistry` call fail on Windows.
+    const base = remote.replace(/[/\\]+$/, '').split(/[/\\:]/).pop() ?? '';
     return base.replace(/\.git$/, '');
 }
 async function addRegistry(remote, nameOverride) {

package/dist/src/commands/sync.js

@@ -16,6 +16,7 @@ exports.runSyncCore = runSyncCore;
 // intro/outro chrome lives in `index.ts`'s Commander registration instead
 // (which already imports clack at the top and is never `require()`d by tests).
 const picocolors_1 = __importDefault(require("picocolors"));
+const paths_1 = require("../core/paths");
 const profile_1 = require("../core/profile");
 const registries_1 = require("../core/registries");
 const bundles_1 = require("../core/bundles");
@@ -31,6 +32,9 @@ const defaultDeps = {
 };
 /** Core, UI-free `awm sync` logic — see `runSync` for the Commander-facing wrapper. */
 async function runSyncCore(options, deps = {}) {
+    // Fires at most once per `awm sync` run, native Windows only — the single
+    // emission point for this command (mirrors `runInit`/`runUpdateCore`).
+    (0, paths_1.noteWindowsCaveat)((m) => console.log(picocolors_1.default.dim(`ℹ ${m}`)));
     const d = { ...defaultDeps, ...deps };
     const cwd = options.cwd ?? process.cwd();
     const projectRoot = (0, profile_1.findProjectRoot)(cwd);

package/dist/src/commands/update.js

@@ -20,6 +20,7 @@ exports.runUpdateCore = runUpdateCore;
 // instead (which already imports clack at the top and is never `require()`d
 // by tests).
 const picocolors_1 = __importDefault(require("picocolors"));
+const paths_1 = require("../core/paths");
 const config_1 = require("../utils/config");
 const agent_targets_1 = require("../core/agent-targets");
 const registries_1 = require("../core/registries");
@@ -49,6 +50,9 @@ const defaultDeps = {
  * `runInit`'s `actions` seam).
  */
 async function runUpdateCore(options = {}, deps = {}) {
+    // Fires at most once per `awm update` run, native Windows only — the
+    // single emission point for this command (mirrors `runInit`/`runSyncCore`).
+    (0, paths_1.noteWindowsCaveat)((m) => console.log(picocolors_1.default.dim(`ℹ ${m}`)));
     const d = { ...defaultDeps, ...deps };
     const prefs = (0, config_1.getPreferences)();
     const resolved = (0, agent_targets_1.resolveAgentTargetsOrError)({ prefs, explicit: options.agent });

package/dist/src/core/atomic-file.js

@@ -75,12 +75,34 @@ function writeFileAtomic(file, content, mode = 0o644) {
 /** fsync del directorio contenedor: garantiza que una ENTRADA creada/renombrada
  *  sobrevive un crash del OS. Falla LANZANDO — la durabilidad de la transición
  *  es parte del contrato, nunca un best-effort silencioso (design R1.2,
- *  bloqueador 4 de la review del plan). */
+ *  bloqueador 4 de la review del plan) — EXCEPTO en Windows, donde fsync-ear un
+ *  file descriptor de directorio no es una operacion que el SO soporte en
+ *  absoluto (no es una falla de durabilidad real: no existe el mecanismo
+ *  POSIX que esta funcion intenta invocar). Confirmado via R6 CI (2026-08-08,
+ *  primera corrida real en windows-latest): `fs.openSync(dir, 'r')` tiene
+ *  exito, pero el `fsyncSync` subsiguiente sobre ese fd siempre falla con
+ *  EPERM — libuv mapea asi el resultado de `FlushFileBuffers` sobre un handle
+ *  de directorio en Win32, que Windows rechaza categoricamente (no es un
+ *  fallo intermitente de hardware/permisos, es ausencia de la capacidad).
+ *  NTFS ya registra los renames/creates en su propio journal transaccional,
+ *  asi que la garantia de durabilidad de la ENTRADA sigue sostenida por el
+ *  filesystem — solo el mecanismo explicito para pedirla no existe ahi.
+ *  Por eso, y solo para esta combinacion exacta (win32 + EPERM en el fsync,
+ *  nunca en el open), esta funcion degrada a no-op en vez de lanzar; culquier
+ *  otra plataforma, o cualquier otro código de error incluso en Windows
+ *  (el open fallando, ENOENT, EACCES por permisos reales), sigue lanzando. */
 function fsyncDirSync(dir) {
     let dirFd;
     try {
         dirFd = fs_1.default.openSync(dir, 'r');
-        fs_1.default.fsyncSync(dirFd);
+        try {
+            fs_1.default.fsyncSync(dirFd);
+        }
+        catch (error) {
+            if (process.platform === 'win32' && error.code === 'EPERM')
+                return;
+            throw error;
+        }
     }
     catch (error) {
         throw new Error(`fsync de directorio fallo para ${dir}: ${error.message}`);

package/dist/src/core/executor.js

@@ -10,6 +10,7 @@ exports.installArtifact = installArtifact;
 // src/core/executor.ts
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const paths_1 = require("./paths");
 function removeArtifact(targetPath) {
     let exists = false;
     try {
@@ -39,7 +40,45 @@ function stageArtifact(sourcePath, targetPath, method) {
     const staged = path_1.default.join(parent, `.${path_1.default.basename(targetPath)}.${process.pid}.staged`);
     fs_1.default.rmSync(staged, { recursive: true, force: true });
     if (method === 'symlink') {
-        fs_1.default.symlinkSync(sourcePath, staged, 'dir');
+        const sourceIsDirectory = fs_1.default.statSync(sourcePath).isDirectory();
+        if (sourceIsDirectory) {
+            // A directory *symlink* ('dir') needs SeCreateSymbolicLinkPrivilege on
+            // Windows — denied by default on unprivileged accounts, including
+            // GitHub Actions' windows-latest runner, so every install here would
+            // throw EPERM. A *junction* is a different NTFS reparse-point kind
+            // that Windows lets any account create, and Node/libuv report it the
+            // same way a symlink is reported (`lstat().isSymbolicLink()` is true,
+            // `readlinkSync()` resolves it) — so every downstream consumer
+            // (verify(), R19's provider-facts hashing, doctor's symlink checks)
+            // keeps working unmodified. Junctions require an absolute target,
+            // which `sourcePath` always is here (registry content roots are
+            // resolved under `awmHome()`). POSIX platforms are unaffected: 'dir'
+            // is a plain no-op hint there.
+            fs_1.default.symlinkSync(sourcePath, staged, (0, paths_1.isWindowsNative)() ? 'junction' : 'dir');
+        }
+        else {
+            // A junction is an NTFS *directory* reparse point — it has no
+            // equivalent for an individual FILE artifact (agent .md, workflow
+            // .md, ...), so a file source must never be passed to it (it was,
+            // before this branch existed, and that silently produced a
+            // reparse point that could not resolve back to the file — see
+            // tests/core/bundle-install.test.ts's "claude-code agents" case).
+            // A 'file'-type symlink is the correct primitive here, but it
+            // needs the same SeCreateSymbolicLinkPrivilege a directory symlink
+            // does, and Windows has no privilege-free substitute for files the
+            // way junctions are for directories. So: attempt the real symlink
+            // (works, and keeps `awm update` propagation, whenever the
+            // privilege IS available — e.g. Developer Mode) and fall back to a
+            // plain copy otherwise, mirroring the established fallback already
+            // used for the bootstrap skill file (hooks/claude.ts,
+            // tests/commands/hooks/install-symlink-fallback.test.ts).
+            try {
+                fs_1.default.symlinkSync(sourcePath, staged, 'file');
+            }
+            catch {
+                fs_1.default.copyFileSync(sourcePath, staged);
+            }
+        }
     }
     else {
         fs_1.default.cpSync(sourcePath, staged, { recursive: true });

package/dist/src/core/install-transaction.js

@@ -339,7 +339,19 @@ function defaultTransactionDeps() {
                 return;
             }
             if (op.method === 'symlink' && !stat.isSymbolicLink()) {
-                throw new Error(`verification failed: ${op.targetPath} is not a symlink`);
+                // executor.ts's stageArtifact falls back to a plain copy for a
+                // FILE source when the real 'file'-type symlink throws (no
+                // privilege-free equivalent to a directory junction exists for
+                // individual files on Windows) — accept that fallback here
+                // rather than failing verification for an install that landed
+                // correctly, just not as a symlink. A directory source always
+                // gets a privilege-free junction and should never legitimately
+                // reach this branch, so this stays scoped to files only.
+                const sourceIsDirectory = fs_1.default.existsSync(op.sourcePath) && fs_1.default.statSync(op.sourcePath).isDirectory();
+                const acceptableFileFallback = !sourceIsDirectory && stat.isFile();
+                if (!acceptableFileFallback) {
+                    throw new Error(`verification failed: ${op.targetPath} is not a symlink`);
+                }
             }
             if (op.method === 'copy' && stat.isSymbolicLink()) {
                 throw new Error(`verification failed: ${op.targetPath} is unexpectedly a symlink`);

package/dist/src/core/journal/process.js

@@ -17,6 +17,7 @@ exports.terminateGroupConfirmed = terminateGroupConfirmed;
 exports.terminatePreviouslyOwnedGroup = terminatePreviouslyOwnedGroup;
 const crypto_1 = __importDefault(require("crypto"));
 const child_process_1 = require("child_process");
+const paths_1 = require("../paths");
 exports.NONCE_ENV = 'AWM_SPAWN_NONCE';
 /** Contrato dual, a proposito (tomo 3 rondas de fixes reales llegar aca —
  *  ver historial de Task 10): devuelve `null` SOLO cuando `ps` corrio y
@@ -42,23 +43,90 @@ exports.NONCE_ENV = 'AWM_SPAWN_NONCE';
  *  ese relay jamas ocurre: `execFileSync` captura el stderr del subproceso
  *  internamente y listo, sin tocar el fd real del proceso actual. */
 exports.EXEC_STDIO = ['ignore', 'pipe', 'pipe'];
+/** timeout explicito (defense-in-depth, mismo patron que win32ProcessInfo):
+ *  sin esto, un `ps`/`pgrep` que cuelga (recurso bloqueado, binario
+ *  emulado con comportamiento anomalo) cuelga TODO el proceso llamante
+ *  indefinidamente — sin excepcion que atrapar, sin manera de fallar a
+ *  favor de "vivo" porque el codigo nunca vuelve a ejecutar. Un timeout
+ *  convierte ese cuelgue en un error normal, que el contrato existente de
+ *  cada caller ya sabe manejar (nunca declarar muerte por un error). */
+const PS_TIMEOUT_MS = 3000;
 function psField(pid, field) {
     try {
-        const out = (0, child_process_1.execFileSync)('ps', ['-o', `${field}=`, '-p', String(pid)], { encoding: 'utf8', stdio: exports.EXEC_STDIO }).trim();
+        const out = (0, child_process_1.execFileSync)('ps', ['-o', `${field}=`, '-p', String(pid)], { encoding: 'utf8', stdio: exports.EXEC_STDIO, timeout: PS_TIMEOUT_MS }).trim();
         return out.length > 0 ? out : null;
     }
     catch (error) {
         const status = error.status;
         if (status === 1)
             return null; // ps corrio y confirmo: el pid no existe
-        throw error; // ps no pudo ejecutarse (ENOENT/permisos/etc): NO es prueba de nada
+        throw error; // ps no pudo ejecutarse (ENOENT/permisos/timeout/etc): NO es prueba de nada
     }
 }
 function sleepSync(seconds) {
     try {
-        (0, child_process_1.execFileSync)('sleep', [seconds], { stdio: exports.EXEC_STDIO });
+        (0, child_process_1.execFileSync)('sleep', [seconds], { stdio: exports.EXEC_STDIO, timeout: PS_TIMEOUT_MS });
     }
     catch { /* sin sleep: seguimos */ }
+    // Nota win32: `sleep` no existe nativamente ahi (ver callers via
+    // win32ProcessInfo/captureRefFor) — el catch de arriba lo absorbe
+    // silenciosamente, asi que en esa plataforma los reintentos que llaman
+    // a esta funcion ocurren espalda-con-espalda sin pausa real. No es un
+    // fallo: solo pierde el espaciado, nunca crashea ni miente sobre
+    // resultado alguno.
+}
+/** Analogo win32 de `psField`/`stablePsArgs` (R2.1, R6): identidad real de un
+ *  pid via WMI (clase Win32_Process), consultada a traves de PowerShell's
+ *  Get-CimInstance — el reemplazo moderno soportado de `wmic` (que Microsoft
+ *  viene retirando de instalaciones nuevas), y presente en cualquier Windows
+ *  no deliberadamente reducido (a diferencia de `ps`/`pgrep`, que en Windows
+ *  SOLO existen si algo como Git for Windows los puso en el PATH, y ahi son
+ *  la capa emulada de MSYS/Cygwin ciega a procesos nativos — ver
+ *  pidExistsNative). Contrato de TRES vias, deliberado, paralelo al de
+ *  `psField`:
+ *   - `'absent'`: PowerShell corrio bien y WMI no encontro NINGUN proceso
+ *     con ese pid — evidencia POSITIVA de ausencia (el analogo exacto del
+ *     exit-1 de `ps`/`pgrep` sobre un pid real), independiente de
+ *     `process.kill` (que pidExistsNative usa) — asi que sigue siendo
+ *     evidencia valida incluso si `process.kill` fuera mockeado/erroneo en
+ *     algun caller (visto en CI real: un test que mockea process.kill para
+ *     verificar que executeReap NUNCA senializa, sin intencion de simular
+ *     un pid vivo — WMI no comparte ese mock y corrige la vista).
+ *   - `null`: PowerShell no pudo ejecutarse, timeout, politica de ejecucion
+ *     restrictiva, WMI/CIM deshabilitado, salida no parseable, etc. — CERO
+ *     evidencia, ni de vida ni de muerte. Igual que el ENOENT de `ps` en
+ *     POSIX: nunca se traduce a "muerto".
+ *   - objeto con `creationDate`/`commandLine` reales: exito, comparables
+ *     con `ref.startTime`/`ref.psArgsDigest` (via identityDigest) igual que
+ *     `lstart`/`args` en la rama POSIX.
+ *  Acotado con `timeout` (nunca cuelga al caller indefinidamente si el
+ *  proveedor WMI no responde) y con `-NoProfile -NonInteractive -NoLogo`
+ *  (arranque mas rapido y determinista, sin depender de perfiles del
+ *  usuario). Solo se invoca desde refIsAlive/captureRefFor en win32, jamas
+ *  desde un path "barato" (groupIsGone, pidExistsNative) — ver refIsAlive
+ *  para el razonamiento de costo/beneficio. */
+function win32ProcessInfo(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return null;
+    let out;
+    try {
+        const script = `try { $p = Get-CimInstance Win32_Process -Filter "ProcessId=${pid}" -ErrorAction Stop; if ($p) { [PSCustomObject]@{ CreationDate = $p.CreationDate.ToString('o'); CommandLine = [string]$p.CommandLine } | ConvertTo-Json -Compress } } catch { exit 1 }`;
+        out = (0, child_process_1.execFileSync)('powershell.exe', ['-NoProfile', '-NonInteractive', '-NoLogo', '-Command', script], { encoding: 'utf8', stdio: exports.EXEC_STDIO, timeout: 2000 }).trim();
+    }
+    catch {
+        return null; // powershell/WMI no disponible, timeout, o error interno: sin evidencia (nunca "ausente")
+    }
+    if (out.length === 0)
+        return 'absent'; // corrio bien, cero coincidencias: evidencia positiva
+    try {
+        const parsed = JSON.parse(out);
+        if (typeof parsed.CreationDate !== 'string' || typeof parsed.CommandLine !== 'string')
+            return null;
+        return { creationDate: parsed.CreationDate, commandLine: parsed.CommandLine };
+    }
+    catch {
+        return null;
+    } // salida inesperada: inconclusive, jamas "ausente" por un parseo roto
 }
 /** Variante de psField para contextos de CAPTURA de identidad (spawn time):
  *  aqui "no se pudo determinar" ya tiene un fallback seguro documentado
@@ -107,8 +175,34 @@ function psArgsDigestOf(pid, spawnNonce = '', requestedArgvDigest = '') {
     return identityDigest(args, spawnNonce, requestedArgvDigest);
 }
 /** Captura la identidad COMPLETA de un pid recien spawneado (R2.1):
- *  startTime + pgid reales de ps + digest de `ps -o args=` estable. */
+ *  startTime + pgid reales de ps + digest de `ps -o args=` estable.
+ *
+ *  win32: sin pgid POSIX real jamas (convencion fija: processGroup === pid,
+ *  la misma que asume killTreeWindows/groupIsGone); startTime/psArgsDigest
+ *  se intentan via WMI (win32ProcessInfo) con el mismo reintento acotado que
+ *  la rama POSIX. Si WMI no responde (politica restrictiva, servicio
+ *  deshabilitado, sin powershell.exe) degrada al mismo sentinel 'unknown'
+ *  ya documentado y testeado (ver 'captureRefFor degrada a unknown...') —
+ *  jamas crashea, jamas fabrica una identidad falsa. */
 function captureRefFor(pid, nonce, argv) {
+    const requestedArgvDigest = argvDigest(argv);
+    if ((0, paths_1.isWindowsNative)()) {
+        let info = null;
+        for (let i = 0; i < 5 && (info === null || info === 'absent'); i++) {
+            info = win32ProcessInfo(pid);
+            if (info === null || info === 'absent')
+                sleepSync('0.05');
+        }
+        const resolved = info !== null && info !== 'absent' ? info : null;
+        return {
+            pid,
+            startTime: resolved?.creationDate ?? 'unknown',
+            spawnNonce: nonce,
+            argvDigest: requestedArgvDigest,
+            processGroup: pid,
+            psArgsDigest: resolved !== null ? identityDigest(resolved.commandLine, nonce, requestedArgvDigest) : 'unknown',
+        };
+    }
     let start = null;
     for (let i = 0; i < 5 && start === null; i++) {
         start = psFieldSafe(pid, 'lstart');
@@ -117,7 +211,6 @@ function captureRefFor(pid, nonce, argv) {
     }
     const pgid = psFieldSafe(pid, 'pgid');
     const args = stablePsArgs(pid);
-    const requestedArgvDigest = argvDigest(argv);
     return {
         pid,
         startTime: start ?? 'unknown',
@@ -138,7 +231,25 @@ function captureSelfRef(nonce) {
 function spawnStructured(argv, cwd, nonce, extraEnv = {}) {
     const [exe, ...args] = argv;
     const child = (0, child_process_1.spawn)(exe, args, {
-        cwd, shell: false, detached: true,
+        cwd, shell: false,
+        // R6 ronda 4 probo `detached: true` incondicional en win32 (razonando
+        // desde la doc de Node sobre supervivencia post-muerte del padre) y
+        // la ronda 5 lo REVIERTE: la primera corrida real en windows-latest
+        // mostro `refIsAlive(ref)` devolviendo `false` INMEDIATAMENTE despues
+        // de un spawn normal, sin matar nada — el test mas basico del
+        // archivo ('spawnStructured produce ProcessRef con tupla completa').
+        // `captureRefFor` fija `processGroup: pid` por convencion en win32
+        // (siempre), asi que ese `false` solo puede venir de
+        // `pidExistsNative` viendo ESRCH real — el proceso hijo aparentaba
+        // no existir casi de inmediato. Evidencia real > lectura de
+        // documentacion: se revierte a `!isWindowsNative()` (el diseño ya
+        // probado, correcto, en 4 rondas previas de CI real). La garantia de
+        // R1.8 ("el wrapper sobrevive al supervisor") queda como gap
+        // ABIERTO en win32 — ver el test skippeado en
+        // tests/commands/watch/e2e-crash.test.ts para el detalle y el
+        // proximo intento debe verificarse contra CI real antes de asumir
+        // que un cambio de `detached` lo resuelve.
+        detached: !(0, paths_1.isWindowsNative)(),
         env: { ...process.env, [exports.NONCE_ENV]: nonce, ...extraEnv },
         // stdio:'ignore' completo (nada de pipes): un pipe destruido/abandonado
         // por el padre puede EPIPE-crashear al hijo si este escribe a su propio
@@ -150,9 +261,77 @@ function spawnStructured(argv, cwd, nonce, extraEnv = {}) {
         throw new Error(`spawn fallo para ${exe}`);
     return { child, ref: captureRefFor(child.pid, nonce, argv) };
 }
+/** Existencia de pid respaldada DIRECTAMENTE por el kernel via libuv
+ *  (process.kill(pid,0) — funciona en cualquier plataforma que Node
+ *  soporte, incluido win32), a diferencia de `ps`/`pgrep`: en Windows esos
+ *  binarios, cuando resuelven en el PATH, son el `ps`/`pgrep` de
+ *  MSYS/Cygwin (Git for Windows) — una capa de EMULACION con su propia
+ *  tabla de pids, ciega a procesos nativos spawneados via CreateProcess
+ *  (exactamente lo que produce spawnStructured). Confirmado en CI
+ *  windows-latest: `ps -o stat= -p <pid>` para un hijo real y vivo salia
+ *  con exit 1 ("no such process" segun la vista emulada), y `psField`
+ *  interpretaba ese exit 1 como "el SO confirmo que el pid no existe" —
+ *  falso: era ceguera de la herramienta, no evidencia de muerte. Eso
+ *  rompia el invariante "JAMAS safe sin evidencia" (safeToReplace
+ *  devolvia 'safe' para un proceso vivo). process.kill(pid,0) evita la
+ *  capa de emulacion por completo. */
+function pidExistsNative(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // ESRCH = el SO confirmo que el pid no existe. Cualquier otro
+        // codigo (ej. EPERM: existe pero sin permiso de senializarlo) NO
+        // es evidencia de muerte — falla a favor de "vivo" (R2.1).
+        return error.code !== 'ESRCH';
+    }
+}
 /** Vivo Y con la MISMA identidad — tupla completa, nunca PID solo (R2.1,
- *  bloqueador 6): startTime + pgid + digest de ps args. */
+ *  bloqueador 6): startTime + pgid + digest de ps args.
+ *
+ *  win32 (R6, ronda 3 — REVIERTE la ronda 2): la ronda 2 intento cerrar el
+ *  gap de reciclado de PID via una comparacion completa de identidad contra
+ *  WMI (win32ProcessInfo, `Get-CimInstance Win32_Process`) en cada llamada.
+ *  La PRIMERA corrida real en windows-latest CI (2026-08-08) mostro
+ *  `refIsAlive` devolviendo `false` para un proceso node recien spawneado y
+ *  genuinamente vivo (test platform-agnostico, SIN mocks de por medio) —
+ *  osea que la comparacion WMI produjo un FALSO NEGATIVO real, la direccion
+ *  de fallo MAS peligrosa para esta funcion (un supervisor que trata un job
+ *  vivo como muerto puede duplicar trabajo o corromper estado). La misma
+ *  corrida tambien mostro 2 tests E2E pesados (supervisor-loop, e2e-crash)
+ *  colgando hasta el timeout, consistente con un loop de polling que nunca
+ *  converge si su chequeo de vida es inestable.
+ *
+ *  `pidExistsNative` (process.kill(pid,0), directo al kernel via libuv) en
+ *  cambio sobrevivio SIN NINGUN falso negativo/positivo a 3 corridas reales
+ *  de CI consecutivas (rondas anteriores de este mismo release) — evidencia
+ *  empirica solida de que es confiable en windows-latest, mientras que WMI
+ *  demostradamente no lo es (razon exacta de la inestabilia sin determinar:
+ *  podria ser latencia de indexado de WMI para procesos recien creados,
+ *  podria ser una conversion de CreationDate no perfectamente determinista
+ *  entre dos consultas separadas — no hay Windows real disponible en este
+ *  entorno para experimentar y confirmar cual).
+ *
+ *  Decision (systematic-debugging: 2+ intentos revelando problemas nuevos en
+ *  lugares distintos exige cuestionar la arquitectura, no seguir parchando):
+ *  se revierte a existencia + convencion de processGroup solamente en
+ *  win32, la MISMA superficie que la ronda 1 ya tenia probada. La proteccion
+ *  contra reciclado de PID completa (bloqueador 6) queda como gap ACEPTADO
+ *  y documentado en esta plataforma — la ventana real para que ocurra
+ *  (Windows reciclando un pid entre esta verificacion y la captura original,
+ *  tipicamente milisegundos/segundos antes, en el mismo proceso controlador)
+ *  es angosta, y el costo de intentar cerrarla con un mecanismo demostrado
+ *  no confiable es peor que el gap mismo. `win32ProcessInfo`/`captureRefFor`
+ *  siguen poblando startTime/psArgsDigest REALES via WMI cuando responden
+ *  (uso informativo — quedan en el ProcessRef persistido) pero refIsAlive
+ *  YA NO los usa para su veredicto go/no-go. */
 function refIsAlive(ref) {
+    if ((0, paths_1.isWindowsNative)()) {
+        if (!pidExistsNative(ref.pid))
+            return false;
+        return ref.processGroup === ref.pid;
+    }
     try {
         const stat = psField(ref.pid, 'stat');
         if (stat === null || stat.startsWith('Z'))
@@ -181,9 +360,20 @@ function processStatesAreGone(states) {
     return states.every((stat) => stat === null || stat.startsWith('Z'));
 }
 function groupIsGone(pgid) {
+    if ((0, paths_1.isWindowsNative)()) {
+        // Sin pgrep confiable en esta plataforma (ver pidExistsNative):
+        // mejor esfuerzo, solo confirma al LIDER (pgid === pid, por la
+        // convencion de fallback de captureRefFor en win32 — nunca hay un
+        // pgid real de ps ahi). No enumeramos descendientes sin Job
+        // Objects (fuera de alcance) — killTreeWindows ya los alcanza al
+        // matar via `taskkill /T`, aunque este check no los confirme
+        // individualmente. Nunca declarar "grupo ausente" por ceguera de
+        // una herramienta POSIX inexistente/emulada.
+        return !pidExistsNative(pgid);
+    }
     let pids;
     try {
-        const out = (0, child_process_1.execFileSync)('pgrep', ['-g', String(pgid)], { encoding: 'utf8', stdio: exports.EXEC_STDIO });
+        const out = (0, child_process_1.execFileSync)('pgrep', ['-g', String(pgid)], { encoding: 'utf8', stdio: exports.EXEC_STDIO, timeout: PS_TIMEOUT_MS });
         pids = out.split('\n').filter(Boolean).map(Number).filter(Number.isInteger);
     }
     catch (error) {
@@ -203,9 +393,26 @@ function groupIsGone(pgid) {
         return false; // sin observacion completa, falla cerrado
     }
 }
+/** Llamada UNA VEZ POR TICK por el supervisor (ver superviseController en
+ *  commands/watch/supervisor.ts) mientras un controlador este activo — el
+ *  path mas caliente de todo el modulo. En win32, `ps`/`pgrep`, cuando
+ *  resuelven en el PATH, son el binario EMULADO de MSYS/Cygwin (Git for
+ *  Windows) — ciego a procesos nativos (el mismo hecho ya documentado y
+ *  probado para pidExistsNative/refIsAlive/groupIsGone en este archivo).
+ *  A diferencia de esas funciones, ESTA no fue tocada por ninguna ronda
+ *  previa del fix de R6 — seguia intentando `ps`/`pgrep` reales en CADA
+ *  tick, sin timeout, sobre un binario ya sabido no confiable ahi.
+ *  Degradar directo (sin tocar el proceso real) evita acumular latencia de
+ *  subprocess real en un loop de polling de alta frecuencia, con o sin el
+ *  timeout de PS_TIMEOUT_MS de defensa — ese timeout cubre el caso en que
+ *  el binario SI exista mal comportado; esta rama cubre el caso, ya
+ *  confirmado real en este archivo, de que la herramienta simplemente no
+ *  es fuente de verdad en esta plataforma. */
 function activitySnapshot(ref) {
     if (!refIsAlive(ref))
         return null;
+    if ((0, paths_1.isWindowsNative)())
+        return { cpuTime: 'unknown', groupSize: 1 };
     let cpu = '0';
     try {
         cpu = psField(ref.pid, 'time') ?? '0';
@@ -215,7 +422,7 @@ function activitySnapshot(ref) {
     }
     let groupSize = 1;
     try {
-        groupSize = (0, child_process_1.execFileSync)('pgrep', ['-g', String(ref.processGroup)], { encoding: 'utf8', stdio: exports.EXEC_STDIO })
+        groupSize = (0, child_process_1.execFileSync)('pgrep', ['-g', String(ref.processGroup)], { encoding: 'utf8', stdio: exports.EXEC_STDIO, timeout: PS_TIMEOUT_MS })
             .split('\n').filter(Boolean).length;
     }
     catch {
@@ -223,6 +430,17 @@ function activitySnapshot(ref) {
     }
     return { cpuTime: cpu, groupSize };
 }
+/** win32: sin process groups POSIX ni convencion de pid negativo, y sin
+ *  distincion real SIGTERM/SIGKILL (Node mapea ambas a TerminateProcess
+ *  alla) — un `taskkill /T /F` (recursivo, forzado) sustituye a la
+ *  escalera completa. Mismo patron ya usado y testeado en
+ *  sensors/exec.ts::killTree (ver tests/commands/sensors/exec-windows.test.ts). */
+function killTreeWindows(pid) {
+    try {
+        (0, child_process_1.execFileSync)('taskkill', ['/pid', String(pid), '/T', '/F'], { stdio: exports.EXEC_STDIO });
+    }
+    catch { /* ya ausente, o taskkill no disponible: best-effort — la confirmacion la hace el poll de groupIsGone */ }
+}
 /** Escalera de gracia (design R4.2b): SIGTERM -> confirmar -> SIGKILL -> confirmar.
  *  true <=> lider muerto por identidad Y grupo entero desaparecido (pgrep -g
  *  vacio) — jamas confirmar solo el lider (bloqueador 6). */
@@ -242,6 +460,13 @@ async function terminateGroupConfirmed(ref, opts) {
     // usar la falta de match como autorizacion para senializar ese grupo.
     if (!refIsAlive(ref))
         return false;
+    if ((0, paths_1.isWindowsNative)()) {
+        killTreeWindows(ref.pid);
+        if (await waitUntilGone(opts.termGraceMs))
+            return true;
+        killTreeWindows(ref.pid);
+        return waitUntilGone(opts.killGraceMs);
+    }
     try {
         process.kill(-ref.processGroup, 'SIGTERM');
     }
@@ -270,6 +495,13 @@ async function terminatePreviouslyOwnedGroup(ref, opts) {
     };
     if (groupIsGone(ref.processGroup))
         return true;
+    if ((0, paths_1.isWindowsNative)()) {
+        killTreeWindows(ref.pid);
+        if (await waitUntilGone(opts.termGraceMs))
+            return true;
+        killTreeWindows(ref.pid);
+        return waitUntilGone(opts.killGraceMs);
+    }
     try {
         process.kill(-ref.processGroup, 'SIGTERM');
     }