agentic-workflow-manager 9.4.0 → 9.5.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/currentness/check.test.js

@@ -22,7 +22,7 @@ describe('checkCurrentness', () => {
             now: () => 1_700_000_000_000,
             fetch: jest.fn().mockResolvedValue({
                 ok: true,
-                text: async () => JSON.stringify({ 'dist-tags': { latest: '1.2.3' } }),
+                text: async () => JSON.stringify({ version: '1.2.3' }),
             }),
             readPreferences: () => ({ pins: {} }),
             listRegistries: () => [{ name: 'baseline', remote: 'https://example.test/team/repo.git', contentRoot: '/registry' }],
@@ -50,6 +50,16 @@ describe('checkCurrentness', () => {
         expect(JSON.stringify(result)).not.toContain('secret');
         expect(result.components[1].source).toBe('https://example.test/team/repo.git');
     });
+    it('reads npm currentness from the bounded latest metadata endpoint', async () => {
+        const fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            text: async () => JSON.stringify({ version: '1.2.3' }),
+        });
+        const { checkCurrentness } = require('../../../src/core/currentness/check');
+        const result = await checkCurrentness(root, deps({ fetch }));
+        expect(fetch).toHaveBeenCalledWith('https://registry.npmjs.org/agentic-workflow-manager/latest', expect.objectContaining({ signal: expect.any(AbortSignal) }));
+        expect(result.components[0]).toEqual(expect.objectContaining({ status: 'current', latest: '1.2.3' }));
+    });
     it('marks an older pinned registry as pinned-behind with the unpin remedy', async () => {
         const { checkCurrentness } = require('../../../src/core/currentness/check');
         const result = await checkCurrentness(root, deps({
@@ -78,7 +88,7 @@ describe('checkCurrentness', () => {
             cliVersion: () => '1.9007199254740992.0',
             fetch: jest.fn().mockResolvedValue({
                 ok: true,
-                text: async () => JSON.stringify({ 'dist-tags': { latest: '1.9007199254740993.0' } }),
+                text: async () => JSON.stringify({ version: '1.9007199254740993.0' }),
             }),
         }));
         expect(result.components[0]).toEqual(expect.objectContaining({
@@ -151,7 +161,7 @@ describe('checkCurrentness', () => {
     ])('fails closed for %s', async (name, git) => {
         const { checkCurrentness } = require('../../../src/core/currentness/check');
         const result = await checkCurrentness(root, deps(name === 'malformed npm semver'
-            ? { fetch: jest.fn().mockResolvedValue({ ok: true, text: async () => JSON.stringify({ 'dist-tags': { latest: 'latest' } }) }) }
+            ? { fetch: jest.fn().mockResolvedValue({ ok: true, text: async () => JSON.stringify({ version: 'latest' }) }) }
             : { git }));
         expect(result.components.some((c) => c.status === 'unverifiable')).toBe(true);
     });

package/dist/tests/integration/preflight-json-pipe.e2e.test.js

@@ -59,6 +59,11 @@ test('preserves actionable no-manifest preflight JSON when verify-sensors is pip
         expect(result.status).toBe(1);
         expect(JSON.parse(result.stdout)).toMatchObject({
             status: 'not_configured',
+            mode: 'missing',
+            reason: 'manifest-absent',
+            projectRoot: project,
+            manifestPath: path_1.default.join(project, '.awm', 'sensors.json'),
+            remedy: expect.any(String),
             checks: expect.arrayContaining([expect.objectContaining({
                     id: 'sensors-execution', ok: false,
                     detail: 'sensor verdict was not_certified; no sensor established an empirical pass',

package/dist/tests/integration/sensor-compatibility.e2e.test.js

@@ -17,12 +17,6 @@ const bin = path_1.default.join(cliDir, 'dist/src/index.js');
 const fixtureRoot = path_1.default.join(cliDir, 'tests/fixtures/sensor-compatibility');
 const projectFixture = path_1.default.join(fixtureRoot, 'project');
 const registryFixture = path_1.default.join(fixtureRoot, 'registry');
-const noFollowUnavailableOnNativeWindows = process.platform === 'win32'
-    && typeof fs_1.default.constants.O_NOFOLLOW !== 'number';
-// Other native platforms exercise coverage through testWithNoFollow; this
-// branch preserves the deliberate Windows fail-closed behavior instead.
-const testWithNoFollow = noFollowUnavailableOnNativeWindows ? test.skip : test;
-const testWithoutNoFollowOnNativeWindows = noFollowUnavailableOnNativeWindows ? test : test.skip;
 function hashTree(root) {
     const hash = crypto_1.default.createHash('sha256');
     const walk = (directory) => {
@@ -97,7 +91,7 @@ test.each(['linux', 'darwin', 'win32'])('keeps injected resolver semantics consi
         fs_1.default.rmSync(fixture.root, { recursive: true, force: true });
     }
 });
-testWithNoFollow('compiled binary dispatches coverage and emits parseable JSON on the native CI platform', () => {
+test('compiled binary dispatches coverage and emits parseable JSON on the native CI platform', () => {
     const fixture = createFixture();
     try {
         const report = json(runCli(fixture, 'coverage', '--json'));
@@ -107,7 +101,7 @@ testWithNoFollow('compiled binary dispatches coverage and emits parseable JSON o
         fs_1.default.rmSync(fixture.root, { recursive: true, force: true });
     }
 });
-testWithNoFollow('compiled sensors run returns nonzero while preserving parseable not_certified JSON', () => {
+test('compiled sensors run returns nonzero while preserving parseable not_certified JSON', () => {
     const fixture = createFixture();
     try {
         fs_1.default.rmSync(path_1.default.join(fixture.project, '.awm', 'sensors.json'));
@@ -119,7 +113,7 @@ testWithNoFollow('compiled sensors run returns nonzero while preserving parseabl
         fs_1.default.rmSync(fixture.root, { recursive: true, force: true });
     }
 });
-testWithNoFollow('compiled status reports static READY without writing or executing the project sensor (R6, R6.2)', () => {
+test('compiled status reports static READY without writing or executing the project sensor (R6, R6.2)', () => {
     const fixture = createFixture();
     try {
         const localBin = path_1.default.join(fixture.project, 'node_modules', '.bin', 'eslint');
@@ -139,7 +133,7 @@ testWithNoFollow('compiled status reports static READY without writing or execut
         fs_1.default.rmSync(fixture.root, { recursive: true, force: true });
     }
 });
-testWithNoFollow('legacy coverage stays unverified, init migrates explicitly, and version drift is visible (R7.2, R7.8)', () => {
+test('legacy coverage stays unverified, init migrates explicitly, and version drift is visible (R7.2, R7.8)', () => {
     const fixture = createFixture();
     try {
         const before = [hashTree(fixture.project), hashTree(fixture.awmHome)];
@@ -167,14 +161,3 @@ testWithNoFollow('legacy coverage stays unverified, init migrates explicitly, an
         fs_1.default.rmSync(fixture.root, { recursive: true, force: true });
     }
 });
-testWithoutNoFollowOnNativeWindows('coverage fails closed when native Windows cannot prevent symlink dereference', () => {
-    const fixture = createFixture();
-    try {
-        const result = runCli(fixture, 'coverage', '--json');
-        expect(result.status).toBe(1);
-        expect(`${result.stdout ?? ''}${result.stderr ?? ''}`).toContain('platform cannot guarantee no symlink dereference');
-    }
-    finally {
-        fs_1.default.rmSync(fixture.root, { recursive: true, force: true });
-    }
-});

package/dist/tests/integration/sensor-coverage.e2e.test.js

@@ -12,9 +12,6 @@ const cliDir = path_1.default.resolve(__dirname, '../..');
 const bin = path_1.default.join(cliDir, 'dist/src/index.js');
 const fixture = path_1.default.join(cliDir, 'tests/fixtures/sensor-coverage/js-ts-gap');
 const registryFixture = path_1.default.join(cliDir, 'tests/fixtures/sensor-coverage/registry');
-const noFollowUnavailableOnNativeWindows = process.platform === 'win32'
-    && typeof fs_1.default.constants.O_NOFOLLOW !== 'number';
-const testWithNoFollow = noFollowUnavailableOnNativeWindows ? test.skip : test;
 const hashTree = (root) => {
     const hash = crypto_1.default.createHash('sha256');
     const walk = (directory) => {
@@ -71,32 +68,26 @@ test('compiled CLI reports static and read-only empirical coverage without leaki
         const result = (0, child_process_1.spawnSync)(process.execPath, [bin, 'sensors', 'coverage', '--json'], {
             cwd: project, encoding: 'utf8', env: { ...process.env, AWM_HOME: awmHome, AWM_NO_UPDATE_CHECK: '1' },
         });
-        if (noFollowUnavailableOnNativeWindows) {
-            expect(result.status).toBe(1);
-            expect(`${result.stdout ?? ''}${result.stderr ?? ''}`).toContain('platform cannot guarantee no symlink dereference');
-        }
-        else {
-            expect(result.status).toBe(0);
-            const report = JSON.parse(result.stdout ?? '');
-            expect(report.static.classes).toEqual(expect.arrayContaining([
-                expect.objectContaining({ id: 'formatting', status: 'unverifiable' }),
-                expect.objectContaining({ id: 'project-style-conventions', status: 'unverifiable' }),
-            ]));
-            expect(report).toMatchObject({ schemaVersion: 2, empirical: {
-                    status: 'partial', classes: [expect.objectContaining({ defectClass: 'lint-errors', occurrences: 2, recurrent: true })],
-                    unclassified: { occurrences: 1 },
-                } });
-            expect(result.stdout).not.toContain('fixture-secret-description');
-            expect(result.stdout).not.toContain('private-lint-signature');
-            expect(result.stdout).not.toContain('windows secret');
-        }
+        expect(result.status).toBe(0);
+        const report = JSON.parse(result.stdout ?? '');
+        expect(report.static.classes).toEqual(expect.arrayContaining([
+            expect.objectContaining({ id: 'formatting', status: 'unverifiable' }),
+            expect.objectContaining({ id: 'project-style-conventions', status: 'unverifiable' }),
+        ]));
+        expect(report).toMatchObject({ schemaVersion: 2, empirical: {
+                status: 'partial', classes: [expect.objectContaining({ defectClass: 'lint-errors', occurrences: 2, recurrent: true })],
+                unclassified: { occurrences: 1 },
+            } });
+        expect(result.stdout).not.toContain('fixture-secret-description');
+        expect(result.stdout).not.toContain('private-lint-signature');
+        expect(result.stdout).not.toContain('windows secret');
         expect([hashTree(project), hashTree(awmHome)]).toEqual(before);
     }
     finally {
         fs_1.default.rmSync(tmp, { recursive: true, force: true });
     }
 });
-testWithNoFollow('compiled coverage keeps static verdict stable while --min changes only recurrence emphasis', () => {
+test('compiled coverage keeps static verdict stable while --min changes only recurrence emphasis', () => {
     const { tmp, project, awmHome } = runWithFixture();
     try {
         const before = [hashTree(project), hashTree(awmHome)];
@@ -115,7 +106,7 @@ testWithNoFollow('compiled coverage keeps static verdict stable while --min chan
         fs_1.default.rmSync(tmp, { recursive: true, force: true });
     }
 });
-testWithNoFollow('informative states exit zero; malformed contract exits non-zero (R2.7, R2.9)', () => {
+test('informative states exit zero; malformed contract exits non-zero (R2.7, R2.9)', () => {
     const run = (mutatePack) => {
         const { tmp, project, awmHome } = runWithFixture(mutatePack);
         try {

package/package.json

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