agentic-workflow-manager 9.15.1 → 9.16.1

package/dist/src/core/admission/index.js

@@ -25,7 +25,10 @@ exports.PROVIDER_EXECUTION_CAPABILITIES = {
     opencode: { ...UNKNOWN },
     'claude-code': { ...UNKNOWN, interactiveExecution: 'supported', unattendedController: 'supported', durableResume: 'supported' },
     codex: { ...UNKNOWN, interactiveExecution: 'supported', unattendedController: 'supported', durableResume: 'supported' },
-    cursor: { ...UNKNOWN },
+    // Plan C (native session only): interactive + journal-less unattended v1.
+    // durableResume stays unverified — Camino B / awm watch is suspended (D-023)
+    // and Cursor is not in WATCH_PROVIDERS. Evidence: docs/testing/cursor-execution-evidence.md
+    cursor: { ...UNKNOWN, interactiveExecution: 'supported', unattendedController: 'supported' },
     copilot: { ...UNKNOWN },
 };
 /** #168: the controller can only act if it was launched with an autonomy

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

@@ -470,7 +470,10 @@ function descendantActivity(psTable, 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);
+        // time may be empty on some Darwin samples for a just-spawned process;
+        // treat blank as "0" so the pid still joins the descendant tree (otherwise
+        // a healthy detached grandchild is invisible and activity reads as frozen).
+        const match = /^\s*(\d+)\s+(\d+)(?:\s+(\S+))?\s*$/.exec(line);
         if (match === null)
             continue;
         if (++rows > MAX_PS_ROWS)
@@ -478,7 +481,7 @@ function descendantActivity(psTable, rootPid) {
         const pid = Number(match[1]);
         const ppid = Number(match[2]);
         const siblings = children.get(ppid) ?? [];
-        siblings.push({ pid, time: match[3] });
+        siblings.push({ pid, time: match[3] && match[3].length > 0 ? match[3] : '0' });
         children.set(ppid, siblings);
     }
     const seen = new Set([rootPid]);
@@ -499,13 +502,24 @@ function descendantActivity(psTable, rootPid) {
     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';
+    // One transient `ps` failure under CI load used to freeze the snapshot at
+    // `unknown`, which made the Darwin integration test (and a real supervisor
+    // tick) treat a later concrete `0:none` as "activity changed" without ever
+    // seeing the grandchild. Retry once before degrading.
+    let lastError;
+    for (let attempt = 0; attempt < 2; attempt++) {
+        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 (error) {
+            lastError = error;
+        }
     }
+    void lastError;
+    return 'unknown';
 }
 /** Llamada UNA VEZ POR TICK por el supervisor (ver superviseController en
  *  commands/watch/supervisor.ts) mientras un controlador este activo — el

package/dist/src/providers/index.js

@@ -163,6 +163,15 @@ function providers() {
         cursor: {
             label: 'Cursor',
             configHome: configHomeFor('cursor'),
+            // Date-based CLI line (YYYY.MM.DD-<hash>). compareSemver orders the
+            // date triple as [YYYY, M, D]. Floor from owner-machine capture
+            // 2026.09.26-dd393fe (docs/testing/cursor-execution-evidence.md).
+            minimumVersion: '2026.09.26',
+            versionCommand: {
+                command: 'agent',
+                args: ['--version'],
+                versionPattern: /^(\d{4}\.\d{2}\.\d{2})-[0-9a-f]+$/,
+            },
             // Skills join the Codex/OpenCode shared physical dirs (~/.agents/skills +
             // .agents/skills, renderer link). cursor-mdc remains registered for S3
             // migration reads of historical ~/.cursor/rules installs.

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

@@ -434,6 +434,10 @@ describe('runInit', () => {
                 agent: 'cursor',
                 yes: true,
                 machineOnly: true,
+                // Plan C adds a Cursor version gate; CI has no `agent` binary.
+                // Stub the same way Codex init tests do — the gate itself is
+                // covered in provider-version.test.ts.
+                assertProviderSupported: () => ({ provider: 'cursor', version: '2026.09.26' }),
                 // seedBaselineRegistry() writes registries.json pointing at 'baseline'
                 // (our manually-seeded content root above) since none exists yet — no
                 // real network clone happens because that content root already exists

package/dist/tests/core/admission/index.test.js

@@ -27,7 +27,7 @@ describe('admitPlan', () => {
     });
     it.each([
         ['journal', { provider: 'codex', executionMode: 'desatendido' }],
-        ['provider capability', { provider: 'cursor', executionMode: 'interactivo' }],
+        ['provider capability', { provider: 'copilot', executionMode: 'interactivo' }],
     ])('does not invoke deferred v2 routing facts when %s gate blocks', async (_name, fields) => {
         const reader = jest.fn(() => { throw new Error('routing reader must not run'); });
         const report = await (0, admission_1.admitPlan)({ plan: v2(), cwd: process.cwd(), enabledAgents: [fields.provider], routingReader: reader, ...fields });
@@ -139,10 +139,32 @@ describe('admitPlan', () => {
         expect(report.currentness).toBe('not-checked');
     });
     it('does not let an unverified execution capability admit interactive work', async () => {
-        const report = await (0, admission_1.admitPlan)({ plan: valid, provider: 'cursor', cwd: process.cwd(), enabledAgents: ['cursor'] });
-        expect(report).toMatchObject({ state: 'blocked', executionMode: 'interactivo', provider: 'cursor', journal: 'not-required' });
+        const report = await (0, admission_1.admitPlan)({ plan: valid, provider: 'copilot', cwd: process.cwd(), enabledAgents: ['copilot'] });
+        expect(report).toMatchObject({ state: 'blocked', executionMode: 'interactivo', provider: 'copilot', journal: 'not-required' });
         expect(report.diagnostics[0].code).toBe('ADMISSION_CAPABILITY_UNVERIFIED');
     });
+    it('admits Cursor interactive work once Plan C marks interactiveExecution supported', async () => {
+        const report = await (0, admission_1.admitPlan)({ plan: valid, provider: 'cursor', cwd: process.cwd(), enabledAgents: ['cursor'] });
+        expect(report).toMatchObject({ state: 'admitted', executionMode: 'interactivo', provider: 'cursor', journal: 'not-required' });
+        expect(report.capabilityResolution).toMatchObject({ outcome: 'native', capabilities: { interactiveExecution: 'supported' } });
+    });
+    it('admits Cursor journal-less unattended v1 with an explicit autonomy posture', async () => {
+        const unattended = { ...valid, manifest: { ...valid.manifest, executionMode: 'desatendido' } };
+        const report = await (0, admission_1.admitPlan)({
+            plan: unattended, provider: 'cursor', cwd: process.cwd(), enabledAgents: ['cursor'],
+            planPath: 'docs/plan.md', controllerAutonomy: 'approval-free',
+        });
+        expect(report).toMatchObject({ state: 'admitted', executionMode: 'desatendido', provider: 'cursor', journal: 'not-required' });
+        expect(report.capabilityResolution).toMatchObject({ outcome: 'native', capabilities: { unattendedController: 'supported' } });
+    });
+    it('still requires the autonomy posture for Cursor unattended work', async () => {
+        const unattended = { ...valid, manifest: { ...valid.manifest, executionMode: 'desatendido' } };
+        const report = await (0, admission_1.admitPlan)({
+            plan: unattended, provider: 'cursor', cwd: process.cwd(), enabledAgents: ['cursor'], planPath: 'docs/plan.md',
+        });
+        expect(report.state).toBe('blocked');
+        expect(report.diagnostics[0]).toMatchObject({ code: 'ADMISSION_CONTROLLER_AUTONOMY_REQUIRED' });
+    });
     // The durable controller (journal + awm watch + jobs) is opt-in again for
     // native v1 dispatch, as it was before 9.8.0: a v1 unattended plan with no
     // journal on its branch runs as one native provider session. Creating a
@@ -266,7 +288,7 @@ describe('admitPlan', () => {
             expect(report.state).toBe('admitted');
         });
         it('keeps the original diagnostic for a provider that never had the capability', async () => {
-            const report = await (0, admission_1.admitPlan)({ plan: unattended(), provider: 'cursor', cwd: process.cwd(), enabledAgents: ['cursor'], journalState: journal(), planPath: 'docs/plan.md', controllerAutonomy: 'approval-free' });
+            const report = await (0, admission_1.admitPlan)({ plan: unattended(), provider: 'copilot', cwd: process.cwd(), enabledAgents: ['copilot'], journalState: journal(), planPath: 'docs/plan.md', controllerAutonomy: 'approval-free' });
             expect(report.state).toBe('blocked');
             expect(report.diagnostics[0]).toMatchObject({ code: 'ADMISSION_CAPABILITY_UNVERIFIED' });
         });

package/dist/tests/core/journal/controller-autonomy.test.js

@@ -58,8 +58,15 @@ describe('unattendedController stops being asserted for free (#168)', () => {
         expect((0, admission_1.unattendedCapabilities)('claude-code', 'approval-free').unattendedController).toBe('supported');
     });
     test('never promotes a provider that never had the capability', () => {
-        expect(admission_1.PROVIDER_EXECUTION_CAPABILITIES.cursor.unattendedController).toBe('unverified');
-        expect((0, admission_1.unattendedCapabilities)('cursor', 'approval-free').unattendedController).toBe('unverified');
+        expect(admission_1.PROVIDER_EXECUTION_CAPABILITIES.copilot.unattendedController).toBe('unverified');
+        expect((0, admission_1.unattendedCapabilities)('copilot', 'approval-free').unattendedController).toBe('unverified');
+    });
+    test('Cursor gains unattendedController only with a declared posture (Plan C)', () => {
+        expect(admission_1.PROVIDER_EXECUTION_CAPABILITIES.cursor.unattendedController).toBe('supported');
+        expect((0, admission_1.unattendedCapabilities)('cursor', undefined).unattendedController).toBe('unverified');
+        expect((0, admission_1.unattendedCapabilities)('cursor', 'approval-free').unattendedController).toBe('supported');
+        // Watch/custody resume is still unverified and suspended (D-023).
+        expect(admission_1.PROVIDER_EXECUTION_CAPABILITIES.cursor.durableResume).toBe('unverified');
     });
 });
 describe('awm watch surfaces the posture on the compiled binary (#168)', () => {

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

@@ -202,28 +202,51 @@ describe('process identity', () => {
         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('keeps Darwin-style rows with blank or dotted cputime in the tree', () => {
+            // macOS `ps -o time=` is often `0:00.01`; a brand-new process can also
+            // omit the third column entirely on some samples.
+            expect((0, process_1.descendantActivity)('  10     1 0:00.05\n  20    10 0:00.01\n  30    20\n', 10)).toMatch(/^2:/);
+            expect((0, process_1.descendantActivity)('  10     1\n  20    10\n', 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 script = "setTimeout(() => { require('child_process').spawn(process.execPath, ['-e', 'setTimeout(()=>{}, 15000)'], { detached: true, stdio: 'ignore' }).unref(); }, 200); setTimeout(()=>{}, 15000)";
         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++) {
+            // Wait for a concrete baseline (not `unknown` from a transient ps miss).
+            let before = (0, process_1.activitySnapshot)(ref);
+            for (let i = 0; i < 50 && (before === null || before.descendants === 'unknown'); i++) {
                 await new Promise((resolve) => setTimeout(resolve, 50));
-                after = (0, process_1.activitySnapshot)(ref);
+                before = (0, process_1.activitySnapshot)(ref);
+            }
+            expect(before).not.toBeNull();
+            expect(before.descendants).not.toBe('unknown');
+            const beforeGroup = before.groupSize;
+            let after = before;
+            const deadline = Date.now() + 8000;
+            while (Date.now() < deadline) {
+                const snap = (0, process_1.activitySnapshot)(ref);
+                if (snap !== null)
+                    after = snap;
+                // Success: same process group, at least one PPID-descendant appeared.
+                if (after.groupSize === beforeGroup && /^[1-9]\d*:/.test(after.descendants))
+                    break;
+                await new Promise((resolve) => setTimeout(resolve, 100));
             }
-            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:/);
+            expect(after.groupSize).toBe(beforeGroup);
+            expect(after.descendants).toMatch(/^[1-9]\d*:/);
         }
         finally {
+            // Detached grandchildren are outside `-PGID`; reap by parent pid too.
+            try {
+                const { execFileSync } = require('child_process');
+                execFileSync('pkill', ['-P', String(ref.pid)], { stdio: 'ignore', timeout: 1000 });
+            }
+            catch { /* ya ausente */ }
             try {
                 process.kill(-ref.processGroup, 'SIGKILL');
             }

package/dist/tests/core/provider-version.test.js

@@ -75,6 +75,26 @@ describe('assertProviderSupported', () => {
         });
         expect(exec).not.toHaveBeenCalled();
     });
+    it('accepts the Cursor date-based agent line (Plan C)', () => {
+        const exec = jest.fn(() => Buffer.from('2026.09.26-dd393fe\n'));
+        expect((0, provider_version_1.assertProviderSupported)('cursor', exec)).toEqual({
+            provider: 'cursor',
+            version: '2026.09.26',
+        });
+        expect(exec).toHaveBeenCalledWith('agent', ['--version'], expect.any(Object));
+    });
+    it.each([
+        [Buffer.from('2026.09.25-abc1234\n'), 'requires Cursor >= 2026.09.26'],
+        [Buffer.from('2026.09.26\n'), 'could not parse Cursor version'],
+        [Buffer.from('v2026.09.26-dd393fe\n'), 'could not parse Cursor version'],
+    ])('rejects unsupported Cursor output without mutation', (output, message) => {
+        expect(() => (0, provider_version_1.assertProviderSupported)('cursor', () => output)).toThrow(message);
+    });
+    it('reports a missing Cursor agent binary distinctly', () => {
+        const missing = Object.assign(new Error('spawnSync agent ENOENT'), { code: 'ENOENT' });
+        expect(() => (0, provider_version_1.assertProviderSupported)('cursor', () => { throw missing; }))
+            .toThrow('Cursor is not installed or not available on PATH');
+    });
     it('reports a missing Codex binary distinctly', () => {
         const missing = Object.assign(new Error('spawnSync codex ENOENT'), { code: 'ENOENT' });
         expect(() => (0, provider_version_1.assertProviderSupported)('codex', () => { throw missing; }))

package/dist/tests/providers/index.test.js

@@ -210,6 +210,14 @@ describe('Providers Routing', () => {
             });
             expect((0, providers_1.providerFor)('copilot').hooks).toBeUndefined();
         });
+        it('declares Cursor agent version gate (Plan C R26)', () => {
+            expect((0, providers_1.providerFor)('cursor').minimumVersion).toBe('2026.09.26');
+            expect((0, providers_1.providerFor)('cursor').versionCommand).toEqual({
+                command: 'agent',
+                args: ['--version'],
+                versionPattern: /^(\d{4}\.\d{2}\.\d{2})-[0-9a-f]+$/,
+            });
+        });
         it('assigns Copilot instructions renderer; Cursor skills use link (cursor-mdc kept for migration)', () => {
             expect((0, providers_1.providerFor)('cursor').skill.renderer).toBe('link');
             expect((0, providers_1.providerFor)('copilot').skill.renderer).toBe('copilot-instructions');

package/package.json

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