agentic-workflow-manager 9.13.0 → 9.13.2

package/dist/src/commands/watch/supervisor.js

@@ -245,14 +245,18 @@ function recoveryWhitelistBlocker(state) {
     // Pending work is the normal reason to launch (or retry launching) the
     // controller.  It is not recovery evidence and therefore cannot turn a
     // transient launch failure into permanent custody.  Conversely, once a
-    // non-empty task set claims completion, missing required evidence is an
-    // unsafe recovery fact and must remain fail-closed.
+    // non-empty task set claims completion, a required verifier that no plan
+    // contains, or a task-level item left unsatisfied, is an unsafe recovery
+    // fact and must remain fail-closed. A cycle-level item that was planned
+    // but never requested is not: it is the pending closure a relaunched
+    // controller exists to perform (#196, v1 smoke), and the gate still
+    // demands its evidence before COMPLETE.
     if (state.tasks.length === 0 || state.tasks.some(task => task.status !== 'done'))
         return undefined;
     const verificationItems = [...state.cycleVerificationPlan, ...state.tasks.flatMap(task => task.verificationPlan)];
     for (const required of state.requiredVerifiers) {
         const requiredItems = verificationItems.filter(item => item.kind === required);
-        if (requiredItems.length === 0 || requiredItems.some(item => item.satisfiedBy === undefined))
+        if (requiredItems.length === 0 || requiredItems.some(item => item.satisfiedBy === undefined && !state.cycleVerificationPlan.includes(item)))
             return `falta evidencia del verificador requerido: ${required}`;
     }
     return undefined;
@@ -483,18 +487,23 @@ class Supervisor {
                 const job = before0.state.jobs[id];
                 return job !== undefined && job.verdict === 'pass' && !staleJob;
             };
-            const verificationItems = [...before0.state.cycleVerificationPlan, ...before0.state.tasks.flatMap(task => task.verificationPlan)];
-            const tests = verificationItems.filter(item => item.kind === 'test');
-            const sensorItems = verificationItems.filter(item => item.kind === 'sensors');
+            const cycleItems = before0.state.cycleVerificationPlan;
+            const verificationItems = [...cycleItems, ...before0.state.tasks.flatMap(task => task.verificationPlan)];
+            // Planned cycle items never requested are closure work, not
+            // evidence; every requested or task-level item is still judged.
+            const judged = (items) => items.filter(item => item.satisfiedBy !== undefined || !cycleItems.includes(item));
+            const tests = judged(verificationItems.filter(item => item.kind === 'test'));
+            const sensorItems = judged(verificationItems.filter(item => item.kind === 'sensors'));
             // `computeGate` is the single authority for every verification
             // kind (review, QA and interlock included). Reuse its evidence
             // semantics instead of maintaining a weaker recovery subset.
             const evidenceGate = (0, gate_1.computeGate)(before0.state, false, this.fingerprintNow);
             const terminalTaskClaims = before0.state.tasks.length > 0 && before0.state.tasks.every(task => task.status === 'done');
-            const unresolvedVerification = terminalTaskClaims && evidenceGate.reasons.some(reason => [
-                'dangling-reference', 'unsatisfied-plan', 'adverse-verdict',
+            const closurePending = terminalTaskClaims && cycleItems.some(item => item.satisfiedBy === undefined);
+            const unresolvedVerification = terminalTaskClaims && (evidenceGate.reasons.some(reason => [
+                'dangling-reference', 'adverse-verdict',
                 'stale-fingerprint', 'open-obligation', 'open-fix',
-            ].includes(reason.category));
+            ].includes(reason.category)) || verificationItems.some(item => item.satisfiedBy === undefined && !cycleItems.includes(item)));
             const hasStaleReview = before0.state.verdicts.some(verdict => verdict.fingerprint === '' || (verdict.argv.length > 0 && (() => {
                 try {
                     return (0, fingerprint_1.computeFingerprint)(this.repoRoot, verdict.argv, verdict.paths, verdict.cwd).fingerprint !== verdict.fingerprint;
@@ -524,7 +533,7 @@ class Supervisor {
                 sensors: !terminalTaskClaims || sensorItems.length === 0 || sensorItems.every(item => passed(item.satisfiedBy)) ? 'pass' : 'missing',
                 verdicts: hasStaleReview ? 'stale' : (openReviewOrFix || unresolvedVerification) ? 'missing' : 'current',
             });
-            (0, store_1.appendEvent)(this.repoRoot, this.branch, { kind: 'unattended-recovery', nextAction: recovery.nextAction, activeJobIds: recovery.activeJobIds, diagnostics: recovery.diagnostics });
+            (0, store_1.appendEvent)(this.repoRoot, this.branch, { kind: 'unattended-recovery', nextAction: recovery.nextAction, activeJobIds: recovery.activeJobIds, diagnostics: recovery.diagnostics, closurePending });
             if (recovery.state !== 'ready') {
                 const staleReasons = terminalTaskClaims ? evidenceGate.reasons.filter(reason => reason.category === 'stale-fingerprint') : [];
                 const remedy = staleReasons.length > 0
@@ -533,7 +542,7 @@ class Supervisor {
                 (0, generations_1.enterCustody)(this.repoRoot, this.branch, `recovery no autorizado: ${recovery.diagnostics.join(', ')}${remedy}`);
                 return 'custody';
             }
-            recoveryResumeAction = { schema: 'controller-recovery/v1', kind: recovery.nextAction === 'reconcile-active-jobs' ? 'reconcile-active-jobs' : 'resume-next-action' };
+            recoveryResumeAction = { schema: 'controller-recovery/v1', kind: recovery.nextAction === 'reconcile-active-jobs' ? 'reconcile-active-jobs' : closurePending ? 'resume-cycle' : 'resume-next-action' };
         }
         // R6.2/R6.8/C7 (Task 11): reconciliar un `MERGE_HEAD` abierto por un
         // crash a mitad de un merge ANTES de cualquier guard general — hoy
@@ -792,6 +801,11 @@ class Supervisor {
         const decision = snap === null && safeToReplace === 'safe' ? 'resolve-generation' : (0, generations_1.decideStall)({ heartbeatAgeMs, activityFrozenMs, safeToReplace }, { heartbeatTimeoutMs: this.cfg.heartbeatTimeoutMs, activityWindowMs: this.cfg.activityWindowMs });
         if (decision === 'healthy') {
             this.backoff.reset();
+            if (gen.state === 'controller-suspected-stall') {
+                gen.state = 'active'; // heartbeat reanudado: la sospecha se levanta
+                (0, store_1.writeJournal)(this.repoRoot, this.branch, s);
+                (0, store_1.appendEvent)(this.repoRoot, this.branch, { kind: 'controller-stall-cleared', n: gen.n });
+            }
             return 'ok';
         }
         if (decision === 'suspected-stall-observe') {

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

@@ -12,6 +12,7 @@ exports.spawnStructured = spawnStructured;
 exports.refIsAlive = refIsAlive;
 exports.processStatesAreGone = processStatesAreGone;
 exports.groupIsGone = groupIsGone;
+exports.descendantActivity = descendantActivity;
 exports.activitySnapshot = activitySnapshot;
 exports.terminateGroupConfirmed = terminateGroupConfirmed;
 exports.terminatePreviouslyOwnedGroup = terminatePreviouslyOwnedGroup;
@@ -455,6 +456,57 @@ function groupIsGone(pgid) {
         return false; // sin observacion completa, falla cerrado
     }
 }
+const MAX_PS_ROWS = 65536;
+/** Activity of every process descending from `rootPid` in a `ps -A -o
+ *  pid=,ppid=,time=` table. The process group alone misses work a controller
+ *  waits on when the provider runs it in its own group or session (sandboxed
+ *  tool commands), which turned a healthy wait on a native subagent into a
+ *  "frozen" controller and a false custody (#196, v1 smoke). Root excluded;
+ *  malformed rows ignored; a ppid cycle cannot loop because each pid is
+ *  visited once. */
+function descendantActivity(psTable, rootPid) {
+    if (!Number.isInteger(rootPid) || rootPid <= 0)
+        throw new Error(`descendantActivity: root pid must be a positive integer, got ${rootPid}`);
+    const children = new Map();
+    let rows = 0;
+    for (const line of psTable.split('\n')) {
+        const match = /^\s*(\d+)\s+(\d+)\s+(\S+)\s*$/.exec(line);
+        if (match === null)
+            continue;
+        if (++rows > MAX_PS_ROWS)
+            break;
+        const pid = Number(match[1]);
+        const ppid = Number(match[2]);
+        const siblings = children.get(ppid) ?? [];
+        siblings.push({ pid, time: match[3] });
+        children.set(ppid, siblings);
+    }
+    const seen = new Set([rootPid]);
+    const found = [];
+    const queue = [rootPid];
+    while (queue.length > 0) {
+        for (const child of children.get(queue.shift()) ?? []) {
+            if (seen.has(child.pid))
+                continue;
+            seen.add(child.pid);
+            found.push(`${child.pid}:${child.time}`);
+            queue.push(child.pid);
+        }
+    }
+    if (found.length === 0)
+        return '0:none';
+    found.sort();
+    return `${found.length}:${crypto_1.default.createHash('sha256').update(found.join('\n')).digest('hex')}`;
+}
+function observeDescendants(rootPid) {
+    try {
+        const table = (0, child_process_1.execFileSync)('ps', ['-A', '-o', 'pid=,ppid=,time='], { encoding: 'utf8', stdio: exports.EXEC_STDIO, timeout: PS_TIMEOUT_MS, maxBuffer: 16 * 1024 * 1024 });
+        return descendantActivity(table, rootPid);
+    }
+    catch {
+        return 'unknown';
+    }
+}
 /** 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
@@ -474,7 +526,7 @@ function activitySnapshot(ref) {
     if (!refIsAlive(ref))
         return null;
     if ((0, paths_1.isWindowsNative)())
-        return { cpuTime: 'unknown', groupSize: 1 };
+        return { cpuTime: 'unknown', groupSize: 1, descendants: 'unknown' };
     let cpu = '0';
     try {
         cpu = psField(ref.pid, 'time') ?? '0';
@@ -490,7 +542,7 @@ function activitySnapshot(ref) {
     catch {
         groupSize = 1;
     }
-    return { cpuTime: cpu, groupSize };
+    return { cpuTime: cpu, groupSize, descendants: observeDescendants(ref.pid) };
 }
 /** win32: sin process groups POSIX ni convencion de pid negativo, y sin
  *  distincion real SIGTERM/SIGKILL (Node mapea ambas a TerminateProcess

package/dist/tests/commands/watch/plan-lifecycle.test.js

@@ -183,7 +183,7 @@ describe('compact lifecycle proof and unused bootstrap archival', () => {
         (0, store_1.writeJournal)(repo, 'main', launched);
         const adapter = adapterModule.adapterFor('codex');
         jest.spyOn(adapterModule, 'adapterFor').mockReturnValue({ ...adapter,
-            activity: () => ({ cpuTime: '0', groupSize: 1 }), safeToReplace: () => 'indeterminate' });
+            activity: () => ({ cpuTime: '0', groupSize: 1, descendants: '0:none' }), safeToReplace: () => 'indeterminate' });
         for (let i = 0; i < 100; i++) {
             expect(await supervisor.tick()).toBe('continue');
             if (Object.values((0, store_1.readJournal)(repo, 'main').state.jobs).some(job => job.verdict === 'pass'))

package/dist/tests/commands/watch/reopened-196.test.js

@@ -489,7 +489,7 @@ describe('issue #196 reopened: supervised S1 handoff', () => {
             (0, store_1.writeJournal)(repo, 'main', launched);
             const adapter = adapterModule.adapterFor('codex');
             jest.spyOn(adapterModule, 'adapterFor').mockReturnValue({ ...adapter,
-                activity: () => ({ cpuTime: '0', groupSize: 1 }), safeToReplace: () => 'indeterminate' });
+                activity: () => ({ cpuTime: '0', groupSize: 1, descendants: '0:none' }), safeToReplace: () => 'indeterminate' });
             fs_1.default.writeFileSync(path_1.default.join(repo, 's1-red.test.ts'), 'test("RED", () => { throw new Error("RED"); });\n');
             (0, request_1.requestJob)(repo, 'main', gen.token, [process.execPath, '-e', 'process.exit(0)'], [], '.');
             report = redSensor;

package/dist/tests/commands/watch/supervisor-loop.test.js

@@ -104,7 +104,7 @@ function adoptFixtureController(repo) {
     (0, store_1.writeJournal)(repo, 'main', state);
     const adapter = adapterModule.adapterFor('codex');
     jest.spyOn(adapterModule, 'adapterFor').mockReturnValue({ ...adapter,
-        activity: () => ({ cpuTime: '0', groupSize: 1 }), safeToReplace: () => 'indeterminate' });
+        activity: () => ({ cpuTime: '0', groupSize: 1, descendants: '0:none' }), safeToReplace: () => 'indeterminate' });
 }
 /** Legacy fixtures predate compact-only admission; make their execution contract explicit. */
 function initUnattendedFixture(repo) {
@@ -621,6 +621,88 @@ describe('supervisor loop', () => {
         expect(spawns).toBe(0);
         expect((0, store_1.readJournal)(repo, 'main').state.cycle.status).toBe('BLOCKED');
     });
+    // v1 smoke 2026-09-26 (#196): the Codex controller exited after the last
+    // review, before requesting the cycle-level verifications it had planned.
+    // Tasks done + planned-but-never-requested cycle items is pending closure
+    // work, not an unsafe recovery claim: relaunch the controller to close.
+    function closurePendingState(repoRoot) {
+        initUnattendedFixture(repoRoot);
+        const state = (0, store_1.readJournal)(repoRoot, 'main').state;
+        const verdict = (id, obligationId) => {
+            const argv = ['awm-review', obligationId];
+            return { id, obligationId, result: 'pass', detail: 'ok', receivedAt: new Date().toISOString(),
+                fingerprint: (0, fingerprint_1.computeFingerprint)(repoRoot, argv, [], '.').fingerprint, argv, paths: [], cwd: '.' };
+        };
+        state.requiredVerifiers = ['test', 'sensors'];
+        state.tasks.push({ id: 'S1', title: 'terminada', status: 'done', attempts: 1, verificationPlan: [], reviewObligations: [
+                { id: 'o-spec', taskId: 'S1', kind: 'spec', verdictId: 'v-spec' },
+                { id: 'o-quality', taskId: 'S1', kind: 'quality', verdictId: 'v-quality' },
+            ] });
+        state.verdicts.push(verdict('v-spec', 'o-spec'), verdict('v-quality', 'o-quality'));
+        state.cycleVerificationPlan.push({ id: 'cycle-test', kind: 'test' }, { id: 'cycle-sensors', kind: 'sensors' }, { id: 'cycle-qa', kind: 'qa' }, { id: 'cycle-interlock', kind: 'interlock' });
+        return state;
+    }
+    test('cierre pendiente: tareas terminadas + verificaciones de ciclo nunca pedidas => relanza el controller para cerrar, sin custodia', async () => {
+        const state = closurePendingState(repo);
+        (0, store_1.writeJournal)(repo, 'main', state);
+        (0, generations_1.beginGeneration)(repo, 'main'); // el reemplazo que el loop abre tras la salida del anterior
+        let spawns = 0;
+        const outcome = await new supervisor_1.Supervisor(repo, 'main', supervisor_1.DEFAULT_SUPERVISOR_CONFIG, () => { spawns++; }, undefined, admitted).tick();
+        expect(outcome).not.toBe('custody');
+        const after = (0, store_1.readJournal)(repo, 'main').state;
+        expect(after.cycle.status).toBe('IN_PROGRESS');
+        expect(spawns).toBe(1);
+        expect((0, generations_1.activeGeneration)(after).resumeAction?.kind).toBe('resume-cycle');
+        expect(after.tasks.map(task => [task.id, task.status, task.attempts])).toEqual([['S1', 'done', 1]]); // nada se redespacha
+    });
+    test.each([
+        ['un item de tarea sin satisfacer tras declararla terminada', (s) => {
+                s.tasks[0].verificationPlan.push({ id: 'task-test', kind: 'test' });
+            }],
+        ['un item de ciclo que cita un job inexistente', (s) => {
+                s.cycleVerificationPlan[0].satisfiedBy = 'job-fantasma';
+            }],
+        ['una revision obligatoria sin verdict', (s) => {
+                s.tasks[0].reviewObligations[1].verdictId = undefined;
+            }],
+        ['un verdict de revision adverso sin fix cerrado', (s) => {
+                s.verdicts[1].result = 'fail';
+            }],
+        ['un verificador requerido que ningun plan contiene', (s) => {
+                s.cycleVerificationPlan.splice(0, 1);
+            }],
+    ])('cierre pendiente sigue fail-closed con %s: custodia sin controller', async (_name, mutate) => {
+        const state = closurePendingState(repo);
+        mutate(state);
+        (0, store_1.writeJournal)(repo, 'main', state);
+        (0, generations_1.beginGeneration)(repo, 'main'); // mismo reemplazo: solo cambia la evidencia
+        let spawns = 0;
+        const outcome = await new supervisor_1.Supervisor(repo, 'main', supervisor_1.DEFAULT_SUPERVISOR_CONFIG, () => { spawns++; }, undefined, admitted).tick();
+        expect(outcome).toBe('custody');
+        expect(spawns).toBe(0);
+        expect((0, store_1.readJournal)(repo, 'main').state.cycle.status).toBe('BLOCKED');
+    });
+    // A controller that resumes heartbeating is healthy again; leaving the
+    // generation marked as a suspected stall misreports the cycle.
+    test('una generacion en sospecha de stall vuelve a active cuando el heartbeat se reanuda', async () => {
+        initUnattendedFixture(repo);
+        (0, generations_1.beginGeneration)(repo, 'main');
+        const { child, ref } = (0, process_1.spawnStructured)(['node', '-e', 'setTimeout(()=>{}, 20000)'], process.cwd(), 'nBack');
+        try {
+            const s = (0, store_1.readJournal)(repo, 'main').state;
+            const gen = (0, generations_1.activeGeneration)(s);
+            gen.processRef = ref;
+            gen.state = 'controller-suspected-stall';
+            s.controllerHeartbeatAt = new Date().toISOString();
+            (0, store_1.writeJournal)(repo, 'main', s);
+            const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, provider: 'codex', heartbeatTimeoutMs: 60000, activityWindowMs: 60000, tickMs: 20 };
+            expect(await new supervisor_1.Supervisor(repo, 'main', cfg, fakeSpawner, undefined, admitted).tick()).not.toBe('custody');
+            expect((0, generations_1.activeGeneration)((0, store_1.readJournal)(repo, 'main').state).state).toBe('active');
+        }
+        finally {
+            child.kill('SIGKILL');
+        }
+    });
     test('un journal schema-1 legacy no despacha controller ni jobs aunque contenga trabajo pendiente', async () => {
         (0, store_1.initJournal)(repo, 'main');
         const legacy = (0, store_1.readJournal)(repo, 'main').state;
@@ -672,6 +754,47 @@ describe('supervisor loop', () => {
         expect(child.killed).toBe(false); // y NO mato al controlador
         child.kill('SIGKILL');
     });
+    // v1 smoke 2026-09-26 (#196): a Codex controller waiting on a native
+    // subagent kept an idle leader while the work ran in processes outside its
+    // process group, and the supervisor entered a false custody. Work in the
+    // descendant tree is activity: observe, never custody, while it moves.
+    itPosix('espera sana: lider ocioso + descendiente fuera del grupo trabajando => observa, no custodia (R4.2)', async () => {
+        initUnattendedFixture(repo);
+        (0, generations_1.beginGeneration)(repo, 'main');
+        const worker = "require('child_process').spawn('sh', ['-c', 'while :; do sleep 0.02; done'], { detached: true, stdio: 'ignore' }).unref(); setTimeout(()=>{}, 20000)";
+        const { child, ref } = (0, process_1.spawnStructured)(['node', '-e', worker], process.cwd(), 'nWait');
+        try {
+            let s = (0, store_1.readJournal)(repo, 'main').state;
+            (0, generations_1.activeGeneration)(s).processRef = ref;
+            s.controllerHeartbeatAt = new Date(Date.now() - 3600000).toISOString(); // heartbeat vencido: bloqueado en la espera
+            (0, store_1.writeJournal)(repo, 'main', s);
+            await until(() => ((0, process_1.activitySnapshot)(ref)?.descendants ?? '0:none') !== '0:none');
+            const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, provider: 'codex', heartbeatTimeoutMs: 1, activityWindowMs: 50, tickMs: 20 };
+            const sup = new supervisor_1.Supervisor(repo, 'main', cfg, fakeSpawner, undefined, admitted);
+            await sup.tick();
+            await new Promise((r) => setTimeout(r, 150)); // mas que la ventana, pero el arbol se movio
+            expect(await sup.tick()).not.toBe('custody');
+            const after = (0, store_1.readJournal)(repo, 'main').state;
+            expect(after.cycle.status).toBe('IN_PROGRESS');
+            expect((0, generations_1.activeGeneration)(after).state).toBe('controller-suspected-stall'); // observado, jamas matado
+            expect(child.killed).toBe(false);
+        }
+        finally {
+            // The detached shell leads its own group: kill that group, never a pattern match.
+            let shells = [];
+            try {
+                shells = (0, child_process_1.execFileSync)('pgrep', ['-P', String(ref.pid)], { encoding: 'utf8' }).split('\n').filter(Boolean).map(Number);
+            }
+            catch { /* sin hijos */ }
+            for (const pid of shells) {
+                try {
+                    process.kill(-pid, 'SIGKILL');
+                }
+                catch { /* ya ausente */ }
+            }
+            child.kill('SIGKILL');
+        }
+    });
     itPosix('runSupervisorLoop: bootstrap gen-1 con stub codex, COMPLETE => libera lock y termina su generacion (R4.1/R4.5/R2.4)', async () => {
         initUnattendedFixture(repo);
         jest.spyOn(fingerprint, 'reconcileUnattendedRecovery').mockReturnValue({

package/dist/tests/core/journal/process.test.js

@@ -167,6 +167,70 @@ describe('process identity', () => {
         expect(snap.groupSize).toBeGreaterThanOrEqual(1);
         child.kill('SIGKILL');
     });
+    // False-stall root cause (Kodria/agentic-workflow#196, v1 smoke 2026-09-26):
+    // a Codex controller waiting on a native subagent barely moves its own CPU
+    // time, and the work it waits on can run in processes OUTSIDE its process
+    // group (sandboxed tool commands). Activity must see the whole descendant
+    // tree, or a healthy wait reads as frozen and the cycle enters custody.
+    describe('descendantActivity (descendant tree, not only the process group)', () => {
+        const table = [
+            '  10     1 00:00:05',
+            '  20    10 00:00:01', // child
+            '  30    20 00:00:02', // grandchild (e.g. setsid'd sandbox command)
+            '  40     1 00:00:09', // unrelated
+            '  50    40 00:00:03', // child of the unrelated process
+        ].join('\n');
+        test('counts children and grandchildren, excludes the root and unrelated processes', () => {
+            expect((0, process_1.descendantActivity)(table, 10)).toMatch(/^2:[0-9a-f]{64}$/);
+            expect((0, process_1.descendantActivity)(table, 20)).toMatch(/^1:/);
+            expect((0, process_1.descendantActivity)(table, 30)).toBe('0:none');
+            expect((0, process_1.descendantActivity)(table, 999)).toBe('0:none');
+        });
+        test('changes when a descendant accumulates cpu, appears or exits, and ignores unrelated churn', () => {
+            const base = (0, process_1.descendantActivity)(table, 10);
+            expect((0, process_1.descendantActivity)(table.replace('30    20 00:00:02', '30    20 00:00:03'), 10)).not.toBe(base);
+            expect((0, process_1.descendantActivity)(`${table}\n  60    30 00:00:00`, 10)).not.toBe(base);
+            expect((0, process_1.descendantActivity)(table.split('\n').filter((line) => !line.includes('30    20')).join('\n'), 10)).not.toBe(base);
+            expect((0, process_1.descendantActivity)(table.replace('50    40 00:00:03', '50    40 00:00:07'), 10)).toBe(base);
+            expect((0, process_1.descendantActivity)(`${table}\n  70    40 00:00:00`, 10)).toBe(base);
+        });
+        test('rejects an invalid root and never follows a ppid cycle forever', () => {
+            expect(() => (0, process_1.descendantActivity)(table, 0)).toThrow(/root pid/);
+            expect(() => (0, process_1.descendantActivity)(table, Number.NaN)).toThrow(/root pid/);
+            expect((0, process_1.descendantActivity)('  10     1 00:00:00\n  20    10 00:00:00\n  10    20 00:00:00', 10)).toMatch(/^1:/);
+        });
+        test('ignores malformed ps lines instead of inventing processes', () => {
+            expect((0, process_1.descendantActivity)('garbage\n  20    10 00:00:01\n\n  x y z', 10)).toMatch(/^1:/);
+        });
+    });
+    test('activitySnapshot ve un nieto fuera del process group del controlador', async () => {
+        if ((0, paths_1.isWindowsNative)())
+            return; // win32 degrada activity sin ps (ver activitySnapshot)
+        const script = "setTimeout(() => { require('child_process').spawn(process.execPath, ['-e', 'setTimeout(()=>{}, 4000)'], { detached: true, stdio: 'ignore' }).unref(); }, 400); setTimeout(()=>{}, 4000)";
+        const { child, ref } = (0, process_1.spawnStructured)(['node', '-e', script], process.cwd(), 'n-desc');
+        try {
+            const before = (0, process_1.activitySnapshot)(ref);
+            expect(before).not.toBeNull();
+            let after = (0, process_1.activitySnapshot)(ref);
+            for (let i = 0; i < 40 && after !== null && after.descendants === before.descendants; i++) {
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                after = (0, process_1.activitySnapshot)(ref);
+            }
+            expect(after).not.toBeNull();
+            // The detached grandchild lives in its own process group: the group
+            // signal cannot see it, the descendant signal must.
+            expect(after.groupSize).toBe(before.groupSize);
+            expect(after.descendants).not.toBe(before.descendants);
+            expect(after.descendants).toMatch(/^1:/);
+        }
+        finally {
+            try {
+                process.kill(-ref.processGroup, 'SIGKILL');
+            }
+            catch { /* ya ausente */ }
+            child.kill('SIGKILL');
+        }
+    });
     test('captureSelfRef captura la identidad del proceso actual (R2.1)', () => {
         const self = (0, process_1.captureSelfRef)('nonce-self');
         expect(self.pid).toBe(process.pid);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-workflow-manager",
-  "version": "9.13.0",
+  "version": "9.13.2",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"