agentic-workflow-manager 2.0.0

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

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const init_1 = require("../../../src/commands/sensors/init");
+// Build a throwaway registry with a js-ts pack.json (the single source of truth
+// init now reads from). `defaultCmd` uses the {{SOURCE_DIRS}} placeholder for depcheck.
+function makeRegistry() {
+    const registryRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-reg-'));
+    const packDir = path_1.default.join(registryRoot, 'sensor-packs', 'js-ts');
+    fs_1.default.mkdirSync(packDir, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(packDir, 'pack.json'), JSON.stringify({
+        name: 'js-ts',
+        sensors: {
+            typecheck: { fast: true, defaultCmd: 'npx tsc --noEmit' },
+            lint: { fast: true, defaultCmd: 'npx eslint . --config eslint.config.awm.mjs --cache --format json' },
+            depcheck: { fast: false, defaultCmd: 'npx depcruise --config .dep-cruiser.awm.js {{SOURCE_DIRS}}' },
+            mutation: { fast: false, enabled: false, defaultCmd: 'npx stryker run' },
+        },
+    }));
+    return registryRoot;
+}
+describe('detectStack', () => {
+    let tmpDir;
+    beforeEach(() => { tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-init-')); });
+    afterEach(() => { fs_1.default.rmSync(tmpDir, { recursive: true }); });
+    it('detects js-ts when package.json exists', () => {
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'package.json'), '{}');
+        expect((0, init_1.detectStack)(tmpDir).pack).toBe('js-ts');
+    });
+    it('detects python when pyproject.toml exists', () => {
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'pyproject.toml'), '');
+        expect((0, init_1.detectStack)(tmpDir).pack).toBe('python');
+    });
+    it('falls back to generic when no indicators found', () => {
+        expect((0, init_1.detectStack)(tmpDir).pack).toBe('generic');
+    });
+});
+describe('detectSourceDirs', () => {
+    let tmpDir;
+    beforeEach(() => { tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-src-')); });
+    afterEach(() => { fs_1.default.rmSync(tmpDir, { recursive: true }); });
+    it('returns the App-Router-style dirs that exist', () => {
+        for (const d of ['app', 'lib', 'components'])
+            fs_1.default.mkdirSync(path_1.default.join(tmpDir, d));
+        expect((0, init_1.detectSourceDirs)(tmpDir)).toEqual(['app', 'lib', 'components']);
+    });
+    it('returns src when it exists', () => {
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, 'src'));
+        expect((0, init_1.detectSourceDirs)(tmpDir)).toEqual(['src']);
+    });
+    it('falls back to ["src"] when no known source dir exists', () => {
+        expect((0, init_1.detectSourceDirs)(tmpDir)).toEqual(['src']);
+    });
+});
+describe('buildManifest', () => {
+    let registryRoot;
+    let cwd;
+    beforeEach(() => {
+        registryRoot = makeRegistry();
+        cwd = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-cwd-'));
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(registryRoot, { recursive: true });
+        fs_1.default.rmSync(cwd, { recursive: true });
+    });
+    it('builds manifest from the pack.json single source', () => {
+        const m = (0, init_1.buildManifest)('js-ts', undefined, registryRoot, cwd);
+        expect(m.pack).toBe('js-ts');
+        expect(m.sensors.typecheck.cmd).toBe('npx tsc --noEmit');
+        expect(m.sensors.lint.cmd).toContain('--config eslint.config.awm.mjs');
+    });
+    it('substitutes {{SOURCE_DIRS}} in depcheck with the detected dirs', () => {
+        for (const d of ['app', 'lib'])
+            fs_1.default.mkdirSync(path_1.default.join(cwd, d));
+        const m = (0, init_1.buildManifest)('js-ts', undefined, registryRoot, cwd);
+        expect(m.sensors.depcheck.cmd).toBe('npx depcruise --config .dep-cruiser.awm.js app lib');
+        expect(m.sensors.depcheck.cmd).not.toContain('{{SOURCE_DIRS}}');
+    });
+    it('merges conservatively — existing sensor commands are preserved', () => {
+        const existing = { pack: 'js-ts', sensors: { typecheck: { cmd: 'custom-tsc', fast: true } } };
+        const m = (0, init_1.buildManifest)('js-ts', existing, registryRoot, cwd);
+        expect(m.sensors.typecheck.cmd).toBe('custom-tsc');
+        expect(m.sensors.lint).toBeDefined();
+    });
+    it('uses the python fallback when the pack has no pack.json', () => {
+        const m = (0, init_1.buildManifest)('python', undefined, registryRoot, cwd);
+        expect(m.sensors.typecheck.cmd).toBe('mypy .');
+    });
+});
+describe('initSensors', () => {
+    let tmpDir;
+    let registryRoot;
+    beforeEach(() => {
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-init-'));
+        registryRoot = makeRegistry();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpDir, { recursive: true });
+        fs_1.default.rmSync(registryRoot, { recursive: true });
+    });
+    it('creates .awm/sensors.json for js-ts project', () => {
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'package.json'), '{}');
+        const result = (0, init_1.initSensors)({ cwd: tmpDir, registryRoot });
+        expect(fs_1.default.existsSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'))).toBe(true);
+        expect(result.detection.pack).toBe('js-ts');
+        expect(result.manifest.sensors.typecheck).toBeDefined();
+    });
+    it('is idempotent — existing sensor commands survive re-init', () => {
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'package.json'), '{}');
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
+        const existing = { pack: 'js-ts', sensors: { typecheck: { cmd: 'my-tsc', fast: true } } };
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify(existing));
+        (0, init_1.initSensors)({ cwd: tmpDir, registryRoot });
+        const written = JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), 'utf-8'));
+        expect(written.sensors.typecheck.cmd).toBe('my-tsc');
+        expect(written.sensors.lint).toBeDefined(); // new sensor added
+    });
+    it('copies pack config files into the repo by default (configure on)', () => {
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'package.json'), '{}');
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'sensor-packs', 'js-ts', 'tsconfig.awm.json'), '{}');
+        const result = (0, init_1.initSensors)({ cwd: tmpDir, registryRoot }); // no explicit configure → default true
+        expect(result.configured).toContain('tsconfig.awm.json');
+        expect(fs_1.default.existsSync(path_1.default.join(tmpDir, 'tsconfig.awm.json'))).toBe(true);
+    });
+    it('does NOT copy config files when configure is false', () => {
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'package.json'), '{}');
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'sensor-packs', 'js-ts', 'tsconfig.awm.json'), '{}');
+        const result = (0, init_1.initSensors)({ cwd: tmpDir, registryRoot, configure: false });
+        expect(result.configured).toEqual([]);
+        expect(fs_1.default.existsSync(path_1.default.join(tmpDir, 'tsconfig.awm.json'))).toBe(false);
+    });
+});

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

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+describe('sensor hook install/uninstall', () => {
+    let tmpDir;
+    let settingsPath;
+    beforeEach(() => {
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-install-'));
+        settingsPath = path_1.default.join(tmpDir, 'settings.json');
+        jest.resetModules();
+    });
+    afterEach(() => { fs_1.default.rmSync(tmpDir, { recursive: true }); });
+    const load = () => require('../../../src/commands/sensors/install');
+    it('installs PostToolUse hook into fresh settings.json', () => {
+        const { installSensorHook } = load();
+        const result = installSensorHook(settingsPath);
+        expect(result.status).toBe('installed');
+        const settings = JSON.parse(fs_1.default.readFileSync(settingsPath, 'utf-8'));
+        expect(settings.hooks.PostToolUse).toHaveLength(1);
+        expect(settings.hooks.PostToolUse[0].matcher).toBe('Write|Edit|MultiEdit');
+        expect(settings.hooks.PostToolUse[0].hooks[0].command).toBe('awm sensors run --fast');
+    });
+    it('merges with existing hooks — SessionStart entries preserved', () => {
+        const existing = { hooks: { SessionStart: [{ matcher: 'startup', hooks: [] }] } };
+        fs_1.default.writeFileSync(settingsPath, JSON.stringify(existing));
+        const { installSensorHook } = load();
+        installSensorHook(settingsPath);
+        const settings = JSON.parse(fs_1.default.readFileSync(settingsPath, 'utf-8'));
+        expect(settings.hooks.SessionStart).toHaveLength(1);
+        expect(settings.hooks.PostToolUse).toHaveLength(1);
+    });
+    it('is idempotent — second install returns already-installed', () => {
+        const { installSensorHook } = load();
+        installSensorHook(settingsPath);
+        const result2 = installSensorHook(settingsPath);
+        expect(result2.status).toBe('already-installed');
+        const settings = JSON.parse(fs_1.default.readFileSync(settingsPath, 'utf-8'));
+        expect(settings.hooks.PostToolUse).toHaveLength(1);
+    });
+    it('creates a backup before modifying settings.json', () => {
+        fs_1.default.writeFileSync(settingsPath, JSON.stringify({ hooks: {} }));
+        const { installSensorHook } = load();
+        const result = installSensorHook(settingsPath);
+        expect(result.backupPath).toBeDefined();
+        expect(fs_1.default.existsSync(result.backupPath)).toBe(true);
+    });
+    it('uninstall removes only the AWM sensor PostToolUse entry', () => {
+        const { installSensorHook, uninstallSensorHook } = load();
+        installSensorHook(settingsPath);
+        const result = uninstallSensorHook(settingsPath);
+        expect(result.status).toBe('removed');
+        const settings = JSON.parse(fs_1.default.readFileSync(settingsPath, 'utf-8'));
+        expect(settings.hooks?.PostToolUse ?? []).toHaveLength(0);
+    });
+});

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('@clack/prompts', () => ({ log: { success: jest.fn(), info: jest.fn() } }));
+jest.mock('picocolors', () => ({ green: (s) => s, yellow: (s) => s, red: (s) => s }));
+jest.mock('../../../src/commands/sensors/run', () => ({ runSensors: jest.fn().mockReturnValue({ sensors: [], overall: 'pass' }) }));
+jest.mock('../../../src/commands/sensors/init', () => ({ initSensors: jest.fn().mockReturnValue({ detection: { pack: 'js-ts', indicators: [] }, manifest: { sensors: {} }, configured: [] }) }));
+jest.mock('../../../src/commands/sensors/status', () => ({ computeSensorStatus: jest.fn().mockReturnValue({ overall: 'HEALTHY', pack: 'js-ts', checks: {} }) }));
+jest.mock('../../../src/commands/sensors/install', () => ({ installSensorHook: jest.fn().mockReturnValue({ status: 'installed' }) }));
+const commander_1 = require("commander");
+const index_1 = require("../../../src/commands/sensors/index");
+describe('registerSensorsCommand', () => {
+    it('registers sensors command with 4 subcommands', () => {
+        const program = new commander_1.Command();
+        (0, index_1.registerSensorsCommand)(program);
+        const cmd = program.commands.find(c => c.name() === 'sensors');
+        expect(cmd).toBeDefined();
+        const subNames = cmd.commands.map(c => c.name());
+        expect(subNames).toContain('run');
+        expect(subNames).toContain('init');
+        expect(subNames).toContain('status');
+        expect(subNames).toContain('install');
+    });
+});

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

@@ -0,0 +1,353 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+function mkTmp() {
+    return fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-sensors-'));
+}
+// Define stable mock before jest.mock hoisting
+const mockExecSyncFn = jest.fn();
+jest.mock('child_process', () => ({
+    execSync: (...args) => mockExecSyncFn(...args),
+}));
+const MANIFEST = {
+    pack: 'js-ts',
+    sensors: {
+        typecheck: { cmd: 'npx tsc --noEmit', fast: true },
+        lint: { cmd: 'npx eslint . --format json', fast: true },
+        security: { cmd: 'semgrep .', fast: false, enabled: false },
+        mutation: { enabled: false }
+    }
+};
+describe('runSensors', () => {
+    let tmpDir;
+    const path = require('path');
+    const os = require('os');
+    beforeEach(() => {
+        jest.resetModules();
+        tmpDir = fs_1.default.mkdtempSync(path.join(os.tmpdir(), 'awm-run-test-'));
+        fs_1.default.mkdirSync(path.join(tmpDir, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify(MANIFEST));
+        mockExecSyncFn.mockReset();
+    });
+    afterEach(() => { fs_1.default.rmSync(tmpDir, { recursive: true }); });
+    const load = () => require('../../../src/commands/sensors/run');
+    it('returns not_certified output when manifest does not exist', () => {
+        const emptyDir = fs_1.default.mkdtempSync(path.join(os.tmpdir(), 'awm-empty-'));
+        try {
+            const { runSensors } = load();
+            const result = runSensors({ fast: true, cwd: emptyDir });
+            expect(result.overall).toBe('not_certified');
+            expect(result.sensors).toHaveLength(0);
+        }
+        finally {
+            fs_1.default.rmSync(emptyDir, { recursive: true });
+        }
+    });
+    it('runs only fast sensors with --fast flag', () => {
+        mockExecSyncFn.mockReturnValue('');
+        const { runSensors } = load();
+        const result = runSensors({ fast: true, cwd: tmpDir });
+        expect(mockExecSyncFn).toHaveBeenCalledTimes(2); // typecheck + lint (security disabled, mutation disabled)
+        expect(result.sensors.some((s) => s.name === 'security')).toBe(false);
+        expect(result.overall).toBe('pass');
+    });
+    it('returns fail when a fast sensor has errors', () => {
+        mockExecSyncFn
+            .mockImplementationOnce(() => { throw Object.assign(new Error(), { stdout: "src/a.ts(1,1): error TS0001: Bad type.", stderr: '', status: 1 }); })
+            .mockReturnValueOnce('');
+        const { runSensors } = load();
+        const result = runSensors({ fast: true, cwd: tmpDir });
+        expect(result.overall).toBe('fail');
+        const tc = result.sensors.find((s) => s.name === 'typecheck');
+        expect(tc.status).toBe('fail');
+        expect(tc.errors[0].message).toMatch('SENSOR[typecheck]');
+    });
+    it('marks sensor as skipped on timeout', () => {
+        mockExecSyncFn.mockImplementationOnce(() => { throw Object.assign(new Error('killed'), { code: 'ETIMEDOUT' }); });
+        mockExecSyncFn.mockReturnValueOnce('');
+        const { runSensors } = load();
+        const result = runSensors({ fast: true, cwd: tmpDir });
+        const tc = result.sensors.find((s) => s.name === 'typecheck');
+        expect(tc.status).toBe('skipped');
+        expect(tc.skipReason).toMatch('timeout');
+    });
+    it('skips disabled sensors', () => {
+        mockExecSyncFn.mockReturnValue('');
+        const { runSensors } = load();
+        const result = runSensors({ all: true, cwd: tmpDir });
+        const sec = result.sensors.find((s) => s.name === 'security');
+        expect(sec.status).toBe('skipped');
+        expect(sec.skipReason).toBe('disabled');
+    });
+    const tcError = () => { throw Object.assign(new Error(), { stdout: 'src/a.ts(1,1): error TS0001: Bad type.', stderr: '', status: 1 }); };
+    it('baseline suppresses accepted findings — sensor passes on no NEW findings', () => {
+        const { runSensors } = load();
+        const { buildBaseline, writeBaseline } = require('../../../src/commands/sensors/baseline');
+        // Run 1 (no baseline): typecheck reports a TS error → fail.
+        mockExecSyncFn.mockImplementationOnce(tcError).mockReturnValueOnce('');
+        const first = runSensors({ fast: true, cwd: tmpDir });
+        expect(first.overall).toBe('fail');
+        // Accept the current findings as baseline.
+        writeBaseline(tmpDir, buildBaseline(first.sensors.map((s) => ({ name: s.name, errors: s.errors }))));
+        // Run 2 (same finding): baseline-suppressed → pass.
+        mockExecSyncFn.mockImplementationOnce(tcError).mockReturnValueOnce('');
+        const second = runSensors({ fast: true, cwd: tmpDir });
+        const tc = second.sensors.find((s) => s.name === 'typecheck');
+        expect(tc.status).toBe('pass');
+        expect(tc.baselineCount).toBe(1);
+        expect(second.overall).toBe('pass');
+    });
+    it('baseline lets NEW findings through (still fails)', () => {
+        const { runSensors } = load();
+        const { writeBaseline } = require('../../../src/commands/sensors/baseline');
+        writeBaseline(tmpDir, { typecheck: ['some-unrelated-fingerprint'] });
+        mockExecSyncFn.mockImplementationOnce(tcError).mockReturnValueOnce('');
+        const result = runSensors({ fast: true, cwd: tmpDir });
+        const tc = result.sensors.find((s) => s.name === 'typecheck');
+        expect(tc.status).toBe('fail');
+        expect(result.overall).toBe('fail');
+    });
+    it('--ignore-baseline reports all findings even when a baseline exists', () => {
+        const { runSensors } = load();
+        const { buildBaseline, writeBaseline } = require('../../../src/commands/sensors/baseline');
+        // First capture + accept the finding.
+        mockExecSyncFn.mockImplementationOnce(tcError).mockReturnValueOnce('');
+        const first = runSensors({ fast: true, cwd: tmpDir });
+        writeBaseline(tmpDir, buildBaseline(first.sensors.map((s) => ({ name: s.name, errors: s.errors }))));
+        // With ignoreBaseline, the accepted finding still counts → fail.
+        mockExecSyncFn.mockImplementationOnce(tcError).mockReturnValueOnce('');
+        const result = runSensors({ fast: true, cwd: tmpDir, ignoreBaseline: true });
+        expect(result.overall).toBe('fail');
+    });
+});
+describe('runSensors — missing tool is a fail, not a skip', () => {
+    let root;
+    afterEach(() => {
+        if (root)
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+    });
+    beforeEach(() => {
+        mockExecSyncFn.mockReset();
+        // Simulate shell exit 127 "command not found" — matches what Node's execSync
+        // captures in err.stderr when the binary does not exist on PATH.
+        mockExecSyncFn.mockImplementation(() => {
+            throw Object.assign(new Error('Command failed: awm-nonexistent-binary-xyz --check'), {
+                stdout: '',
+                stderr: '/bin/sh: awm-nonexistent-binary-xyz: command not found\n',
+                status: 127,
+            });
+        });
+    });
+    it('marks a sensor whose binary is missing as fail', () => {
+        root = mkTmp();
+        fs_1.default.mkdirSync(path_1.default.join(root, '.awm'));
+        fs_1.default.writeFileSync(path_1.default.join(root, '.awm', 'sensors.json'), JSON.stringify({
+            pack: 'test',
+            sensors: { ghost: { cmd: 'awm-nonexistent-binary-xyz --check', fast: true } },
+        }));
+        const out = (0, run_1.runSensors)({ cwd: root });
+        const ghost = out.sensors.find((s) => s.name === 'ghost');
+        expect(ghost?.status).toBe('fail');
+        expect(out.overall).toBe('fail');
+    });
+});
+describe('runSensors — not_certified + auto-discovery', () => {
+    let tmpDir;
+    beforeEach(() => {
+        mockExecSyncFn.mockReset();
+        mockExecSyncFn.mockReturnValue('');
+    });
+    afterEach(() => {
+        if (tmpDir) {
+            fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+            tmpDir = undefined;
+        }
+    });
+    it('returns not_certified when no manifest exists anywhere up the tree', () => {
+        tmpDir = mkTmp();
+        const out = (0, run_1.runSensors)({ cwd: tmpDir });
+        expect(out.overall).toBe('not_certified');
+        expect(out.sensors).toEqual([]);
+    });
+    it('discovers .awm/sensors.json in a parent directory (walk-up)', () => {
+        tmpDir = mkTmp();
+        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 = (0, run_1.runSensors)({ cwd: nested });
+        expect(out.overall).toBe('pass');
+        expect(out.sensors.length).toBe(1);
+    });
+});
+describe('reconcilePack', () => {
+    // Build a minimal fake registry in a tmpdir (registry/ no longer lives in this repo —
+    // content lives in awm-baseline-registry / awm-documentation-registry).
+    let FAKE_REGISTRY;
+    beforeAll(() => {
+        FAKE_REGISTRY = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-fake-reg-'));
+        const jstsPackDir = path_1.default.join(FAKE_REGISTRY, 'sensor-packs', 'js-ts');
+        const genericPackDir = path_1.default.join(FAKE_REGISTRY, 'sensor-packs', 'generic');
+        fs_1.default.mkdirSync(jstsPackDir, { recursive: true });
+        fs_1.default.mkdirSync(genericPackDir, { recursive: true });
+        // Minimal pack.json matching what the real js-ts pack ships
+        fs_1.default.writeFileSync(path_1.default.join(jstsPackDir, 'pack.json'), JSON.stringify({
+            name: 'js-ts',
+            description: 'JavaScript/TypeScript sensor pack (test fixture)',
+            sensors: {
+                typecheck: { defaultCmd: 'npx tsc --noEmit', fast: true },
+                lint: { defaultCmd: 'npx eslint . --format json', fast: true },
+                security: { defaultCmd: 'semgrep --config .semgrep.awm.yml --json .', fast: false },
+                mutation: { enabled: false },
+            },
+        }));
+        fs_1.default.writeFileSync(path_1.default.join(genericPackDir, 'pack.json'), JSON.stringify({
+            name: 'generic',
+            description: 'Generic sensor pack (test fixture)',
+            sensors: {
+                security: { defaultCmd: 'semgrep .', fast: false },
+            },
+        }));
+    });
+    afterAll(() => { fs_1.default.rmSync(FAKE_REGISTRY, { recursive: true, force: true }); });
+    function tmpProject(pack, withPackageJson) {
+        const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-reconcile-'));
+        fs_1.default.mkdirSync(path_1.default.join(dir, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(dir, '.awm', 'sensors.json'), JSON.stringify({ pack, sensors: pack === 'generic'
+                ? { security: { cmd: 'semgrep .', fast: false } }
+                : {} }));
+        if (withPackageJson)
+            fs_1.default.writeFileSync(path_1.default.join(dir, 'package.json'), '{}');
+        return dir;
+    }
+    it('upgrades generic→js-ts when package.json is present', () => {
+        const { reconcilePack } = require('../../../src/commands/sensors/run');
+        const dir = tmpProject('generic', true);
+        try {
+            const manifest = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, '.awm', 'sensors.json'), 'utf-8'));
+            const res = reconcilePack(dir, manifest, FAKE_REGISTRY);
+            expect(res.manifest.pack).toBe('js-ts');
+            expect(res.upgradedFrom).toBe('generic');
+            expect(Object.keys(res.manifest.sensors)).toContain('typecheck');
+            // custom sensor cmd preserved through merge
+            expect(res.manifest.sensors.security?.cmd).toBe('semgrep .');
+            // persisted to disk
+            const onDisk = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, '.awm', 'sensors.json'), 'utf-8'));
+            expect(onDisk.pack).toBe('js-ts');
+        }
+        finally {
+            fs_1.default.rmSync(dir, { recursive: true });
+        }
+    });
+    it('is a no-op when pack is already real (idempotent)', () => {
+        const { reconcilePack } = require('../../../src/commands/sensors/run');
+        const dir = tmpProject('js-ts', true);
+        try {
+            const manifest = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, '.awm', 'sensors.json'), 'utf-8'));
+            const res = reconcilePack(dir, manifest, FAKE_REGISTRY);
+            expect(res.manifest.pack).toBe('js-ts');
+            expect(res.upgradedFrom).toBeUndefined();
+        }
+        finally {
+            fs_1.default.rmSync(dir, { recursive: true });
+        }
+    });
+    it('does not upgrade a truly generic project (no indicators)', () => {
+        const { reconcilePack } = require('../../../src/commands/sensors/run');
+        const dir = tmpProject('generic', false);
+        try {
+            const manifest = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, '.awm', 'sensors.json'), 'utf-8'));
+            const res = reconcilePack(dir, manifest, FAKE_REGISTRY);
+            expect(res.manifest.pack).toBe('generic');
+            expect(res.upgradedFrom).toBeUndefined();
+        }
+        finally {
+            fs_1.default.rmSync(dir, { recursive: true });
+        }
+    });
+});
+describe('runSensors — test sensor (exit-code)', () => {
+    let tmpDir;
+    const path = require('path');
+    const os = require('os');
+    beforeEach(() => {
+        jest.resetModules();
+        tmpDir = fs_1.default.mkdtempSync(path.join(os.tmpdir(), 'awm-run-test-'));
+        fs_1.default.mkdirSync(path.join(tmpDir, '.awm'), { recursive: true });
+        mockExecSyncFn.mockReset();
+    });
+    afterEach(() => { fs_1.default.rmSync(tmpDir, { recursive: true }); });
+    const load = () => require('../../../src/commands/sensors/run');
+    it('test sensor: passing run (exit 0 with output) is pass, not fail', () => {
+        fs_1.default.writeFileSync(path.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({ pack: 'js-ts', sensors: { test: { cmd: 'npm test', fast: false } } }));
+        mockExecSyncFn.mockReturnValue('Tests: 6 passed, 6 total\n'); // runner prints on success
+        const { runSensors } = load();
+        const result = runSensors({ all: true, cwd: tmpDir });
+        const test = result.sensors.find((s) => s.name === 'test');
+        expect(test.status).toBe('pass');
+    });
+    it('test sensor: failing run (non-zero exit) is fail, not skipped', () => {
+        fs_1.default.writeFileSync(path.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({ pack: 'js-ts', sensors: { test: { cmd: 'npm test', fast: false } } }));
+        mockExecSyncFn.mockImplementation(() => {
+            const err = new Error('jest failed');
+            err.status = 1;
+            err.stdout = 'Tests: 1 failed, 5 passed\n';
+            err.stderr = '';
+            throw err;
+        });
+        const { runSensors } = load();
+        const result = runSensors({ all: true, cwd: tmpDir });
+        const test = result.sensors.find((s) => s.name === 'test');
+        expect(test.status).toBe('fail');
+        expect(result.overall).toBe('fail');
+    });
+    it('test sensor: missing npm test script exits non-zero → fail, not skipped', () => {
+        fs_1.default.writeFileSync(path.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({ pack: 'js-ts', sensors: { test: { cmd: 'npm test', fast: false } } }));
+        mockExecSyncFn.mockImplementation(() => {
+            const err = new Error('npm test: missing script');
+            err.status = 1;
+            err.stdout = 'npm error Missing script: test\n';
+            err.stderr = '';
+            throw err;
+        });
+        const { runSensors } = load();
+        const result = runSensors({ all: true, cwd: tmpDir });
+        const test = result.sensors.find((s) => s.name === 'test');
+        expect(test.status).toBe('fail');
+        expect(result.overall).toBe('fail');
+    });
+});
+describe('runSensors — honest floor (not_certified over real stack)', () => {
+    const path = require('path');
+    const os = require('os');
+    beforeEach(() => {
+        mockExecSyncFn.mockReset();
+        mockExecSyncFn.mockReturnValue('');
+    });
+    it('returns not_certified (not skipped) for a generic manifest over a real stack', () => {
+        const dir = fs_1.default.mkdtempSync(path.join(os.tmpdir(), 'awm-floor-'));
+        fs_1.default.mkdirSync(path.join(dir, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path.join(dir, '.awm', 'sensors.json'), JSON.stringify({ pack: 'generic', sensors: { security: { cmd: 'semgrep .', fast: false } } }));
+        fs_1.default.writeFileSync(path.join(dir, 'package.json'), '{}');
+        const prevHome = process.env.AWM_HOME;
+        const fakeHome = fs_1.default.mkdtempSync(path.join(os.tmpdir(), 'awm-nohome-'));
+        process.env.AWM_HOME = fakeHome; // no registry cache → no upgrade
+        try {
+            jest.resetModules();
+            const { runSensors } = require('../../../src/commands/sensors/run');
+            const result = runSensors({ fast: true, cwd: dir }); // --fast filters the fast:false security sensor → empty
+            expect(result.overall).toBe('not_certified');
+        }
+        finally {
+            process.env.AWM_HOME = prevHome;
+            fs_1.default.rmSync(dir, { recursive: true });
+            fs_1.default.rmSync(fakeHome, { recursive: true, force: true });
+        }
+    });
+});