agentic-workflow-manager 8.1.4 → 8.1.6

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

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpretResult = interpretResult;
+exports.executePrepared = executePrepared;
+exports.applyBaseline = applyBaseline;
+const exec_1 = require("./exec");
+const baseline_1 = require("./baseline");
+const tsc_1 = require("./formatters/tsc");
+const eslint_1 = require("./formatters/eslint");
+const semgrep_1 = require("./formatters/semgrep");
+const generic_1 = require("./formatters/generic");
+const test_1 = require("./formatters/test");
+const mypy_1 = require("./formatters/mypy");
+const ruff_1 = require("./formatters/ruff");
+const shellcheck_1 = require("./formatters/shellcheck");
+const MAX_BUFFER = 64 * 1024 * 1024;
+function formatterFor(name, formatter) {
+    if (formatter !== undefined) {
+        switch (formatter) {
+            case 'tsc': return tsc_1.parseTscOutput;
+            case 'eslint-llm': return eslint_1.parseEslintOutput;
+            case 'semgrep': return semgrep_1.parseSemgrepOutput;
+            case 'test': return test_1.parseTestOutput;
+            case 'mypy': return mypy_1.parseMypyOutput;
+            case 'ruff': return ruff_1.parseRuffOutput;
+            case 'shellcheck': return shellcheck_1.parseShellcheckOutput;
+            case 'generic': return generic_1.parseGenericOutput;
+            default: return generic_1.parseGenericOutput;
+        }
+    }
+    if (name === 'typecheck')
+        return tsc_1.parseTscOutput;
+    if (name === 'lint')
+        return eslint_1.parseEslintOutput;
+    if (name === 'security')
+        return semgrep_1.parseSemgrepOutput;
+    if (name === 'test')
+        return test_1.parseTestOutput;
+    return generic_1.parseGenericOutput;
+}
+function executionEvidence(prepared, elapsedMs) {
+    return {
+        timeoutMs: prepared.timeoutMs,
+        timeoutSource: prepared.timeoutSource,
+        elapsedMs,
+        requestedScope: prepared.requestedScope,
+        effectiveScope: prepared.effectiveScope,
+        ...(prepared.files !== undefined ? { files: prepared.files } : {}),
+        ...(prepared.scopeReason ? { scopeReason: prepared.scopeReason } : {}),
+    };
+}
+function validatePrepared(prepared) {
+    if (!prepared || typeof prepared !== 'object' || typeof prepared.name !== 'string' || prepared.name === '')
+        throw new Error('prepared sensor requires a nonempty name');
+    if (!Number.isSafeInteger(prepared.timeoutMs) || prepared.timeoutMs <= 0)
+        throw new Error('prepared sensor timeoutMs must be a positive safe integer');
+    if (!['project', 'pack', 'fallback'].includes(prepared.timeoutSource))
+        throw new Error('prepared sensor timeoutSource is invalid');
+    if (!['full', 'changed'].includes(prepared.requestedScope) || !['full', 'changed'].includes(prepared.effectiveScope))
+        throw new Error('prepared sensor scope is invalid');
+    if (prepared.files !== undefined && (!Number.isSafeInteger(prepared.files) || prepared.files < 0))
+        throw new Error('prepared sensor files must be a non-negative safe integer');
+    if (prepared.command !== undefined && (prepared.command.kind !== 'legacy' && prepared.command.kind !== 'structured'))
+        throw new Error('prepared sensor command kind is invalid');
+}
+function scoped(result, prepared) {
+    return {
+        ...result,
+        ...(prepared.effectiveScope === 'changed' ? { scope: 'changed' } : {}),
+    };
+}
+/** Interpret one raw bounded process result without knowing its manifest format. */
+function interpretResult(prepared, raw) {
+    validatePrepared(prepared);
+    if (!raw || typeof raw !== 'object' || !Number.isSafeInteger(raw.elapsedMs) || raw.elapsedMs < 0)
+        throw new Error('execution result requires a non-negative safe-integer elapsedMs');
+    const execution = executionEvidence(prepared, raw.elapsedMs);
+    const withEvidence = (result) => ({
+        ...result,
+        ...(prepared.effectiveScope === 'changed' ? { scope: 'changed' } : {}),
+        execution,
+    });
+    const format = formatterFor(prepared.name, prepared.formatter);
+    if (raw.spawnError)
+        return withEvidence({ name: prepared.name, status: 'fail', errors: [{ message: `sensor could not be started: ${raw.spawnError.message}` }] });
+    if (raw.timedOut || raw.overflowed) {
+        const reason = raw.timedOut ? `timeout after ${prepared.timeoutMs}ms` : `output exceeded ${MAX_BUFFER} bytes`;
+        const errors = format(raw.stdout + raw.stderr);
+        if (errors.length > 0)
+            return withEvidence({ name: prepared.name, status: 'fail', errors, incomplete: `${reason} — findings below are from partial output; the run did not finish` });
+        return withEvidence({ name: prepared.name, status: 'inconclusive', errors: [], skipReason: reason });
+    }
+    if (raw.code === 0) {
+        const errors = format(raw.stdout);
+        return withEvidence({ name: prepared.name, status: errors.length ? 'fail' : 'pass', errors });
+    }
+    const output = raw.stdout + raw.stderr;
+    const errors = format(output);
+    if (errors.length > 0)
+        return withEvidence({ name: prepared.name, status: 'fail', errors });
+    const lower = output.toLowerCase();
+    const toolMissing = raw.code === 127
+        || lower.includes('command not found')
+        || lower.includes('is not recognized as an internal or external command')
+        || lower.includes('enoent')
+        || lower.includes('could not determine executable');
+    if (toolMissing)
+        return withEvidence({ name: prepared.name, status: 'fail', errors: [{ message: `sensor tool not available: ${output.slice(0, 200)}` }] });
+    if (prepared.name === 'test')
+        return withEvidence({ name: prepared.name, status: 'fail', errors: [{ message: `SENSOR[${prepared.name}] failed (exit ${raw.code})` }] });
+    return withEvidence({ name: prepared.name, status: 'inconclusive', errors: [], skipReason: `exit ${raw.code}: ${output.slice(0, 200)}` });
+}
+/** Execute a validated prepared command, or render its deliberate synthetic result. */
+async function executePrepared(prepared, cwd = process.cwd()) {
+    validatePrepared(prepared);
+    if (prepared.syntheticStatus !== undefined || prepared.command === undefined) {
+        const status = prepared.syntheticStatus ?? 'inconclusive';
+        return scoped({
+            name: prepared.name,
+            status,
+            errors: [],
+            ...(prepared.syntheticReason ? { skipReason: prepared.syntheticReason } : {}),
+            execution: executionEvidence(prepared, 0),
+        }, prepared);
+    }
+    const options = { timeout: prepared.timeoutMs, cwd, maxBuffer: MAX_BUFFER };
+    const raw = prepared.command.kind === 'legacy'
+        ? await (0, exec_1.runCommand)(prepared.command.value, options)
+        : await (0, exec_1.runStructuredCommand)(prepared.command.value, options);
+    return interpretResult(prepared, raw);
+}
+/** Apply baseline suppression only to completed verdicts. */
+function applyBaseline(result, accepted) {
+    if (result.status === 'skipped' || result.status === 'inconclusive')
+        return result;
+    const { newErrors, suppressed } = (0, baseline_1.partition)(result.name, result.errors, accepted);
+    if (suppressed === 0)
+        return result;
+    return { ...result, errors: newErrors, status: newErrors.length > 0 ? 'fail' : 'pass', newCount: newErrors.length, baselineCount: suppressed };
+}

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

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyBaseline = applyBaseline;
+exports.applyBaseline = void 0;
 exports.detectPackDrift = detectPackDrift;
 exports.findManifestDir = findManifestDir;
 exports.resolveConcurrency = resolveConcurrency;
@@ -11,23 +11,17 @@ exports.runSensors = runSensors;
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
-const exec_1 = require("./exec");
-const tsc_1 = require("./formatters/tsc");
-const eslint_1 = require("./formatters/eslint");
-const semgrep_1 = require("./formatters/semgrep");
-const generic_1 = require("./formatters/generic");
-const test_1 = require("./formatters/test");
-const mypy_1 = require("./formatters/mypy");
-const ruff_1 = require("./formatters/ruff");
-const shellcheck_1 = require("./formatters/shellcheck");
 const baseline_1 = require("./baseline");
+const result_1 = require("./result");
+Object.defineProperty(exports, "applyBaseline", { enumerable: true, get: function () { return result_1.applyBaseline; } });
 const changed_1 = require("./changed");
 // Solo `detectStack` (puro, lee el arbol) — NO `initSensors`, que escribe. `run` es un
 // 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 prepare_1 = require("./prepare");
+const verdict_1 = require("./verdict");
 const MANIFEST_FILE = '.awm/sensors.json';
 const DEFAULT_FAST_TIMEOUT = 10_000;
 const DEFAULT_SLOW_TIMEOUT = 120_000;
@@ -37,38 +31,6 @@ const DEFAULT_SLOW_TIMEOUT = 120_000;
 const MAX_BUFFER = 64 * 1024 * 1024;
 /** Hard ceiling on parallel sensors: past this, they only contend for the same cores. */
 const MAX_CONCURRENCY = 4;
-/**
- * Apply the baseline to a sensor result: keep only findings not already accepted.
- * `status` becomes 'pass' when every finding was baseline-suppressed. Results
- * without a verdict of their own — skipped and inconclusive — are returned
- * untouched: there is nothing to ratchet, and letting them through here would
- * hand back a `pass` for a sensor that never reported anything.
- */
-function applyBaseline(result, accepted) {
-    if (result.status === 'skipped' || result.status === 'inconclusive')
-        return result;
-    const { newErrors, suppressed } = (0, baseline_1.partition)(result.name, result.errors, accepted);
-    if (suppressed === 0)
-        return result;
-    return {
-        ...result,
-        errors: newErrors,
-        status: newErrors.length > 0 ? 'fail' : 'pass',
-        newCount: newErrors.length,
-        baselineCount: suppressed,
-    };
-}
-function readManifest(cwd) {
-    const p = path_1.default.join(cwd, MANIFEST_FILE);
-    if (!fs_1.default.existsSync(p))
-        return null;
-    try {
-        return JSON.parse(fs_1.default.readFileSync(p, 'utf-8'));
-    }
-    catch {
-        return null;
-    }
-}
 async function resolveLiveV2(cwd, manifest) {
     if (manifest.kind !== 'v2')
         return null;
@@ -79,18 +41,6 @@ async function resolveLiveV2(cwd, manifest) {
         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,
@@ -142,137 +92,13 @@ function findManifestDir(startCwd) {
 function shouldRun(isFast, opts) {
     if (opts.all)
         return true;
-    if (opts.fast && isFast)
-        return true;
-    if (opts.slow && !isFast)
+    if (opts.fast && opts.slow)
         return true;
-    if (!opts.fast && !opts.slow && !opts.all)
-        return true;
-    return false;
-}
-/**
- * Dispatch by the pack's `formatter` field (the real tool behind the sensor slot —
- * `lint` is eslint on js-ts but ruff on python, shellcheck on shell) when present.
- * Manifests written before this field existed carry no `formatter`, so they fall back
- * to the pre-existing name-based dispatch — nothing already installed breaks.
- */
-function getFormatter(name, formatterField) {
-    // A `formatter` field that is PRESENT but unrecognized (a typo in a pack.json, or a
-    // future pack declaring a tool this CLI version doesn't know about yet) is a
-    // different situation from no field at all. Falling through to name-based dispatch
-    // in that case would silently misparse a foreign output shape via the wrong parser
-    // (e.g. a `bandit` formatter falling through to `parseSemgrepOutput`, reading
-    // bandit's differently-shaped JSON and producing garbage findings). Only the
-    // ABSENT case (old manifest, written before this field existed) gets name-based
-    // backward-compat dispatch; a present-but-unknown value degrades honestly to the
-    // generic raw-wrap formatter instead.
-    if (formatterField !== undefined) {
-        switch (formatterField) {
-            case 'tsc': return tsc_1.parseTscOutput;
-            case 'eslint-llm': return eslint_1.parseEslintOutput;
-            case 'semgrep': return semgrep_1.parseSemgrepOutput;
-            case 'test': return test_1.parseTestOutput;
-            case 'mypy': return mypy_1.parseMypyOutput;
-            case 'ruff': return ruff_1.parseRuffOutput;
-            case 'shellcheck': return shellcheck_1.parseShellcheckOutput;
-            case 'generic': return generic_1.parseGenericOutput;
-            default: return generic_1.parseGenericOutput;
-        }
-    }
-    if (name === 'typecheck')
-        return tsc_1.parseTscOutput;
-    if (name === 'lint')
-        return eslint_1.parseEslintOutput;
-    if (name === 'security')
-        return semgrep_1.parseSemgrepOutput;
-    if (name === 'test')
-        return test_1.parseTestOutput;
-    return generic_1.parseGenericOutput;
-}
-function isExitCodeSensor(name) {
-    return name === 'test';
-}
-async function runSensor(name, cmd, timeout, cwd, formatterField) {
-    const res = await (0, exec_1.runCommand)(cmd, { timeout, cwd, maxBuffer: MAX_BUFFER });
-    const format = getFormatter(name, formatterField);
-    // The shell itself never started (bad cwd, no shell). Nothing ran.
-    if (res.spawnError) {
-        return {
-            name,
-            status: 'fail',
-            errors: [{ message: `sensor could not be started: ${res.spawnError.message}` }],
-        };
-    }
-    // Cut short by the deadline or the output cap. The run is NOT a verdict — but
-    // whatever it printed before being cut is still evidence, and throwing it away
-    // is what forced the caller to re-run the same command by hand to learn
-    // anything. Findings in the partial output are real findings; their absence
-    // proves nothing, so a clean partial can never be `pass`.
-    if (res.timedOut || res.overflowed) {
-        const reason = res.timedOut
-            ? `timeout after ${timeout}ms`
-            : `output exceeded ${MAX_BUFFER} bytes`;
-        const errors = format(res.stdout + res.stderr);
-        if (errors.length > 0) {
-            return {
-                name,
-                status: 'fail',
-                errors,
-                incomplete: `${reason} — findings below are from partial output; the run did not finish`,
-            };
-        }
-        return { name, status: 'inconclusive', errors: [], skipReason: reason };
-    }
-    if (res.code === 0) {
-        const errors = format(res.stdout);
-        return { name, status: errors.length > 0 ? 'fail' : 'pass', errors };
-    }
-    // Non-zero exit — the normal path for linters/typecheckers that found
-    // findings. Parse the output; if it yields findings, that's a fail.
-    const raw = res.stdout + res.stderr;
-    const errors = format(raw);
-    if (errors.length > 0)
-        return { name, status: 'fail', errors };
-    // A missing tool (binary not installed) must NOT pass silently — the gate
-    // cannot certify what it could not run. Treat it as a fail with a clear message.
-    //
-    // Exit 127 is the POSIX signal for "command not found" and is the only check
-    // here that holds across shells and locales: bash writes `command not found`
-    // but dash — `/bin/sh` on Debian/Ubuntu, hence most CI runners and containers
-    // — writes `not found`, so matching shell text alone read an absent tool as a
-    // benign skip. A failure to spawn the shell itself is a different thing and
-    // is handled above via `spawnError`. The cut-short branches are evaluated
-    // above too, so reaching here with status 127 means the command did not exist.
-    //
-    // A wrapper (`npm test`, `npx …`) that exits 127 because a binary it invokes
-    // is absent is classified the same way, deliberately: the gate still ran
-    // nothing and still cannot certify anything.
-    const lower = raw.toLowerCase();
-    const toolMissing = res.code === 127 || // POSIX: command not found
-        lower.includes('command not found') || // bash, zsh
-        // cmd.exe reports an absent binary with exit 1, so 127 does not cover
-        // Windows; this exact phrase does. Kept narrow on purpose — a loose
-        // `not found` would also match a tool that ran and said "not found"
-        // for reasons of its own.
-        lower.includes('is not recognized as an internal or external command') ||
-        lower.includes('enoent') ||
-        lower.includes('could not determine executable');
-    if (toolMissing) {
-        return {
-            name,
-            status: 'fail',
-            errors: [{ message: `sensor tool not available: ${raw.slice(0, 200)}` }],
-        };
-    }
-    // Exit-code sensors (tests): any genuine non-zero exit is a real failure,
-    // even when no per-line findings can be parsed from the output.
-    if (isExitCodeSensor(name)) {
-        return { name, status: 'fail', errors: [{ message: `SENSOR[${name}] failed (exit ${res.code})` }] };
-    }
-    // Residual case: it exited non-zero, the tool exists, and no finding
-    // could be parsed. We do not know what happened — say so instead of
-    // reporting a benign skip.
-    return { name, status: 'inconclusive', errors: [], skipReason: `exit ${res.code}: ${raw.slice(0, 200)}` };
+    if (opts.fast)
+        return isFast;
+    if (opts.slow)
+        return !isFast;
+    return true;
 }
 /**
  * How many sensors may run at once. Sensors are separate processes over the same
@@ -302,170 +128,65 @@ async function pooled(tasks, limit) {
     await Promise.all(Array.from({ length: Math.min(limit, tasks.length) }, worker));
     return results;
 }
+/**
+ * One orchestration path for both manifest contracts. Preparation selects the
+ * authorized command; execution, baseline handling, and verdict reduction are
+ * deliberately format-agnostic.
+ */
 async function runSensors(opts = {}) {
-    const startCwd = opts.cwd ?? process.cwd();
-    const manifestDir = findManifestDir(startCwd);
+    (0, prepare_1.validateRunOptions)(opts);
+    const manifestDir = findManifestDir(opts.cwd ?? process.cwd());
     if (!manifestDir)
         return { sensors: [], overall: 'not_certified' };
-    const manifest = readManifest(manifestDir);
-    if (!manifest)
-        return { sensors: [], overall: 'not_certified' };
-    let parsedManifest;
+    let parsed;
     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));
+        parsed = (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
-    // Baseline suppresses already-accepted findings so sensors fail only on NEW
-    // ones (essential on repos with a large pre-existing baseline). Absent file or
-    // --ignore-baseline → every finding counts (backward-compatible).
-    const baseline = opts.ignoreBaseline ? null : (0, baseline_1.readBaseline)(cwd);
-    // A scoped run must never define the accepted set. `buildBaseline` snapshots the
-    // findings of the run it is given, so baselining a `--changed` run would write a
-    // baseline covering only the touched files and silently drop every accepted
-    // finding elsewhere in the repo — which then reports as NEW on the next full run.
-    // The two flags only ever meet by mistake, so refuse rather than pick a meaning.
-    if (opts.changed && opts.ignoreBaseline) {
-        throw new Error('refusing to combine --changed with a baseline capture: a partial run cannot define '
-            + 'the accepted set (it would drop every accepted finding outside the diff). '
-            + 'Run `awm sensors baseline` without --changed.');
-    }
-    // Resolved once for the whole run, not per sensor: `git` is cheap but the answer
-    // must be identical across sensors, or two of them scope to different file sets.
-    const changed = opts.changed ? (0, changed_1.changedFiles)(cwd, opts.base ?? 'HEAD') : null;
-    // Security (BatBadBut / CVE-2024-27980): on native Windows, `runCommand` spawns
-    // the sensor command through cmd.exe (`shell: true`), which parses `& | < > ^ %`
-    // as ITS OWN syntax before the target program ever sees argv — quoting does not
-    // reliably neutralize this layer (the primary research this fix is based on
-    // concludes escaping it is not safely possible). A changed filename carrying one
-    // of these is refused, not escaped: routed through the exact same fallback the
-    // module already has for "scope could not be resolved" (`changed.error`), so
-    // every sensor degrades to its full unscoped command rather than interpolating
-    // an unsafe path. POSIX is unaffected — single-quote quoting there is fully
-    // literal per POSIX shell grammar, no metacharacter exception exists.
-    if (changed && !changed.error && (0, paths_1.isWindowsNative)() && changed.files.some(changed_1.hasUnsafeWin32Chars)) {
-        changed.error = 'a changed filename contains a cmd.exe metacharacter (& | < > ^ % or newline/CR) '
-            + 'that quoting cannot reliably neutralize on native Windows — refusing to interpolate it, '
-            + 'falling back to the full unscoped command';
-    }
-    // Sensors are independent processes over the same tree, so they run
-    // concurrently rather than one-after-another: wall clock becomes the slowest
-    // sensor instead of the sum of all of them. Tasks are built — and dispatched —
-    // in manifest order, so the reported order stays stable.
-    const tasks = [];
-    const settled = (r) => () => Promise.resolve(r);
-    for (const [name, config] of Object.entries(activeManifest.sensors ?? {})) {
-        const isFast = config.fast ?? false;
-        if (!shouldRun(isFast, opts))
-            continue;
-        if (config.enabled === false) {
-            tasks.push(settled({ name, status: 'skipped', errors: [], skipReason: 'disabled' }));
-            continue;
-        }
-        if (!config.cmd) {
-            // Enabled but with nothing to run: broken config, not a deliberate
-            // opt-out. `enabled: false` is how a sensor is turned off.
-            tasks.push(settled({ name, status: 'inconclusive', errors: [], skipReason: 'no cmd configured' }));
+    const baseline = opts.ignoreBaseline ? null : (0, baseline_1.readBaseline)(manifestDir);
+    const changed = opts.changed ? (0, changed_1.changedFiles)(manifestDir, opts.base ?? 'HEAD') : null;
+    // Legacy commands pass changed filenames through a shell; preserve the native
+    // Windows safety fallback. Structured v2 argv never crosses that shell layer.
+    if (parsed.kind === 'legacy' && changed && !changed.error) {
+        const scopeError = (0, changed_1.changedScopeError)(changed);
+        if (scopeError)
+            changed.error = scopeError;
+    }
+    const live = parsed.kind === 'v2' ? await resolveLiveV2(manifestDir, parsed) : null;
+    const drift = parsed.kind === 'legacy' ? detectPackDrift(manifestDir, parsed.pack) : undefined;
+    const requestedScope = opts.changed ? 'changed' : 'full';
+    const prepared = [];
+    for (const [name, sensor] of Object.entries(parsed.pack.sensors)) {
+        const liveSensor = parsed.kind === 'v2' ? live?.pack.sensors[name] : undefined;
+        const fast = parsed.kind === 'v2'
+            ? sensor.fast ?? liveSensor?.fast ?? false
+            : sensor.fast ?? false;
+        if (!shouldRun(fast, opts))
             continue;
-        }
-        // Scoping applies only where the pack opted in AND the scope resolved. Any
-        // other combination falls back to the full command: slower, never wrong.
-        let cmd = config.cmd;
-        let scope;
-        if (changed && !changed.error && config.changedCmd) {
-            if (!config.changedCmd.includes('{files}')) {
-                // Running the template as-is would cover the whole repo while the
-                // result claimed to be scoped — a mislabel, not a slow path.
-                tasks.push(settled({
-                    name,
-                    status: 'inconclusive',
-                    errors: [],
-                    skipReason: 'changedCmd has no {files} placeholder',
-                }));
-                continue;
-            }
-            const inScope = (0, changed_1.filterByExtension)(changed.files, config.changedExtensions);
-            if (inScope.length === 0) {
-                tasks.push(settled({
-                    name,
-                    status: 'skipped',
-                    errors: [],
-                    skipReason: 'no changed files in scope',
-                    scope: 'changed',
-                }));
-                continue;
-            }
-            cmd = (0, changed_1.applyChangedCmd)(config.changedCmd, inScope);
-            scope = 'changed';
-        }
-        const timeout = config.timeout ?? (isFast ? DEFAULT_FAST_TIMEOUT : DEFAULT_SLOW_TIMEOUT);
-        tasks.push(async () => {
-            const result = await runSensor(name, cmd, timeout, cwd, config.formatter);
-            const scoped = scope ? { ...result, scope } : result;
-            return baseline ? applyBaseline(scoped, baseline[name]) : scoped;
-        });
-    }
-    const results = await pooled(tasks, resolveConcurrency(activeManifest, tasks.length));
-    // `fail` outranks `inconclusive`: when something is broken AND something
-    // could not be measured, the broken thing is the actionable verdict.
-    let overall = results.some(r => r.status === 'fail') ? 'fail'
-        : results.some(r => r.status === 'inconclusive') ? 'not_certified'
-            : 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')
+        const execution = parsed.kind === 'v2'
+            ? (0, prepare_1.prepareV2Sensor)({ name, sensor, liveSensor, liveState: live?.sensors[name], requestedScope, changed: changed ?? undefined })
+            : (0, prepare_1.prepareLegacySensor)({ name, config: sensor, requestedScope, changed: changed ?? undefined });
+        prepared.push(sensor.enabled === false
+            ? { ...execution, command: undefined, syntheticStatus: 'skipped', syntheticReason: 'disabled' }
+            : execution);
+    }
+    const results = await pooled(prepared.map(entry => async () => {
+        const result = await (0, result_1.executePrepared)(entry, manifestDir);
+        return baseline ? (0, result_1.applyBaseline)(result, baseline[entry.name]) : result;
+    }), resolveConcurrency(parsed.pack, prepared.length));
+    let overall = (0, verdict_1.reduceVerdict)(results);
+    // Legacy commands retain operational compatibility but their shell-backed
+    // contract cannot certify a green run.
+    if (parsed.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') {
+    if (overall === 'skipped' && drift && drift.detection.pack !== 'generic')
         overall = 'not_certified';
-    }
     return {
         sensors: results,
         overall,
-        ...(drift.drift ? { packDrift: drift.drift } : {}),
-        // Always emitted on a --changed run, including when the scope failed to
-        // resolve: a green that came back from an unscoped fallback and a green from a
-        // genuinely scoped run are different claims, and the caller cannot tell them
-        // apart from the sensor list alone.
+        ...(drift?.drift ? { packDrift: drift.drift } : {}),
         ...(changed ? { changedScope: { files: changed.files.length, ...(changed.error ? { error: changed.error } : {}) } } : {}),
     };
 }