agentic-workflow-manager 9.12.1 → 9.12.3

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

@@ -58,6 +58,7 @@ const currentnessCheck = __importStar(require("../../../src/core/currentness/che
 const sensorCommands = __importStar(require("../../../src/commands/sensors/run"));
 const preferencesConfig = __importStar(require("../../../src/utils/config"));
 const providers_1 = require("../../../src/providers");
+const adapterModule = __importStar(require("../../../src/core/journal/adapter"));
 jest.setTimeout(60000);
 // runSupervisorLoop's full external-controller lifecycle (spawn stub codex ->
 // identity captured by the wrapper -> adopted via collectControllerGeneration's
@@ -93,6 +94,18 @@ const admitted = async () => ({
     state: 'admitted', planState: 'valid', executionMode: 'desatendido',
     journal: 'current', currentness: 'current', sensors: 'pass', diagnostics: [],
 });
+/** Lifecycle fixtures do not spawn a real controller. Explicitly adopt a
+ * simulated native identity before expecting job dispatch. */
+function adoptFixtureController(repo) {
+    const state = (0, store_1.readJournal)(repo, 'main').state;
+    const gen = (0, generations_1.activeGeneration)(state);
+    gen.processRef = { pid: process.pid, processGroup: process.pid, startTime: 'fixture',
+        spawnNonce: gen.spawnNonce, argvDigest: gen.launchArgvDigest, psArgsDigest: 'b'.repeat(64) };
+    (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' });
+}
 /** Legacy fixtures predate compact-only admission; make their execution contract explicit. */
 function initUnattendedFixture(repo) {
     (0, init_1.initWatch)(repo, 'main');
@@ -266,6 +279,8 @@ describe('supervisor loop', () => {
         try {
             let sawContinueWithLiveJob = false;
             let outcome = 'continue';
+            expect(await sup.tick()).toBe('continue');
+            adoptFixtureController(repo);
             for (let i = 0; i < 400 && outcome !== 'complete'; i++) {
                 outcome = await sup.tick();
                 const s = (0, store_1.readJournal)(repo, 'main').state;
@@ -280,7 +295,8 @@ describe('supervisor loop', () => {
             expect(final.cycle.status).toBe('COMPLETE');
             expect(typeof final.cycle.completedAt).toBe('string');
             expect(Object.values(final.jobs).every((j) => j.executionState === 'exited' && j.verdict === 'pass')).toBe(true);
-            expect(final.generations.every((entry) => entry.state === 'terminated' && entry.processRef === undefined)).toBe(true);
+            expect(final.generations.every((entry) => entry.state === 'terminated'
+                && (entry.processRef === undefined || entry.processRef.pid === process.pid))).toBe(true);
             expect(controllerSpawnAttempts).toBeGreaterThan(0);
         }
         finally {
@@ -356,6 +372,8 @@ describe('supervisor loop', () => {
             };
             const sup = new supervisor_1.Supervisor(repo, 'main', cfg, lifecycleSpawner, undefined, admitted);
             let outcome = 'continue';
+            expect(await sup.tick()).toBe('continue');
+            adoptFixtureController(repo);
             for (let i = 0; i < 400 && outcome !== 'complete'; i++) {
                 outcome = await sup.tick();
                 await new Promise((r) => setTimeout(r, 50));
@@ -367,7 +385,10 @@ describe('supervisor loop', () => {
             for (const t of final.tracks)
                 expect(['REMOVED', 'DECLARED']).toContain(t.phase);
             const { refIsAlive } = require('../../../src/core/journal/process');
-            expect(final.generations.every((entry) => entry.state === 'terminated' && (entry.processRef === undefined || !refIsAlive(entry.processRef)))).toBe(true);
+            // The fixture adopts this Jest process as its controller; it is
+            // intentionally not killed on COMPLETE and remains alive on Windows.
+            expect(final.generations.every((entry) => entry.state === 'terminated'
+                && (entry.processRef === undefined || entry.processRef.pid === process.pid || !refIsAlive(entry.processRef)))).toBe(true);
         }
         finally {
             fs_1.default.rmSync(tracksRoot, { recursive: true, force: true });
@@ -416,9 +437,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 +467,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.1",
+  "version": "9.12.3",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"