agentic-workflow-manager 8.0.0 → 8.1.0

package/dist/src/commands/sensors/exec.js

@@ -90,6 +90,7 @@ function collectSpawn(input, opts) {
                 shell: false,
                 cwd: opts.cwd,
                 detached: !(0, paths_1.isWindowsNative)(),
+                ...(input.environment ? { env: { ...process.env, ...input.environment } } : {}),
                 // stdin closed: a sensor must never block waiting for input, and the
                 // EOF also tells watch-mode-capable tools (vitest, jest) to run once.
                 stdio: ['ignore', 'pipe', 'pipe'],
@@ -144,14 +145,72 @@ function collectSpawn(input, opts) {
     });
 }
 function validateStructuredCommand(command) {
-    if (!command || typeof command !== 'object' || typeof command.executable !== 'string' || (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(command.executable) && !path_1.default.isAbsolute(command.executable))) {
+    if (!command || typeof command !== 'object' || typeof command.executable !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(command.executable)) {
         throw new Error('structured command executable must be a safe executable name');
     }
-    if (!Array.isArray(command.args) || command.args.some(arg => typeof arg !== 'string' || /[\0\r\n]/.test(arg))) {
-        throw new Error('structured command args must be an array of single-line strings without NUL');
+    const normalizedExecutable = command.executable.toLowerCase().replace(/\.exe$/, '');
+    if (new Set(['sh', 'bash', 'cmd', 'powershell']).has(normalizedExecutable)) {
+        throw new Error('structured command executable must not be a shell');
+    }
+    if (!Array.isArray(command.args) || command.args.length === 0) {
+        throw new Error('structured command args must be a nonempty array');
+    }
+    for (const [index, arg] of command.args.entries()) {
+        if (typeof arg !== 'string' || arg.trim() === '' || /[\0\r\n]/.test(arg)) {
+            throw new Error(`structured command args[${index}] must be a nonempty single-line string without NUL`);
+        }
+        if (arg.includes('{files}') && arg !== '{files}') {
+            throw new Error(`structured command args[${index}] must not embed {files}`);
+        }
     }
     if (!['node-modules-bin', 'python-environment', 'path'].includes(command.resolution))
         throw new Error('structured command resolution is unsupported');
+    if (command.pythonEnvironmentRoot !== undefined && (command.resolution !== 'python-environment' || (command.pythonEnvironmentRoot !== '.venv' && command.pythonEnvironmentRoot !== 'venv'))) {
+        throw new Error('structured command pythonEnvironmentRoot must name the selected .venv or venv Python environment');
+    }
+    if (command.resolution === 'python-environment' && command.pythonEnvironmentRoot === undefined)
+        throw new Error('python environment command requires a discovery-bound contained local environment root');
+    const packageManagers = new Set(['npm', 'pnpm', 'yarn', 'bun']);
+    const normalizedPackageManager = typeof command.packageManager === 'string' ? command.packageManager.toLowerCase().replace(/\.exe$/, '') : undefined;
+    if (packageManagers.has(normalizedExecutable) && normalizedPackageManager !== normalizedExecutable)
+        throw new Error('structured command packageManager must explicitly match its executable');
+    if (normalizedPackageManager !== undefined && !packageManagers.has(normalizedPackageManager))
+        throw new Error('structured command packageManager is unsupported');
+    if (normalizedPackageManager !== undefined && normalizedPackageManager !== normalizedExecutable)
+        throw new Error('structured command packageManager must explicitly match its executable');
+    if (command.environment !== undefined) {
+        const environment = command.environment;
+        if (!environment || typeof environment !== 'object' || Array.isArray(environment) || Object.keys(environment).length !== 1 || !Object.prototype.hasOwnProperty.call(environment, 'ESLINT_USE_FLAT_CONFIG')) {
+            throw new Error('structured command environment must be the exact allowlisted ESLINT_USE_FLAT_CONFIG=true or false mapping');
+        }
+        const flatConfig = environment.ESLINT_USE_FLAT_CONFIG;
+        if (flatConfig !== 'true' && flatConfig !== 'false')
+            throw new Error('structured command environment must be the exact allowlisted ESLINT_USE_FLAT_CONFIG=true or false mapping');
+    }
+    const fileArguments = command.args.filter(arg => arg === '{files}').length;
+    if (command.fileInput === undefined) {
+        if (fileArguments !== 0)
+            throw new Error('structured command {files} argument requires fileInput');
+        return;
+    }
+    const fileInput = command.fileInput;
+    if (!fileInput || typeof fileInput !== 'object' || Array.isArray(fileInput) || Object.keys(fileInput).length !== 2 || !Object.prototype.hasOwnProperty.call(fileInput, 'placeholder') || !Object.prototype.hasOwnProperty.call(fileInput, 'extensions')) {
+        throw new Error('structured command fileInput must contain only placeholder and extensions');
+    }
+    const { placeholder, extensions } = fileInput;
+    if (placeholder !== '{files}')
+        throw new Error('structured command fileInput.placeholder must be {files}');
+    if (!Array.isArray(extensions) || extensions.length === 0 || extensions.some(extension => typeof extension !== 'string' || extension.trim() === '' || /[\0\r\n]/.test(extension) || !/^\.[A-Za-z0-9]+$/.test(extension))) {
+        throw new Error('structured command fileInput.extensions must be a nonempty array of extensions');
+    }
+    if (fileArguments !== 1)
+        throw new Error('structured command fileInput requires exactly one {files} argument');
+}
+function safeWindowsExecutableExtensions() {
+    return (process.env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD')
+        .split(';')
+        .map(ext => ext.toLowerCase())
+        .filter(ext => ext === '.exe' || ext === '.com');
 }
 function regularFile(candidate) {
     try {
@@ -162,6 +221,25 @@ function regularFile(candidate) {
         return false;
     }
 }
+/** Resolve a Python environment executable only when every selected path
+ * component is a non-symbolic-link local entry. A leaf-only lstat follows a
+ * linked .venv/venv ancestor and can otherwise execute outside the project. */
+function localPythonEnvironmentExecutable(cwd, environmentRoot, executable) {
+    const parts = [environmentRoot, (0, paths_1.isWindowsNative)() ? 'Scripts' : 'bin', executable];
+    let candidate = cwd;
+    try {
+        for (const part of parts) {
+            candidate = path_1.default.join(candidate, part);
+            const stat = fs_1.default.lstatSync(candidate);
+            if (stat.isSymbolicLink())
+                return null;
+        }
+        return fs_1.default.lstatSync(candidate).isFile() ? candidate : null;
+    }
+    catch {
+        return null;
+    }
+}
 function containedPath(root, candidate) {
     const relative = path_1.default.relative(root, candidate);
     return relative !== '' && !relative.startsWith(`..${path_1.default.sep}`) && relative !== '..' && !path_1.default.isAbsolute(relative);
@@ -202,7 +280,9 @@ function resolveStructuredExecutable(command, cwd) {
                 return local;
             throw new Error('node_modules executable is not a contained local file');
         }
-        const extensions = (process.env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD').split(';').map(ext => ext.toLowerCase()).filter(ext => ext === '.exe' || ext === '.com');
+        const extensions = safeWindowsExecutableExtensions();
+        if (extensions.length === 0)
+            throw new Error('PATHEXT contains no safe Windows executable extension for structured commands');
         const candidates = [path_1.default.join(bin, command.executable), ...extensions.map(extension => path_1.default.join(bin, command.executable + extension))];
         for (const candidate of candidates) {
             const lower = candidate.toLowerCase();
@@ -218,8 +298,24 @@ function resolveStructuredExecutable(command, cwd) {
     if (command.resolution === 'python-environment') {
         if (path_1.default.isAbsolute(command.executable))
             throw new Error('python environment executable must be a contained local name');
-        candidates.push(path_1.default.join(cwd, '.venv', (0, paths_1.isWindowsNative)() ? 'Scripts' : 'bin', command.executable));
-        candidates.push(path_1.default.join(cwd, 'venv', (0, paths_1.isWindowsNative)() ? 'Scripts' : 'bin', command.executable));
+        if (!(0, paths_1.isWindowsNative)()) {
+            const local = localPythonEnvironmentExecutable(cwd, command.pythonEnvironmentRoot, command.executable);
+            if (local)
+                return local;
+            throw new Error('python environment executable is not a contained local regular file');
+        }
+        const extensions = safeWindowsExecutableExtensions();
+        if (extensions.length === 0)
+            throw new Error('PATHEXT contains no safe Windows executable extension for structured commands');
+        for (const executable of [command.executable, ...extensions.map(extension => command.executable + extension)]) {
+            const lower = executable.toLowerCase();
+            if (lower.endsWith('.cmd') || lower.endsWith('.bat'))
+                throw new Error('structured commands cannot execute Windows command wrappers');
+            const local = localPythonEnvironmentExecutable(cwd, command.pythonEnvironmentRoot, executable);
+            if (local && extensions.some(extension => lower.endsWith(extension)))
+                return local;
+        }
+        throw new Error('python environment executable is not a contained local regular file');
     }
     else if (path_1.default.isAbsolute(command.executable))
         candidates.push(command.executable);
@@ -231,11 +327,11 @@ function resolveStructuredExecutable(command, cwd) {
         const found = candidates.find(regularFile);
         if (found)
             return found;
-        if (command.resolution === 'python-environment')
-            throw new Error('python environment executable is not a contained local regular file');
         return command.executable;
     }
-    const extensions = (process.env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD').split(';').map(ext => ext.toLowerCase()).filter(ext => ext === '.exe' || ext === '.com');
+    const extensions = safeWindowsExecutableExtensions();
+    if (extensions.length === 0)
+        throw new Error('PATHEXT contains no safe Windows executable extension for structured commands');
     for (const candidate of candidates) {
         const lower = candidate.toLowerCase();
         if (lower.endsWith('.cmd') || lower.endsWith('.bat'))
@@ -246,14 +342,12 @@ function resolveStructuredExecutable(command, cwd) {
             if (regularFile(candidate + extension))
                 return candidate + extension;
     }
-    if (command.resolution === 'python-environment')
-        throw new Error('python environment executable is not a contained local regular file');
     return command.executable;
 }
 /** Execute a v2 command as an executable plus literal argv; it never starts a shell. */
 function runStructuredCommand(command, opts) {
     validateStructuredCommand(command);
-    return collectSpawn({ executable: resolveStructuredExecutable(command, opts.cwd), args: command.args, shell: false }, opts);
+    return collectSpawn({ executable: resolveStructuredExecutable(command, opts.cwd), args: command.args, shell: false, environment: command.environment }, opts);
 }
 /** Legacy sensor strings intentionally retain their documented shell semantics. */
 function runCommand(cmd, opts) {

package/dist/src/commands/sensors/init.js

@@ -253,9 +253,11 @@ async function initSensors(opts = {}) {
     if (opts.registryRoot) {
         const resolvedV2 = readV2Pack(resolvedPack, opts.registryRoot);
         if (resolvedV2) {
-            const compatibility = (await (0, live_1.resolveParsedPackCompatibility)(cwd, resolvedV2.pack)).sensors;
+            const packSelection = opts.pack ? 'explicit' : undefined;
+            const live = await (0, live_1.resolveParsedPackCompatibility)(cwd, resolvedV2.pack, { packSelection });
+            const compatibility = live.sensors;
             const sensors = {};
-            for (const [name, sensor] of Object.entries(resolvedV2.pack.sensors)) {
+            for (const [name, sensor] of Object.entries(live.pack.sensors)) {
                 const resolved = compatibility[name];
                 const variant = resolved.variantId === null ? null : sensor.variants.find(candidate => candidate.id === resolved.variantId) ?? null;
                 // Unresolved states do not receive an arbitrary command. They remain
@@ -273,6 +275,7 @@ async function initSensors(opts = {}) {
                         variantId: variant.id,
                         command: variant.command,
                         assets: variant.assets,
+                        ...(variant.policyRef ? { policyRef: variant.policyRef } : {}),
                         initializedCompatibility: migratedOverride
                             ? { ...resolved, state: 'compatible-unverified', reason: 'legacy custom command requires explicit v2 migration' }
                             : resolved,
@@ -281,7 +284,7 @@ async function initSensors(opts = {}) {
             }
             const materialized = (0, materialize_1.materializeResolvedSensors)({
                 projectRoot: cwd, packRoot: resolvedV2.packRoot,
-                pack: resolvedPack, registryRoot: opts.registryRoot, sensors, configure,
+                pack: resolvedPack, ...(packSelection ? { packSelection } : {}), registryRoot: opts.registryRoot, sensors, configure,
             });
             return { detection, ...materialized,
                 compatibility, ...(unavailablePack ? { unavailablePack } : {}) };

package/dist/src/commands/sensors/run.js

@@ -73,7 +73,7 @@ async function resolveLiveV2(cwd, manifest) {
     if (manifest.kind !== 'v2')
         return null;
     try {
-        return await (0, live_1.resolveLiveCompatibility)(cwd, manifest.pack.pack, manifest.pack.registryRoot);
+        return await (0, live_1.resolveLiveCompatibility)(cwd, manifest.pack.pack, manifest.pack.registryRoot, { packSelection: manifest.pack.packSelection });
     }
     catch {
         return null;

package/dist/src/commands/sensors/status.js

@@ -68,7 +68,7 @@ async function computeSensorStatus(cwd = process.cwd()) {
             const checks = {};
             let live;
             try {
-                live = await (0, live_1.resolveLiveCompatibility)(cwd, parsed.pack.pack, parsed.pack.registryRoot);
+                live = await (0, live_1.resolveLiveCompatibility)(cwd, parsed.pack.pack, parsed.pack.registryRoot, { packSelection: parsed.pack.packSelection });
             }
             catch (error) {
                 const detail = `compatibility revalidation failed: ${error instanceof Error ? error.message : String(error)}`;

package/dist/tests/commands/sensors/compatibility/contract.test.js

@@ -1,6 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const contract_1 = require("../../../../src/commands/sensors/compatibility/contract");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
 const coverage = {
     schemaVersion: 1,
     classes: {
@@ -37,9 +43,92 @@ function validPack() {
     };
 }
 describe('sensor pack v2 contract', () => {
+    it('derives Semgrep compatibility from a contained shared policy reference', () => {
+        const sensorPacks = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-semgrep-policy-'));
+        const packDir = path_1.default.join(sensorPacks, 'python');
+        try {
+            fs_1.default.mkdirSync(path_1.default.join(sensorPacks, 'shared'), { recursive: true });
+            fs_1.default.mkdirSync(packDir);
+            fs_1.default.writeFileSync(path_1.default.join(sensorPacks, 'shared', 'semgrep-policy.json'), JSON.stringify({
+                tool: 'semgrep', toolRange: '>=1.0.0', runtime: 'python', runtimeRange: '>=3.9.0', probe: 'semgrep-validate',
+            }));
+            const pack = validPack();
+            pack.sensors.lint.variants[0] = {
+                id: 'semgrep-python', priority: 10, certifiedRange: '>=1.0.0', policyRef: 'shared/semgrep-policy.json',
+                command: { executable: 'semgrep', resolution: 'path', args: ['--config', '.semgrep.awm.yml', '--json', '.'] },
+                assets: ['.semgrep.awm.yml'], formatter: 'semgrep',
+            };
+            const parsed = (0, contract_1.parseSensorPack)(pack, path_1.default.join(packDir, 'pack.json'));
+            expect(parsed).toMatchObject({ kind: 'v2', pack: { sensors: { lint: { variants: [{
+                                    policyRef: 'shared/semgrep-policy.json', requirements: { tool: 'semgrep', runtime: 'python' }, probe: { kind: 'semgrep-validate' },
+                                }] } } } });
+        }
+        finally {
+            fs_1.default.rmSync(sensorPacks, { recursive: true, force: true });
+        }
+    });
+    it('fails closed when a policy reference is not the AWM-owned shared Semgrep policy', () => {
+        const pack = validPack();
+        pack.sensors.lint.variants[0] = {
+            id: 'semgrep-python', priority: 10, certifiedRange: '>=1.0.0', policyRef: '../secret.json',
+            command: { executable: 'semgrep', resolution: 'path', args: ['--config', '.semgrep.awm.yml', '--json', '.'] },
+            assets: ['.semgrep.awm.yml'], formatter: 'semgrep',
+        };
+        expect(() => (0, contract_1.parseSensorPack)(pack, '/tmp/sensor-packs/python/pack.json')).toThrow('policyRef');
+    });
     it('parses a valid versioned pack', () => {
         expect((0, contract_1.parseSensorPack)(validPack(), 'pack.json')).toMatchObject({ kind: 'v2', pack: validPack() });
     });
+    it('accepts an opt-in hardening asset while variants may require no assets', () => {
+        const pack = {
+            ...validPack(),
+            hardening: { 'typescript-strict': { assets: ['tsconfig.awm.json'] } },
+            sensors: {
+                lint: {
+                    ...validPack().sensors.lint,
+                    variants: [{ ...validPack().sensors.lint.variants[0], assets: [] }],
+                },
+            },
+        };
+        expect((0, contract_1.parseSensorPack)(pack, 'pack.json')).toMatchObject({
+            kind: 'v2',
+            pack: { hardening: { 'typescript-strict': { assets: ['tsconfig.awm.json'] } }, sensors: { lint: { variants: [{ assets: [] }] } } },
+        });
+    });
+    it.each(['true', 'false'])('accepts the exact ESLINT_USE_FLAT_CONFIG=%s environment mapping', flatConfig => {
+        const command = {
+            executable: 'npm',
+            resolution: 'path',
+            args: ['run', 'lint'],
+            packageManager: 'npm',
+            environment: { ESLINT_USE_FLAT_CONFIG: flatConfig },
+        };
+        expect((0, contract_1.parseSensorPack)({ ...validPack(), sensors: { lint: { ...validPack().sensors.lint, variants: [{ ...validPack().sensors.lint.variants[0], command }] } } }, 'pack.json'))
+            .toMatchObject({ kind: 'v2', pack: { sensors: { lint: { variants: [{ command }] } } } });
+    });
+    it.each([
+        { ESLINT_USE_FLAT_CONFIG: 'yes' },
+        { ESLINT_USE_FLAT_CONFIG: 'true', OTHER: 'value' },
+    ])('rejects an unknown or expanded ESLint environment mapping', environment => {
+        const command = { executable: 'npm', resolution: 'path', args: ['run', 'lint'], packageManager: 'npm', environment };
+        expect(() => (0, contract_1.parseSensorPack)({ ...validPack(), sensors: { lint: { ...validPack().sensors.lint, variants: [{ ...validPack().sensors.lint.variants[0], command }] } } }, 'pack.json'))
+            .toThrow('command.environment');
+    });
+    it('normalizes package-manager executable spelling before enforcing its explicit selection', () => {
+        const variant = validPack().sensors.lint.variants[0];
+        const withExecutable = (executable, packageManager) => ({
+            ...validPack(),
+            sensors: { lint: { ...validPack().sensors.lint, variants: [{
+                            ...variant,
+                            command: { executable, resolution: 'path', args: ['run', 'lint'], ...(packageManager === undefined ? {} : { packageManager }) },
+                        }] } },
+        });
+        expect(() => (0, contract_1.parseSensorPack)(withExecutable('NPM'), 'pack.json')).toThrow('packageManager');
+        expect((0, contract_1.parseSensorPack)(withExecutable('npm.exe', 'NPM'), 'pack.json')).toMatchObject({
+            kind: 'v2', pack: { sensors: { lint: { variants: [{ command: { executable: 'npm.exe', packageManager: 'npm' } }] } } },
+        });
+        expect(() => (0, contract_1.parseSensorPack)(withExecutable('NPM', 'pnpm'), 'pack.json')).toThrow('match executable');
+    });
     it('keeps an unversioned pack on the legacy compatibility path', () => {
         const legacy = { name: 'legacy', sensors: {} };
         expect((0, contract_1.parseSensorPack)(legacy, 'pack.json')).toMatchObject({ kind: 'legacy', pack: { ...legacy, compatibility: { state: 'compatible-unverified' } } });
@@ -90,8 +179,14 @@ describe('sensor pack v2 contract', () => {
         [{ ...validPack(), sensors: { lint: { variants: [validPack().sensors.lint.variants[0], { ...validPack().sensors.lint.variants[0], id: 'eslint-9-next', certifiedRange: '>=9.1.0 <10.0.0' }] } } }, 'overlap'],
         [{ ...validPack(), sensors: { lint: { ...validPack().sensors.lint, variants: [{ ...validPack().sensors.lint.variants[0], assets: ['C:/secret'] }] } } }, 'asset'],
         [{ ...validPack(), sensors: { lint: { ...validPack().sensors.lint, variants: [{ ...validPack().sensors.lint.variants[0], command: { executable: 'cmd.exe', resolution: 'path', args: ['x'] } }] } } }, 'executable'],
+        [{ ...validPack(), sensors: { lint: { ...validPack().sensors.lint, variants: [{ ...validPack().sensors.lint.variants[0], command: { executable: 'npm', resolution: 'path', args: ['run', 'lint'] } }] } } }, 'packageManager'],
+        [{ ...validPack(), sensors: { lint: { ...validPack().sensors.lint, variants: [{ ...validPack().sensors.lint.variants[0], command: { executable: 'npm', resolution: 'path', args: ['run', 'lint'], packageManager: 'pnpm' } }] } } }, 'match executable'],
+        [{ ...validPack(), sensors: { lint: { ...validPack().sensors.lint, variants: [{ ...validPack().sensors.lint.variants[0], command: { ...validPack().sensors.lint.variants[0].command, environment: { NODE_OPTIONS: '--require unsafe' } } }] } } }, 'environment'],
         [{ ...validPack(), sensors: { lint: { ...validPack().sensors.lint, variants: [{ ...validPack().sensors.lint.variants[0], command: { ...validPack().sensors.lint.variants[0].command, args: ['prefix{files}'] } }] } } }, 'embed'],
         [{ ...validPack(), sensors: { lint: { ...validPack().sensors.lint, variants: [{ ...validPack().sensors.lint.variants[0], formatter: 'bad\nformat' }] } } }, 'formatter'],
+        [{ ...validPack(), hardening: { 'typescript-strict': { assets: ['../tsconfig.awm.json'] } } }, 'asset'],
+        [{ ...validPack(), hardening: { 'typescript-strict': { assets: [] } } }, 'hardening'],
+        [{ ...validPack(), hardening: { 'typescript-strict': { assets: ['tsconfig.awm.json'], command: {} } } }, 'unknown field'],
     ])('rejects malformed pack %j', (input, message) => {
         expect(() => (0, contract_1.parseSensorPack)(input, 'pack.json')).toThrow(message);
     });

package/dist/tests/commands/sensors/compatibility/live.test.js

@@ -0,0 +1,124 @@
+"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 live_1 = require("../../../../src/commands/sensors/compatibility/live");
+const exec_1 = require("../../../../src/commands/sensors/exec");
+const python_venv_fixture_1 = require("./python-venv-fixture");
+const itPosix = process.platform !== 'win32' ? it : it.skip;
+describe('resolveParsedPackCompatibility — contained Python commands', () => {
+    test.each([
+        ['linux', ['.venv', 'bin', 'semgrep']],
+        ['win32', ['.venv', 'Scripts', 'semgrep.exe']],
+    ])('creates a local Semgrep executable in the %s virtual-environment layout', (targetPlatform, executableParts) => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-semgrep-venv-layout-'));
+        try {
+            (0, python_venv_fixture_1.createSemgrepVenvFixture)(root, targetPlatform);
+            expect(fs_1.default.lstatSync(path_1.default.join(root, ...executableParts)).isFile()).toBe(true);
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('resolves the Windows virtual-environment executable from Scripts instead of PATH', async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-semgrep-windows-resolution-'));
+        const global = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-semgrep-windows-global-'));
+        const originalPlatform = process.platform;
+        const savedPath = process.env.PATH;
+        const savedPathExt = process.env.PATHEXT;
+        try {
+            Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+            process.env.PATH = global;
+            process.env.PATHEXT = '.EXE';
+            (0, python_venv_fixture_1.createSemgrepVenvFixture)(root, 'win32');
+            fs_1.default.writeFileSync(path_1.default.join(global, 'semgrep.exe'), 'must-not-run');
+            await expect((0, exec_1.runStructuredCommand)({
+                executable: 'semgrep', resolution: 'python-environment', pythonEnvironmentRoot: '.venv', args: ['--version'],
+            }, { cwd: root, timeout: 5_000 })).resolves.toMatchObject({
+                code: 0,
+                stdout: expect.stringContaining(process.version),
+            });
+        }
+        finally {
+            Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true });
+            if (savedPath === undefined)
+                delete process.env.PATH;
+            else
+                process.env.PATH = savedPath;
+            if (savedPathExt === undefined)
+                delete process.env.PATHEXT;
+            else
+                process.env.PATHEXT = savedPathExt;
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+            fs_1.default.rmSync(global, { recursive: true, force: true });
+        }
+    });
+    itPosix('binds Semgrep discovery, validation probe, and execution to the same local virtual-environment executable', async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-semgrep-contained-'));
+        const global = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-semgrep-global-'));
+        const savedPath = process.env.PATH;
+        try {
+            (0, python_venv_fixture_1.createSemgrepVenvFixture)(root);
+            fs_1.default.writeFileSync(path_1.default.join(root, '.venv', 'bin', 'semgrep'), '#!/bin/sh\nif [ "$1" = "--validate" ]; then echo local-semgrep; exit 0; fi\nexit 1\n', { mode: 0o755 });
+            fs_1.default.writeFileSync(path_1.default.join(global, 'semgrep'), '#!/bin/sh\necho global-semgrep\n', { mode: 0o755 });
+            process.env.PATH = global;
+            const pack = {
+                schemaVersion: 2,
+                name: 'python',
+                description: 'test',
+                detects: ['pyproject.toml'],
+                coverage: {},
+                sensors: {
+                    security: {
+                        applicability: { allFiles: ['pyproject.toml'] },
+                        variants: [{
+                                id: 'semgrep-1', priority: 1, certifiedRange: '>=1 <2',
+                                requirements: { tool: 'semgrep', toolRange: '>=1 <2', runtime: 'python', runtimeRange: '>=3.12 <4' },
+                                assets: [], formatter: 'semgrep', probe: { kind: 'semgrep-validate' },
+                                command: { executable: 'semgrep', resolution: 'path', args: ['--validate'] },
+                            }],
+                    },
+                },
+            };
+            fs_1.default.writeFileSync(path_1.default.join(root, 'pyproject.toml'), '[project]\nname = "sample"\n');
+            const live = await (0, live_1.resolveParsedPackCompatibility)(root, pack);
+            const command = live.pack.sensors.security.variants[0].command;
+            expect(live.sensors.security).toMatchObject({ state: 'certified', toolVersion: '1.91.0' });
+            expect(command).toMatchObject({ executable: 'semgrep', resolution: 'python-environment' });
+            await expect((0, exec_1.runStructuredCommand)(command, { cwd: root, timeout: 5_000 })).resolves.toMatchObject({ code: 0, stdout: 'local-semgrep\n' });
+        }
+        finally {
+            process.env.PATH = savedPath;
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+            fs_1.default.rmSync(global, { recursive: true, force: true });
+        }
+    });
+    it('never falls back from the discovered .venv to a sibling venv executable', async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-semgrep-environment-identity-'));
+        try {
+            (0, python_venv_fixture_1.createSemgrepVenvFixture)(root, process.platform, '.venv', { executable: false });
+            (0, python_venv_fixture_1.createSemgrepVenvFixture)(root, process.platform, 'venv');
+            fs_1.default.writeFileSync(path_1.default.join(root, 'pyproject.toml'), '[project]\nname = "sample"\n');
+            const pack = {
+                schemaVersion: 2, name: 'python', description: 'test', detects: ['pyproject.toml'], coverage: {},
+                sensors: { security: { applicability: { allFiles: ['pyproject.toml'] }, variants: [{
+                                id: 'semgrep-1', priority: 1, certifiedRange: '>=1 <2',
+                                requirements: { tool: 'semgrep', toolRange: '>=1 <2', runtime: 'python', runtimeRange: '>=3.12 <4' },
+                                assets: [], formatter: 'semgrep', probe: { kind: 'semgrep-validate' },
+                                command: { executable: 'semgrep', resolution: 'path', args: ['--validate'] },
+                            }] } },
+            };
+            const live = await (0, live_1.resolveParsedPackCompatibility)(root, pack);
+            expect(live.sensors.security).toMatchObject({ state: 'unverifiable', reason: 'probe-inconclusive', toolVersion: '1.91.0' });
+            expect(() => (0, exec_1.runStructuredCommand)(live.pack.sensors.security.variants[0].command, { cwd: root, timeout: 5_000 }))
+                .toThrow('python environment executable is not a contained local regular file');
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+});

package/dist/tests/commands/sensors/compatibility/manifest.test.js

@@ -35,6 +35,15 @@ describe('sensor manifest contract', () => {
         expect((0, manifest_1.parseSensorManifest)(manifest, 'sensors.json')).toMatchObject({ kind: 'v2', pack: manifest });
         expect(JSON.parse((0, manifest_1.serializeManifestV2)(manifest))).toEqual(manifest);
     });
+    it('persists only an explicit v2 pack selection as applicability provenance', () => {
+        const manifest = {
+            schemaVersion: 2, pack: 'generic', packSelection: 'explicit',
+            sensors: {},
+        };
+        expect((0, manifest_1.parseSensorManifest)(manifest, 'sensors.json')).toMatchObject({ kind: 'v2', pack: { packSelection: 'explicit' } });
+        expect(JSON.parse((0, manifest_1.serializeManifestV2)(manifest))).toEqual(manifest);
+        expect(() => (0, manifest_1.parseSensorManifest)({ ...manifest, packSelection: 'detected' }, 'sensors.json')).toThrow('packSelection');
+    });
     it('accepts optional contained assets and rejects traversal', () => {
         const sensor = { enabled: true, variantId: 'eslint-9', assets: ['eslint.config.awm.mjs'], command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] }, initializedCompatibility: { state: 'certified', reason: 'ok', variantId: 'eslint-9', toolVersion: '9.0.0', runtimeVersion: '24.0.0', certifiedRange: '>=9 <10', evidence: [] } };
         expect((0, manifest_1.parseSensorManifest)({ schemaVersion: 2, pack: 'js-ts', sensors: { lint: sensor } }, 'sensors.json')).toMatchObject({ kind: 'v2' });

package/dist/tests/commands/sensors/compatibility/materialize.test.js

@@ -38,6 +38,25 @@ describe('materializeResolvedSensors', () => {
         expect(result.preserved).toEqual(['eslint.config.awm.mjs']);
         expect(fs_1.default.readFileSync(path_1.default.join(projectRoot, 'eslint.config.awm.mjs'), 'utf8')).toBe('owner content');
     });
+    it('revalidates a shared Semgrep policy reference without materializing the policy itself', () => {
+        const sensorPacks = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-materialize-policy-'));
+        const semgrepPack = path_1.default.join(sensorPacks, 'python');
+        try {
+            fs_1.default.mkdirSync(path_1.default.join(sensorPacks, 'shared'), { recursive: true });
+            fs_1.default.mkdirSync(semgrepPack);
+            fs_1.default.writeFileSync(path_1.default.join(semgrepPack, 'pack.json'), '{}');
+            fs_1.default.writeFileSync(path_1.default.join(semgrepPack, '.semgrep.awm.yml'), 'rules: []\n');
+            fs_1.default.writeFileSync(path_1.default.join(sensorPacks, 'shared', 'semgrep-policy.json'), JSON.stringify({ tool: 'semgrep', toolRange: '>=1.0.0', runtime: 'python', runtimeRange: '>=3.9.0', probe: 'semgrep-validate' }));
+            const result = (0, materialize_1.materializeResolvedSensors)({ projectRoot, packRoot: semgrepPack, pack: 'python', sensors: {
+                    security: { enabled: true, variantId: 'semgrep-python', command: { executable: 'semgrep', resolution: 'path', args: ['--config', '.semgrep.awm.yml', '--json', '.'] }, assets: ['.semgrep.awm.yml'], policyRef: 'shared/semgrep-policy.json', initializedCompatibility: { ...evidence, variantId: 'semgrep-python' } },
+                } });
+            expect(result.configured).toEqual(['.semgrep.awm.yml']);
+            expect(fs_1.default.existsSync(path_1.default.join(projectRoot, 'shared', 'semgrep-policy.json'))).toBe(false);
+        }
+        finally {
+            fs_1.default.rmSync(sensorPacks, { recursive: true, force: true });
+        }
+    });
     it('reports previous AWM assets as orphaned and never deletes them', () => {
         fs_1.default.mkdirSync(path_1.default.join(projectRoot, '.awm'));
         fs_1.default.writeFileSync(path_1.default.join(projectRoot, '.awm', 'sensors.json'), JSON.stringify({ schemaVersion: 2, pack: 'js-ts', sensors: {

package/dist/tests/commands/sensors/compatibility/probe.test.js

@@ -24,4 +24,14 @@ describe('runCompatibilityProbe', () => {
         await (0, probe_1.runCompatibilityProbe)({ kind: 'semgrep-validate' }, evidence, fakeExecutor);
         expect(fakeExecutor).toHaveBeenCalledWith(expect.objectContaining({ executable: 'semgrep', resolution: 'python-environment' }), expect.any(Object));
     });
+    it('keeps Windows Semgrep validation on the discovered .venv executable', async () => {
+        await (0, probe_1.runCompatibilityProbe)({ kind: 'semgrep-validate' }, {
+            cwd: process.cwd(), toolExecutable: 'semgrep', toolResolution: 'python-environment', pythonEnvironmentRoot: '.venv',
+        }, fakeExecutor);
+        expect(fakeExecutor).toHaveBeenCalledWith({ executable: 'semgrep', resolution: 'python-environment', pythonEnvironmentRoot: '.venv', args: ['--validate'] }, expect.objectContaining({ cwd: process.cwd() }));
+    });
+    it.each(['mypy', 'ruff', 'pytest'])('probes a %s variant through the contained Python environment', async (toolExecutable) => {
+        await (0, probe_1.runCompatibilityProbe)({ kind: 'version' }, { ...evidence, toolExecutable, toolResolution: 'python-environment' }, fakeExecutor);
+        expect(fakeExecutor).toHaveBeenCalledWith(expect.objectContaining({ executable: toolExecutable, resolution: 'python-environment', args: ['--version'] }), expect.any(Object));
+    });
 });

package/dist/tests/commands/sensors/compatibility/python-venv-fixture.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSemgrepVenvFixture = createSemgrepVenvFixture;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/** Creates contained Semgrep metadata and the host-appropriate virtualenv executable. */
+function createSemgrepVenvFixture(root, targetPlatform = process.platform, environmentRoot = '.venv', options = {}) {
+    if (typeof root !== 'string' || root.trim() === '')
+        throw new Error('fixture root must be a non-empty path');
+    const windows = targetPlatform === 'win32';
+    const sitePackages = windows
+        ? [environmentRoot, 'Lib', 'site-packages']
+        : [environmentRoot, 'lib', 'python3.12', 'site-packages'];
+    const metadata = path_1.default.join(root, ...sitePackages, 'semgrep-1.91.0.dist-info');
+    fs_1.default.mkdirSync(metadata, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(root, environmentRoot, 'pyvenv.cfg'), 'version = 3.12.4\n');
+    fs_1.default.writeFileSync(path_1.default.join(metadata, 'METADATA'), 'Name: semgrep\nVersion: 1.91.0\n');
+    if (options.executable === false)
+        return;
+    const executable = path_1.default.join(root, environmentRoot, windows ? 'Scripts' : 'bin', windows ? 'semgrep.exe' : 'semgrep');
+    fs_1.default.mkdirSync(path_1.default.dirname(executable), { recursive: true });
+    if (windows)
+        fs_1.default.copyFileSync(process.execPath, executable);
+    else
+        fs_1.default.writeFileSync(executable, '#!/bin/sh\necho local-semgrep\n', { mode: 0o755 });
+}

package/dist/tests/commands/sensors/compatibility/resolve.test.js

@@ -12,6 +12,14 @@ const sensor = { applicability: { allFiles: ['package.json'] }, variants: [varia
 const evidence = (input = {}) => ({ paths: ['package.json'], applicable: true, packageManagerConflict: false, toolVersion: '10.4.1', runtimeVersion: '22.0.0', probe: { status: 'matched' }, ...input });
 const context = { pack: 'js-ts', sensor: 'lint' };
 describe('resolveSensorCompatibility', () => {
+    it('keeps an automatically selected generic pack not-applicable despite language markers', () => {
+        const resolved = (0, resolve_1.resolveSensorCompatibility)({ applicability: { kind: 'explicit-or-supported-language' }, variants: [variant('semgrep')] }, evidence({ applicable: undefined, paths: ['pyproject.toml'], toolVersion: '1.0.0', runtimeVersion: '3.12.0', probe: { status: 'matched' } }), { pack: 'generic', sensor: 'security' });
+        expect(resolved).toMatchObject({ state: 'not-applicable', reason: 'applicability-not-met' });
+    });
+    it('treats the persisted explicit generic pack selection as positive capability in project resolution', () => {
+        const resolved = (0, resolve_1.resolveProjectCompatibility)({ schemaVersion: 2, name: 'generic', sensors: { security: { applicability: { kind: 'explicit-or-supported-language' }, variants: [variant('semgrep')] } } }, evidence({ applicable: undefined, paths: [], packSelection: 'explicit' }));
+        expect(resolved.sensors.security.state).not.toBe('not-applicable');
+    });
     test.each([
         ['certified', evidence(), 'eslint-main'],
         ['compatible-unverified', evidence({ toolVersion: '11.0.0' }), 'eslint-main'],