agentic-workflow-manager 9.20.4 → 9.22.0

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

@@ -0,0 +1,271 @@
+"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 status_1 = require("../../../src/commands/sensors/status");
+/**
+ * RF-3.4 — status surfaces a non-blocking warning when a configured enabled
+ * sensor lacks effective `inputs` (not cacheable). Warnings must not degrade
+ * `overall`, and opt-out / native-gate must stay silent.
+ */
+describe('computeSensorStatus inputs warnings (RF-3.4)', () => {
+    let tmpDir;
+    let previousHome;
+    let home;
+    beforeEach(() => {
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-inputs-'));
+        home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-inputs-home-'));
+        previousHome = process.env.AWM_HOME;
+        process.env.AWM_HOME = home;
+        fs_1.default.writeFileSync(path_1.default.join(home, 'registries.json'), JSON.stringify([]));
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, 'node_modules', '.bin'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'node_modules', '.bin', 'eslint'), '');
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
+    });
+    afterEach(() => {
+        if (previousHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = previousHome;
+        fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+        fs_1.default.rmSync(home, { recursive: true, force: true });
+    });
+    function writeOnlyProject(sensors) {
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
+            schemaVersion: 3,
+            mode: 'project-sensors',
+            sensors,
+        }));
+    }
+    function projectSensor(extra = {}) {
+        return {
+            source: 'project',
+            enabled: true,
+            command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+            formatter: 'exit-code',
+            ...extra,
+        };
+    }
+    it('warns when an enabled sensor lacks effective inputs (not cacheable)', async () => {
+        writeOnlyProject({ custom: projectSensor() });
+        const result = await (0, status_1.computeSensorStatus)(tmpDir);
+        expect(result.overall).toBe('READY');
+        expect(result.warnings).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                sensor: 'custom',
+                detail: expect.stringMatching(/not cacheable|no effective inputs|lacks inputs/i),
+            }),
+        ]));
+    });
+    it('does not warn when effective inputs are present', async () => {
+        writeOnlyProject({ custom: projectSensor({ inputs: ['**/*.ts'] }) });
+        const result = await (0, status_1.computeSensorStatus)(tmpDir);
+        expect(result.overall).toBe('READY');
+        expect(result.warnings ?? []).toEqual([]);
+    });
+    it('does not warn for disabled sensors that lack inputs', async () => {
+        writeOnlyProject({ custom: projectSensor({ enabled: false }) });
+        const result = await (0, status_1.computeSensorStatus)(tmpDir);
+        expect(result.warnings ?? []).toEqual([]);
+        expect(result.checks.custom).toMatchObject({ ok: true, detail: expect.stringMatching(/disabled/i) });
+    });
+    it.each([
+        ['native-gate', 'CI is authoritative.'],
+        ['opt-out', 'No local gate.'],
+    ])('emits no spurious warnings for v3 %s', async (mode, reason) => {
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
+            schemaVersion: 3, mode, reason,
+        }));
+        const result = await (0, status_1.computeSensorStatus)(tmpDir);
+        expect(result.mode).toBe(mode);
+        expect(result.warnings ?? []).toEqual([]);
+    });
+    it('uses pack-variant inputs as effective inputs (no warning when only the pack declares them)', async () => {
+        const registry = path_1.default.join(home, 'registries', 'baseline');
+        fs_1.default.mkdirSync(path_1.default.join(registry, 'sensor-packs', 'js-ts'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(home, 'registries.json'), JSON.stringify([
+            { name: 'baseline', remote: 'https://example.test/baseline.git' },
+        ]));
+        fs_1.default.writeFileSync(path_1.default.join(registry, 'sensor-packs', 'js-ts', 'pack.json'), JSON.stringify({
+            schemaVersion: 2, name: 'js-ts', description: 'fixture', detects: ['package.json'],
+            coverage: {
+                schemaVersion: 1,
+                classes: {
+                    lint: {
+                        description: 'lint',
+                        detectors: [{ sensor: 'lint' }],
+                        remedy: { summary: 'fix', command: 'awm sensors init' },
+                    },
+                },
+            },
+            sensors: {
+                lint: {
+                    applicability: { allFiles: ['package.json'] },
+                    variants: [{
+                            id: 'eslint-10', priority: 10, certifiedRange: '>=10 <11',
+                            requirements: {
+                                tool: 'eslint', toolRange: '>=10 <11',
+                                runtime: 'node', runtimeRange: '>=0',
+                            },
+                            assets: [], formatter: 'eslint-llm',
+                            probe: { kind: 'package-script-present', script: 'lint' },
+                            command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+                            inputs: ['src/**/*.ts'],
+                        }],
+                },
+            },
+        }));
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'package.json'), JSON.stringify({
+            scripts: { lint: 'eslint .' },
+            devDependencies: { eslint: '^10.0.0' },
+        }));
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, 'node_modules', 'eslint'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'node_modules', 'eslint', 'package.json'), JSON.stringify({ version: '10.0.0' }));
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
+            schemaVersion: 2, pack: 'js-ts',
+            sensors: {
+                lint: {
+                    enabled: true, variantId: 'eslint-10',
+                    command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+                    assets: [],
+                    initializedCompatibility: {
+                        state: 'certified', reason: 'range-and-probe', variantId: 'eslint-10',
+                        toolVersion: '10.0.0', runtimeVersion: process.versions.node,
+                        certifiedRange: '>=10 <11', evidence: [],
+                    },
+                },
+            },
+        }));
+        const result = await (0, status_1.computeSensorStatus)(tmpDir);
+        expect(result.checks.lint).toMatchObject({ ok: true });
+        expect(result.warnings ?? []).toEqual([]);
+    });
+    it('warns for pack-bound enabled sensors when neither project nor pack variant provides inputs', async () => {
+        const registry = path_1.default.join(home, 'registries', 'baseline');
+        fs_1.default.mkdirSync(path_1.default.join(registry, 'sensor-packs', 'js-ts'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(home, 'registries.json'), JSON.stringify([
+            { name: 'baseline', remote: 'https://example.test/baseline.git' },
+        ]));
+        fs_1.default.writeFileSync(path_1.default.join(registry, 'sensor-packs', 'js-ts', 'pack.json'), JSON.stringify({
+            schemaVersion: 2, name: 'js-ts', description: 'fixture', detects: ['package.json'],
+            coverage: {
+                schemaVersion: 1,
+                classes: {
+                    lint: {
+                        description: 'lint',
+                        detectors: [{ sensor: 'lint' }],
+                        remedy: { summary: 'fix', command: 'awm sensors init' },
+                    },
+                },
+            },
+            sensors: {
+                lint: {
+                    applicability: { allFiles: ['package.json'] },
+                    variants: [{
+                            id: 'eslint-10', priority: 10, certifiedRange: '>=10 <11',
+                            requirements: {
+                                tool: 'eslint', toolRange: '>=10 <11',
+                                runtime: 'node', runtimeRange: '>=0',
+                            },
+                            assets: [], formatter: 'eslint-llm',
+                            probe: { kind: 'package-script-present', script: 'lint' },
+                            command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+                        }],
+                },
+            },
+        }));
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'package.json'), JSON.stringify({
+            scripts: { lint: 'eslint .' },
+            devDependencies: { eslint: '^10.0.0' },
+        }));
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, 'node_modules', 'eslint'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'node_modules', 'eslint', 'package.json'), JSON.stringify({ version: '10.0.0' }));
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
+            schemaVersion: 2, pack: 'js-ts',
+            sensors: {
+                lint: {
+                    enabled: true, variantId: 'eslint-10',
+                    command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+                    assets: [],
+                    initializedCompatibility: {
+                        state: 'certified', reason: 'range-and-probe', variantId: 'eslint-10',
+                        toolVersion: '10.0.0', runtimeVersion: process.versions.node,
+                        certifiedRange: '>=10 <11', evidence: [],
+                    },
+                },
+            },
+        }));
+        const result = await (0, status_1.computeSensorStatus)(tmpDir);
+        expect(result.overall).toBe('READY');
+        expect(result.warnings).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                sensor: 'lint',
+                detail: expect.stringMatching(/not cacheable|no effective inputs|lacks inputs/i),
+            }),
+        ]));
+    });
+});
+describe('awm sensors status CLI renders inputs warnings (RF-3.4)', () => {
+    let tmpDir;
+    let previousHome;
+    let home;
+    let previousCwd;
+    beforeEach(() => {
+        previousCwd = process.cwd();
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-inputs-cli-'));
+        home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-inputs-cli-home-'));
+        previousHome = process.env.AWM_HOME;
+        process.env.AWM_HOME = home;
+        fs_1.default.writeFileSync(path_1.default.join(home, 'registries.json'), JSON.stringify([]));
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, 'node_modules', '.bin'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'node_modules', '.bin', 'eslint'), '');
+        fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
+            schemaVersion: 3,
+            mode: 'project-sensors',
+            sensors: {
+                custom: {
+                    source: 'project',
+                    enabled: true,
+                    command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+                    formatter: 'exit-code',
+                },
+            },
+        }));
+        process.chdir(tmpDir);
+    });
+    afterEach(() => {
+        process.chdir(previousCwd);
+        if (previousHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = previousHome;
+        fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+        fs_1.default.rmSync(home, { recursive: true, force: true });
+    });
+    it('prints warning text in human-readable status output without failing READY', async () => {
+        const { Command } = require('commander');
+        const { registerSensorsCommand } = require('../../../src/commands/sensors/index');
+        const program = new Command();
+        program.exitOverride();
+        registerSensorsCommand(program);
+        const output = jest.spyOn(console, 'log').mockImplementation(() => undefined);
+        const exitSpy = jest.spyOn(process, 'exit').mockImplementation((() => undefined));
+        try {
+            await program.parseAsync(['node', 'awm', 'sensors', 'status']);
+            const rendered = output.mock.calls.flat().join('\n');
+            expect(rendered).toMatch(/READY/);
+            expect(rendered).toMatch(/custom/);
+            expect(rendered).toMatch(/not cacheable|no effective inputs|lacks inputs/i);
+            expect(exitSpy).not.toHaveBeenCalled();
+        }
+        finally {
+            output.mockRestore();
+            exitSpy.mockRestore();
+        }
+    });
+});

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

@@ -0,0 +1,34 @@
+"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 init_1 = require("../../../src/commands/watch/init");
+const awm_gitignore_1 = require("../../../src/core/awm-gitignore");
+const git_1 = require("../../../src/core/tracks/git");
+describe('initWatch managed awm gitignore (GI-2/GI-10)', () => {
+    let repo;
+    beforeEach(() => {
+        repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-watch-gi-'));
+        (0, child_process_1.execFileSync)('git', ['init'], { cwd: repo, stdio: 'pipe' });
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'package.json'), JSON.stringify({ scripts: { test: 'jest' } }));
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(repo, { recursive: true, force: true });
+    });
+    it('writes the managed block instead of a bare .awm/ allow-nothing rule', () => {
+        (0, init_1.initWatch)(repo, 'rama');
+        const gi = fs_1.default.readFileSync(path_1.default.join(repo, '.gitignore'), 'utf8');
+        expect(gi).toContain(awm_gitignore_1.AWM_GITIGNORE_BEGIN);
+        expect(gi).toContain(awm_gitignore_1.AWM_GITIGNORE_END);
+        expect(gi).toContain('!.awm/sensors.json');
+        expect(gi).toContain('!.awm/profile.json');
+        const lines = gi.split('\n').map((l) => l.trim()).filter(Boolean);
+        expect(lines.filter((l) => l === '.awm' || l === '.awm/')).toEqual([]);
+        expect((0, git_1.isAwmGitignored)(repo)).toBe(true);
+    });
+});

package/dist/tests/commands/watch/track-freeze.test.js

@@ -301,13 +301,10 @@ describe('Supervisor.tick() — freeze de un track individual (R5.2/R6.3)', () =
     }
     function setUpGreenTrack() {
         initCompactWatch(repo, BRANCH);
-        // `initWatch` ESCRIBE `.gitignore` (`.awm/`) pero no lo commitea — un
-        // `.gitignore` sin trackear es en sí mismo un path "untracked" para
-        // `git status --porcelain` (R6.4's chequeo de limpieza no distingue
-        // "sucio de verdad" de "el propio bootstrap del journal"). Sin este
-        // commit, `isWorktreeClean` nunca sería `true` y el freeze jamás
-        // convergería — no por un bug del driver, sino por un repo de test
-        // que nunca terminó su propio setup.
+        // `initWatch` upserts the managed `# AWM:GITIGNORE` block but does not
+        // commit it — an untracked/modified `.gitignore` keeps the worktree
+        // dirty for R6.4's clean check. Commit the bootstrap side-effect so
+        // freeze can converge.
         git(repo, 'add', '.gitignore');
         git(repo, 'commit', '-qm', 'gitignore .awm');
         const s = (0, store_1.readJournal)(repo, BRANCH).state;
@@ -526,6 +523,13 @@ describe('loop end-to-end: plan (reconcileTracks) + track (Supervisor.tick) cier
     test('reconcileTracks real (plan) + Supervisor.tick real (track), en loop contra dos worktrees reales, cierran request -> drenaje -> persist -> observación -> FROZEN', async () => {
         // --- lado TRACK: registrar el trabajo y drenarlo con un Supervisor REAL ---
         initCompactWatch(trackWorktree, TRACK_BRANCH);
+        // `initWatch` migrates the seeded `.awm/` ignore into the managed
+        // `.awm/*` allowlist block. That (1) dirties `.gitignore` and (2)
+        // un-ignores `.awm/sensors.json`, which then shows up as untracked.
+        // Both must be committed or R6.4's clean-worktree gate never passes
+        // and this loop times out (same class of fixture bug as setUpGreenTrack).
+        git(trackWorktree, 'add', '.gitignore', '.awm/sensors.json');
+        git(trackWorktree, 'commit', '-qm', 'awm gitignore + sensors');
         const ts0 = (0, store_1.readJournal)(trackWorktree, TRACK_BRANCH).state;
         ts0.trackContext = { trackId: 'a', taskIds: ['T1'], planDigest: '', baseSha, planJournalId: 'j-plan' };
         (0, store_1.writeJournal)(trackWorktree, TRACK_BRANCH, ts0);

package/dist/tests/commands/watch/watch-init.test.js

@@ -154,7 +154,9 @@ describe('watch --init: plan-vs-repo mecanico', () => {
         const out = (0, init_1.initWatch)(repo, 'rama');
         expect(out.requiredVerifiers).toEqual(['test']);
         expect((0, store_1.readJournal)(repo, 'rama').state.requiredVerifiers).toEqual(['test']);
-        expect(fs_1.default.readFileSync(path_1.default.join(repo, '.gitignore'), 'utf8')).toContain('.awm/');
+        const gi = fs_1.default.readFileSync(path_1.default.join(repo, '.gitignore'), 'utf8');
+        expect(gi).toContain('# AWM:GITIGNORE:BEGIN');
+        expect(gi).toContain('.awm/*');
         expect(() => (0, init_1.initWatch)(repo, 'rama')).not.toThrow(); // idempotente
     });
     test('no escribe .gitignore cuando es un symlink', () => {

package/dist/tests/core/awm-gitignore.test.js

@@ -0,0 +1,58 @@
+"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");
+describe('awm-gitignore managed block', () => {
+    let tmp;
+    beforeEach(() => {
+        tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-gi-'));
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmp, { recursive: true, force: true });
+    });
+    it('renders the canonical managed block with versioned allowlist entries', () => {
+        expect((0, awm_gitignore_1.renderManagedBlock)()).toBe([
+            awm_gitignore_1.AWM_GITIGNORE_BEGIN,
+            '.awm/*',
+            '!.awm/sensors.json',
+            '!.awm/sensors.baseline.json',
+            '!.awm/profile.json',
+            '!.awm/context-budget.json',
+            '!.awm/context/',
+            '.awm/context/*',
+            '!.awm/context/index.json',
+            awm_gitignore_1.AWM_GITIGNORE_END,
+            '',
+        ].join('\n'));
+    });
+    it('creates .gitignore with the managed block and is idempotent', () => {
+        (0, awm_gitignore_1.upsertAwmGitignore)(tmp);
+        const first = fs_1.default.readFileSync(path_1.default.join(tmp, '.gitignore'), 'utf8');
+        expect(first).toContain(awm_gitignore_1.AWM_GITIGNORE_BEGIN);
+        expect(first).toContain(awm_gitignore_1.AWM_GITIGNORE_END);
+        (0, awm_gitignore_1.upsertAwmGitignore)(tmp);
+        expect(fs_1.default.readFileSync(path_1.default.join(tmp, '.gitignore'), 'utf8')).toBe(first);
+    });
+    it('migrates bare .awm/ and .awm lines into the managed block without dropping unrelated rules', () => {
+        fs_1.default.writeFileSync(path_1.default.join(tmp, '.gitignore'), 'node_modules\n.awm/\ndist\n');
+        (0, awm_gitignore_1.upsertAwmGitignore)(tmp);
+        const text = fs_1.default.readFileSync(path_1.default.join(tmp, '.gitignore'), 'utf8');
+        expect(text).toContain('node_modules');
+        expect(text).toContain('dist');
+        expect(text).toContain(awm_gitignore_1.AWM_GITIGNORE_BEGIN);
+        const outside = text.slice(0, text.indexOf(awm_gitignore_1.AWM_GITIGNORE_BEGIN));
+        expect(outside.split('\n').map((l) => l.trim()).filter(Boolean)).not.toContain('.awm/');
+        expect(outside.split('\n').map((l) => l.trim()).filter(Boolean)).not.toContain('.awm');
+    });
+    it('refuses a symlink .gitignore', () => {
+        const target = path_1.default.join(tmp, 'ignore-target');
+        fs_1.default.writeFileSync(target, 'x\n');
+        fs_1.default.symlinkSync(target, path_1.default.join(tmp, '.gitignore'));
+        expect(() => (0, awm_gitignore_1.upsertAwmGitignore)(tmp)).toThrow(/symlink/i);
+    });
+});