agentic-workflow-manager 9.7.1 → 9.9.0

package/dist/tests/core/model-policy/store.test.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const atomic_file_1 = require("../../../src/core/atomic-file");
+const canonical_1 = require("../../../src/core/model-policy/canonical");
+const store_1 = require("../../../src/core/model-policy/store");
+const paths_1 = require("../../../src/core/model-policy/paths");
+const policy = () => ({ schema: 'model-policy/v1', mappings: [{ target: 'codex', runtimeKind: 'native', profiles: {
+                mechanical: { selector: { kind: 'model', id: 'gpt-5.6-luna' }, effort: { kind: 'explicit', value: 'medium' } },
+                integration: { selector: { kind: 'model', id: 'gpt-5.6-terra' }, effort: { kind: 'explicit', value: 'medium' } },
+                judgment: { selector: { kind: 'model', id: 'gpt-5.6-sol' }, effort: { kind: 'explicit', value: 'medium' } },
+            }, fullCapability: { selector: { kind: 'model', id: 'gpt-5.6-sol' }, effort: { kind: 'explicit', value: 'high' } }, degradation: { allowMissingModelOverride: false, allowMissingEffortOverride: false, allowMissingObservedIdentity: false } }], implementationBudget: { maxAttempts: 3, escalation: ['mechanical', 'integration', 'judgment'], judgmentEfforts: ['medium', 'high'] } });
+function createIdentityFencedBoundary() {
+    const observations = new WeakMap();
+    return {
+        withProjectLease: (_root, operation) => operation(),
+        readRegularFile: (file) => {
+            const identity = Object.freeze({});
+            const bytes = fs_1.default.readFileSync(file);
+            observations.set(identity, { file, bytes });
+            return { bytes, identity };
+        },
+        writeProjectTransaction: (root, destination, content, options) => {
+            const file = path_1.default.join(root, destination);
+            fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+            if (options.mode === 'create' && fs_1.default.existsSync(file))
+                throw new Error('project destination already exists');
+            if (options.mode === 'replace') {
+                const observed = observations.get(options.expectedIdentity);
+                if (!observed || observed.file !== file || !observed.bytes.equals(options.expected) || !fs_1.default.readFileSync(file).equals(options.expected))
+                    throw new Error('original changed before fenced replacement');
+            }
+            const temporary = `${file}.test-tmp`;
+            const fd = fs_1.default.openSync(temporary, 'wx', 0o600);
+            try {
+                fs_1.default.writeFileSync(fd, content);
+                fs_1.default.fsyncSync(fd);
+                fs_1.default.closeSync(fd);
+                fs_1.default.renameSync(temporary, file);
+                // La durabilidad de la ENTRADA publicada se pide por el unico helper
+                // que define esa politica (atomic-file.fsyncDirSync): fail-closed en
+                // POSIX y degradado SOLO ante el gap conocido de win32 (EPERM al
+                // fsync-ear un fd de directorio, capacidad que el SO no expone).
+                // Reimplementarla aca la hacia divergir y rompia la matriz Windows.
+                (0, atomic_file_1.fsyncDirSync)(path_1.default.dirname(file));
+            }
+            finally {
+                try {
+                    fs_1.default.rmSync(temporary, { force: true });
+                }
+                catch { /* preserve transaction result */ }
+            }
+        },
+    };
+}
+const identityFencedBoundary = createIdentityFencedBoundary();
+const approve = (input) => (0, store_1.approvePolicyWithBoundary)(input, identityFencedBoundary);
+describe('approved policy store', () => {
+    let root;
+    let oldHome;
+    let oldAwmHome;
+    beforeEach(() => { root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-policy-')); oldHome = process.env.HOME; oldAwmHome = process.env.AWM_HOME; process.env.AWM_HOME = path_1.default.join(root, 'operator'); });
+    afterEach(() => { jest.restoreAllMocks(); delete process.env.POLICY_TEST_FAIL_WRITE; delete process.env.POLICY_TEST_MUTATE_DURING_REPLACE; if (oldHome === undefined)
+        delete process.env.HOME;
+    else
+        process.env.HOME = oldHome; if (oldAwmHome === undefined)
+        delete process.env.AWM_HOME;
+    else
+        process.env.AWM_HOME = oldAwmHome; fs_1.default.rmSync(root, { recursive: true, force: true }); });
+    const candidate = () => { const file = path_1.default.join(root, 'candidate.json'); fs_1.default.writeFileSync(file, JSON.stringify(policy())); return file; };
+    it('publishes only an expected digest and reads it without creating state', () => {
+        const file = candidate();
+        const digest = (0, canonical_1.canonicalPolicyDigest)(policy());
+        expect((0, store_1.readEffectivePolicy)(root)).toEqual({ state: 'absent' });
+        const approved = approve({ file, scope: 'user', cwd: root, expectedDigest: digest });
+        expect(approved.contentDigest).toBe(digest);
+        expect((0, store_1.readEffectivePolicy)(root)).toMatchObject({ state: 'approved', provenance: 'user', policy: { contentDigest: digest } });
+    });
+    it('rejects a mismatched digest before writing', () => {
+        const file = candidate();
+        expect(() => approve({ file, scope: 'user', cwd: root, expectedDigest: '0'.repeat(64) })).toThrow(/digest/i);
+        expect(fs_1.default.existsSync((0, paths_1.userPolicyPath)())).toBe(false);
+    });
+    it('allows exactly one initial writer and exact CAS replacement', () => {
+        const file = candidate();
+        const digest = (0, canonical_1.canonicalPolicyDigest)(policy());
+        approve({ file, scope: 'user', cwd: root, expectedDigest: digest });
+        expect(() => approve({ file, scope: 'user', cwd: root, expectedDigest: digest })).toThrow(/replace|existing/i);
+        expect(() => approve({ file, scope: 'user', cwd: root, expectedDigest: digest, replaceDigest: 'f'.repeat(64) })).toThrow(/predecessor|replace/i);
+        expect(approve({ file, scope: 'user', cwd: root, expectedDigest: digest, replaceDigest: digest }).lineage.previousDigest).toBe(digest);
+    });
+    it('rejects an unexpected opaque identity token before replacing bytes', () => {
+        const target = path_1.default.join(root, 'identity.json');
+        fs_1.default.writeFileSync(target, 'observed');
+        const observed = identityFencedBoundary.readRegularFile(target, 1024);
+        expect(() => identityFencedBoundary.writeProjectTransaction(root, 'identity.json', Buffer.from('replacement'), {
+            mode: 'replace', createParents: false, expected: observed.bytes, expectedIdentity: Object.freeze({}),
+        })).toThrow(/original changed/i);
+        expect(fs_1.default.readFileSync(target, 'utf8')).toBe('observed');
+    });
+    it('resolves a relative candidate through cwd instead of process cwd', () => {
+        const cwd = path_1.default.join(root, 'project');
+        fs_1.default.mkdirSync(cwd);
+        const file = path_1.default.join(cwd, 'candidate.json');
+        fs_1.default.writeFileSync(file, JSON.stringify(policy()));
+        const digest = (0, canonical_1.canonicalPolicyDigest)(policy());
+        expect(approve({ file: 'candidate.json', scope: 'project', cwd, expectedDigest: digest }).contentDigest).toBe(digest);
+    });
+    it('accepts exactly one of two competing fenced replacements', () => {
+        const file = candidate();
+        const digest = (0, canonical_1.canonicalPolicyDigest)(policy());
+        approve({ file, scope: 'user', cwd: root, expectedDigest: digest });
+        const input = { file, scope: 'user', cwd: root, expectedDigest: digest, replaceDigest: digest };
+        let entered = false;
+        let accepted = 0;
+        const boundary = {
+            withProjectLease: (_root, operation) => operation(),
+            readRegularFile: (target) => ({ bytes: fs_1.default.readFileSync(target), identity: Object.freeze({}) }),
+            writeProjectTransaction: (base, destination, bytes, options) => {
+                const target = path_1.default.join(base, destination);
+                if (options.mode === 'replace' && !entered) {
+                    entered = true;
+                    // Model a non-cooperating external process: the native
+                    // identity fence, not this advisory lock, must reject us.
+                    fs_1.default.rmSync(`${target}.lock`);
+                    (0, store_1.approvePolicyWithBoundary)(input, boundary);
+                    fs_1.default.writeFileSync(`${target}.lock`, 'outer lock placeholder');
+                }
+                if (options.mode === 'replace' && (!options.expected || !fs_1.default.readFileSync(target).equals(options.expected)))
+                    throw new Error('original changed before fenced replacement');
+                fs_1.default.mkdirSync(path_1.default.dirname(target), { recursive: true });
+                fs_1.default.writeFileSync(target, bytes);
+                accepted++;
+            },
+        };
+        expect(() => (0, store_1.approvePolicyWithBoundary)(input, boundary)).toThrow(/changed|replacement/i);
+        expect(accepted).toBe(1);
+    });
+    it('returns a failed publication and preserves predecessor bytes on injected transaction failure', () => {
+        const file = candidate();
+        const digest = (0, canonical_1.canonicalPolicyDigest)(policy());
+        approve({ file, scope: 'user', cwd: root, expectedDigest: digest });
+        const before = fs_1.default.readFileSync((0, paths_1.userPolicyPath)());
+        const boundary = {
+            withProjectLease: (_root, operation) => operation(),
+            readRegularFile: (target) => ({ bytes: fs_1.default.readFileSync(target), identity: Object.freeze({}) }),
+            writeProjectTransaction: () => { throw new Error('injected durable publication failure'); },
+        };
+        expect(() => (0, store_1.approvePolicyWithBoundary)({ file, scope: 'user', cwd: root, expectedDigest: digest, replaceDigest: digest }, boundary)).toThrow(/publication failure/);
+        expect(fs_1.default.readFileSync((0, paths_1.userPolicyPath)()).equals(before)).toBe(true);
+    });
+    it('blocks an invalid project policy instead of falling back to a valid user policy', () => {
+        const file = candidate();
+        const digest = (0, canonical_1.canonicalPolicyDigest)(policy());
+        approve({ file, scope: 'user', cwd: root, expectedDigest: digest });
+        fs_1.default.mkdirSync(path_1.default.join(root, '.awm'));
+        fs_1.default.writeFileSync(path_1.default.join(root, '.awm', 'model-policy.json'), '{"content":');
+        expect((0, store_1.readEffectivePolicy)(root)).toMatchObject({ state: 'invalid', provenance: 'project' });
+    });
+    it('rejects duplicate JSON keys and symlinked parent or destination without touching the target', () => {
+        const duplicate = path_1.default.join(root, 'duplicate.json');
+        fs_1.default.writeFileSync(duplicate, '{"schema":"model-policy/v1","schema":"model-policy/v1"}');
+        expect(() => approve({ file: duplicate, scope: 'user', cwd: root, expectedDigest: 'a'.repeat(64) })).toThrow(/duplicate/i);
+        const file = candidate();
+        const digest = (0, canonical_1.canonicalPolicyDigest)(policy());
+        fs_1.default.mkdirSync(process.env.AWM_HOME);
+        fs_1.default.symlinkSync(root, path_1.default.join(process.env.AWM_HOME, 'link'));
+        const target = (0, paths_1.userPolicyPath)();
+        fs_1.default.symlinkSync(path_1.default.join(root, 'outside'), target);
+        expect(() => approve({ file, scope: 'user', cwd: root, expectedDigest: digest })).toThrow(/symlink/i);
+    });
+});

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');
@@ -37,21 +50,307 @@ function fixture(root, mutate) {
     fs_1.default.writeFileSync(plan, markdown);
     return plan;
 }
+function v2Fixture(root, profile = 'mechanical') {
+    const plan = fixture(root, manifest => {
+        manifest.schema = 'compact-slices/v2';
+        const slices = manifest.slices;
+        slices[0].implementerProfile = profile;
+    });
+    fs_1.default.writeFileSync(plan, fs_1.default.readFileSync(plan, 'utf8').replace(START, '<!-- AWM:COMPACT-SLICES:START v2 -->').replace(END, '<!-- AWM:COMPACT-SLICES:END v2 -->'));
+    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.each(['mechanical', 'integration', 'judgment'])('accepts v2 with the exact %s implementer profile', profile => {
+        const report = (0, validate_1.validatePlanFile)(v2Fixture(root, profile), root);
+        expect(report).toMatchObject({ state: 'valid', schema: 'compact-slices/v2', manifest: { slices: [expect.objectContaining({ implementerProfile: profile })] } });
+    });
+    test('rejects v1 profile without weakening exact keys', () => {
+        expect((0, validate_1.validatePlanFile)(fixture(root, manifest => { (manifest.slices[0]).implementerProfile = 'mechanical'; }), root)).toMatchObject({ state: 'invalid' });
+    });
+    test.each([
+        ['missing profile', (text) => text.replace(/,\n\s*"implementerProfile": "mechanical"/, '')],
+        ['concrete model', (text) => text.replace('"implementerProfile": "mechanical"', '"implementerProfile": "mechanical",\n      "model": "vendor-model"')],
+        ['unknown profile', (text) => text.replace('"implementerProfile": "mechanical"', '"implementerProfile": "cheap"')],
+    ])('rejects v2 %s without weakening exact keys', (_name, mutate) => {
+        const plan = v2Fixture(root);
+        fs_1.default.writeFileSync(plan, mutate(fs_1.default.readFileSync(plan, 'utf8')));
+        expect((0, validate_1.validatePlanFile)(plan, root)).toMatchObject({ state: 'invalid' });
+    });
+    test('preserves v2 profile bytes in the execution identity', () => {
+        const mechanical = fs_1.default.readFileSync(v2Fixture(root, 'mechanical'), 'utf8');
+        const integration = mechanical.replace('"implementerProfile": "mechanical"', '"implementerProfile": "integration"');
+        const integrationPath = path_1.default.join(root, 'integration.md');
+        fs_1.default.writeFileSync(integrationPath, integration);
+        const left = (0, validate_1.validatePlanFile)(path_1.default.join(root, 'plan.md'), root);
+        const right = (0, validate_1.validatePlanFile)(integrationPath, root);
+        expect(left).toMatchObject({ state: 'valid', schema: 'compact-slices/v2' });
+        expect(right).toMatchObject({ state: 'valid', schema: 'compact-slices/v2' });
+        if (left.state !== 'valid' || right.state !== 'valid')
+            throw new Error('v2 fixture must validate');
+        expect(left.executionDigest).not.toBe(right.executionDigest);
+    });
+    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 +372,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');
@@ -122,7 +474,7 @@ describe('validatePlanFile', () => {
     test('keeps a future schema behind partial markers invalid rather than unsupported', () => {
         const plan = path_1.default.join(root, 'partial-future.md');
         fs_1.default.writeFileSync(plan, `${START}\n{"schema":"compact-slices/v2"}`);
-        expect((0, validate_1.validatePlanFile)(plan, root)).toMatchObject({ state: 'unsupported', schema: 'compact-slices/v2' });
+        expect((0, validate_1.validatePlanFile)(plan, root)).toMatchObject({ state: 'invalid', diagnostics: [expect.objectContaining({ code: 'PLAN_MARKERS' })] });
     });
     test('applies scalar limits before classifying a future schema as unsupported', () => {
         const plan = path_1.default.join(root, 'future-too-large.md');
@@ -229,12 +581,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 +594,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' })] });
@@ -419,7 +771,7 @@ describe('validatePlanFile', () => {
     test('recognizes a parseable future schema when only the END marker is broken', () => {
         const plan = path_1.default.join(root, 'future-missing-end.md');
         fs_1.default.writeFileSync(plan, `${START}\n{"schema":"compact-slices/v2"}\n`);
-        expect((0, validate_1.validatePlanFile)(plan, root)).toMatchObject({ state: 'unsupported', schema: 'compact-slices/v2' });
+        expect((0, validate_1.validatePlanFile)(plan, root)).toMatchObject({ state: 'invalid', diagnostics: [expect.objectContaining({ code: 'PLAN_MARKERS' })] });
     });
     test('accepts CRLF Markdown with nested headings and fenced code in a required section', () => {
         const plan = fixture(root);