agentic-workflow-manager 9.12.5 → 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/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/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.5",
+  "version": "9.13.0",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"