agentic-workflow-manager 9.16.0 → 9.17.0

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

@@ -7,6 +7,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const status_1 = require("../../../src/commands/sensors/status");
+const coverage_1 = require("../../../src/commands/sensors/coverage");
 jest.mock('../../../src/commands/sensors/exec', () => ({
     runCommand: jest.fn(),
     runStructuredCommand: jest.fn(),
@@ -409,3 +410,206 @@ describe('computeSensorStatus', () => {
         }
     });
 });
+describe('project-declared status and coverage (S3)', () => {
+    let tmpDir;
+    let pathDir;
+    let originalPath;
+    beforeEach(() => {
+        tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-s3-'));
+        pathDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-s3-path-'));
+        originalPath = process.env.PATH;
+        process.env.PATH = pathDir;
+        fs_1.default.writeFileSync(path_1.default.join(pathDir, 'terraform'), '#!/bin/sh\nexit 0\n');
+        fs_1.default.chmodSync(path_1.default.join(pathDir, 'terraform'), 0o755);
+    });
+    afterEach(() => {
+        if (originalPath === undefined)
+            delete process.env.PATH;
+        else
+            process.env.PATH = originalPath;
+        fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+        fs_1.default.rmSync(pathDir, { recursive: true, force: true });
+    });
+    function writeOnlyProject(sensors) {
+        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,
+        }));
+    }
+    it('lists each only-project sensor with project-declared provenance (RF-2.8)', async () => {
+        writeOnlyProject({
+            'iac-format': {
+                source: 'project',
+                enabled: true,
+                command: { executable: 'terraform', resolution: 'path', args: ['fmt', '-check'] },
+                formatter: 'exit-code',
+            },
+        });
+        const result = await (0, status_1.computeSensorStatus)(tmpDir);
+        expect(result.checks['iac-format']).toMatchObject({
+            ok: true,
+            certification: 'project-declared',
+        });
+        expect(result.checks['iac-format'].detail).toMatch(/project-declared/i);
+        expect(result.overall).not.toBe('NOT_CONFIGURED');
+        // Must not be empty Pack:none / DEGRADED with zero detail solely because pack is absent.
+        expect(result.pack === null || result.pack === undefined).toBe(true);
+        expect(Object.keys(result.checks)).toEqual(expect.arrayContaining(['iac-format']));
+    });
+    it('reports coverage as inconclusive / no pack-reference for only-project (RF-2.9)', async () => {
+        writeOnlyProject({
+            'iac-format': {
+                source: 'project',
+                enabled: true,
+                command: { executable: 'terraform', resolution: 'path', args: ['fmt', '-check'] },
+                formatter: 'exit-code',
+            },
+        });
+        const coverage = await (0, coverage_1.runCoverage)(tmpDir);
+        expect(coverage.overall).toBe('inconclusive');
+        expect(coverage.static.status).toBe('inconclusive');
+        expect(coverage.static.reason).toBe('no_reference');
+        expect(coverage.static.classes).toEqual([]);
+        expect(coverage.overall).not.toBe('covered');
+        expect(JSON.stringify(coverage)).not.toMatch(/"certification"\s*:\s*"certified"/);
+    });
+    it('soft-isolates valid siblings when one project entry is schema-invalid (status vs run)', async () => {
+        writeOnlyProject({
+            good: {
+                source: 'project',
+                enabled: true,
+                command: { executable: 'terraform', resolution: 'path', args: ['fmt', '-check'] },
+                formatter: 'exit-code',
+            },
+            bad: {
+                source: 'project',
+                enabled: true,
+                command: { executable: 'terraform', resolution: 'path', args: ['fmt', '-check'] },
+                formatter: 'not-a-formatter',
+            },
+        });
+        const result = await (0, status_1.computeSensorStatus)(tmpDir);
+        expect(Object.keys(result.checks).length).toBeGreaterThan(0);
+        expect(result.checks['good']).toMatchObject({
+            ok: true,
+            certification: 'project-declared',
+        });
+        expect(result.checks['bad']).toMatchObject({ ok: false });
+        expect(result.checks['bad'].detail).toMatch(/formatter|invalid/i);
+        expect(result.overall).toBe('DEGRADED');
+    });
+});
+describe('project-declared status pack collision (S3 RF-1.7)', () => {
+    let project;
+    let home;
+    let pathDir;
+    let originalPath;
+    let originalHome;
+    const version = '10.0.0';
+    beforeEach(() => {
+        project = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-collision-'));
+        home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-collision-home-'));
+        pathDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-collision-path-'));
+        originalPath = process.env.PATH;
+        originalHome = process.env.AWM_HOME;
+        process.env.PATH = pathDir;
+        process.env.AWM_HOME = home;
+        fs_1.default.writeFileSync(path_1.default.join(pathDir, 'node'), '#!/bin/sh\nexit 0\n');
+        fs_1.default.chmodSync(path_1.default.join(pathDir, 'node'), 0o755);
+        const registry = path_1.default.join(home, 'registries', 'baseline', 'sensor-packs', 'js-ts');
+        fs_1.default.mkdirSync(registry, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registry, 'eslint.config.awm.mjs'), 'export default []');
+        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(project, 'package.json'), JSON.stringify({ scripts: { lint: 'eslint .' }, devDependencies: { eslint: '^10.0.0' } }));
+        fs_1.default.mkdirSync(path_1.default.join(project, 'node_modules', 'eslint'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(project, 'node_modules', 'eslint', 'package.json'), JSON.stringify({ version }));
+        fs_1.default.mkdirSync(path_1.default.join(project, 'node_modules', '.bin'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(project, 'node_modules', '.bin', 'eslint'), '');
+        fs_1.default.writeFileSync(path_1.default.join(registry, '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: {
+                    fast: true,
+                    applicability: { allFiles: ['package.json'] },
+                    variants: [{
+                            id: 'eslint-10', priority: 1, certifiedRange: '>=10 <11',
+                            requirements: { tool: 'eslint', toolRange: '>=10 <11', runtime: 'node', runtimeRange: '>=0' },
+                            assets: ['eslint.config.awm.mjs'], formatter: 'generic',
+                            probe: { kind: 'package-script-present', script: 'lint' },
+                            command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+                        }],
+                },
+            },
+        }));
+        fs_1.default.mkdirSync(path_1.default.join(project, '.awm'));
+        fs_1.default.writeFileSync(path_1.default.join(project, 'eslint.config.awm.mjs'), 'export default []');
+    });
+    afterEach(() => {
+        if (originalPath === undefined)
+            delete process.env.PATH;
+        else
+            process.env.PATH = originalPath;
+        if (originalHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalHome;
+        fs_1.default.rmSync(project, { recursive: true, force: true });
+        fs_1.default.rmSync(home, { recursive: true, force: true });
+        fs_1.default.rmSync(pathDir, { recursive: true, force: true });
+    });
+    it('does not label a colliding project id as project-declared READY (RF-1.7 status)', async () => {
+        fs_1.default.writeFileSync(path_1.default.join(project, '.awm', 'sensors.json'), JSON.stringify({
+            schemaVersion: 3,
+            mode: 'project-sensors',
+            pack: 'js-ts',
+            source: { registry: 'baseline' },
+            sensors: {
+                lint: {
+                    source: 'project',
+                    enabled: true,
+                    command: { executable: 'node', resolution: 'path', args: ['-e', 'process.exit(0)'] },
+                    formatter: 'exit-code',
+                },
+            },
+        }));
+        const result = await (0, status_1.computeSensorStatus)(project);
+        expect(result.checks['lint']).toBeDefined();
+        expect(result.checks['lint'].certification).not.toBe('project-declared');
+        expect(result.checks['lint'].detail).toMatch(/project-sensor-name-collision|pack (sensor )?kept/i);
+        expect(result.overall).not.toBe('READY');
+    });
+    it('soft-isolate + pack + colliding project id does not certify project-declared READY (RF-1.7)', async () => {
+        // Invalid sibling forces softIsolatedChecks; lint collides with live pack id.
+        fs_1.default.writeFileSync(path_1.default.join(project, '.awm', 'sensors.json'), JSON.stringify({
+            schemaVersion: 3,
+            mode: 'project-sensors',
+            pack: 'js-ts',
+            source: { registry: 'baseline' },
+            sensors: {
+                lint: {
+                    source: 'project',
+                    enabled: true,
+                    command: { executable: 'node', resolution: 'path', args: ['-e', 'process.exit(0)'] },
+                    formatter: 'exit-code',
+                },
+                bad: {
+                    source: 'project',
+                    enabled: true,
+                    command: { executable: 'node', resolution: 'path', args: ['-e', 'process.exit(0)'] },
+                    formatter: 'not-a-formatter',
+                },
+            },
+        }));
+        const result = await (0, status_1.computeSensorStatus)(project);
+        expect(result.mode).toBe('invalid');
+        expect(result.checks['bad']).toMatchObject({ ok: false });
+        expect(result.checks['lint']).toBeDefined();
+        expect(result.checks['lint'].ok).toBe(false);
+        expect(result.checks['lint'].certification).not.toBe('project-declared');
+        expect(result.checks['lint'].detail).toMatch(/project-sensor-name-collision|pack (sensor )?kept/i);
+        expect(result.overall).not.toBe('READY');
+    });
+});

package/dist/tests/core/journal/process.test.js

@@ -202,28 +202,51 @@ describe('process identity', () => {
         test('ignores malformed ps lines instead of inventing processes', () => {
             expect((0, process_1.descendantActivity)('garbage\n  20    10 00:00:01\n\n  x y z', 10)).toMatch(/^1:/);
         });
+        test('keeps Darwin-style rows with blank or dotted cputime in the tree', () => {
+            // macOS `ps -o time=` is often `0:00.01`; a brand-new process can also
+            // omit the third column entirely on some samples.
+            expect((0, process_1.descendantActivity)('  10     1 0:00.05\n  20    10 0:00.01\n  30    20\n', 10)).toMatch(/^2:/);
+            expect((0, process_1.descendantActivity)('  10     1\n  20    10\n', 10)).toMatch(/^1:/);
+        });
     });
     test('activitySnapshot ve un nieto fuera del process group del controlador', async () => {
         if ((0, paths_1.isWindowsNative)())
             return; // win32 degrada activity sin ps (ver activitySnapshot)
-        const script = "setTimeout(() => { require('child_process').spawn(process.execPath, ['-e', 'setTimeout(()=>{}, 4000)'], { detached: true, stdio: 'ignore' }).unref(); }, 400); setTimeout(()=>{}, 4000)";
+        const script = "setTimeout(() => { require('child_process').spawn(process.execPath, ['-e', 'setTimeout(()=>{}, 15000)'], { detached: true, stdio: 'ignore' }).unref(); }, 200); setTimeout(()=>{}, 15000)";
         const { child, ref } = (0, process_1.spawnStructured)(['node', '-e', script], process.cwd(), 'n-desc');
         try {
-            const before = (0, process_1.activitySnapshot)(ref);
-            expect(before).not.toBeNull();
-            let after = (0, process_1.activitySnapshot)(ref);
-            for (let i = 0; i < 40 && after !== null && after.descendants === before.descendants; i++) {
+            // Wait for a concrete baseline (not `unknown` from a transient ps miss).
+            let before = (0, process_1.activitySnapshot)(ref);
+            for (let i = 0; i < 50 && (before === null || before.descendants === 'unknown'); i++) {
                 await new Promise((resolve) => setTimeout(resolve, 50));
-                after = (0, process_1.activitySnapshot)(ref);
+                before = (0, process_1.activitySnapshot)(ref);
+            }
+            expect(before).not.toBeNull();
+            expect(before.descendants).not.toBe('unknown');
+            const beforeGroup = before.groupSize;
+            let after = before;
+            const deadline = Date.now() + 8000;
+            while (Date.now() < deadline) {
+                const snap = (0, process_1.activitySnapshot)(ref);
+                if (snap !== null)
+                    after = snap;
+                // Success: same process group, at least one PPID-descendant appeared.
+                if (after.groupSize === beforeGroup && /^[1-9]\d*:/.test(after.descendants))
+                    break;
+                await new Promise((resolve) => setTimeout(resolve, 100));
             }
-            expect(after).not.toBeNull();
             // The detached grandchild lives in its own process group: the group
             // signal cannot see it, the descendant signal must.
-            expect(after.groupSize).toBe(before.groupSize);
-            expect(after.descendants).not.toBe(before.descendants);
-            expect(after.descendants).toMatch(/^1:/);
+            expect(after.groupSize).toBe(beforeGroup);
+            expect(after.descendants).toMatch(/^[1-9]\d*:/);
         }
         finally {
+            // Detached grandchildren are outside `-PGID`; reap by parent pid too.
+            try {
+                const { execFileSync } = require('child_process');
+                execFileSync('pkill', ['-P', String(ref.pid)], { stdio: 'ignore', timeout: 1000 });
+            }
+            catch { /* ya ausente */ }
             try {
                 process.kill(-ref.processGroup, 'SIGKILL');
             }

package/dist/tests/structural/native-release-artifacts.test.js

@@ -17,8 +17,10 @@ function assertArmPartition(source) {
     const [matrixJob, rest] = workflow.split(/^  windows-arm-hot:\s*$/m);
     expect(rest).toBeDefined();
     const hotJob = rest.split(/^  [a-z][\w-]*:\s*$/m)[0];
-    expect(matrixJob).toMatch(/- name: Tests?\n        if: matrix\.target != 'win32-arm64'\n        working-directory: cli\n        run: npx jest --runInBand --bail\n/);
-    const remainder = matrixJob.match(/- name: Tests? \(Windows ARM remainder\)\n        if: matrix\.target == 'win32-arm64'\n        working-directory: cli\n        run: ([^\n]+)/)?.[1];
+    // Optional env: (e.g. AWM_BASELINE_REGISTRY_ROOT for RF-5.1 docs contract) may
+    // sit between working-directory and run; release.yml still omits it.
+    expect(matrixJob).toMatch(/- name: Tests?\n        if: matrix\.target != 'win32-arm64'\n        working-directory: cli\n(?:        env:\n(?:          [^\n]+\n)+)?        run: npx jest --runInBand --bail\n/);
+    const remainder = matrixJob.match(/- name: Tests? \(Windows ARM remainder\)\n        if: matrix\.target == 'win32-arm64'\n        working-directory: cli\n(?:        env:\n(?:          [^\n]+\n)+)?        run: ([^\n]+)/)?.[1];
     expect(remainder).toMatch(/^npx jest --runInBand --bail --testPathIgnorePatterns='[^']+'$/);
     const ignorePattern = remainder?.match(/--testPathIgnorePatterns='([^']+)'/)?.[1];
     expect(ignorePattern).toBe(String.raw `node_modules|[/\\]cli[/\\]tests[/\\]commands[/\\]watch[/\\]track-(finalize|freeze)\.test\.ts$`);

package/dist/tests/structural/project-declared-sensors-docs-contract.test.js

@@ -0,0 +1,104 @@
+"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 path_1 = __importDefault(require("path"));
+/**
+ * CMD-DOCS — RF-5.1 / RF-5.2 (project-declared sensors documentation).
+ *
+ * Resolves awm-baseline-registry from (in order):
+ * 1. `AWM_BASELINE_REGISTRY_ROOT` (CI docs checkout)
+ * 2. nested `repoRoot/awm-baseline-registry` (CI support-matrix layout)
+ * 3. sibling `repoRoot/../awm-baseline-registry` (maintainer workspace)
+ *
+ * Prefer a checkout that already contains RF-5.1 (`## Project sensors vs packs`).
+ * Missing / too-old checkouts fail loudly (no silent skip).
+ */
+const repoRoot = path_1.default.resolve(__dirname, '../../..');
+const cliReferencePath = path_1.default.join(repoRoot, 'docs', 'cli-reference.md');
+const RF51_HEADING = '## Project sensors vs packs';
+function setupSensorsSkillPath(registryRoot) {
+    return path_1.default.join(registryRoot, 'skills', 'setup-sensors', 'SKILL.md');
+}
+function resolveSetupSensorsPath() {
+    const envRoot = process.env.AWM_BASELINE_REGISTRY_ROOT?.trim();
+    // When CI/maintainer sets the override, that root is authoritative (no silent
+    // fallback to a nested immutable pin that lacks RF-5.1 prose).
+    const candidates = envRoot
+        ? [path_1.default.resolve(envRoot)]
+        : [
+            path_1.default.join(repoRoot, 'awm-baseline-registry'),
+            path_1.default.join(repoRoot, '..', 'awm-baseline-registry'),
+        ];
+    const existing = candidates
+        .map(root => ({ root, skill: setupSensorsSkillPath(root) }))
+        .filter(entry => fs_1.default.existsSync(entry.skill));
+    if (existing.length === 0) {
+        throw new Error('Baseline registry checkout missing for RF-5.1 docs contract. Tried:\n'
+            + candidates.map(root => `  - ${setupSensorsSkillPath(root)}`).join('\n')
+            + '\nClone awm-baseline-registry as a sibling, nest it under the CLI repo, '
+            + 'or set AWM_BASELINE_REGISTRY_ROOT to a checkout that includes setup-sensors RF-5.1.');
+    }
+    const withRf51 = existing.find(entry => fs_1.default.readFileSync(entry.skill, 'utf8').includes(RF51_HEADING));
+    if (!withRf51) {
+        throw new Error('Baseline registry checkout is present but too old for RF-5.1 '
+            + `(missing ${RF51_HEADING}). Checked:\n`
+            + existing.map(entry => `  - ${entry.skill}`).join('\n')
+            + '\nPoint AWM_BASELINE_REGISTRY_ROOT at a registry tip that documents project-declared sensors '
+            + '(coordinated awm-baseline-registry PR), without replacing the immutable v2.0.1 support-matrix pin.');
+    }
+    return withRf51.skill;
+}
+function sensorsSection(text) {
+    const start = text.indexOf('## Sensors (per-project computational checks)');
+    expect(start).toBeGreaterThanOrEqual(0);
+    const rest = text.slice(start);
+    const nextH2 = rest.search(/\n## (?!Sensors)/);
+    return nextH2 === -1 ? rest : rest.slice(0, nextH2);
+}
+/** Skill body after YAML frontmatter (content after the closing `---`). */
+function skillBody(skill) {
+    const match = skill.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n([\s\S]*)$/);
+    if (!match) {
+        throw new Error('setup-sensors SKILL.md missing YAML frontmatter delimiters');
+    }
+    return match[1];
+}
+/** Named H2 section inside the skill body; fails if the heading is absent. */
+function skillSection(body, heading) {
+    const start = body.indexOf(heading);
+    expect(start).toBeGreaterThanOrEqual(0);
+    const rest = body.slice(start);
+    const nextH2 = rest.search(/\n## /);
+    return nextH2 === -1 ? rest : rest.slice(0, nextH2);
+}
+describe('project-declared sensors docs contract (CMD-DOCS)', () => {
+    it('cli-reference sensors section documents project markers, provenance, exit-code, and non-gating (RF-5.2)', () => {
+        const text = fs_1.default.readFileSync(cliReferencePath, 'utf8');
+        const section = sensorsSection(text);
+        expect(section).toMatch(/source:\s*"project"|source"\s*:\s*"project"/);
+        expect(section).toContain('project-declared');
+        expect(section).toContain('exit-code');
+        expect(section).toMatch(/provenance[\s\S]{0,220}(?:does not|never)\s+(?:block|blocks)[\s\S]{0,100}(?:unattended|gates)/i);
+        // Optional pack (omit or null) — RF-5.2 clause already in cli-reference prose.
+        expect(section).toMatch(/[Pp]ack may be omitted or set\s+to\s+`?null`?[\s\S]{0,120}project-declared/i);
+        // JSON-vs-schema diagnostics distinction — RF-5.2.
+        expect(section).toMatch(/not valid JSON[\s\S]{0,220}schema-invalid/i);
+    });
+    it('setup-sensors skill documents project vs pack, JSON example, and non-gating provenance (RF-5.1)', () => {
+        const setupSensorsPath = resolveSetupSensorsPath();
+        const skill = fs_1.default.readFileSync(setupSensorsPath, 'utf8');
+        const body = skillBody(skill);
+        // Scope when-to-use / project-vs-packs (and related RF-5.1 prose) to the
+        // dedicated body section — frontmatter description must not satisfy these.
+        const projectVsPacks = skillSection(body, RF51_HEADING);
+        // Both guidance clauses are required — Prefer|Declare OR let either alone satisfy.
+        expect(projectVsPacks).toMatch(/Prefer a \*\*pack\*\*/);
+        expect(projectVsPacks).toMatch(/Declare a \*\*project sensor\*\*\s+when\s+the check is project-owned/i);
+        expect(projectVsPacks).toMatch(/"source"\s*:\s*"project"/);
+        expect(projectVsPacks).toMatch(/```json[\s\S]*?"source"\s*:\s*"project"[\s\S]*?```/);
+        expect(projectVsPacks).toMatch(/project-declared[\s\S]{0,220}(?:does not|never)\s+(?:block|blocks)[\s\S]{0,100}unattended/i);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-workflow-manager",
-  "version": "9.16.0",
+  "version": "9.17.0",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"