agentic-workflow-manager 9.5.0 → 9.6.1

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

@@ -0,0 +1,513 @@
+"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 migrate_1 = require("../../../src/commands/sensors/migrate");
+const safe_file_1 = require("../../../src/commands/sensors/compatibility/safe-file");
+const native_bridge_1 = require("../../../src/core/secure-fs/native-bridge");
+afterEach(() => (0, safe_file_1.setSecureFsForTests)(undefined));
+function replaceWithoutNoFollow(...args) {
+    let replace;
+    jest.isolateModules(() => {
+        jest.doMock('fs', () => {
+            const actual = jest.requireActual('fs');
+            const constants = { ...actual.constants, O_NOFOLLOW: undefined };
+            return { __esModule: true, default: { ...actual, constants }, ...actual, constants };
+        });
+        replace = require('../../../src/commands/sensors/migrate').replaceV2ManifestWithV3;
+    });
+    jest.dontMock('fs');
+    if (!replace)
+        throw new Error('portable migration replacement could not be loaded');
+    replace(...args);
+}
+const sensor = {
+    enabled: false, fast: true, timeout: 45_000, variantId: 'eslint-9',
+    command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.', '--format', 'json'] },
+    assets: ['eslint.config.awm.mjs'], policyRef: 'shared/semgrep-policy.json',
+    initializedCompatibility: { state: 'certified', reason: 'range-and-probe', variantId: 'eslint-9', toolVersion: '9.0.0', runtimeVersion: '24.0.0', certifiedRange: '>=9 <10', evidence: [{ kind: 'version', status: 'pass' }] },
+};
+const v2RegistryRoot = path_1.default.join(path_1.default.parse(process.cwd()).root, 'home', 'alice', '.awm', 'registries', 'baseline');
+const v2 = { schemaVersion: 2, pack: 'js-ts', packSelection: 'explicit', registryRoot: v2RegistryRoot, packageRoot: 'cli', sensors: { lint: sensor }, concurrency: 2 };
+const sourceRegistryRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-migrate-source-'));
+afterAll(() => fs_1.default.rmSync(sourceRegistryRoot, { recursive: true, force: true }));
+function resolvedSource(pack = 'js-ts', registry = 'baseline', contentRoot = sourceRegistryRoot) {
+    return {
+        kind: 'logical',
+        source: {
+            path: path_1.default.join(contentRoot, 'sensor-packs', pack, 'pack.json'),
+            content: JSON.stringify({
+                schemaVersion: 2, name: pack, description: 'fixture', detects: ['package.json'],
+                sensors: { lint: { applicability: { allFiles: ['package.json'] }, variants: [{
+                                id: 'eslint-9', priority: 1,
+                                requirements: { tool: 'eslint', toolRange: '>=9 <10', runtime: 'node', runtimeRange: '>=20' },
+                                certifiedRange: '>=9 <10', assets: [], formatter: 'generic', probe: { kind: 'eslint-print-config' },
+                                command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+                            }] } },
+                coverage: { schemaVersion: 1, classes: { linting: { description: 'fixture', detectors: [{ sensor: 'lint' }], remedy: { summary: 'fixture', command: 'npm test' } } } },
+            }),
+            registry: { name: registry, remote: 'https://example.invalid/baseline', contentRoot },
+        },
+    };
+}
+function sourceWithPack(mutator) {
+    const source = resolvedSource();
+    const pack = JSON.parse(source.source.content);
+    mutator(pack);
+    return { ...source, source: { ...source.source, content: JSON.stringify(pack) } };
+}
+function canonicalManifestPath(project) {
+    const manifestPath = path_1.default.join(project, '.awm', 'sensors.json');
+    fs_1.default.mkdirSync(path_1.default.dirname(manifestPath), { recursive: true });
+    return manifestPath;
+}
+describe('planV2Migration', () => {
+    it('returns an equivalent portable v3 candidate bound to the exact logical source', () => {
+        const plan = (0, migrate_1.planV2Migration)({ manifest: v2, source: resolvedSource() });
+        expect(plan.equivalent).toBe(true);
+        expect(plan.equivalence).toEqual({
+            pack: true,
+            enabledDisabled: true,
+            structuredCommands: true,
+            assets: true,
+            timeouts: true,
+            fast: true,
+            variants: true,
+            policies: true,
+            sensorIdentityAndOrder: true,
+            concurrency: true,
+            compatibilityEvidence: true,
+            packageRoot: true,
+            logicalSourceBinding: true,
+        });
+        expect(plan.candidate).toEqual({ schemaVersion: 3, mode: 'project-sensors', pack: 'js-ts', packSelection: 'explicit', source: { registry: 'baseline' }, packageRoot: 'cli', sensors: { lint: sensor }, concurrency: 2 });
+        expect(JSON.stringify(plan.candidate)).not.toContain('registryRoot');
+        expect(JSON.stringify(plan.candidate)).not.toContain('/home/alice');
+        expect(JSON.stringify(plan.equivalence)).not.toContain('registryRoot');
+        expect(JSON.stringify(plan.equivalence)).not.toContain('/home/alice');
+    });
+    it('invokes the secure-fs bridge before applying a migration', () => {
+        const project = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-migrate-'));
+        const manifestPath = canonicalManifestPath(project);
+        let leaseHeld = false;
+        const bridge = {
+            withProjectLease: jest.fn((_projectRoot, operation) => {
+                leaseHeld = true;
+                try {
+                    return operation();
+                }
+                finally {
+                    leaseHeld = false;
+                }
+            }),
+            readRegularFile: jest.fn((...args) => {
+                expect(leaseHeld).toBe(true);
+                return native_bridge_1.secureFs.readRegularFile(...args);
+            }),
+            writeProjectTransaction: jest.fn((...args) => {
+                expect(leaseHeld).toBe(true);
+                return native_bridge_1.secureFs.writeProjectTransaction(...args);
+            }),
+        };
+        try {
+            fs_1.default.writeFileSync(manifestPath, JSON.stringify(v2));
+            (0, safe_file_1.setSecureFsForTests)(bridge);
+            (0, migrate_1.replaceV2ManifestWithV3)(manifestPath, (0, migrate_1.planV2Migration)({ manifest: v2, source: resolvedSource() }).candidate, resolvedSource());
+            expect(bridge.withProjectLease).toHaveBeenCalledWith(project, expect.any(Function));
+            expect(bridge.readRegularFile).toHaveBeenCalledWith(manifestPath, 1024 * 1024);
+            expect(bridge.writeProjectTransaction).toHaveBeenCalledWith(project, '.awm/sensors.json', expect.any(Buffer), { mode: 'replace', expected: expect.any(Buffer), expectedIdentity: expect.any(Object), createParents: false });
+            const observed = bridge.readRegularFile.mock.results[0].value;
+            const writeOptions = bridge.writeProjectTransaction.mock.calls[0][3];
+            expect(writeOptions.expectedIdentity).toBe(observed.identity);
+        }
+        finally {
+            fs_1.default.rmSync(project, { recursive: true, force: true });
+        }
+    });
+    it('accepts an old bound registry root only when an explicitly supplied logical source contains every selected sensor variant', () => {
+        const legacyBound = { ...v2, registryRoot: path_1.default.join(path_1.default.parse(process.cwd()).root, 'opt', 'old-machine', 'registries', 'baseline') };
+        expect((0, migrate_1.planV2Migration)({ manifest: legacyBound, source: resolvedSource() }).candidate.source).toEqual({ registry: 'baseline' });
+        for (const source of [
+            sourceWithPack(pack => { pack.sensors.other = pack.sensors.lint; delete pack.sensors.lint; }),
+            sourceWithPack(pack => { (pack.sensors.lint.variants[0]).id = 'eslint-8'; }),
+        ]) {
+            expect(() => (0, migrate_1.planV2Migration)({ manifest: legacyBound, source })).toThrow('compatible');
+        }
+    });
+    it('accepts a uniquely rebound configured logical source but rejects physical manifest provenance', () => {
+        const rebound = { ...resolvedSource(), kind: 'legacy-rebound' };
+        expect((0, migrate_1.planV2Migration)({ manifest: v2, source: rebound }).candidate.source).toEqual({ registry: 'baseline' });
+        const bound = { ...resolvedSource(), kind: 'legacy-bound', source: {
+                ...resolvedSource().source,
+                registry: { ...resolvedSource().source.registry, name: 'manifest-provenance', remote: 'local' },
+            } };
+        expect(() => (0, migrate_1.planV2Migration)({ manifest: v2, source: bound })).toThrow('unique logical resolution');
+    });
+    it('rejects a replacement when any persisted sensor semantic differs', () => {
+        const project = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-migrate-'));
+        const manifestPath = canonicalManifestPath(project);
+        const original = JSON.stringify(v2, null, 2) + '\n';
+        try {
+            fs_1.default.writeFileSync(manifestPath, original);
+            const candidate = (0, migrate_1.planV2Migration)({ manifest: v2, source: resolvedSource() }).candidate;
+            const withoutPolicy = { ...candidate.sensors.lint };
+            delete withoutPolicy.policyRef;
+            for (const changed of [
+                { ...candidate.sensors.lint, fast: false },
+                { ...candidate.sensors.lint, variantId: 'eslint-8', initializedCompatibility: { ...candidate.sensors.lint.initializedCompatibility, variantId: 'eslint-8', toolVersion: '8.0.0', certifiedRange: '>=8 <9' } },
+                withoutPolicy,
+            ]) {
+                expect(() => (0, migrate_1.replaceV2ManifestWithV3)(manifestPath, { ...candidate, sensors: { lint: changed } }, resolvedSource())).toThrow('semantic mismatch');
+                expect(fs_1.default.readFileSync(manifestPath, 'utf8')).toBe(original);
+            }
+        }
+        finally {
+            fs_1.default.rmSync(project, { recursive: true, force: true });
+        }
+    });
+    it('requires source.path to be the canonical selected pack beneath its content root', () => {
+        const source = resolvedSource();
+        const mismatched = { ...source, source: { ...source.source, path: path_1.default.join(source.source.registry.contentRoot, 'sensor-packs', 'other', 'pack.json') } };
+        expect(() => (0, migrate_1.planV2Migration)({ manifest: v2, source: mismatched })).toThrow('exact resolved pack');
+    });
+    it('plans from the resolved source snapshot without probing its physical root', () => {
+        const unavailableRoot = path_1.default.join(os_1.default.tmpdir(), `awm-migrate-unavailable-${Date.now()}`);
+        const source = resolvedSource('js-ts', 'baseline', unavailableRoot);
+        expect((0, migrate_1.planV2Migration)({ manifest: v2, source }).candidate.source).toEqual({ registry: 'baseline' });
+    });
+    test.each([
+        [{ manifest: { schemaVersion: 3, mode: 'native-gate', reason: 'CI' }, source: resolvedSource() }, 'v2'],
+        [{ manifest: v2, source: { kind: 'source-unavailable' } }, 'unavailable'],
+        [{ manifest: v2, source: { kind: 'source-ambiguous' } }, 'ambiguous'],
+        [{ manifest: v2, source: { ...resolvedSource(), source: { ...resolvedSource().source, registry: { ...resolvedSource().source.registry, name: 'Baseline' } } } }, 'registry'],
+        [{ manifest: v2, source: { ...resolvedSource('python'), source: { ...resolvedSource('python').source, path: resolvedSource().source.path } } }, 'exact v2 pack'],
+        [{ manifest: { pack: 'js-ts', sensors: { lint: 'npm run lint' } }, source: resolvedSource() }, 'v2'],
+    ])('rejects unsafe migration input %#', (input, message) => {
+        expect(() => (0, migrate_1.planV2Migration)(input)).toThrow(message);
+    });
+    it('rejects physical home and registry paths in persisted sensor semantics while retaining relative evidence', () => {
+        const relative = {
+            ...v2,
+            sensors: { lint: { ...sensor, command: { ...sensor.command, args: ['--config', 'config/eslint.json'] }, initializedCompatibility: {
+                        ...sensor.initializedCompatibility, reason: 'reports/eslint.json', evidence: [{ kind: 'file', status: 'pass', path: 'reports/eslint.json' }],
+                    } } },
+        };
+        expect((0, migrate_1.planV2Migration)({ manifest: relative, source: resolvedSource() }).candidate.sensors.lint).toMatchObject({
+            command: { args: ['--config', 'config/eslint.json'] },
+            initializedCompatibility: { reason: 'reports/eslint.json', evidence: [{ path: 'reports/eslint.json' }] },
+        });
+        for (const manifest of [
+            { ...v2, sensors: { lint: { ...sensor, command: { ...sensor.command, args: ['--cache', '/tmp/eslint-cache'] } } } },
+            { ...v2, sensors: { lint: { ...sensor, command: { ...sensor.command, args: ['--cache', 'C:\\build-cache'] } } } },
+            { ...v2, sensors: { lint: { ...sensor, command: { ...sensor.command, args: ['--cache', '\\\\server\\share\\eslint-cache'] } } } },
+            { ...v2, sensors: { lint: { ...sensor, command: { ...sensor.command, args: ['--cache', '/home/alice/.awm/registries/baseline/cache'] } } } },
+            { ...v2, sensors: { lint: { ...sensor, command: { ...sensor.command, args: ['--cache', '/home/alice/.awm/registries/baseline/cache'] } } } },
+            { ...v2, sensors: { lint: { ...sensor, initializedCompatibility: { ...sensor.initializedCompatibility, reason: 'source /home/alice/.awm/registries/baseline' } } } },
+            { ...v2, sensors: { lint: { ...sensor, initializedCompatibility: { ...sensor.initializedCompatibility, evidence: [{ kind: 'file', status: 'pass', path: '/home/alice/report.json' }] } } } },
+        ])
+            expect(() => (0, migrate_1.planV2Migration)({ manifest, source: resolvedSource() })).toThrow(/physical path|contained relative asset/);
+    });
+    it('rejects absolute paths embedded in flag-value strings while retaining relative flag values', () => {
+        const relative = {
+            ...v2,
+            sensors: { lint: { ...sensor, command: { ...sensor.command, args: ['--cache=cache/eslint', '--config=config/eslint.json', '--inputs=(reports/lint.json,cache/eslint)'] } } },
+        };
+        expect((0, migrate_1.planV2Migration)({ manifest: relative, source: resolvedSource() }).candidate.sensors.lint.command.args)
+            .toEqual(['--cache=cache/eslint', '--config=config/eslint.json', '--inputs=(reports/lint.json,cache/eslint)']);
+        for (const args of [
+            ['--cache=/tmp/x'],
+            ['--config=C:\\temp\\x'],
+            ['--config=C:temp\\x'],
+            ['--config=\\temp\\x'],
+            ['--output=//server/share'],
+            ['--cache="/tmp/x"'],
+            ["--cache='C:\\temp\\x'"],
+            ['--config="//server/share"'],
+            ['--cache:/tmp/x'],
+            ['--config:C:\\temp\\x'],
+            ['--cache:"/tmp/x"'],
+            ["--config:'C:\\temp\\x'"],
+            ['--cache;/tmp/x'],
+            ['--cache,/tmp/x'],
+            ['--config(C:\\\\temp\\\\x)'],
+            ['--output,\\\\\\\\server\\\\share'],
+            ['--config(//server/share)'],
+            ['--cache;"/tmp/x"'],
+            ["--config;'C:\\temp\\x'"],
+        ]) {
+            const manifest = { ...v2, sensors: { lint: { ...sensor, command: { ...sensor.command, args } } } };
+            expect(() => (0, migrate_1.planV2Migration)({ manifest, source: resolvedSource() })).toThrow('physical path');
+        }
+    });
+    it('retains an HTTPS URL command argument as portable sensor semantics', () => {
+        const manifest = {
+            ...v2,
+            sensors: {
+                lint: {
+                    ...sensor,
+                    command: { ...sensor.command, args: ['--rules-url=https://example.test/eslint/rules.json'] },
+                },
+            },
+        };
+        expect((0, migrate_1.planV2Migration)({ manifest, source: resolvedSource() }).candidate.sensors.lint.command.args)
+            .toEqual(['--rules-url=https://example.test/eslint/rules.json']);
+    });
+    test.each(['C:package', 'C:/package'])('rejects a Windows drive-qualified packageRoot: %s', packageRoot => {
+        expect(() => (0, migrate_1.planV2Migration)({ manifest: { ...v2, packageRoot }, source: resolvedSource() })).toThrow(/physical path|contained relative asset path/);
+    });
+    it('rejects a physical path under the resolved source root even when the v2 root differs', () => {
+        const resolvedRegistry = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-migrate-resolved-'));
+        const source = resolvedSource('js-ts', 'baseline', resolvedRegistry);
+        const manifest = {
+            ...v2,
+            registryRoot: path_1.default.join(path_1.default.sep, 'opt', 'legacy-registry'),
+            sensors: { lint: { ...sensor, command: { ...sensor.command, args: ['--cache', path_1.default.join(resolvedRegistry, 'cache')] } } },
+        };
+        try {
+            expect(() => (0, migrate_1.planV2Migration)({ manifest, source })).toThrow('physical path');
+        }
+        finally {
+            fs_1.default.rmSync(resolvedRegistry, { recursive: true, force: true });
+        }
+    });
+    it('validates before atomic replacement and leaves the v2 original intact on write failure', () => {
+        const project = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-migrate-'));
+        const manifestPath = canonicalManifestPath(project);
+        const original = JSON.stringify(v2, null, 2) + '\n';
+        try {
+            fs_1.default.writeFileSync(manifestPath, original);
+            const plan = (0, migrate_1.planV2Migration)({ manifest: v2, source: resolvedSource() });
+            (0, safe_file_1.setSecureFsForTests)({
+                ...native_bridge_1.secureFs,
+                writeProjectTransaction: jest.fn(() => { throw new Error('injected write failure'); }),
+            });
+            expect(() => (0, migrate_1.replaceV2ManifestWithV3)(manifestPath, plan.candidate, resolvedSource())).toThrow('injected write failure');
+            expect(fs_1.default.readFileSync(manifestPath, 'utf8')).toBe(original);
+        }
+        finally {
+            (0, safe_file_1.setSecureFsForTests)(undefined);
+            fs_1.default.rmSync(project, { recursive: true, force: true });
+        }
+    });
+    it('rejects a physical sensor path before replacement and preserves the v2 original', () => {
+        const project = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-migrate-'));
+        const manifestPath = canonicalManifestPath(project);
+        const original = JSON.stringify(v2, null, 2) + '\n';
+        try {
+            fs_1.default.writeFileSync(manifestPath, original);
+            const candidate = (0, migrate_1.planV2Migration)({ manifest: v2, source: resolvedSource() }).candidate;
+            const unsafe = { ...candidate, sensors: { lint: { ...candidate.sensors.lint, command: { ...candidate.sensors.lint.command, args: [path_1.default.join(path_1.default.parse(process.cwd()).root, 'home', 'alice', '.awm', 'cache')] } } } };
+            expect(() => (0, migrate_1.replaceV2ManifestWithV3)(manifestPath, unsafe, resolvedSource())).toThrow('physical path');
+            expect(fs_1.default.readFileSync(manifestPath, 'utf8')).toBe(original);
+        }
+        finally {
+            fs_1.default.rmSync(project, { recursive: true, force: true });
+        }
+    });
+    it('requires replacement to use the supplied logical source rather than candidate provenance', () => {
+        const project = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-migrate-'));
+        const manifestPath = canonicalManifestPath(project);
+        const original = JSON.stringify({ ...v2, registryRoot: path_1.default.join(path_1.default.parse(process.cwd()).root, 'opt', 'legacy-bound-registry') }, null, 2) + '\n';
+        try {
+            fs_1.default.writeFileSync(manifestPath, original);
+            const source = resolvedSource();
+            const candidate = (0, migrate_1.planV2Migration)({ manifest: JSON.parse(original), source }).candidate;
+            expect(() => (0, migrate_1.replaceV2ManifestWithV3)(manifestPath, { ...candidate, source: { registry: 'other' } }, source)).toThrow('semantic mismatch');
+            expect(() => (0, migrate_1.replaceV2ManifestWithV3)(manifestPath, candidate, resolvedSource('js-ts', 'rebound'))).toThrow('semantic mismatch');
+            expect(() => (0, migrate_1.replaceV2ManifestWithV3)(manifestPath, candidate, sourceWithPack(pack => { (pack.sensors.lint.variants[0]).id = 'eslint-8'; }))).toThrow('compatible');
+            expect(fs_1.default.readFileSync(manifestPath, 'utf8')).toBe(original);
+        }
+        finally {
+            fs_1.default.rmSync(project, { recursive: true, force: true });
+        }
+    });
+    it('rejects an arbitrary absolute sensors.json outside the canonical project manifest location', () => {
+        const project = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-migrate-arbitrary-'));
+        const manifestPath = path_1.default.join(project, 'sensors.json');
+        const original = JSON.stringify(v2, null, 2) + '\n';
+        try {
+            fs_1.default.writeFileSync(manifestPath, original);
+            const candidate = (0, migrate_1.planV2Migration)({ manifest: v2, source: resolvedSource() }).candidate;
+            expect(() => (0, migrate_1.replaceV2ManifestWithV3)(manifestPath, candidate, resolvedSource()))
+                .toThrow(/canonical project manifest|\.awm\/sensors\.json/i);
+            expect(fs_1.default.readFileSync(manifestPath, 'utf8')).toBe(original);
+            expect(fs_1.default.existsSync(path_1.default.join(project, '.awm'))).toBe(false);
+        }
+        finally {
+            fs_1.default.rmSync(project, { recursive: true, force: true });
+        }
+    });
+    it('preserves a pre-existing legacy-named temporary file while staging privately', () => {
+        const project = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-migrate-'));
+        const manifestPath = canonicalManifestPath(project);
+        const now = jest.spyOn(Date, 'now').mockReturnValue(12345);
+        const temporary = path_1.default.join(project, `.sensors.json.${process.pid}.12345.tmp`);
+        try {
+            fs_1.default.writeFileSync(manifestPath, JSON.stringify(v2));
+            fs_1.default.writeFileSync(temporary, 'not ours');
+            const candidate = (0, migrate_1.planV2Migration)({ manifest: v2, source: resolvedSource() }).candidate;
+            expect(() => (0, migrate_1.replaceV2ManifestWithV3)(manifestPath, candidate, resolvedSource())).not.toThrow();
+            expect(fs_1.default.readFileSync(temporary, 'utf8')).toBe('not ours');
+        }
+        finally {
+            now.mockRestore();
+            fs_1.default.rmSync(project, { recursive: true, force: true });
+        }
+    });
+    it.skip('fails closed before staging when descriptor-bound publication is unavailable', () => {
+        const project = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-migrate-portable-parent-'));
+        const movedProject = `${project}-original`;
+        const outside = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-migrate-portable-outside-'));
+        const manifestPath = canonicalManifestPath(project);
+        const mkdtempSync = fs_1.default.mkdtempSync.bind(fs_1.default);
+        const mkdtemp = jest.spyOn(fs_1.default, 'mkdtempSync');
+        let parentSwapAttempted = false;
+        try {
+            fs_1.default.writeFileSync(manifestPath, JSON.stringify(v2));
+            const candidate = (0, migrate_1.planV2Migration)({ manifest: v2, source: resolvedSource() }).candidate;
+            mkdtemp.mockImplementation(((prefix, options) => {
+                if (prefix.startsWith(path_1.default.join(project, '.sensors.json.migrate-'))) {
+                    parentSwapAttempted = true;
+                    fs_1.default.renameSync(project, movedProject);
+                    fs_1.default.symlinkSync(outside, project, 'dir');
+                }
+                return mkdtempSync(prefix, options);
+            }));
+            expect(() => replaceWithoutNoFollow(manifestPath, candidate, resolvedSource())).toThrow(/descriptor|safe|migration/i);
+            expect(parentSwapAttempted).toBe(false);
+            expect(fs_1.default.readdirSync(outside)).toEqual([]);
+            expect(fs_1.default.readFileSync(manifestPath, 'utf8')).toBe(JSON.stringify(v2));
+        }
+        finally {
+            mkdtemp.mockRestore();
+            fs_1.default.rmSync(project, { recursive: true, force: true });
+            fs_1.default.rmSync(movedProject, { recursive: true, force: true });
+            fs_1.default.rmSync(outside, { recursive: true, force: true });
+        }
+    });
+    it.skip('keeps descriptor-bound Linux publication inside the original parent after a swap', () => {
+        const project = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-migrate-parent-swap-'));
+        const movedProject = `${project}-original`;
+        const outside = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-migrate-parent-outside-'));
+        const manifestPath = canonicalManifestPath(project);
+        const original = JSON.stringify(v2, null, 2) + '\n';
+        const mkdtempSync = fs_1.default.mkdtempSync.bind(fs_1.default);
+        const mkdtemp = jest.spyOn(fs_1.default, 'mkdtempSync');
+        const writeFileSync = fs_1.default.writeFileSync.bind(fs_1.default);
+        const write = jest.spyOn(fs_1.default, 'writeFileSync');
+        let swapped = false;
+        const redirectedWrites = [];
+        try {
+            fs_1.default.writeFileSync(manifestPath, original);
+            fs_1.default.writeFileSync(path_1.default.join(outside, 'sensors.json'), original);
+            const candidate = (0, migrate_1.planV2Migration)({ manifest: v2, source: resolvedSource() }).candidate;
+            mkdtemp.mockImplementation(((prefix, options) => {
+                if (!swapped && path_1.default.basename(prefix).startsWith('.sensors.json.migrate-')) {
+                    swapped = true;
+                    fs_1.default.renameSync(project, movedProject);
+                    fs_1.default.symlinkSync(outside, project, 'dir');
+                }
+                return mkdtempSync(prefix, options);
+            }));
+            write.mockImplementation(((file, data, options) => {
+                if (typeof file === 'string' && fs_1.default.realpathSync(path_1.default.dirname(file)).startsWith(outside + path_1.default.sep))
+                    redirectedWrites.push(file);
+                return writeFileSync(file, data, options);
+            }));
+            expect(() => (0, migrate_1.replaceV2ManifestWithV3)(manifestPath, candidate, resolvedSource())).not.toThrow();
+            expect(swapped).toBe(true);
+            expect(redirectedWrites).toEqual([]);
+            expect(fs_1.default.readFileSync(path_1.default.join(outside, 'sensors.json'), 'utf8')).toBe(original);
+            expect(JSON.parse(fs_1.default.readFileSync(path_1.default.join(movedProject, 'sensors.json'), 'utf8'))).toMatchObject({ schemaVersion: 3, source: { registry: 'baseline' } });
+        }
+        finally {
+            mkdtemp.mockRestore();
+            write.mockRestore();
+            fs_1.default.rmSync(project, { recursive: true, force: true });
+            fs_1.default.rmSync(movedProject, { recursive: true, force: true });
+            fs_1.default.rmSync(outside, { recursive: true, force: true });
+        }
+    });
+    it('refuses to replace a manifest whose bytes change after the original is read', () => {
+        const project = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-migrate-'));
+        const manifestPath = canonicalManifestPath(project);
+        const original = JSON.stringify(v2, null, 2) + '\n';
+        const replacement = JSON.stringify({ schemaVersion: 2, pack: 'js-ts', sensors: {} }) + '\n';
+        const originalLstat = fs_1.default.lstatSync.bind(fs_1.default);
+        const lstat = jest.spyOn(fs_1.default, 'lstatSync');
+        let inspections = 0;
+        try {
+            fs_1.default.writeFileSync(manifestPath, original);
+            const candidate = (0, migrate_1.planV2Migration)({ manifest: v2, source: resolvedSource() }).candidate;
+            lstat.mockImplementation(((candidatePath, options) => {
+                if (path_1.default.basename(String(candidatePath)) === 'sensors.json' && ++inspections === 2)
+                    fs_1.default.writeFileSync(manifestPath, replacement);
+                return originalLstat(candidatePath, options);
+            }));
+            expect(() => (0, migrate_1.replaceV2ManifestWithV3)(manifestPath, candidate, resolvedSource())).toThrow(/changed|identity/i);
+            expect(fs_1.default.readFileSync(manifestPath, 'utf8')).toBe(replacement);
+        }
+        finally {
+            lstat.mockRestore();
+            fs_1.default.rmSync(project, { recursive: true, force: true });
+        }
+    });
+    it('refuses a same-byte manifest substitution after the native read and preserves the swapped target', () => {
+        const project = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-migrate-same-byte-swap-'));
+        const manifestPath = canonicalManifestPath(project);
+        const parkedPath = path_1.default.join(project, 'original-sensors.json');
+        const original = JSON.stringify(v2, null, 2) + '\n';
+        const bridge = {
+            withProjectLease: jest.fn((_projectRoot, operation) => operation()),
+            readRegularFile: jest.fn((...args) => native_bridge_1.secureFs.readRegularFile(...args)),
+            writeProjectTransaction: jest.fn((...args) => {
+                fs_1.default.renameSync(manifestPath, parkedPath);
+                fs_1.default.writeFileSync(manifestPath, original);
+                return native_bridge_1.secureFs.writeProjectTransaction(...args);
+            }),
+        };
+        try {
+            fs_1.default.writeFileSync(manifestPath, original);
+            (0, safe_file_1.setSecureFsForTests)(bridge);
+            const candidate = (0, migrate_1.planV2Migration)({ manifest: v2, source: resolvedSource() }).candidate;
+            expect(() => (0, migrate_1.replaceV2ManifestWithV3)(manifestPath, candidate, resolvedSource())).toThrow(/changed|identity|secure-fs/i);
+            expect(fs_1.default.readFileSync(manifestPath, 'utf8')).toBe(original);
+            expect(fs_1.default.readFileSync(parkedPath, 'utf8')).toBe(original);
+            expect(bridge.writeProjectTransaction).toHaveBeenCalledTimes(1);
+        }
+        finally {
+            (0, safe_file_1.setSecureFsForTests)(undefined);
+            fs_1.default.rmSync(project, { recursive: true, force: true });
+        }
+    });
+    it.skip('never overwrites a manifest installed during final no-clobber publication', () => {
+        const project = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-migrate-'));
+        const manifestPath = canonicalManifestPath(project);
+        const original = JSON.stringify(v2, null, 2) + '\n';
+        const replacement = JSON.stringify({ schemaVersion: 2, pack: 'js-ts', sensors: {} }) + '\n';
+        const originalLink = fs_1.default.linkSync.bind(fs_1.default);
+        const link = jest.spyOn(fs_1.default, 'linkSync');
+        let published = false;
+        try {
+            fs_1.default.writeFileSync(manifestPath, original);
+            const candidate = (0, migrate_1.planV2Migration)({ manifest: v2, source: resolvedSource() }).candidate;
+            link.mockImplementation(((existingPath, newPath) => {
+                if (path_1.default.basename(String(newPath)) === 'sensors.json' && !published) {
+                    published = true;
+                    fs_1.default.writeFileSync(manifestPath, replacement, { flag: 'wx' });
+                }
+                return originalLink(existingPath, newPath);
+            }));
+            expect(() => (0, migrate_1.replaceV2ManifestWithV3)(manifestPath, candidate, resolvedSource())).toThrow();
+            expect(fs_1.default.readFileSync(manifestPath, 'utf8')).toBe(replacement);
+        }
+        finally {
+            link.mockRestore();
+            fs_1.default.rmSync(project, { recursive: true, force: true });
+        }
+    });
+});

package/dist/tests/core/context/orchestrator.test.js

@@ -255,6 +255,8 @@ describe('InjectionOrchestrator (declared orchestrators from an installed regist
         const registryRoot = (0, registries_1.registryContentRoot)('declaring');
         fs_1.default.mkdirSync(path_1.default.join(registryRoot, 'skills/using-awm'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'skills/using-awm/SKILL.md'), '---\nversion: "1.0.0"\n---\nBODY');
+        fs_1.default.mkdirSync(path_1.default.join(registryRoot, 'skills/mi-proceso'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'skills/mi-proceso/SKILL.md'), '---\nname: mi-proceso\n---\n');
         fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'awm-registry.json'), JSON.stringify({
             orchestrator: { name: 'mi-proceso', appliesWhen: 'al arrancar', terminatesTo: 'development-process' },
         }));

package/dist/tests/core/discovery-multiroot.test.js

@@ -60,4 +60,9 @@ describe('discovery multi-root', () => {
         expect(discoverSkills([rootA, rootB]).length).toBe(1);
         expect(discoverAgents([rootA, rootB])).toEqual([]);
     });
+    it('rejects a real directory named SKILL.md as a nonregular artifact without blocking', () => {
+        fs_1.default.mkdirSync(path_1.default.join(rootA, 'skills', 'unsafe', 'SKILL.md'), { recursive: true });
+        const { discoverSkills } = require('../../src/core/discovery');
+        expect(() => discoverSkills([rootA])).toThrow(/SKILL\.md.*regular file/);
+    });
 });

package/dist/tests/core/discovery-parent-race.test.js

@@ -0,0 +1,95 @@
+"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 discovery_1 = require("../../src/core/discovery");
+describe('real skill parent races', () => {
+    let fixture;
+    let root;
+    let skillDir;
+    let skillFile;
+    beforeEach(() => {
+        fixture = fs_1.default.mkdtempSync(path_1.default.join(fs_1.default.realpathSync(os_1.default.tmpdir()), 'skill-parent-race-'));
+        root = path_1.default.join(fixture, 'registry');
+        skillDir = path_1.default.join(root, 'skills', 'safe');
+        skillFile = path_1.default.join(skillDir, 'SKILL.md');
+        fs_1.default.mkdirSync(skillDir, { recursive: true });
+        fs_1.default.writeFileSync(skillFile, '---\ndescription: Inside skill\n---\n');
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+        fs_1.default.rmSync(fixture, { recursive: true, force: true });
+    });
+    it('reads an unchanged skill through its descriptor', () => {
+        expect((0, discovery_1.discoverSkills)([root])).toEqual([
+            { name: 'safe', path: skillDir, description: 'Inside skill' },
+        ]);
+    });
+    describe.each(['root', 'skills', 'skill directory'])('%s substitution', (component) => {
+        it.each(['symlink', 'directory'])('rejects a %s swapped after parent inspection before reading outside bytes', (replacement) => {
+            const parent = component === 'root' ? root : component === 'skills' ? path_1.default.dirname(skillDir) : skillDir;
+            const outside = path_1.default.join(fixture, 'outside');
+            const outsideFile = path_1.default.join(outside, path_1.default.relative(parent, skillFile));
+            fs_1.default.mkdirSync(path_1.default.dirname(outsideFile), { recursive: true });
+            fs_1.default.writeFileSync(outsideFile, '---\ndescription: Outside skill\n---\n');
+            const lstat = fs_1.default.lstatSync;
+            let swapped = false;
+            // Keep real lstat results; only schedule a real rename/symlink at the race boundary.
+            jest.spyOn(fs_1.default, 'lstatSync').mockImplementation(((...args) => {
+                const stat = lstat(...args);
+                if (args[0] === parent && !swapped) {
+                    swapped = true;
+                    fs_1.default.renameSync(parent, path_1.default.join(fixture, 'original-parent'));
+                    if (replacement === 'symlink')
+                        fs_1.default.symlinkSync(outside, parent, 'junction');
+                    else
+                        fs_1.default.renameSync(outside, parent);
+                }
+                return stat;
+            }));
+            const read = jest.spyOn(fs_1.default, 'readFileSync');
+            expect(() => (0, discovery_1.discoverSkills)([root])).toThrow(/symbolic link|directory identity/i);
+            expect(swapped).toBe(true);
+            expect(read.mock.calls.filter(([file]) => typeof file === 'number'
+                || String(file).startsWith(fixture + path_1.default.sep))).toEqual([]);
+        });
+    });
+    it('rejects an observable parent symlink introduced after open and closes the descriptor without reading', () => {
+        const open = fs_1.default.openSync;
+        let descriptor;
+        jest.spyOn(fs_1.default, 'openSync').mockImplementation((...args) => {
+            descriptor = open(...args);
+            const moved = path_1.default.join(fixture, 'original-parent');
+            fs_1.default.renameSync(skillDir, moved);
+            fs_1.default.symlinkSync(moved, skillDir, 'junction');
+            return descriptor;
+        });
+        const read = jest.spyOn(fs_1.default, 'readFileSync');
+        const close = jest.spyOn(fs_1.default, 'closeSync');
+        let thrown;
+        try {
+            (0, discovery_1.discoverSkills)([root]);
+        }
+        catch (error) {
+            thrown = error;
+        }
+        if (process.platform === 'win32') {
+            // Windows holds the opened file's parent directory handle, so the
+            // replacement itself is denied before a symlink can be introduced.
+            // This is the same security guarantee: outside bytes cannot be read.
+            expect(thrown).toBeInstanceOf(Error);
+            expect(thrown.message).toMatch(/EPERM.*rename|rename.*EPERM/i);
+        }
+        else {
+            expect(thrown).toBeInstanceOf(Error);
+            expect(thrown.message).toMatch(/symbolic link/i);
+            expect(close).toHaveBeenCalledWith(descriptor);
+        }
+        expect(read.mock.calls.filter(([file]) => typeof file === 'number'
+            || String(file).startsWith(fixture + path_1.default.sep))).toEqual([]);
+    });
+});