agentic-workflow-manager 3.12.0 → 3.13.0

package/dist/src/commands/preflight/checks.js

@@ -9,6 +9,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const status_1 = require("../sensors/status");
 const init_1 = require("../sensors/init");
+const baseline_1 = require("../sensors/baseline");
 const paths_1 = require("../../core/paths");
 const MANIFEST = path_1.default.join('.awm', 'sensors.json');
 /**
@@ -36,6 +37,18 @@ function readManifest(cwd) {
         return null;
     }
 }
+/**
+ * Total sensor entries and how many are enabled (`enabled !== false`, so a missing
+ * `enabled` field defaults to counted-as-enabled). Shared by `checkManifest` and
+ * `checkSensorsBaseline` — they were previously two copies of the identical
+ * predicate, which post-implementation-qa flagged: a hardening applied to one (e.g.
+ * guarding a malformed sensor entry) would silently NOT apply to the other unless
+ * someone remembered to edit both. One function, two callers, one place to harden.
+ */
+function countEnabledSensors(manifest) {
+    const entries = Object.values(manifest.sensors ?? {});
+    return { total: entries.length, enabled: entries.filter(s => s.enabled !== false).length };
+}
 /**
  * A repo may legitimately have no sensors — but it has to SAY so, in a committed file.
  *
@@ -62,8 +75,7 @@ function checkManifest(cwd, manifest) {
             remedy: 'fix or regenerate it with `awm sensors init`',
         };
     }
-    const total = Object.keys(manifest.sensors ?? {}).length;
-    const enabled = Object.values(manifest.sensors ?? {}).filter(s => s.enabled !== false).length;
+    const { total, enabled } = countEnabledSensors(manifest);
     // total === 0 is NOT an opt-out: a deliberate opt-out lists every known sensor NAME
     // explicitly with `enabled: false` (total > 0, enabled === 0). Zero entries means
     // nothing was ever configured — most commonly because the registry had no pack.json
@@ -135,6 +147,51 @@ function checkPack(cwd, manifest) {
     }
     return { id: 'pack', ok: true, detail: `${manifest.pack} matches the detected stack` };
 }
+/**
+ * Advisory only — `ok` is ALWAYS `true`, same contract as `checkHost` below. A team
+ * adopting AWM on a legacy repo starts with pre-existing sensor findings; the ratchet
+ * (`awm sensors baseline`, `.awm/sensors.baseline.json`) exists precisely to snapshot
+ * those as accepted debt so the gate only fails on genuinely NEW findings. But nothing
+ * today surfaces that the mechanism exists — the team discovers it only after hitting a
+ * wall of red findings and going looking. This nudges them toward it before that
+ * happens. It never blocks preflight: a repo can legitimately have zero debt to
+ * snapshot (sensors enabled from day one), and "no baseline yet" is not itself a
+ * failure — only the operator's lack of awareness that baselining is an option is the
+ * problem this addresses.
+ *
+ * Only called when a manifest exists (see the conditional spread in `preflight()`) —
+ * there is nothing to baseline without sensors configured in the first place, so this
+ * mirrors how `checkTools`/`checkPack` are skipped entirely rather than reported on a
+ * repo that was never set up.
+ *
+ * Also requires at least one ENABLED sensor, via the same `countEnabledSensors` helper
+ * `checkManifest` uses — a deliberate opt-out (every sensor `enabled: false`) or an
+ * unparseable/empty manifest has nothing to baseline either, and nudging "run `awm
+ * sensors baseline`" there would be actively misleading rather than merely unnecessary.
+ *
+ * Presence is checked via `readBaseline` (same function `partition()` uses at gate time
+ * to decide suppression), not a raw `fs.existsSync` — a baseline PATH that exists but
+ * isn't a readable JSON file (e.g. a stray directory at that path) is treated by the
+ * real gate as "no baseline, nothing suppressed"; `existsSync` alone would have reported
+ * "baseline present" for that same case, reassuring the operator that debt is being
+ * suppressed when it silently is not.
+ */
+function checkSensorsBaseline(cwd, manifest) {
+    const enabled = manifest ? countEnabledSensors(manifest).enabled : 0;
+    if (enabled === 0) {
+        return { id: 'sensors-baseline', ok: true, detail: 'no enabled sensors — nothing to baseline' };
+    }
+    if ((0, baseline_1.readBaseline)(cwd) !== null) {
+        return { id: 'sensors-baseline', ok: true, detail: 'baseline present' };
+    }
+    return {
+        id: 'sensors-baseline',
+        ok: true,
+        detail: 'sensors configured, no baseline yet — awm sensors baseline',
+        remedy: 'run `awm sensors baseline` to snapshot pre-existing findings as accepted debt, '
+            + 'so the gate only chases new problems',
+    };
+}
 /**
  * Extract just the hostname portion of a git remote URL — never match against the
  * full URL string. A bare substring check against the whole remote (`remote.includes
@@ -224,9 +281,10 @@ function preflight(cwd = process.cwd()) {
     const checks = [
         checkContext(cwd),
         checkManifest(cwd, manifest),
-        // Skipped when there is no manifest: reporting "tools broken" on a repo that was
-        // never set up buries the one thing the operator needs to read.
-        ...(manifestExists ? [checkTools(cwd), checkPack(cwd, manifest)] : []),
+        // Skipped when there is no manifest: reporting "tools broken" (or nudging toward
+        // a baseline that has nothing to snapshot) on a repo that was never set up
+        // buries the one thing the operator needs to read.
+        ...(manifestExists ? [checkTools(cwd), checkPack(cwd, manifest), checkSensorsBaseline(cwd, manifest)] : []),
         // Runs unconditionally — orthogonal to sensor configuration entirely, this is
         // about PR/MR tooling, not sensors.
         checkHost(cwd),

package/dist/src/commands/preflight/index.js

@@ -20,7 +20,12 @@ function exitCodeFor(report) {
     return report.status === 'ready' ? 0 : 1;
 }
 function formatReport(report) {
-    const lines = report.checks.map(c => `  ${c.ok ? picocolors_1.default.green('✔') : picocolors_1.default.red('✘')}  ${c.id.padEnd(9)} ${c.detail}`
+    // Computed from the actual ids present, not hardcoded to the widest id THIS
+    // report happens to have — a fixed literal here silently misaligns the moment a
+    // longer `PreflightCheck['id']` is added (confirmed: 'sensors-baseline', at 16
+    // chars, broke a hardcoded 9-char pad).
+    const idWidth = Math.max(0, ...report.checks.map(c => c.id.length));
+    const lines = report.checks.map(c => `  ${c.ok ? picocolors_1.default.green('✔') : picocolors_1.default.red('✘')}  ${c.id.padEnd(idWidth)} ${c.detail}`
         + (c.remedy ? `\n       ${picocolors_1.default.dim('→ ' + c.remedy)}` : ''));
     if (report.status === 'ready') {
         return `${picocolors_1.default.green('✔')}  Harness ready — this project can be gated.\n${lines.join('\n')}\n`;

package/dist/src/commands/sensors/baseline.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASELINE_FILE = void 0;
 exports.fingerprint = fingerprint;
 exports.readBaseline = readBaseline;
 exports.writeBaseline = writeBaseline;
@@ -11,7 +12,7 @@ exports.buildBaseline = buildBaseline;
 const crypto_1 = __importDefault(require("crypto"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const BASELINE_FILE = path_1.default.join('.awm', 'sensors.baseline.json');
+exports.BASELINE_FILE = path_1.default.join('.awm', 'sensors.baseline.json');
 /**
  * Mask runs of digits so location noise embedded in messages (e.g. the tsc
  * formatter writes "... line 199 ...") doesn't change the fingerprint when code
@@ -43,7 +44,7 @@ function fingerprint(sensor, e) {
     return crypto_1.default.createHash('sha1').update(basis).digest('hex');
 }
 function readBaseline(cwd) {
-    const p = path_1.default.join(cwd, BASELINE_FILE);
+    const p = path_1.default.join(cwd, exports.BASELINE_FILE);
     if (!fs_1.default.existsSync(p))
         return null;
     try {
@@ -55,7 +56,7 @@ function readBaseline(cwd) {
 }
 function writeBaseline(cwd, baseline) {
     fs_1.default.mkdirSync(path_1.default.join(cwd, '.awm'), { recursive: true });
-    fs_1.default.writeFileSync(path_1.default.join(cwd, BASELINE_FILE), JSON.stringify(baseline, null, 2), 'utf-8');
+    fs_1.default.writeFileSync(path_1.default.join(cwd, exports.BASELINE_FILE), JSON.stringify(baseline, null, 2), 'utf-8');
 }
 /**
  * Split a sensor's findings into new vs baseline-suppressed. With no accepted

package/dist/tests/commands/preflight/preflight.test.js

@@ -312,6 +312,81 @@ describe('preflight', () => {
             expect(check(report, 'host').detail).toContain('gitlab detected');
         });
     });
+    describe('sensors-baseline check (advisory — never changes the exit code)', () => {
+        it('nudges toward `awm sensors baseline` when sensors are configured but no baseline exists', () => {
+            // The team-rollout gap this addresses: a legacy repo adopts AWM, sensors get
+            // configured, and the ratchet mechanism exists to snapshot pre-existing debt —
+            // but nothing tells the operator it's there until they hit a wall of red
+            // findings and go looking for it.
+            const dir = make({
+                manifest: { pack: 'js-ts', sensors: { lint: { cmd: 'npx eslint .' } } },
+                bins: ['eslint'],
+                files: ['package.json'],
+            });
+            const report = (0, checks_1.preflight)(dir);
+            expect(check(report, 'sensors-baseline').ok).toBe(true);
+            expect(check(report, 'sensors-baseline').detail).toContain('no baseline yet');
+            expect(check(report, 'sensors-baseline').remedy).toContain('awm sensors baseline');
+            expect(report.status).toBe('ready');
+        });
+        it('reports the no-advisory-needed state when a baseline already exists, without nudging', () => {
+            const dir = make({
+                manifest: { pack: 'js-ts', sensors: { lint: { cmd: 'npx eslint .' } } },
+                bins: ['eslint'],
+                files: ['package.json'],
+            });
+            fs_1.default.mkdirSync(path_1.default.join(dir, '.awm'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(dir, '.awm', 'sensors.baseline.json'), JSON.stringify({ lint: [] }));
+            const report = (0, checks_1.preflight)(dir);
+            expect(check(report, 'sensors-baseline').ok).toBe(true);
+            expect(check(report, 'sensors-baseline').detail).toBe('baseline present');
+            expect(check(report, 'sensors-baseline').remedy).toBeUndefined();
+            expect(report.status).toBe('ready');
+        });
+        it('is omitted entirely when there is no manifest at all — nothing to baseline without sensors', () => {
+            const dir = make();
+            const report = (0, checks_1.preflight)(dir);
+            expect(report.checks.find(c => c.id === 'sensors-baseline')).toBeUndefined();
+            expect(report.status).toBe('not_configured');
+        });
+        it('does not nudge on a deliberate opt-out (every sensor disabled) — nothing to baseline', () => {
+            // Regression: the trigger condition originally checked only manifestExists, so a
+            // repo that deliberately opted out (checkManifest's own documented pattern: every
+            // sensor `enabled: false`) still got told to run `awm sensors baseline` — nothing
+            // to baseline when there's nothing enabled to have findings in the first place.
+            const dir = make({
+                manifest: { pack: 'js-ts', sensors: { lint: { cmd: 'npx eslint .', enabled: false } } },
+            });
+            const report = (0, checks_1.preflight)(dir);
+            expect(check(report, 'sensors-baseline').ok).toBe(true);
+            expect(check(report, 'sensors-baseline').detail).toBe('no enabled sensors — nothing to baseline');
+            expect(check(report, 'sensors-baseline').remedy).toBeUndefined();
+        });
+        it('does not nudge on an unparseable manifest — nothing to baseline', () => {
+            const dir = make({ manifest: '{not valid json' });
+            const report = (0, checks_1.preflight)(dir);
+            expect(check(report, 'sensors-baseline').ok).toBe(true);
+            expect(check(report, 'sensors-baseline').detail).toBe('no enabled sensors — nothing to baseline');
+            expect(check(report, 'sensors-baseline').remedy).toBeUndefined();
+        });
+        it('still nudges when the baseline path exists but is not a readable file (e.g. a stray directory)', () => {
+            // Regression: checking presence via `fs.existsSync` alone would have reported
+            // "baseline present" here, reassuring the operator that debt is suppressed —
+            // but the real gate (`readBaseline`, used by `partition()`) treats an unreadable
+            // baseline path as "no baseline, nothing suppressed". The advisory must track
+            // what the runtime actually does, not just whether something exists at the path.
+            const dir = make({
+                manifest: { pack: 'js-ts', sensors: { lint: { cmd: 'npx eslint .' } } },
+                bins: ['eslint'],
+                files: ['package.json'],
+            });
+            fs_1.default.mkdirSync(path_1.default.join(dir, '.awm', 'sensors.baseline.json'), { recursive: true });
+            const report = (0, checks_1.preflight)(dir);
+            expect(check(report, 'sensors-baseline').ok).toBe(true);
+            expect(check(report, 'sensors-baseline').detail).toContain('no baseline yet');
+            expect(check(report, 'sensors-baseline').remedy).toContain('awm sensors baseline');
+        });
+    });
     it('tells the operator not to hand a broken harness to an unattended run', () => {
         const out = (0, preflight_1.formatReport)({
             status: 'not_configured',
@@ -320,4 +395,24 @@ describe('preflight', () => {
         expect(out).toContain('unattended');
         expect(out).toContain('awm sensors init');
     });
+    it('pads the id column to the widest id actually present, not a hardcoded width', () => {
+        // Regression: a literal `.padEnd(9)` silently misaligned once `sensors-baseline`
+        // (16 chars) was added as a check id — every detail column shifted left of where
+        // shorter ids' details landed. The width must be derived from the report itself.
+        // Marker prefixes (@@) pin exactly where each detail column starts, independent
+        // of the detail text's own content.
+        const out = (0, preflight_1.formatReport)({
+            status: 'ready',
+            checks: [
+                { id: 'host', ok: true, detail: '@@marker' },
+                { id: 'sensors-baseline', ok: true, detail: '@@marker' },
+            ],
+        });
+        const lines = out.split('\n').filter(l => l.includes('@@marker'));
+        expect(lines).toHaveLength(2);
+        expect(lines[0].indexOf('@@marker')).toBe(lines[1].indexOf('@@marker'));
+        // And the column is genuinely sized to the longest id (16, 'sensors-baseline'),
+        // not the old hardcoded 9 — the shorter id's row must carry visible padding.
+        expect(lines[0]).toMatch(/host {12,}@@marker/);
+    });
 });

package/package.json

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