agentic-workflow-manager 9.15.0 → 9.16.0

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

@@ -13,6 +13,7 @@ const capabilities_1 = require("../../core/model-policy/capabilities");
 const adapter_1 = require("../../core/journal/adapter");
 const process_1 = require("../../core/journal/process");
 const adapter_2 = require("../../core/journal/adapter");
+const durable_custody_1 = require("../../core/journal/durable-custody");
 const context_1 = require("../../core/tracks/context");
 const concurrency_1 = require("../../core/tracks/concurrency");
 const validate_1 = require("../../core/plan/validate");
@@ -20,6 +21,12 @@ const path_1 = __importDefault(require("path"));
 const archive_unused_1 = require("./archive-unused");
 const store_1 = require("../../core/journal/store");
 const fingerprint_1 = require("../../core/journal/fingerprint");
+function refuseIfDurableCustodySuspended() {
+    if (!(0, durable_custody_1.isDurableCustodySuspended)())
+        return;
+    process.stderr.write(`${durable_custody_1.DURABLE_CUSTODY_SUSPENDED_MESSAGE}\n`);
+    process.exit(1);
+}
 function currentBranch(cwd) {
     // stdio explicito (ver EXEC_STDIO en journal/process.ts): evita el relay
     // default de execFileSync del stderr de git hacia el stderr del llamante,
@@ -61,6 +68,9 @@ function registerWatchCommand(program) {
         // #168: sin esto el controller desatendido arranca y se cuelga en la
         // primera herramienta pidiendo aprobación. Se declara, no se adivina.
         .option('--controller-autonomy <postura>', `postura del controller desatendido (${adapter_1.CONTROLLER_AUTONOMIES.join(' | ')})`)
+        // Fail-closed for every watch verb (parent + subcommands) while durable
+        // custody is suspended. Help still works; only actions are refused.
+        .hook('preAction', () => { refuseIfDurableCustodySuspended(); })
         .action(async (opts) => {
         const repo = process.cwd();
         const branch = currentBranch(repo);

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

@@ -6,6 +6,7 @@ exports.sanitizeAdmissionReport = sanitizeAdmissionReport;
 exports.admitPlan = admitPlan;
 const providers_1 = require("../../providers");
 const paths_1 = require("../journal/paths");
+const durable_custody_1 = require("../journal/durable-custody");
 const resolve_1 = require("../model-policy/resolve");
 const capabilities_1 = require("../model-policy/capabilities");
 const UNKNOWN = {
@@ -24,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
@@ -242,10 +246,14 @@ async function admitPlan(input) {
         // The durable controller (journal + awm watch + jobs) is opt-in, as it
         // was before 9.8.0: native v1 dispatch with no journal on its branch
         // runs as one provider session. Creating a journal is the opt-in, and
-        // from then on it must be current. v2 routing custody lives in the
-        // journal, so awm-routed work still requires it.
+        // from then on it must be current. While durable custody is suspended
+        // (see durable-custody.ts), leftover journals must not trap native v1
+        // unattended work. v2 routing custody lives in the journal, so
+        // awm-routed work still requires it when that path is active.
         const observed = journalStatus(input, plan);
-        const journal = observed === 'missing' && plan.schema === 'compact-slices/v1' ? 'not-required' : observed;
+        const journal = plan.schema === 'compact-slices/v1' && (observed === 'missing' || (0, durable_custody_1.isDurableCustodySuspended)())
+            ? 'not-required'
+            : observed;
         if (journal !== 'current' && journal !== 'not-required')
             return blocked(input, [diagnostic('ADMISSION_JOURNAL_BINDING_REQUIRED', 'Unattended execution requires a healthy schema-2 journal binding for this exact plan; run watch --init --plan.')], { planDigest: plan.planDigest, provider, executionMode: mode, journal, currentness: input.requireCurrent ? 'current' : 'not-checked', cliCurrentness, sensors: sensorsReported, ...sensorEvidence });
         const capabilities = unattendedCapabilities(provider, input.controllerAutonomy);

package/dist/src/core/journal/durable-custody.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Durable custody = `awm watch` + journal-bound supervisor/controller relaunch.
+ *
+ * Suspended for every provider until routing/custody work resumes. The supported
+ * unattended path is the native provider session (compact-slices/v1, no journal).
+ *
+ * The Jest suite sets `AWM_ALLOW_DURABLE_CUSTODY=1` so the machinery stays tested
+ * for when this suspension is lifted. Operators never set that variable.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DURABLE_CUSTODY_SUSPENDED_MESSAGE = void 0;
+exports.isDurableCustodySuspended = isDurableCustodySuspended;
+exports.DURABLE_CUSTODY_SUSPENDED_MESSAGE = 'Durable custody (awm watch) is suspended for all providers until routing/custody work resumes. '
+    + 'Use native provider-session unattended (compact-slices/v1, no journal).';
+/** True for operators; false only when tests explicitly re-enable the machinery. */
+function isDurableCustodySuspended() {
+    return process.env.AWM_ALLOW_DURABLE_CUSTODY !== '1';
+}

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
@@ -177,6 +199,25 @@ describe('admitPlan', () => {
             expect(report.state).toBe('blocked');
             expect(report.diagnostics[0]).toMatchObject({ code: 'ADMISSION_CONTROLLER_AUTONOMY_REQUIRED' });
         });
+        // While Camino B is suspended, a leftover journal on the branch must not
+        // trap native v1 unattended admission. Jest sets AWM_ALLOW_DURABLE_CUSTODY=1
+        // for the rest of the suite; this case restores the operator default.
+        it('ignores leftover journals for native v1 while durable custody is suspended', async () => {
+            const previous = process.env.AWM_ALLOW_DURABLE_CUSTODY;
+            delete process.env.AWM_ALLOW_DURABLE_CUSTODY;
+            try {
+                const corrupt = await (0, admission_1.admitPlan)({ ...base(), journalCorrupt: true });
+                expect(corrupt).toMatchObject({ state: 'admitted', executionMode: 'desatendido', journal: 'not-required' });
+                const stale = await (0, admission_1.admitPlan)({ ...base(), journalState: { ...(0, types_1.emptyState)('main'), schema: 2, planBinding: { path: 'docs/plan.md', digest: 'b'.repeat(64), schema: 'compact-slices/v1', executionMode: 'desatendido', boundAt: '2026-09-15T00:00:00.000Z' } } });
+                expect(stale).toMatchObject({ state: 'admitted', journal: 'not-required' });
+            }
+            finally {
+                if (previous === undefined)
+                    delete process.env.AWM_ALLOW_DURABLE_CUSTODY;
+                else
+                    process.env.AWM_ALLOW_DURABLE_CUSTODY = previous;
+            }
+        });
     });
     // R8: a content registry whose sensors are ALL deliberately disabled may close
     // work; its release proof lives in CI. The local verdict stays not-certified —
@@ -247,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/durable-custody.test.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const durable_custody_1 = require("../../../src/core/journal/durable-custody");
+const watch_1 = require("../../../src/commands/watch");
+describe('durable custody suspension', () => {
+    const original = process.env.AWM_ALLOW_DURABLE_CUSTODY;
+    afterEach(() => {
+        if (original === undefined)
+            delete process.env.AWM_ALLOW_DURABLE_CUSTODY;
+        else
+            process.env.AWM_ALLOW_DURABLE_CUSTODY = original;
+    });
+    it('is suspended for operators (env unset) and only re-enabled by the Jest harness', () => {
+        delete process.env.AWM_ALLOW_DURABLE_CUSTODY;
+        expect((0, durable_custody_1.isDurableCustodySuspended)()).toBe(true);
+        process.env.AWM_ALLOW_DURABLE_CUSTODY = '0';
+        expect((0, durable_custody_1.isDurableCustodySuspended)()).toBe(true);
+        process.env.AWM_ALLOW_DURABLE_CUSTODY = '1';
+        expect((0, durable_custody_1.isDurableCustodySuspended)()).toBe(false);
+    });
+    it('refuses every awm watch entry point while suspended', async () => {
+        delete process.env.AWM_ALLOW_DURABLE_CUSTODY;
+        const program = new commander_1.Command();
+        (0, watch_1.registerWatchCommand)(program);
+        const err = [];
+        const exit = jest.spyOn(process, 'exit').mockImplementation(((code) => {
+            throw Object.assign(new Error(`exit:${code ?? 0}`), { code });
+        }));
+        program.configureOutput({ writeErr: (s) => { err.push(String(s)); } });
+        // stderr write in the refusal helper bypasses configureOutput; capture it too.
+        const stderr = jest.spyOn(process.stderr, 'write').mockImplementation(((chunk) => {
+            err.push(String(chunk));
+            return true;
+        }));
+        await expect(program.parseAsync(['node', 'awm', 'watch', 'journal-status'])).rejects.toThrow(/exit:1/);
+        expect(err.join('')).toContain(durable_custody_1.DURABLE_CUSTODY_SUSPENDED_MESSAGE);
+        err.length = 0;
+        await expect(program.parseAsync(['node', 'awm', 'watch', '--init', '--plan', 'docs/plan.md'])).rejects.toThrow(/exit:1/);
+        expect(err.join('')).toContain(durable_custody_1.DURABLE_CUSTODY_SUSPENDED_MESSAGE);
+        exit.mockRestore();
+        stderr.mockRestore();
+    });
+});

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.0",
+  "version": "9.16.0",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"