agentic-workflow-manager 6.5.2 → 8.1.0

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

@@ -1,7 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStructuredCommand = runStructuredCommand;
 exports.runCommand = runCommand;
 const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 const paths_1 = require("../../core/paths");
 const DEFAULT_MAX_BUFFER = 64 * 1024 * 1024;
 const DEFAULT_KILL_GRACE_MS = 2_000;
@@ -53,7 +59,17 @@ function killTree(pid, signal) {
  *     throws away 60s of eslint output costs double: the wall clock, and then
  *     the re-run the caller has to do to learn anything at all.
  */
-function runCommand(cmd, opts) {
+function validateOptions(opts) {
+    if (!opts || typeof opts !== 'object' || typeof opts.cwd !== 'string' || opts.cwd.trim() === '' || !Number.isSafeInteger(opts.timeout) || opts.timeout <= 0) {
+        throw new Error('exec options require a non-empty cwd and positive safe-integer timeout');
+    }
+    if (opts.maxBuffer !== undefined && (!Number.isSafeInteger(opts.maxBuffer) || opts.maxBuffer <= 0))
+        throw new Error('exec options maxBuffer must be a positive safe integer');
+    if (opts.killGraceMs !== undefined && (!Number.isSafeInteger(opts.killGraceMs) || opts.killGraceMs < 0))
+        throw new Error('exec options killGraceMs must be a non-negative safe integer');
+}
+function collectSpawn(input, opts) {
+    validateOptions(opts);
     const maxBuffer = opts.maxBuffer ?? DEFAULT_MAX_BUFFER;
     const killGraceMs = opts.killGraceMs ?? DEFAULT_KILL_GRACE_MS;
     return new Promise((resolve) => {
@@ -63,14 +79,22 @@ function runCommand(cmd, opts) {
         let overflowed = false;
         let settled = false;
         const timers = [];
-        const child = (0, child_process_1.spawn)(cmd, {
-            shell: true,
-            cwd: opts.cwd,
-            detached: !(0, paths_1.isWindowsNative)(),
-            // 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'],
-        });
+        const child = input.shell
+            ? (0, child_process_1.spawn)(input.executable, {
+                shell: true,
+                cwd: opts.cwd,
+                detached: !(0, paths_1.isWindowsNative)(),
+                stdio: ['ignore', 'pipe', 'pipe'],
+            })
+            : (0, child_process_1.spawn)(input.executable, input.args, {
+                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'],
+            });
         const later = (fn, ms) => {
             const t = setTimeout(fn, ms);
             t.unref?.();
@@ -120,3 +144,214 @@ function runCommand(cmd, opts) {
         later(() => { timedOut = true; cutShort(); }, opts.timeout);
     });
 }
+function validateStructuredCommand(command) {
+    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');
+    }
+    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 {
+        const stat = fs_1.default.lstatSync(candidate);
+        return stat.isFile() && !stat.isSymbolicLink();
+    }
+    catch {
+        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);
+}
+/** Resolve a local npm shim to its real regular-file target. npm commonly uses
+ * symlinks in .bin on POSIX, so rejecting every symlink would reject valid local
+ * installs. The real target must remain inside the project's node_modules. */
+function localNodeModulesExecutable(candidate, modulesRoot) {
+    try {
+        const shim = fs_1.default.lstatSync(candidate);
+        if (!shim.isFile() && !shim.isSymbolicLink())
+            return null;
+        const real = fs_1.default.realpathSync(candidate);
+        const target = fs_1.default.statSync(real);
+        return target.isFile() && containedPath(modulesRoot, real) ? real : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Find a real executable without a shell. Windows .cmd/.bat shims are deliberately
+ * excluded: CreateProcess cannot execute them safely without cmd.exe. */
+function resolveStructuredExecutable(command, cwd) {
+    if (command.resolution === 'node-modules-bin') {
+        let modulesRoot;
+        try {
+            modulesRoot = fs_1.default.realpathSync(path_1.default.join(cwd, 'node_modules'));
+            if (!fs_1.default.statSync(modulesRoot).isDirectory())
+                throw new Error();
+        }
+        catch {
+            throw new Error('node_modules executable not found locally');
+        }
+        const bin = path_1.default.join(modulesRoot, '.bin');
+        if (!(0, paths_1.isWindowsNative)()) {
+            const local = localNodeModulesExecutable(path_1.default.join(bin, command.executable), modulesRoot);
+            if (local)
+                return local;
+            throw new Error('node_modules executable is not a contained local file');
+        }
+        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();
+            if (lower.endsWith('.cmd') || lower.endsWith('.bat'))
+                throw new Error('structured commands cannot execute Windows command wrappers');
+            const local = localNodeModulesExecutable(candidate, modulesRoot);
+            if (local && extensions.some(extension => local.toLowerCase().endsWith(extension)))
+                return local;
+        }
+        throw new Error('node_modules executable is not a contained local file');
+    }
+    const candidates = [];
+    if (command.resolution === 'python-environment') {
+        if (path_1.default.isAbsolute(command.executable))
+            throw new Error('python environment executable must be a contained local name');
+        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);
+    else {
+        for (const entry of (process.env.PATH ?? '').split(path_1.default.delimiter).filter(Boolean))
+            candidates.push(path_1.default.join(entry, command.executable));
+    }
+    if (!(0, paths_1.isWindowsNative)()) {
+        const found = candidates.find(regularFile);
+        if (found)
+            return found;
+        return command.executable;
+    }
+    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'))
+            throw new Error('structured commands cannot execute Windows command wrappers');
+        if (regularFile(candidate) && extensions.some(ext => lower.endsWith(ext)))
+            return candidate;
+        for (const extension of extensions)
+            if (regularFile(candidate + extension))
+                return candidate + extension;
+    }
+    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, environment: command.environment }, opts);
+}
+/** Legacy sensor strings intentionally retain their documented shell semantics. */
+function runCommand(cmd, opts) {
+    if (typeof cmd !== 'string' || cmd.trim() === '' || /[\0\r\n]/.test(cmd))
+        throw new Error('runCommand: cmd must be a non-empty single-line legacy string without NUL');
+    return collectSpawn({ executable: cmd, args: [], shell: true }, opts);
+}

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

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.exitCodeFor = exitCodeFor;
+exports.parsePositiveSafeInteger = parsePositiveSafeInteger;
 exports.registerSensorsCommand = registerSensorsCommand;
 const picocolors_1 = __importDefault(require("picocolors"));
 const prompts_1 = require("@clack/prompts");
@@ -21,15 +22,26 @@ const registries_1 = require("../../core/registries");
 function exitCodeFor(output) {
     return output.overall === 'fail' ? 1 : 0;
 }
+/** Commander coercion for coverage recurrence emphasis. It deliberately runs
+ * before the action, so an invalid value cannot trigger ledger I/O. */
+function parsePositiveSafeInteger(value) {
+    if (typeof value !== 'string' || !/^[1-9][0-9]*$/.test(value))
+        throw new Error('--min must be a positive safe integer');
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed))
+        throw new Error('--min must be a positive safe integer');
+    return parsed;
+}
 function registerSensorsCommand(program) {
     const sensors = program.command('sensors').description('manage computational sensors for the current project');
     sensors
         .command('coverage')
         .description('report static gaps between configured sensors and the pack reference')
         .option('--json', 'emit the versioned machine-readable envelope')
-        .action((opts) => {
+        .option('--min <count>', 'recurrence emphasis threshold', parsePositiveSafeInteger, 2)
+        .action(async (opts) => {
         try {
-            const report = (0, coverage_1.runCoverage)(process.cwd());
+            const report = await (0, coverage_1.runCoverage)(process.cwd(), {}, { min: opts.min });
             process.stdout.write(opts.json ? (0, render_1.renderCoverageJson)(report) : (0, render_1.renderCoverageHuman)(report));
         }
         catch (error) {
@@ -63,10 +75,10 @@ function registerSensorsCommand(program) {
         .option('--no-configure', 'skip copying sensor pack config files into the project')
         .option('--registry-root <path>', 'path to AWM registry root')
         .option('--pack <name>', 'skip auto-detection, use this pack explicitly')
-        .action((opts) => {
+        .action(async (opts) => {
         const registryRoot = opts.registryRoot ?? (0, registries_1.capabilityRoot)('sensor-packs') ?? undefined;
         try {
-            const result = (0, init_1.initSensors)({ configure: opts.configure, registryRoot, pack: opts.pack });
+            const result = await (0, init_1.initSensors)({ configure: opts.configure, registryRoot, pack: opts.pack });
             prompts_1.log.success(`Detected: ${result.detection.pack} (${result.detection.indicators.join(', ') || 'fallback'})`);
             // Said BEFORE "Wrote .awm/sensors.json": the manifest about to be
             // reported as written is not the one the detection implied.
@@ -99,8 +111,8 @@ function registerSensorsCommand(program) {
     sensors
         .command('status')
         .description('check sensor health for the current project')
-        .action(() => {
-        const status = (0, status_1.computeSensorStatus)();
+        .action(async () => {
+        const status = await (0, status_1.computeSensorStatus)();
         const icon = status.overall === 'HEALTHY' ? picocolors_1.default.green('✔') : picocolors_1.default.yellow('⚠');
         console.log(`\nPack:    ${status.pack ?? 'none'}`);
         console.log(`Overall: ${icon} ${status.overall}\n`);

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

@@ -9,6 +9,41 @@ exports.buildManifest = buildManifest;
 exports.initSensors = initSensors;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const contract_1 = require("./compatibility/contract");
+const materialize_1 = require("./compatibility/materialize");
+const live_1 = require("./compatibility/live");
+const manifest_1 = require("./compatibility/manifest");
+const pack_source_1 = require("./compatibility/pack-source");
+/** Read a pack only through the shared source resolver.  Init is a registry
+ * boundary: a pack path that is absent is harmless, but a symlink or escaping
+ * claimed source is never silently downgraded to an empty manifest. */
+function readResolvedPack(pack, registryRoot) {
+    try {
+        const source = (0, pack_source_1.resolvePackSource)(pack, {
+            registries: [{ name: 'init-registry', remote: 'local', contentRoot: registryRoot }],
+        });
+        return { path: source.path, content: source.content };
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('was not found in configured registries'))
+            return null;
+        throw error;
+    }
+}
+function readV2Pack(pack, registryRoot) {
+    const source = readResolvedPack(pack, registryRoot);
+    if (!source)
+        return null;
+    let raw;
+    try {
+        raw = JSON.parse(source.content);
+    }
+    catch {
+        throw new Error(`cannot parse sensor pack ${source.path}`);
+    }
+    const parsed = (0, contract_1.parseSensorPack)(raw, source.path);
+    return parsed.kind === 'v2' ? { pack: parsed.pack, packRoot: path_1.default.dirname(source.path) } : null;
+}
 const STACK_DETECTORS = [
     { pack: 'js-ts', files: ['package.json'] },
     { pack: 'python', files: ['pyproject.toml', 'setup.py', 'setup.cfg', 'requirements.txt', 'Pipfile'] },
@@ -60,12 +95,12 @@ function detectSourceDirs(cwd) {
  * with the project's actual source dirs. Returns null if the pack has no pack.json.
  */
 function readPackDefaults(pack, registryRoot, cwd) {
-    const packJsonPath = path_1.default.join(registryRoot, 'sensor-packs', pack, 'pack.json');
-    if (!fs_1.default.existsSync(packJsonPath))
+    const source = readResolvedPack(pack, registryRoot);
+    if (!source)
         return null;
     let parsed;
     try {
-        parsed = JSON.parse(fs_1.default.readFileSync(packJsonPath, 'utf-8'));
+        parsed = JSON.parse(source.content);
     }
     catch {
         return null;
@@ -174,7 +209,7 @@ function assertPackExists(pack, registryRoot) {
         throw new Error(`pack '${pack}' not found in registry (available: ${available.join(', ')})`);
     }
 }
-function initSensors(opts = {}) {
+async function initSensors(opts = {}) {
     const cwd = opts.cwd ?? process.cwd();
     const configure = opts.configure ?? true; // configure (copy pack config files) by default
     const manifestPath = path_1.default.join(cwd, '.awm', 'sensors.json');
@@ -192,15 +227,69 @@ function initSensors(opts = {}) {
         detection = detectStack(cwd);
     }
     let existing;
+    let existingV2;
     if (fs_1.default.existsSync(manifestPath)) {
+        let raw;
         try {
-            existing = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf-8'));
+            raw = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf-8'));
         }
-        catch { /* ignore corrupt manifest */ }
+        catch {
+            throw new Error(`cannot parse existing sensor manifest ${manifestPath}`);
+        }
+        // Never overwrite a corrupt or future-version manifest during init. Legacy
+        // manifests remain a supported migration input; v2 is validated before a new
+        // materialized selection becomes the commit point.
+        const parsed = (0, manifest_1.parseSensorManifest)(raw, manifestPath);
+        if (parsed.kind === 'legacy')
+            existing = parsed.pack;
+        else
+            existingV2 = parsed.pack;
     }
     // `detection` keeps saying what the tree IS; `pack` is what the registry can serve
     // for it. They diverge only when the registry lacks the detected pack.
     const { pack: resolvedPack, unavailablePack } = resolvePack(detection.pack, opts.registryRoot);
+    // v2 packs own the executable contract. Legacy packs deliberately retain the
+    // old string-command path below until a registry author publishes a v2 contract.
+    if (opts.registryRoot) {
+        const resolvedV2 = readV2Pack(resolvedPack, opts.registryRoot);
+        if (resolvedV2) {
+            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(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
+                // represented in the manifest so status/coverage can explain them,
+                // but run cannot accidentally dispatch a mismatched executable.
+                if (variant) {
+                    const prior = existing?.sensors[name] ?? existingV2?.sensors[name];
+                    // Legacy string commands cannot be translated into a shell-free
+                    // structured command without guessing. Preserve the operator's
+                    // enabled/fast intent but make that migration non-certified.
+                    const migratedOverride = existing?.sensors[name]?.cmd !== undefined;
+                    sensors[name] = {
+                        enabled: prior?.enabled ?? true,
+                        fast: prior?.fast ?? sensor.fast ?? false,
+                        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,
+                    };
+                }
+            }
+            const materialized = (0, materialize_1.materializeResolvedSensors)({
+                projectRoot: cwd, packRoot: resolvedV2.packRoot,
+                pack: resolvedPack, ...(packSelection ? { packSelection } : {}), registryRoot: opts.registryRoot, sensors, configure,
+            });
+            return { detection, ...materialized,
+                compatibility, ...(unavailablePack ? { unavailablePack } : {}) };
+        }
+    }
     const manifest = buildManifest(resolvedPack, existing, opts.registryRoot, cwd);
     fs_1.default.mkdirSync(path_1.default.join(cwd, '.awm'), { recursive: true });
     const tmpPath = manifestPath + '.tmp';

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

@@ -26,6 +26,8 @@ const changed_1 = require("./changed");
 // verbo de lectura: no debe tener a mano ninguna funcion capaz de mutar el proyecto.
 const init_1 = require("./init");
 const paths_1 = require("../../core/paths");
+const manifest_1 = require("./compatibility/manifest");
+const live_1 = require("./compatibility/live");
 const MANIFEST_FILE = '.awm/sensors.json';
 const DEFAULT_FAST_TIMEOUT = 10_000;
 const DEFAULT_SLOW_TIMEOUT = 120_000;
@@ -67,6 +69,28 @@ function readManifest(cwd) {
         return null;
     }
 }
+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, { packSelection: manifest.pack.packSelection });
+    }
+    catch {
+        return null;
+    }
+}
+async function runV2Sensor(name, command, timeout, cwd, formatter) {
+    const res = await (0, exec_1.runStructuredCommand)(command, { timeout, cwd, maxBuffer: MAX_BUFFER });
+    const format = getFormatter(name, formatter);
+    if (res.spawnError)
+        return { name, status: 'fail', errors: [{ message: `sensor could not be started: ${res.spawnError.message}` }] };
+    if (res.timedOut || res.overflowed)
+        return { name, status: 'inconclusive', errors: [], skipReason: res.timedOut ? `timeout after ${timeout}ms` : `output exceeded ${MAX_BUFFER} bytes` };
+    const errors = format(res.stdout + res.stderr);
+    if (res.code === 0)
+        return { name, status: errors.length ? 'fail' : 'pass', errors };
+    return errors.length ? { name, status: 'fail', errors } : { name, status: 'inconclusive', errors: [], skipReason: `exit ${res.code}` };
+}
 /**
  * Detect — and only detect — that the manifest's pack no longer describes the tree:
  * it sits on the `generic` fallback while real stack indicators (package.json,
@@ -105,6 +129,10 @@ function findManifestDir(startCwd) {
     while (true) {
         if (fs_1.default.existsSync(path_1.default.join(dir, MANIFEST_FILE)))
             return dir;
+        // Temp directories are test/scratch boundaries, never project ancestors.
+        // This prevents an unrelated /tmp/.awm from being adopted by a fresh project.
+        if (dir === path_1.default.resolve(os_1.default.tmpdir()))
+            return null;
         const parent = path_1.default.dirname(dir);
         if (parent === dir)
             return null; // reached filesystem root
@@ -282,6 +310,45 @@ async function runSensors(opts = {}) {
     const manifest = readManifest(manifestDir);
     if (!manifest)
         return { sensors: [], overall: 'not_certified' };
+    let parsedManifest;
+    try {
+        parsedManifest = (0, manifest_1.parseSensorManifest)(JSON.parse(fs_1.default.readFileSync(path_1.default.join(manifestDir, MANIFEST_FILE), 'utf8')), path_1.default.join(manifestDir, MANIFEST_FILE));
+    }
+    catch {
+        return { sensors: [], overall: 'not_certified' };
+    }
+    if (parsedManifest.kind === 'v2') {
+        const live = await resolveLiveV2(manifestDir, parsedManifest);
+        const tasks = [];
+        for (const [name, sensor] of Object.entries(parsedManifest.pack.sensors)) {
+            const state = live?.sensors[name];
+            const liveSensor = live?.pack.sensors[name];
+            if (!shouldRun(sensor.fast ?? liveSensor?.fast ?? false, opts))
+                continue;
+            if (sensor.enabled === false) {
+                tasks.push(() => Promise.resolve({ name, status: 'skipped', errors: [], skipReason: 'disabled' }));
+                continue;
+            }
+            if (!state || state.state !== 'certified') {
+                tasks.push(() => Promise.resolve({ name, status: 'inconclusive', errors: [], skipReason: state ? `${state.state}: ${state.reason}` : 'compatibility could not be revalidated' }));
+                continue;
+            }
+            if (state.variantId !== sensor.variantId) {
+                tasks.push(() => Promise.resolve({ name, status: 'inconclusive', errors: [], skipReason: `variant-drift: manifest ${sensor.variantId}, live ${state.variantId ?? 'none'}; run \`awm sensors init\`` }));
+                continue;
+            }
+            const selected = liveSensor?.variants.find(candidate => candidate.id === state.variantId);
+            if (!selected) {
+                tasks.push(() => Promise.resolve({ name, status: 'inconclusive', errors: [], skipReason: 'variant-drift: selected live variant has no command; run `awm sensors init`' }));
+                continue;
+            }
+            // Variant IDs are stable selectors, not immutable command snapshots.
+            // Only the just re-resolved pack command is authorized to execute.
+            tasks.push(() => runV2Sensor(name, selected.command, (sensor.fast ?? liveSensor?.fast ?? false) ? DEFAULT_FAST_TIMEOUT : DEFAULT_SLOW_TIMEOUT, manifestDir, selected.formatter));
+        }
+        const sensors = await pooled(tasks, Math.min(MAX_CONCURRENCY, Math.max(1, tasks.length)));
+        return { sensors, overall: sensors.some(sensor => sensor.status === 'fail') ? 'fail' : sensors.some(sensor => sensor.status === 'inconclusive') ? 'not_certified' : sensors.length ? 'pass' : 'skipped' };
+    }
     const drift = detectPackDrift(manifestDir, manifest);
     const activeManifest = manifest; // el manifest COMITEADO es lo que se corre; `run` no lo reescribe
     const cwd = manifestDir; // ejecutar sensores y baseline desde donde vive el manifest
@@ -382,6 +449,10 @@ async function runSensors(opts = {}) {
             : results.length > 0 && results.every(r => r.status === 'skipped') ? 'skipped'
                 : results.length === 0 ? 'skipped'
                     : 'pass';
+    // Legacy commands retain operational compatibility but their unversioned,
+    // shell-backed contract can never certify a run.
+    if (parsedManifest.kind === 'legacy' && overall === 'pass')
+        overall = 'not_certified';
     // Honest floor: a benign-green 'skipped' over a tree that clearly HAS a stack
     // (indicators present) is a false green — the gate ran nothing real. Never green.
     if (overall === 'skipped' && drift.detection.pack !== 'generic') {