agentic-workflow-manager 6.5.2 → 8.0.0

package/dist/tests/core/ledger/store.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 store_1 = require("../../../src/core/ledger/store");
+const types_1 = require("../../../src/core/ledger/types");
 function mkTmp() {
     return fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-ledger-'));
 }
@@ -32,6 +33,14 @@ describe('ledger store — add/list', () => {
     test('ledgerPath sanitizes branch slashes into the filename', () => {
         expect((0, store_1.ledgerPath)(cwd, 'feature/foo')).toBe(path_1.default.join(cwd, '.awm', 'ledger', 'feature__foo.jsonl'));
     });
+    test.each(['..\\outside', 'feature\\..\\outside'])('rejects a Windows path-traversal branch %p before it can escape the ledger directory', (branch) => {
+        // On Windows, a backslash is a separator even when this test suite runs on POSIX.
+        // Keep the regression explicit so future path changes cannot reintroduce the escape.
+        expect(branch.split(path_1.default.win32.sep)).toContain('..');
+        expect(() => (0, store_1.ledgerPath)(cwd, branch)).toThrow(/invalid ledger branch/i);
+        expect(() => (0, store_1.addEntry)(cwd, entry({ branch }))).toThrow(/invalid ledger branch/i);
+        expect(fs_1.default.existsSync(path_1.default.join(cwd, '.awm', 'ledger'))).toBe(false);
+    });
     test('addEntry creates .awm/ledger/ and appends one jsonl line', () => {
         (0, store_1.addEntry)(cwd, entry());
         const raw = fs_1.default.readFileSync((0, store_1.ledgerPath)(cwd, 'feat-x'), 'utf-8');
@@ -43,6 +52,25 @@ describe('ledger store — add/list', () => {
         (0, store_1.addEntry)(cwd, entry({ signature: 'second', desc: 'another' }));
         expect((0, store_1.listEntries)(cwd, 'feat-x')).toHaveLength(2);
     });
+    test('persists an optional reusable defect class', () => {
+        (0, store_1.addEntry)(cwd, entry({ defectClass: 'lint-errors' }));
+        expect(JSON.parse(fs_1.default.readFileSync((0, store_1.ledgerPath)(cwd, 'feat-x'), 'utf-8'))).toMatchObject({ defectClass: 'lint-errors' });
+    });
+    test('rejects an invalid direct entry before it can cross the durable boundary', () => {
+        expect(() => (0, store_1.addEntry)(cwd, { ...entry(), defectClass: 'Bad_ID' })).toThrow(/invalid-defect-class/i);
+        expect(fs_1.default.existsSync((0, store_1.ledgerPath)(cwd, 'feat-x'))).toBe(false);
+    });
+    test('keeps a legacy entry without defectClass valid and unclassified', () => {
+        const parsed = (0, types_1.parseLedgerEntry)(entry(), 'line 1');
+        expect(parsed).toMatchObject({ ok: true, entry: { defectClass: undefined } });
+    });
+    test.each(['', 'Bad_ID', '../escape', 'a b', '-leading', 'trailing-'])('skips a persisted invalid defect class %p', (defectClass) => {
+        const parsed = (0, types_1.parseLedgerEntry)({ ...entry(), defectClass }, 'line 1');
+        expect(parsed).toMatchObject({ ok: false, reason: 'invalid-defect-class' });
+    });
+    test('rejects a non-string durable source instead of returning an unsafe parse result', () => {
+        expect(() => (0, types_1.parseLedgerEntry)(entry(), null)).toThrow(/source.*string/i);
+    });
     test('listEntries on a branch with no ledger returns []', () => {
         expect((0, store_1.listEntries)(cwd, 'never-touched')).toEqual([]);
     });
@@ -154,4 +182,84 @@ describe('ledger store — archive', () => {
     test('archiving a non-existent ledger is a no-op returning false', () => {
         expect((0, store_1.archiveLedger)(cwd, 'feat-x', '20260606T000000')).toBe(false);
     });
+    test('refuses to overwrite an existing archive and preserves both ledger files', () => {
+        (0, store_1.addEntry)(cwd, entry({ signature: 'active-evidence' }));
+        const archivePath = path_1.default.join(cwd, '.awm', 'ledger', 'archive', 'feat-x-20260606T000000.jsonl');
+        fs_1.default.mkdirSync(path_1.default.dirname(archivePath), { recursive: true });
+        fs_1.default.writeFileSync(archivePath, JSON.stringify(entry({ signature: 'archived-evidence' })) + '\n');
+        expect(() => (0, store_1.archiveLedger)(cwd, 'feat-x', '20260606T000000')).toThrow(/archive.*already exists/i);
+        expect((0, store_1.listEntries)(cwd, 'feat-x')).toEqual([expect.objectContaining({ signature: 'active-evidence' })]);
+        expect(fs_1.default.readFileSync(archivePath, 'utf-8')).toContain('archived-evidence');
+    });
+    test('refuses a dangling symlink archive destination and preserves the active ledger', () => {
+        (0, store_1.addEntry)(cwd, entry({ signature: 'active-evidence' }));
+        const archivePath = path_1.default.join(cwd, '.awm', 'ledger', 'archive', 'feat-x-20260606T000000.jsonl');
+        fs_1.default.mkdirSync(path_1.default.dirname(archivePath), { recursive: true });
+        try {
+            fs_1.default.symlinkSync(path_1.default.join(cwd, 'missing-target.jsonl'), archivePath);
+        }
+        catch (error) {
+            if (process.platform === 'win32')
+                return;
+            throw error;
+        }
+        expect(() => (0, store_1.archiveLedger)(cwd, 'feat-x', '20260606T000000')).toThrow(/archive.*already exists/i);
+        expect(fs_1.default.lstatSync(archivePath).isSymbolicLink()).toBe(true);
+        expect((0, store_1.listEntries)(cwd, 'feat-x')).toEqual([expect.objectContaining({ signature: 'active-evidence' })]);
+    });
+    test('rejects a symlinked archive directory without moving the active ledger outside the project', () => {
+        (0, store_1.addEntry)(cwd, entry({ signature: 'active-evidence' }));
+        const archive = path_1.default.join(cwd, '.awm', 'ledger', 'archive');
+        const outside = path_1.default.join(cwd, 'outside');
+        fs_1.default.mkdirSync(outside, { recursive: true });
+        try {
+            fs_1.default.symlinkSync(outside, archive, 'dir');
+        }
+        catch (error) {
+            if (error.code === 'EPERM')
+                return;
+            throw error;
+        }
+        expect(() => (0, store_1.archiveLedger)(cwd, 'feat-x', '20260606T000000')).toThrow(/unsafe|escape|symlink/i);
+        expect((0, store_1.listEntries)(cwd, 'feat-x')).toEqual([expect.objectContaining({ signature: 'active-evidence' })]);
+        expect(fs_1.default.readdirSync(outside)).toEqual([]);
+    });
+    test('rejects a symlinked source ledger and preserves the link target', () => {
+        const outside = path_1.default.join(cwd, 'outside.jsonl');
+        fs_1.default.writeFileSync(outside, JSON.stringify(entry({ signature: 'outside-evidence' })) + '\n');
+        const source = (0, store_1.ledgerPath)(cwd, 'feat-x');
+        fs_1.default.mkdirSync(path_1.default.dirname(source), { recursive: true });
+        try {
+            fs_1.default.symlinkSync(outside, source);
+        }
+        catch (error) {
+            if (error.code === 'EPERM')
+                return;
+            throw error;
+        }
+        expect(() => (0, store_1.archiveLedger)(cwd, 'feat-x', '20260606T000000')).toThrow(/unsafe|escape|symlink/i);
+        expect(fs_1.default.lstatSync(source).isSymbolicLink()).toBe(true);
+        expect(fs_1.default.readFileSync(outside, 'utf-8')).toContain('outside-evidence');
+        expect(fs_1.default.existsSync(path_1.default.join(cwd, '.awm', 'ledger', 'archive', 'feat-x-20260606T000000.jsonl'))).toBe(false);
+    });
+    test.each(['', '.', '..', '../outside', '/tmp/outside', 'C:\\temp\\outside'])('rejects an unsafe archive label %p before touching a ledger', (label) => {
+        expect(() => (0, store_1.archiveLedger)(cwd, 'feat-x', label)).toThrow(/invalid ledger label/i);
+        expect(fs_1.default.existsSync(path_1.default.join(cwd, '.awm', 'ledger'))).toBe(false);
+    });
+    test.each(['safe/child', 'safe\\child'])('rejects an archive label with a separator %p before it can create ledger files', (label) => {
+        expect(() => (0, store_1.archiveLedger)(cwd, 'feat-x', label)).toThrow(/invalid ledger label/i);
+        expect(fs_1.default.existsSync(path_1.default.join(cwd, '.awm', 'ledger'))).toBe(false);
+        expect(fs_1.default.existsSync((0, store_1.ledgerPath)(cwd, 'feat-x'))).toBe(false);
+    });
+    test('rejects a Windows traversal archive label before it can create an escaped file', () => {
+        const label = '..\\outside';
+        const archiveRoot = path_1.default.win32.join('C:\\project', '.awm', 'ledger', 'archive');
+        const escaped = path_1.default.win32.resolve(archiveRoot, label);
+        (0, store_1.addEntry)(cwd, entry());
+        expect(escaped.startsWith(`${archiveRoot}\\`)).toBe(false);
+        expect(() => (0, store_1.archiveLedger)(cwd, 'feat-x', label)).toThrow(/invalid ledger label/i);
+        expect(fs_1.default.existsSync(path_1.default.join(cwd, '.awm', 'ledger', 'archive'))).toBe(false);
+        expect(fs_1.default.existsSync(path_1.default.join(cwd, 'outside.jsonl'))).toBe(false);
+        expect(fs_1.default.existsSync((0, store_1.ledgerPath)(cwd, 'feat-x'))).toBe(true);
+    });
 });

package/dist/tests/core/profile-pins.test.js

@@ -11,7 +11,8 @@ 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 -c tag.gpgSign=false ${cmd}`, { cwd, stdio: 'pipe' });
 function makeTaggedRepo(base, name, versions) {
     const dir = path_1.default.join(base, name);
-    fs_1.default.mkdirSync(dir, { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.join(dir, 'skills'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(dir, 'skills', '.keep'), 'fixture');
     GIT(dir, 'init -q -b main');
     fs_1.default.writeFileSync(path_1.default.join(dir, 'VERSION'), 'init');
     GIT(dir, 'add -A');

package/dist/tests/core/project-skill-links.test.js

@@ -156,4 +156,26 @@ describe('awm sync reaches the project-scope reconciliation', () => {
         expect(out.code).toBe(0);
         expect(spy).toHaveBeenCalledTimes(1);
     });
+    it('fails before project reconciliation when registry sync leaves unsafe content', async () => {
+        writeProfile(['demo']);
+        const registry = path_1.default.join(process.env.AWM_HOME, 'registries', 'baseline');
+        const outside = path_1.default.join(home, 'outside-skill');
+        fs_1.default.writeFileSync(outside, 'outside');
+        fs_1.default.mkdirSync(path_1.default.join(registry, 'skills'), { recursive: true });
+        fs_1.default.symlinkSync(outside, path_1.default.join(registry, 'skills', 'artifact'));
+        fs_1.default.writeFileSync(path_1.default.join(process.env.AWM_HOME, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: 'r' }]));
+        const reconcile = jest.fn(() => []);
+        const syncProfile = jest.fn(() => ({ installed: [], skipped: [], extensions: [], transactionIds: [], modifiedFiles: [] }));
+        const { runSyncCore } = require('../../src/commands/sync');
+        const out = await runSyncCore({ cwd: projectRoot }, {
+            syncRegistries: async () => [{ name: 'baseline', action: 'error', error: 'unsafe layout' }],
+            verifyMinCliVersions: () => [],
+            verifyProjectPins: async () => [],
+            syncProfile,
+            reconcileProjectSkillLinks: reconcile,
+        });
+        expect(out.code).toBe(1);
+        expect(reconcile).not.toHaveBeenCalled();
+        expect(syncProfile).not.toHaveBeenCalled();
+    });
 });

package/dist/tests/core/registries-capability.test.js

@@ -49,4 +49,14 @@ describe('capabilityRoot', () => {
         m.writeRegistriesConfig([]);
         expect(m.capabilityRoot('hooks')).toBeNull();
     });
+    it('ignora una capability que no es un directorio y selecciona la primera regular', () => {
+        const m = require('../../src/core/registries');
+        const aRoot = path_1.default.join(tmpHome, '.awm', 'registries', 'a');
+        const bRoot = path_1.default.join(tmpHome, '.awm', 'registries', 'b');
+        fs_1.default.mkdirSync(aRoot, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(aRoot, 'hooks'), 'not a directory');
+        fs_1.default.mkdirSync(path_1.default.join(bRoot, 'hooks'), { recursive: true });
+        m.writeRegistriesConfig([{ name: 'a', remote: 'x' }, { name: 'b', remote: 'y' }]);
+        expect(m.capabilityRoot('hooks')).toBe(bRoot);
+    });
 });

package/dist/tests/core/registries-sync.test.js

@@ -101,6 +101,22 @@ describe('syncRegistries (git fixtures locales)', () => {
         const synced = fs_1.default.readFileSync(path_1.default.join(tmpHome, '.awm/registries/personal/skills/alpha/SKILL.md'), 'utf-8');
         expect(synced).toContain('v2');
     });
+    it('reports an unsafe symlink introduced by an update instead of a successful pull', async () => {
+        const m = require('../../src/core/registries');
+        const source = makeSourceRepo(tmpWork, 'alpha');
+        m.writeRegistriesConfig([{ name: 'personal', remote: source }]);
+        await m.syncRegistries();
+        const outside = path_1.default.join(tmpWork, 'outside-skill.md');
+        fs_1.default.writeFileSync(outside, 'outside');
+        fs_1.default.rmSync(path_1.default.join(source, 'skills', 'alpha', 'SKILL.md'));
+        fs_1.default.symlinkSync(outside, path_1.default.join(source, 'skills', 'alpha', 'SKILL.md'));
+        GIT(source, 'add -A');
+        GIT(source, 'commit -qm unsafe-link');
+        const results = await m.syncRegistries();
+        expect(results[0].action).toBe('error');
+        expect(results[0].error).toMatch(/unsafe|layout/i);
+        expect(m.contentRoots()).toEqual([]);
+    });
     it('registry con tags queda en el último tag y reporta la versión', async () => {
         const m = require('../../src/core/registries');
         const source = makeSourceRepo(tmpWork, 'alpha');

package/dist/tests/core/registries.test.js

@@ -61,6 +61,16 @@ describe('core/registries', () => {
         fs_1.default.writeFileSync(path_1.default.join(tmpHome, '.awm', 'registries.json'), JSON.stringify([{ name: '.', remote: 'r' }]));
         expect(() => m.readRegistriesConfig()).toThrow(/path traversal/);
     });
+    it('readRegistriesConfig rejects an empty name that would resolve to the registries parent', () => {
+        const m = load();
+        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: '', remote: 'r' }]));
+        expect(() => m.readRegistriesConfig()).toThrow(/path traversal/);
+        expect(() => m.registryContentRoot('')).toThrow(/Invalid registry name/);
+    });
+    it.each(['.', 'baseline/skills', 'baseline\\skills'])('registryContentRoot rejects unsafe registry component %s', (name) => {
+        expect(() => load().registryContentRoot(name)).toThrow(/Invalid registry name/);
+    });
     it('listRegistries derives contentRoot under ~/.awm/registries/<name>', () => {
         const m = load();
         m.writeRegistriesConfig([{ name: 'personal', remote: 'r' }]);
@@ -72,14 +82,82 @@ describe('core/registries', () => {
         const m = load();
         // 'present' existe en disco, 'ghost' no
         const present = path_1.default.join(tmpHome, '.awm', 'registries', 'present');
-        fs_1.default.mkdirSync(present, { recursive: true });
+        fs_1.default.mkdirSync(path_1.default.join(present, 'skills'), { recursive: true });
         m.writeRegistriesConfig([{ name: 'present', remote: 'r1' }, { name: 'ghost', remote: 'r2' }]);
         expect(m.contentRoots()).toEqual([present]);
     });
+    it('contentRoots preserves an empty configured registry for later synchronization', () => {
+        const m = load();
+        const empty = path_1.default.join(tmpHome, '.awm', 'registries', 'empty');
+        fs_1.default.mkdirSync(empty, { recursive: true });
+        m.writeRegistriesConfig([{ name: 'empty', remote: 'r1' }]);
+        expect(m.contentRoots()).toEqual([empty]);
+    });
+    it('contentRoots omits a configured registry with nested artifact symlinks', () => {
+        const m = load();
+        const present = path_1.default.join(tmpHome, '.awm', 'registries', 'present');
+        const outside = path_1.default.join(tmpHome, 'outside-skill.md');
+        fs_1.default.writeFileSync(outside, 'outside');
+        fs_1.default.mkdirSync(path_1.default.join(present, 'skills', 'linked'), { recursive: true });
+        fs_1.default.symlinkSync(outside, path_1.default.join(present, 'skills', 'linked', 'SKILL.md'));
+        m.writeRegistriesConfig([{ name: 'present', remote: 'r1' }]);
+        expect(m.contentRoots()).toEqual([]);
+    });
+    it('contentRoots omits a configured registry root that is itself a symlink', () => {
+        const m = load();
+        const outside = path_1.default.join(tmpHome, 'outside-registry');
+        const linked = path_1.default.join(tmpHome, '.awm', 'registries', 'linked');
+        fs_1.default.mkdirSync(path_1.default.join(outside, 'skills'), { recursive: true });
+        fs_1.default.mkdirSync(path_1.default.dirname(linked), { recursive: true });
+        fs_1.default.symlinkSync(outside, linked, 'dir');
+        m.writeRegistriesConfig([{ name: 'linked', remote: 'r1' }]);
+        expect(m.contentRoots()).toEqual([]);
+    });
+    it('contentRoots omits a registry with symlinked root metadata', () => {
+        const m = load();
+        for (const metadata of ['awm-registry.json', 'catalog.json']) {
+            const root = path_1.default.join(tmpHome, '.awm', 'registries', metadata);
+            const outside = path_1.default.join(tmpHome, `outside-${metadata}`);
+            fs_1.default.writeFileSync(outside, '{}');
+            fs_1.default.mkdirSync(path_1.default.join(root, 'skills'), { recursive: true });
+            fs_1.default.symlinkSync(outside, path_1.default.join(root, metadata));
+            m.writeRegistriesConfig([{ name: metadata, remote: 'r1' }]);
+            expect(m.contentRoots()).toEqual([]);
+            fs_1.default.rmSync(path_1.default.join(tmpHome, '.awm', 'registries', metadata), { recursive: true, force: true });
+        }
+    });
     it('contentRoots returns [] when no registries are configured', () => {
         const m = load();
         expect(m.contentRoots()).toEqual([]);
     });
+    it('treats an errored registry with an unsafe existing layout as unusable', () => {
+        const m = load();
+        const root = path_1.default.join(tmpHome, '.awm', 'registries', 'baseline');
+        const outside = path_1.default.join(tmpHome, 'outside');
+        fs_1.default.writeFileSync(outside, 'outside');
+        fs_1.default.mkdirSync(path_1.default.join(root, 'skills'), { recursive: true });
+        fs_1.default.symlinkSync(outside, path_1.default.join(root, 'skills', 'artifact'));
+        m.writeRegistriesConfig([{ name: 'baseline', remote: 'r' }]);
+        const results = [{ name: 'baseline', action: 'error', error: 'unsafe layout' }];
+        expect(m.unusableSyncedRegistries(results)).toEqual([{ name: 'baseline', error: 'unsafe layout' }]);
+        expect(() => m.assertSyncedRegistriesUsable(results)).toThrow(/registry sync failed/);
+    });
+    it('treats an errored registry with an empty existing root as unusable', () => {
+        const m = load();
+        const root = path_1.default.join(tmpHome, '.awm', 'registries', 'baseline');
+        fs_1.default.mkdirSync(root, { recursive: true });
+        m.writeRegistriesConfig([{ name: 'baseline', remote: 'r' }]);
+        const results = [{ name: 'baseline', action: 'error', error: 'network unreachable' }];
+        expect(m.unusableSyncedRegistries(results)).toEqual([{ name: 'baseline', error: 'network unreachable' }]);
+        expect(() => m.assertSyncedRegistriesUsable(results)).toThrow(/registry sync failed/);
+    });
+    it('requires synchronization before discovery when a configured root is empty', () => {
+        const m = load();
+        const root = path_1.default.join(tmpHome, '.awm', 'registries', 'baseline');
+        fs_1.default.mkdirSync(root, { recursive: true });
+        m.writeRegistriesConfig([{ name: 'baseline', remote: 'r' }]);
+        expect(m.registriesNeedSync()).toBe(true);
+    });
     it('validateRegistryLayout requires at least one content dir at the root', () => {
         const m = load();
         const root = path_1.default.join(tmpHome, 'somerepo');
@@ -88,4 +166,54 @@ describe('core/registries', () => {
         fs_1.default.mkdirSync(path_1.default.join(root, 'skills'));
         expect(m.validateRegistryLayout(root)).toBe(true);
     });
+    it('validateRegistryLayout accepts a regular capability-only registry', () => {
+        const m = load();
+        for (const directory of ['hooks', 'sensor-packs']) {
+            const root = path_1.default.join(tmpHome, `repo-${directory}`);
+            fs_1.default.mkdirSync(path_1.default.join(root, directory), { recursive: true });
+            expect(m.validateRegistryLayout(root)).toBe(true);
+        }
+    });
+    it('validateRegistryLayout fails closed when a content entry cannot be inspected', () => {
+        const m = load();
+        const root = path_1.default.join(tmpHome, 'somerepo');
+        const inaccessible = path_1.default.join(root, 'bundles');
+        fs_1.default.mkdirSync(path_1.default.join(root, 'skills'), { recursive: true });
+        const original = fs_1.default.lstatSync;
+        const lstat = jest.spyOn(fs_1.default, 'lstatSync').mockImplementation(((candidate) => {
+            if (candidate === inaccessible) {
+                const error = Object.assign(new Error('permission denied'), { code: 'EACCES' });
+                throw error;
+            }
+            return original(candidate);
+        }));
+        try {
+            expect(m.validateRegistryLayout(root)).toBe(false);
+        }
+        finally {
+            lstat.mockRestore();
+        }
+    });
+    it('validateRegistryLayout rejects nested symlinks in every managed registry directory', () => {
+        const m = load();
+        for (const directory of m.REGISTRY_DIR_NAMES) {
+            const root = path_1.default.join(tmpHome, `repo-${directory}`);
+            const outside = path_1.default.join(tmpHome, `outside-${directory}`);
+            fs_1.default.writeFileSync(outside, 'outside');
+            fs_1.default.mkdirSync(path_1.default.join(root, directory, 'nested'), { recursive: true });
+            fs_1.default.symlinkSync(outside, path_1.default.join(root, directory, 'nested', 'artifact'));
+            expect(m.validateRegistryLayout(root)).toBe(false);
+        }
+    });
+    it('validateRegistryLayout rejects symlinked root metadata', () => {
+        const m = load();
+        for (const metadata of ['awm-registry.json', 'catalog.json']) {
+            const root = path_1.default.join(tmpHome, `repo-${metadata}`);
+            const outside = path_1.default.join(tmpHome, `outside-${metadata}`);
+            fs_1.default.writeFileSync(outside, '{}');
+            fs_1.default.mkdirSync(path_1.default.join(root, 'skills'), { recursive: true });
+            fs_1.default.symlinkSync(outside, path_1.default.join(root, metadata));
+            expect(m.validateRegistryLayout(root)).toBe(false);
+        }
+    });
 });

package/dist/tests/core/registry-manifest.test.js

@@ -54,6 +54,13 @@ describe('registry manifest (awm-registry.json)', () => {
         const { readRegistryManifest } = load();
         expect(() => readRegistryManifest(tmpWork)).toThrow(/awm-registry\.json/);
     });
+    it('rejects a manifest symlink instead of reading outside the registry', () => {
+        const outside = path_1.default.join(tmpHome, 'outside-manifest.json');
+        fs_1.default.writeFileSync(outside, JSON.stringify({ overrides: ['outside'] }));
+        fs_1.default.symlinkSync(outside, path_1.default.join(tmpWork, 'awm-registry.json'));
+        const { readRegistryManifest } = load();
+        expect(() => readRegistryManifest(tmpWork)).toThrow(/symbolic link/);
+    });
     it('throws when overrides is not an array of strings', () => {
         fs_1.default.writeFileSync(path_1.default.join(tmpWork, 'awm-registry.json'), JSON.stringify({ overrides: 'brainstorming' }));
         const { readRegistryManifest } = load();

package/dist/tests/core/same-existing-path.test.js

@@ -14,6 +14,7 @@ const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const paths_1 = require("../../src/core/paths");
+const itPosix = process.platform !== 'win32' ? it : it.skip;
 describe('sameExistingPath', () => {
     let root;
     beforeEach(() => { root = fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-samepath-'))); });
@@ -34,12 +35,46 @@ describe('sameExistingPath', () => {
         fs_1.default.mkdirSync(b);
         expect((0, paths_1.sameExistingPath)(a, b)).toBe(false);
     });
+    it('does not treat colliding inode metadata as identity when native realpaths differ', () => {
+        const a = path_1.default.join(root, 'inode-collision-a');
+        const b = path_1.default.join(root, 'inode-collision-b');
+        fs_1.default.mkdirSync(a);
+        fs_1.default.mkdirSync(b);
+        const stat = jest.spyOn(fs_1.default, 'statSync').mockImplementation((() => ({ dev: 1, ino: 1 })));
+        const platform = Object.getOwnPropertyDescriptor(process, 'platform');
+        Object.defineProperty(process, 'platform', { ...platform, value: 'win32' });
+        try {
+            expect((0, paths_1.sameExistingPath)(a, b)).toBe(false);
+        }
+        finally {
+            Object.defineProperty(process, 'platform', platform);
+            stat.mockRestore();
+        }
+    });
+    itPosix('conserva la identidad de un archivo con hard links POSIX', () => {
+        const original = path_1.default.join(root, 'original');
+        const alias = path_1.default.join(root, 'alias');
+        fs_1.default.writeFileSync(original, 'contenido');
+        fs_1.default.linkSync(original, alias);
+        expect((0, paths_1.sameExistingPath)(alias, original)).toBe(true);
+    });
     it('una ruta inexistente nunca "coincide" — la identidad no se afirma sin prueba', () => {
         const a = path_1.default.join(root, 'a');
         fs_1.default.mkdirSync(a);
         expect((0, paths_1.sameExistingPath)(a, path_1.default.join(root, 'fantasma'))).toBe(false);
         expect((0, paths_1.sameExistingPath)(path_1.default.join(root, 'fantasma'), path_1.default.join(root, 'fantasma'))).toBe(false);
     });
+    it('falla cerrado si la canonicalización nativa no está disponible', () => {
+        const a = path_1.default.join(root, 'a');
+        fs_1.default.mkdirSync(a);
+        const realpath = jest.spyOn(fs_1.default.realpathSync, 'native').mockImplementation(() => { throw new Error('canonicalización no disponible'); });
+        try {
+            expect((0, paths_1.sameExistingPath)(a, a)).toBe(false);
+        }
+        finally {
+            realpath.mockRestore();
+        }
+    });
     it('sobrevive a separadores y segmentos redundantes', () => {
         const a = path_1.default.join(root, 'a');
         fs_1.default.mkdirSync(a);

package/dist/tests/core/sync-gates.test.js

@@ -41,7 +41,8 @@ async function rmSyncRetryingBusy(target, attempts = 10, delayMs = 100) {
 }
 function makeRegistryWithManifest(base, name, manifest) {
     const dir = path_1.default.join(base, name);
-    fs_1.default.mkdirSync(dir, { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.join(dir, 'skills'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(dir, 'skills', '.keep'), 'fixture');
     GIT(dir, 'init -q -b main');
     fs_1.default.writeFileSync(path_1.default.join(dir, 'awm-registry.json'), JSON.stringify(manifest));
     GIT(dir, 'add -A');

package/dist/tests/integration/copilot-init-isolated.test.js

@@ -94,6 +94,24 @@ describe('copilot provider — isolated home E2E (devCore global-scope guard reg
     function readPrefs() {
         return JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmpHome, '.awm/preferences.json'), 'utf8'));
     }
+    it('machine-only enables Copilot without writing project artifacts (R7, R15)', async () => {
+        seedPublicRegistryFixture(path_1.default.join(tmpHome, '.awm/registries/baseline'));
+        fs_1.default.rmSync(path_1.default.join(tmpWork, 'package.json'));
+        const before = fs_1.default.readdirSync(tmpWork).sort();
+        const { runInit } = require('../../src/commands/init');
+        const code = await runInit({
+            cwd: tmpWork,
+            yes: true,
+            agent: 'copilot',
+            machineOnly: true,
+        });
+        expect(code).toBe(0);
+        expect(readPrefs().enabledAgents).toEqual(['copilot']);
+        expect(fs_1.default.readdirSync(tmpWork).sort()).toEqual(before);
+        expect(fs_1.default.existsSync(path_1.default.join(tmpWork, 'AGENTS.md'))).toBe(false);
+        expect(fs_1.default.existsSync(path_1.default.join(tmpWork, '.github'))).toBe(false);
+        expect(fs_1.default.existsSync(path_1.default.join(tmpWork, '.awm'))).toBe(false);
+    });
     it('completes without crashing/rolling back (real bug repro) and delivers content via AGENTS.md, not a doomed global-scope install', async () => {
         seedPublicRegistryFixture(path_1.default.join(tmpHome, '.awm/registries/baseline'));
         const { runInit } = require('../../src/commands/init');

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

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const contract_1 = require("../../src/commands/sensors/compatibility/contract");
+const discovery_1 = require("../../src/commands/sensors/compatibility/discovery");
+const probe_1 = require("../../src/commands/sensors/compatibility/probe");
+const resolve_1 = require("../../src/commands/sensors/compatibility/resolve");
+const cliDir = path_1.default.resolve(__dirname, '../..');
+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) => {
+        for (const entry of fs_1.default.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+            const file = path_1.default.join(directory, entry.name);
+            hash.update(path_1.default.relative(root, file));
+            if (entry.isDirectory())
+                walk(file);
+            else if (entry.isFile())
+                hash.update(fs_1.default.readFileSync(file));
+        }
+    };
+    walk(root);
+    return hash.digest('hex');
+}
+function createFixture() {
+    const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-r3-compatibility-'));
+    const project = path_1.default.join(root, 'project');
+    const awmHome = path_1.default.join(root, 'awm-home');
+    const registryRoot = path_1.default.join(awmHome, 'registries', 'baseline');
+    fs_1.default.cpSync(projectFixture, project, { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.join(project, 'node_modules', 'eslint'), { recursive: true });
+    fs_1.default.copyFileSync(path_1.default.join(project, 'eslint-tool-package.json'), path_1.default.join(project, 'node_modules', 'eslint', 'package.json'));
+    fs_1.default.mkdirSync(path_1.default.dirname(registryRoot), { recursive: true });
+    fs_1.default.cpSync(registryFixture, registryRoot, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(awmHome, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: 'fixture' }]));
+    return { root, project, awmHome, registryRoot };
+}
+function runCli(fixture, ...args) {
+    return (0, child_process_1.spawnSync)(process.execPath, [bin, 'sensors', ...args], {
+        cwd: fixture.project,
+        encoding: 'utf8',
+        env: { ...process.env, AWM_HOME: fixture.awmHome, AWM_NO_UPDATE_CHECK: '1' },
+    });
+}
+function json(result) {
+    expect(result.status).toBe(0);
+    if (!(result.stdout ?? '').trim())
+        throw new Error(`coverage emitted no JSON: stderr=${result.stderr ?? ''}`);
+    return JSON.parse(result.stdout ?? '');
+}
+beforeAll(() => {
+    if (!fs_1.default.existsSync(bin))
+        throw new Error(`Compatibility E2E requires the compiled CLI at ${bin}; run npm run build before this test.`);
+});
+// This is a portable resolver *semantic* matrix: `platform` is injected into
+// the resolver, so it proves the three path/selection branches but does not
+// claim that this Linux process is a native macOS or Windows execution. Native
+// binary coverage is exercised separately below and by the CI OS matrix.
+test.each(['linux', 'darwin', 'win32'])('keeps injected resolver semantics consistent on %s (R9.1)', async (platform) => {
+    const fixture = createFixture();
+    try {
+        const source = JSON.parse(fs_1.default.readFileSync(path_1.default.join(fixture.registryRoot, 'sensor-packs', 'js-ts', 'pack.json'), 'utf8'));
+        const parsed = (0, contract_1.parseSensorPack)(source, 'fixture/pack.json');
+        if (parsed.kind !== 'v2')
+            throw new Error('fixture must be a v2 pack');
+        const discovered = (0, discovery_1.discoverProjectEvidence)(fixture.project, parsed.pack, { platform: () => platform });
+        const probe = await (0, probe_1.runCompatibilityProbe)({ kind: 'version' }, { cwd: fixture.project, toolExecutable: 'eslint' }, async () => ({
+            code: 0, signal: null, timedOut: false, overflowed: false, stdout: 'eslint v10.4.1', stderr: '',
+        }));
+        const result = (0, resolve_1.resolveSensorCompatibility)(parsed.pack.sensors.lint, { ...discovered, probe }, { pack: 'js-ts', sensor: 'lint' });
+        expect(result).toMatchObject({ state: 'certified', variantId: 'eslint-10', toolVersion: '10.4.1' });
+    }
+    finally {
+        fs_1.default.rmSync(fixture.root, { recursive: true, force: true });
+    }
+});
+testWithNoFollow('compiled binary dispatches coverage and emits parseable JSON on the native CI platform', () => {
+    const fixture = createFixture();
+    try {
+        const report = json(runCli(fixture, 'coverage', '--json'));
+        expect(report).toMatchObject({ schemaVersion: 2, static: expect.any(Object), empirical: expect.any(Object) });
+    }
+    finally {
+        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)', () => {
+    const fixture = createFixture();
+    try {
+        const before = [hashTree(fixture.project), hashTree(fixture.awmHome)];
+        const legacy = json(runCli(fixture, 'coverage', '--json'));
+        expect(legacy).toMatchObject({ schemaVersion: 2, static: { status: 'inconclusive' } });
+        expect(legacy.static.classes).toEqual(expect.arrayContaining([expect.objectContaining({
+                id: 'lint-errors', status: 'unverifiable', detectors: expect.arrayContaining([expect.objectContaining({ compatibility: expect.objectContaining({ state: 'compatible-unverified' }) })]),
+            })]));
+        expect([hashTree(fixture.project), hashTree(fixture.awmHome)]).toEqual(before);
+        const migrated = runCli(fixture, 'init', '--registry-root', fixture.registryRoot, '--pack', 'js-ts', '--no-configure');
+        expect(migrated.status).toBe(0);
+        const manifest = JSON.parse(fs_1.default.readFileSync(path_1.default.join(fixture.project, '.awm', 'sensors.json'), 'utf8'));
+        expect(manifest).toMatchObject({ schemaVersion: 2, pack: 'js-ts', sensors: { lint: { variantId: 'eslint-10' } } });
+        const certified = json(runCli(fixture, 'coverage', '--json'));
+        expect(certified.static.classes).toEqual(expect.arrayContaining([expect.objectContaining({
+                id: 'lint-errors', status: 'covered', detectors: expect.arrayContaining([expect.objectContaining({ compatibility: expect.objectContaining({ state: 'certified' }) })]),
+            })]));
+        fs_1.default.writeFileSync(path_1.default.join(fixture.project, 'node_modules', 'eslint', 'package.json'), JSON.stringify({ name: 'eslint', version: '11.0.0' }));
+        const drift = json(runCli(fixture, 'coverage', '--json'));
+        expect(drift).toMatchObject({ overall: 'inconclusive', static: { classes: [expect.objectContaining({
+                        id: 'lint-errors', status: 'unverifiable', detectors: expect.arrayContaining([expect.objectContaining({ compatibility: expect.objectContaining({ state: 'compatible-unverified' }) })]),
+                    })] } });
+    }
+    finally {
+        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 });
+    }
+});