agentic-workflow-manager 2.0.0

package/dist/tests/commands/registry/add.test.js

@@ -0,0 +1,223 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// cli/tests/commands/registry/add.test.ts
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const child_process_1 = require("child_process");
+const GIT = (cwd, cmd) => (0, child_process_1.execSync)(`git -c user.email=t@t.t -c user.name=t ${cmd}`, { cwd, stdio: 'pipe' });
+function makeSourceRepo(base, opts) {
+    const dir = path_1.default.join(base, `src-${opts.skill ?? 'empty'}`);
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    if (!opts.empty && opts.skill) {
+        fs_1.default.mkdirSync(path_1.default.join(dir, 'skills', opts.skill), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'skills', opts.skill, 'SKILL.md'), `---\nname: ${opts.skill}\ndescription: d\n---\n`);
+    }
+    else {
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'README.md'), 'no content dirs');
+    }
+    GIT(dir, 'init -q');
+    GIT(dir, 'add -A');
+    GIT(dir, 'commit -qm init');
+    return dir;
+}
+describe('addRegistry', () => {
+    let tmpHome;
+    let tmpWork;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-regadd-home-'));
+        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-regadd-work-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        fs_1.default.rmSync(tmpWork, { recursive: true, force: true });
+        if (originalHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = originalHome;
+        if (originalAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalAwmHome;
+    });
+    it('clones, validates, writes config and derives name from remote', async () => {
+        const source = makeSourceRepo(tmpWork, { skill: 'alpha' });
+        const { addRegistry } = require('../../../src/commands/registry/add');
+        const result = await addRegistry(source);
+        expect(result.ok).toBe(true);
+        expect(result.name).toBe(path_1.default.basename(source));
+        const { readRegistriesConfig } = require('../../../src/core/registries');
+        expect(readRegistriesConfig()).toEqual([{ name: path_1.default.basename(source), remote: source }]);
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/registries', path_1.default.basename(source), 'skills/alpha/SKILL.md'))).toBe(true);
+    });
+    it('is atomic: invalid layout → no config written, clone dir cleaned up', async () => {
+        const source = makeSourceRepo(tmpWork, { empty: true });
+        const { addRegistry } = require('../../../src/commands/registry/add');
+        const result = await addRegistry(source, 'bad');
+        expect(result.ok).toBe(false);
+        expect(result.error).toMatch(/skills\/, bundles\/, workflows\/, agents\//);
+        const { readRegistriesConfig } = require('../../../src/core/registries');
+        expect(readRegistriesConfig()).toEqual([]);
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/registries/bad'))).toBe(false);
+    });
+    it('is atomic: artifact collision with existing configured registry → no config, cleanup, error names both', async () => {
+        // First registry already registered with the 'alpha' skill
+        const source1 = path_1.default.join(tmpWork, 'src-alpha-1');
+        fs_1.default.mkdirSync(path_1.default.join(source1, 'skills', 'alpha'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(source1, 'skills', 'alpha', 'SKILL.md'), '---\nname: alpha\ndescription: d\n---\n');
+        GIT(source1, 'init -q');
+        GIT(source1, 'add -A');
+        GIT(source1, 'commit -qm init');
+        const { addRegistry } = require('../../../src/commands/registry/add');
+        const first = await addRegistry(source1, 'baseline');
+        expect(first.ok).toBe(true);
+        // Second registry also has 'alpha' — should collide
+        const source2 = path_1.default.join(tmpWork, 'src-alpha-2');
+        fs_1.default.mkdirSync(path_1.default.join(source2, 'skills', 'alpha'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(source2, 'skills', 'alpha', 'SKILL.md'), '---\nname: alpha\ndescription: d\n---\n');
+        GIT(source2, 'init -q');
+        GIT(source2, 'add -A');
+        GIT(source2, 'commit -qm init');
+        jest.resetModules();
+        const { addRegistry: addRegistry2 } = require('../../../src/commands/registry/add');
+        const result = await addRegistry2(source2, 'personal');
+        expect(result.ok).toBe(false);
+        expect(result.error).toMatch(/collision/i);
+        expect(result.error).toMatch(/alpha/);
+        const { readRegistriesConfig } = require('../../../src/core/registries');
+        expect(readRegistriesConfig().map((r) => r.name)).toEqual(['baseline']);
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/registries/personal'))).toBe(false);
+    });
+    it('rejects dot as registry name without touching disk', async () => {
+        const { addRegistry } = require('../../../src/commands/registry/add');
+        const result = await addRegistry('/any/remote', '.');
+        expect(result.ok).toBe(false);
+        expect(result.error).toMatch(/Invalid registry name/);
+        const { readRegistriesConfig } = require('../../../src/core/registries');
+        expect(readRegistriesConfig()).toEqual([]);
+    });
+    it('rejects duplicate registry name and clone failure without writing config', async () => {
+        const source = makeSourceRepo(tmpWork, { skill: 'alpha' });
+        const { addRegistry } = require('../../../src/commands/registry/add');
+        await addRegistry(source, 'personal');
+        const dup = await addRegistry(source, 'personal');
+        expect(dup.ok).toBe(false);
+        expect(dup.error).toMatch(/already exists/);
+        const broken = await addRegistry(path_1.default.join(tmpWork, 'no-such-repo'), 'ghost');
+        expect(broken.ok).toBe(false);
+        const { readRegistriesConfig } = require('../../../src/core/registries');
+        expect(readRegistriesConfig().map((r) => r.name)).toEqual(['personal']);
+    });
+});
+describe('registry add + bundle install (post-add flow)', () => {
+    let tmpHome;
+    let tmpWork;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-regadd-bundle-home-'));
+        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-regadd-bundle-work-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        fs_1.default.rmSync(tmpWork, { recursive: true, force: true });
+        if (originalHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = originalHome;
+        if (originalAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalAwmHome;
+    });
+    function makeBundleRegistry(base, name) {
+        const dir = path_1.default.join(base, `bundle-src-${name}`);
+        fs_1.default.mkdirSync(path_1.default.join(dir, 'skills', name), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'skills', name, 'SKILL.md'), `---\nname: ${name}\ndescription: d\n---\n`);
+        fs_1.default.mkdirSync(path_1.default.join(dir, 'bundles', name), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'bundles', name, 'bundle.json'), JSON.stringify({ name, version: '1.0.0', scope: 'ambient', skills: [name] }));
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'catalog.json'), JSON.stringify({
+            version: 1,
+            bundles: [{ name, source: `./bundles/${name}`, version: '1.0.0', scope: 'ambient' }],
+        }));
+        GIT(dir, 'init -q');
+        GIT(dir, 'add -A');
+        GIT(dir, 'commit -qm init');
+        return dir;
+    }
+    it('--install-all simulation: installs bundle and skill symlink after add', async () => {
+        const skillName = 'myskill';
+        const source = makeBundleRegistry(tmpWork, skillName);
+        const { addRegistry } = require('../../../src/commands/registry/add');
+        const result = await addRegistry(source, 'team');
+        expect(result.ok).toBe(true);
+        const { installBundlesFromRegistry } = require('../../../src/commands/registry/install-bundles');
+        const results = installBundlesFromRegistry(result.contentRoot, 'all', ['claude-code'], tmpWork);
+        expect(results).toHaveLength(1);
+        expect(results[0].bundle).toBe(skillName);
+        const skillLink = path_1.default.join(tmpHome, '.claude', 'skills', skillName);
+        expect(fs_1.default.existsSync(skillLink)).toBe(true);
+        const { readRegistriesConfig } = require('../../../src/core/registries');
+        expect(readRegistriesConfig()).toHaveLength(1);
+        expect(readRegistriesConfig()[0].name).toBe('team');
+    });
+    it('--no-install simulation: add persists but skill symlink absent', async () => {
+        const skillName = 'noskill';
+        const source = makeBundleRegistry(tmpWork, skillName);
+        const { addRegistry } = require('../../../src/commands/registry/add');
+        const result = await addRegistry(source, 'team');
+        expect(result.ok).toBe(true);
+        // Simulate --no-install: do not call installBundlesFromRegistry
+        const { readRegistriesConfig } = require('../../../src/core/registries');
+        expect(readRegistriesConfig()).toHaveLength(1);
+        expect(readRegistriesConfig()[0].name).toBe('team');
+        const skillLink = path_1.default.join(tmpHome, '.claude', 'skills', skillName);
+        expect(fs_1.default.existsSync(skillLink)).toBe(false);
+    });
+    it('atomicity: failing install does not revert the registry add', async () => {
+        const skillName = 'atomicskill';
+        const source = makeBundleRegistry(tmpWork, skillName);
+        const { addRegistry } = require('../../../src/commands/registry/add');
+        const result = await addRegistry(source, 'team');
+        expect(result.ok).toBe(true);
+        // Corrupt the bundle.json so discoverAllBundles inside installBundlesFromRegistry
+        // reads an invalid file and throws, simulating a failing install.
+        const bundleJsonPath = path_1.default.join(result.contentRoot, 'bundles', skillName, 'bundle.json');
+        fs_1.default.rmSync(bundleJsonPath);
+        const { installBundlesFromRegistry } = require('../../../src/commands/registry/install-bundles');
+        // discoverAllBundles skips entries whose bundle.json is missing (continue), so deletion
+        // produces an empty result (no throw). Force a failure via corrupted catalog.json instead.
+        const catalogPath = path_1.default.join(result.contentRoot, 'catalog.json');
+        fs_1.default.writeFileSync(catalogPath, 'not-json');
+        let threw = false;
+        try {
+            installBundlesFromRegistry(result.contentRoot, 'all', ['claude-code'], tmpWork);
+        }
+        catch (_e) {
+            threw = true;
+        }
+        expect(threw).toBe(true);
+        // Registry add must still be persisted
+        const { readRegistriesConfig } = require('../../../src/core/registries');
+        expect(readRegistriesConfig()).toHaveLength(1);
+        expect(readRegistriesConfig()[0].name).toBe('team');
+        // Skill symlink must NOT exist (install failed)
+        const skillLink = path_1.default.join(tmpHome, '.claude', 'skills', skillName);
+        expect(fs_1.default.existsSync(skillLink)).toBe(false);
+    });
+});

package/dist/tests/commands/registry/install-bundles.test.js

@@ -0,0 +1,87 @@
+"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"));
+function writeBundleRoot(root, bundleName, skillName) {
+    fs_1.default.mkdirSync(path_1.default.join(root, 'bundles', bundleName), { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.join(root, 'skills', skillName), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(root, 'skills', skillName, 'SKILL.md'), `---\nname: ${skillName}\ndescription: d\n---\n`);
+    fs_1.default.writeFileSync(path_1.default.join(root, 'bundles', bundleName, 'bundle.json'), JSON.stringify({ name: bundleName, version: '1.0.0', scope: 'ambient', skills: [skillName] }));
+    fs_1.default.writeFileSync(path_1.default.join(root, 'catalog.json'), JSON.stringify({
+        version: 1,
+        bundles: [{ name: bundleName, source: `./bundles/${bundleName}`, version: '1.0.0', scope: 'ambient' }],
+    }));
+}
+describe('installBundlesFromRegistry', () => {
+    let tmpHome;
+    let tmpWork;
+    const origHome = process.env.HOME;
+    const origAwmHome = process.env.AWM_HOME;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-home-'));
+        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-work-'));
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        jest.resetModules();
+    });
+    afterEach(() => {
+        process.env.HOME = origHome;
+        if (origAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = origAwmHome;
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        fs_1.default.rmSync(tmpWork, { recursive: true, force: true });
+    });
+    it('installs all ambient bundles of the given registry root for the agent', () => {
+        const { REGISTRIES_DIR } = require('../../../src/core/registries');
+        const regRoot = path_1.default.join(REGISTRIES_DIR, 'team');
+        writeBundleRoot(regRoot, 'team-pack', 'team-skill');
+        fs_1.default.mkdirSync(path_1.default.join(tmpHome, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpHome, '.awm', 'registries.json'), JSON.stringify([{ name: 'team', remote: 'r' }]));
+        const { installBundlesFromRegistry } = require('../../../src/commands/registry/install-bundles');
+        const results = installBundlesFromRegistry(regRoot, 'all', ['claude-code'], tmpWork);
+        expect(results).toHaveLength(1);
+        expect(results[0].bundle).toBe('team-pack');
+        expect(results[0].installed.length).toBeGreaterThan(0);
+        // ambient → global → symlink under the isolated home
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.claude', 'skills', 'team-skill'))).toBe(true);
+    });
+    it('returns empty when the registry has no bundles', () => {
+        const { REGISTRIES_DIR } = require('../../../src/core/registries');
+        const regRoot = path_1.default.join(REGISTRIES_DIR, 'empty');
+        fs_1.default.mkdirSync(path_1.default.join(regRoot, 'skills', 's'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(regRoot, 'skills', 's', 'SKILL.md'), `---\nname: s\ndescription: d\n---\n`);
+        fs_1.default.mkdirSync(path_1.default.join(tmpHome, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpHome, '.awm', 'registries.json'), JSON.stringify([{ name: 'empty', remote: 'r' }]));
+        const { installBundlesFromRegistry } = require('../../../src/commands/registry/install-bundles');
+        expect(installBundlesFromRegistry(regRoot, 'all', ['claude-code'], tmpWork)).toEqual([]);
+    });
+    it('installs only the named bundles when a list is given', () => {
+        const { REGISTRIES_DIR } = require('../../../src/core/registries');
+        const regRoot = path_1.default.join(REGISTRIES_DIR, 'team');
+        writeBundleRoot(regRoot, 'wanted', 'skill-w');
+        // second bundle in same catalog
+        fs_1.default.mkdirSync(path_1.default.join(regRoot, 'bundles', 'unwanted'), { recursive: true });
+        fs_1.default.mkdirSync(path_1.default.join(regRoot, 'skills', 'skill-u'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(regRoot, 'skills', 'skill-u', 'SKILL.md'), `---\nname: skill-u\ndescription: d\n---\n`);
+        fs_1.default.writeFileSync(path_1.default.join(regRoot, 'bundles', 'unwanted', 'bundle.json'), JSON.stringify({ name: 'unwanted', version: '1.0.0', scope: 'ambient', skills: ['skill-u'] }));
+        fs_1.default.writeFileSync(path_1.default.join(regRoot, 'catalog.json'), JSON.stringify({
+            version: 1,
+            bundles: [
+                { name: 'wanted', source: './bundles/wanted', version: '1.0.0', scope: 'ambient' },
+                { name: 'unwanted', source: './bundles/unwanted', version: '1.0.0', scope: 'ambient' },
+            ],
+        }));
+        fs_1.default.mkdirSync(path_1.default.join(tmpHome, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpHome, '.awm', 'registries.json'), JSON.stringify([{ name: 'team', remote: 'r' }]));
+        const { installBundlesFromRegistry } = require('../../../src/commands/registry/install-bundles');
+        const results = installBundlesFromRegistry(regRoot, ['wanted'], ['claude-code'], tmpWork);
+        expect(results.map((r) => r.bundle)).toEqual(['wanted']);
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.claude', 'skills', 'skill-u'))).toBe(false);
+    });
+});

package/dist/tests/commands/registry/remove.test.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// cli/tests/commands/registry/remove.test.ts
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+describe('removeRegistry', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-regrm-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        if (originalHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = originalHome;
+        if (originalAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalAwmHome;
+    });
+    it('removes the config entry and the clone dir', () => {
+        const { writeRegistriesConfig, registryContentRoot, readRegistriesConfig } = require('../../../src/core/registries');
+        writeRegistriesConfig([{ name: 'personal', remote: 'r' }]);
+        fs_1.default.mkdirSync(path_1.default.join(registryContentRoot('personal'), 'skills'), { recursive: true });
+        const { removeRegistry } = require('../../../src/commands/registry/remove');
+        const result = removeRegistry('personal');
+        expect(result.ok).toBe(true);
+        expect(readRegistriesConfig()).toEqual([]);
+        expect(fs_1.default.existsSync(registryContentRoot('personal'))).toBe(false);
+    });
+    it('errors on unknown name without touching anything', () => {
+        const { removeRegistry } = require('../../../src/commands/registry/remove');
+        const result = removeRegistry('nope');
+        expect(result.ok).toBe(false);
+        expect(result.error).toMatch(/not found/);
+    });
+});

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

@@ -0,0 +1,43 @@
+"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"));
+function writeSkill(root, name) {
+    const dir = path_1.default.join(root, 'skills', name);
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(dir, 'SKILL.md'), `---\nname: ${name}\ndescription: d\n---\n`);
+}
+describe('registry override status', () => {
+    let tmp;
+    beforeEach(() => {
+        tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-'));
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmp, { recursive: true, force: true });
+    });
+    it('classifies declared overrides as active or without effect', () => {
+        const base = path_1.default.join(tmp, 'base');
+        const team = path_1.default.join(tmp, 'team');
+        writeSkill(base, 'brainstorming');
+        writeSkill(team, 'brainstorming');
+        writeSkill(team, 'team-only');
+        fs_1.default.writeFileSync(path_1.default.join(team, 'awm-registry.json'), JSON.stringify({ overrides: ['brainstorming', 'ghost-skill'] }));
+        const { overrideStatus } = require('../../../src/commands/registry/status');
+        const status = overrideStatus(team, [base]);
+        expect(status).toEqual([
+            { name: 'brainstorming', active: true },
+            { name: 'ghost-skill', active: false },
+        ]);
+    });
+    it('returns empty for a registry without manifest', () => {
+        const team = path_1.default.join(tmp, 'team');
+        writeSkill(team, 'x');
+        const { overrideStatus } = require('../../../src/commands/registry/status');
+        expect(overrideStatus(team, [])).toEqual([]);
+    });
+});

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

@@ -0,0 +1,106 @@
+"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 baseline_1 = require("../../../src/commands/sensors/baseline");
+const err = (over = {}) => ({
+    file: 'lib/a.ts', rule: 'TS2345', message: 'Argument of type X', ...over,
+});
+describe('fingerprint', () => {
+    it('is stable across line-number drift (digits masked)', () => {
+        const a = (0, baseline_1.fingerprint)('typecheck', err({ message: 'a.ts line 199 — bad', line: 199 }));
+        const b = (0, baseline_1.fingerprint)('typecheck', err({ message: 'a.ts line 412 — bad', line: 412 }));
+        expect(a).toBe(b);
+    });
+    it('differs when file or rule differs', () => {
+        const base = (0, baseline_1.fingerprint)('lint', err());
+        expect((0, baseline_1.fingerprint)('lint', err({ file: 'lib/b.ts' }))).not.toBe(base);
+        expect((0, baseline_1.fingerprint)('lint', err({ rule: 'TS9999' }))).not.toBe(base);
+    });
+    it('is STABLE across message wording changes when a rule id is present', () => {
+        // Regression guard: a tool-version bump or rule-config tweak (e.g. adding
+        // argsIgnorePattern) rewords the message. The fingerprint must NOT change,
+        // or the entire baseline goes stale and reports false "new" findings.
+        const base = (0, baseline_1.fingerprint)('lint', err({ message: "'x' is defined but never used." }));
+        const reworded = (0, baseline_1.fingerprint)('lint', err({ message: "'x' is defined but never used. Allowed unused args must match /^_/u." }));
+        expect(reworded).toBe(base);
+    });
+    it('falls back to the masked message when there is no rule id (generic sensor)', () => {
+        const base = (0, baseline_1.fingerprint)('raw', { message: 'SENSOR[raw] something broke' });
+        expect((0, baseline_1.fingerprint)('raw', { message: 'SENSOR[raw] something else' })).not.toBe(base);
+        // digits are still masked in the fallback path
+        expect((0, baseline_1.fingerprint)('raw', { message: 'err at 199' })).toBe((0, baseline_1.fingerprint)('raw', { message: 'err at 412' }));
+    });
+    it('differs by sensor', () => {
+        expect((0, baseline_1.fingerprint)('typecheck', err())).not.toBe((0, baseline_1.fingerprint)('lint', err()));
+    });
+});
+describe('partition', () => {
+    it('returns all errors as new when there is no accepted set', () => {
+        const errors = [err(), err({ file: 'lib/b.ts' })];
+        const { newErrors, suppressed } = (0, baseline_1.partition)('lint', errors, undefined);
+        expect(newErrors).toHaveLength(2);
+        expect(suppressed).toBe(0);
+    });
+    it('suppresses errors whose fingerprint is in the baseline', () => {
+        const accepted = err();
+        const fresh = err({ file: 'lib/new.ts' });
+        const baseline = [(0, baseline_1.fingerprint)('lint', accepted)];
+        const { newErrors, suppressed } = (0, baseline_1.partition)('lint', [accepted, fresh], baseline);
+        expect(suppressed).toBe(1);
+        expect(newErrors).toHaveLength(1);
+        expect(newErrors[0].file).toBe('lib/new.ts');
+    });
+    it('counts occurrences: extra same-(file,rule) findings beyond the baseline budget are new', () => {
+        // Baseline accepted 3 occurrences of the same (file, rule). The file now
+        // has 5 → only the 2 beyond the accepted budget are new. This is the gap
+        // that a plain Set of fingerprints would have missed (it would suppress
+        // all 5). Messages vary to prove matching ignores wording.
+        const occ = (msg) => err({ message: msg });
+        const baseline = [
+            (0, baseline_1.fingerprint)('lint', err()), (0, baseline_1.fingerprint)('lint', err()), (0, baseline_1.fingerprint)('lint', err()),
+        ];
+        const current = [occ('a'), occ('b'), occ('c'), occ('d'), occ('e')];
+        const { newErrors, suppressed } = (0, baseline_1.partition)('lint', current, baseline);
+        expect(suppressed).toBe(3);
+        expect(newErrors).toHaveLength(2);
+    });
+    it('fixing findings below the baseline budget yields zero new', () => {
+        const baseline = [(0, baseline_1.fingerprint)('lint', err()), (0, baseline_1.fingerprint)('lint', err())];
+        const { newErrors, suppressed } = (0, baseline_1.partition)('lint', [err()], baseline);
+        expect(suppressed).toBe(1);
+        expect(newErrors).toHaveLength(0);
+    });
+});
+describe('readBaseline / writeBaseline', () => {
+    let cwd;
+    beforeEach(() => { cwd = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-bl-')); });
+    afterEach(() => { fs_1.default.rmSync(cwd, { recursive: true }); });
+    it('returns null when no baseline file exists', () => {
+        expect((0, baseline_1.readBaseline)(cwd)).toBeNull();
+    });
+    it('returns null on a corrupt baseline file (does not throw)', () => {
+        fs_1.default.mkdirSync(path_1.default.join(cwd, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(cwd, '.awm', 'sensors.baseline.json'), '{ not json');
+        expect((0, baseline_1.readBaseline)(cwd)).toBeNull();
+    });
+    it('round-trips a baseline through write then read', () => {
+        (0, baseline_1.writeBaseline)(cwd, { lint: ['abc'], typecheck: ['def'] });
+        expect((0, baseline_1.readBaseline)(cwd)).toEqual({ lint: ['abc'], typecheck: ['def'] });
+    });
+});
+describe('buildBaseline', () => {
+    it('maps each sensor to the fingerprints of its current findings', () => {
+        const b = (0, baseline_1.buildBaseline)([
+            { name: 'lint', errors: [err(), err({ file: 'lib/b.ts' })] },
+            { name: 'typecheck', errors: [err()] },
+        ]);
+        expect(b.lint).toHaveLength(2);
+        expect(b.typecheck).toHaveLength(1);
+        expect(b.lint[0]).toBe((0, baseline_1.fingerprint)('lint', err()));
+    });
+});

package/dist/tests/commands/sensors/formatters/eslint.test.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const eslint_1 = require("../../../../src/commands/sensors/formatters/eslint");
+const SAMPLE = JSON.stringify([
+    {
+        filePath: '/home/user/project/src/index.ts',
+        messages: [
+            { ruleId: 'no-unused-vars', severity: 2, message: "'x' is assigned a value but never used.", line: 42, column: 5 },
+            { ruleId: 'no-console', severity: 1, message: 'Unexpected console statement.', line: 10, column: 1 }
+        ]
+    }
+]);
+describe('parseEslintOutput', () => {
+    let cwdSpy;
+    beforeEach(() => { cwdSpy = jest.spyOn(process, 'cwd').mockReturnValue('/home/user/project'); });
+    afterEach(() => { cwdSpy.mockRestore(); });
+    it('parses ESLint JSON and filters severity-1 warnings', () => {
+        const errors = (0, eslint_1.parseEslintOutput)(SAMPLE);
+        expect(errors).toHaveLength(1);
+        expect(errors[0].rule).toBe('no-unused-vars');
+        expect(errors[0].line).toBe(42);
+        expect(errors[0].message).toMatch('SENSOR[lint]');
+        expect(errors[0].message).toMatch('Fix:');
+    });
+    it('returns empty array for malformed JSON', () => {
+        expect((0, eslint_1.parseEslintOutput)('not json')).toEqual([]);
+    });
+    it('returns empty array when all messages are warnings', () => {
+        const warnings = JSON.stringify([{ filePath: '/p/f.ts', messages: [{ ruleId: 'r', severity: 1, message: 'w', line: 1, column: 1 }] }]);
+        expect((0, eslint_1.parseEslintOutput)(warnings)).toEqual([]);
+    });
+});

package/dist/tests/commands/sensors/formatters/semgrep.test.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const semgrep_1 = require("../../../../src/commands/sensors/formatters/semgrep");
+const generic_1 = require("../../../../src/commands/sensors/formatters/generic");
+const SAMPLE_SEMGREP = JSON.stringify({
+    results: [
+        { check_id: 'js.sql-injection', path: 'src/db.ts', start: { line: 15 }, extra: { message: 'SQL injection risk detected.' } }
+    ]
+});
+describe('parseSemgrepOutput', () => {
+    it('parses Semgrep JSON results', () => {
+        const errors = (0, semgrep_1.parseSemgrepOutput)(SAMPLE_SEMGREP);
+        expect(errors).toHaveLength(1);
+        expect(errors[0].file).toBe('src/db.ts');
+        expect(errors[0].line).toBe(15);
+        expect(errors[0].rule).toBe('js.sql-injection');
+        expect(errors[0].message).toMatch('SENSOR[security]');
+        expect(errors[0].message).toMatch('Fix:');
+    });
+    it('returns empty array for malformed JSON', () => {
+        expect((0, semgrep_1.parseSemgrepOutput)('bad json')).toEqual([]);
+    });
+    it('returns empty array when results is empty', () => {
+        expect((0, semgrep_1.parseSemgrepOutput)(JSON.stringify({ results: [] }))).toEqual([]);
+    });
+});
+describe('parseGenericOutput', () => {
+    it('wraps raw output with SENSOR[raw] prefix', () => {
+        const errors = (0, generic_1.parseGenericOutput)('something went wrong');
+        expect(errors).toHaveLength(1);
+        expect(errors[0].message).toMatch('SENSOR[raw]');
+        expect(errors[0].message).toMatch('something went wrong');
+    });
+    it('returns empty array for empty output', () => {
+        expect((0, generic_1.parseGenericOutput)('')).toEqual([]);
+        expect((0, generic_1.parseGenericOutput)('   ')).toEqual([]);
+    });
+});

package/dist/tests/commands/sensors/formatters/tsc.test.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tsc_1 = require("../../../../src/commands/sensors/formatters/tsc");
+describe('parseTscOutput', () => {
+    it('parses a standard tsc error line', () => {
+        const raw = "src/auth.ts(23,7): error TS2322: Type 'string | undefined' is not assignable to type 'string'.";
+        const errors = (0, tsc_1.parseTscOutput)(raw);
+        expect(errors).toHaveLength(1);
+        expect(errors[0].file).toBe('src/auth.ts');
+        expect(errors[0].line).toBe(23);
+        expect(errors[0].rule).toBe('TS2322');
+        expect(errors[0].message).toMatch('SENSOR[typecheck]');
+        expect(errors[0].message).toMatch('Fix:');
+    });
+    it('returns empty array for clean output', () => {
+        expect((0, tsc_1.parseTscOutput)('')).toEqual([]);
+        expect((0, tsc_1.parseTscOutput)('Found 0 errors.')).toEqual([]);
+    });
+    it('ignores malformed lines, parses valid ones', () => {
+        const raw = 'some random text\nsrc/file.ts(1,1): error TS0000: Real error.';
+        const errors = (0, tsc_1.parseTscOutput)(raw);
+        expect(errors).toHaveLength(1);
+        expect(errors[0].file).toBe('src/file.ts');
+    });
+});

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

@@ -0,0 +1,18 @@
+"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() }));
+jest.mock('../../../src/commands/sensors/init', () => ({ initSensors: jest.fn() }));
+jest.mock('../../../src/commands/sensors/status', () => ({ computeSensorStatus: jest.fn() }));
+jest.mock('../../../src/commands/sensors/install', () => ({ installSensorHook: jest.fn() }));
+jest.mock('../../../src/commands/sensors/baseline', () => ({ buildBaseline: jest.fn(), writeBaseline: jest.fn() }));
+jest.mock('../../../src/core/registries', () => ({ capabilityRoot: jest.fn(() => '/mock/registry') }));
+const index_1 = require("../../../src/commands/sensors/index");
+describe('exitCodeFor — sensor run verdict → exit code', () => {
+    const base = (overall) => ({ sensors: [], overall });
+    it('pass → 0', () => expect((0, index_1.exitCodeFor)(base('pass'))).toBe(0));
+    it('skipped → 0', () => expect((0, index_1.exitCodeFor)(base('skipped'))).toBe(0));
+    it('not_certified → 0 (signal is in overall, not exit code)', () => expect((0, index_1.exitCodeFor)(base('not_certified'))).toBe(0));
+    it('fail → 1', () => expect((0, index_1.exitCodeFor)(base('fail'))).toBe(1));
+});