agentic-workflow-manager 6.5.2 → 8.1.0

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

@@ -12,8 +12,10 @@ function mkTmp() {
 }
 // Define stable mock before jest.mock hoisting
 const mockRunCommand = jest.fn();
+const mockRunStructuredCommand = jest.fn();
 jest.mock('../../../src/commands/sensors/exec', () => ({
     runCommand: (...args) => mockRunCommand(...args),
+    runStructuredCommand: (...args) => mockRunStructuredCommand(...args),
 }));
 const { ok, exited, timedOut } = require('./exec-fixtures');
 const MANIFEST = {
@@ -35,6 +37,7 @@ describe('runSensors', () => {
         fs_1.default.mkdirSync(path.join(tmpDir, '.awm'), { recursive: true });
         fs_1.default.writeFileSync(path.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify(MANIFEST));
         mockRunCommand.mockReset();
+        mockRunStructuredCommand.mockReset();
     });
     afterEach(() => { fs_1.default.rmSync(tmpDir, { recursive: true }); });
     const load = () => require('../../../src/commands/sensors/run');
@@ -56,7 +59,7 @@ describe('runSensors', () => {
         const result = await runSensors({ fast: true, cwd: tmpDir });
         expect(mockRunCommand).toHaveBeenCalledTimes(2); // typecheck + lint (security disabled, mutation disabled)
         expect(result.sensors.some((s) => s.name === 'security')).toBe(false);
-        expect(result.overall).toBe('pass');
+        expect(result.overall).toBe('not_certified');
     });
     it('returns fail when a fast sensor has errors', async () => {
         mockRunCommand
@@ -175,7 +178,7 @@ describe('runSensors', () => {
         const tc = second.sensors.find((s) => s.name === 'typecheck');
         expect(tc.status).toBe('pass');
         expect(tc.baselineCount).toBe(1);
-        expect(second.overall).toBe('pass');
+        expect(second.overall).toBe('not_certified');
     });
     it('baseline lets NEW findings through (still fails)', async () => {
         const { runSensors } = load();
@@ -200,6 +203,66 @@ describe('runSensors', () => {
         expect(result.overall).toBe('fail');
     });
 });
+describe('runSensors v2 lifecycle contract', () => {
+    let project;
+    let home;
+    const version = '10.0.0';
+    beforeEach(() => {
+        jest.resetModules();
+        project = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-v2-run-project-'));
+        home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-v2-run-home-'));
+        process.env.AWM_HOME = home;
+        const registry = path_1.default.join(home, 'registries', 'baseline', 'sensor-packs', 'js-ts');
+        fs_1.default.mkdirSync(registry, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registry, 'eslint.config.awm.mjs'), 'export default []');
+        fs_1.default.writeFileSync(path_1.default.join(home, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: 'https://example.test/baseline.git' }]));
+        fs_1.default.writeFileSync(path_1.default.join(project, 'package.json'), JSON.stringify({ scripts: { lint: 'eslint .' }, devDependencies: { eslint: '^10.0.0' } }));
+        fs_1.default.mkdirSync(path_1.default.join(project, 'node_modules', 'eslint'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(project, 'node_modules', 'eslint', 'package.json'), JSON.stringify({ version }));
+        fs_1.default.writeFileSync(path_1.default.join(registry, 'pack.json'), JSON.stringify({
+            schemaVersion: 2, name: 'js-ts', description: 'fixture', detects: ['package.json'],
+            coverage: { schemaVersion: 1, classes: { lint: { description: 'lint', detectors: [{ sensor: 'lint' }], remedy: { summary: 'fix', command: 'awm sensors init' } } } },
+            sensors: { lint: { fast: true, applicability: { allFiles: ['package.json'] }, variants: [{
+                            id: 'eslint-10', priority: 1, certifiedRange: '>=10 <11',
+                            requirements: { tool: 'eslint', toolRange: '>=10 <11', runtime: 'node', runtimeRange: '>=0' },
+                            assets: ['eslint.config.awm.mjs'], formatter: 'generic', probe: { kind: 'package-script-present' },
+                            command: { executable: 'live-eslint', resolution: 'node-modules-bin', args: ['.'] },
+                        }] } },
+        }));
+        fs_1.default.mkdirSync(path_1.default.join(project, '.awm'));
+        fs_1.default.writeFileSync(path_1.default.join(project, '.awm', 'sensors.json'), JSON.stringify({
+            schemaVersion: 2, pack: 'js-ts', registryRoot: path_1.default.join(home, 'registries', 'baseline'), sensors: { lint: {
+                    enabled: true, fast: true, variantId: 'eslint-10',
+                    command: { executable: 'stale-eslint', resolution: 'node-modules-bin', args: ['.'] }, assets: ['eslint.config.awm.mjs'],
+                    initializedCompatibility: { state: 'certified', reason: 'range-and-probe', variantId: 'eslint-10', toolVersion: version, runtimeVersion: process.versions.node, certifiedRange: '>=10 <11', evidence: [] },
+                } },
+        }));
+        mockRunStructuredCommand.mockReset();
+        mockRunStructuredCommand.mockResolvedValue(ok());
+    });
+    afterEach(() => {
+        delete process.env.AWM_HOME;
+        fs_1.default.rmSync(project, { recursive: true, force: true });
+        fs_1.default.rmSync(home, { recursive: true, force: true });
+    });
+    it('runs the re-resolved command for an unchanged variant id, never the stale manifest command', async () => {
+        const { resolveLiveCompatibility } = require('../../../src/commands/sensors/compatibility/live');
+        await expect(resolveLiveCompatibility(project, 'js-ts', path_1.default.join(home, 'registries', 'baseline'))).resolves.toBeDefined();
+        const { runSensors } = require('../../../src/commands/sensors/run');
+        const result = await runSensors({ cwd: project, fast: true });
+        expect(result).toEqual(expect.objectContaining({ overall: 'pass' }));
+        expect(mockRunStructuredCommand).toHaveBeenCalledWith(expect.objectContaining({ executable: 'live-eslint' }), expect.any(Object));
+    });
+    it('honors disabled v2 sensors before dispatching them', async () => {
+        const manifest = JSON.parse(fs_1.default.readFileSync(path_1.default.join(project, '.awm', 'sensors.json'), 'utf8'));
+        manifest.sensors.lint.enabled = false;
+        fs_1.default.writeFileSync(path_1.default.join(project, '.awm', 'sensors.json'), JSON.stringify(manifest));
+        const { runSensors } = require('../../../src/commands/sensors/run');
+        const result = await runSensors({ cwd: project, fast: true });
+        expect(result.sensors).toEqual([expect.objectContaining({ status: 'skipped', skipReason: 'disabled' })]);
+        expect(mockRunStructuredCommand).not.toHaveBeenCalled();
+    });
+});
 describe('runSensors — missing tool is a fail, not a skip', () => {
     let root;
     afterEach(() => {
@@ -276,7 +339,7 @@ describe('runSensors — not_certified + auto-discovery', () => {
         const nested = path_1.default.join(tmpDir, 'a', 'b');
         fs_1.default.mkdirSync(nested, { recursive: true });
         const out = await (0, run_1.runSensors)({ cwd: nested });
-        expect(out.overall).toBe('pass');
+        expect(out.overall).toBe('not_certified');
         expect(out.sensors.length).toBe(1);
     });
 });

package/dist/tests/commands/sensors/status-windows.test.js

@@ -48,25 +48,25 @@ describe('computeSensorStatus — Windows PATH resolution', () => {
             sensors: { security: { cmd: 'semgrep --json .', fast: false } }
         }));
     }
-    it('resuelve un binario instalado en win32 via PATHEXT (incluido un shim .cmd)', () => {
+    it('resuelve un binario instalado en win32 via PATHEXT (incluido un shim .cmd)', async () => {
         writeManifest();
         // En win32 el usuario escribe `semgrep` y en disco existe `semgrep.cmd`.
         fs_1.default.writeFileSync(path_1.default.join(pathDir, 'semgrep.cmd'), '@echo off\r\n');
-        const result = (0, status_1.computeSensorStatus)(tmpDir);
-        expect(result.overall).toBe('HEALTHY');
+        const result = await (0, status_1.computeSensorStatus)(tmpDir);
+        expect(result.overall).toBe('DEGRADED');
         expect(result.checks.security.ok).toBe(true);
     });
-    it('reporta ok:false en win32 cuando el binario no esta en PATH', () => {
+    it('reporta ok:false en win32 cuando el binario no esta en PATH', async () => {
         writeManifest();
         // PATH aislado y vacio.
-        const result = (0, status_1.computeSensorStatus)(tmpDir);
+        const result = await (0, status_1.computeSensorStatus)(tmpDir);
         expect(result.overall).toBe('DEGRADED');
         expect(result.checks.security.ok).toBe(false);
     });
-    it('en win32 no exige bit de ejecucion — un .exe sin permisos POSIX igual resuelve', () => {
+    it('en win32 no exige bit de ejecucion — un .exe sin permisos POSIX igual resuelve', async () => {
         writeManifest();
         fs_1.default.writeFileSync(path_1.default.join(pathDir, 'semgrep.exe'), '');
         fs_1.default.chmodSync(path_1.default.join(pathDir, 'semgrep.exe'), 0o644);
-        expect((0, status_1.computeSensorStatus)(tmpDir).checks.security.ok).toBe(true);
+        expect((await (0, status_1.computeSensorStatus)(tmpDir)).checks.security.ok).toBe(true);
     });
 });

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

@@ -7,6 +7,8 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const status_1 = require("../../../src/commands/sensors/status");
+const checks_1 = require("../../../src/commands/preflight/checks");
+const run_1 = require("../../../src/commands/sensors/run");
 // `resolveOnPath` resuelve PATH en proceso (ya no invoca un shell — ver
 // core/paths.ts). Por eso estos tests controlan un PATH aislado en vez de
 // mockear `execSync`: ademas de reflejar el mecanismo real, los vuelve
@@ -36,8 +38,8 @@ describe('computeSensorStatus', () => {
         fs_1.default.writeFileSync(p, '#!/bin/sh\nexit 0\n');
         fs_1.default.chmodSync(p, 0o755);
     }
-    it('returns NOT_CONFIGURED when .awm/sensors.json missing', () => {
-        const result = (0, status_1.computeSensorStatus)(tmpDir);
+    it('returns NOT_CONFIGURED when .awm/sensors.json missing', async () => {
+        const result = await (0, status_1.computeSensorStatus)(tmpDir);
         expect(result.overall).toBe('NOT_CONFIGURED');
         expect(result.pack).toBeNull();
     });
@@ -47,42 +49,42 @@ describe('computeSensorStatus', () => {
         fs_1.default.mkdirSync(binDir, { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(binDir, tool), '');
     }
-    it('returns HEALTHY when an npx tool is installed locally', () => {
+    it('keeps an operational legacy manifest DEGRADED even when its npx tool is installed locally', async () => {
         installLocalBin('tsc');
         fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
             pack: 'js-ts',
             sensors: { typecheck: { cmd: 'npx tsc --noEmit', fast: true } }
         }));
-        const result = (0, status_1.computeSensorStatus)(tmpDir);
-        expect(result.overall).toBe('HEALTHY');
+        const result = await (0, status_1.computeSensorStatus)(tmpDir);
+        expect(result.overall).toBe('DEGRADED');
         expect(result.pack).toBe('js-ts');
         expect(result.checks.typecheck.ok).toBe(true);
     });
-    it('marks an npx sensor DEGRADED when the tool is NOT installed locally (npx would fetch a remote package)', () => {
+    it('marks an npx sensor DEGRADED when the tool is NOT installed locally (npx would fetch a remote package)', async () => {
         // No node_modules/.bin/depcruise → status must NOT report ✔ just because npx exists.
         fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
             pack: 'js-ts',
             sensors: { depcheck: { cmd: 'npx depcruise --config .dep-cruiser.awm.js app', fast: false } }
         }));
-        const result = (0, status_1.computeSensorStatus)(tmpDir);
+        const result = await (0, status_1.computeSensorStatus)(tmpDir);
         expect(result.overall).toBe('DEGRADED');
         expect(result.checks.depcheck.ok).toBe(false);
         expect(result.checks.depcheck.detail).toMatch(/not installed locally/i);
     });
-    it('marks a sensor DEGRADED when its --config file is missing', () => {
+    it('marks a sensor DEGRADED when its --config file is missing', async () => {
         installLocalBin('eslint');
         fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
             pack: 'js-ts',
             sensors: { lint: { cmd: 'npx eslint . --config eslint.config.awm.mjs --format json', fast: true } }
         }));
-        const result = (0, status_1.computeSensorStatus)(tmpDir);
+        const result = await (0, status_1.computeSensorStatus)(tmpDir);
         expect(result.checks.lint.ok).toBe(false);
         expect(result.checks.lint.detail).toMatch(/missing config/i);
     });
-    it('is HEALTHY when the npx tool is installed and the --config file exists', () => {
+    it('is HEALTHY when the npx tool is installed and the --config file exists', async () => {
         installLocalBin('eslint');
         fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'eslint.config.awm.mjs'), 'export default []');
         fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
@@ -90,17 +92,17 @@ describe('computeSensorStatus', () => {
             pack: 'js-ts',
             sensors: { lint: { cmd: 'npx eslint . --config eslint.config.awm.mjs --format json', fast: true } }
         }));
-        const result = (0, status_1.computeSensorStatus)(tmpDir);
+        const result = await (0, status_1.computeSensorStatus)(tmpDir);
         expect(result.checks.lint.ok).toBe(true);
     });
-    it('returns DEGRADED when a binary is missing', () => {
+    it('returns DEGRADED when a binary is missing', async () => {
         fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
             pack: 'js-ts',
             sensors: { security: { cmd: 'semgrep --json .', fast: false } }
         }));
         // PATH aislado y vacio => semgrep no resuelve.
-        const result = (0, status_1.computeSensorStatus)(tmpDir);
+        const result = await (0, status_1.computeSensorStatus)(tmpDir);
         expect(result.overall).toBe('DEGRADED');
         expect(result.checks.security.ok).toBe(false);
     });
@@ -112,19 +114,19 @@ describe('computeSensorStatus', () => {
         afterEach(() => {
             Object.defineProperty(process, 'platform', { value: originalPlatform });
         });
-        it('resuelve un binario instalado recorriendo PATH, sin invocar un shell', () => {
+        it('resuelve un binario instalado recorriendo PATH, sin invocar un shell', async () => {
             fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
             fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
                 pack: 'js-ts',
                 sensors: { security: { cmd: 'semgrep --json .', fast: false } }
             }));
             installOnPath('semgrep');
-            const result = (0, status_1.computeSensorStatus)(tmpDir);
-            expect(result.overall).toBe('HEALTHY');
+            const result = await (0, status_1.computeSensorStatus)(tmpDir);
+            expect(result.overall).toBe('DEGRADED');
             expect(result.checks.security.ok).toBe(true);
         });
     });
-    it('is DEGRADED (never HEALTHY) when the manifest has zero sensor entries', () => {
+    it('is DEGRADED (never HEALTHY) when the manifest has zero sensor entries', async () => {
         // `Object.values({}).every(...)` is vacuously true — guard against reading an
         // empty manifest (the honest floor when the registry had no pack.json for the
         // detected stack) as a clean run that found nothing wrong.
@@ -133,11 +135,11 @@ describe('computeSensorStatus', () => {
             pack: 'python',
             sensors: {},
         }));
-        const result = (0, status_1.computeSensorStatus)(tmpDir);
+        const result = await (0, status_1.computeSensorStatus)(tmpDir);
         expect(result.overall).toBe('DEGRADED');
         expect(result.pack).toBe('python');
     });
-    it('degrades gracefully (never throws) when sensors is null in a hand-edited manifest', () => {
+    it('degrades gracefully (never throws) when sensors is null in a hand-edited manifest', async () => {
         // Regression for Finding 3: `checkManifest` (preflight) already guards
         // `manifest.sensors ?? {}` — computeSensorStatus needs the same guard, or a
         // corrupted/hand-edited manifest with `"sensors": null` crashes
@@ -147,20 +149,69 @@ describe('computeSensorStatus', () => {
             pack: 'python',
             sensors: null,
         }));
-        expect(() => (0, status_1.computeSensorStatus)(tmpDir)).not.toThrow();
-        const result = (0, status_1.computeSensorStatus)(tmpDir);
+        const result = await (0, status_1.computeSensorStatus)(tmpDir);
         expect(result.overall).toBe('DEGRADED');
         expect(result.pack).toBe('python');
         expect(result.checks).toEqual({});
     });
-    it('marks disabled sensors as ok', () => {
+    it('marks disabled sensors as ok', async () => {
         fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
             pack: 'js-ts',
             sensors: { mutation: { enabled: false } }
         }));
-        const result = (0, status_1.computeSensorStatus)(tmpDir);
+        const result = await (0, status_1.computeSensorStatus)(tmpDir);
         expect(result.checks.mutation.ok).toBe(true);
         expect(result.checks.mutation.detail).toBe('disabled');
     });
+    it('does not trust the initialized v2 variant after local tool drift', async () => {
+        // The manifest records ESLint 9 at init time, but local evidence is now ESLint
+        // 10. Status must resolve the installed pack again, not certify the stale
+        // initializedCompatibility record.
+        const previousHome = process.env.AWM_HOME;
+        const home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-home-'));
+        try {
+            process.env.AWM_HOME = home;
+            const registry = path_1.default.join(home, 'registries', 'baseline');
+            fs_1.default.mkdirSync(path_1.default.join(registry, 'sensor-packs', 'js-ts'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(home, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: 'https://example.test/baseline.git' }]));
+            const variant = (id, range) => ({
+                id, priority: 10, certifiedRange: range,
+                requirements: { tool: 'eslint', toolRange: range, runtime: 'node', runtimeRange: '>=0.0.0' },
+                assets: ['eslint.config.awm.mjs'], formatter: 'eslint-llm', probe: { kind: 'config-present' },
+                command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+            });
+            fs_1.default.writeFileSync(path_1.default.join(registry, 'sensor-packs', 'js-ts', 'pack.json'), JSON.stringify({
+                schemaVersion: 2, name: 'js-ts', description: 'test', detects: ['package.json'], coverage: { schemaVersion: 1, classes: { lint: { description: 'lint', detectors: [{ sensor: 'lint' }], remedy: { summary: 'fix lint', command: 'awm sensors init --pack js-ts' } } } },
+                sensors: { lint: { applicability: { allFiles: ['package.json'] }, variants: [variant('eslint-9', '>=9.0.0 <10.0.0'), variant('eslint-10', '>=10.0.0 <11.0.0')] } },
+            }));
+            fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'package.json'), JSON.stringify({ devDependencies: { eslint: '^10.0.0' } }));
+            fs_1.default.mkdirSync(path_1.default.join(tmpDir, 'node_modules', 'eslint'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'node_modules', 'eslint', 'package.json'), JSON.stringify({ version: '10.0.0' }));
+            fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
+                schemaVersion: 2, pack: 'js-ts', sensors: { lint: {
+                        enabled: true, variantId: 'eslint-9', command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+                        initializedCompatibility: { state: 'certified', reason: 'range-and-probe', variantId: 'eslint-9', toolVersion: '9.0.0', runtimeVersion: process.versions.node, certifiedRange: '>=9.0.0 <10.0.0', evidence: [] },
+                    } },
+            }));
+            const result = await (0, status_1.computeSensorStatus)(tmpDir);
+            expect(result.overall).toBe('DEGRADED');
+            expect(result.checks.lint).toMatchObject({ ok: false, detail: expect.stringContaining('variant-drift') });
+            fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'AGENTS.md'), '# test\n');
+            const gate = await (0, checks_1.preflight)(tmpDir);
+            expect(gate.status).toBe('degraded');
+            expect(gate.checks.find(check => check.id === 'tools')).toMatchObject({ ok: false, detail: expect.stringContaining('variant-drift') });
+            const run = await (0, run_1.runSensors)({ cwd: tmpDir, all: true });
+            expect(run.overall).toBe('not_certified');
+            expect(run.sensors).toEqual([expect.objectContaining({ name: 'lint', status: 'inconclusive', skipReason: expect.stringContaining('variant-drift') })]);
+        }
+        finally {
+            if (previousHome === undefined)
+                delete process.env.AWM_HOME;
+            else
+                process.env.AWM_HOME = previousHome;
+            fs_1.default.rmSync(home, { recursive: true, force: true });
+        }
+    });
 });

package/dist/tests/commands/update.test.js

@@ -137,7 +137,7 @@ describe('awm update — honest outcome', () => {
         // `unusableSyncedRegistries` mira contenido EN DISCO: se siembra el content root
         // y el registries.json para que `docs` cuente como stale, no como roto.
         const registriesDir = path_1.default.join(process.env.AWM_HOME, 'registries');
-        fs_1.default.mkdirSync(path_1.default.join(registriesDir, 'docs'), { recursive: true });
+        fs_1.default.mkdirSync(path_1.default.join(registriesDir, 'docs', 'skills'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(process.env.AWM_HOME, 'registries.json'), JSON.stringify([{ name: 'docs', remote: 'https://example.test/docs.git' }]));
         const { runUpdateCore, updateOutro } = require('../../src/commands/update');
         const result = await runUpdateCore({}, deps({

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

@@ -37,6 +37,14 @@ describe('readCatalog', () => {
         expect(entries.map((e) => e.name).sort()).toEqual(['dev', 'frontend']);
         expect(entries.find((e) => e.name === 'dev').scope).toBe('baseline');
     });
+    it('rejects a catalog symlink instead of reading outside the registry', () => {
+        const content = makeFixture();
+        const outside = path_1.default.join(path_1.default.dirname(content), 'outside-catalog.json');
+        fs_1.default.writeFileSync(outside, JSON.stringify({ bundles: [] }));
+        fs_1.default.rmSync(path_1.default.join(content, 'catalog.json'));
+        fs_1.default.symlinkSync(outside, path_1.default.join(content, 'catalog.json'));
+        expect(() => (0, bundles_1.readCatalog)(content)).toThrow(/symbolic link/);
+    });
 });
 describe('discoverBundles', () => {
     it('loads each bundle and normalizes skill refs (string | object)', () => {
@@ -54,6 +62,35 @@ describe('discoverBundles', () => {
         const empty = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-empty-'));
         expect((0, bundles_1.discoverBundles)(empty)).toEqual([]);
     });
+    it('rejects catalog sources that escape the registry content root', () => {
+        const content = makeFixture();
+        const outside = path_1.default.join(path_1.default.dirname(content), 'outside');
+        fs_1.default.mkdirSync(outside, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(outside, 'bundle.json'), JSON.stringify({ name: 'outside' }));
+        fs_1.default.writeFileSync(path_1.default.join(content, 'catalog.json'), JSON.stringify({
+            bundles: [{ name: 'outside', source: '../outside', version: '1.0.0', scope: 'project' }],
+        }));
+        expect(() => (0, bundles_1.discoverBundles)(content)).toThrow(/invalid bundle source/i);
+    });
+    it('rejects a bundle manifest symlink instead of reading outside the registry', () => {
+        const content = makeFixture();
+        const outside = path_1.default.join(path_1.default.dirname(content), 'outside-bundle.json');
+        fs_1.default.writeFileSync(outside, JSON.stringify({ name: 'outside' }));
+        fs_1.default.rmSync(path_1.default.join(content, 'bundles', 'dev', 'bundle.json'));
+        fs_1.default.symlinkSync(outside, path_1.default.join(content, 'bundles', 'dev', 'bundle.json'));
+        expect(() => (0, bundles_1.discoverBundles)(content)).toThrow(/symbolic link/);
+    });
+    it('rejects a catalog source that reaches a bundle through an intermediate symlink', () => {
+        const content = makeFixture();
+        const outside = path_1.default.join(path_1.default.dirname(content), 'outside-bundle');
+        fs_1.default.mkdirSync(outside, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(outside, 'bundle.json'), JSON.stringify({ name: 'outside' }));
+        fs_1.default.symlinkSync(outside, path_1.default.join(content, 'outside'));
+        fs_1.default.writeFileSync(path_1.default.join(content, 'catalog.json'), JSON.stringify({
+            bundles: [{ name: 'outside', source: 'outside', version: '1.0.0', scope: 'project' }],
+        }));
+        expect(() => (0, bundles_1.discoverBundles)(content)).toThrow(/symbolic link/);
+    });
 });
 describe('resolveBundleSkills', () => {
     it('follows dependsOn transitively and dedupes', () => {

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

@@ -18,6 +18,10 @@ const WORKFLOWS_DIR = path_1.default.join(CONTENT_ROOT, 'workflows');
 describe('Artifact Discovery', () => {
     beforeEach(() => {
         jest.clearAllMocks();
+        fs_1.default.lstatSync.mockImplementation(() => {
+            const error = Object.assign(new Error('missing'), { code: 'ENOENT' });
+            throw error;
+        });
     });
     describe('discoverSkills', () => {
         it('should return a list of skill directories that contain a SKILL.md', () => {

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

@@ -19,7 +19,11 @@ function seedRegistry(contentRoot) {
     fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'hooks', 'run-hook.cmd'), '#!/bin/sh\n');
     fs_1.default.chmodSync(path_1.default.join(contentRoot, 'hooks', 'run-hook.cmd'), 0o755);
     fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'sensor-packs', 'js-ts'), { recursive: true });
-    fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'sensor-packs', 'js-ts', 'pack.json'), JSON.stringify({ sensors: { lint: { defaultCmd: 'eslint {{SOURCE_DIRS}}', fast: true } } }));
+    fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'sensor-packs', 'js-ts', 'pack.json'), 
+    // R3 validates even a legacy pack at the registry boundary.  This fixture
+    // intentionally stays legacy (no schemaVersion) but must still carry its
+    // required stable identity, just like a real legacy registry pack.
+    JSON.stringify({ name: 'js-ts', sensors: { lint: { defaultCmd: 'eslint {{SOURCE_DIRS}}', fast: true } } }));
     // catalog + bundle dev (baseline)
     fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'catalog.json'), JSON.stringify({
         version: 1, bundles: [{ name: 'dev', source: './bundles/dev', version: '1.0.0', scope: 'baseline' }],

package/dist/tests/core/init/steps.test.js

@@ -143,6 +143,22 @@ describe('stepHook / stepDevCore / stepAmbient', () => {
         expect((0, steps_1.stepDevCore)(deps({ machine: m, project: null }, a)).action).toBe('applied');
         expect(a.installBundle).toHaveBeenCalled();
     });
+    it('defers local-only baseline bundles during --machine-only (R7)', () => {
+        const a = spies();
+        const m = machine();
+        m.devCore = { present: false, brokenLinks: [] };
+        const r = (0, steps_1.stepDevCore)(deps({ machine: m, project: null }, a, {
+            agent: 'copilot',
+            enabledAgents: ['copilot'],
+            machineOnly: true,
+        }));
+        expect(r).toMatchObject({
+            action: 'skipped',
+            level: 'machine',
+        });
+        expect(r.detail).toMatch(/project scope.*deferred/i);
+        expect(a.installBundle).not.toHaveBeenCalled();
+    });
     // Regression for the confirmed production bug: `awm init -a copilot` crashed
     // 100% of the time with "machine.devCore: skill global scope is not
     // supported by Copilot...", rolling back the ENTIRE init transaction (even
@@ -386,13 +402,13 @@ describe('stepActivation', () => {
     });
 });
 describe('stepSensors', () => {
-    it('skips when sensors present', () => {
+    it('skips when sensors present', async () => {
         const a = spies();
-        expect((0, steps_1.stepSensors)(deps({ machine: machine(), project: project() }, a)).action).toBe('skipped');
+        expect((await (0, steps_1.stepSensors)(deps({ machine: machine(), project: project() }, a))).action).toBe('skipped');
     });
-    it('inits sensors when absent', () => {
+    it('inits sensors when absent', async () => {
         const a = spies();
-        const r = (0, steps_1.stepSensors)(deps({ machine: machine(), project: project({ sensors: { present: false } }) }, a));
+        const r = await (0, steps_1.stepSensors)(deps({ machine: machine(), project: project({ sensors: { present: false } }) }, a));
         expect(r.action).toBe('applied');
         expect(a.initSensors).toHaveBeenCalledWith({ cwd: '/repo', registryRoot: '/cache/registry', configure: true }); // sensorPacksRoot='/cache/registry' from deps()
     });