agentic-workflow-manager 9.21.0 → 9.22.1

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/update.test.js

@@ -164,9 +164,9 @@ describe('awm update — honest outcome', () => {
         expect(result.code).toBe(1);
         expect(result.registries.failed).toEqual(['baseline']);
     });
-    it('un registry que falló pero conserva contenido sigue, y el cierre lo nombra en vez de anunciar éxito parejo', async () => {
-        // `unusableSyncedRegistries` mira contenido EN DISCO: se siembra el content root
-        // y el registries.json para que `docs` cuente como stale, no como roto.
+    it('un registry que falló falla cerrado aunque conserve contenido en disco (SG-7)', async () => {
+        // Pre-SG-7 update warn-and-continued on usable cache; #238 SG-7 requires
+        // non-zero exit for init/update/sync/registry add on any sync failure.
         const registriesDir = path_1.default.join(process.env.AWM_HOME, 'registries');
         fs_1.default.mkdirSync(path_1.default.join(registriesDir, 'docs', 'skills'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(process.env.AWM_HOME, 'registries.json'), JSON.stringify([{ name: 'docs', remote: 'https://example.test/docs.git' }]));
@@ -177,12 +177,12 @@ describe('awm update — honest outcome', () => {
                 { name: 'docs', action: 'error', error: 'network unreachable' },
             ],
         }));
-        expect(result.code).toBe(0);
+        expect(result.code).toBe(1);
         expect(result.registries).toEqual({ configured: 2, synced: 1, failed: ['docs'] });
-        const outro = updateOutro(result);
-        expect(outro).toMatch(/stale/i);
-        expect(outro).toMatch(/docs/);
-        expect(outro).not.toMatch(/^✅/);
+        expect(updateOutro(result)).toMatch(/Finished with registry sync errors/);
+        expect(updateOutro(result)).toMatch(/1\/2/);
+        expect(updateOutro(result)).toMatch(/docs/);
+        expect(errSpy.mock.calls.flat().join('\n')).toMatch(/docs/);
     });
 });
 describe('awm update — nunca se cuelga esperando a un humano que no está', () => {

package/dist/tests/commands/watch/supervisor-loop.test.js

@@ -758,21 +758,37 @@ describe('supervisor loop', () => {
     // subagent kept an idle leader while the work ran in processes outside its
     // process group, and the supervisor entered a false custody. Work in the
     // descendant tree is activity: observe, never custody, while it moves.
+    // The tree must move deterministically between the two ticks. A `while :; do
+    // sleep 0.02; done` loop leaves instants with no `sleep` child, so under CPU
+    // load two samples 150 ms apart could read identical (~1% of pairs) and the
+    // supervisor entered a real custody: a flaky red on linux-arm64. Each worker
+    // child lives 30 s, and the test itself makes the tree grow by one between ticks.
     itPosix('espera sana: lider ocioso + descendiente fuera del grupo trabajando => observa, no custodia (R4.2)', async () => {
         initUnattendedFixture(repo);
         (0, generations_1.beginGeneration)(repo, 'main');
-        const worker = "require('child_process').spawn('sh', ['-c', 'while :; do sleep 0.02; done'], { detached: true, stdio: 'ignore' }).unref(); setTimeout(()=>{}, 20000)";
-        const { child, ref } = (0, process_1.spawnStructured)(['node', '-e', worker], process.cwd(), 'nWait');
+        const trigger = path_1.default.join(repo, 'grow-descendant');
+        const worker = [
+            "const { spawn } = require('child_process'); const fs = require('fs');",
+            "const grow = () => spawn('sleep', ['30'], { detached: true, stdio: 'ignore' }).unref();",
+            'grow();',
+            'const poll = setInterval(() => { if (fs.existsSync(process.argv[1])) { clearInterval(poll); grow(); } }, 10);',
+            'setTimeout(() => {}, 20000);',
+        ].join(' ');
+        const { child, ref } = (0, process_1.spawnStructured)(['node', '-e', worker, trigger], process.cwd(), 'nWait');
         try {
             let s = (0, store_1.readJournal)(repo, 'main').state;
             (0, generations_1.activeGeneration)(s).processRef = ref;
             s.controllerHeartbeatAt = new Date(Date.now() - 3600000).toISOString(); // heartbeat vencido: bloqueado en la espera
             (0, store_1.writeJournal)(repo, 'main', s);
-            await until(() => ((0, process_1.activitySnapshot)(ref)?.descendants ?? '0:none') !== '0:none');
+            const descendants = () => (0, process_1.activitySnapshot)(ref)?.descendants ?? '0:none';
+            await until(() => descendants().startsWith('1:'));
             const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, provider: 'codex', heartbeatTimeoutMs: 1, activityWindowMs: 50, tickMs: 20 };
             const sup = new supervisor_1.Supervisor(repo, 'main', cfg, fakeSpawner, undefined, admitted);
             await sup.tick();
-            await new Promise((r) => setTimeout(r, 150)); // mas que la ventana, pero el arbol se movio
+            const firstTick = Date.now();
+            fs_1.default.writeFileSync(trigger, ''); // el arbol crece: trabajo real fuera del grupo
+            await until(() => descendants().startsWith('2:'));
+            await new Promise((r) => setTimeout(r, Math.max(0, 150 - (Date.now() - firstTick)))); // mas que la ventana, pero el arbol se movio
             expect(await sup.tick()).not.toBe('custody');
             const after = (0, store_1.readJournal)(repo, 'main').state;
             expect(after.cycle.status).toBe('IN_PROGRESS');
@@ -780,7 +796,7 @@ describe('supervisor loop', () => {
             expect(child.killed).toBe(false);
         }
         finally {
-            // The detached shell leads its own group: kill that group, never a pattern match.
+            // Each detached child leads its own group: kill that group, never a pattern match.
             let shells = [];
             try {
                 shells = (0, child_process_1.execFileSync)('pgrep', ['-P', String(ref.pid)], { encoding: 'utf8' }).split('\n').filter(Boolean).map(Number);

package/dist/tests/core/changes/helpers.js

@@ -67,19 +67,25 @@ function emptyGitConfig(home) {
     fs_1.default.writeFileSync(file, '');
     return file;
 }
+/**
+ * Every test git child: no signing, and no automatic maintenance after a commit. A newer git runs that maintenance detached in
+ * the background, where its lock file under `.git/objects` appears and vanishes while a test copies or removes the repository
+ * (`cloneRepo` failed with ENOENT on macOS with git 2.55).
+ */
+const GIT_TEST_CONFIG = ['-c', 'commit.gpgsign=false', '-c', 'maintenance.auto=false', '-c', 'gc.auto=0'];
 /** The git runner of a repository: identity and config isolation in an explicit environment, optional explicit dates. */
 function gitApi(root, home) {
     const env = {
         ...process.env, HOME: home, GIT_CONFIG_GLOBAL: path_1.default.join(home, 'gitconfig'), GIT_CONFIG_NOSYSTEM: '1',
         GIT_AUTHOR_NAME: 't', GIT_AUTHOR_EMAIL: 't@t', GIT_COMMITTER_NAME: 't', GIT_COMMITTER_EMAIL: 't@t',
     };
-    const run = (extra, args) => (0, child_process_1.execFileSync)('git', ['-c', 'commit.gpgsign=false', ...args], { cwd: root, encoding: 'utf8', env: { ...env, ...extra } }).trim();
+    const run = (extra, args) => (0, child_process_1.execFileSync)('git', [...GIT_TEST_CONFIG, ...args], { cwd: root, encoding: 'utf8', env: { ...env, ...extra } }).trim();
     const dates = (date) => {
         const stamp = `${Math.floor(Date.parse(date) / 1000)} +0000`;
         return { GIT_AUTHOR_DATE: stamp, GIT_COMMITTER_DATE: stamp };
     };
     const git = (...args) => run({}, args);
-    const gitInput = (input, ...args) => (0, child_process_1.execFileSync)('git', ['-c', 'commit.gpgsign=false', ...args], { cwd: root, encoding: 'utf8', env, input }).trim();
+    const gitInput = (input, ...args) => (0, child_process_1.execFileSync)('git', [...GIT_TEST_CONFIG, ...args], { cwd: root, encoding: 'utf8', env, input }).trim();
     const gitAt = (date, ...args) => run(dates(date), args);
     const commit = (files, message, date) => {
         for (const [rel, content] of Object.entries(files)) {
@@ -144,7 +150,13 @@ Object.defineProperty(exports, "posixOnly", { enumerable: true, get: function ()
  */
 function cloneRepo(template) {
     const root = fs_1.default.realpathSync.native(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-chg-')));
-    fs_1.default.cpSync(template.root, root, { recursive: true });
+    try {
+        fs_1.default.cpSync(template.root, root, { recursive: true });
+    }
+    catch (error) {
+        fs_1.default.rmSync(root, { recursive: true, force: true });
+        throw error;
+    }
     const { git, gitInput, gitAt, commit } = gitApi(root, template.home);
     return { root, home: template.home, git, gitInput, gitAt, commit, cleanup: () => fs_1.default.rmSync(root, { recursive: true, force: true }) };
 }