agentic-workflow-manager 9.20.4 → 9.22.0

package/dist/tests/commands/change/validate-unmeasured.test.js

@@ -0,0 +1,246 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 path_1 = __importDefault(require("path"));
+const helpers_1 = require("../../core/changes/helpers");
+const change_1 = require("../../../src/commands/change");
+const receipt_1 = require("../../../src/core/changes/receipt");
+const types_1 = require("../../../src/core/changes/types");
+const gitModule = __importStar(require("../../../src/core/changes/git"));
+const REAL_CHANGES_DIR = path_1.default.resolve(__dirname, '..', '..', '..', '..', 'docs', 'changes');
+const listReal = () => { try {
+    return fs_1.default.readdirSync(REAL_CHANGES_DIR).sort();
+}
+catch {
+    return null;
+} };
+const realBefore = listReal();
+afterEach(() => expect(listReal()).toEqual(realBefore));
+let repo;
+let template;
+const now = () => new Date('2026-10-17T12:00:00.000Z');
+const REL = 'docs/changes/2026-10-17-rec.md';
+const abs = (rel) => path_1.default.join(repo.root, ...rel.split('/'));
+beforeAll(() => {
+    template = (0, helpers_1.makeRepo)();
+    template.git('checkout', '-q', '-b', 'feat/x');
+    // Track sensors.json / baseline for RF-4.5 always-measured late-path cases (default makeRepo ignores `.awm/`).
+    template.commit({
+        '.gitignore': 'node_modules\n.awm/sensors/runs\n.awm/journal\n.awm/ledger\n.awm/evidence\n',
+        'cli/src/a.ts': '1',
+        'cli/package.json': '{"name":"cli"}',
+        'cli/package-lock.json': '{"lockfileVersion":3}',
+        '.awm/sensors.json': '{"schemaVersion":2,"pack":"js-ts","sensors":{}}',
+        '.awm/sensors.baseline.json': '{}',
+        'README.md': '# root\n',
+    }, 'feat(changes): a');
+});
+afterAll(() => template.cleanup());
+beforeEach(() => { repo = (0, helpers_1.cloneRepo)(template); });
+afterEach(() => { jest.restoreAllMocks(); repo.cleanup(); });
+const DIGEST = `sha256:${'a'.repeat(64)}`;
+const FINGERPRINT = `sha256:${'b'.repeat(64)}`;
+function measurement(overrides = {}) {
+    return {
+        inputs: ['src/**/*.ts'],
+        packageRootRel: 'cli',
+        inputDigest: DIGEST,
+        sensorFingerprint: FINGERPRINT,
+        measuredPaths: ['cli/src/a.ts', '.awm/sensors.json', 'cli/package.json', 'cli/package-lock.json'],
+        ...overrides,
+    };
+}
+function writeSchema2Receipt(args) {
+    const head = repo.git('rev-parse', 'HEAD');
+    const sensors = args.sensors.map((name) => ({
+        name,
+        status: 'pass',
+        errors: [],
+        ...(args.measurements?.[name]
+            ? { measurement: args.measurements[name] }
+            : {}),
+    }));
+    (0, receipt_1.writeReceipt)(repo.root, (0, receipt_1.buildReceipt)({
+        commit: head,
+        ranAt: '2026-10-17T11:00:00.000Z',
+        cliVersion: '9.21.0',
+        output: { overall: 'pass', sensors },
+        alwaysMeasuredPaths: args.alwaysMeasuredPaths ?? [
+            '.awm/sensors.json',
+            '.awm/sensors.baseline.json',
+            'cli/package.json',
+            'cli/package-lock.json',
+        ],
+    }));
+}
+function commitRecord(slug = 'rec', receipt = () => writeSchema2Receipt({
+    sensors: ['lint', 'typecheck'],
+    measurements: { lint: measurement(), typecheck: measurement({ inputs: ['src/**/*.ts'] }) },
+})) {
+    receipt();
+    expect((0, change_1.runChangeNew)(repo.root, slug, {}, { now }).code).toBe(0);
+    const rel = `docs/changes/2026-10-17-${slug}.md`;
+    fs_1.default.writeFileSync(abs(rel), fs_1.default.readFileSync(abs(rel), 'utf8').split(types_1.PENDING_MARKER).join('filled'));
+    repo.git('add', '-A');
+    repo.git('commit', '-q', '-m', `docs(changes): ${slug}`);
+    return rel;
+}
+const run = (target = undefined, opts = {}) => (0, change_1.runChangeValidate)(repo.root, target, { json: true, ...opts });
+const report = (r) => JSON.parse(r.stdout);
+const diagsOf = (r, index = 0) => report(r).records[index].diagnostics;
+const codesOf = (r, index = 0) => diagsOf(r, index).map((d) => d.code);
+function diag(r, code, field) {
+    const found = diagsOf(r).filter((d) => d.code === code);
+    expect(found).toHaveLength(1);
+    expect(found[0].field).toBe(field);
+    return found[0];
+}
+describe('RF-4.5/4.6 schema 2 unmeasured late paths', () => {
+    test('RF-4.5: README-only after verify is OK when every sensor had authored inputs', () => {
+        commitRecord();
+        repo.commit({ 'README.md': '# docs only\n' }, 'docs: readme');
+        expect(codesOf(run())).not.toContain('code-changed-after-verification');
+        expect(report(run()).state).toBe('valid');
+    });
+    test('RF-4.6: any sensor without authored inputs keeps schema-1 late rules (README fails)', () => {
+        commitRecord('rec', () => writeSchema2Receipt({
+            sensors: ['lint', 'test'],
+            measurements: { lint: measurement() }, // test has no measurement / no authored inputs
+        }));
+        repo.commit({ 'README.md': '# docs only\n' }, 'docs: readme');
+        expect(codesOf(run())).toContain('code-changed-after-verification');
+        expect(diag(run(), 'code-changed-after-verification', undefined).message).toContain('README.md');
+    });
+    test('RF-4.5: measured path late still fails when relaxation applies', () => {
+        commitRecord();
+        repo.commit({ 'cli/src/a.ts': '2' }, 'fix: measured');
+        expect(codesOf(run())).toContain('code-changed-after-verification');
+        expect(diag(run(), 'code-changed-after-verification', undefined).message).toContain('cli/src/a.ts');
+    });
+    test('RF-4.5: NEW file matching authored inputs globs after verify fails (not frozen measuredPaths only)', () => {
+        // Certify with measuredPaths frozen to a.ts only; a later matching source must still count.
+        commitRecord('rec', () => writeSchema2Receipt({
+            sensors: ['lint'],
+            measurements: {
+                lint: measurement({
+                    inputs: ['src/**/*.ts'],
+                    packageRootRel: 'cli',
+                    measuredPaths: ['cli/src/a.ts', '.awm/sensors.json', 'cli/package.json', 'cli/package-lock.json'],
+                }),
+            },
+        }));
+        repo.commit({ 'cli/src/brand-new.ts': 'export const x = 1;\n' }, 'feat: new matching source');
+        expect(codesOf(run())).toContain('code-changed-after-verification');
+        expect(diag(run(), 'code-changed-after-verification', undefined).message).toContain('cli/src/brand-new.ts');
+    });
+    test('RF-4.5: sensors.json late fails (always-measured)', () => {
+        commitRecord();
+        repo.commit({ '.awm/sensors.json': '{"schemaVersion":2,"pack":"js-ts","sensors":{"lint":{"enabled":false}}}' }, 'chore: sensors');
+        expect(codesOf(run())).toContain('code-changed-after-verification');
+        expect(diag(run(), 'code-changed-after-verification', undefined).message).toContain('.awm/sensors.json');
+    });
+    test('RF-4.5: lockfile late fails (always-measured)', () => {
+        commitRecord();
+        repo.commit({ 'cli/package-lock.json': '{"lockfileVersion":3,"x":1}' }, 'chore: lock');
+        expect(codesOf(run())).toContain('code-changed-after-verification');
+        expect(diag(run(), 'code-changed-after-verification', undefined).message).toContain('cli/package-lock.json');
+    });
+    test('RF-4.5: baseline.json late fails (validate always-measured includes baseline, unlike cache)', () => {
+        commitRecord();
+        repo.commit({ '.awm/sensors.baseline.json': '{"lint":[]}' }, 'chore: baseline');
+        expect(codesOf(run())).toContain('code-changed-after-verification');
+        expect(diag(run(), 'code-changed-after-verification', undefined).message).toContain('.awm/sensors.baseline.json');
+    });
+    test('RF-4.8: monorepo packageRoot paths compare as repo-root POSIX', () => {
+        commitRecord('rec', () => writeSchema2Receipt({
+            sensors: ['lint'],
+            measurements: {
+                lint: measurement({
+                    inputs: ['src/**/*.ts'],
+                    measuredPaths: ['cli/src/a.ts', '.awm/sensors.json', 'cli/package.json', 'cli/package-lock.json'],
+                }),
+            },
+        }));
+        repo.commit({ 'cli/src/a.ts': 'changed' }, 'fix: under packageRoot');
+        const d = diag(run(), 'code-changed-after-verification', undefined);
+        expect(d.message).toContain('cli/src/a.ts');
+        expect(d.message).not.toMatch(/(^|[^/])src\/a\.ts/);
+    });
+    test('schema 1 receipts keep strict late rules (only docs/changes carved out)', () => {
+        const head = repo.git('rev-parse', 'HEAD');
+        // Force a schema-1 write through the legacy shape helper used by older tests.
+        const { writeReceipt: write, computeReceiptDigest } = require('../../../src/core/changes/receipt');
+        const body = {
+            schema: 1,
+            commit: head,
+            ranAt: '2026-10-17T11:00:00.000Z',
+            cliVersion: '9.20.0',
+            overall: 'pass',
+            sensors: { lint: 'pass' },
+        };
+        // buildReceipt now yields schema 2; write a raw schema-1 receipt for this fixture.
+        const digest = computeReceiptDigest(body);
+        write(repo.root, { ...body, digest });
+        expect((0, change_1.runChangeNew)(repo.root, 'rec', {}, { now }).code).toBe(0);
+        fs_1.default.writeFileSync(abs(REL), fs_1.default.readFileSync(abs(REL), 'utf8').split(types_1.PENDING_MARKER).join('filled'));
+        repo.git('add', '-A');
+        repo.git('commit', '-q', '-m', 'docs(changes): rec');
+        repo.commit({ 'README.md': '# docs\n' }, 'docs: readme');
+        expect(codesOf(run())).toContain('code-changed-after-verification');
+    });
+    test('RF-E.2: git failure listing late files is git-failed (fail closed)', () => {
+        commitRecord();
+        const verified = repo.git('rev-parse', 'HEAD~1');
+        const real = gitModule.changedFiles;
+        jest.spyOn(gitModule, 'changedFiles').mockImplementation((root, from, to) => (from === verified ? null : real(root, from, to)));
+        const r = run();
+        expect(r.code).toBe(2);
+        expect(diag(r, 'git-failed', undefined).message).toContain('git could not list the files changed since');
+    });
+});
+describe('RF-4.7 change new remedy honesty', () => {
+    test('missing HEAD receipt remedy names full-gate sensors run and does not claim every binary must re-exec', () => {
+        const r = (0, change_1.runChangeNew)(repo.root, 'rec', {}, { now });
+        expect(r.code).toBe(2);
+        expect(r.stderr).toMatch(/^receipt-missing: /);
+        expect(r.stderr).toMatch(/full-gate awm sensors run/);
+        expect(r.stderr.toLowerCase()).not.toMatch(/every tool|re-exec|reexecute|must re-run every/);
+        expect(r.stderr).toMatch(/cache/i);
+    });
+});

package/dist/tests/commands/preflight/awm-gitignore.test.js

@@ -0,0 +1,52 @@
+"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 child_process_1 = require("child_process");
+const checks_1 = require("../../../src/commands/preflight/checks");
+const awm_gitignore_1 = require("../../../src/core/awm-gitignore");
+function git(cwd, args) {
+    (0, child_process_1.execFileSync)('git', args, { cwd, stdio: 'pipe' });
+}
+describe('preflight awm-gitignore check (GI-6/GI-7)', () => {
+    let repo;
+    beforeEach(() => {
+        repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-gi-pf-'));
+        git(repo, ['init']);
+        git(repo, ['config', 'user.email', 't@t']);
+        git(repo, ['config', 'user.name', 't']);
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(repo, { recursive: true, force: true });
+    });
+    it('degrades when versioned sensors.json is ignored', async () => {
+        fs_1.default.mkdirSync(path_1.default.join(repo, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(repo, '.awm', 'sensors.json'), JSON.stringify({
+            schemaVersion: 3, mode: 'opt-out', reason: 'test',
+        }));
+        fs_1.default.writeFileSync(path_1.default.join(repo, '.gitignore'), '.awm/\n');
+        const report = await (0, checks_1.preflight)(repo);
+        const check = report.checks.find((c) => c.id === 'awm-gitignore');
+        expect(check).toBeDefined();
+        expect(check.ok).toBe(false);
+        expect(check.advisory).not.toBe(true);
+        expect(check.remedy).toMatch(/awm sensors init|awm watch init/);
+        expect(report.status).not.toBe('ready');
+    });
+    it('includes a passing awm-gitignore check when managed block is present for opt-out manifest', async () => {
+        fs_1.default.mkdirSync(path_1.default.join(repo, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(repo, '.awm', 'sensors.json'), JSON.stringify({
+            schemaVersion: 3, mode: 'opt-out', reason: 'test',
+        }));
+        (0, awm_gitignore_1.upsertAwmGitignore)(repo);
+        git(repo, ['add', '-A']);
+        git(repo, ['commit', '-m', 'ok']);
+        const report = await (0, checks_1.preflight)(repo);
+        const check = report.checks.find((c) => c.id === 'awm-gitignore');
+        expect(check).toMatchObject({ ok: true });
+    });
+});

package/dist/tests/commands/preflight/sensors-inputs.test.js

@@ -0,0 +1,110 @@
+"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 checks_1 = require("../../../src/commands/preflight/checks");
+const preflight_1 = require("../../../src/commands/preflight");
+/**
+ * RF-3.4 — preflight surfaces a non-blocking (advisory) warning when configured
+ * enabled sensors lack effective `inputs`. Opt-out / native-gate must stay quiet.
+ */
+describe('preflight sensors-inputs warning (RF-3.4)', () => {
+    const dirs = [];
+    const homes = [];
+    let previousHome;
+    beforeEach(() => {
+        previousHome = process.env.AWM_HOME;
+        const home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-pf-inputs-home-'));
+        homes.push(home);
+        process.env.AWM_HOME = home;
+        fs_1.default.writeFileSync(path_1.default.join(home, 'registries.json'), JSON.stringify([]));
+    });
+    afterEach(() => {
+        if (previousHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = previousHome;
+    });
+    afterAll(() => {
+        for (const dir of dirs)
+            fs_1.default.rmSync(dir, { recursive: true, force: true });
+        for (const home of homes)
+            fs_1.default.rmSync(home, { recursive: true, force: true });
+    });
+    function project(opts = {}) {
+        const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-pf-inputs-'));
+        dirs.push(dir);
+        for (const f of opts.context ?? ['AGENTS.md']) {
+            fs_1.default.writeFileSync(path_1.default.join(dir, f), '# ctx\n');
+        }
+        for (const b of opts.bins ?? ['eslint']) {
+            fs_1.default.mkdirSync(path_1.default.join(dir, 'node_modules', '.bin'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(dir, 'node_modules', '.bin', b), '');
+        }
+        if (opts.manifest !== undefined) {
+            fs_1.default.mkdirSync(path_1.default.join(dir, '.awm'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(dir, '.awm', 'sensors.json'), typeof opts.manifest === 'string' ? opts.manifest : JSON.stringify(opts.manifest));
+        }
+        return dir;
+    }
+    function check(report, id) {
+        return report.checks.find(c => c.id === id);
+    }
+    function onlyProjectSensor(extra = {}) {
+        return {
+            schemaVersion: 3,
+            mode: 'project-sensors',
+            sensors: {
+                custom: {
+                    source: 'project',
+                    enabled: true,
+                    command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+                    formatter: 'exit-code',
+                    ...extra,
+                },
+            },
+        };
+    }
+    it('emits an advisory sensors-inputs warning when an enabled sensor lacks inputs', async () => {
+        const dir = project({ manifest: onlyProjectSensor() });
+        const report = await (0, checks_1.preflight)(dir);
+        expect(report.status).toBe('ready');
+        expect((0, preflight_1.exitCodeFor)(report)).toBe(0);
+        expect(check(report, 'sensors-inputs')).toMatchObject({
+            ok: false,
+            advisory: true,
+            detail: expect.stringMatching(/custom/i),
+            remedy: expect.stringMatching(/inputs|cache/i),
+        });
+        expect(check(report, 'sensors-inputs').detail).toMatch(/not cacheable|no effective inputs|lacks inputs/i);
+        expect((0, preflight_1.formatReport)(report)).toMatch(/⚠.*sensors-inputs/s);
+    });
+    it('omits sensors-inputs when every enabled sensor has effective inputs', async () => {
+        const dir = project({ manifest: onlyProjectSensor({ inputs: ['**/*.ts'] }) });
+        const report = await (0, checks_1.preflight)(dir);
+        expect(report.status).toBe('ready');
+        expect(check(report, 'sensors-inputs')).toBeUndefined();
+    });
+    it('does not warn for disabled sensors that lack inputs', async () => {
+        const dir = project({
+            manifest: onlyProjectSensor({ enabled: false }),
+        });
+        const report = await (0, checks_1.preflight)(dir);
+        expect(check(report, 'sensors-inputs')).toBeUndefined();
+    });
+    it.each([
+        ['native-gate', 'CI is authoritative.', 'native_gate'],
+        ['opt-out', 'No local gate.', 'ungated'],
+    ])('emits no sensors-inputs warning for v3 %s', async (mode, reason, status) => {
+        const dir = project({
+            manifest: { schemaVersion: 3, mode, reason },
+        });
+        const report = await (0, checks_1.preflight)(dir);
+        expect(report.status).toBe(status);
+        expect(check(report, 'sensors-inputs')).toBeUndefined();
+    });
+});

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

@@ -302,4 +302,64 @@ describe('sensor pack v2 contract', () => {
     ])('rejects malformed pack %j', (input, message) => {
         expect(() => (0, contract_1.parseSensorPack)(input, 'pack.json')).toThrow(message);
     });
+    describe('inputs and sensor-level closureOnly (RF-1.1, RF-1.2, RF-1.5, RF-1.7)', () => {
+        it('accepts inputs on variants and closureOnly on the sensor (RF-1.2 pack defaults)', () => {
+            const pack = validPack();
+            pack.sensors.lint.closureOnly = true;
+            pack.sensors.lint.variants[0].inputs = ['**/*.ts', '**/*.[cm]js'];
+            expect((0, contract_1.parseSensorPack)(pack, 'pack.json')).toMatchObject({
+                kind: 'v2',
+                pack: {
+                    sensors: {
+                        lint: {
+                            closureOnly: true,
+                            variants: [{ inputs: ['**/*.ts', '**/*.[cm]js'] }],
+                        },
+                    },
+                },
+            });
+        });
+        it('treats omitted sensor closureOnly as false and does not invent variant inputs', () => {
+            const parsed = (0, contract_1.parseSensorPack)(validPack(), 'pack.json');
+            expect(parsed).toMatchObject({ kind: 'v2' });
+            if (parsed.kind !== 'v2')
+                throw new Error('expected v2 pack');
+            const lint = parsed.pack.sensors.lint;
+            expect(lint.closureOnly ?? false).toBe(false);
+            expect('inputs' in lint.variants[0]).toBe(false);
+        });
+        it('rejects closureOnly on a variant (RF-1.7 sensor-level only)', () => {
+            const pack = validPack();
+            pack.sensors.lint.variants[0].closureOnly = true;
+            expect(() => (0, contract_1.parseSensorPack)(pack, 'pack.json')).toThrow(/unknown field "closureOnly"/);
+        });
+        it('rejects inputs on the sensor object (inputs belong on variants)', () => {
+            const pack = validPack();
+            pack.sensors.lint.inputs = ['**/*.ts'];
+            expect(() => (0, contract_1.parseSensorPack)(pack, 'pack.json')).toThrow(/unknown field "inputs"/);
+        });
+        it.each([
+            [[''], /nonempty single-line/],
+            [['/abs'], /absolute paths are invalid/],
+            [['has\u0000nul'], /NUL or control/],
+            [['../escape'], /contained relative glob/],
+            [['src/{a,b}.ts'], /brace expansion/],
+            [['!negated.ts'], /negation/],
+            [[], /must be a nonempty array/],
+            [['@(a|b).ts'], /extglob|parentheses/],
+            [['+(a).ts'], /extglob|parentheses/],
+            [['*(a).ts'], /extglob|parentheses/],
+            [['?(a).ts'], /extglob|parentheses/],
+            [['(a|b).ts'], /extglob|parentheses/],
+        ])('rejects invalid variant inputs %j', (inputs, reason) => {
+            const pack = validPack();
+            pack.sensors.lint.variants[0].inputs = inputs;
+            expect(() => (0, contract_1.parseSensorPack)(pack, 'pack.json')).toThrow(reason);
+        });
+        it('rejects non-boolean sensor closureOnly', () => {
+            const pack = validPack();
+            pack.sensors.lint.closureOnly = 1;
+            expect(() => (0, contract_1.parseSensorPack)(pack, 'pack.json')).toThrow(/closureOnly must be a boolean/);
+        });
+    });
 });

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

@@ -396,4 +396,98 @@ describe('sensor manifest contract', () => {
             expect(soft.invalidEntries.some(entry => /not valid JSON|valid JSON/i.test(entry.reason))).toBe(false);
         });
     });
+    describe('inputs and sensor-level closureOnly (RF-1.1, RF-1.3, RF-1.5, RF-1.7, RF-1.8)', () => {
+        it('accepts inputs and closureOnly on pack-bound and project-declared entries', () => {
+            const packBound = {
+                ...validV2Manifest().sensors.lint,
+                inputs: ['**/*.ts', 'src/**/?est.ts'],
+                closureOnly: true,
+            };
+            const project = projectSensor({
+                inputs: ['lib/**/*.js'],
+                closureOnly: false,
+            });
+            const parsed = (0, manifest_1.parseSensorManifest)({
+                schemaVersion: 3,
+                mode: 'project-sensors',
+                pack: 'js-ts',
+                source: { registry: 'baseline' },
+                sensors: { lint: packBound, custom: project },
+            }, 'sensors.json');
+            expect(parsed).toMatchObject({
+                kind: 'v3',
+                pack: {
+                    sensors: {
+                        lint: { inputs: ['**/*.ts', 'src/**/?est.ts'], closureOnly: true },
+                        custom: { inputs: ['lib/**/*.js'], closureOnly: false },
+                    },
+                },
+            });
+        });
+        it('accepts inputs and closureOnly on v2 pack-bound sensors', () => {
+            const manifest = validV2Manifest();
+            manifest.sensors.lint.inputs = ['**/*.[jt]s'];
+            manifest.sensors.lint.closureOnly = true;
+            expect((0, manifest_1.parseSensorManifest)(manifest, 'sensors.json')).toMatchObject({
+                kind: 'v2',
+                pack: { sensors: { lint: { inputs: ['**/*.[jt]s'], closureOnly: true } } },
+            });
+        });
+        it('treats omitted closureOnly as false and does not invent inputs (RF-1.8)', () => {
+            const parsed = (0, manifest_1.parseSensorManifest)(v3WithPackAndProject(), 'sensors.json');
+            expect(parsed).toMatchObject({ kind: 'v3' });
+            if (parsed.kind !== 'v3' || parsed.pack.mode !== 'project-sensors')
+                throw new Error('expected v3 project-sensors');
+            const lint = parsed.pack.sensors.lint;
+            const custom = parsed.pack.sensors.custom;
+            expect(lint.closureOnly ?? false).toBe(false);
+            expect(custom.closureOnly ?? false).toBe(false);
+            expect('inputs' in lint).toBe(false);
+            expect('inputs' in custom).toBe(false);
+        });
+        it.each([
+            [[''], /sensors\.custom\.inputs\[0\] must be a nonempty single-line/],
+            [['/abs/path'], /sensors\.custom\.inputs\[0\].*absolute paths are invalid/],
+            [['C:/windows'], /sensors\.custom\.inputs\[0\].*absolute paths are invalid/],
+            [['has\u0000nul'], /sensors\.custom\.inputs\[0\].*NUL or control/],
+            [['../escape'], /sensors\.custom\.inputs\[0\].*contained relative glob/],
+            [['foo/../bar'], /sensors\.custom\.inputs\[0\].*contained relative glob/],
+            [['a{b,c}'], /sensors\.custom\.inputs\[0\].*brace expansion/],
+            [['!negated'], /sensors\.custom\.inputs\[0\].*negation/],
+            [['path/with!bang'], /sensors\.custom\.inputs\[0\].*negation/],
+            [[], /sensors\.custom\.inputs must be a nonempty array/],
+            [['@(a|b).ts'], /sensors\.custom\.inputs\[0\].*(?:extglob|parentheses)/],
+            [['+(a).ts'], /sensors\.custom\.inputs\[0\].*(?:extglob|parentheses)/],
+            [['*(a).ts'], /sensors\.custom\.inputs\[0\].*(?:extglob|parentheses)/],
+            [['?(a).ts'], /sensors\.custom\.inputs\[0\].*(?:extglob|parentheses)/],
+            [['(a|b).ts'], /sensors\.custom\.inputs\[0\].*(?:extglob|parentheses)/],
+        ])('rejects invalid project inputs %j', (inputs, reason) => {
+            expect(() => (0, manifest_1.parseSensorManifest)(v3WithPackAndProject({ inputs }), 'sensors.json'))
+                .toThrow(reason);
+        });
+        it('soft-isolates a project entry with bad inputs while keeping siblings', () => {
+            const soft = (0, manifest_1.parseSensorManifestWithIssues)(v3WithPackAndProject({ inputs: ['**/{a,b}.ts'] }), 'sensors.json');
+            expect(soft.invalidEntries).toEqual([
+                expect.objectContaining({
+                    name: 'custom',
+                    reason: expect.stringMatching(/sensors\.custom\.inputs\[0\].*brace expansion/),
+                }),
+            ]);
+            expect(soft.invalidEntries[0]?.reason).not.toMatch(/Invalid sensor pack/);
+            expect(soft).toMatchObject({
+                kind: 'v3',
+                pack: { sensors: { lint: { variantId: 'eslint-9' } } },
+            });
+            expect('custom' in soft.pack.sensors).toBe(false);
+        });
+        it('rejects closureOnly on a non-boolean sensor field', () => {
+            const soft = (0, manifest_1.parseSensorManifestWithIssues)(v3WithPackAndProject({ closureOnly: 'yes' }), 'sensors.json');
+            expect(soft.invalidEntries).toEqual([
+                expect.objectContaining({
+                    name: 'custom',
+                    reason: expect.stringMatching(/sensors\.custom\.closureOnly must be a boolean/),
+                }),
+            ]);
+        });
+    });
 });

package/dist/tests/commands/sensors/init-gitignore.test.js

@@ -0,0 +1,59 @@
+"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 awm_gitignore_1 = require("../../../src/core/awm-gitignore");
+jest.mock('../../../src/commands/sensors/bootstrap', () => ({
+    planSensorBootstrap: jest.fn(),
+    applySensorBootstrap: jest.fn(),
+}));
+jest.mock('../../../src/commands/sensors/detection', () => ({
+    detectStack: jest.fn(() => ({ pack: 'js-ts', evidence: [] })),
+}));
+const { planSensorBootstrap, applySensorBootstrap } = require('../../../src/commands/sensors/bootstrap');
+const { initSensors } = require('../../../src/commands/sensors/init');
+describe('initSensors managed awm gitignore (GI-1)', () => {
+    let tmp;
+    beforeEach(() => {
+        tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-sensors-gi-'));
+        jest.clearAllMocks();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmp, { recursive: true, force: true });
+    });
+    it('upserts the managed block after a successful create', async () => {
+        planSensorBootstrap.mockResolvedValue({
+            kind: 'create',
+            projectRoot: tmp,
+            manifestPath: path_1.default.join(tmp, '.awm', 'sensors.json'),
+            dryRun: false,
+            changes: [],
+            manifest: { schemaVersion: 3, mode: 'project-sensors', pack: 'js-ts', source: { registry: 'baseline' }, sensors: {} },
+        });
+        applySensorBootstrap.mockImplementation(() => {
+            fs_1.default.mkdirSync(path_1.default.join(tmp, '.awm'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(tmp, '.awm', 'sensors.json'), '{}');
+            return 'created';
+        });
+        await initSensors({ cwd: tmp });
+        expect(applySensorBootstrap).toHaveBeenCalled();
+        const gi = fs_1.default.readFileSync(path_1.default.join(tmp, '.gitignore'), 'utf8');
+        expect(gi).toContain(awm_gitignore_1.AWM_GITIGNORE_BEGIN);
+        expect(gi).toContain('!.awm/profile.json');
+    });
+    it('repairs the managed block on noop when .awm/ already exists', async () => {
+        fs_1.default.mkdirSync(path_1.default.join(tmp, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmp, '.awm', 'sensors.json'), '{}');
+        fs_1.default.writeFileSync(path_1.default.join(tmp, '.gitignore'), '.awm/\n');
+        planSensorBootstrap.mockResolvedValue({ kind: 'noop' });
+        await initSensors({ cwd: tmp });
+        expect(applySensorBootstrap).not.toHaveBeenCalled();
+        const gi = fs_1.default.readFileSync(path_1.default.join(tmp, '.gitignore'), 'utf8');
+        expect(gi).toContain(awm_gitignore_1.AWM_GITIGNORE_BEGIN);
+        expect(gi.split('\n').map((l) => l.trim()).filter((l) => l === '.awm/')).toEqual([]);
+    });
+});