agentic-workflow-manager 9.7.0 → 9.8.0

package/dist/tests/core/plan/validate.test.js

@@ -7,6 +7,7 @@ const fs_1 = __importDefault(require("fs"));
 const child_process_1 = require("child_process");
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
 const json_1 = require("../../../src/core/plan/json");
 const validate_1 = require("../../../src/core/plan/validate");
 jest.mock('child_process', () => ({ exec: jest.fn(), execFileSync: jest.fn(), execSync: jest.fn(), spawn: jest.fn(), spawnSync: jest.fn() }));
@@ -21,6 +22,18 @@ function expectApprovedPlanValid(report) {
     }
     expect(report.schema).toBe('compact-slices/v1');
 }
+function assertFrozenObjectGraph(value, location = 'report', visited = new WeakSet()) {
+    if (value === null || typeof value !== 'object' || visited.has(value))
+        return;
+    visited.add(value);
+    if (!Object.isFrozen(value))
+        throw new Error(`${location} is mutable`);
+    for (const key of Reflect.ownKeys(value)) {
+        const property = Object.getOwnPropertyDescriptor(value, key);
+        if (property && 'value' in property)
+            assertFrozenObjectGraph(property.value, `${location}.${String(key)}`, visited);
+    }
+}
 function fixture(root, mutate) {
     fs_1.default.mkdirSync(path_1.default.join(root, 'docs'), { recursive: true });
     fs_1.default.writeFileSync(path_1.default.join(root, 'docs', 'source.md'), '## Source\nKnown fact\n');
@@ -38,20 +51,268 @@ function fixture(root, mutate) {
     return plan;
 }
 describe('validatePlanFile', () => {
+    it('validates an authenticated snapshot without reopening a swapped plan parent', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-plan-snapshot-'));
+        const outside = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-plan-snapshot-outside-'));
+        try {
+            fs_1.default.mkdirSync(path_1.default.join(root, 'docs'));
+            const snapshot = '### Task 1: anchored\n';
+            fs_1.default.writeFileSync(path_1.default.join(root, 'docs', 'plan.md'), snapshot);
+            fs_1.default.rmSync(path_1.default.join(root, 'docs'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(outside, 'plan.md'), '<!-- attacker -->');
+            fs_1.default.symlinkSync(outside, path_1.default.join(root, 'docs'));
+            expect((0, validate_1.validatePlanSnapshot)('docs/plan.md', root, snapshot)).toMatchObject({ state: 'migration-required' });
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+            fs_1.default.rmSync(outside, { recursive: true, force: true });
+        }
+    });
     let root;
     beforeEach(() => { root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-plan-')); });
     afterEach(() => { fs_1.default.rmSync(root, { recursive: true, force: true }); });
+    test.each([
+        ['valid.md', 'valid'],
+        ['unmarked.md', 'migration-required'],
+        ['future-schema.md', 'unsupported'],
+        ['missing-section.md', 'invalid'],
+    ])('classifies the versioned v1 corpus member %s as %s without transforms', (file, state) => {
+        const corpus = path_1.default.resolve(__dirname, 'fixtures', 'compact-slices-v1');
+        expect((0, validate_1.validatePlanFile)(file, corpus).state).toBe(state);
+    });
     test('accepts a valid compact plan without modifying it', () => {
         const plan = fixture(root);
         const before = fs_1.default.readFileSync(plan, 'utf8');
         expect((0, validate_1.validatePlanFile)(plan, root)).toMatchObject({ state: 'valid', schema: 'compact-slices/v1' });
         expect(fs_1.default.readFileSync(plan, 'utf8')).toBe(before);
     });
+    test('makes an approved valid report and its nested manifest immutable after verification', () => {
+        const report = (0, validate_1.validatePlanFile)(fixture(root), root);
+        expectApprovedPlanValid(report);
+        if (report.state !== 'valid')
+            throw new Error('expected an approved compact plan');
+        const slice = report.manifest.slices[0];
+        assertFrozenObjectGraph(report);
+        expect(Reflect.set(report.manifest.requirements, '0', 'R4-FORGED')).toBe(false);
+        expect(Reflect.set(report.manifest.sources[0], 'fact', 'forged fact')).toBe(false);
+        expect(Reflect.set(report.manifest.commands[0].args, '0', 'forged-arg')).toBe(false);
+        expect(Reflect.set(slice.fallback, '0', 'forged fallback')).toBe(false);
+        expect(Reflect.set(slice.reviewEvidence, '1', 'bogus')).toBe(false);
+        expect(Reflect.set(slice, 'risk', 'unbounded')).toBe(false);
+        expect(Reflect.set(report.manifest.closureCommands, '0', 'CMD-MISSING')).toBe(false);
+        expect(report.manifest.requirements).toEqual(['R4-VAL-2']);
+        expect(report.manifest.sources[0].fact).toBe('Known fact');
+        expect(report.manifest.commands[0].args).toEqual(['test']);
+        expect(slice.fallback).toEqual(['Use a reviewed fallback']);
+        expect(slice.reviewEvidence).toEqual(['specification', 'code-quality']);
+        expect(slice.risk).toBe('bounded');
+        expect(report.manifest.closureCommands).toEqual(['CMD-ONE']);
+    });
+    test('detects a selectively thawed command-args node even when every ancestor is frozen', () => {
+        const report = (0, validate_1.validatePlanFile)(fixture(root), root);
+        expectApprovedPlanValid(report);
+        const thawed = JSON.parse(JSON.stringify(report));
+        const mutableArgs = thawed.manifest.commands[0].args;
+        const freezeExceptArgs = (value) => {
+            if (value === null || typeof value !== 'object' || value === mutableArgs)
+                return;
+            for (const child of Object.values(value))
+                freezeExceptArgs(child);
+            Object.freeze(value);
+        };
+        freezeExceptArgs(thawed);
+        expect(Object.isFrozen(thawed.manifest.commands[0])).toBe(true);
+        expect(Object.isFrozen(mutableArgs)).toBe(false);
+        expect(Reflect.set(mutableArgs, '0', 'tampered')).toBe(true);
+        expect(() => assertFrozenObjectGraph(thawed)).toThrow('report.manifest.commands.0.args is mutable');
+    });
+    test('scans bounded markerless brace runs without quadratic retries', () => {
+        const plan = path_1.default.join(root, 'braces.md');
+        fs_1.default.writeFileSync(plan, '{'.repeat(32_000));
+        const started = Date.now();
+        const report = (0, validate_1.validatePlanFile)(plan, root);
+        expect(report).toEqual({ state: 'migration-required', reason: 'unmarked-plan' });
+        expect(Date.now() - started).toBeLessThan(500);
+    });
+    test('retains markerless unsupported classification for nested JSON in an unclosed outer object', () => {
+        const plan = path_1.default.join(root, 'nested-future.md');
+        fs_1.default.writeFileSync(plan, '# Notes\n{"outer":\n{"\\u0073chema":"compact\\u002dslices\\/v2"}\n');
+        expect((0, validate_1.validatePlanFile)(plan, root)).toMatchObject({ state: 'unsupported', schema: 'compact-slices/v2' });
+    });
+    test('uses exact bigint filesystem identities for legitimate Windows-sized inode values', () => {
+        const plan = fixture(root);
+        const nativeLstat = fs_1.default.lstatSync;
+        const nativeFstat = fs_1.default.fstatSync;
+        const largeIdentity = (observed) => Object.assign(Object.create(observed), {
+            ino: typeof observed.ino === 'bigint' ? 9007199254740993n : 9007199254740992,
+        });
+        const lstat = jest.spyOn(fs_1.default, 'lstatSync').mockImplementation(((...args) => largeIdentity(Reflect.apply(nativeLstat, fs_1.default, args))));
+        const fstat = jest.spyOn(fs_1.default, 'fstatSync').mockImplementation(((...args) => largeIdentity(Reflect.apply(nativeFstat, fs_1.default, args))));
+        try {
+            expectApprovedPlanValid((0, validate_1.validatePlanFile)(plan, root));
+        }
+        finally {
+            lstat.mockRestore();
+            fstat.mockRestore();
+        }
+    });
+    test('retains the manifest byte limit beneath the bounded plan-file limit', () => {
+        const plan = fixture(root);
+        const text = fs_1.default.readFileSync(plan, 'utf8');
+        fs_1.default.writeFileSync(plan, text.replace(END, `${' '.repeat(256 * 1024)}\n${END}`));
+        expect((0, validate_1.validatePlanFile)(plan, root)).toMatchObject({ state: 'invalid', diagnostics: [expect.objectContaining({ code: 'PLAN_LIMIT' })] });
+    });
+    test.each([
+        ['plan', 'PLAN_LIMIT'],
+        ['source', 'PLAN_SOURCE_LIMIT'],
+    ])('bounds %s bytes when the inspected file grows during descriptor read', (target, code) => {
+        const plan = fixture(root);
+        const targetPath = target === 'plan' ? plan : path_1.default.join(root, 'docs', 'source.md');
+        const targetInode = fs_1.default.statSync(targetPath, { bigint: true }).ino;
+        const nativeFstat = fs_1.default.fstatSync;
+        let grew = false;
+        const fstat = jest.spyOn(fs_1.default, 'fstatSync').mockImplementation((descriptor) => {
+            const observed = nativeFstat(descriptor, { bigint: true });
+            if (!grew && observed.ino === targetInode) {
+                fs_1.default.appendFileSync(targetPath, Buffer.alloc(1024 * 1024));
+                grew = true;
+            }
+            return observed;
+        });
+        try {
+            expect((0, validate_1.validatePlanFile)(plan, root)).toMatchObject({ state: 'invalid', diagnostics: [expect.objectContaining({ code })] });
+            expect(grew).toBe(true);
+        }
+        finally {
+            fstat.mockRestore();
+        }
+    });
+    test.each([
+        ['plan', 'final', 'PLAN_PATH_UNSAFE'],
+        ['plan', 'ancestor', 'PLAN_PATH_UNSAFE'],
+        ['source', 'final', 'PLAN_SOURCE_UNSAFE'],
+        ['source', 'ancestor', 'PLAN_SOURCE_UNSAFE'],
+    ])('rejects a %s %s symlink swap after inspection without reading outside', (target, swap, code) => {
+        let plan = fixture(root);
+        const outside = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-plan-race-outside-'));
+        const targetDirectory = target === 'plan' ? path_1.default.join(root, 'plans') : path_1.default.join(root, 'docs');
+        if (target === 'plan') {
+            fs_1.default.mkdirSync(targetDirectory);
+            const nestedPlan = path_1.default.join(targetDirectory, 'plan.md');
+            fs_1.default.renameSync(plan, nestedPlan);
+            plan = nestedPlan;
+        }
+        const inspectedPath = target === 'plan' ? plan : path_1.default.join(root, 'docs', 'source.md');
+        const outsideFile = path_1.default.join(outside, path_1.default.basename(inspectedPath));
+        fs_1.default.copyFileSync(inspectedPath, outsideFile);
+        const outsideIdentity = fs_1.default.statSync(outsideFile);
+        const nativeRealpath = fs_1.default.realpathSync;
+        let swapped = false;
+        const realpath = jest.spyOn(fs_1.default, 'realpathSync').mockImplementation((file) => {
+            const resolved = nativeRealpath(file);
+            if (!swapped && file === inspectedPath) {
+                swapped = true;
+                if (swap === 'final') {
+                    fs_1.default.renameSync(inspectedPath, `${inspectedPath}-original`);
+                    fs_1.default.symlinkSync(outsideFile, inspectedPath, 'file');
+                }
+                else {
+                    fs_1.default.renameSync(targetDirectory, `${targetDirectory}-original`);
+                    fs_1.default.symlinkSync(outside, targetDirectory, 'dir');
+                }
+            }
+            return resolved;
+        });
+        const reads = jest.spyOn(fs_1.default, 'readFileSync');
+        const nativeReadSync = fs_1.default.readSync;
+        let outsideDescriptorReads = 0;
+        const descriptorReads = jest.spyOn(fs_1.default, 'readSync').mockImplementation((...args) => {
+            const opened = fs_1.default.fstatSync(args[0]);
+            if (opened.dev === outsideIdentity.dev && opened.ino === outsideIdentity.ino)
+                outsideDescriptorReads += 1;
+            return Reflect.apply(nativeReadSync, fs_1.default, args);
+        });
+        try {
+            expect((0, validate_1.validatePlanFile)(plan, root)).toMatchObject({ state: 'invalid', diagnostics: [expect.objectContaining({ code })] });
+            expect(swapped).toBe(true);
+            expect(reads.mock.calls.some(([file]) => file === inspectedPath)).toBe(false);
+            expect(outsideDescriptorReads).toBe(0);
+        }
+        finally {
+            descriptorReads.mockRestore();
+            reads.mockRestore();
+            realpath.mockRestore();
+            fs_1.default.rmSync(outside, { recursive: true, force: true });
+        }
+    });
     test('accepts a valid compact plan converted to CRLF', () => {
         const plan = fixture(root);
         fs_1.default.writeFileSync(plan, fs_1.default.readFileSync(plan, 'utf8').replace(/\n/g, '\r\n'));
         expect((0, validate_1.validatePlanFile)(plan, root)).toMatchObject({ state: 'valid', schema: 'compact-slices/v1' });
     });
+    test('returns the SHA-256 identity of the complete normalized valid plan', () => {
+        const plan = fixture(root);
+        const lf = fs_1.default.readFileSync(plan, 'utf8');
+        const expected = crypto_1.default.createHash('sha256').update(lf).digest('hex');
+        const lfReport = (0, validate_1.validatePlanFile)(plan, root);
+        fs_1.default.writeFileSync(plan, lf.replace(/\n/g, '\r\n'));
+        const crlfReport = (0, validate_1.validatePlanFile)(plan, root);
+        expect(lfReport).toMatchObject({ state: 'valid', planDigest: expected });
+        expect(crlfReport).toMatchObject({ state: 'valid', planDigest: expected });
+    });
+    test.each([
+        ['manifest requirement', (text) => text.replace(/R4-VAL-2/g, 'R4-VAL-3')],
+        ['source fact', (text) => text.replace('Known fact', 'Changed fact')],
+        ['command argv', (text) => text.replace('"test"', '"build"')],
+        ['slice prose', (text) => text.replace('One evidence item.', 'Changed evidence item.')],
+        ['execution-mode prose', (text) => `${text}\nModo de ejecución: desatendido\n`],
+    ])('changes the plan identity when %s changes', (_name, edit) => {
+        const plan = fixture(root);
+        const first = (0, validate_1.validatePlanFile)(plan, root);
+        expect(first.state).toBe('valid');
+        if (first.state !== 'valid')
+            throw new Error('expected valid fixture');
+        fs_1.default.writeFileSync(plan, edit(fs_1.default.readFileSync(plan, 'utf8')));
+        const amended = (0, validate_1.validatePlanFile)(plan, root);
+        expect(amended.state).toBe('valid');
+        if (amended.state !== 'valid')
+            throw new Error('expected valid amended fixture');
+        expect(amended.planDigest).not.toBe(first.planDigest);
+    });
+    test('separates exact progress updates from the full normalized identity', () => {
+        const plan = fixture(root);
+        fs_1.default.appendFileSync(plan, '\n- [ ] Reviewed task.\n');
+        const before = (0, validate_1.validatePlanFile)(plan, root);
+        fs_1.default.writeFileSync(plan, fs_1.default.readFileSync(plan, 'utf8').replace('- [ ] Reviewed task.', '- [x] Reviewed task.')
+            .replace('#### Evidence', '<!-- awm-qa-complete: 2026-09-16 -->\n<!-- awm-docs-complete: 2026-09-16 -->\n<!-- awm-retro-complete: Release R1 -->\n#### Evidence'));
+        const after = (0, validate_1.validatePlanFile)(plan, root);
+        expect(before.executionDigest).toEqual(expect.any(String));
+        expect(after.planDigest).not.toBe(before.planDigest);
+        expect(after.executionDigest).toBe(before.executionDigest);
+    });
+    test.each([
+        ['task prose', '- [x] Changed task.\n'],
+        ['inline marker', 'prose <!-- awm-qa-complete: 2026-09-16 -->\n'],
+        ['unknown marker', '<!-- awm-qa-complete: arbitrary requirements -->\n'],
+        ['fenced task', '```md\n- [x] Reviewed task.\n```\n'],
+        ['fenced marker', '~~~~md\n<!-- awm-qa-complete: 2026-09-16 -->\n~~~~\n'],
+    ])('does not canonicalize %s away from execution identity', (_label, addition) => {
+        const plan = fixture(root);
+        const before = (0, validate_1.validatePlanFile)(plan, root);
+        fs_1.default.appendFileSync(plan, addition);
+        const after = (0, validate_1.validatePlanFile)(plan, root);
+        expect(before.executionDigest).toEqual(expect.any(String));
+        expect(after.executionDigest).not.toBe(before.executionDigest);
+    });
+    test('a false fence closer cannot make code checkboxes and markers into lifecycle progress', () => {
+        const plan = fixture(root);
+        fs_1.default.appendFileSync(plan, '\n~~~~md\n~~~~not-a-closer\n- [ ] Code task.\n<!-- awm-qa-complete: 2026-09-16 -->\n~~~~\n');
+        const before = (0, validate_1.validatePlanFile)(plan, root);
+        fs_1.default.writeFileSync(plan, fs_1.default.readFileSync(plan, 'utf8').replace('- [ ] Code task.', '- [x] Code task.')
+            .replace('<!-- awm-qa-complete: 2026-09-16 -->', '<!-- awm-docs-complete: 2026-09-16 -->'));
+        const after = (0, validate_1.validatePlanFile)(plan, root);
+        expect(after.executionDigest).not.toBe(before.executionDigest);
+    });
     test('accepts a contained plan when path.relative returns Windows separators', () => {
         const plan = fixture(root);
         const nestedPlan = path_1.default.join(root, 'docs', 'plan.md');
@@ -73,6 +334,59 @@ describe('validatePlanFile', () => {
         const repositoryRoot = path_1.default.resolve(__dirname, '../../../..');
         expectApprovedPlanValid((0, validate_1.validatePlanFile)('docs/plans/2026-08-26-r4a-compact-plan-cli-plan.md', repositoryRoot));
     });
+    test('preserves every previously valid tracked compact-v1 plan', () => {
+        const repositoryRoot = path_1.default.resolve(__dirname, '../../../..');
+        const tracked = jest.requireActual('child_process')
+            .execFileSync('git', ['ls-files', '--', 'docs/plans/*.md'], { cwd: repositoryRoot, encoding: 'utf8' })
+            .trim().split('\n').filter(Boolean);
+        const marked = tracked.filter((file) => fs_1.default.readFileSync(path_1.default.join(repositoryRoot, file), 'utf8').includes(START));
+        const previouslyValid = [
+            'docs/plans/2026-08-26-r4a-compact-plan-cli-plan.md',
+            'docs/plans/2026-08-27-sensor-portability-publication-a-plan.md',
+            'docs/plans/2026-09-07-retire-onsignal.md',
+            'docs/plans/2026-09-14-compact-only-bootstrap-plan.md',
+        ];
+        expect(marked.length).toBeGreaterThan(0);
+        expect(previouslyValid.length).toBeGreaterThan(0);
+        const corpusCounts = `marked=${marked.length}; previouslyValid=${previouslyValid.length}; historicalInvalid=${marked.length - previouslyValid.length}`;
+        for (const file of previouslyValid) {
+            if (!marked.includes(file))
+                throw new Error(`previously valid compact-v1 plan is not tracked with a marker: ${file}; ${corpusCounts}`);
+            const report = (0, validate_1.validatePlanFile)(file, repositoryRoot);
+            if (report.state !== 'valid')
+                throw new Error(`previously valid compact-v1 plan failed: ${file}; state=${report.state}; ${corpusCounts}`);
+            assertFrozenObjectGraph(report, file);
+        }
+    });
+    test.each(['RF-1.3', 'RNF-T.2', 'R4-VAL-2', 'A'.repeat(62) + '.1'])('accepts canonical bounded requirement ID %s in every requirement reference', (id) => {
+        const report = (0, validate_1.validatePlanFile)(fixture(root, (manifest) => {
+            manifest.requirements = [id];
+            manifest.commands[0].covers = [id];
+            manifest.slices[0].requirements = [id];
+        }), root);
+        expect(report).toMatchObject({ state: 'valid', manifest: { requirements: [id] } });
+    });
+    test.each([
+        '.RF-1', 'RF-1.', 'RF..1', 'RF--1', 'RF-', 'rf-1.3', 'RF-1.a', ' RF-1.3', 'RF-1.3 ',
+        'RF-1. 3', 'RF-1/3', 'RF-1\\3', 'RF-1.é', 'RF-1.\u0000', 'RF-1.\u007f',
+        'A'.repeat(63) + '.1',
+    ])('rejects malformed or oversized requirement ID %j', (id) => {
+        const report = (0, validate_1.validatePlanFile)(fixture(root, (manifest) => {
+            manifest.requirements = [id];
+            manifest.commands[0].covers = [id];
+            manifest.slices[0].requirements = [id];
+        }), root);
+        expect(report).toMatchObject({ state: 'invalid', diagnostics: [expect.objectContaining({ code: 'PLAN_SHAPE' })] });
+    });
+    test.each([
+        ['source', (m) => { m.sources[0].id = 'SRC.ONE'; }, 'PLAN_SOURCE_SHAPE'],
+        ['command', (m) => { m.commands[0].id = 'CMD.ONE'; }, 'PLAN_COMMAND_SHAPE'],
+        ['slice', (m) => { m.slices[0].id = 'S.1'; }, 'PLAN_SLICE_SHAPE'],
+    ])('keeps dotted %s entity IDs invalid', (_name, mutate, code) => {
+        expect((0, validate_1.validatePlanFile)(fixture(root, mutate), root)).toMatchObject({
+            state: 'invalid', diagnostics: [expect.objectContaining({ code })],
+        });
+    });
     test('performs no execution, network request, model work, grouping, or rewrite', () => {
         const plan = fixture(root);
         const before = fs_1.default.readFileSync(plan, 'utf8');
@@ -229,12 +543,12 @@ describe('validatePlanFile', () => {
         const report = (0, validate_1.validatePlanFile)(fixture(root, (m) => { m.slices[0].sectionAnchor = 'a'.repeat(4097); }), root);
         expect(report).toMatchObject({ state: 'invalid', diagnostics: [expect.objectContaining({ code: 'PLAN_SLICE_SHAPE' })] });
     });
-    test('treats a document without any optimized signal as legacy', () => {
+    test('requires migration for a document without any compact signal', () => {
         const plan = path_1.default.join(root, 'legacy.md');
         fs_1.default.writeFileSync(plan, '# Legacy plan\n');
-        expect((0, validate_1.validatePlanFile)(plan, root)).toEqual({ state: 'legacy' });
+        expect((0, validate_1.validatePlanFile)(plan, root)).toEqual({ state: 'migration-required', reason: 'unmarked-plan' });
     });
-    test('does not classify an escaped future schema signal as legacy', () => {
+    test('does not classify an escaped future schema signal as migration-required', () => {
         const plan = path_1.default.join(root, 'escaped-future.md');
         fs_1.default.writeFileSync(plan, '{"schema":"compact-slices\\u002fv2"}');
         expect((0, validate_1.validatePlanFile)(plan, root)).toMatchObject({ state: 'unsupported', schema: 'compact-slices/v2' });
@@ -242,17 +556,17 @@ describe('validatePlanFile', () => {
     test.each([
         ['escaped schema key', '{"\\u0073chema":"compact-slices/v2"}'],
         ['escaped schema hyphen', '{"schema":"compact\\u002dslices/v2"}'],
-    ])('does not classify a future schema with an %s as legacy', (_name, manifest) => {
+    ])('does not classify a future schema with an %s as migration-required', (_name, manifest) => {
         const plan = path_1.default.join(root, 'escaped-future-schema.md');
         fs_1.default.writeFileSync(plan, manifest);
         expect((0, validate_1.validatePlanFile)(plan, root)).toMatchObject({ state: 'unsupported', schema: 'compact-slices/v2' });
     });
-    test('does not classify an escaped future schema embedded in Markdown without markers as legacy', () => {
+    test('does not classify an escaped future schema embedded in Markdown without markers as migration-required', () => {
         const plan = path_1.default.join(root, 'embedded-escaped-future.md');
         fs_1.default.writeFileSync(plan, '# Plan notes\n\n```json\n{"\\u0073chema":"compact\\u002dslices\\u002fv2"}\n```\n');
         expect((0, validate_1.validatePlanFile)(plan, root)).toMatchObject({ state: 'unsupported', schema: 'compact-slices/v2' });
     });
-    test('rejects an unparseable escaped compact schema embedded in Markdown rather than treating it as legacy', () => {
+    test('rejects an unparseable escaped compact schema embedded in Markdown rather than requiring migration', () => {
         const plan = path_1.default.join(root, 'embedded-escaped-malformed.md');
         fs_1.default.writeFileSync(plan, '# Plan notes\n\n{"\\u0073chema":"compact\\u002dslices\\u002fv2"\n');
         expect((0, validate_1.validatePlanFile)(plan, root)).toMatchObject({ state: 'invalid', diagnostics: [expect.objectContaining({ code: 'PLAN_MARKERS' })] });

package/dist/tests/core/reconciliation.test.js

@@ -17,7 +17,7 @@ function writeBundle(contentRoot, name, scope, skills, dependsOn = []) {
     fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'bundles', name), { recursive: true });
     fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'bundles', name, 'bundle.json'), JSON.stringify({
         name, version: '1.0.0', scope, dependsOn,
-        skills: skills.map((s) => ({ name: s })), workflows: [], agents: [],
+        skills, workflows: [], agents: [],
     }));
     for (const skill of skills) {
         fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'skills', skill), { recursive: true });

package/dist/tests/core/sync-profile-atomicity.test.js

@@ -27,7 +27,7 @@ const bundle_install_1 = require("../../src/core/bundle-install");
 function bundle(name, skills, contentRoot) {
     return {
         name, description: '', version: '1.0.0', scope: 'project', visibility: 'public',
-        dependsOn: [], skills: skills.map(n => ({ name: n })), workflows: [], agents: [],
+        dependsOn: [], skills, workflows: [], agents: [],
         source: `bundles/${name}`, contentRoot,
     };
 }

package/dist/tests/integration/pack-e2e.test.js

@@ -38,7 +38,10 @@ it('el tarball empaquetado corre awm update sin el monorepo', () => {
         const awmHome = path_1.default.join(home, '.awm');
         fs_1.default.mkdirSync(awmHome, { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(awmHome, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: source }]));
-        (0, child_process_1.execSync)(`node "${path_1.default.join(pkgDir, 'dist/src/index.js')}" update`, {
+        // El artefacto se debe ejecutar con el mismo runtime que corre la prueba:
+        // usar `node` desde PATH podría probar accidentalmente otra versión. En
+        // particular, esto cubre Node 22, declarado como compatible por package.json.
+        (0, child_process_1.execSync)(`"${process.execPath}" "${path_1.default.join(pkgDir, 'dist/src/index.js')}" update`, {
             env: { ...process.env, HOME: home, AWM_HOME: awmHome, AWM_NO_UPDATE_CHECK: '1' },
             stdio: 'pipe',
         });

package/dist/tests/integration/preflight-json-pipe.e2e.test.js

@@ -105,13 +105,17 @@ test('verify-sensors degrades parseably for a v2 sensor that exits 2 without fin
         writeJson(path_1.default.join(project, 'package.json'), { name: 'preflight-verify-fixture', private: true });
         writeJson(path_1.default.join(project, 'node_modules', 'fixture-sensor', 'package.json'), { name: 'fixture-sensor', version: '1.0.0' });
         fs_1.default.writeFileSync(path_1.default.join(project, 'fixture-sensor.config.mjs'), 'export default {};\n');
-        fs_1.default.writeFileSync(path_1.default.join(project, 'fixture-sensor.mjs'), 'process.exit(2);\n');
+        const fixtureArgs = ['-e', 'process.exit(2);', '--', '--fixture'];
+        const fixtureBin = path_1.default.join(project, 'node_modules', '.bin', process.platform === 'win32' ? 'fixture-sensor.exe' : 'fixture-sensor');
+        fs_1.default.mkdirSync(path_1.default.dirname(fixtureBin), { recursive: true });
+        fs_1.default.copyFileSync(process.execPath, fixtureBin);
+        fs_1.default.chmodSync(fixtureBin, 0o755);
         writeJson(path_1.default.join(registry, 'sensor-packs', 'fixture', 'pack.json'), {
             schemaVersion: 2, name: 'fixture', description: 'preflight exit-2 fixture', detects: ['package.json'],
             sensors: { lint: { applicability: { allFiles: ['package.json'] }, variants: [{
                             id: 'fixture-v1', priority: 100,
                             requirements: { tool: 'fixture-sensor', toolRange: '>=1 <2', runtime: 'node', runtimeRange: '>=20', configFiles: ['fixture-sensor.config.mjs'] },
-                            certifiedRange: '>=1 <2', command: { executable: 'node', resolution: 'path', args: ['fixture-sensor.mjs'] },
+                            certifiedRange: '>=1 <2', command: { executable: 'fixture-sensor', resolution: 'node-modules-bin', args: fixtureArgs },
                             assets: ['fixture-sensor.config.mjs'], formatter: 'generic', probe: { kind: 'config-present' },
                         }] } },
             coverage: { schemaVersion: 1, classes: {
@@ -124,7 +128,7 @@ test('verify-sensors degrades parseably for a v2 sensor that exits 2 without fin
         writeJson(path_1.default.join(awmHome, 'registries.json'), [{ name: 'baseline', remote: 'fixture' }]);
         writeJson(path_1.default.join(project, '.awm', 'sensors.json'), {
             schemaVersion: 2, pack: 'fixture', packSelection: 'explicit', sensors: { lint: {
-                    enabled: true, fast: true, variantId: 'fixture-v1', command: { executable: 'node', resolution: 'path', args: ['fixture-sensor.mjs'] }, assets: ['fixture-sensor.config.mjs'],
+                    enabled: true, fast: true, variantId: 'fixture-v1', command: { executable: 'fixture-sensor', resolution: 'node-modules-bin', args: fixtureArgs }, assets: ['fixture-sensor.config.mjs'],
                     initializedCompatibility: { state: 'certified', reason: 'fixture', variantId: 'fixture-v1', toolVersion: '1.0.0', runtimeVersion: process.versions.node, certifiedRange: '>=1 <2', evidence: [] },
                 } },
         });

package/dist/tests/integration/sensor-bootstrap.e2e.test.js

@@ -14,6 +14,7 @@ const safe_file_1 = require("../../src/commands/sensors/compatibility/safe-file"
 const native_bridge_1 = require("../../src/core/secure-fs/native-bridge");
 const cliRoot = path_1.default.resolve(__dirname, '../..');
 const bin = path_1.default.join(cliRoot, 'dist/src/index.js');
+const nativeArtifact = path_1.default.join(cliRoot, 'prebuilds', `${process.platform}-${process.arch}`, 'secure_fs.node');
 const fixtureRoot = path_1.default.join(cliRoot, 'tests/fixtures/sensor-compatibility');
 function hashTree(root) {
     const hash = crypto_1.default.createHash('sha256');
@@ -70,6 +71,8 @@ function v2Manifest() {
 beforeAll(() => {
     if (!fs_1.default.existsSync(bin))
         throw new Error(`Sensor bootstrap E2E requires the compiled CLI at ${bin}; run npm run build before this test.`);
+    if (!fs_1.default.existsSync(nativeArtifact))
+        throw new Error(`Sensor bootstrap E2E requires the host secure-fs artifact at ${nativeArtifact}; run npm run native:build before this test.`);
 });
 test('compiled bootstrap creates once and the exact second invocation is a byte-stable no-op', () => {
     const subject = fixture();
@@ -163,3 +166,37 @@ test('compiled bootstrap migrates v2 once, preserves all non-manifest project by
         fs_1.default.rmSync(subject.root, { recursive: true, force: true });
     }
 });
+test('compiled bootstrap requires explicit project-sensors mode before replacing a legacy manifest', () => {
+    const subject = fixture();
+    try {
+        const manifest = path_1.default.join(subject.project, '.awm', 'sensors.json');
+        const legacy = {
+            pack: 'js-ts',
+            sensors: { lint: { cmd: 'npx eslint .' } },
+        };
+        fs_1.default.writeFileSync(manifest, JSON.stringify(legacy, null, 2) + '\n');
+        const before = fs_1.default.readFileSync(manifest);
+        const machineBefore = hashTree(subject.awmHome);
+        const blocked = run(subject, '--dry-run');
+        expect(blocked.status).toBe(1);
+        expect(`${blocked.stdout}${blocked.stderr}`).toContain('legacy-replacement-requires-project-sensors-mode');
+        expect(fs_1.default.readFileSync(manifest)).toEqual(before);
+        const dryRun = run(subject, '--mode', 'project-sensors', '--dry-run');
+        expect(dryRun.status).toBe(0);
+        expect(fs_1.default.readFileSync(manifest)).toEqual(before);
+        const migrated = run(subject, '--mode', 'project-sensors');
+        expect(migrated.status).toBe(0);
+        expect(`${migrated.stdout}${migrated.stderr}`).toContain('migrated');
+        expect(`${migrated.stdout}${migrated.stderr}`).not.toContain('legacy-v1-preserved');
+        expect(JSON.parse(fs_1.default.readFileSync(manifest, 'utf8'))).toMatchObject({
+            schemaVersion: 3,
+            mode: 'project-sensors',
+            pack: 'js-ts',
+            source: { registry: 'baseline' },
+        });
+        expect(hashTree(subject.awmHome)).toBe(machineBefore);
+    }
+    finally {
+        fs_1.default.rmSync(subject.root, { recursive: true, force: true });
+    }
+});

package/dist/tests/integration/sensor-structured-run.e2e.test.js

@@ -26,6 +26,7 @@ function createFixture() {
     const awmHome = path_1.default.join(root, 'awm-home');
     const registryRoot = path_1.default.join(awmHome, 'registries', 'baseline');
     const literal = shellSensitiveLiteral;
+    const args = ['-e', "require('fs').writeFileSync('structured-argv.json', JSON.stringify(process.argv.slice(1)));", '--', literal];
     writeJson(path_1.default.join(project, 'package.json'), { name: 'structured-run-fixture', private: true });
     // Local metadata is the compatibility evidence. It is not a tool found in a
     // global installation, so init and run must keep resolving this fixture's pack.
@@ -33,10 +34,12 @@ function createFixture() {
         name: 'fixture-sensor', version: '1.0.0',
     });
     fs_1.default.writeFileSync(path_1.default.join(project, 'fixture-sensor.config.mjs'), 'export default {};\n');
-    fs_1.default.writeFileSync(path_1.default.join(project, 'fixture-sensor.mjs'), [
-        "import fs from 'fs';",
-        "fs.writeFileSync('structured-argv.json', JSON.stringify(process.argv.slice(2)));",
-    ].join('\n'));
+    const fixtureBin = path_1.default.join(project, 'node_modules', '.bin', process.platform === 'win32' ? 'fixture-sensor.exe' : 'fixture-sensor');
+    fs_1.default.mkdirSync(path_1.default.dirname(fixtureBin), { recursive: true });
+    // A real local native executable works on Windows too; shebang scripts do
+    // not. The controlled program and adversarial literal remain separate argv.
+    fs_1.default.copyFileSync(process.execPath, fixtureBin);
+    fs_1.default.chmodSync(fixtureBin, 0o755);
     writeJson(path_1.default.join(registryRoot, 'sensor-packs', 'fixture', 'pack.json'), {
         schemaVersion: 2,
         name: 'fixture',
@@ -53,10 +56,9 @@ function createFixture() {
                             runtime: 'node', runtimeRange: '>=20', configFiles: ['fixture-sensor.config.mjs'],
                         },
                         certifiedRange: '>=1 <2',
-                        // `node` is resolved from the process environment, but the actual
-                        // executable payload is the fixture-local script. Keeping the
-                        // literal as one argv element proves no shell parses it.
-                        command: { executable: 'node', resolution: 'path', args: ['fixture-sensor.mjs', literal] },
+                        // The fixture executable is project-local. Keeping the literal
+                        // as one argv element proves no shell parses it.
+                        command: { executable: 'fixture-sensor', resolution: 'node-modules-bin', args },
                         assets: ['fixture-sensor.config.mjs'], formatter: 'generic', probe: { kind: 'config-present' },
                     }],
             },
@@ -72,7 +74,7 @@ function createFixture() {
         },
     });
     writeJson(path_1.default.join(awmHome, 'registries.json'), [{ name: 'baseline', remote: 'fixture' }]);
-    return { root, project, awmHome, registryRoot, literal };
+    return { root, project, awmHome, registryRoot, literal, args };
 }
 function runCli(fixture, ...args) {
     return (0, child_process_1.spawnSync)(process.execPath, [bin, 'sensors', ...args], {
@@ -111,7 +113,7 @@ test('compiled sensors run materializes a v2 registry command and passes its lit
             mode: 'project-sensors',
             pack: 'fixture',
             source: { registry: 'baseline' },
-            sensors: { structured: { variantId: 'fixture-v1', command: { executable: 'node', resolution: 'path', args: ['fixture-sensor.mjs', fixture.literal] } } },
+            sensors: { structured: { variantId: 'fixture-v1', command: { executable: 'fixture-sensor', resolution: 'node-modules-bin', args: fixture.args } } },
         });
         const result = runCli(fixture, 'run', '--fast');
         assertSuccessfulCli(result, 'run --fast', true);

package/dist/tests/providers/injection-config.test.js

@@ -6,18 +6,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const providers_1 = require("../../src/providers");
+const paths_1 = require("../../src/core/paths");
 describe('getInjection', () => {
     it('returns cc-settings-merge for claude-code', () => {
         const inj = (0, providers_1.getInjection)('claude-code');
         expect(inj?.type).toBe('cc-settings-merge');
     });
     it('returns config-instructions for opencode pointing at the global opencode.json', () => {
-        const inj = (0, providers_1.getInjection)('opencode');
-        expect(inj).toEqual({
-            type: 'config-instructions',
-            configPath: path_1.default.join(os_1.default.homedir(), '.config/opencode/opencode.json'),
-            field: 'instructions',
-        });
+        // Windows os.homedir() uses USERPROFILE while the CLI honors HOME.
+        const systemHome = jest.spyOn(os_1.default, 'homedir').mockReturnValue(path_1.default.resolve('different-system-profile'));
+        try {
+            const inj = (0, providers_1.getInjection)('opencode');
+            expect(inj).toEqual({
+                type: 'config-instructions',
+                configPath: path_1.default.join((0, paths_1.homeDir)(), '.config/opencode/opencode.json'),
+                field: 'instructions',
+            });
+        }
+        finally {
+            systemHome.mockRestore();
+        }
     });
     it('returns undefined for antigravity (no injection mechanism wired yet)', () => {
         expect((0, providers_1.getInjection)('antigravity')).toBeUndefined();