agentic-workflow-manager 9.16.1 → 9.18.0

package/dist/tests/core/environments/resolve.test.js

@@ -0,0 +1,347 @@
+"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 catalog_1 = require("../../../src/core/facts/catalog");
+const resolve_1 = require("../../../src/core/environments/resolve");
+const store_1 = require("../../../src/core/environments/store");
+function isolateHome() {
+    const tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-env-resolve-'));
+    process.env.AWM_HOME = path_1.default.join(tmp, '.awm');
+    process.env.HOME = tmp;
+    return tmp;
+}
+const durableCatalog = (0, catalog_1.parseFactsCatalog)({
+    schemaVersion: 1,
+    facts: {
+        'repos.root': {
+            valueType: 'path',
+            durability: 'durable',
+            inject: 'reference',
+        },
+    },
+});
+const volatileCatalog = (0, catalog_1.parseFactsCatalog)({
+    schemaVersion: 1,
+    facts: {
+        'aws.token': {
+            valueType: 'string',
+            durability: 'volatile',
+            ttl: 1,
+            inject: 'reference',
+        },
+    },
+});
+/** Volatile + inject:context — required so the fresh-status gate in buildInjection is reachable. */
+const volatileContextCatalog = (0, catalog_1.parseFactsCatalog)({
+    schemaVersion: 1,
+    facts: {
+        'aws.token': {
+            valueType: 'string',
+            durability: 'volatile',
+            ttl: 1,
+            inject: 'context',
+        },
+    },
+});
+const contextCatalog = (0, catalog_1.parseFactsCatalog)({
+    schemaVersion: 1,
+    facts: {
+        'team.color': {
+            valueType: 'string',
+            durability: 'durable',
+            inject: 'context',
+        },
+        'team.nick': {
+            valueType: 'string',
+            durability: 'durable',
+            inject: 'context',
+        },
+        'repos.root': {
+            valueType: 'path',
+            durability: 'durable',
+            inject: 'reference',
+        },
+    },
+});
+describe('environment resolve / inject (RF-2.3–2.5, RF-3.1–3.2, RNF-2)', () => {
+    let tmp;
+    let prevHome;
+    let prevAwm;
+    beforeEach(() => {
+        prevHome = process.env.HOME;
+        prevAwm = process.env.AWM_HOME;
+        tmp = isolateHome();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmp, { recursive: true, force: true });
+        if (prevHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = prevHome;
+        if (prevAwm === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = prevAwm;
+    });
+    it('exports CONTEXT_INJECT_MAX_CHARS = 2048', () => {
+        expect(resolve_1.CONTEXT_INJECT_MAX_CHARS).toBe(2048);
+    });
+    it('durable value stays fresh after fake clock +1y (RF-2.3)', () => {
+        const store = {
+            'repos.root': {
+                value: '/x',
+                status: 'fresh',
+                updatedAt: '2025-01-01T00:00:00.000Z',
+            },
+        };
+        const now = new Date('2026-01-01T00:00:00.000Z');
+        expect((0, resolve_1.statusFor)(durableCatalog, store, now)).toEqual({ 'repos.root': 'fresh' });
+        const injection = (0, resolve_1.buildInjection)({
+            catalog: durableCatalog,
+            store,
+            storePath: '/store/values.json',
+            inject: 'reference',
+            now,
+        });
+        expect(injection.mode).toBe('reference');
+        expect(injection.values).toBeUndefined();
+    });
+    it('volatile+ttl elapsed + inject:context does not serve secret as fresh (RF-2.4/2.5)', () => {
+        const secret = 'secret-should-not-serve-as-fresh';
+        const store = {
+            'aws.token': {
+                value: secret,
+                status: 'fresh',
+                updatedAt: '2026-10-12T00:00:00.000Z',
+                expiresAt: '2026-10-12T00:00:01.000Z',
+            },
+        };
+        const now = new Date('2026-10-12T00:00:02.000Z');
+        expect((0, resolve_1.statusFor)(volatileContextCatalog, store, now)['aws.token']).toBe('stale');
+        // Catalog inject:context + request inject:context so omitting the stale/fresh
+        // gate would put `secret` into values and flip mode to context (mutation-proof).
+        const injection = (0, resolve_1.buildInjection)({
+            catalog: volatileContextCatalog,
+            store,
+            storePath: '/store/values.json',
+            inject: 'context',
+            now,
+            maxChars: 10_000,
+        });
+        expect(injection.mode).toBe('reference');
+        expect(injection.values).toBeUndefined();
+        expect(injection.values?.['aws.token']).toBeUndefined();
+        expect(JSON.stringify(injection)).not.toContain(secret);
+    });
+    it('stored status stale + inject:context does not inline the value (RF-2.4/2.5)', () => {
+        const secret = 'stale-context-secret-value';
+        const store = {
+            'aws.token': {
+                value: secret,
+                status: 'stale',
+                updatedAt: '2026-10-12T00:00:00.000Z',
+                expiresAt: '2026-10-12T00:00:01.000Z',
+            },
+        };
+        const now = new Date('2026-10-12T00:00:00.500Z'); // before expiresAt; stored status still stale
+        expect((0, resolve_1.statusFor)(volatileContextCatalog, store, now)['aws.token']).toBe('stale');
+        const injection = (0, resolve_1.buildInjection)({
+            catalog: volatileContextCatalog,
+            store,
+            storePath: '/store/values.json',
+            inject: 'context',
+            now,
+            maxChars: 10_000,
+        });
+        expect(injection.mode).toBe('reference');
+        expect(injection.values).toBeUndefined();
+        expect(JSON.stringify(injection)).not.toContain(secret);
+    });
+    it('missing fact → status missing, no default (RF-2.5)', () => {
+        expect((0, resolve_1.statusFor)(durableCatalog, {}, new Date())['repos.root']).toBe('missing');
+        const injection = (0, resolve_1.buildInjection)({
+            catalog: durableCatalog,
+            store: {},
+            storePath: '/store/values.json',
+            inject: 'context',
+            maxChars: 10_000,
+        });
+        expect(injection.values).toBeUndefined();
+        expect(injection.factIds).toContain('repos.root');
+    });
+    it('buildInjection({ inject: reference }) returns store path + ids, no values (RF-3.1)', () => {
+        const store = {
+            'team.color': { value: 'blue', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' },
+            'team.nick': { value: 'ace', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' },
+        };
+        const result = (0, resolve_1.buildInjection)({
+            catalog: contextCatalog,
+            store,
+            storePath: '/abs/environments/default/values.json',
+            inject: 'reference',
+        });
+        expect(result).toMatchObject({
+            mode: 'reference',
+            storePath: '/abs/environments/default/values.json',
+        });
+        expect(result.factIds).toEqual(expect.arrayContaining(['team.color', 'team.nick', 'repos.root']));
+        expect(result.values).toBeUndefined();
+        expect(JSON.stringify(result)).not.toContain('blue');
+        expect(JSON.stringify(result)).not.toContain('ace');
+    });
+    it('buildInjection omits inject option → default reference; no values even when context-fresh exist (RNF-2)', () => {
+        const store = {
+            'team.color': { value: 'blue', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' },
+            'team.nick': { value: 'ace', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' },
+        };
+        // No `inject` field: default must be reference. Mutating default to `context` would
+        // include blue/ace and fail these assertions.
+        const result = (0, resolve_1.buildInjection)({
+            catalog: contextCatalog,
+            store,
+            storePath: '/abs/environments/default/values.json',
+            maxChars: resolve_1.CONTEXT_INJECT_MAX_CHARS,
+        });
+        expect(result.mode).toBe('reference');
+        expect(result.values).toBeUndefined();
+        expect(JSON.stringify(result)).not.toContain('blue');
+        expect(JSON.stringify(result)).not.toContain('ace');
+    });
+    it('unknown/typo inject does not fail open into context; no values inlined (RNF-2)', () => {
+        const store = {
+            'team.color': { value: 'blue', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' },
+            'team.nick': { value: 'ace', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' },
+        };
+        // Runtime typo must not fall through into the context branch (fail-open).
+        const result = (0, resolve_1.buildInjection)({
+            catalog: contextCatalog,
+            store,
+            storePath: '/store/values.json',
+            inject: 'contezt',
+            maxChars: resolve_1.CONTEXT_INJECT_MAX_CHARS,
+        });
+        expect(result.mode).toBe('reference');
+        expect(result.values).toBeUndefined();
+        expect(JSON.stringify(result)).not.toContain('blue');
+        expect(JSON.stringify(result)).not.toContain('ace');
+    });
+    it('inject: context under budget includes fresh context values (RF-3.2)', () => {
+        const store = {
+            'team.color': { value: 'blue', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' },
+            'team.nick': { value: 'ace', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' },
+            'repos.root': { value: '/should-not-inline', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' },
+        };
+        const result = (0, resolve_1.buildInjection)({
+            catalog: contextCatalog,
+            store,
+            storePath: '/store/values.json',
+            inject: 'context',
+            maxChars: resolve_1.CONTEXT_INJECT_MAX_CHARS,
+        });
+        expect(result.mode).toBe('context');
+        expect(result.values).toEqual({
+            'team.color': 'blue',
+            'team.nick': 'ace',
+        });
+        expect(result.values).not.toHaveProperty('repos.root');
+        expect(result.warning).toBeUndefined();
+    });
+    it('inject: context over budget degrades to reference + warning (RF-3.2)', () => {
+        const store = {
+            'team.color': { value: 'blue', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' },
+            'team.nick': { value: 'ace', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' },
+        };
+        const result = (0, resolve_1.buildInjection)({
+            catalog: contextCatalog,
+            store,
+            storePath: '/store/values.json',
+            inject: 'context',
+            maxChars: 1,
+        });
+        expect(result.mode).toBe('reference');
+        expect(result.values).toBeUndefined();
+        expect(result.warning).toMatch(/budget|degrad/i);
+        expect(result.storePath).toBe('/store/values.json');
+        expect(JSON.stringify(result)).not.toMatch(/blue|ace/);
+    });
+    it('writeFact + statusFor: volatile ttl:1 with past updatedAt is stale', () => {
+        (0, store_1.writeFact)('default', 'aws.token', {
+            value: 'tok',
+            status: 'fresh',
+            updatedAt: '2026-10-12T00:00:00.000Z',
+        }, {
+            definition: volatileCatalog.facts['aws.token'],
+        });
+        const store = (0, store_1.readValues)('default');
+        const now = new Date('2026-10-12T00:00:02.000Z');
+        expect((0, resolve_1.statusFor)(volatileCatalog, store, now)['aws.token']).toBe('stale');
+    });
+    it('volatile: now >= expiresAt is stale; missing/garbage expiresAt is stale; null now throws', () => {
+        const expired = {
+            'aws.token': {
+                value: 'tok',
+                status: 'fresh',
+                updatedAt: '2026-10-12T00:00:00.000Z',
+                expiresAt: '2026-10-12T00:00:01.000Z',
+            },
+        };
+        // Exact boundary: now === expiresAt → stale (>=, not >).
+        expect((0, resolve_1.statusFor)(volatileCatalog, expired, new Date('2026-10-12T00:00:01.000Z'))['aws.token']).toBe('stale');
+        // One ms before boundary stays fresh.
+        expect((0, resolve_1.statusFor)(volatileCatalog, expired, new Date('2026-10-12T00:00:00.999Z'))['aws.token']).toBe('fresh');
+        const missingExpires = {
+            'aws.token': {
+                value: 'tok',
+                status: 'fresh',
+                updatedAt: '2026-10-12T00:00:00.000Z',
+            },
+        };
+        expect((0, resolve_1.statusFor)(volatileCatalog, missingExpires, new Date())['aws.token']).toBe('stale');
+        const garbageExpires = {
+            'aws.token': {
+                value: 'tok',
+                status: 'fresh',
+                updatedAt: '2026-10-12T00:00:00.000Z',
+                expiresAt: 'not-a-date',
+            },
+        };
+        expect((0, resolve_1.statusFor)(volatileCatalog, garbageExpires, new Date())['aws.token']).toBe('stale');
+        expect(() => (0, resolve_1.statusFor)(volatileCatalog, expired, null)).toThrow(/now|Date/i);
+        expect(() => (0, resolve_1.buildInjection)({
+            catalog: volatileCatalog,
+            store: expired,
+            storePath: '/store/values.json',
+            now: new Date(Number.NaN),
+        })).toThrow(/now|Date/i);
+    });
+    it('inject: context mixed fresh+stale inlines only fresh (RF-3.2)', () => {
+        const store = {
+            'team.color': { value: 'blue', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' },
+            'team.nick': { value: 'stale-nick', status: 'stale', updatedAt: '2026-10-12T00:00:00.000Z' },
+        };
+        const result = (0, resolve_1.buildInjection)({
+            catalog: contextCatalog,
+            store,
+            storePath: '/store/values.json',
+            inject: 'context',
+            maxChars: resolve_1.CONTEXT_INJECT_MAX_CHARS,
+        });
+        expect(result.mode).toBe('context');
+        expect(result.values).toEqual({ 'team.color': 'blue' });
+        expect(result.values).not.toHaveProperty('team.nick');
+        expect(JSON.stringify(result)).not.toContain('stale-nick');
+    });
+    it('buildInjection rejects non-array factIds (string must not spread to chars)', () => {
+        expect(() => (0, resolve_1.buildInjection)({
+            catalog: durableCatalog,
+            store: {},
+            storePath: '/store/values.json',
+            factIds: 'repos.root',
+        })).toThrow(/factIds/i);
+    });
+});

package/dist/tests/core/environments/store.test.js

@@ -0,0 +1,248 @@
+"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 store_1 = require("../../../src/core/environments/store");
+const registries_1 = require("../../../src/core/registries");
+function isolateHome() {
+    const tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-env-store-'));
+    process.env.AWM_HOME = path_1.default.join(tmp, '.awm');
+    process.env.HOME = tmp;
+    return tmp;
+}
+describe('environment store (RF-2.1, RF-2.2, RNF-1)', () => {
+    let tmp;
+    let prevHome;
+    let prevAwm;
+    beforeEach(() => {
+        prevHome = process.env.HOME;
+        prevAwm = process.env.AWM_HOME;
+        tmp = isolateHome();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmp, { recursive: true, force: true });
+        if (prevHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = prevHome;
+        if (prevAwm === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = prevAwm;
+    });
+    it('environmentsRoot is under AWM_HOME/environments (RF-2.1)', () => {
+        expect((0, store_1.environmentsRoot)()).toBe(path_1.default.join(process.env.AWM_HOME, 'environments'));
+    });
+    it('set writes only under AWM_HOME/environments/default/values.json (RF-2.1)', () => {
+        (0, store_1.writeFact)('default', 'repos.root', {
+            value: '/machine/repos',
+            status: 'fresh',
+            updatedAt: '2026-10-12T00:00:00.000Z',
+        });
+        const expected = path_1.default.join(process.env.AWM_HOME, 'environments', 'default', 'values.json');
+        expect((0, store_1.valuesPath)('default')).toBe(expected);
+        expect(fs_1.default.existsSync(expected)).toBe(true);
+        const parsed = JSON.parse(fs_1.default.readFileSync(expected, 'utf-8'));
+        expect(parsed['repos.root']).toMatchObject({
+            value: '/machine/repos',
+            status: 'fresh',
+        });
+        // Nothing written outside environments/
+        const awm = process.env.AWM_HOME;
+        const entries = fs_1.default.readdirSync(awm);
+        expect(entries).toEqual(['environments']);
+    });
+    it('maintains exactly one active environment; first writeFact activates that name (RF-2.2)', () => {
+        expect((0, store_1.getActiveEnvironmentName)()).toBe('default');
+        // First materialization activates the env being written — not a hardcoded default.
+        (0, store_1.writeFact)('staging', 'repos.root', {
+            value: '/a',
+            status: 'fresh',
+            updatedAt: '2026-10-12T00:00:00.000Z',
+        });
+        expect((0, store_1.getActiveEnvironmentName)()).toBe('staging');
+        (0, store_1.setActiveEnvironmentName)('default');
+        expect((0, store_1.getActiveEnvironmentName)()).toBe('default');
+        (0, store_1.writeFact)('default', 'repos.root', {
+            value: '/b',
+            status: 'fresh',
+            updatedAt: '2026-10-12T00:00:00.000Z',
+        });
+        expect((0, store_1.getActiveEnvironmentName)()).toBe('default');
+        (0, store_1.setActiveEnvironmentName)('staging');
+        expect((0, store_1.getActiveEnvironmentName)()).toBe('staging');
+    });
+    it('readValues returns empty object when store file is missing', () => {
+        expect((0, store_1.readValues)('default')).toEqual({});
+    });
+    it('on volatile write sets expiresAt from updatedAt + ttlSeconds', () => {
+        const def = {
+            valueType: 'string',
+            resolution: 'prompt',
+            durability: 'volatile',
+            inject: 'reference',
+            ttl: 60,
+        };
+        (0, store_1.writeFact)('default', 'aws.token', {
+            value: 'tok',
+            status: 'fresh',
+            updatedAt: '2026-10-12T00:00:00.000Z',
+        }, { definition: def });
+        const stored = (0, store_1.readValues)('default')['aws.token'];
+        expect(stored.expiresAt).toBe('2026-10-12T00:01:00.000Z');
+    });
+    it('writeEnvValue refuses a target inside a registry tree (RNF-1)', () => {
+        const registryRoot = path_1.default.join(tmp, 'fake-registry');
+        fs_1.default.mkdirSync(path_1.default.join(registryRoot, 'skills'), { recursive: true });
+        const badTarget = path_1.default.join(registryRoot, 'environments', 'default', 'values.json');
+        expect(() => (0, store_1.writeEnvValue)(badTarget, { 'repos.root': { value: 'x', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' } }, {
+            registryRoots: [registryRoot],
+        })).toThrow(store_1.EnvironmentStoreError);
+        expect(() => (0, store_1.writeEnvValue)(badTarget, { 'repos.root': { value: 'x', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' } }, {
+            registryRoots: [registryRoot],
+        })).toThrow(/registry/i);
+        expect(fs_1.default.existsSync(badTarget)).toBe(false);
+    });
+    it('refuses write when AWM_HOME/environments is a symlink into a registry root (RNF-1)', () => {
+        const registryRoot = path_1.default.join(tmp, 'fake-registry');
+        const registryEnvLanding = path_1.default.join(registryRoot, 'hijacked-env');
+        fs_1.default.mkdirSync(registryEnvLanding, { recursive: true });
+        const awm = process.env.AWM_HOME;
+        fs_1.default.mkdirSync(awm, { recursive: true });
+        // Lexical path is under AWM_HOME; realpath lands inside the registry.
+        fs_1.default.symlinkSync(registryEnvLanding, path_1.default.join(awm, 'environments'));
+        expect(() => (0, store_1.writeFact)('default', 'repos.root', { value: '/leaked', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' }, { registryRoots: [registryRoot] })).toThrow(store_1.EnvironmentStoreError);
+        expect(() => (0, store_1.writeFact)('default', 'repos.root', { value: '/leaked', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' }, { registryRoots: [registryRoot] })).toThrow(/registry/i);
+        // Nothing materialised inside the registry landing dir.
+        expect(fs_1.default.readdirSync(registryEnvLanding)).toEqual([]);
+        expect(fs_1.default.existsSync(path_1.default.join(registryEnvLanding, 'default', 'values.json'))).toBe(false);
+    });
+    it('writeFact rejects empty path valueType without mutating store', () => {
+        const def = {
+            valueType: 'path',
+            resolution: 'prompt',
+            durability: 'durable',
+            inject: 'reference',
+        };
+        expect(() => (0, store_1.writeFact)('default', 'repos.root', { value: '', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' }, { definition: def })).toThrow(store_1.EnvironmentStoreError);
+        expect((0, store_1.readValues)('default')).toEqual({});
+    });
+    it('writeFact rejects unknown id when catalog is provided', () => {
+        expect(() => (0, store_1.writeFact)('default', 'unknown.fact', { value: 'x', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' }, {
+            catalog: { schemaVersion: 1, facts: { 'repos.root': {
+                        valueType: 'path',
+                        resolution: 'prompt',
+                        durability: 'durable',
+                        inject: 'reference',
+                    } } },
+            consultedRoots: ['/tmp/reg-a', '/tmp/reg-b'],
+        })).toThrow(/unknown\.fact/);
+        expect(() => (0, store_1.writeFact)('default', 'unknown.fact', { value: 'x', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' }, {
+            catalog: { schemaVersion: 1, facts: {} },
+            consultedRoots: ['/tmp/reg-a'],
+        })).toThrow(/reg-a/);
+        expect((0, store_1.readValues)('default')).toEqual({});
+    });
+    it('writeFact with catalog rejects prototype key id toString', () => {
+        expect(() => (0, store_1.writeFact)('default', 'toString', { value: 'x', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' }, {
+            catalog: {
+                schemaVersion: 1,
+                facts: {
+                    'repos.root': {
+                        valueType: 'path',
+                        resolution: 'prompt',
+                        durability: 'durable',
+                        inject: 'reference',
+                    },
+                },
+            },
+            consultedRoots: ['/tmp/reg'],
+        })).toThrow(/toString|Unknown fact/i);
+        expect((0, store_1.readValues)('default')).toEqual({});
+    });
+    it('assertEnvName rejects NUL, meta.json, values.json (case-insensitive)', () => {
+        expect(() => (0, store_1.writeFact)('meta.json', 'repos.root', {
+            value: '/x',
+            status: 'fresh',
+            updatedAt: '2026-10-12T00:00:00.000Z',
+        })).toThrow(store_1.EnvironmentStoreError);
+        expect(() => (0, store_1.writeFact)('META.JSON', 'repos.root', {
+            value: '/x',
+            status: 'fresh',
+            updatedAt: '2026-10-12T00:00:00.000Z',
+        })).toThrow(/reserved/i);
+        expect(() => (0, store_1.writeFact)('Values.json', 'repos.root', {
+            value: '/x',
+            status: 'fresh',
+            updatedAt: '2026-10-12T00:00:00.000Z',
+        })).toThrow(/reserved/i);
+        expect(() => (0, store_1.writeFact)('values.json', 'repos.root', {
+            value: '/x',
+            status: 'fresh',
+            updatedAt: '2026-10-12T00:00:00.000Z',
+        })).toThrow(store_1.EnvironmentStoreError);
+        expect(() => (0, store_1.writeFact)('bad\0name', 'repos.root', {
+            value: '/x',
+            status: 'fresh',
+            updatedAt: '2026-10-12T00:00:00.000Z',
+        })).toThrow(store_1.EnvironmentStoreError);
+        expect(() => (0, store_1.setActiveEnvironmentName)('   ')).toThrow(store_1.EnvironmentStoreError);
+    });
+    it('readValues rejects __proto__ fact id (prototype pollution)', () => {
+        const file = (0, store_1.valuesPath)('default');
+        fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+        // Raw JSON — object-literal __proto__ would set [[Prototype]], not an own key.
+        fs_1.default.writeFileSync(file, '{"__proto__":{"value":"x","status":"fresh","updatedAt":"2026-10-12T00:00:00.000Z"}}\n');
+        expect(() => (0, store_1.readValues)('default')).toThrow(/forbidden|__proto__/i);
+    });
+    it('getActiveEnvironmentName asserts active from meta (corrupt → throw)', () => {
+        const meta = path_1.default.join(process.env.AWM_HOME, 'environments', 'meta.json');
+        fs_1.default.mkdirSync(path_1.default.dirname(meta), { recursive: true });
+        fs_1.default.writeFileSync(meta, JSON.stringify({ active: 'meta.json' }) + '\n');
+        expect(() => (0, store_1.getActiveEnvironmentName)()).toThrow(store_1.EnvironmentStoreError);
+    });
+    it('registryRoots:[] still unions contentRoots() — cannot bypass RNF-1', () => {
+        const regName = 'guard-reg';
+        (0, registries_1.writeRegistriesConfig)([{ name: regName, remote: 'https://example.test/guard.git' }]);
+        const regRoot = (0, registries_1.registryContentRoot)(regName);
+        fs_1.default.mkdirSync(path_1.default.join(regRoot, 'skills'), { recursive: true });
+        const badTarget = path_1.default.join(regRoot, 'environments', 'default', 'values.json');
+        // Explicit empty array must NOT disable checks — contentRoots() still applies.
+        expect(() => (0, store_1.writeEnvValue)(badTarget, {
+            'repos.root': {
+                value: '/leaked',
+                status: 'fresh',
+                updatedAt: '2026-10-12T00:00:00.000Z',
+            },
+        }, { registryRoots: [] })).toThrow(/registry/i);
+        expect(fs_1.default.existsSync(badTarget)).toBe(false);
+    });
+    it('writeEnvValue validates each stored entry before write', () => {
+        const target = path_1.default.join(process.env.AWM_HOME, 'environments', 'default', 'values.json');
+        expect(() => (0, store_1.writeEnvValue)(target, {
+            'repos.root': { value: 1, status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' },
+        })).toThrow(store_1.EnvironmentStoreError);
+        expect(fs_1.default.existsSync(target)).toBe(false);
+    });
+    it('withExpiresAt requires finite ttl for volatile and catches RangeError', () => {
+        const noTtl = {
+            valueType: 'string',
+            resolution: 'prompt',
+            durability: 'volatile',
+            inject: 'reference',
+        };
+        expect(() => (0, store_1.writeFact)('default', 'aws.token', { value: 'tok', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' }, { definition: noTtl })).toThrow(/ttl/i);
+        const huge = {
+            valueType: 'string',
+            resolution: 'prompt',
+            durability: 'volatile',
+            inject: 'reference',
+            ttl: Number.MAX_SAFE_INTEGER,
+        };
+        expect(() => (0, store_1.writeFact)('default', 'aws.token', { value: 'tok', status: 'fresh', updatedAt: '2026-10-12T00:00:00.000Z' }, { definition: huge })).toThrow(store_1.EnvironmentStoreError);
+    });
+});