agentic-workflow-manager 9.7.1 → 9.9.0

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

@@ -51,7 +51,7 @@ function declaration(mode, reason) {
     return { schemaVersion: 3, mode, reason };
 }
 function digest(bytes) { return (0, crypto_1.createHash)('sha256').update(bytes).digest('hex'); }
-async function projectSensors(projectRoot, registryRoot, requestedPack, packageRoot) {
+async function projectSensors(projectRoot, registryRoot, requestedPack, packageRoot, explicitPackSelection = requestedPack !== undefined) {
     const detectionRoot = packageRoot ? path_1.default.resolve(projectRoot, packageRoot) : projectRoot;
     const detected = (0, detection_1.detectStack)(detectionRoot);
     const pack = requestedPack ?? detected.pack;
@@ -76,7 +76,9 @@ async function projectSensors(projectRoot, registryRoot, requestedPack, packageR
         return { reason: 'source-unsupported', remedy: 'install-a-v2-sensor-pack' };
     let live;
     try {
-        live = await (0, live_1.resolveParsedPackCompatibility)(detectionRoot, parsed.pack);
+        live = explicitPackSelection
+            ? await (0, live_1.resolveParsedPackCompatibility)(detectionRoot, parsed.pack, { packSelection: 'explicit' })
+            : await (0, live_1.resolveParsedPackCompatibility)(detectionRoot, parsed.pack);
     }
     catch {
         return { reason: 'compatibility-unresolvable', remedy: 'repair-project-tools-or-select-another-mode' };
@@ -84,6 +86,8 @@ async function projectSensors(projectRoot, registryRoot, requestedPack, packageR
     const sensors = {};
     for (const [name, packSensor] of Object.entries(live.pack.sensors)) {
         const evidence = live.sensors[name];
+        if (evidence.state === 'not-applicable')
+            continue;
         const variant = evidence.variantId === null ? undefined : packSensor.variants.find(item => item.id === evidence.variantId);
         if (!variant)
             return { reason: 'sensor-variant-unresolvable', remedy: 'repair-project-tools-or-select-another-mode' };
@@ -109,8 +113,32 @@ async function planSensorBootstrap(cwd = process.cwd(), input = {}) {
             }
             return { kind: 'noop', projectRoot: project.projectRoot, manifestPath: project.manifestPath, changes: [], dryRun: opts.dryRun };
         }
-        if (project.manifest.kind === 'legacy')
-            return blocked(project.projectRoot, project.manifestPath, opts.dryRun, 'legacy-v1-preserved', 'migrate-the-manifest-explicitly');
+        if (project.manifest.kind === 'legacy') {
+            // Legacy manifests can carry arbitrary commands and per-sensor
+            // semantics that a v3 pack cannot prove equivalent. Replacing
+            // them is therefore a deliberate opt-in, never an automatic
+            // side effect of inspection or an unqualified bootstrap.
+            if (opts.mode !== 'project-sensors') {
+                return blocked(project.projectRoot, project.manifestPath, opts.dryRun, 'legacy-replacement-requires-project-sensors-mode', 'rerun-bootstrap-with-mode-project-sensors');
+            }
+            // The legacy pack name identifies the source to migrate, but must not
+            // activate v2 sensors which require an explicit project opt-in.
+            const planned = await projectSensors(project.projectRoot, opts.registryRoot, project.manifest.pack.pack, undefined, false);
+            if ('reason' in planned)
+                return blocked(project.projectRoot, project.manifestPath, opts.dryRun, planned.reason, planned.remedy, 'candidates' in planned ? planned.candidates : undefined);
+            try {
+                const original = fs_1.default.readFileSync(project.manifestPath);
+                return {
+                    kind: 'migrate', projectRoot: project.projectRoot, manifestPath: project.manifestPath,
+                    changes: planned.changes.map((change, index) => index === 0 ? { ...change, action: 'replace' } : change),
+                    dryRun: opts.dryRun, migration: { kind: 'legacy-v1', manifest: planned.manifest }, source: planned.source,
+                    originalDigest: digest(original),
+                };
+            }
+            catch {
+                return blocked(project.projectRoot, project.manifestPath, opts.dryRun, 'legacy-manifest-unreadable', 'repair-the-manifest-before-bootstrap');
+            }
+        }
         let source;
         try {
             source = (0, source_1.resolveSensorSource)(project.manifest, { registries: (0, registries_1.listRegistries)() });
@@ -152,7 +180,10 @@ function applySensorBootstrap(plan) {
         const current = fs_1.default.readFileSync(plan.manifestPath);
         if (digest(current) !== plan.originalDigest)
             throw new Error('bootstrap migration plan is stale: manifest changed after planning');
-        (0, migrate_2.replaceV2ManifestWithV3)(plan.manifestPath, plan.migration.candidate, plan.source);
+        if ('kind' in plan.migration)
+            (0, migrate_1.replaceLegacyManifestWithV3)(plan.manifestPath, plan.migration.manifest, plan.source);
+        else
+            (0, migrate_2.replaceV2ManifestWithV3)(plan.manifestPath, plan.migration.candidate, plan.source);
         return 'migrated';
     }
     if (plan.manifest.mode === 'project-sensors') {

package/dist/src/commands/sensors/compatibility/contract.js

@@ -216,10 +216,21 @@ function parseVariant(input, source, location) {
     if (semver_1.default.validRange(toolRange) === null || semver_1.default.validRange(runtimeRange) === null)
         invalid(source, `${location}.requirements ranges must be valid semver ranges`);
     const probe = policy ? undefined : record(value.probe, source, `${location}.probe`);
+    let probeScript;
     if (probe) {
-        fields(probe, ['kind'], source, `${location}.probe`);
+        fields(probe, ['kind', 'script'], source, `${location}.probe`);
         if (typeof probe.kind !== 'string' || !ALLOWED_PROBES.has(probe.kind))
             invalid(source, `${location}.probe.kind must be an allowed probe`);
+        // Historical schema-v2 packs remain readable. An unnamed probe cannot
+        // certify compatibility; the probe runner rejects it as unverifiable.
+        if (probe.kind === 'package-script-present' && 'script' in probe) {
+            probeScript = text(probe.script, source, `${location}.probe.script`);
+            if (!/^[A-Za-z0-9][A-Za-z0-9:_-]*$/.test(probeScript))
+                invalid(source, `${location}.probe.script must be a package script name`);
+        }
+        else if (probe.kind !== 'package-script-present' && 'script' in probe) {
+            invalid(source, `${location}.probe.script is only valid for package-script-present`);
+        }
     }
     const changedCommand = 'changedCommand' in value ? parseStructuredCommand(value.changedCommand, source) : undefined;
     if (changedCommand && !changedCommand.fileInput)
@@ -234,7 +245,7 @@ function parseVariant(input, source, location) {
                         invalid(source, `${location}.requirements.packageJsonFields[${index}] must be a stable package.json field`); return field; }) } : {}) },
         assets: assetArray(value.assets, source, `${location}.assets`, true),
         formatter: text(value.formatter, source, `${location}.formatter`),
-        probe: { kind: policy?.probe ?? probe.kind },
+        probe: { kind: policy?.probe ?? probe.kind, ...(probeScript ? { script: probeScript } : {}) },
         ...(policy ? { policyRef: SEMGREP_POLICY_REF } : {}),
         command: parseStructuredCommand(value.command, source),
         ...(changedCommand ? { changedCommand } : {}),
@@ -295,8 +306,12 @@ function parseSensor(input, source, location, variantIds) {
         applicability.allFiles = stringArray(applicabilityInput.allFiles, source, `${location}.applicability.allFiles`).map((file, index) => asset(file, source, `${location}.applicability.allFiles[${index}]`));
     if ('anyFiles' in applicabilityInput)
         applicability.anyFiles = stringArray(applicabilityInput.anyFiles, source, `${location}.applicability.anyFiles`).map((file, index) => asset(file, source, `${location}.applicability.anyFiles[${index}]`));
-    if ('kind' in applicabilityInput)
-        applicability.kind = text(applicabilityInput.kind, source, `${location}.applicability.kind`);
+    if ('kind' in applicabilityInput) {
+        const kind = text(applicabilityInput.kind, source, `${location}.applicability.kind`);
+        if (kind !== 'explicit-or-supported-language' && kind !== 'explicit-opt-in')
+            invalid(source, `${location}.applicability.kind must be a supported applicability kind`);
+        applicability.kind = kind;
+    }
     if (Object.keys(applicability).length === 0)
         invalid(source, `${location}.applicability must declare a condition`);
     if ('fast' in value && typeof value.fast !== 'boolean')

package/dist/src/commands/sensors/compatibility/discovery.js

@@ -176,6 +176,7 @@ function discoverProjectEvidence(cwd, pack, dependencies = {}) {
     const declaredManager = typeof pkg?.packageManager === 'string' ? pkg.packageManager.split('@')[0] : null;
     if (declaredManager)
         lockManagers.add(declaredManager);
+    const packageManager = declaredManager ?? (lockManagers.size === 1 ? [...lockManagers][0] : null);
     const configCandidates = new Set(COMMON_CONFIGS);
     if ('schemaVersion' in pack) {
         for (const marker of pack.detects)
@@ -193,16 +194,35 @@ function discoverProjectEvidence(cwd, pack, dependencies = {}) {
     const packageJsonFields = Object.keys(pkg ?? {}).filter(field => /^[A-Za-z][A-Za-z0-9]*$/.test(field)).sort();
     const declaredToolRanges = { ...stringMap(pkg?.dependencies), ...stringMap(pkg?.devDependencies), ...stringMap(pkg?.peerDependencies) };
     const tools = new Set();
+    const pathTools = new Set();
     if ('schemaVersion' in pack)
         for (const sensor of Object.values(pack.sensors))
-            for (const variant of sensor.variants)
+            for (const variant of sensor.variants) {
                 tools.add(variant.requirements.tool);
+                if (variant.command?.resolution === 'path' && variant.command.packageManager === variant.requirements.tool)
+                    pathTools.add(variant.requirements.tool);
+            }
     const environment = pythonEnvironment(root);
     const sitePackages = environment ? pythonSitePackages(root, environment.rootParts, targetPlatform) : [];
-    const toolVersions = Object.fromEntries([...tools].sort().map(tool => [tool, pythonToolVersion(root, sitePackages, tool) ?? installedPackageVersion(root, tool)]));
+    const toolVersions = {};
+    const toolProvenance = {};
+    for (const tool of [...tools].sort()) {
+        if (pathTools.has(tool) && packageManager === tool) {
+            // Discovery/status is read-only. A PATH executable is not inspected or
+            // executed here; callers that already possess trusted runtime evidence
+            // may inject it explicitly for an execution-time compatibility check.
+            toolVersions[tool] = exactVersion(dependencies.pathToolVersion?.(tool) ?? null);
+            toolProvenance[tool] = toolVersions[tool] === null ? null : 'path';
+        }
+        else {
+            const pythonVersion = pythonToolVersion(root, sitePackages, tool);
+            toolVersions[tool] = pythonVersion ?? installedPackageVersion(root, tool);
+            toolProvenance[tool] = pythonVersion ? 'python-environment' : toolVersions[tool] ? 'node-modules-bin' : null;
+        }
+    }
     return {
         cwd: root, os: targetPlatform, runtimeVersions: { node: process.versions.node ?? null, ...(environment ? { python: environment.runtimeVersion } : {}) }, pythonEnvironmentRoot: environment?.rootParts[0] ?? null, declaredToolRanges, toolVersions,
-        packageManager: declaredManager ?? (lockManagers.size === 1 ? [...lockManagers][0] : null), packageManagerConflict: lockManagers.size > 1,
+        toolProvenance, packageManager, packageManagerConflict: lockManagers.size > 1,
         scripts, configFiles, packageJsonFields, paths: [...new Set([...(safeFile(root, 'package.json') ? ['package.json'] : []), ...locks, ...configFiles])].sort(),
     };
 }

package/dist/src/commands/sensors/compatibility/live.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.bindContainedRuntimeCommands = bindContainedRuntimeCommands;
 exports.resolveLiveCompatibility = resolveLiveCompatibility;
 exports.resolveParsedPackCompatibility = resolveParsedPackCompatibility;
 const pack_source_1 = require("./pack-source");
@@ -11,6 +12,22 @@ const discovery_1 = require("./discovery");
 const resolve_1 = require("./resolve");
 const probe_1 = require("./probe");
 const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const semver_1 = __importDefault(require("semver"));
+/** Execution-time evidence only. Status/discovery never invokes this resolver. */
+function pathPackageManagerVersion(tool) {
+    if (!['npm', 'pnpm', 'yarn', 'bun'].includes(tool))
+        return null;
+    try {
+        const result = (0, child_process_1.spawnSync)(tool, ['--version'], { cwd: process.cwd(), shell: false, encoding: 'utf8', timeout: 5_000, maxBuffer: 1024, windowsHide: true, stdio: 'pipe' });
+        if (result.error || result.status !== 0 || result.signal || typeof result.stdout !== 'string' || result.stdout.length > 256)
+            return null;
+        return semver_1.default.valid(result.stdout.trim());
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Python package metadata is evidence only for a contained virtual environment.
  * A v2 command that names a Python-runtime tool must therefore resolve through
@@ -68,7 +85,7 @@ async function resolveParsedPackCompatibility(cwd, pack, options = {}) {
         throw new Error('cwd must be a non-empty path');
     if (!pack || typeof pack !== 'object' || pack.schemaVersion !== 2)
         throw new Error('pack must be a parsed v2 sensor pack');
-    const evidence = (0, discovery_1.discoverProjectEvidence)(cwd, pack);
+    const evidence = (0, discovery_1.discoverProjectEvidence)(cwd, pack, { pathToolVersion: pathPackageManagerVersion });
     const executionPack = bindContainedRuntimeCommands(pack, evidence.pythonEnvironmentRoot);
     const resolutionEvidence = { ...evidence, ...(options.packSelection === 'explicit' ? { packSelection: 'explicit' } : {}) };
     const initial = (0, resolve_1.resolveProjectCompatibility)(executionPack, resolutionEvidence).sensors;

package/dist/src/commands/sensors/compatibility/probe.js

@@ -48,8 +48,14 @@ async function runCompatibilityProbe(probe, evidence, executor = exec_1.runStruc
         throw new Error('compatibility probe kind must be allowed');
     if (!evidence || typeof evidence.cwd !== 'string' || evidence.cwd.trim() === '')
         throw new Error('probe evidence requires cwd');
-    if (probe.kind === 'package-script-present')
-        return { status: (evidence.scripts?.length ?? 0) > 0 ? 'matched' : 'not-matched', reason: 'package-script' };
+    if (probe.kind === 'package-script-present') {
+        const script = probe.script;
+        if (!Object.prototype.hasOwnProperty.call(probe, 'script'))
+            return { status: 'unverifiable', reason: 'package-script-name-required' };
+        if (typeof script !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9:_-]*$/.test(script))
+            throw new Error('package-script-present probe requires a named package script');
+        return { status: evidence.scripts?.includes(script) ? 'matched' : 'not-matched', reason: 'package-script' };
+    }
     if (probe.kind === 'config-present')
         return { status: (evidence.configFiles?.length ?? 0) > 0 ? 'matched' : 'not-matched', reason: 'config-file' };
     try {

package/dist/src/commands/sensors/compatibility/resolve.js

@@ -26,7 +26,7 @@ function result(state, reason, variant, evidence) {
     return { state, reason, variantId: variant?.id ?? null, toolVersion, runtimeVersion, certifiedRange: variant?.certifiedRange ?? null, evidence: refs.slice(0, 32) };
 }
 function applies(sensor, evidence) {
-    if (sensor.applicability.kind === 'explicit-or-supported-language') {
+    if (sensor.applicability.kind === 'explicit-or-supported-language' || sensor.applicability.kind === 'explicit-opt-in') {
         return evidence.applicable === true || evidence.packSelection === 'explicit';
     }
     if (evidence.applicable === false)
@@ -40,7 +40,10 @@ function specificity(variant) {
 }
 function validVersion(value) { return typeof value === 'string' && semver_1.default.valid(value) !== null; }
 function toolFor(variant, evidence) {
-    return evidence.toolVersions === undefined ? evidence.toolVersion : evidence.toolVersions[variant.requirements.tool];
+    const tool = variant.requirements.tool;
+    const version = evidence.toolVersions === undefined ? evidence.toolVersion : evidence.toolVersions[tool];
+    const provenance = evidence.toolProvenance?.[tool];
+    return provenance !== undefined && provenance !== null && provenance !== variant.command.resolution ? null : version;
 }
 function runtimeFor(variant, evidence) {
     return evidence.runtimeVersions === undefined ? evidence.runtimeVersion : evidence.runtimeVersions[variant.requirements.runtime];

package/dist/src/commands/sensors/coverage/evidence.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.observeDetector = observeDetector;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const native_bridge_1 = require("../../../core/secure-fs/native-bridge");
 const contract_1 = require("./contract");
 const realIo = {
     lstatSync: fs_1.default.lstatSync,
@@ -39,23 +40,31 @@ function inspectFile(root, relative, markers, io) {
         return { status: 'unverifiable', evidence: [{ kind: 'file', path: relative, status: 'unverifiable' }] };
     }
     const noFollow = fs_1.default.constants.O_NOFOLLOW;
-    if (typeof noFollow !== 'number') {
+    if (typeof noFollow !== 'number' && io !== realIo) {
         return { status: 'unverifiable', evidence: [{ kind: 'file', path: relative, status: 'unverifiable' }] };
     }
     let fd;
     let content;
     try {
-        fd = (io.openSync ?? realIo.openSync)(absolute, fs_1.default.constants.O_RDONLY | noFollow);
-        const opened = (io.fstatSync ?? realIo.fstatSync)(fd);
-        if (!opened.isFile() || opened.size > contract_1.MAX_COVERAGE_FILE_BYTES) {
-            return { status: 'unverifiable', evidence: [{ kind: 'file', path: relative, status: 'unverifiable' }] };
+        if (typeof noFollow !== 'number') {
+            // Windows has no O_NOFOLLOW. Its native descriptor-anchored read
+            // rejects reparse points in every ancestor and preserves identity.
+            // Never replace an injected IO boundary with this native trust.
+            content = native_bridge_1.secureFs.readRegularFile(absolute, contract_1.MAX_COVERAGE_FILE_BYTES).bytes.toString('utf8');
         }
-        const buffer = Buffer.allocUnsafe(contract_1.MAX_COVERAGE_FILE_BYTES + 1);
-        const bytesRead = (io.readSync ?? realIo.readSync)(fd, buffer, 0, buffer.length, null);
-        if (!Number.isSafeInteger(bytesRead) || bytesRead < 0 || bytesRead > contract_1.MAX_COVERAGE_FILE_BYTES) {
-            return { status: 'unverifiable', evidence: [{ kind: 'file', path: relative, status: 'unverifiable' }] };
+        else {
+            fd = (io.openSync ?? realIo.openSync)(absolute, fs_1.default.constants.O_RDONLY | noFollow);
+            const opened = (io.fstatSync ?? realIo.fstatSync)(fd);
+            if (!opened.isFile() || opened.size > contract_1.MAX_COVERAGE_FILE_BYTES) {
+                return { status: 'unverifiable', evidence: [{ kind: 'file', path: relative, status: 'unverifiable' }] };
+            }
+            const buffer = Buffer.allocUnsafe(contract_1.MAX_COVERAGE_FILE_BYTES + 1);
+            const bytesRead = (io.readSync ?? realIo.readSync)(fd, buffer, 0, buffer.length, null);
+            if (!Number.isSafeInteger(bytesRead) || bytesRead < 0 || bytesRead > contract_1.MAX_COVERAGE_FILE_BYTES) {
+                return { status: 'unverifiable', evidence: [{ kind: 'file', path: relative, status: 'unverifiable' }] };
+            }
+            content = buffer.subarray(0, bytesRead).toString('utf8');
         }
-        content = buffer.subarray(0, bytesRead).toString('utf8');
     }
     catch {
         return { status: 'unverifiable', evidence: [{ kind: 'file', path: relative, status: 'unverifiable' }] };

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

@@ -12,6 +12,7 @@ const manifest_1 = require("../compatibility/manifest");
 const scan_1 = require("../../../core/ledger/scan");
 const empirical_1 = require("./empirical");
 const path_1 = __importDefault(require("path"));
+const project_1 = require("../project");
 const defaults = { resolve: resolve_1.resolveCoverageInputs, observe: evidence_1.observeDetector, resolveLive: live_1.resolveLiveCompatibility, scan: scan_1.scanProjectLedgers };
 function normalizedMin(value) {
     if (value === undefined)
@@ -34,13 +35,21 @@ async function runCoverage(cwd, dependencies = {}, options = {}) {
         return { schemaVersion: 2, pack: null, registry: null, overall: 'inconclusive', static: { status: 'inconclusive', reason: 'not_configured', classes: [] },
             empirical: empirical(deps, path_1.default.resolve(cwd), {}, min, 'unavailable') };
     }
+    const packageRoot = input.manifest.kind !== 'legacy' && input.manifest.pack.packageRoot
+        ? (() => {
+            const project = (0, project_1.resolveSensorProject)(input.projectRoot);
+            if (project.state !== 'configured')
+                throw new Error(`runCoverage: packageRoot cannot be resolved: ${project.state === 'invalid' ? project.reason : 'manifest missing'}`);
+            return project.packageRoot;
+        })()
+        : input.projectRoot;
     if (input.kind === 'no_reference') {
         return { schemaVersion: 2, pack: input.pack, registry: input.registry, overall: 'inconclusive', static: { status: 'inconclusive', reason: 'no_reference', classes: [] },
             empirical: empirical(deps, input.projectRoot, {}, min, 'unavailable') };
     }
     let live;
     if (input.manifest.kind !== 'legacy') {
-        live = (await deps.resolveLive(input.projectRoot, input.pack, input.registryRoot)).sensors;
+        live = (await deps.resolveLive(packageRoot, input.pack, input.registryRoot)).sensors;
     }
     else {
         live = Object.fromEntries(Object.keys(input.manifest.pack.sensors).map((name) => [name, (0, manifest_1.legacyCompatibility)('legacy manifest without schemaVersion')]));
@@ -48,7 +57,7 @@ async function runCoverage(cwd, dependencies = {}, options = {}) {
     const observations = [];
     for (const [classId, coverageClass] of Object.entries(input.contract.classes)) {
         coverageClass.detectors.forEach((detector, detectorIndex) => {
-            const observed = deps.observe(input.projectRoot, classId, detectorIndex, detector, input.manifest.pack.sensors[detector.sensor]);
+            const observed = deps.observe(packageRoot, classId, detectorIndex, detector, input.manifest.pack.sensors[detector.sensor]);
             observations.push({
                 ...observed,
                 compatibility: live[detector.sensor] ?? {

package/dist/src/commands/sensors/coverage/resolve.js

@@ -70,6 +70,16 @@ function findManifestDirNoFollow(startCwd) {
             if (error.code !== 'ENOENT')
                 throw readFailure(manifestPath, error);
         }
+        const gitMarker = path_1.default.join(dir, '.git');
+        try {
+            const marker = fs_1.default.lstatSync(gitMarker);
+            if (marker.isFile() || marker.isDirectory())
+                return null;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw readFailure(gitMarker, error);
+        }
         const parent = path_1.default.dirname(dir);
         if (parent === dir)
             return null;

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

@@ -98,6 +98,20 @@ function validateOptions(opts) {
     if (opts.killGraceMs !== undefined && (!Number.isSafeInteger(opts.killGraceMs) || opts.killGraceMs < 0))
         throw new Error('exec options killGraceMs must be a non-negative safe integer');
 }
+/** Run sensor commands with the same Node runtime that launched AWM. Package
+ * manager wrappers resolve `node` through PATH, so an older inherited Node can
+ * otherwise run a sensor even when the CLI itself is running on a supported
+ * runtime. Keep every inherited entry after the runtime directory: tools and
+ * project-local shims remain available to the child. */
+function sensorEnvironment(inputEnvironment) {
+    const runtimeDir = path_1.default.dirname(process.execPath);
+    const inheritedPath = process.env.PATH;
+    return {
+        ...process.env,
+        PATH: inheritedPath ? `${runtimeDir}${path_1.default.delimiter}${inheritedPath}` : runtimeDir,
+        ...inputEnvironment,
+    };
+}
 function collectSpawn(input, opts) {
     validateOptions(opts);
     const maxBuffer = opts.maxBuffer ?? DEFAULT_MAX_BUFFER;
@@ -164,6 +178,7 @@ function collectSpawn(input, opts) {
                 shell: true,
                 cwd: opts.cwd,
                 detached: !(0, paths_1.isWindowsNative)(),
+                env: sensorEnvironment(input.environment),
                 stdio: ['ignore', 'pipe', 'pipe'],
             })
             : (0, child_process_1.spawn)(prlimit ?? input.executable, prlimit
@@ -172,7 +187,7 @@ function collectSpawn(input, opts) {
                 shell: false,
                 cwd: opts.cwd,
                 detached: !(0, paths_1.isWindowsNative)(),
-                ...(input.environment ? { env: { ...process.env, ...input.environment } } : {}),
+                env: sensorEnvironment(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: prlimit ? ['ignore', stdoutFd, stderrFd] : ['ignore', 'pipe', 'pipe'],

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

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.planV2Migration = planV2Migration;
 exports.replaceV2ManifestWithV3 = replaceV2ManifestWithV3;
+exports.replaceLegacyManifestWithV3 = replaceLegacyManifestWithV3;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const contract_1 = require("./compatibility/contract");
@@ -67,7 +68,7 @@ function exactLogicalSource(input, pack) {
         throw new Error('v2 migration source must contain an exact resolved pack');
     let parsedSource;
     try {
-        parsedSource = (0, contract_1.parseSensorPack)(JSON.parse(source.content), 'v2 migration resolved source');
+        parsedSource = (0, contract_1.parseSensorPack)(JSON.parse(source.content), source.path);
     }
     catch {
         throw new Error('v2 migration source exact v2 pack is invalid');
@@ -79,7 +80,7 @@ function exactLogicalSource(input, pack) {
 function assertSourceCompatibleWithManifest(source, manifest) {
     let parsedSource;
     try {
-        parsedSource = (0, contract_1.parseSensorPack)(JSON.parse(source.content), 'v2 migration resolved source');
+        parsedSource = (0, contract_1.parseSensorPack)(JSON.parse(source.content), source.path);
     }
     catch {
         throw new Error('v2 migration source exact v2 pack is invalid');
@@ -94,6 +95,23 @@ function assertSourceCompatibleWithManifest(source, manifest) {
         }
     }
 }
+function assertSourceCompatibleWithCandidate(source, candidate) {
+    let parsedSource;
+    try {
+        parsedSource = (0, contract_1.parseSensorPack)(JSON.parse(source.content), source.path);
+    }
+    catch {
+        throw new Error('legacy migration source exact v2 pack is invalid');
+    }
+    if (parsedSource.kind !== 'v2' || parsedSource.pack.name !== candidate.pack) {
+        throw new Error('legacy migration source must contain the exact v2 pack');
+    }
+    for (const [name, sensor] of Object.entries(candidate.sensors)) {
+        if (!parsedSource.pack.sensors[name]?.variants.some(variant => variant.id === sensor.variantId)) {
+            throw new Error('legacy migration source is not compatible with selected manifest sensors');
+        }
+    }
+}
 function hasPhysicalSensorPath(value, registryRoots) {
     if (typeof value === 'string') {
         const normalized = path_1.default.posix.normalize(value.replace(/\\/g, '/')).toLowerCase();
@@ -207,3 +225,45 @@ function replaceV2ManifestWithV3(manifestPath, candidate, source) {
         });
     });
 }
+/**
+ * Replace an explicitly bootstrapped legacy manifest with the v3 declaration
+ * selected from one current logical pack. Legacy commands have no structured
+ * variant identity, so equivalence cannot be asserted; the caller must have
+ * re-probed every selected v3 sensor before this fenced publication.
+ */
+function replaceLegacyManifestWithV3(manifestPath, candidate, source) {
+    if (typeof manifestPath !== 'string' || !path_1.default.isAbsolute(manifestPath) || path_1.default.normalize(manifestPath) !== manifestPath
+        || manifestPath.includes('\0') || path_1.default.basename(manifestPath) !== 'sensors.json'
+        || path_1.default.basename(path_1.default.dirname(manifestPath)) !== '.awm') {
+        throw new Error('legacy migration manifest path must be the canonical project manifest <project>/.awm/sensors.json');
+    }
+    const manifestDirectory = path_1.default.dirname(manifestPath);
+    const projectRoot = path_1.default.dirname(manifestDirectory);
+    (0, safe_file_1.withProjectLease)(projectRoot, () => {
+        const originalFailure = (_reason) => new Error('legacy migration original manifest must be readable JSON');
+        let inspected;
+        let original;
+        try {
+            inspected = inspectManifest(manifestPath, originalFailure);
+            original = JSON.parse(inspected.content.toString('utf8'));
+        }
+        catch {
+            throw new Error('legacy migration original manifest must be readable JSON');
+        }
+        const before = (0, manifest_1.parseSensorManifest)(original, manifestPath);
+        const after = (0, manifest_1.parseSensorManifest)(candidate, 'legacy migration candidate');
+        if (before.kind !== 'legacy' || after.kind !== 'v3' || after.pack.mode !== 'project-sensors') {
+            throw new Error('legacy migration candidate semantic mismatch');
+        }
+        const logicalSource = exactLogicalSource({ kind: 'logical', source }, after.pack.pack);
+        assertSourceCompatibleWithCandidate(logicalSource, after.pack);
+        if (after.pack.source.registry !== logicalSource.registry.name || hasPhysicalSensorPath(after.pack.sensors, [logicalSource.registry.contentRoot])
+            || hasPhysicalSensorPath(after.pack.packageRoot, [])) {
+            throw new Error('legacy migration candidate contains an unsafe source or physical path');
+        }
+        assertManifestUnchanged(manifestPath, inspected);
+        (0, safe_file_1.writeProjectFile)(projectRoot, '.awm/sensors.json', Buffer.from((0, manifest_1.serializeManifestV3)(after.pack), 'utf8'), {
+            mode: 'replace', expected: inspected.content, expectedIdentity: inspected.identity, createParents: false,
+        });
+    });
+}

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

@@ -30,6 +30,8 @@ function validateRunOptions(opts) {
         throw new Error('run option ignoreBaseline must be a boolean');
     if (opts.base !== undefined && (typeof opts.base !== 'string' || opts.base.trim() === ''))
         throw new Error('run option base must be a nonempty string');
+    if (opts.readOnly !== undefined && typeof opts.readOnly !== 'boolean')
+        throw new Error('run option readOnly must be a boolean');
     if (opts.changed && opts.ignoreBaseline) {
         throw new Error('refusing to combine --changed with a baseline capture: a partial run cannot define the accepted set');
     }

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

@@ -91,6 +91,8 @@ function interpretResult(prepared, raw) {
         return withEvidence({ name: prepared.name, status: 'inconclusive', errors: [], skipReason: reason });
     }
     if (raw.code === 0) {
+        if (format === generic_1.parseGenericOutput)
+            return withEvidence({ name: prepared.name, status: 'pass', errors: [] });
         const errors = format(raw.stdout);
         return withEvidence({ name: prepared.name, status: errors.length ? 'fail' : 'pass', errors });
     }

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

@@ -8,8 +8,10 @@ exports.findManifestDir = findManifestDir;
 exports.detectPackDrift = detectPackDrift;
 exports.resolveConcurrency = resolveConcurrency;
 exports.runSensors = runSensors;
+const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
 const baseline_1 = require("./baseline");
 const result_1 = require("./result");
 Object.defineProperty(exports, "applyBaseline", { enumerable: true, get: function () { return result_1.applyBaseline; } });
@@ -30,6 +32,59 @@ const project_1 = require("./project");
 const MAX_BUFFER = 64 * 1024 * 1024;
 /** Hard ceiling on parallel sensors: past this, they only contend for the same cores. */
 const MAX_CONCURRENCY = 4;
+const READ_ONLY_MAX_ENTRIES = 250_000;
+const READ_ONLY_MAX_BYTES = 1024 * 1024 * 1024;
+/**
+ * A git status only sees tracked and non-ignored paths, while a sensor can
+ * mutate ignored runtime files (notably `.awm/`) just as easily. Hash the
+ * actual project tree instead. The scan is deliberately bounded: inability to
+ * observe the whole declared project means no admission certificate.
+ */
+function filesystemSnapshot(root) {
+    try {
+        const digest = crypto_1.default.createHash('sha256');
+        let entriesSeen = 0;
+        let bytesSeen = 0;
+        const visit = (directory, relative) => {
+            const entries = fs_1.default.readdirSync(directory, { withFileTypes: true })
+                .sort((left, right) => left.name.localeCompare(right.name));
+            for (const entry of entries) {
+                // Git's internal bookkeeping changes as a consequence of normal
+                // observation, not project sensor execution. Everything else,
+                // including ignored/untracked `.awm`, is evidence-relevant.
+                if (relative === '' && entry.name === '.git')
+                    continue;
+                if (++entriesSeen > READ_ONLY_MAX_ENTRIES)
+                    throw new Error('snapshot-entry-limit');
+                const child = path_1.default.join(directory, entry.name);
+                const childRelative = relative === '' ? entry.name : `${relative}/${entry.name}`;
+                const stat = fs_1.default.lstatSync(child);
+                digest.update(`${childRelative}\0${stat.mode}\0${stat.size}\0`);
+                if (stat.isDirectory()) {
+                    digest.update('directory\0');
+                    visit(child, childRelative);
+                }
+                else if (stat.isFile()) {
+                    if ((bytesSeen += stat.size) > READ_ONLY_MAX_BYTES)
+                        throw new Error('snapshot-byte-limit');
+                    digest.update('file\0');
+                    digest.update(fs_1.default.readFileSync(child));
+                }
+                else if (stat.isSymbolicLink()) {
+                    digest.update(`symlink\0${fs_1.default.readlinkSync(child)}\0`);
+                }
+                else {
+                    digest.update(`special\0${stat.rdev}\0`);
+                }
+            }
+        };
+        visit(root, '');
+        return digest.digest('hex');
+    }
+    catch {
+        return null;
+    }
+}
 async function resolveLiveFromSource(cwd, source, packSelection) {
     try {
         const parsed = (0, contract_1.parseSensorPack)(JSON.parse(source.content), source.path);
@@ -141,6 +196,10 @@ async function runSensors(opts = {}) {
         return { sensors: [], overall: 'not_certified', mode: 'invalid', reason, projectRoot: project.projectRoot, manifestPath: project.manifestPath, remedy: 'repair-sensor-manifest' };
     }
     const manifestDir = project.projectRoot;
+    const beforeReadOnly = opts.readOnly ? filesystemSnapshot(manifestDir) : undefined;
+    if (opts.readOnly && beforeReadOnly === null) {
+        return { sensors: [], overall: 'not_certified', projectRoot: project.projectRoot, manifestPath: project.manifestPath, mode: 'invalid', reason: 'read-only-observation-unavailable', remedy: 'run admission from a readable git worktree' };
+    }
     const parsed = project.manifest;
     const authority = { projectRoot: project.projectRoot, manifestPath: project.manifestPath };
     if (parsed.kind === 'v3' && (parsed.pack.mode === 'native-gate' || parsed.pack.mode === 'opt-out')) {
@@ -205,7 +264,7 @@ async function runSensors(opts = {}) {
         overall = 'not_certified';
     if (overall === 'skipped' && drift && drift.detection.pack !== 'generic')
         overall = 'not_certified';
-    return {
+    const output = {
         sensors: results,
         overall,
         ...authority,
@@ -216,4 +275,8 @@ async function runSensors(opts = {}) {
         ...(drift?.drift ? { packDrift: drift.drift } : {}),
         ...(changed ? { changedScope: { files: changed.files.length, ...(changed.error ? { error: changed.error } : {}) } } : {}),
     };
+    if (opts.readOnly && filesystemSnapshot(manifestDir) !== beforeReadOnly) {
+        return { ...output, overall: 'not_certified', reason: 'read-only-mutation-detected', remedy: 'sensor execution changed the worktree; repair it before using this evidence for admission' };
+    }
+    return output;
 }