agentic-workflow-manager 9.16.1 → 9.17.0

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

@@ -14,6 +14,7 @@ const resolve_1 = require("./compatibility/resolve");
 const project_1 = require("./project");
 const source_1 = require("./compatibility/source");
 const registries_1 = require("../../core/registries");
+const manifest_1 = require("./compatibility/manifest");
 /** First non-flag token after `npx` — the tool the command actually runs. */
 function npxTool(parts) {
     for (let i = 1; i < parts.length; i++) {
@@ -197,6 +198,90 @@ function invalidStatus(project, pack, reason = 'manifest-malformed', remedy = 'r
         ...projectMetadata(project, 'invalid', reason, { remedy }),
     };
 }
+function hasSelectedPack(manifest) {
+    return typeof manifest.pack === 'string' && manifest.pack.length > 0;
+}
+function projectSensorCheck(sensor, cwd) {
+    if (sensor.enabled === false) {
+        return { ok: true, detail: 'disabled (project-declared)', certification: 'project-declared' };
+    }
+    const check = checkStructuredCommand(sensor.command, cwd, sensor.assets);
+    return {
+        ok: check.ok,
+        detail: check.ok ? `project-declared: ${check.detail}` : `${check.detail} (project-declared)`,
+        certification: 'project-declared',
+    };
+}
+function packBoundOnly(manifest) {
+    const sensors = Object.fromEntries(Object.entries(manifest.sensors).filter(([, sensor]) => !(0, manifest_1.isProjectDeclaredSensor)(sensor)));
+    const pack = 'pack' in manifest && typeof manifest.pack === 'string' ? manifest.pack : '';
+    return { schemaVersion: 2, pack, sensors };
+}
+/** Live pack sensor ids, or null when the pack cannot be resolved (fail closed). */
+function livePackSensorIds(source) {
+    try {
+        const parsed = (0, contract_1.parseSensorPack)(JSON.parse(source.content), source.path);
+        if (parsed.kind !== 'v2')
+            return null;
+        return new Set(Object.keys(parsed.pack.sensors));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * RF-1.7 status: never label a colliding project id as project-declared READY.
+ * When pack is selected and live is unavailable, fail closed rather than claiming
+ * the project override is safe.
+ */
+function projectDeclaredOrCollisionCheck(name, sensor, packageRoot, packSelected, liveIds) {
+    if (packSelected && (liveIds === null || liveIds.has(name))) {
+        return {
+            ok: false,
+            detail: liveIds === null
+                ? `project-sensor-name-collision: ${name} (live pack unavailable)`
+                : `project-sensor-name-collision: ${name}; pack sensor kept`,
+        };
+    }
+    return projectSensorCheck(sensor, packageRoot);
+}
+/** Soft-isolate valid siblings into checks while authority remains invalid (RF soft-parse). */
+function softIsolatedChecks(project) {
+    const recovered = (0, project_1.softRecoverInvalidProject)(project);
+    if (!recovered)
+        return {};
+    const checks = {};
+    const v3Project = recovered.manifest.kind === 'v3' && recovered.manifest.pack.mode === 'project-sensors'
+        ? recovered.manifest.pack
+        : null;
+    const sensors = v3Project?.sensors ?? {};
+    // RF-1.7: same collision path as configured status — live pack probe when pack is selected.
+    const packSelected = v3Project !== null && hasSelectedPack(v3Project);
+    let liveIds = null;
+    if (packSelected) {
+        try {
+            const resolution = (0, source_1.resolveSensorSource)(recovered.manifest, { registries: (0, registries_1.listRegistries)() });
+            liveIds = 'source' in resolution ? livePackSensorIds(resolution.source) : null;
+        }
+        catch {
+            liveIds = null;
+        }
+    }
+    for (const [name, sensor] of Object.entries(sensors)) {
+        if ((0, manifest_1.isProjectDeclaredSensor)(sensor)) {
+            checks[name] = projectDeclaredOrCollisionCheck(name, sensor, recovered.packageRoot, packSelected, liveIds);
+            continue;
+        }
+        const packSensor = sensor;
+        checks[name] = packSensor.enabled === false
+            ? { ok: true, detail: 'disabled' }
+            : checkStructuredCommand(packSensor.command, recovered.packageRoot, packSensor.assets);
+    }
+    for (const entry of recovered.invalidEntries) {
+        checks[entry.name] = { ok: false, detail: entry.reason };
+    }
+    return checks;
+}
 async function computeSensorStatus(cwd = process.cwd()) {
     let project;
     try {
@@ -211,15 +296,40 @@ async function computeSensorStatus(cwd = process.cwd()) {
     }
     if (project.state === 'invalid') {
         let pack = null;
+        let reason = 'manifest-malformed';
+        let remedy = 'repair-sensor-manifest';
         try {
-            const raw = JSON.parse(fs_1.default.readFileSync(project.manifestPath, 'utf-8'));
-            if (raw && typeof raw === 'object' && !Array.isArray(raw) && !('schemaVersion' in raw) && typeof raw.pack === 'string') {
-                pack = raw.pack;
+            const text = fs_1.default.readFileSync(project.manifestPath, 'utf-8');
+            try {
+                const raw = JSON.parse(text);
+                if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+                    const record = raw;
+                    if (!('schemaVersion' in record) && typeof record.pack === 'string')
+                        pack = record.pack;
+                    else if (typeof record.pack === 'string')
+                        pack = record.pack;
+                }
+                // JSON.parse succeeded — this is schema invalidity, not "not valid JSON" (RF-4.1).
+                if (project.reason.includes('unsupported manifest schemaVersion')) {
+                    reason = 'schema-unsupported';
+                }
+                else {
+                    reason = `schema-invalid: ${project.reason}`;
+                    // Project-entry schema failures must not lead with `awm sensors init` (RF-3.3).
+                    remedy = 'repair-the-invalid-sensor-entry-in-sensors-json';
+                }
+            }
+            catch {
+                reason = 'manifest-malformed';
             }
         }
-        catch { /* malformed JSON is not configured */ }
-        const reason = project.reason.includes('unsupported manifest schemaVersion') ? 'schema-unsupported' : 'manifest-malformed';
-        return invalidStatus(project, pack, reason);
+        catch { /* unreadable manifest stays malformed */ }
+        // Soft-isolate valid siblings into checks (same WithIssues path as run) while
+        // keeping mode=invalid so preflight RF-4.1 still sees schema-invalid authority.
+        return {
+            ...invalidStatus(project, pack, reason, remedy),
+            checks: softIsolatedChecks(project),
+        };
     }
     const packageRoot = project.packageRoot;
     const parsed = project.manifest;
@@ -229,38 +339,73 @@ async function computeSensorStatus(cwd = process.cwd()) {
             ...projectMetadata(project, parsed.pack.mode, `${parsed.pack.mode}-declared`, { declarationReason: parsed.pack.reason }),
         };
     }
+    if (parsed.kind === 'v3' && parsed.pack.mode === 'project-sensors' && !hasSelectedPack(parsed.pack)) {
+        // Only-project: no pack source to resolve. Report each project sensor with
+        // project-declared provenance rather than an empty Pack:none DEGRADED (RF-2.8).
+        const checks = {};
+        for (const [name, sensor] of Object.entries(parsed.pack.sensors)) {
+            if ((0, manifest_1.isProjectDeclaredSensor)(sensor)) {
+                checks[name] = projectSensorCheck(sensor, packageRoot);
+            }
+            else {
+                checks[name] = { ok: false, detail: 'pack-bound sensor requires a nonempty pack' };
+            }
+        }
+        return {
+            overall: Object.keys(checks).length > 0 && Object.values(checks).every(check => check.ok) ? 'READY' : 'DEGRADED',
+            pack: null,
+            checks,
+            ...projectMetadata(project, 'project-sensors', 'project-declared-only'),
+        };
+    }
     if (parsed.kind === 'v2' || parsed.kind === 'v3') {
         const parsedPack = parsed.pack;
+        const packId = typeof parsedPack.pack === 'string' ? parsedPack.pack : null;
+        const packSelected = typeof parsedPack.pack === 'string' && parsedPack.pack.length > 0;
         let resolution;
         try {
             resolution = (0, source_1.resolveSensorSource)(parsed, { registries: (0, registries_1.listRegistries)() });
         }
         catch {
-            return invalidStatus(project, parsedPack.pack, 'sensor-source-invalid', 'repair-or-run-awm-update');
+            return invalidStatus(project, packId, 'sensor-source-invalid', 'repair-or-run-awm-update');
         }
         if (!('source' in resolution))
-            return sourceFailure(project, parsedPack.pack, resolution);
+            return sourceFailure(project, packId ?? 'unknown', resolution);
         const sourceMeta = resolvedSourceMetadata(resolution);
-        const manifest = parsedPack;
+        const liveIds = livePackSensorIds(resolution.source);
+        const packManifest = packBoundOnly(parsedPack);
         const checks = {};
         let compatibility;
         try {
-            compatibility = resolveStaticV2Compatibility(packageRoot, manifest, resolution.source);
+            compatibility = resolveStaticV2Compatibility(packageRoot, packManifest, resolution.source);
         }
         catch (error) {
             const detail = error instanceof Error ? error.message : 'live compatibility unavailable';
-            for (const [name, sensor] of Object.entries(manifest.sensors))
-                checks[name] = sensor.enabled === false ? { ok: true, detail: 'disabled' } : { ok: false, detail };
-            return { overall: 'DEGRADED', pack: manifest.pack, checks, ...projectMetadata(project, 'project-sensors', sourceMeta.reason, { ...sourceMeta }) };
+            for (const [name, sensor] of Object.entries(parsedPack.sensors)) {
+                if ((0, manifest_1.isProjectDeclaredSensor)(sensor)) {
+                    checks[name] = projectDeclaredOrCollisionCheck(name, sensor, packageRoot, packSelected, liveIds);
+                }
+                else {
+                    checks[name] = sensor.enabled === false
+                        ? { ok: true, detail: 'disabled' }
+                        : { ok: false, detail };
+                }
+            }
+            return { overall: 'DEGRADED', pack: packId, checks, ...projectMetadata(project, 'project-sensors', sourceMeta.reason, { ...sourceMeta }) };
         }
-        for (const [name, sensor] of Object.entries(manifest.sensors)) {
-            checks[name] = sensor.enabled === false ? { ok: true, detail: 'disabled' }
-                : staticCompatibilityCheck(sensor, compatibility[name]) ?? checkStructuredCommand(sensor.command, packageRoot, sensor.assets);
+        for (const [name, sensor] of Object.entries(parsedPack.sensors)) {
+            if ((0, manifest_1.isProjectDeclaredSensor)(sensor)) {
+                checks[name] = projectDeclaredOrCollisionCheck(name, sensor, packageRoot, packSelected, liveIds);
+                continue;
+            }
+            const packSensor = sensor;
+            checks[name] = packSensor.enabled === false ? { ok: true, detail: 'disabled' }
+                : staticCompatibilityCheck(packSensor, compatibility[name]) ?? checkStructuredCommand(packSensor.command, packageRoot, packSensor.assets);
         }
-        const uninitialized = uninitializedSensors(manifest, compatibility);
+        const uninitialized = uninitializedSensors(packManifest, compatibility);
         return {
             overall: Object.keys(checks).length > 0 && Object.values(checks).every(check => check.ok) ? 'READY' : 'DEGRADED',
-            pack: manifest.pack, checks,
+            pack: packId, checks,
             ...(uninitialized ? { uninitialized } : {}),
             ...projectMetadata(project, 'project-sensors', sourceMeta.reason, { ...sourceMeta }),
         };

package/dist/src/core/init/steps.js

@@ -75,7 +75,11 @@ exports.defaultActions = {
             throw new Error('sensor init does not migrate an existing v2 manifest; run awm sensors bootstrap');
         if (plan.kind === 'create')
             (0, bootstrap_1.applySensorBootstrap)(plan);
-        const pack = plan.kind === 'create' && plan.manifest.mode === 'project-sensors' ? plan.manifest.pack : (0, detection_1.detectStack)(o.cwd).pack;
+        const detected = (0, detection_1.detectStack)(o.cwd).pack;
+        const declared = plan.kind === 'create' && plan.manifest.mode === 'project-sensors' ? plan.manifest.pack : undefined;
+        const pack = typeof declared === 'string' && declared.length > 0 ? declared : detected;
+        if (typeof pack !== 'string' || pack.length === 0)
+            throw new Error('sensor init could not resolve a pack id');
         return { detection: { pack }, manifest: { pack } };
     },
     addExtension: (root, name) => { (0, profile_1.addExtension)(root, name); },

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

@@ -397,6 +397,19 @@ describe('preflight', () => {
         expect(execution.remedy).toContain('awm sensors init');
         expect(execution.remedy).not.toContain('named sensor');
     });
+    it('does not treat overall=pass as unconditional green when invalidEntries are present', async () => {
+        const dir = make({ manifest: { pack: 'generic', sensors: { security: { enabled: false } } } });
+        mockRunSensors.mockResolvedValue({
+            overall: 'pass',
+            sensors: [{ name: 'good', status: 'pass', errors: [] }],
+            invalidEntries: [{ name: 'broken', reason: 'sensors.broken.formatter is not a registered formatter id' }],
+        });
+        const report = await (0, checks_1.preflight)(dir, { verifySensors: true });
+        const execution = check(report, 'sensors-execution');
+        expect(execution.ok).toBe(false);
+        expect(execution.detail).toMatch(/invalidEntries|broken/i);
+        expect(execution.detail).not.toBe('all selected sensors completed with pass');
+    });
     it('reports not_configured when no sensor manifest exists', async () => {
         // The team-rollout case: a developer clones the repo and never runs
         // `awm sensors init`. Today nothing notices until an unattended run is already
@@ -813,4 +826,112 @@ describe('preflight', () => {
         expect(check(report, 'manifest').detail).not.toContain('no .awm/sensors.json');
         expect(check(report, 'tools')).toBeUndefined();
     });
+    describe('project-declared diagnostics (S3)', () => {
+        it('does not claim not-valid-JSON when JSON parses but a project field fails schema (RF-4.1/4.2)', async () => {
+            const dir = make({
+                manifest: {
+                    schemaVersion: 3,
+                    mode: 'project-sensors',
+                    sensors: {
+                        broken: {
+                            source: 'project',
+                            enabled: true,
+                            command: { executable: 'terraform', resolution: 'path', args: ['fmt', '-check'] },
+                            formatter: 'not-a-formatter',
+                        },
+                    },
+                },
+            });
+            const report = await (0, checks_1.preflight)(dir);
+            const manifestCheck = check(report, 'manifest');
+            expect(manifestCheck.ok).toBe(false);
+            expect(manifestCheck.detail).not.toBe('.awm/sensors.json is not valid JSON');
+            expect(manifestCheck.detail).not.toMatch(/not valid JSON/i);
+            expect(manifestCheck.detail).toMatch(/broken/);
+            expect(manifestCheck.detail).toMatch(/formatter/);
+            expect(report.reason).toMatch(/schema-invalid/i);
+        });
+        it('still reports not-valid-JSON for truly broken JSON (RF-4.1)', async () => {
+            const dir = make({ manifest: '{ not json' });
+            const report = await (0, checks_1.preflight)(dir);
+            expect(check(report, 'manifest').detail).toContain('not valid JSON');
+        });
+        it('does not recommend awm sensors init as the first remedy for project schema invalidity (RF-3.3)', async () => {
+            const dir = make({
+                manifest: {
+                    schemaVersion: 3,
+                    mode: 'project-sensors',
+                    sensors: {
+                        broken: {
+                            source: 'project',
+                            enabled: true,
+                            command: { executable: 'terraform', resolution: 'path', args: ['fmt'] },
+                            formatter: 'not-a-formatter',
+                        },
+                    },
+                },
+            });
+            const remedy = check(await (0, checks_1.preflight)(dir), 'manifest').remedy ?? '';
+            const firstLine = remedy.split('\n')[0] ?? remedy;
+            expect(firstLine).not.toMatch(/awm sensors init/i);
+            // RF-3.3 positive: first remedy names repair of the entry/field, not regen.
+            expect(firstLine).toMatch(/repair|entry|field/i);
+        });
+        it('uses an only-project-honest tools remedy when sensors are empty and pack is null', async () => {
+            const dir = make({
+                manifest: {
+                    schemaVersion: 3,
+                    mode: 'project-sensors',
+                    sensors: {},
+                },
+            });
+            const report = await (0, checks_1.preflight)(dir);
+            const tools = check(report, 'tools');
+            expect(tools.ok).toBe(false);
+            expect(tools.remedy ?? '').not.toMatch(/['"]null['"]/);
+            expect(tools.remedy ?? '').not.toMatch(/awm update/i);
+            expect(tools.remedy ?? '').not.toMatch(/registry has no pack/i);
+            expect(tools.remedy ?? '').toMatch(/source:"project"|declare a pack/i);
+        });
+        it('accepts only-project READY status without inventing a pack id (RF-2.8)', async () => {
+            const pathDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-preflight-only-project-path-'));
+            const previousPath = process.env.PATH;
+            try {
+                fs_1.default.writeFileSync(path_1.default.join(pathDir, 'terraform'), '#!/bin/sh\nexit 0\n');
+                fs_1.default.chmodSync(path_1.default.join(pathDir, 'terraform'), 0o755);
+                process.env.PATH = pathDir;
+                const dir = make({
+                    manifest: {
+                        schemaVersion: 3,
+                        mode: 'project-sensors',
+                        sensors: {
+                            'iac-format': {
+                                source: 'project',
+                                enabled: true,
+                                command: { executable: 'terraform', resolution: 'path', args: ['fmt', '-check'] },
+                                formatter: 'exit-code',
+                            },
+                        },
+                    },
+                });
+                const report = await (0, checks_1.preflight)(dir);
+                const manifestCheck = check(report, 'manifest');
+                expect(manifestCheck.ok).toBe(true);
+                expect(manifestCheck.detail).not.toMatch(/sensor authority is unavailable/i);
+                expect(manifestCheck.detail).not.toMatch(/pack ['"]?generic['"]?/i);
+                // only-project READY must say so — loose "sensors enabled" alone is pack wording.
+                expect(manifestCheck.detail).toMatch(/only-project/i);
+                expect(manifestCheck.detail).toMatch(/project-declared/i);
+                expect(check(report, 'tools').ok).toBe(true);
+                expect(report.mode).toBe('project-sensors');
+            }
+            finally {
+                if (previousPath === undefined)
+                    delete process.env.PATH;
+                else
+                    process.env.PATH = previousPath;
+                fs_1.default.rmSync(pathDir, { recursive: true, force: true });
+            }
+        });
+    });
 });

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

@@ -230,3 +230,13 @@ describe('planSensorBootstrap', () => {
         }
     });
 });
+describe('bootstrap only-project honesty (S3)', () => {
+    it('does not invent pack:"generic" when planning an only-project write path is requested via pack null (RF-3.2)', async () => {
+        // Bootstrap options today reject null pack (stable id only). Until an explicit
+        // pack-less planner mode exists, requesting pack:null must fail closed — never
+        // coerce to generic and write a lying pack pin.
+        project_1.resolveSensorProject.mockReturnValue(missing);
+        await expect((0, bootstrap_1.planSensorBootstrap)(root, { mode: 'project-sensors', pack: null })).rejects.toThrow(/pack/i);
+        expect(detection_1.detectStack).not.toHaveBeenCalled();
+    });
+});

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

@@ -19,6 +19,26 @@ function validV2Manifest() {
         },
     };
 }
+function projectSensor(overrides = {}) {
+    return {
+        source: 'project',
+        enabled: true,
+        command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+        ...overrides,
+    };
+}
+function v3WithPackAndProject(projectOverrides = {}) {
+    return {
+        schemaVersion: 3,
+        mode: 'project-sensors',
+        pack: 'js-ts',
+        source: { registry: 'baseline' },
+        sensors: {
+            lint: validV2Manifest().sensors.lint,
+            custom: projectSensor(projectOverrides),
+        },
+    };
+}
 describe('sensor manifest contract', () => {
     it('keeps compatibility contracts on an acyclic import boundary', () => {
         const source = (relative) => fs_1.default.readFileSync(path_1.default.join(__dirname, '../../../../src/commands/sensors', relative), 'utf8');
@@ -192,4 +212,188 @@ describe('sensor manifest contract', () => {
     ])('rejects malformed manifest %j', (input, message) => {
         expect(() => (0, manifest_1.parseSensorManifest)(input, 'sensors.json')).toThrow(message);
     });
+    describe('project-declared sensors (S1)', () => {
+        it('accepts a source:project entry alongside a pack-bound lint sensor', () => {
+            const manifest = v3WithPackAndProject();
+            const parsed = (0, manifest_1.parseSensorManifest)(manifest, 'sensors.json');
+            expect(parsed).toMatchObject({
+                kind: 'v3',
+                pack: {
+                    mode: 'project-sensors',
+                    pack: 'js-ts',
+                    sensors: {
+                        lint: { variantId: 'eslint-9', enabled: true },
+                        custom: {
+                            source: 'project',
+                            enabled: true,
+                            command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+                            formatter: 'exit-code',
+                        },
+                    },
+                },
+            });
+            expect(parsed.kind === 'v3' && parsed.pack.mode === 'project-sensors' && 'variantId' in parsed.pack.sensors.custom).toBe(false);
+            expect(parsed.kind === 'v3' && parsed.pack.mode === 'project-sensors' && 'initializedCompatibility' in parsed.pack.sensors.custom).toBe(false);
+        });
+        it('accepts an only-project manifest with pack omitted or null', () => {
+            const base = {
+                schemaVersion: 3,
+                mode: 'project-sensors',
+                sensors: { custom: projectSensor() },
+            };
+            for (const manifest of [base, { ...base, pack: null }]) {
+                const parsed = (0, manifest_1.parseSensorManifest)(manifest, 'sensors.json');
+                expect(parsed).toMatchObject({
+                    kind: 'v3',
+                    pack: {
+                        mode: 'project-sensors',
+                        sensors: { custom: { source: 'project', formatter: 'exit-code' } },
+                    },
+                });
+                if (parsed.kind === 'v3' && parsed.pack.mode === 'project-sensors') {
+                    expect(parsed.pack.pack === undefined || parsed.pack.pack === null).toBe(true);
+                    expect(parsed.pack.source).toBeUndefined();
+                }
+            }
+        });
+        it('accepts an empty only-project sensors map', () => {
+            expect((0, manifest_1.parseSensorManifest)({
+                schemaVersion: 3,
+                mode: 'project-sensors',
+                sensors: {},
+            }, 'sensors.json')).toMatchObject({
+                kind: 'v3',
+                pack: { mode: 'project-sensors', sensors: {} },
+            });
+        });
+        it.each(['variantId', 'initializedCompatibility'])('rejects a project entry that declares forbidden pack field %s', field => {
+            const value = field === 'variantId'
+                ? 'eslint-9'
+                : { state: 'certified', reason: 'ok', variantId: 'eslint-9', toolVersion: '9.0.0', runtimeVersion: '24.0.0', certifiedRange: '>=9 <10', evidence: [] };
+            const soft = (0, manifest_1.parseSensorManifestWithIssues)(v3WithPackAndProject({ [field]: value }), 'sensors.json');
+            expect(soft.invalidEntries).toEqual([
+                expect.objectContaining({
+                    name: 'custom',
+                    reason: expect.stringMatching(new RegExp(`sensors\\.custom\\.${field}`)),
+                }),
+            ]);
+            expect(soft).toMatchObject({
+                kind: 'v3',
+                pack: { sensors: { lint: { variantId: 'eslint-9' } } },
+            });
+            expect('custom' in soft.pack.sensors).toBe(false);
+        });
+        it('soft-rejects an invalid project command with sensors.<name>.command in the reason (RF-1.12)', () => {
+            const soft = (0, manifest_1.parseSensorManifestWithIssues)(v3WithPackAndProject({
+                command: { executable: 'bash', resolution: 'path', args: ['-c', 'true'] },
+            }), 'sensors.json');
+            expect(soft.invalidEntries).toHaveLength(1);
+            expect(soft.invalidEntries[0]?.reason).toMatch(/sensors\.custom\.command/);
+            expect(soft).toMatchObject({
+                kind: 'v3',
+                pack: { sensors: { lint: { variantId: 'eslint-9' } } },
+            });
+            expect('custom' in soft.pack.sensors).toBe(false);
+        });
+        it('soft-rejects an unmarked custom command as missing source (RF-1.2)', () => {
+            const soft = (0, manifest_1.parseSensorManifestWithIssues)({
+                schemaVersion: 3,
+                mode: 'project-sensors',
+                pack: 'js-ts',
+                source: { registry: 'baseline' },
+                sensors: {
+                    lint: validV2Manifest().sensors.lint,
+                    custom: {
+                        enabled: true,
+                        command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+                    },
+                },
+            }, 'sensors.json');
+            expect(soft.invalidEntries).toEqual([
+                expect.objectContaining({
+                    name: 'custom',
+                    reason: expect.stringMatching(/sensors\.custom\.source/),
+                }),
+            ]);
+            expect(soft.invalidEntries[0]?.reason).toMatch(/source/);
+            expect(soft).toMatchObject({
+                kind: 'v3',
+                pack: { sensors: { lint: { variantId: 'eslint-9' } } },
+            });
+            // Soft-isolation: unmarked custom must be dropped, pack sibling kept.
+            expect('custom' in soft.pack.sensors).toBe(false);
+        });
+        it('rejects unknown formatter and defaults omitted formatter to exit-code', () => {
+            const soft = (0, manifest_1.parseSensorManifestWithIssues)(v3WithPackAndProject({ formatter: 'not-a-formatter' }), 'sensors.json');
+            expect(soft.invalidEntries).toEqual([
+                expect.objectContaining({
+                    name: 'custom',
+                    reason: expect.stringMatching(/sensors\.custom\.formatter/),
+                }),
+            ]);
+            const ok = (0, manifest_1.parseSensorManifest)(v3WithPackAndProject(), 'sensors.json');
+            expect(ok).toMatchObject({
+                kind: 'v3',
+                pack: { sensors: { custom: { formatter: 'exit-code' } } },
+            });
+        });
+        it('treats omitted applicability as always applicable and rejects invalid shapes', () => {
+            const ok = (0, manifest_1.parseSensorManifest)(v3WithPackAndProject(), 'sensors.json');
+            expect(ok.kind === 'v3' && ok.pack.mode === 'project-sensors' && !('applicability' in ok.pack.sensors.custom)).toBe(true);
+            const withApplicability = (0, manifest_1.parseSensorManifest)(v3WithPackAndProject({ applicability: { allFiles: ['package.json'] } }), 'sensors.json');
+            expect(withApplicability).toMatchObject({
+                kind: 'v3',
+                pack: { sensors: { custom: { applicability: { allFiles: ['package.json'] } } } },
+            });
+            const soft = (0, manifest_1.parseSensorManifestWithIssues)(v3WithPackAndProject({ applicability: {} }), 'sensors.json');
+            expect(soft.invalidEntries).toEqual([
+                expect.objectContaining({
+                    name: 'custom',
+                    reason: expect.stringMatching(/sensors\.custom\.applicability/),
+                }),
+            ]);
+        });
+        it('rejects schemaVersion 2 and legacy manifests that use source:project with migrate-to-v3', () => {
+            const v2 = {
+                schemaVersion: 2,
+                pack: 'js-ts',
+                sensors: {
+                    custom: {
+                        source: 'project',
+                        enabled: true,
+                        command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+                    },
+                },
+            };
+            expect(() => (0, manifest_1.parseSensorManifest)(v2, 'sensors.json')).toThrow(/migrate-to-v3|migrate to v3/i);
+            const legacy = {
+                pack: 'js-ts',
+                sensors: {
+                    custom: {
+                        source: 'project',
+                        enabled: true,
+                        cmd: 'npm run lint',
+                    },
+                },
+            };
+            expect(() => (0, manifest_1.parseSensorManifest)(legacy, 'sensors.json')).toThrow(/migrate-to-v3|migrate to v3/i);
+        });
+        it('soft-isolates one invalid project entry while keeping a valid pack sensor', () => {
+            const soft = (0, manifest_1.parseSensorManifestWithIssues)(v3WithPackAndProject({ formatter: 'not-a-formatter' }), 'sensors.json');
+            expect(soft.invalidEntries).toHaveLength(1);
+            expect(soft.invalidEntries[0]).toMatchObject({
+                name: 'custom',
+                reason: expect.stringMatching(/sensors\.custom\.formatter/),
+            });
+            expect(soft).toMatchObject({
+                kind: 'v3',
+                pack: {
+                    mode: 'project-sensors',
+                    sensors: { lint: { enabled: true, variantId: 'eslint-9' } },
+                },
+            });
+            expect('custom' in soft.pack.sensors).toBe(false);
+            expect(soft.invalidEntries.some(entry => /not valid JSON|valid JSON/i.test(entry.reason))).toBe(false);
+        });
+    });
 });