agentic-workflow-manager 9.16.1 → 9.18.0

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

@@ -641,3 +641,334 @@ describe('runSensors — honest floor (not_certified over real stack)', () => {
         }
     });
 });
+describe('runSensors project-declared parity (S2)', () => {
+    let project;
+    let home;
+    const version = '10.0.0';
+    const packBoundLint = () => ({
+        enabled: true,
+        fast: true,
+        variantId: 'eslint-10',
+        command: { executable: 'stale-eslint', resolution: 'node-modules-bin', args: ['.'] },
+        assets: ['eslint.config.awm.mjs'],
+        initializedCompatibility: {
+            state: 'certified',
+            reason: 'range-and-probe',
+            variantId: 'eslint-10',
+            toolVersion: version,
+            runtimeVersion: process.versions.node,
+            certifiedRange: '>=10 <11',
+            evidence: [],
+        },
+    });
+    const projectIac = (exitScript = 'process.exit(0)') => ({
+        source: 'project',
+        enabled: true,
+        fast: true,
+        command: { executable: 'node', resolution: 'path', args: ['-e', exitScript] },
+        formatter: 'exit-code',
+    });
+    beforeEach(() => {
+        jest.resetModules();
+        project = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-v3-project-run-'));
+        home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-v3-project-home-'));
+        process.env.AWM_HOME = home;
+        const registry = path_1.default.join(home, 'registries', 'baseline', 'sensor-packs', 'js-ts');
+        fs_1.default.mkdirSync(registry, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registry, 'eslint.config.awm.mjs'), 'export default []');
+        fs_1.default.writeFileSync(path_1.default.join(home, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: 'https://example.test/baseline.git' }]));
+        fs_1.default.writeFileSync(path_1.default.join(project, 'package.json'), JSON.stringify({ scripts: { lint: 'eslint .' }, devDependencies: { eslint: '^10.0.0' } }));
+        fs_1.default.mkdirSync(path_1.default.join(project, 'node_modules', 'eslint'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(project, 'node_modules', 'eslint', 'package.json'), JSON.stringify({ version }));
+        fs_1.default.writeFileSync(path_1.default.join(registry, 'pack.json'), JSON.stringify({
+            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: {
+                    fast: true,
+                    applicability: { allFiles: ['package.json'] },
+                    variants: [{
+                            id: 'eslint-10', priority: 1, certifiedRange: '>=10 <11',
+                            requirements: { tool: 'eslint', toolRange: '>=10 <11', runtime: 'node', runtimeRange: '>=0' },
+                            assets: ['eslint.config.awm.mjs'], formatter: 'generic',
+                            probe: { kind: 'package-script-present', script: 'lint' },
+                            command: { executable: 'live-eslint', resolution: 'node-modules-bin', args: ['.'] },
+                        }],
+                },
+                typecheck: {
+                    fast: true,
+                    applicability: { allFiles: ['package.json'] },
+                    variants: [{
+                            id: 'tsc-5', priority: 1, certifiedRange: '>=5 <6',
+                            requirements: { tool: 'tsc', toolRange: '>=5 <6', runtime: 'node', runtimeRange: '>=0' },
+                            assets: [], formatter: 'tsc',
+                            probe: { kind: 'version' },
+                            command: { executable: 'tsc', resolution: 'node-modules-bin', args: ['--noEmit'] },
+                        }],
+                },
+            },
+        }));
+        fs_1.default.mkdirSync(path_1.default.join(project, '.awm'));
+        mockRunStructuredCommand.mockReset();
+        mockRunCommand.mockReset();
+    });
+    afterEach(() => {
+        delete process.env.AWM_HOME;
+        fs_1.default.rmSync(project, { recursive: true, force: true });
+        fs_1.default.rmSync(home, { recursive: true, force: true });
+    });
+    function writeManifest(sensors, pack = 'js-ts') {
+        const body = {
+            schemaVersion: 3,
+            mode: 'project-sensors',
+            sensors,
+        };
+        if (pack !== undefined) {
+            body.pack = pack;
+            if (typeof pack === 'string' && pack.length > 0)
+                body.source = { registry: 'baseline' };
+        }
+        fs_1.default.writeFileSync(path_1.default.join(project, '.awm', 'sensors.json'), JSON.stringify(body));
+    }
+    it('runs pack lint and project iac-format together with project-declared provenance and overall pass (RF-2.1/2.2/2.3)', async () => {
+        writeManifest({ lint: packBoundLint(), 'iac-format': projectIac('process.exit(0)') });
+        mockRunStructuredCommand.mockImplementation(async (command) => {
+            if (command.executable === 'live-eslint')
+                return ok();
+            if (command.executable === 'node')
+                return ok();
+            return ok();
+        });
+        const { runSensors } = require('../../../src/commands/sensors/run');
+        const result = await runSensors({ cwd: project, fast: true });
+        expect(result.sensors.map((s) => s.name).sort()).toEqual(['iac-format', 'lint']);
+        const projectRow = result.sensors.find((s) => s.name === 'iac-format');
+        expect(projectRow).toMatchObject({ status: 'pass', certification: 'project-declared' });
+        expect(projectRow.certification).not.toBe('certified');
+        expect(result.overall).toBe('pass');
+        expect(result.invalidEntries ?? []).toEqual([]);
+    });
+    it('fails overall when the project sensor exits non-zero (RF-2.5)', async () => {
+        writeManifest({ lint: packBoundLint(), 'iac-format': projectIac('process.exit(1)') });
+        mockRunStructuredCommand.mockImplementation(async (command) => {
+            if (command.executable === 'live-eslint')
+                return ok();
+            if (command.executable === 'node')
+                return exited(1, 'fmt drift\n');
+            return ok();
+        });
+        const { runSensors } = require('../../../src/commands/sensors/run');
+        const result = await runSensors({ cwd: project, fast: true });
+        expect(result.sensors.find((s) => s.name === 'iac-format')).toMatchObject({ status: 'fail' });
+        expect(result.overall).toBe('fail');
+    });
+    it('skips a schema-invalid project sibling, still runs pack, and lists the invalid entry (RF-2.6)', async () => {
+        writeManifest({
+            lint: packBoundLint(),
+            broken: {
+                source: 'project',
+                enabled: true,
+                fast: true,
+                command: { executable: 'node', resolution: 'path', args: ['.'] },
+                formatter: 'not-a-formatter',
+            },
+        });
+        mockRunStructuredCommand.mockResolvedValue(ok());
+        const { runSensors } = require('../../../src/commands/sensors/run');
+        const result = await runSensors({ cwd: project, fast: true });
+        expect(result.sensors.some((s) => s.name === 'lint')).toBe(true);
+        expect(result.sensors.some((s) => s.name === 'broken')).toBe(false);
+        expect(result.invalidEntries).toEqual([
+            expect.objectContaining({
+                name: 'broken',
+                reason: expect.stringMatching(/sensors\.broken\.formatter|not a registered formatter/i),
+            }),
+        ]);
+        expect(result.reason).not.toBe('manifest-malformed');
+        expect(result.sensors.length).toBeGreaterThan(0);
+    });
+    it('suppresses a baselined project exit-code failure as sensor-level debt (RF-2.7)', async () => {
+        writeManifest({ 'iac-format': projectIac('process.exit(1)') }, null);
+        mockRunStructuredCommand.mockResolvedValue(exited(1, 'fmt drift\n'));
+        const { runSensors } = require('../../../src/commands/sensors/run');
+        const { buildBaseline, writeBaseline } = require('../../../src/commands/sensors/baseline');
+        const first = await runSensors({ cwd: project, all: true });
+        expect(first.overall).toBe('fail');
+        const row = first.sensors.find((s) => s.name === 'iac-format');
+        expect(row.status).toBe('fail');
+        writeBaseline(project, buildBaseline(first.sensors.map((s) => ({ name: s.name, errors: s.errors }))));
+        mockRunStructuredCommand.mockResolvedValue(exited(1, 'fmt drift\n'));
+        const second = await runSensors({ cwd: project, all: true });
+        const suppressed = second.sensors.find((s) => s.name === 'iac-format');
+        expect(suppressed).toMatchObject({ status: 'pass', baselineCount: 1 });
+        expect(second.overall).toBe('pass');
+    });
+    it('yields overall pass for a passing project-only run (RF-2.3 provenance never gates)', async () => {
+        writeManifest({ 'iac-format': projectIac('process.exit(0)') }, null);
+        mockRunStructuredCommand.mockResolvedValue(ok());
+        const { runSensors } = require('../../../src/commands/sensors/run');
+        const result = await runSensors({ cwd: project, all: true });
+        expect(result.sensors).toEqual([
+            expect.objectContaining({ name: 'iac-format', status: 'pass', certification: 'project-declared' }),
+        ]);
+        expect(result.overall).toBe('pass');
+    });
+    it('marks a colliding project entry invalid and still prepares/runs the pack sensor for that id (RF-1.7)', async () => {
+        // Project entry reuses pack id `lint` — invalid, but pack lint must remain executable.
+        writeManifest({ lint: projectIac('process.exit(0)') });
+        mockRunStructuredCommand.mockResolvedValue(ok());
+        const { runSensors } = require('../../../src/commands/sensors/run');
+        const result = await runSensors({ cwd: project, all: true });
+        expect(result.invalidEntries).toEqual([
+            expect.objectContaining({
+                name: 'lint',
+                reason: expect.stringMatching(/project-sensor-name-collision:\s*lint/),
+            }),
+        ]);
+        const lint = result.sensors.find((s) => s.name === 'lint');
+        expect(lint).toBeDefined();
+        expect(lint.certification).not.toBe('project-declared');
+        expect(lint.status).toBe('pass');
+        expect(mockRunStructuredCommand).toHaveBeenCalledWith(expect.objectContaining({ executable: 'live-eslint' }), expect.any(Object));
+    });
+    it('on collision with null liveState.variantId still prepares pack (not project) for that id (RF-1.7)', async () => {
+        writeManifest({ lint: projectIac('process.exit(0)') });
+        // Remove the tool so live resolution yields missing-tool with variantId null,
+        // while the pack still defines the lint sensor.
+        fs_1.default.rmSync(path_1.default.join(project, 'node_modules', 'eslint'), { recursive: true, force: true });
+        fs_1.default.writeFileSync(path_1.default.join(project, 'package.json'), JSON.stringify({ scripts: { lint: 'eslint .' } }));
+        mockRunStructuredCommand.mockResolvedValue(ok());
+        const { runSensors } = require('../../../src/commands/sensors/run');
+        const result = await runSensors({ cwd: project, all: true });
+        expect(result.invalidEntries).toEqual([
+            expect.objectContaining({
+                name: 'lint',
+                reason: expect.stringMatching(/project-sensor-name-collision:\s*lint/),
+            }),
+        ]);
+        const lint = result.sensors.find((s) => s.name === 'lint');
+        expect(lint).toBeDefined();
+        expect(lint.certification).not.toBe('project-declared');
+        // Pack prepare/synthetic outcome — never the project node command.
+        expect(mockRunStructuredCommand).not.toHaveBeenCalledWith(expect.objectContaining({ executable: 'node' }), expect.any(Object));
+    });
+    it('carries project-declared provenance on a disabled/synthetic project sensor (RF-2.2)', async () => {
+        writeManifest({
+            'iac-format': { ...projectIac('process.exit(0)'), enabled: false },
+        }, null);
+        const { runSensors } = require('../../../src/commands/sensors/run');
+        const result = await runSensors({ cwd: project, all: true });
+        expect(result.sensors).toEqual([
+            expect.objectContaining({
+                name: 'iac-format',
+                status: 'skipped',
+                skipReason: 'disabled',
+                certification: 'project-declared',
+            }),
+        ]);
+        expect(mockRunStructuredCommand).not.toHaveBeenCalled();
+    });
+    it('runs a project sensor when its allFiles marker exists', async () => {
+        writeManifest({
+            'iac-format': {
+                ...projectIac('process.exit(0)'),
+                applicability: { allFiles: ['package.json'] },
+            },
+        }, null);
+        mockRunStructuredCommand.mockResolvedValue(ok());
+        const { runSensors } = require('../../../src/commands/sensors/run');
+        const result = await runSensors({ cwd: project, all: true });
+        expect(result.sensors).toEqual([
+            expect.objectContaining({ name: 'iac-format', status: 'pass', certification: 'project-declared' }),
+        ]);
+        expect(mockRunStructuredCommand).toHaveBeenCalledWith(expect.objectContaining({ executable: 'node' }), expect.any(Object));
+    });
+    it('keeps a project sensor synthetic not-applicable when its allFiles marker is missing', async () => {
+        writeManifest({
+            'iac-format': {
+                ...projectIac('process.exit(0)'),
+                applicability: { allFiles: ['missing-stack.marker'] },
+            },
+        }, null);
+        mockRunStructuredCommand.mockResolvedValue(ok());
+        const { runSensors } = require('../../../src/commands/sensors/run');
+        const result = await runSensors({ cwd: project, all: true });
+        expect(result.sensors).toEqual([
+            expect.objectContaining({
+                name: 'iac-format',
+                status: 'inconclusive',
+                skipReason: 'not-applicable: applicability-not-met',
+                certification: 'project-declared',
+            }),
+        ]);
+        expect(mockRunStructuredCommand).not.toHaveBeenCalled();
+    });
+    it('does not soft-recover when packageRoot is a symlink escaping the project root', async () => {
+        const outside = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-soft-escape-out-'));
+        try {
+            fs_1.default.symlinkSync(outside, path_1.default.join(project, 'pkg'));
+            const body = {
+                schemaVersion: 3,
+                mode: 'project-sensors',
+                packageRoot: 'pkg',
+                sensors: {
+                    broken: {
+                        source: 'project',
+                        enabled: true,
+                        fast: true,
+                        command: { executable: 'node', resolution: 'path', args: ['-e', 'process.exit(0)'] },
+                        formatter: 'not-a-formatter',
+                    },
+                    good: projectIac('process.exit(0)'),
+                },
+            };
+            fs_1.default.writeFileSync(path_1.default.join(project, '.awm', 'sensors.json'), JSON.stringify(body));
+            mockRunStructuredCommand.mockResolvedValue(ok());
+            const { runSensors } = require('../../../src/commands/sensors/run');
+            const result = await runSensors({ cwd: project, all: true });
+            expect(result.overall).toBe('not_certified');
+            expect(result.mode).toBe('invalid');
+            expect(result.sensors).toEqual([]);
+            expect(mockRunStructuredCommand).not.toHaveBeenCalled();
+        }
+        finally {
+            fs_1.default.rmSync(outside, { recursive: true, force: true });
+        }
+    });
+    it('does not soft-recover a symlinked sensors.json (non-regular-file authority)', async () => {
+        const realManifest = path_1.default.join(project, 'elsewhere-sensors.json');
+        fs_1.default.writeFileSync(realManifest, JSON.stringify({
+            schemaVersion: 3,
+            mode: 'project-sensors',
+            sensors: { good: projectIac('process.exit(0)') },
+        }));
+        const manifestPath = path_1.default.join(project, '.awm', 'sensors.json');
+        if (fs_1.default.existsSync(manifestPath))
+            fs_1.default.unlinkSync(manifestPath);
+        fs_1.default.symlinkSync(realManifest, manifestPath);
+        mockRunStructuredCommand.mockResolvedValue(ok());
+        const { runSensors } = require('../../../src/commands/sensors/run');
+        const result = await runSensors({ cwd: project, all: true });
+        expect(result.overall).toBe('not_certified');
+        expect(result.mode).toBe('invalid');
+        expect(result.sensors).toEqual([]);
+        expect(mockRunStructuredCommand).not.toHaveBeenCalled();
+    });
+    it('fail-closes a project id collision when the live pack cannot be resolved (live null)', async () => {
+        writeManifest({ lint: projectIac('process.exit(0)') });
+        fs_1.default.writeFileSync(path_1.default.join(home, 'registries', 'baseline', 'sensor-packs', 'js-ts', 'pack.json'), 'not-valid-json{');
+        mockRunStructuredCommand.mockResolvedValue(ok());
+        const { runSensors } = require('../../../src/commands/sensors/run');
+        const result = await runSensors({ cwd: project, all: true });
+        expect(result.invalidEntries).toEqual([
+            expect.objectContaining({
+                name: 'lint',
+                reason: expect.stringMatching(/project-sensor-name-collision:\s*lint/),
+            }),
+        ]);
+        const lint = result.sensors.find((s) => s.name === 'lint');
+        if (lint)
+            expect(lint.certification).not.toBe('project-declared');
+        expect(mockRunStructuredCommand).not.toHaveBeenCalledWith(expect.objectContaining({ executable: 'node' }), expect.any(Object));
+    });
+});

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

@@ -7,6 +7,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const status_1 = require("../../../src/commands/sensors/status");
+const coverage_1 = require("../../../src/commands/sensors/coverage");
 jest.mock('../../../src/commands/sensors/exec', () => ({
     runCommand: jest.fn(),
     runStructuredCommand: jest.fn(),
@@ -409,3 +410,206 @@ describe('computeSensorStatus', () => {
         }
     });
 });
+describe('project-declared status and coverage (S3)', () => {
+    let tmpDir;
+    let pathDir;
+    let originalPath;
+    beforeEach(() => {
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-s3-'));
+        pathDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-s3-path-'));
+        originalPath = process.env.PATH;
+        process.env.PATH = pathDir;
+        fs_1.default.writeFileSync(path_1.default.join(pathDir, 'terraform'), '#!/bin/sh\nexit 0\n');
+        fs_1.default.chmodSync(path_1.default.join(pathDir, 'terraform'), 0o755);
+    });
+    afterEach(() => {
+        if (originalPath === undefined)
+            delete process.env.PATH;
+        else
+            process.env.PATH = originalPath;
+        fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+        fs_1.default.rmSync(pathDir, { recursive: true, force: true });
+    });
+    function writeOnlyProject(sensors) {
+        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',
+            sensors,
+        }));
+    }
+    it('lists each only-project sensor with project-declared provenance (RF-2.8)', async () => {
+        writeOnlyProject({
+            'iac-format': {
+                source: 'project',
+                enabled: true,
+                command: { executable: 'terraform', resolution: 'path', args: ['fmt', '-check'] },
+                formatter: 'exit-code',
+            },
+        });
+        const result = await (0, status_1.computeSensorStatus)(tmpDir);
+        expect(result.checks['iac-format']).toMatchObject({
+            ok: true,
+            certification: 'project-declared',
+        });
+        expect(result.checks['iac-format'].detail).toMatch(/project-declared/i);
+        expect(result.overall).not.toBe('NOT_CONFIGURED');
+        // Must not be empty Pack:none / DEGRADED with zero detail solely because pack is absent.
+        expect(result.pack === null || result.pack === undefined).toBe(true);
+        expect(Object.keys(result.checks)).toEqual(expect.arrayContaining(['iac-format']));
+    });
+    it('reports coverage as inconclusive / no pack-reference for only-project (RF-2.9)', async () => {
+        writeOnlyProject({
+            'iac-format': {
+                source: 'project',
+                enabled: true,
+                command: { executable: 'terraform', resolution: 'path', args: ['fmt', '-check'] },
+                formatter: 'exit-code',
+            },
+        });
+        const coverage = await (0, coverage_1.runCoverage)(tmpDir);
+        expect(coverage.overall).toBe('inconclusive');
+        expect(coverage.static.status).toBe('inconclusive');
+        expect(coverage.static.reason).toBe('no_reference');
+        expect(coverage.static.classes).toEqual([]);
+        expect(coverage.overall).not.toBe('covered');
+        expect(JSON.stringify(coverage)).not.toMatch(/"certification"\s*:\s*"certified"/);
+    });
+    it('soft-isolates valid siblings when one project entry is schema-invalid (status vs run)', async () => {
+        writeOnlyProject({
+            good: {
+                source: 'project',
+                enabled: true,
+                command: { executable: 'terraform', resolution: 'path', args: ['fmt', '-check'] },
+                formatter: 'exit-code',
+            },
+            bad: {
+                source: 'project',
+                enabled: true,
+                command: { executable: 'terraform', resolution: 'path', args: ['fmt', '-check'] },
+                formatter: 'not-a-formatter',
+            },
+        });
+        const result = await (0, status_1.computeSensorStatus)(tmpDir);
+        expect(Object.keys(result.checks).length).toBeGreaterThan(0);
+        expect(result.checks['good']).toMatchObject({
+            ok: true,
+            certification: 'project-declared',
+        });
+        expect(result.checks['bad']).toMatchObject({ ok: false });
+        expect(result.checks['bad'].detail).toMatch(/formatter|invalid/i);
+        expect(result.overall).toBe('DEGRADED');
+    });
+});
+describe('project-declared status pack collision (S3 RF-1.7)', () => {
+    let project;
+    let home;
+    let pathDir;
+    let originalPath;
+    let originalHome;
+    const version = '10.0.0';
+    beforeEach(() => {
+        project = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-collision-'));
+        home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-collision-home-'));
+        pathDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-collision-path-'));
+        originalPath = process.env.PATH;
+        originalHome = process.env.AWM_HOME;
+        process.env.PATH = pathDir;
+        process.env.AWM_HOME = home;
+        fs_1.default.writeFileSync(path_1.default.join(pathDir, 'node'), '#!/bin/sh\nexit 0\n');
+        fs_1.default.chmodSync(path_1.default.join(pathDir, 'node'), 0o755);
+        const registry = path_1.default.join(home, 'registries', 'baseline', 'sensor-packs', 'js-ts');
+        fs_1.default.mkdirSync(registry, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registry, 'eslint.config.awm.mjs'), 'export default []');
+        fs_1.default.writeFileSync(path_1.default.join(home, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: 'https://example.test/baseline.git' }]));
+        fs_1.default.writeFileSync(path_1.default.join(project, 'package.json'), JSON.stringify({ scripts: { lint: 'eslint .' }, devDependencies: { eslint: '^10.0.0' } }));
+        fs_1.default.mkdirSync(path_1.default.join(project, 'node_modules', 'eslint'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(project, 'node_modules', 'eslint', 'package.json'), JSON.stringify({ version }));
+        fs_1.default.mkdirSync(path_1.default.join(project, 'node_modules', '.bin'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(project, 'node_modules', '.bin', 'eslint'), '');
+        fs_1.default.writeFileSync(path_1.default.join(registry, 'pack.json'), JSON.stringify({
+            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: {
+                    fast: true,
+                    applicability: { allFiles: ['package.json'] },
+                    variants: [{
+                            id: 'eslint-10', priority: 1, certifiedRange: '>=10 <11',
+                            requirements: { tool: 'eslint', toolRange: '>=10 <11', runtime: 'node', runtimeRange: '>=0' },
+                            assets: ['eslint.config.awm.mjs'], formatter: 'generic',
+                            probe: { kind: 'package-script-present', script: 'lint' },
+                            command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+                        }],
+                },
+            },
+        }));
+        fs_1.default.mkdirSync(path_1.default.join(project, '.awm'));
+        fs_1.default.writeFileSync(path_1.default.join(project, 'eslint.config.awm.mjs'), 'export default []');
+    });
+    afterEach(() => {
+        if (originalPath === undefined)
+            delete process.env.PATH;
+        else
+            process.env.PATH = originalPath;
+        if (originalHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalHome;
+        fs_1.default.rmSync(project, { recursive: true, force: true });
+        fs_1.default.rmSync(home, { recursive: true, force: true });
+        fs_1.default.rmSync(pathDir, { recursive: true, force: true });
+    });
+    it('does not label a colliding project id as project-declared READY (RF-1.7 status)', async () => {
+        fs_1.default.writeFileSync(path_1.default.join(project, '.awm', 'sensors.json'), JSON.stringify({
+            schemaVersion: 3,
+            mode: 'project-sensors',
+            pack: 'js-ts',
+            source: { registry: 'baseline' },
+            sensors: {
+                lint: {
+                    source: 'project',
+                    enabled: true,
+                    command: { executable: 'node', resolution: 'path', args: ['-e', 'process.exit(0)'] },
+                    formatter: 'exit-code',
+                },
+            },
+        }));
+        const result = await (0, status_1.computeSensorStatus)(project);
+        expect(result.checks['lint']).toBeDefined();
+        expect(result.checks['lint'].certification).not.toBe('project-declared');
+        expect(result.checks['lint'].detail).toMatch(/project-sensor-name-collision|pack (sensor )?kept/i);
+        expect(result.overall).not.toBe('READY');
+    });
+    it('soft-isolate + pack + colliding project id does not certify project-declared READY (RF-1.7)', async () => {
+        // Invalid sibling forces softIsolatedChecks; lint collides with live pack id.
+        fs_1.default.writeFileSync(path_1.default.join(project, '.awm', 'sensors.json'), JSON.stringify({
+            schemaVersion: 3,
+            mode: 'project-sensors',
+            pack: 'js-ts',
+            source: { registry: 'baseline' },
+            sensors: {
+                lint: {
+                    source: 'project',
+                    enabled: true,
+                    command: { executable: 'node', resolution: 'path', args: ['-e', 'process.exit(0)'] },
+                    formatter: 'exit-code',
+                },
+                bad: {
+                    source: 'project',
+                    enabled: true,
+                    command: { executable: 'node', resolution: 'path', args: ['-e', 'process.exit(0)'] },
+                    formatter: 'not-a-formatter',
+                },
+            },
+        }));
+        const result = await (0, status_1.computeSensorStatus)(project);
+        expect(result.mode).toBe('invalid');
+        expect(result.checks['bad']).toMatchObject({ ok: false });
+        expect(result.checks['lint']).toBeDefined();
+        expect(result.checks['lint'].ok).toBe(false);
+        expect(result.checks['lint'].certification).not.toBe('project-declared');
+        expect(result.checks['lint'].detail).toMatch(/project-sensor-name-collision|pack (sensor )?kept/i);
+        expect(result.overall).not.toBe('READY');
+    });
+});

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

@@ -921,9 +921,16 @@ describe('issue #196 reopened: supervised S1 handoff', () => {
             }
             expect(stdout).toContain('supervisor activo');
             child.kill('SIGINT');
-            const exit = await new Promise(resolve => child.once('close', code => resolve(code)));
-            expect(exit).toBe(130);
+            const exit = await new Promise(resolve => {
+                child.once('exit', (code, signal) => resolve({ code, signal }));
+            });
+            // Contract: truthful interrupt report. Exit status is secondary —
+            // on Darwin, child_process often reports code null + SIGINT when the
+            // signal disposition races process.exitCode=130 (never use process.exit
+            // in watch/index: it kills in-process Jest callers). Either 130 or
+            // null+SIGINT is an interrupted stop; require the detenido line either way.
             expect(stdout).toMatch(/detenido; ciclo IN_PROGRESS/);
+            expect(exit.code === 130 || (exit.code === null && exit.signal === 'SIGINT')).toBe(true);
             expect(stdout).not.toContain('COMPLETE');
             expect(stderr).not.toContain('Error');
         }