agentic-workflow-manager 9.4.1 → 9.6.0

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

@@ -7,6 +7,7 @@ const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const run_1 = require("../../../src/commands/sensors/run");
+const status_1 = require("../../../src/commands/sensors/status");
 const verdict_1 = require("../../../src/commands/sensors/verdict");
 function mkTmp() {
     return fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-sensors-'));
@@ -14,10 +15,18 @@ function mkTmp() {
 // Define stable mock before jest.mock hoisting
 const mockRunCommand = jest.fn();
 const mockRunStructuredCommand = jest.fn();
+const mockResolveSensorProject = jest.fn((startCwd) => {
+    const actual = jest.requireActual('../../../src/commands/sensors/project');
+    return actual.resolveSensorProject(startCwd);
+});
 jest.mock('../../../src/commands/sensors/exec', () => ({
     runCommand: (...args) => mockRunCommand(...args),
     runStructuredCommand: (...args) => mockRunStructuredCommand(...args),
 }));
+jest.mock('../../../src/commands/sensors/project', () => {
+    const actual = jest.requireActual('../../../src/commands/sensors/project');
+    return { ...actual, resolveSensorProject: (startCwd) => mockResolveSensorProject(startCwd) };
+});
 const { ok, exited, timedOut } = require('./exec-fixtures');
 const MANIFEST = {
     pack: 'js-ts',
@@ -39,6 +48,7 @@ describe('runSensors', () => {
         fs_1.default.writeFileSync(path.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify(MANIFEST));
         mockRunCommand.mockReset();
         mockRunStructuredCommand.mockReset();
+        mockResolveSensorProject.mockClear();
     });
     afterEach(() => { fs_1.default.rmSync(tmpDir, { recursive: true }); });
     const load = () => require('../../../src/commands/sensors/run');
@@ -282,6 +292,22 @@ describe('runSensors v2 lifecycle contract', () => {
         expect(result).toEqual(expect.objectContaining({ overall: 'pass' }));
         expect(mockRunStructuredCommand).toHaveBeenCalledWith(expect.objectContaining({ executable: 'live-eslint' }), expect.any(Object));
     });
+    it('rebinds a missing v2 registryRoot through the unique configured source without mutation', async () => {
+        const manifestPath = path_1.default.join(project, '.awm', 'sensors.json');
+        const manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf8'));
+        delete manifest.registryRoot;
+        fs_1.default.writeFileSync(manifestPath, JSON.stringify(manifest));
+        const before = fs_1.default.readFileSync(manifestPath, 'utf8');
+        const inventoryPath = path_1.default.join(home, 'registries.json');
+        const inventoryBefore = fs_1.default.readFileSync(inventoryPath, 'utf8');
+        const { runSensors } = require('../../../src/commands/sensors/run');
+        const result = await runSensors({ cwd: project, fast: true });
+        expect(result).toMatchObject({ overall: 'pass', mode: 'project-sensors', reason: 'legacy-rebound' });
+        expect(result.source).toMatchObject({ kind: 'legacy-rebound', registry: 'baseline' });
+        expect(mockRunStructuredCommand).toHaveBeenCalledWith(expect.objectContaining({ executable: 'live-eslint' }), expect.any(Object));
+        expect(fs_1.default.readFileSync(manifestPath, 'utf8')).toBe(before);
+        expect(fs_1.default.readFileSync(inventoryPath, 'utf8')).toBe(inventoryBefore);
+    });
     it('scopes applicability detection and execution to packageRoot for a monorepo manifest', async () => {
         // Move the fixture project into a subdirectory ("cli") and point the
         // manifest at it via packageRoot — mirrors a monorepo where the
@@ -388,15 +414,92 @@ describe('runSensors — not_certified + auto-discovery', () => {
         expect(out.overall).toBe('not_certified');
         expect(out.sensors).toEqual([]);
     });
-    it('discovers .awm/sensors.json in a parent directory (walk-up)', async () => {
+    it('uses the same stable schema-unsupported reason as status', async () => {
+        tmpDir = mkTmp();
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.git'));
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'));
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({ schemaVersion: 99 }));
+        const status = await (0, status_1.computeSensorStatus)(tmpDir);
+        const run = await (0, run_1.runSensors)({ cwd: tmpDir });
+        expect(status).toMatchObject({ mode: 'invalid', reason: 'schema-unsupported' });
+        expect(run).toMatchObject({ mode: 'invalid', reason: 'schema-unsupported' });
+    });
+    it('resolves the same legacy project and execution cwd from root and nested CWD', async () => {
         tmpDir = mkTmp();
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.git'));
         fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'));
         fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({ pack: 'test', sensors: { noop: { cmd: 'echo ok', fast: true } } }));
         const nested = path_1.default.join(tmpDir, 'a', 'b');
         fs_1.default.mkdirSync(nested, { recursive: true });
-        const out = await (0, run_1.runSensors)({ cwd: nested });
-        expect(out.overall).toBe('not_certified');
-        expect(out.sensors.length).toBe(1);
+        const rootRun = await (0, run_1.runSensors)({ cwd: tmpDir });
+        const nestedRun = await (0, run_1.runSensors)({ cwd: nested });
+        expect(nestedRun).toEqual(rootRun);
+        expect(rootRun.overall).toBe('not_certified');
+        expect(rootRun.sensors).toHaveLength(1);
+        expect(mockResolveSensorProject).toHaveBeenCalledWith(tmpDir);
+        expect(mockResolveSensorProject).toHaveBeenCalledWith(nested);
+        expect(mockRunCommand).toHaveBeenNthCalledWith(1, 'echo ok', expect.objectContaining({ cwd: tmpDir }));
+        expect(mockRunCommand).toHaveBeenNthCalledWith(2, 'echo ok', expect.objectContaining({ cwd: tmpDir }));
+    });
+    it.each([
+        ['native-gate', 'Release-blocking CI is authoritative.'],
+        ['opt-out', 'This repository intentionally has no local gate.'],
+    ])('does not dispatch v3 %s declarations', async (mode, declarationReason) => {
+        tmpDir = mkTmp();
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.git'));
+        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, reason: declarationReason }));
+        const out = await (0, run_1.runSensors)({ cwd: tmpDir, all: true });
+        expect(out).toMatchObject({
+            overall: 'not_certified', mode, reason: `${mode}-declared`,
+            declarationReason,
+            projectRoot: tmpDir, manifestPath: path_1.default.join(tmpDir, '.awm', 'sensors.json'),
+        });
+        expect(out.sensors).toEqual([]);
+        expect(mockRunCommand).not.toHaveBeenCalled();
+        expect(mockRunStructuredCommand).not.toHaveBeenCalled();
+    });
+    it('reports bounded candidates and a remedy when v2 source resolution is ambiguous', async () => {
+        const previousHome = process.env.AWM_HOME;
+        const home = mkTmp();
+        try {
+            process.env.AWM_HOME = home;
+            const pack = {
+                schemaVersion: 2, name: 'js-ts', description: 'fixture', detects: ['package.json'],
+                coverage: { schemaVersion: 1, classes: { lint: { description: 'lint', detectors: [{ sensor: 'lint' }], remedy: { summary: 'fix', command: 'awm sensors init' } } } },
+                sensors: { lint: { applicability: { allFiles: ['package.json'] }, variants: [{
+                                id: 'eslint-10', priority: 1, certifiedRange: '>=10 <11',
+                                requirements: { tool: 'eslint', toolRange: '>=10 <11', runtime: 'node', runtimeRange: '>=0' },
+                                assets: [], formatter: 'generic', probe: { kind: 'package-script-present' },
+                                command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+                            }] } },
+            };
+            const registries = ['alpha', 'beta'];
+            fs_1.default.writeFileSync(path_1.default.join(home, 'registries.json'), JSON.stringify(registries.map(name => ({ name, remote: `https://example.test/${name}.git` }))));
+            for (const name of registries) {
+                const packDir = path_1.default.join(home, 'registries', name, 'sensor-packs', 'js-ts');
+                fs_1.default.mkdirSync(packDir, { recursive: true });
+                fs_1.default.writeFileSync(path_1.default.join(packDir, 'pack.json'), JSON.stringify(pack));
+            }
+            tmpDir = mkTmp();
+            fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.git'));
+            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: 2, pack: 'js-ts', sensors: {} }));
+            const out = await (0, run_1.runSensors)({ cwd: tmpDir });
+            expect(out).toMatchObject({
+                overall: 'not_certified', mode: 'source-ambiguous', reason: 'multiple-compatible-registries',
+                remedy: 'configure-one-logical-registry',
+                source: { kind: 'source-ambiguous', candidates: ['alpha', 'beta'] },
+            });
+            expect(out.source.candidates).toHaveLength(2);
+        }
+        finally {
+            if (previousHome === undefined)
+                delete process.env.AWM_HOME;
+            else
+                process.env.AWM_HOME = previousHome;
+            fs_1.default.rmSync(home, { recursive: true, force: true });
+        }
     });
 });
 describe('detectPackDrift', () => {

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

@@ -46,6 +46,26 @@ describe('computeSensorStatus', () => {
         expect(result.overall).toBe('NOT_CONFIGURED');
         expect(result.pack).toBeNull();
     });
+    it('resolves the Git-bounded project manifest from a nested CWD', async () => {
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.git'));
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, 'node_modules', '.bin'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'node_modules', '.bin', 'tsc'), '');
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
+            pack: 'js-ts', sensors: { typecheck: { cmd: 'npx tsc --noEmit', fast: true } },
+        }));
+        const nestedCwd = path_1.default.join(tmpDir, 'packages', 'app');
+        fs_1.default.mkdirSync(nestedCwd, { recursive: true });
+        await expect((0, status_1.computeSensorStatus)(nestedCwd)).resolves.toMatchObject({
+            overall: 'READY',
+            pack: 'js-ts',
+            mode: 'project-sensors',
+            reason: 'legacy-v1',
+            projectRoot: tmpDir,
+            manifestPath: path_1.default.join(tmpDir, '.awm', 'sensors.json'),
+            checks: { typecheck: { ok: true } },
+        });
+    });
     it.each([
         ['valid manifest', 'READY', () => {
                 installLocalBin('eslint');
@@ -218,17 +238,24 @@ describe('computeSensorStatus', () => {
             fs_1.default.writeFileSync(path_1.default.join(packageDir, 'node_modules', '.bin', 'eslint'), '');
             fs_1.default.writeFileSync(path_1.default.join(packageDir, 'eslint.config.awm.mjs'), 'export default []');
             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: 2, pack: 'js-ts', packageRoot: 'cli', registryRoot: registry,
+            const manifestPath = path_1.default.join(tmpDir, '.awm', 'sensors.json');
+            fs_1.default.writeFileSync(manifestPath, JSON.stringify({
+                schemaVersion: 2, pack: 'js-ts', packageRoot: 'cli',
                 sensors: { lint: {
                         enabled: true, variantId: 'eslint-10', command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.', '--config', 'eslint.config.awm.mjs'] },
                         assets: ['eslint.config.awm.mjs'],
                         initializedCompatibility: { state: 'certified', reason: 'range-and-probe', variantId: 'eslint-10', toolVersion: '10.4.1', runtimeVersion: process.versions.node, certifiedRange: '>=10.0.0 <11.0.0', evidence: [] },
                     } },
             }));
+            const manifestBefore = fs_1.default.readFileSync(manifestPath);
+            const inventoryPath = path_1.default.join(home, 'registries.json');
+            const inventoryBefore = fs_1.default.readFileSync(inventoryPath);
             const result = await (0, status_1.computeSensorStatus)(tmpDir);
             expect(result.checks.lint).toMatchObject({ ok: true });
             expect(result.overall).toBe('READY');
+            expect(result.source).toMatchObject({ kind: 'legacy-rebound', registry: 'baseline' });
+            expect(fs_1.default.readFileSync(manifestPath)).toEqual(manifestBefore);
+            expect(fs_1.default.readFileSync(inventoryPath)).toEqual(inventoryBefore);
             expect(runCommand).not.toHaveBeenCalled();
             expect(runStructuredCommand).not.toHaveBeenCalled();
         }
@@ -304,4 +331,81 @@ describe('computeSensorStatus', () => {
             fs_1.default.rmSync(home, { recursive: true, force: true });
         }
     });
+    it.each([
+        ['native-gate', 'Release-blocking CI is authoritative.', 'native-gate-declared'],
+        ['opt-out', 'This repository intentionally has no local gate.', 'opt-out-declared'],
+    ])('reports v3 %s without dispatching sensors', async (mode, declarationReason, diagnosticReason) => {
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.git'));
+        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, reason: declarationReason }));
+        await expect((0, status_1.computeSensorStatus)(tmpDir)).resolves.toMatchObject({
+            overall: 'NOT_CONFIGURED', mode, reason: diagnosticReason,
+            declarationReason,
+            projectRoot: tmpDir, manifestPath: path_1.default.join(tmpDir, '.awm', 'sensors.json'),
+        });
+        expect(runCommand).not.toHaveBeenCalled();
+        expect(runStructuredCommand).not.toHaveBeenCalled();
+    });
+    it('reports a v2 source-unavailable state instead of accepting a missing pack', async () => {
+        const previousHome = process.env.AWM_HOME;
+        const home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-missing-source-home-'));
+        try {
+            process.env.AWM_HOME = home;
+            fs_1.default.writeFileSync(path_1.default.join(home, 'registries.json'), JSON.stringify([]));
+            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: 2, pack: 'js-ts', registryRoot: path_1.default.join(home, 'gone'), sensors: {},
+            }));
+            await expect((0, status_1.computeSensorStatus)(tmpDir)).resolves.toMatchObject({
+                overall: 'DEGRADED', pack: 'js-ts', mode: 'source-unavailable',
+                reason: 'no-compatible-registry', remedy: 'install-registry-or-run-awm-update',
+                projectRoot: tmpDir, manifestPath: path_1.default.join(tmpDir, '.awm', 'sensors.json'),
+            });
+        }
+        finally {
+            if (previousHome === undefined)
+                delete process.env.AWM_HOME;
+            else
+                process.env.AWM_HOME = previousHome;
+            fs_1.default.rmSync(home, { recursive: true, force: true });
+        }
+    });
+    it('reports bounded candidates and a remedy when v2 source resolution is ambiguous', async () => {
+        const previousHome = process.env.AWM_HOME;
+        const home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-ambiguous-home-'));
+        try {
+            process.env.AWM_HOME = home;
+            const pack = {
+                schemaVersion: 2, name: 'js-ts', description: 'fixture', detects: ['package.json'],
+                coverage: { schemaVersion: 1, classes: { lint: { description: 'lint', detectors: [{ sensor: 'lint' }], remedy: { summary: 'fix', command: 'awm sensors init' } } } },
+                sensors: { lint: { applicability: { allFiles: ['package.json'] }, variants: [{
+                                id: 'eslint-10', priority: 1, certifiedRange: '>=10 <11',
+                                requirements: { tool: 'eslint', toolRange: '>=10 <11', runtime: 'node', runtimeRange: '>=0' },
+                                assets: [], formatter: 'generic', probe: { kind: 'package-script-present' },
+                                command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+                            }] } },
+            };
+            const registries = ['alpha', 'beta'];
+            fs_1.default.writeFileSync(path_1.default.join(home, 'registries.json'), JSON.stringify(registries.map(name => ({ name, remote: `https://example.test/${name}.git` }))));
+            for (const name of registries) {
+                const packDir = path_1.default.join(home, 'registries', name, 'sensor-packs', 'js-ts');
+                fs_1.default.mkdirSync(packDir, { recursive: true });
+                fs_1.default.writeFileSync(path_1.default.join(packDir, 'pack.json'), JSON.stringify(pack));
+            }
+            fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.git'));
+            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: 2, pack: 'js-ts', sensors: {} }));
+            await expect((0, status_1.computeSensorStatus)(tmpDir)).resolves.toMatchObject({
+                overall: 'DEGRADED', mode: 'source-ambiguous', reason: 'multiple-compatible-registries',
+                remedy: 'configure-one-logical-registry', candidates: ['alpha', 'beta'],
+            });
+        }
+        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/core/init/orchestrator.test.js

@@ -135,7 +135,9 @@ describe('runInitSteps — orchestrator', () => {
         const deps = buildDeps(root);
         const { runInitSteps } = require('../../../src/core/init/orchestrator');
         const out = await runInitSteps(deps);
-        expect(out.steps.some((s) => s.id === 'project.sensors' && s.action === 'applied')).toBe(true);
+        // The sensor step is always represented; whether this fixture's pack is
+        // portable is orthogonal to activation/constitution orchestration.
+        expect(out.steps.some((s) => s.id === 'project.sensors')).toBe(true);
         expect(out.steps.find((s) => s.id === 'project.constitution').action).toBe('pending');
         expect(out.steps.find((s) => s.id === 'project.context').action).toBe('pending');
     });