agentic-workflow-manager 9.12.4 → 9.13.0

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

@@ -106,6 +106,7 @@ function reportPayload(report, planPath) {
         case 'valid':
             return {
                 state: report.state, path: planPath, schema: report.schema, planId: report.manifest.planId,
+                ...(report.dispatchMode ? { dispatchMode: report.dispatchMode } : {}),
                 planDigest: report.planDigest,
                 requirements: report.manifest.requirements.length, sources: report.manifest.sources.length,
                 commands: report.manifest.commands.length, slices: report.manifest.slices.length, completeOwnership: true,
@@ -259,11 +260,15 @@ function registerPlanCommand(program, deps = { validatePlanFile: validate_1.vali
         .description('validate a compact plan without modifying it')
         .option('--json', 'emit one stable JSON report')
         .option('--cwd <path>', 'repository root for plan containment and source resolution')
+        .option('--require-dispatch-mode', 'require an explicit dispatch choice for a newly authored plan')
         .action((planPath, options) => {
         assertText(planPath, 'plan path');
         const cwd = options.cwd ?? process.cwd();
         assertText(cwd, '--cwd');
-        const report = deps.validatePlanFile(planPath, cwd);
+        const validated = deps.validatePlanFile(planPath, cwd);
+        const report = options.requireDispatchMode && validated.state === 'valid' && !validated.dispatchMode
+            ? { state: 'invalid', diagnostics: [{ code: 'PLAN_DISPATCH_MODE', message: 'new plans must declare Modo de despacho before the manifest' }] }
+            : validated;
         const output = options.json === true
             ? `${JSON.stringify(reportPayload(report, planPath))}\n`
             : formatReport(report, planPath);

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/src/core/model-policy/resolve.js

@@ -152,6 +152,8 @@ function resolveV1Dispatch(input) {
     if (!input.plan || input.plan.schema !== 'compact-slices/v1')
         throw new Error('resolveV1Dispatch requires an authenticated v1 plan report');
     (0, validate_2.assertVerifiedValidPlanReport)(input.plan);
+    if (input.plan.dispatchMode === 'proveedor-nativo' && input.optInV1)
+        return blocked('ROUTING_DISPATCH_MODE', 'Provider-native plan forbids v1 routing opt-in; create a separately approved routed plan.');
     if (!input.optInV1)
         return { state: 'not-required', reason: 'v1-without-opt-in' };
     return resolveConfiguredSelection({ ...input, requestedProfile: 'full' });

package/dist/src/core/plan/validate.js

@@ -395,6 +395,12 @@ function validatePlan(planPath, cwd, snapshot) {
         return diagnostic('PLAN_LIMIT', 'plan id exceeds maximum string size');
     if ((raw.schema !== 'compact-slices/v1' && raw.schema !== 'compact-slices/v2') || (raw.schema === 'compact-slices/v1' && start !== START) || (raw.schema === 'compact-slices/v2' && start !== START_V2) || typeof raw.planId !== 'string' || !PLAN_ID.test(raw.planId) || !allStrings(raw.requirements) || new Set(raw.requirements).size !== raw.requirements.length)
         return diagnostic('PLAN_SHAPE', 'manifest scalar fields are invalid');
+    const dispatchHeaders = Array.from(text.slice(0, text.indexOf(start)).matchAll(/^[ \t]*\*\*Modo de despacho:\*\*[ \t]*([^\r\n]*)$/gm), match => match[1].trim());
+    if (dispatchHeaders.length > 1 || dispatchHeaders.some(value => value !== 'proveedor-nativo' && value !== 'awm-routed'))
+        return diagnostic('PLAN_DISPATCH_MODE', 'dispatch mode must occur once and be proveedor-nativo or awm-routed');
+    const dispatchMode = dispatchHeaders[0];
+    if (dispatchMode && ((dispatchMode === 'proveedor-nativo') !== (raw.schema === 'compact-slices/v1')))
+        return diagnostic('PLAN_DISPATCH_MODE', 'dispatch mode does not match compact plan schema');
     if (raw.requirements.some((id) => !validRequirementId(id)) || !allStrings(raw.closureCommands) || new Set(raw.closureCommands).size !== raw.closureCommands.length)
         return diagnostic('PLAN_SHAPE', 'manifest arrays or identifiers are invalid');
     const sourceIds = new Set();
@@ -488,6 +494,7 @@ function validatePlan(planPath, cwd, snapshot) {
         planDigest: crypto_1.default.createHash('sha256').update(text, 'utf8').digest('hex'),
         executionDigest: (0, identity_1.executionPlanDigest)(text),
         manifest: raw, executionMode: executionModeFromValidatedText(text),
+        ...(dispatchMode ? { dispatchMode } : {}),
     };
     freezeJson(report);
     verifiedValidReports.add(report);

package/dist/tests/commands/plan/index.test.js

@@ -57,6 +57,12 @@ describe('plan validate Commander wiring', () => {
         stdoutWrite.mockRestore();
         process.exitCode = previousExitCode;
     });
+    it('requires an explicit dispatch header for strict new-plan validation', async () => {
+        const program = commandFor(valid);
+        await program.parseAsync(['node', 'awm', 'plan', 'validate', 'plans/r4.md', '--cwd', repositoryRoot, '--require-dispatch-mode', '--json']);
+        expect(JSON.parse(String(stdoutWrite.mock.calls.at(-1)[0]))).toMatchObject({ state: 'invalid', diagnostics: [{ code: 'PLAN_DISPATCH_MODE' }] });
+        expect(process.exitCode).toBe(2);
+    });
     it('returns v1 not-required before reading personal policy or capability state', async () => {
         const policy = jest.fn();
         const capabilities = jest.fn();

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/dist/tests/core/plan/validate.test.js

@@ -10,6 +10,7 @@ const path_1 = __importDefault(require("path"));
 const crypto_1 = __importDefault(require("crypto"));
 const json_1 = require("../../../src/core/plan/json");
 const validate_1 = require("../../../src/core/plan/validate");
+const resolve_1 = require("../../../src/core/model-policy/resolve");
 jest.mock('child_process', () => ({ exec: jest.fn(), execFileSync: jest.fn(), execSync: jest.fn(), spawn: jest.fn(), spawnSync: jest.fn() }));
 const START = '<!-- AWM:COMPACT-SLICES:START v1 -->';
 const END = '<!-- AWM:COMPACT-SLICES:END v1 -->';
@@ -99,6 +100,42 @@ describe('validatePlanFile', () => {
         const report = (0, validate_1.validatePlanFile)(v2Fixture(root, profile), root);
         expect(report).toMatchObject({ state: 'valid', schema: 'compact-slices/v2', manifest: { slices: [expect.objectContaining({ implementerProfile: profile })] } });
     });
+    test.each([
+        ['proveedor-nativo', false],
+        ['awm-routed', true],
+    ])('accepts an explicit %s dispatch mode only with its matching schema', (mode, v2) => {
+        const plan = v2 ? v2Fixture(root) : fixture(root);
+        const before = fs_1.default.readFileSync(plan, 'utf8');
+        fs_1.default.writeFileSync(plan, `**Modo de despacho:** ${mode}\n${before}`);
+        expect((0, validate_1.validatePlanFile)(plan, root)).toMatchObject({ state: 'valid', dispatchMode: mode });
+        fs_1.default.writeFileSync(plan, `**Modo de despacho:** ${v2 ? 'proveedor-nativo' : 'awm-routed'}\n${before}`);
+        expect((0, validate_1.validatePlanFile)(plan, root)).toMatchObject({ state: 'invalid', diagnostics: [{ code: 'PLAN_DISPATCH_MODE' }] });
+    });
+    test.each(['indefinido', 'proveedor-nativo\n**Modo de despacho:** proveedor-nativo'])('rejects an invalid or duplicated dispatch header: %s', value => {
+        const plan = fixture(root);
+        fs_1.default.writeFileSync(plan, `**Modo de despacho:** ${value}\n${fs_1.default.readFileSync(plan, 'utf8')}`);
+        expect((0, validate_1.validatePlanFile)(plan, root)).toMatchObject({ state: 'invalid', diagnostics: [{ code: 'PLAN_DISPATCH_MODE' }] });
+    });
+    test('binds an explicit dispatch choice into plan and execution identity', () => {
+        const plan = fixture(root);
+        const historical = (0, validate_1.validatePlanFile)(plan, root);
+        fs_1.default.writeFileSync(plan, `**Modo de despacho:** proveedor-nativo\n${fs_1.default.readFileSync(plan, 'utf8')}`);
+        const explicit = (0, validate_1.validatePlanFile)(plan, root);
+        expect(historical).toMatchObject({ state: 'valid' });
+        expect(explicit).toMatchObject({ state: 'valid', dispatchMode: 'proveedor-nativo' });
+        if (historical.state !== 'valid' || explicit.state !== 'valid')
+            throw new Error('both v1 plans must validate');
+        expect(explicit.planDigest).not.toBe(historical.planDigest);
+        expect(explicit.executionDigest).not.toBe(historical.executionDigest);
+    });
+    test('does not let v1 opt-in override an explicit provider-native plan', () => {
+        const plan = fixture(root);
+        fs_1.default.writeFileSync(plan, `**Modo de despacho:** proveedor-nativo\n${fs_1.default.readFileSync(plan, 'utf8')}`);
+        const report = (0, validate_1.validatePlanFile)(plan, root);
+        if (report.state !== 'valid')
+            throw new Error('provider-native fixture must validate');
+        expect((0, resolve_1.resolveV1Dispatch)({ plan: report, optInV1: true, role: 'controller', runtime: { target: 'codex', kind: 'native', version: '1.0.0', accountScopeDigest: 'a'.repeat(64) }, now: new Date() })).toMatchObject({ state: 'blocked', diagnostics: [{ code: 'ROUTING_DISPATCH_MODE' }] });
+    });
     test('rejects v1 profile without weakening exact keys', () => {
         expect((0, validate_1.validatePlanFile)(fixture(root, manifest => { (manifest.slices[0]).implementerProfile = 'mechanical'; }), root)).toMatchObject({ state: 'invalid' });
     });

package/package.json

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