agentic-workflow-manager 3.12.0 → 3.13.1

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');
     }

package/dist/tests/commands/hooks/install-symlink-fallback.test.js

@@ -56,4 +56,29 @@ describe('hooks/install — skill symlink fallback to copy', () => {
         expect(fs_1.default.lstatSync(skillDest).isSymbolicLink()).toBe(false); // it was copied, not linked
         expect(fs_1.default.readFileSync(skillDest, 'utf-8')).toContain('using-awm');
     });
+    // Regression: syncExecutable (shared.ts) — used for the hook SCRIPT files
+    // (session-start, run-hook.cmd), not just the bootstrap skill above — called
+    // fs.symlinkSync unconditionally when installMethod is 'symlink', with no
+    // EPERM fallback at all. On native Windows without SeCreateSymbolicLinkPrivilege
+    // (the default for GitHub Actions' windows-latest runner), that would throw
+    // out of installHook uninstall, failing the whole `awm init` step. Proves the
+    // same fallback-to-copy this file already established for the skill file also
+    // now covers the script files when the caller actually requests 'symlink'.
+    it('copies the hook scripts when symlink throws (EPERM), instead of throwing out of installHook', () => {
+        const registryRoot = path_1.default.join(tmpHome, 'registry');
+        seedRegistry(registryRoot);
+        symlinkSpy = jest.spyOn(fs_1.default, 'symlinkSync').mockImplementation(() => {
+            const err = new Error('EPERM: operation not permitted, symlink');
+            err.code = 'EPERM';
+            throw err;
+        });
+        const { installHook } = require('../../../src/commands/hooks/install');
+        const result = installHook({ agent: 'claude-code', registryRoot, installMethod: 'symlink' });
+        const scriptDest = path_1.default.join(result.scriptsDir, 'session-start');
+        const wrapperDest = path_1.default.join(result.scriptsDir, 'run-hook.cmd');
+        expect(fs_1.default.existsSync(scriptDest)).toBe(true);
+        expect(fs_1.default.lstatSync(scriptDest).isSymbolicLink()).toBe(false); // copied, not linked
+        expect(fs_1.default.existsSync(wrapperDest)).toBe(true);
+        expect(fs_1.default.lstatSync(wrapperDest).isSymbolicLink()).toBe(false);
+    });
 });

package/dist/tests/commands/hooks/status.test.js

@@ -78,8 +78,23 @@ describe('computeHookStatus', () => {
         fs_1.default.chmodSync(path_1.default.join(tmpHome, '.awm/hooks/session-start'), 0o644);
         const { computeHookStatus } = require('../../../src/commands/hooks/status');
         const result = computeHookStatus('claude-code');
-        expect(result.overall).toBe('DEGRADED');
-        expect(result.checks.sessionStartScript.ok).toBe(false);
+        if (process.platform === 'win32') {
+            // Windows has no POSIX executable-bit concept at all, and this isn't a
+            // gap in computeHookStatus's checkExecutable() — it's Node's own
+            // documented behavior: fs.accessSync(file, X_OK) "has no effect on
+            // Windows (will behave like fs.constants.F_OK)" (Node fs docs). So
+            // chmod(0o644) here only clears write bits, which Windows collapses
+            // into "still not read-only" either way — there was never a distinct
+            // exec permission to remove, and the script remains just as runnable
+            // (via its interpreter/file association) as before the chmod. HEALTHY
+            // is the factually correct report here, not a gap to paper over.
+            expect(result.overall).toBe('HEALTHY');
+            expect(result.checks.sessionStartScript.ok).toBe(true);
+        }
+        else {
+            expect(result.overall).toBe('DEGRADED');
+            expect(result.checks.sessionStartScript.ok).toBe(false);
+        }
     });
     it('throws when agent target has no hooks config', () => {
         const { computeHookStatus } = require('../../../src/commands/hooks/status');
@@ -91,7 +106,12 @@ describe('computeHookStatus', () => {
         // never touching Claude's settings.json path.
         const { computeHookStatus } = require('../../../src/commands/hooks/status');
         const result = computeHookStatus('codex');
-        expect(result.checks.settingsEntry.detail).toContain('.codex/hooks.json');
+        // Separator-agnostic: the detail embeds a real OS path (`path.join`
+        // under the hood), so it's `\` on windows-latest and `/` elsewhere —
+        // assert the two path segments independently rather than one
+        // POSIX-shaped fragment.
+        expect(result.checks.settingsEntry.detail).toContain('.codex');
+        expect(result.checks.settingsEntry.detail).toContain('hooks.json');
         expect(result.checks.bootstrapSkill).toBeUndefined();
         expect(result.checks.runHookWrapper).toBeUndefined();
     });

package/dist/tests/commands/job/exec-wrapper.test.js

@@ -8,6 +8,11 @@ const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const exec_wrapper_1 = require("../../../src/commands/job/exec-wrapper");
 const process_1 = require("../../../src/core/journal/process");
+// Real subprocess spawn + termination + fsync per test; the jest default of
+// 5000ms proved too tight on a loaded windows-latest CI runner (regression:
+// real CI, "Exceeded timeout of 5000 ms"). Same class of issue already fixed
+// in registries-sync.test.ts this round.
+jest.setTimeout(20000);
 describe('exec-wrapper', () => {
     let dir;
     beforeEach(() => { dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-wrap-')); });
@@ -19,7 +24,16 @@ describe('exec-wrapper', () => {
         const identity = JSON.parse(fs_1.default.readFileSync((0, exec_wrapper_1.identityPath)(dir, 'job1', 'nonceA'), 'utf8'));
         expect(identity.wrapper.pid).toBe(process.pid); // ProcessRef REAL del wrapper
         expect(identity.command.pid).toBeGreaterThan(0); // ProcessRef REAL del comando
-        expect(identity.command.psArgsDigest).toMatch(/^[0-9a-f]{16}$/);
+        // hex real cuando la plataforma pudo observar el proceso (ps en
+        // POSIX, WMI/powershell en win32 — ver captureRefFor en
+        // src/core/journal/process.ts); sentinel 'unknown' documentado
+        // cuando esa observacion no estuvo disponible (ps ausente, o en
+        // win32 powershell/WMI restringido/deshabilitado). Mismo criterio
+        // ya establecido en tests/core/journal/process.test.ts — el formato
+        // exacto de este campo nunca es la fuente de verdad de vida/muerte
+        // (esa es refIsAlive), asi que este test no puede exigir mas
+        // certeza de la que la plataforma real puede dar.
+        expect(identity.command.psArgsDigest).toMatch(/^([0-9a-f]{16}|unknown)$/);
         expect(identity.command.processGroup).not.toBe(identity.wrapper.processGroup); // el wrapper puede limpiar el grupo sin matarse
         const result = JSON.parse(fs_1.default.readFileSync((0, exec_wrapper_1.resultPath)(dir, 'job1', 'nonceA'), 'utf8'));
         expect(result.exitCode).toBe(0);

package/dist/tests/commands/job/gate-reconcile.test.js

@@ -272,14 +272,40 @@ describe('reap — limpieza explicita con identidad validada (R2.2)', () => {
         const deadRef = { pid: 999999, startTime: 'gone', spawnNonce: 'n1', argvDigest: 'd', processGroup: 999999, psArgsDigest: 'x' };
         s.jobs['sinRef'] = job({ id: 'sinRef', executionState: 'running' });
         s.jobs['muerto'] = job({ id: 'muerto', executionState: 'running', processRef: deadRef });
-        const killSpy = jest.spyOn(process, 'kill').mockImplementation(() => true);
+        // deadRef.pid (999999) debe comportarse como un pid REALMENTE
+        // ausente ante un sondeo de existencia (signal 0) — igual que en
+        // windows-latest real, donde `isWindowsNative()` es cierto de
+        // verdad y refIsAlive/groupIsGone dependen de pidExistsNative
+        // (process.kill(pid, 0)) como UNICA fuente de veredicto (ronda 3,
+        // ver process.ts). Mockear esto como "siempre exito" incondicional
+        // rompia esa unica fuente de verdad en CI real: pidExistsNative
+        // reportaba "vivo" para un pid que nunca existio, y la escalera de
+        // terminacion quedaba reintentando hasta el timeout del test — no
+        // por una señal real enviada, sino porque nunca podia CONFIRMAR
+        // ausencia. En POSIX este spy ni siquiera se ejercita (refIsAlive
+        // ahi usa ps/pgrep, no process.kill), asi que el fix solo cambia
+        // comportamiento win32.
+        const killSpy = jest.spyOn(process, 'kill').mockImplementation((pid) => {
+            if (pid === deadRef.pid) {
+                const err = new Error('no such process');
+                err.code = 'ESRCH';
+                throw err;
+            }
+            return true;
+        });
         try {
             const killed = await (0, reap_1.executeReap)(s, ['sinRef', 'muerto', 'no-existe']);
             expect(killed).toEqual([]);
-            // no solo el resultado: nunca se INTENTO ninguna señal (R2.1) —
-            // la ausencia de identidad viva confirmada corta antes de llamar
-            // a terminateGroupConfirmed/process.kill, no despues.
-            expect(killSpy).not.toHaveBeenCalled();
+            // no solo el resultado: nunca se envio una señal REAL de
+            // terminacion (R2.1) — la ausencia de identidad viva confirmada
+            // corta antes de llegar a terminateGroupConfirmed. pidExistsNative
+            // SI llama a process.kill(pid, 0) como sondeo de existencia
+            // (signal 0, no una señal real) — eso aparece legitimamente en
+            // este spy y no es evidencia de una señal enviada; se filtra
+            // explicitamente (mismo patron ya aplicado en adapter.test.ts
+            // para execFileSync, narrowing en vez de "cero llamadas").
+            const realSignals = killSpy.mock.calls.filter((call) => call[1] !== 0);
+            expect(realSignals).toEqual([]);
         }
         finally {
             killSpy.mockRestore();

package/dist/tests/commands/preflight/preflight.test.js

@@ -167,8 +167,11 @@ describe('preflight', () => {
         it('reports github + gh available, and does not affect status', () => {
             const dir = make({ manifest: { pack: 'generic', sensors: { security: { enabled: false } } } });
             gitRepo(dir, 'git@github.com:kodria/agentic-workflow.git');
+            // `resolveOnPath('gh')` runs `command -v gh` on POSIX but `where gh` on
+            // win32 (see paths.ts) — match both invocation forms so this test's
+            // "gh is available" fixture holds on windows-latest CI too.
             mockExecSync.mockImplementation(((cmd) => {
-                if (cmd === 'command -v gh')
+                if (cmd === 'command -v gh' || cmd === 'where gh')
                     return Buffer.from('/usr/bin/gh');
                 throw new Error(`not found: ${cmd}`);
             }));
@@ -312,6 +315,81 @@ describe('preflight', () => {
             expect(check(report, 'host').detail).toContain('gitlab detected');
         });
     });
+    describe('sensors-baseline check (advisory — never changes the exit code)', () => {
+        it('nudges toward `awm sensors baseline` when sensors are configured but no baseline exists', () => {
+            // The team-rollout gap this addresses: a legacy repo adopts AWM, sensors get
+            // configured, and the ratchet mechanism exists to snapshot pre-existing debt —
+            // but nothing tells the operator it's there until they hit a wall of red
+            // findings and go looking for it.
+            const dir = make({
+                manifest: { pack: 'js-ts', sensors: { lint: { cmd: 'npx eslint .' } } },
+                bins: ['eslint'],
+                files: ['package.json'],
+            });
+            const report = (0, checks_1.preflight)(dir);
+            expect(check(report, 'sensors-baseline').ok).toBe(true);
+            expect(check(report, 'sensors-baseline').detail).toContain('no baseline yet');
+            expect(check(report, 'sensors-baseline').remedy).toContain('awm sensors baseline');
+            expect(report.status).toBe('ready');
+        });
+        it('reports the no-advisory-needed state when a baseline already exists, without nudging', () => {
+            const dir = make({
+                manifest: { pack: 'js-ts', sensors: { lint: { cmd: 'npx eslint .' } } },
+                bins: ['eslint'],
+                files: ['package.json'],
+            });
+            fs_1.default.mkdirSync(path_1.default.join(dir, '.awm'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(dir, '.awm', 'sensors.baseline.json'), JSON.stringify({ lint: [] }));
+            const report = (0, checks_1.preflight)(dir);
+            expect(check(report, 'sensors-baseline').ok).toBe(true);
+            expect(check(report, 'sensors-baseline').detail).toBe('baseline present');
+            expect(check(report, 'sensors-baseline').remedy).toBeUndefined();
+            expect(report.status).toBe('ready');
+        });
+        it('is omitted entirely when there is no manifest at all — nothing to baseline without sensors', () => {
+            const dir = make();
+            const report = (0, checks_1.preflight)(dir);
+            expect(report.checks.find(c => c.id === 'sensors-baseline')).toBeUndefined();
+            expect(report.status).toBe('not_configured');
+        });
+        it('does not nudge on a deliberate opt-out (every sensor disabled) — nothing to baseline', () => {
+            // Regression: the trigger condition originally checked only manifestExists, so a
+            // repo that deliberately opted out (checkManifest's own documented pattern: every
+            // sensor `enabled: false`) still got told to run `awm sensors baseline` — nothing
+            // to baseline when there's nothing enabled to have findings in the first place.
+            const dir = make({
+                manifest: { pack: 'js-ts', sensors: { lint: { cmd: 'npx eslint .', enabled: false } } },
+            });
+            const report = (0, checks_1.preflight)(dir);
+            expect(check(report, 'sensors-baseline').ok).toBe(true);
+            expect(check(report, 'sensors-baseline').detail).toBe('no enabled sensors — nothing to baseline');
+            expect(check(report, 'sensors-baseline').remedy).toBeUndefined();
+        });
+        it('does not nudge on an unparseable manifest — nothing to baseline', () => {
+            const dir = make({ manifest: '{not valid json' });
+            const report = (0, checks_1.preflight)(dir);
+            expect(check(report, 'sensors-baseline').ok).toBe(true);
+            expect(check(report, 'sensors-baseline').detail).toBe('no enabled sensors — nothing to baseline');
+            expect(check(report, 'sensors-baseline').remedy).toBeUndefined();
+        });
+        it('still nudges when the baseline path exists but is not a readable file (e.g. a stray directory)', () => {
+            // Regression: checking presence via `fs.existsSync` alone would have reported
+            // "baseline present" here, reassuring the operator that debt is suppressed —
+            // but the real gate (`readBaseline`, used by `partition()`) treats an unreadable
+            // baseline path as "no baseline, nothing suppressed". The advisory must track
+            // what the runtime actually does, not just whether something exists at the path.
+            const dir = make({
+                manifest: { pack: 'js-ts', sensors: { lint: { cmd: 'npx eslint .' } } },
+                bins: ['eslint'],
+                files: ['package.json'],
+            });
+            fs_1.default.mkdirSync(path_1.default.join(dir, '.awm', 'sensors.baseline.json'), { recursive: true });
+            const report = (0, checks_1.preflight)(dir);
+            expect(check(report, 'sensors-baseline').ok).toBe(true);
+            expect(check(report, 'sensors-baseline').detail).toContain('no baseline yet');
+            expect(check(report, 'sensors-baseline').remedy).toContain('awm sensors baseline');
+        });
+    });
     it('tells the operator not to hand a broken harness to an unattended run', () => {
         const out = (0, preflight_1.formatReport)({
             status: 'not_configured',
@@ -320,4 +398,24 @@ describe('preflight', () => {
         expect(out).toContain('unattended');
         expect(out).toContain('awm sensors init');
     });
+    it('pads the id column to the widest id actually present, not a hardcoded width', () => {
+        // Regression: a literal `.padEnd(9)` silently misaligned once `sensors-baseline`
+        // (16 chars) was added as a check id — every detail column shifted left of where
+        // shorter ids' details landed. The width must be derived from the report itself.
+        // Marker prefixes (@@) pin exactly where each detail column starts, independent
+        // of the detail text's own content.
+        const out = (0, preflight_1.formatReport)({
+            status: 'ready',
+            checks: [
+                { id: 'host', ok: true, detail: '@@marker' },
+                { id: 'sensors-baseline', ok: true, detail: '@@marker' },
+            ],
+        });
+        const lines = out.split('\n').filter(l => l.includes('@@marker'));
+        expect(lines).toHaveLength(2);
+        expect(lines[0].indexOf('@@marker')).toBe(lines[1].indexOf('@@marker'));
+        // And the column is genuinely sized to the longest id (16, 'sensors-baseline'),
+        // not the old hardcoded 9 — the shorter id's row must carry visible padding.
+        expect(lines[0]).toMatch(/host {12,}@@marker/);
+    });
 });