agentic-workflow-manager 9.12.4 → 9.12.5

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

@@ -542,11 +542,18 @@ function applyRequestToState(s, env, digest, repoRoot, eventScope) {
                     { taskId, entity: 'dispatch', dispatchId: existing.id },
                     { taskId, dispatchId: existing.id, entity: 'dispatch' },
                 ].map(payload => (0, requests_1.digestOf)(payload));
-                const oldAckApplied = Object.values(s.appliedRequests).some(ack => ack.outcome === 'applied'
+                const appliedAcks = Object.values(s.appliedRequests);
+                const oldAckIndex = appliedAcks.findIndex(ack => ack.outcome === 'applied'
                     && ack.resultRef === existing.id && legacyDigests.includes(ack.payloadDigest));
+                const reservationAckIndex = appliedAcks.findIndex(ack => ack.requestId === attempt.reservationRequestId);
+                // The single writer appends ACKs to appliedRequests and persists
+                // their insertion order. Equal millisecond timestamps need this
+                // additional durable ordering evidence, not an inferred child.
+                const legacyPrecedesReservation = oldAt < reservedAt
+                    || (oldAt === reservedAt && oldAckIndex >= 0 && reservationAckIndex > oldAckIndex);
                 const safeLegacy = reservedForNewDispatch && Number.isFinite(oldAt) && Number.isFinite(reservedAt)
-                    && oldAt < reservedAt
-                    && oldAckApplied
+                    && legacyPrecedesReservation
+                    && oldAckIndex >= 0
                     && s.dispatches.filter(d => d.taskId === taskId).length === 1
                     && s.tasks.find(t => t.id === taskId)?.attempts === 1
                     && s.tasks.find(t => t.id === taskId)?.status === 'in-progress'

package/dist/tests/commands/watch/reopened-196.test.js

@@ -224,6 +224,37 @@ describe('issue #196 reopened: supervised S1 handoff', () => {
             .toThrow(/conflictivo/);
         expect(state.dispatches).toHaveLength(2);
     });
+    test('equal-millisecond legacy timestamps reconcile only when the durable dispatch ACK precedes the reservation ACK', () => {
+        const state = v2State();
+        const at = state.routingAttempts[0].reservedAt;
+        state.dispatches.push({ id: 'dispatch-S1', taskId: 'S1', at });
+        state.tasks[0].attempts = 1;
+        state.tasks[0].status = 'in-progress';
+        const reservationAck = state.appliedRequests['reserve-1'];
+        const historicalAck = { requestId: 'old-dispatch-request', idempotencyKey: 'old-dispatch-key',
+            payloadDigest: legacyDispatchDigest(), outcome: 'applied', resultRef: 'dispatch-S1' };
+        state.appliedRequests = { 'old-dispatch-request': historicalAck, 'reserve-1': reservationAck };
+        const durable = JSON.parse(JSON.stringify(state));
+        expect(Object.keys(durable.appliedRequests)).toEqual(['old-dispatch-request', 'reserve-1']);
+        dispatch(durable, { routingAttemptId: 'route-1' });
+        expect(durable.dispatches).toHaveLength(2);
+        expect(durable.dispatches[0]).toEqual({ id: 'dispatch-S1', taskId: 'S1', at });
+        expect(durable.appliedRequests['old-dispatch-request']).toEqual(historicalAck);
+        expect(durable.tasks[0].attempts).toBe(1);
+        expect((0, types_1.isWellFormedState)(durable)).toBe(true);
+    });
+    test('equal-millisecond legacy timestamps do not infer order from a later dispatch ACK', () => {
+        const state = v2State();
+        state.dispatches.push({ id: 'dispatch-S1', taskId: 'S1', at: state.routingAttempts[0].reservedAt });
+        state.tasks[0].attempts = 1;
+        state.tasks[0].status = 'in-progress';
+        state.appliedRequests['old-dispatch-request'] = { requestId: 'old-dispatch-request',
+            idempotencyKey: 'old-dispatch-key', payloadDigest: legacyDispatchDigest(),
+            outcome: 'applied', resultRef: 'dispatch-S1' };
+        expect(() => dispatch(state, { routingAttemptId: 'route-1' })).toThrow(/legacy handoff/);
+        expect(state.dispatches).toHaveLength(1);
+        expect(state.appliedRequests['dispatch-request']).toBeUndefined();
+    });
     test('historical ACK matching is independent of JSON key order but not payload identity', () => {
         for (const rawJson of [
             '{"taskId":"S1","dispatchId":"dispatch-S1"}',
@@ -972,10 +1003,10 @@ describe('issue #196 reopened: supervised S1 handoff', () => {
             (0, apply_1.consumePendingRequests)(repo, 'main', generation.token, scope);
             expect((0, store_1.readJournal)(repo, 'main').state.requestProblems).toEqual([]);
             expect(cli('ack', task.requestId).state).toBe('applied');
-            // Durable 9.12.2 intent predates the route reservation. Neither
-            // the record nor its old ACK may be rewritten to imply a child.
+            // Durable 9.12.2 intent and ACK precede the route reservation.
+            // Equal timestamp granularity alone must not imply a child.
             const historical = (0, store_1.readJournal)(repo, 'main').state;
-            const historicalAt = new Date(Date.now() - 60_000).toISOString();
+            let historicalAt = new Date(Date.now() - 60_000).toISOString();
             historical.dispatches.push({ id: 'dispatch-S1', taskId: 'S1', at: historicalAt });
             historical.tasks[0].attempts = 1;
             historical.tasks[0].status = 'in-progress';
@@ -989,6 +1020,14 @@ describe('issue #196 reopened: supervised S1 handoff', () => {
             const reservation = cli('ack', reserve.requestId);
             expect(reservation.state).toBe('applied');
             const attemptId = reservation.resultRef;
+            // Reproduce the real journal's millisecond tie without changing
+            // the durable ACK order or adding any native evidence.
+            const tied = (0, store_1.readJournal)(repo, 'main').state;
+            historicalAt = tied.routingAttempts.find(attempt => attempt.id === attemptId).reservedAt;
+            tied.dispatches[0].at = historicalAt;
+            expect(Object.keys(tied.appliedRequests).indexOf('old-dispatch-request'))
+                .toBeLessThan(Object.keys(tied.appliedRequests).indexOf(reserve.requestId));
+            (0, store_1.writeJournal)(repo, 'main', tied);
             const dispatchPayload = JSON.stringify({ dispatchId: 'dispatch-S1', taskId: 'S1', routingAttemptId: attemptId });
             const queuedDispatch = cli('register', '--generation', generation.token, '--entity', 'dispatch', '--json', dispatchPayload);
             expect(cli('ack', queuedDispatch.requestId).state).toBe('pending');

package/package.json

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