agentic-workflow-manager 9.12.0 → 9.12.2

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

@@ -416,9 +416,12 @@ describe('supervisor loop', () => {
         });
         let spawned = 0;
         const sup = new supervisor_1.Supervisor(repo, 'main', supervisor_1.DEFAULT_SUPERVISOR_CONFIG, () => { spawned += 1; }, undefined, notCertified);
+        let now = Date.now();
+        jest.spyOn(Date, 'now').mockImplementation(() => now);
         for (let i = 0; i < supervisor_1.MAX_SENSOR_DEFERRALS; i += 1) {
             expect(await sup.tick()).toBe('continue');
             expect((0, store_1.readJournal)(repo, 'main').state.cycle.status).toBe('IN_PROGRESS');
+            now += 5000;
         }
         // The verdict never settled, so the supervisor must stop pretending it might.
         expect(await sup.tick()).toBe('custody');
@@ -443,6 +446,91 @@ describe('supervisor loop', () => {
         // Deferring dispatch was right throughout, and stays right.
         expect(spawned).toBe(0);
     });
+    test('unverifiable currentness retries durably across supervisor restart and does not spawn before admitted', async () => {
+        initUnattendedFixture(repo);
+        let now = Date.now();
+        jest.spyOn(Date, 'now').mockImplementation(() => now);
+        let verdict = 'unverifiable';
+        const observe = async () => verdict === 'unverifiable'
+            ? { state: 'blocked', planState: 'valid', executionMode: 'desatendido', journal: 'not-required', currentness: 'unverifiable', sensors: 'not-required', diagnostics: [{ code: 'ADMISSION_CURRENTNESS_BLOCKED', message: 'registry:baseline' }] }
+            : admitted();
+        let spawned = 0;
+        const spawn = () => { spawned += 1; };
+        expect(await new supervisor_1.Supervisor(repo, 'main', supervisor_1.DEFAULT_SUPERVISOR_CONFIG, spawn, undefined, observe, true).tick()).toBe('continue');
+        expect((0, store_1.readJournal)(repo, 'main').state).toHaveProperty('admissionRetry.attempts', 1);
+        expect((0, store_1.readJournal)(repo, 'main').state.generations).toHaveLength(0);
+        expect(spawned).toBe(0);
+        // New supervisor instance represents a process restart. Repeated early
+        // ticks cannot spend or reset the durable retry budget.
+        const restarted = new supervisor_1.Supervisor(repo, 'main', supervisor_1.DEFAULT_SUPERVISOR_CONFIG, spawn, undefined, observe, true);
+        expect(await restarted.tick()).toBe('continue');
+        expect((0, store_1.readJournal)(repo, 'main').state).toHaveProperty('admissionRetry.attempts', 1);
+        now += 5000;
+        verdict = 'current';
+        expect(await restarted.tick()).toBe('continue');
+        expect((0, store_1.readJournal)(repo, 'main').state).not.toHaveProperty('admissionRetry');
+        expect((0, store_1.readJournal)(repo, 'main').state.cycle.status).toBe('IN_PROGRESS');
+        expect((0, store_1.readJournal)(repo, 'main').state.generations).toHaveLength(1);
+        expect(spawned).toBeGreaterThan(0);
+    });
+    test('stale currentness is conclusive and never receives transient retry budget', async () => {
+        initUnattendedFixture(repo);
+        const blocked = async () => ({ state: 'blocked', planState: 'valid', executionMode: 'desatendido', journal: 'current', currentness: 'stale', sensors: 'not-required', diagnostics: [{ code: 'ADMISSION_CURRENTNESS_BLOCKED', message: 'stale' }] });
+        let spawned = 0;
+        expect(await new supervisor_1.Supervisor(repo, 'main', supervisor_1.DEFAULT_SUPERVISOR_CONFIG, () => { spawned++; }, undefined, blocked).tick()).toBe('custody');
+        const state = (0, store_1.readJournal)(repo, 'main').state;
+        expect(state.cycle.status).toBe('BLOCKED');
+        expect(state).not.toHaveProperty('admissionRetry');
+        expect(state.generations).toHaveLength(0);
+        expect(spawned).toBe(0);
+    });
+    test('first admission observation binds provider, runtime and autonomy; changed restart identity never dispatches', async () => {
+        initUnattendedFixture(repo);
+        const identity = { kind: 'native', version: '1.0.0', accountScopeDigest: 'a'.repeat(64) };
+        const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, routingIdentity: identity, controllerAutonomy: 'approval-free' };
+        const notCurrent = async () => ({ state: 'blocked', planState: 'valid', executionMode: 'desatendido', journal: 'not-required', currentness: 'unverifiable', sensors: 'not-required', diagnostics: [{ code: 'ADMISSION_CURRENTNESS_BLOCKED', message: 'temporary' }] });
+        let spawns = 0;
+        expect(await new supervisor_1.Supervisor(repo, 'main', cfg, () => { spawns++; }, undefined, notCurrent).tick()).toBe('continue');
+        expect((0, store_1.readJournal)(repo, 'main').state).toHaveProperty('admissionContext', { provider: 'codex', runtime: identity, controllerAutonomy: 'approval-free' });
+        const changed = { ...cfg, routingIdentity: { ...identity, accountScopeDigest: 'b'.repeat(64) } };
+        expect(await new supervisor_1.Supervisor(repo, 'main', changed, () => { spawns++; }, undefined, admitted).tick()).toBe('custody');
+        expect((0, store_1.readJournal)(repo, 'main').state.cycle.status).toBe('BLOCKED');
+        expect(spawns).toBe(0);
+    });
+    test('alternating transient causes share one durable retry budget', async () => {
+        initUnattendedFixture(repo);
+        let now = Date.now();
+        jest.spyOn(Date, 'now').mockImplementation(() => now);
+        let reads = 0;
+        const alternating = async () => {
+            const sensor = reads++ % 2 === 1;
+            return sensor
+                ? { state: 'blocked', planState: 'valid', executionMode: 'desatendido', journal: 'not-required', currentness: 'current', sensors: 'not-certified', diagnostics: [{ code: 'ADMISSION_SENSORS_BLOCKED', message: 'temporary' }] }
+                : { state: 'blocked', planState: 'valid', executionMode: 'desatendido', journal: 'not-required', currentness: 'unverifiable', sensors: 'not-required', diagnostics: [{ code: 'ADMISSION_CURRENTNESS_BLOCKED', message: 'temporary' }] };
+        };
+        let spawns = 0;
+        for (let i = 0; i < supervisor_1.MAX_SENSOR_DEFERRALS + 1; i++) {
+            const outcome = await new supervisor_1.Supervisor(repo, 'main', supervisor_1.DEFAULT_SUPERVISOR_CONFIG, () => { spawns++; }, undefined, alternating).tick();
+            expect(outcome).toBe(i < supervisor_1.MAX_SENSOR_DEFERRALS ? 'continue' : 'custody');
+            now += 5000;
+        }
+        expect(reads).toBe(supervisor_1.MAX_SENSOR_DEFERRALS + 1);
+        expect(spawns).toBe(0);
+        expect((0, store_1.readJournal)(repo, 'main').state.generations).toHaveLength(0);
+    });
+    test('an incomplete first configuration can be corrected before dispatch without trapping the cycle', async () => {
+        initUnattendedFixture(repo);
+        const notCurrent = async () => ({ state: 'blocked', planState: 'valid', executionMode: 'desatendido', journal: 'not-required', currentness: 'unverifiable', sensors: 'not-required', diagnostics: [{ code: 'ADMISSION_CURRENTNESS_BLOCKED', message: 'temporary' }] });
+        let spawned = 0;
+        expect(await new supervisor_1.Supervisor(repo, 'main', supervisor_1.DEFAULT_SUPERVISOR_CONFIG, () => { spawned++; }, undefined, notCurrent).tick()).toBe('continue');
+        expect((0, store_1.readJournal)(repo, 'main').state).not.toHaveProperty('admissionContext');
+        const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, routingIdentity: { kind: 'native', version: '1.0.0', accountScopeDigest: 'a'.repeat(64) }, controllerAutonomy: 'approval-free' };
+        const retry = (0, store_1.readJournal)(repo, 'main').state.admissionRetry;
+        jest.spyOn(Date, 'now').mockReturnValue(Date.parse(retry.nextRetryAt));
+        expect(await new supervisor_1.Supervisor(repo, 'main', cfg, () => { spawned++; }, undefined, admitted, true).tick()).toBe('continue');
+        expect((0, store_1.readJournal)(repo, 'main').state).toHaveProperty('admissionContext', { provider: 'codex', runtime: cfg.routingIdentity, controllerAutonomy: 'approval-free' });
+        expect(spawned).toBeGreaterThan(0);
+    });
     test('una admisión compacta bloqueada no lanza controlador ni wrappers', async () => {
         initUnattendedFixture(repo);
         const state = (0, store_1.readJournal)(repo, 'main').state;

package/package.json

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