agentic-workflow-manager 9.12.5 → 9.13.1

package/dist/src/commands/plan/index.js

@@ -106,6 +106,7 @@ function reportPayload(report, planPath) {
         case 'valid':
             return {
                 state: report.state, path: planPath, schema: report.schema, planId: report.manifest.planId,
+                ...(report.dispatchMode ? { dispatchMode: report.dispatchMode } : {}),
                 planDigest: report.planDigest,
                 requirements: report.manifest.requirements.length, sources: report.manifest.sources.length,
                 commands: report.manifest.commands.length, slices: report.manifest.slices.length, completeOwnership: true,
@@ -259,11 +260,15 @@ function registerPlanCommand(program, deps = { validatePlanFile: validate_1.vali
         .description('validate a compact plan without modifying it')
         .option('--json', 'emit one stable JSON report')
         .option('--cwd <path>', 'repository root for plan containment and source resolution')
+        .option('--require-dispatch-mode', 'require an explicit dispatch choice for a newly authored plan')
         .action((planPath, options) => {
         assertText(planPath, 'plan path');
         const cwd = options.cwd ?? process.cwd();
         assertText(cwd, '--cwd');
-        const report = deps.validatePlanFile(planPath, cwd);
+        const validated = deps.validatePlanFile(planPath, cwd);
+        const report = options.requireDispatchMode && validated.state === 'valid' && !validated.dispatchMode
+            ? { state: 'invalid', diagnostics: [{ code: 'PLAN_DISPATCH_MODE', message: 'new plans must declare Modo de despacho before the manifest' }] }
+            : validated;
         const output = options.json === true
             ? `${JSON.stringify(reportPayload(report, planPath))}\n`
             : formatReport(report, planPath);

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/src/core/model-policy/resolve.js

@@ -152,6 +152,8 @@ function resolveV1Dispatch(input) {
     if (!input.plan || input.plan.schema !== 'compact-slices/v1')
         throw new Error('resolveV1Dispatch requires an authenticated v1 plan report');
     (0, validate_2.assertVerifiedValidPlanReport)(input.plan);
+    if (input.plan.dispatchMode === 'proveedor-nativo' && input.optInV1)
+        return blocked('ROUTING_DISPATCH_MODE', 'Provider-native plan forbids v1 routing opt-in; create a separately approved routed plan.');
     if (!input.optInV1)
         return { state: 'not-required', reason: 'v1-without-opt-in' };
     return resolveConfiguredSelection({ ...input, requestedProfile: 'full' });

package/dist/src/core/plan/validate.js

@@ -395,6 +395,12 @@ function validatePlan(planPath, cwd, snapshot) {
         return diagnostic('PLAN_LIMIT', 'plan id exceeds maximum string size');
     if ((raw.schema !== 'compact-slices/v1' && raw.schema !== 'compact-slices/v2') || (raw.schema === 'compact-slices/v1' && start !== START) || (raw.schema === 'compact-slices/v2' && start !== START_V2) || typeof raw.planId !== 'string' || !PLAN_ID.test(raw.planId) || !allStrings(raw.requirements) || new Set(raw.requirements).size !== raw.requirements.length)
         return diagnostic('PLAN_SHAPE', 'manifest scalar fields are invalid');
+    const dispatchHeaders = Array.from(text.slice(0, text.indexOf(start)).matchAll(/^[ \t]*\*\*Modo de despacho:\*\*[ \t]*([^\r\n]*)$/gm), match => match[1].trim());
+    if (dispatchHeaders.length > 1 || dispatchHeaders.some(value => value !== 'proveedor-nativo' && value !== 'awm-routed'))
+        return diagnostic('PLAN_DISPATCH_MODE', 'dispatch mode must occur once and be proveedor-nativo or awm-routed');
+    const dispatchMode = dispatchHeaders[0];
+    if (dispatchMode && ((dispatchMode === 'proveedor-nativo') !== (raw.schema === 'compact-slices/v1')))
+        return diagnostic('PLAN_DISPATCH_MODE', 'dispatch mode does not match compact plan schema');
     if (raw.requirements.some((id) => !validRequirementId(id)) || !allStrings(raw.closureCommands) || new Set(raw.closureCommands).size !== raw.closureCommands.length)
         return diagnostic('PLAN_SHAPE', 'manifest arrays or identifiers are invalid');
     const sourceIds = new Set();
@@ -488,6 +494,7 @@ function validatePlan(planPath, cwd, snapshot) {
         planDigest: crypto_1.default.createHash('sha256').update(text, 'utf8').digest('hex'),
         executionDigest: (0, identity_1.executionPlanDigest)(text),
         manifest: raw, executionMode: executionModeFromValidatedText(text),
+        ...(dispatchMode ? { dispatchMode } : {}),
     };
     freezeJson(report);
     verifiedValidReports.add(report);

package/dist/tests/commands/plan/index.test.js

@@ -57,6 +57,12 @@ describe('plan validate Commander wiring', () => {
         stdoutWrite.mockRestore();
         process.exitCode = previousExitCode;
     });
+    it('requires an explicit dispatch header for strict new-plan validation', async () => {
+        const program = commandFor(valid);
+        await program.parseAsync(['node', 'awm', 'plan', 'validate', 'plans/r4.md', '--cwd', repositoryRoot, '--require-dispatch-mode', '--json']);
+        expect(JSON.parse(String(stdoutWrite.mock.calls.at(-1)[0]))).toMatchObject({ state: 'invalid', diagnostics: [{ code: 'PLAN_DISPATCH_MODE' }] });
+        expect(process.exitCode).toBe(2);
+    });
     it('returns v1 not-required before reading personal policy or capability state', async () => {
         const policy = jest.fn();
         const capabilities = jest.fn();

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/dist/tests/core/plan/validate.test.js

@@ -10,6 +10,7 @@ const path_1 = __importDefault(require("path"));
 const crypto_1 = __importDefault(require("crypto"));
 const json_1 = require("../../../src/core/plan/json");
 const validate_1 = require("../../../src/core/plan/validate");
+const resolve_1 = require("../../../src/core/model-policy/resolve");
 jest.mock('child_process', () => ({ exec: jest.fn(), execFileSync: jest.fn(), execSync: jest.fn(), spawn: jest.fn(), spawnSync: jest.fn() }));
 const START = '<!-- AWM:COMPACT-SLICES:START v1 -->';
 const END = '<!-- AWM:COMPACT-SLICES:END v1 -->';
@@ -99,6 +100,42 @@ describe('validatePlanFile', () => {
         const report = (0, validate_1.validatePlanFile)(v2Fixture(root, profile), root);
         expect(report).toMatchObject({ state: 'valid', schema: 'compact-slices/v2', manifest: { slices: [expect.objectContaining({ implementerProfile: profile })] } });
     });
+    test.each([
+        ['proveedor-nativo', false],
+        ['awm-routed', true],
+    ])('accepts an explicit %s dispatch mode only with its matching schema', (mode, v2) => {
+        const plan = v2 ? v2Fixture(root) : fixture(root);
+        const before = fs_1.default.readFileSync(plan, 'utf8');
+        fs_1.default.writeFileSync(plan, `**Modo de despacho:** ${mode}\n${before}`);
+        expect((0, validate_1.validatePlanFile)(plan, root)).toMatchObject({ state: 'valid', dispatchMode: mode });
+        fs_1.default.writeFileSync(plan, `**Modo de despacho:** ${v2 ? 'proveedor-nativo' : 'awm-routed'}\n${before}`);
+        expect((0, validate_1.validatePlanFile)(plan, root)).toMatchObject({ state: 'invalid', diagnostics: [{ code: 'PLAN_DISPATCH_MODE' }] });
+    });
+    test.each(['indefinido', 'proveedor-nativo\n**Modo de despacho:** proveedor-nativo'])('rejects an invalid or duplicated dispatch header: %s', value => {
+        const plan = fixture(root);
+        fs_1.default.writeFileSync(plan, `**Modo de despacho:** ${value}\n${fs_1.default.readFileSync(plan, 'utf8')}`);
+        expect((0, validate_1.validatePlanFile)(plan, root)).toMatchObject({ state: 'invalid', diagnostics: [{ code: 'PLAN_DISPATCH_MODE' }] });
+    });
+    test('binds an explicit dispatch choice into plan and execution identity', () => {
+        const plan = fixture(root);
+        const historical = (0, validate_1.validatePlanFile)(plan, root);
+        fs_1.default.writeFileSync(plan, `**Modo de despacho:** proveedor-nativo\n${fs_1.default.readFileSync(plan, 'utf8')}`);
+        const explicit = (0, validate_1.validatePlanFile)(plan, root);
+        expect(historical).toMatchObject({ state: 'valid' });
+        expect(explicit).toMatchObject({ state: 'valid', dispatchMode: 'proveedor-nativo' });
+        if (historical.state !== 'valid' || explicit.state !== 'valid')
+            throw new Error('both v1 plans must validate');
+        expect(explicit.planDigest).not.toBe(historical.planDigest);
+        expect(explicit.executionDigest).not.toBe(historical.executionDigest);
+    });
+    test('does not let v1 opt-in override an explicit provider-native plan', () => {
+        const plan = fixture(root);
+        fs_1.default.writeFileSync(plan, `**Modo de despacho:** proveedor-nativo\n${fs_1.default.readFileSync(plan, 'utf8')}`);
+        const report = (0, validate_1.validatePlanFile)(plan, root);
+        if (report.state !== 'valid')
+            throw new Error('provider-native fixture must validate');
+        expect((0, resolve_1.resolveV1Dispatch)({ plan: report, optInV1: true, role: 'controller', runtime: { target: 'codex', kind: 'native', version: '1.0.0', accountScopeDigest: 'a'.repeat(64) }, now: new Date() })).toMatchObject({ state: 'blocked', diagnostics: [{ code: 'ROUTING_DISPATCH_MODE' }] });
+    });
     test('rejects v1 profile without weakening exact keys', () => {
         expect((0, validate_1.validatePlanFile)(fixture(root, manifest => { (manifest.slices[0]).implementerProfile = 'mechanical'; }), root)).toMatchObject({ state: 'invalid' });
     });

package/package.json

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