agentic-workflow-manager 9.13.0 → 9.13.1

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) {
@@ -672,6 +672,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.1",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"