agentic-workflow-manager 9.16.1 → 9.18.0

package/dist/tests/commands/sensors/compatibility/manifest.test.js

@@ -19,6 +19,26 @@ function validV2Manifest() {
         },
     };
 }
+function projectSensor(overrides = {}) {
+    return {
+        source: 'project',
+        enabled: true,
+        command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+        ...overrides,
+    };
+}
+function v3WithPackAndProject(projectOverrides = {}) {
+    return {
+        schemaVersion: 3,
+        mode: 'project-sensors',
+        pack: 'js-ts',
+        source: { registry: 'baseline' },
+        sensors: {
+            lint: validV2Manifest().sensors.lint,
+            custom: projectSensor(projectOverrides),
+        },
+    };
+}
 describe('sensor manifest contract', () => {
     it('keeps compatibility contracts on an acyclic import boundary', () => {
         const source = (relative) => fs_1.default.readFileSync(path_1.default.join(__dirname, '../../../../src/commands/sensors', relative), 'utf8');
@@ -192,4 +212,188 @@ describe('sensor manifest contract', () => {
     ])('rejects malformed manifest %j', (input, message) => {
         expect(() => (0, manifest_1.parseSensorManifest)(input, 'sensors.json')).toThrow(message);
     });
+    describe('project-declared sensors (S1)', () => {
+        it('accepts a source:project entry alongside a pack-bound lint sensor', () => {
+            const manifest = v3WithPackAndProject();
+            const parsed = (0, manifest_1.parseSensorManifest)(manifest, 'sensors.json');
+            expect(parsed).toMatchObject({
+                kind: 'v3',
+                pack: {
+                    mode: 'project-sensors',
+                    pack: 'js-ts',
+                    sensors: {
+                        lint: { variantId: 'eslint-9', enabled: true },
+                        custom: {
+                            source: 'project',
+                            enabled: true,
+                            command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+                            formatter: 'exit-code',
+                        },
+                    },
+                },
+            });
+            expect(parsed.kind === 'v3' && parsed.pack.mode === 'project-sensors' && 'variantId' in parsed.pack.sensors.custom).toBe(false);
+            expect(parsed.kind === 'v3' && parsed.pack.mode === 'project-sensors' && 'initializedCompatibility' in parsed.pack.sensors.custom).toBe(false);
+        });
+        it('accepts an only-project manifest with pack omitted or null', () => {
+            const base = {
+                schemaVersion: 3,
+                mode: 'project-sensors',
+                sensors: { custom: projectSensor() },
+            };
+            for (const manifest of [base, { ...base, pack: null }]) {
+                const parsed = (0, manifest_1.parseSensorManifest)(manifest, 'sensors.json');
+                expect(parsed).toMatchObject({
+                    kind: 'v3',
+                    pack: {
+                        mode: 'project-sensors',
+                        sensors: { custom: { source: 'project', formatter: 'exit-code' } },
+                    },
+                });
+                if (parsed.kind === 'v3' && parsed.pack.mode === 'project-sensors') {
+                    expect(parsed.pack.pack === undefined || parsed.pack.pack === null).toBe(true);
+                    expect(parsed.pack.source).toBeUndefined();
+                }
+            }
+        });
+        it('accepts an empty only-project sensors map', () => {
+            expect((0, manifest_1.parseSensorManifest)({
+                schemaVersion: 3,
+                mode: 'project-sensors',
+                sensors: {},
+            }, 'sensors.json')).toMatchObject({
+                kind: 'v3',
+                pack: { mode: 'project-sensors', sensors: {} },
+            });
+        });
+        it.each(['variantId', 'initializedCompatibility'])('rejects a project entry that declares forbidden pack field %s', field => {
+            const value = field === 'variantId'
+                ? 'eslint-9'
+                : { state: 'certified', reason: 'ok', variantId: 'eslint-9', toolVersion: '9.0.0', runtimeVersion: '24.0.0', certifiedRange: '>=9 <10', evidence: [] };
+            const soft = (0, manifest_1.parseSensorManifestWithIssues)(v3WithPackAndProject({ [field]: value }), 'sensors.json');
+            expect(soft.invalidEntries).toEqual([
+                expect.objectContaining({
+                    name: 'custom',
+                    reason: expect.stringMatching(new RegExp(`sensors\\.custom\\.${field}`)),
+                }),
+            ]);
+            expect(soft).toMatchObject({
+                kind: 'v3',
+                pack: { sensors: { lint: { variantId: 'eslint-9' } } },
+            });
+            expect('custom' in soft.pack.sensors).toBe(false);
+        });
+        it('soft-rejects an invalid project command with sensors.<name>.command in the reason (RF-1.12)', () => {
+            const soft = (0, manifest_1.parseSensorManifestWithIssues)(v3WithPackAndProject({
+                command: { executable: 'bash', resolution: 'path', args: ['-c', 'true'] },
+            }), 'sensors.json');
+            expect(soft.invalidEntries).toHaveLength(1);
+            expect(soft.invalidEntries[0]?.reason).toMatch(/sensors\.custom\.command/);
+            expect(soft).toMatchObject({
+                kind: 'v3',
+                pack: { sensors: { lint: { variantId: 'eslint-9' } } },
+            });
+            expect('custom' in soft.pack.sensors).toBe(false);
+        });
+        it('soft-rejects an unmarked custom command as missing source (RF-1.2)', () => {
+            const soft = (0, manifest_1.parseSensorManifestWithIssues)({
+                schemaVersion: 3,
+                mode: 'project-sensors',
+                pack: 'js-ts',
+                source: { registry: 'baseline' },
+                sensors: {
+                    lint: validV2Manifest().sensors.lint,
+                    custom: {
+                        enabled: true,
+                        command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+                    },
+                },
+            }, 'sensors.json');
+            expect(soft.invalidEntries).toEqual([
+                expect.objectContaining({
+                    name: 'custom',
+                    reason: expect.stringMatching(/sensors\.custom\.source/),
+                }),
+            ]);
+            expect(soft.invalidEntries[0]?.reason).toMatch(/source/);
+            expect(soft).toMatchObject({
+                kind: 'v3',
+                pack: { sensors: { lint: { variantId: 'eslint-9' } } },
+            });
+            // Soft-isolation: unmarked custom must be dropped, pack sibling kept.
+            expect('custom' in soft.pack.sensors).toBe(false);
+        });
+        it('rejects unknown formatter and defaults omitted formatter to exit-code', () => {
+            const soft = (0, manifest_1.parseSensorManifestWithIssues)(v3WithPackAndProject({ formatter: 'not-a-formatter' }), 'sensors.json');
+            expect(soft.invalidEntries).toEqual([
+                expect.objectContaining({
+                    name: 'custom',
+                    reason: expect.stringMatching(/sensors\.custom\.formatter/),
+                }),
+            ]);
+            const ok = (0, manifest_1.parseSensorManifest)(v3WithPackAndProject(), 'sensors.json');
+            expect(ok).toMatchObject({
+                kind: 'v3',
+                pack: { sensors: { custom: { formatter: 'exit-code' } } },
+            });
+        });
+        it('treats omitted applicability as always applicable and rejects invalid shapes', () => {
+            const ok = (0, manifest_1.parseSensorManifest)(v3WithPackAndProject(), 'sensors.json');
+            expect(ok.kind === 'v3' && ok.pack.mode === 'project-sensors' && !('applicability' in ok.pack.sensors.custom)).toBe(true);
+            const withApplicability = (0, manifest_1.parseSensorManifest)(v3WithPackAndProject({ applicability: { allFiles: ['package.json'] } }), 'sensors.json');
+            expect(withApplicability).toMatchObject({
+                kind: 'v3',
+                pack: { sensors: { custom: { applicability: { allFiles: ['package.json'] } } } },
+            });
+            const soft = (0, manifest_1.parseSensorManifestWithIssues)(v3WithPackAndProject({ applicability: {} }), 'sensors.json');
+            expect(soft.invalidEntries).toEqual([
+                expect.objectContaining({
+                    name: 'custom',
+                    reason: expect.stringMatching(/sensors\.custom\.applicability/),
+                }),
+            ]);
+        });
+        it('rejects schemaVersion 2 and legacy manifests that use source:project with migrate-to-v3', () => {
+            const v2 = {
+                schemaVersion: 2,
+                pack: 'js-ts',
+                sensors: {
+                    custom: {
+                        source: 'project',
+                        enabled: true,
+                        command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+                    },
+                },
+            };
+            expect(() => (0, manifest_1.parseSensorManifest)(v2, 'sensors.json')).toThrow(/migrate-to-v3|migrate to v3/i);
+            const legacy = {
+                pack: 'js-ts',
+                sensors: {
+                    custom: {
+                        source: 'project',
+                        enabled: true,
+                        cmd: 'npm run lint',
+                    },
+                },
+            };
+            expect(() => (0, manifest_1.parseSensorManifest)(legacy, 'sensors.json')).toThrow(/migrate-to-v3|migrate to v3/i);
+        });
+        it('soft-isolates one invalid project entry while keeping a valid pack sensor', () => {
+            const soft = (0, manifest_1.parseSensorManifestWithIssues)(v3WithPackAndProject({ formatter: 'not-a-formatter' }), 'sensors.json');
+            expect(soft.invalidEntries).toHaveLength(1);
+            expect(soft.invalidEntries[0]).toMatchObject({
+                name: 'custom',
+                reason: expect.stringMatching(/sensors\.custom\.formatter/),
+            });
+            expect(soft).toMatchObject({
+                kind: 'v3',
+                pack: {
+                    mode: 'project-sensors',
+                    sensors: { lint: { enabled: true, variantId: 'eslint-9' } },
+                },
+            });
+            expect('custom' in soft.pack.sensors).toBe(false);
+            expect(soft.invalidEntries.some(entry => /not valid JSON|valid JSON/i.test(entry.reason))).toBe(false);
+        });
+    });
 });

package/dist/tests/commands/sensors/init.test.js

@@ -95,3 +95,110 @@ describe('initSensors compatibility API', () => {
         expect(bootstrap_1.applySensorBootstrap).not.toHaveBeenCalled();
     });
 });
+describe('buildManifest project-declared preserve (S3)', () => {
+    let tmpDir;
+    let registryRoot;
+    beforeEach(() => {
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-init-s3-'));
+        registryRoot = makeRegistry();
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'package.json'), '{}');
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+        fs_1.default.rmSync(registryRoot, { recursive: true, force: true });
+    });
+    it('preserves an existing source:project entry byte-stable when regenerating pack sensors (RF-3.1)', () => {
+        const projectEntry = {
+            source: 'project',
+            enabled: true,
+            fast: true,
+            command: { executable: 'terraform', resolution: 'path', args: ['fmt', '-check'] },
+            formatter: 'exit-code',
+            description: 'keep-me',
+        };
+        // Collides with a pack default name: per-field merge would otherwise inject pack `cmd`.
+        const existing = {
+            pack: 'js-ts',
+            sensors: {
+                typecheck: projectEntry,
+            },
+        };
+        const merged = (0, init_1.buildManifest)('js-ts', existing, registryRoot, tmpDir);
+        expect(merged.sensors.typecheck).toEqual(projectEntry);
+        expect(merged.sensors.typecheck).not.toHaveProperty('cmd');
+    });
+    it('writes an only-project manifest without forcing pack:"generic" (RF-3.2)', () => {
+        const projectEntry = {
+            source: 'project',
+            enabled: true,
+            command: { executable: 'terraform', resolution: 'path', args: ['fmt', '-check'] },
+            formatter: 'exit-code',
+        };
+        const onlyProject = (0, init_1.buildManifest)(null, {
+            sensors: { 'iac-format': projectEntry },
+        }, undefined, tmpDir);
+        expect(onlyProject).not.toMatchObject({ pack: 'generic' });
+        expect(Object.prototype.hasOwnProperty.call(onlyProject, 'pack')).toBe(false);
+        expect(onlyProject.sensors['iac-format']).toEqual(projectEntry);
+        expect(JSON.stringify(onlyProject)).not.toMatch(/"pack"\s*:/);
+    });
+    it('preserves source:project entries when materialize regenerates pack sensors (RF-3.1)', () => {
+        const { materializePortableSensors } = require('../../../src/commands/sensors/compatibility/materialize');
+        const home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-init-mat-home-'));
+        const previousHome = process.env.AWM_HOME;
+        try {
+            process.env.AWM_HOME = home;
+            const packDir = path_1.default.join(home, 'registries', 'baseline', 'sensor-packs', 'js-ts');
+            fs_1.default.mkdirSync(packDir, { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(packDir, 'eslint.config.awm.mjs'), 'export default []\n');
+            fs_1.default.writeFileSync(path_1.default.join(packDir, 'pack.json'), JSON.stringify({
+                schemaVersion: 2, name: 'js-ts', description: 'fixture', detects: ['package.json'],
+                coverage: { schemaVersion: 1, classes: {} },
+                sensors: { lint: { variants: [] } },
+            }));
+            const projectEntry = {
+                source: 'project',
+                enabled: true,
+                command: { executable: 'terraform', resolution: 'path', args: ['fmt', '-check'] },
+                formatter: 'exit-code',
+                description: 'preserve-me',
+            };
+            fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
+                schemaVersion: 3, mode: 'project-sensors', pack: 'js-ts', source: { registry: 'baseline' },
+                sensors: { 'iac-format': projectEntry },
+            }));
+            const evidence = {
+                state: 'certified', reason: 'range-and-probe', variantId: 'eslint-10',
+                toolVersion: '10.0.0', runtimeVersion: process.versions.node, certifiedRange: '>=10 <11', evidence: [],
+            };
+            const result = materializePortableSensors({
+                projectRoot: tmpDir,
+                pack: 'js-ts',
+                source: {
+                    path: path_1.default.join(packDir, 'pack.json'),
+                    content: fs_1.default.readFileSync(path_1.default.join(packDir, 'pack.json'), 'utf8'),
+                    registry: { name: 'baseline', remote: 'https://example.test/baseline.git', contentRoot: path_1.default.join(home, 'registries', 'baseline') },
+                },
+                configure: false,
+                sensors: {
+                    lint: {
+                        enabled: true, variantId: 'eslint-10',
+                        command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+                        assets: ['eslint.config.awm.mjs'],
+                        initializedCompatibility: evidence,
+                    },
+                },
+            });
+            expect(result.manifest.sensors['iac-format']).toEqual(projectEntry);
+            expect(JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), 'utf8')).sensors['iac-format']).toEqual(projectEntry);
+        }
+        finally {
+            if (previousHome === undefined)
+                delete process.env.AWM_HOME;
+            else
+                process.env.AWM_HOME = previousHome;
+            fs_1.default.rmSync(home, { recursive: true, force: true });
+        }
+    });
+});

package/dist/tests/commands/sensors/migrate.test.js

@@ -154,11 +154,12 @@ describe('planV2Migration', () => {
         try {
             fs_1.default.writeFileSync(manifestPath, original);
             const candidate = (0, migrate_1.planV2Migration)({ manifest: v2, source: resolvedSource() }).candidate;
-            const withoutPolicy = { ...candidate.sensors.lint };
+            const lint = candidate.sensors.lint;
+            const withoutPolicy = { ...lint };
             delete withoutPolicy.policyRef;
             for (const changed of [
-                { ...candidate.sensors.lint, fast: false },
-                { ...candidate.sensors.lint, variantId: 'eslint-8', initializedCompatibility: { ...candidate.sensors.lint.initializedCompatibility, variantId: 'eslint-8', toolVersion: '8.0.0', certifiedRange: '>=8 <9' } },
+                { ...lint, fast: false },
+                { ...lint, variantId: 'eslint-8', initializedCompatibility: { ...lint.initializedCompatibility, variantId: 'eslint-8', toolVersion: '8.0.0', certifiedRange: '>=8 <9' } },
                 withoutPolicy,
             ]) {
                 expect(() => (0, migrate_1.replaceV2ManifestWithV3)(manifestPath, { ...candidate, sensors: { lint: changed } }, resolvedSource())).toThrow('semantic mismatch');

package/dist/tests/commands/sensors/partial-pack-bootstrap.test.js

@@ -52,7 +52,7 @@ describe('project-sensors bootstrap with a partially resolvable pack', () => {
         const manifest = created.manifest;
         // The manifest contents are the assertion, not the exit code.
         expect(Object.keys(manifest.sensors)).toEqual(['lint']);
-        expect(manifest.sensors.lint.variantId).toBe('eslint-10');
+        expect(manifest.sensors.lint).toMatchObject({ variantId: 'eslint-10' });
         expect(created.unresolved).toEqual([{ sensor: 'security', state: 'missing-tool', reason: 'tool-not-found' }]);
         // Nothing is invented for the skipped sensor: no entry, and none of its assets.
         expect(created.changes.map(change => change.path)).toEqual(['.awm/sensors.json']);

package/dist/tests/commands/sensors/prepare.test.js

@@ -86,6 +86,68 @@ describe('validateRunOptions', () => {
             .toThrow(/refusing to combine --changed with a baseline capture/);
     });
 });
+describe('prepareV2Sensor: project-declared entries (S2)', () => {
+    const projectSensor = (overrides = {}) => ({
+        source: 'project',
+        enabled: true,
+        command: { executable: 'node', resolution: 'path', args: ['scripts/iac-format.js'] },
+        formatter: 'exit-code',
+        timeout: 45_000,
+        ...overrides,
+    });
+    test('uses the manifest command, default exit-code formatter, project timeout, and project-declared provenance', () => {
+        const prepared = (0, prepare_1.prepareV2Sensor)({
+            name: 'iac-format',
+            sensor: projectSensor(),
+            requestedScope: 'full',
+        });
+        expect(prepared.command).toEqual({
+            kind: 'structured',
+            value: { executable: 'node', resolution: 'path', args: ['scripts/iac-format.js'] },
+        });
+        expect(prepared.formatter).toBe('exit-code');
+        expect(prepared.timeoutMs).toBe(45_000);
+        expect(prepared.timeoutSource).toBe('project');
+        expect(prepared.certification).toBe('project-declared');
+        expect(prepared.certification).not.toBe('certified');
+        expect(prepared.syntheticStatus).toBeUndefined();
+    });
+    test('skips live variant re-resolution for project entries', () => {
+        const prepared = (0, prepare_1.prepareV2Sensor)({
+            name: 'iac-format',
+            sensor: projectSensor(),
+            liveState: {
+                state: 'missing-tool',
+                reason: 'tool-not-found',
+                variantId: null,
+                toolVersion: null,
+                runtimeVersion: null,
+                certifiedRange: null,
+                evidence: [],
+            },
+            requestedScope: 'full',
+        });
+        expect(prepared.command).toEqual({
+            kind: 'structured',
+            value: { executable: 'node', resolution: 'path', args: ['scripts/iac-format.js'] },
+        });
+        expect(prepared.certification).toBe('project-declared');
+    });
+    test('returns synthetic not-applicable when project applicabilityPaths are not met', () => {
+        const prepared = (0, prepare_1.prepareV2Sensor)({
+            name: 'iac-format',
+            sensor: projectSensor({
+                applicability: { allFiles: ['terraform.tf'] },
+            }),
+            applicabilityPaths: ['README.md'],
+            requestedScope: 'full',
+        });
+        expect(prepared.command).toBeUndefined();
+        expect(prepared.syntheticStatus).toBe('inconclusive');
+        expect(prepared.syntheticReason).toBe('not-applicable: applicability-not-met');
+        expect(prepared.certification).toBe('project-declared');
+    });
+});
 // El bloqueo que esto arregla: `compatible-unverified` significa que la herramienta esta,
 // cae en el rango operativo declarado por el pack y su probe coincidio — solo la version
 // exacta no es la que el registry congelo. Saltearla dejaba el veredicto en

package/dist/tests/commands/sensors/result.test.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const result_1 = require("../../../src/commands/sensors/result");
+const exec_fixtures_1 = require("./exec-fixtures");
+function prepared(overrides = {}) {
+    return {
+        name: 'iac-format',
+        formatter: 'exit-code',
+        timeoutMs: 30_000,
+        timeoutSource: 'project',
+        requestedScope: 'full',
+        effectiveScope: 'full',
+        certification: 'project-declared',
+        command: { kind: 'structured', value: { executable: 'node', resolution: 'path', args: ['check.js'] } },
+        ...overrides,
+    };
+}
+describe('interpretResult exit-code formatter (RF-2.4)', () => {
+    it('maps exit 0 to pass with no per-file findings', () => {
+        const result = (0, result_1.interpretResult)(prepared(), (0, exec_fixtures_1.ok)('all good\n'));
+        expect(result).toMatchObject({
+            name: 'iac-format',
+            status: 'pass',
+            errors: [],
+            certification: 'project-declared',
+        });
+    });
+    it('maps non-zero exit to fail with truncated combined stdout/stderr evidence and no invented per-file findings', () => {
+        const long = `${'x'.repeat(300)}\n`;
+        const result = (0, result_1.interpretResult)(prepared(), (0, exec_fixtures_1.exited)(1, long, 'stderr-tail\n'));
+        expect(result.status).toBe('fail');
+        expect(result.errors).toHaveLength(1);
+        expect(result.errors[0].file).toBeUndefined();
+        expect(result.errors[0].line).toBeUndefined();
+        expect(result.errors[0].rule).toBeUndefined();
+        // Combined = stdout+stderr; truncateEvidence caps at 200 — must be truncated
+        // stdout-first content, not a loose "exit 1" / stderr-only fallback.
+        expect(result.errors[0].message.length).toBeLessThanOrEqual(200);
+        expect(result.errors[0].message).toMatch(/^x{10,}/);
+        expect(result.errors[0].message).not.toMatch(/exit 1/);
+        expect(result.certification).toBe('project-declared');
+    });
+    it('maps non-zero exit with empty stdout/stderr to fail evidence that includes exit N', () => {
+        const result = (0, result_1.interpretResult)(prepared(), (0, exec_fixtures_1.exited)(7, '', ''));
+        expect(result.status).toBe('fail');
+        expect(result.errors).toHaveLength(1);
+        expect(result.errors[0].file).toBeUndefined();
+        expect(result.errors[0].message).toMatch(/exit 7/);
+    });
+});
+describe('executePrepared synthetic provenance (RF-2.2)', () => {
+    it('includes certification on synthetic/disabled results the same way interpretResult does', async () => {
+        const result = await (0, result_1.executePrepared)(prepared({
+            command: undefined,
+            syntheticStatus: 'skipped',
+            syntheticReason: 'disabled',
+            certification: 'project-declared',
+        }));
+        expect(result).toMatchObject({
+            name: 'iac-format',
+            status: 'skipped',
+            skipReason: 'disabled',
+            certification: 'project-declared',
+        });
+    });
+});