agentic-workflow-manager 9.11.1 → 9.11.3

package/dist/scripts/support-matrix.js

@@ -156,7 +156,6 @@ function spliceGenerated(markdown, generated) {
 exports.DOC_PATH = path_1.default.join(__dirname, '..', '..', 'docs', 'support-matrix.md');
 /* istanbul ignore next — entrypoint de CLI, ejercitado por el test via las funciones puras */
 if (require.main === module) {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
     const fs = require('fs');
     const current = fs.readFileSync(exports.DOC_PATH, 'utf-8');
     fs.writeFileSync(exports.DOC_PATH, spliceGenerated(current, renderProviderTables()), 'utf-8');

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

@@ -155,11 +155,18 @@ function checkManifest(status) {
             remedy: `registry has no pack for '${manifest.pack}': run \`awm update\` or add a registry that has it`,
         };
     }
+    // An applicable sensor the project cannot initialize is a real gap, so it is
+    // named here rather than left as an absence. It does not flip `ok`: whether an
+    // uninitialized sensor should block a handoff is a gate-policy decision, and
+    // flipping it would restore the dead end #172 is about — a project whose only
+    // gap is one missing tool could then configure sensors and still never pass.
+    const uninitialized = Object.keys(status.uninitialized ?? {});
+    const gap = uninitialized.length === 0 ? '' : `; ${uninitialized.length} applicable sensor(s) not initialized: ${uninitialized.join(', ')}`;
     return {
         id: 'manifest',
         ok: true,
-        detail: enabled === 0 ? `pack ${manifest.pack}, all ${total} sensors disabled (deliberate opt-out)`
-            : `pack ${manifest.pack}, ${enabled}/${total} sensors enabled`,
+        detail: (enabled === 0 ? `pack ${manifest.pack}, all ${total} sensors disabled (deliberate opt-out)`
+            : `pack ${manifest.pack}, ${enabled}/${total} sensors enabled`) + gap,
     };
 }
 /** Every enabled sensor's command must resolve. This is the check nothing was calling. */

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

@@ -20,8 +20,8 @@ const safe_file_1 = require("./compatibility/safe-file");
 const fs_1 = __importDefault(require("fs"));
 const crypto_1 = require("crypto");
 const path_1 = __importDefault(require("path"));
-function blocked(projectRoot, manifestPath, dryRun, reason, remedy, candidates) {
-    return { kind: 'blocked', projectRoot, manifestPath, changes: [], dryRun, reason, remedy, ...(candidates ? { candidates } : {}) };
+function blocked(projectRoot, manifestPath, dryRun, reason, remedy, candidates, unresolved) {
+    return { kind: 'blocked', projectRoot, manifestPath, changes: [], dryRun, reason, remedy, ...(candidates ? { candidates } : {}), ...(unresolved && unresolved.length > 0 ? { unresolved } : {}) };
 }
 function options(input) {
     if (input === undefined)
@@ -84,21 +84,40 @@ async function projectSensors(projectRoot, registryRoot, requestedPack, packageR
         return { reason: 'compatibility-unresolvable', remedy: 'repair-project-tools-or-select-another-mode' };
     }
     const sensors = {};
+    const unresolved = [];
+    let applicable = 0;
     for (const [name, packSensor] of Object.entries(live.pack.sensors)) {
         const evidence = live.sensors[name];
         if (evidence.state === 'not-applicable')
             continue;
+        applicable += 1;
         const variant = evidence.variantId === null ? undefined : packSensor.variants.find(item => item.id === evidence.variantId);
-        if (!variant)
-            return { reason: 'sensor-variant-unresolvable', remedy: 'repair-project-tools-or-select-another-mode' };
+        // One applicable sensor whose tool is absent used to abort the whole
+        // manifest, including the sensors that DID resolve, so a project whose
+        // only gap was (say) semgrep could not configure sensors at all — and so
+        // could not pass preflight, and so could not be handed off. A missing tool
+        // is a gap in one sensor, not grounds to refuse the pack. It is skipped
+        // and REPORTED by name; nothing is invented for it, because the v3 entry
+        // shape requires a real variant, command and probe evidence. See #172.
+        if (!variant) {
+            unresolved.push({ sensor: name, state: evidence.state, reason: evidence.reason });
+            continue;
+        }
         sensors[name] = { enabled: true, ...(packSensor.fast === undefined ? {} : { fast: packSensor.fast }), ...(packSensor.timeout === undefined ? {} : { timeout: packSensor.timeout }), variantId: variant.id, command: variant.command, ...(variant.assets.length === 0 ? {} : { assets: variant.assets }), ...(variant.policyRef ? { policyRef: variant.policyRef } : {}), initializedCompatibility: evidence };
     }
+    // A pack with NO applicable sensor still writes an honest empty manifest: that
+    // is the distinct "the registry has no pack for this stack" signal preflight
+    // already reports. But a pack where sensors apply and none of them resolve is
+    // a different condition, and writing an empty manifest would collide with it.
+    if (applicable > 0 && Object.keys(sensors).length === 0) {
+        return { reason: 'no-sensor-resolvable', remedy: 'repair-project-tools-or-select-another-mode', unresolved };
+    }
     const manifest = (0, manifest_1.parseSensorManifest)({ schemaVersion: 3, mode: 'project-sensors', pack, source: { registry: source.registry.name }, ...(packageRoot ? { packageRoot } : {}), sensors }, 'bootstrap candidate');
     if (manifest.kind !== 'v3' || manifest.pack.mode !== 'project-sensors')
         throw new Error('bootstrap project-sensors candidate is invalid');
     (0, manifest_1.serializeManifestV3)(manifest.pack);
     const assets = [...new Set(Object.values(sensors).flatMap(sensor => sensor.assets ?? []))].sort();
-    return { manifest: manifest.pack, source, changes: [{ path: '.awm/sensors.json', action: 'create' }, ...assets.map(asset => ({ path: packageRoot ? `${packageRoot}/${asset}` : asset, action: 'create' }))] };
+    return { manifest: manifest.pack, source, changes: [{ path: '.awm/sensors.json', action: 'create' }, ...assets.map(asset => ({ path: packageRoot ? `${packageRoot}/${asset}` : asset, action: 'create' }))], unresolved };
 }
 /** Plan a one-time portable bootstrap. This function never writes project or machine state. */
 async function planSensorBootstrap(cwd = process.cwd(), input = {}) {
@@ -125,7 +144,7 @@ async function planSensorBootstrap(cwd = process.cwd(), input = {}) {
             // activate v2 sensors which require an explicit project opt-in.
             const planned = await projectSensors(project.projectRoot, opts.registryRoot, project.manifest.pack.pack, undefined, false);
             if ('reason' in planned)
-                return blocked(project.projectRoot, project.manifestPath, opts.dryRun, planned.reason, planned.remedy, 'candidates' in planned ? planned.candidates : undefined);
+                return blocked(project.projectRoot, project.manifestPath, opts.dryRun, planned.reason, planned.remedy, 'candidates' in planned ? planned.candidates : undefined, planned.unresolved);
             try {
                 const original = fs_1.default.readFileSync(project.manifestPath);
                 return {
@@ -133,6 +152,7 @@ async function planSensorBootstrap(cwd = process.cwd(), input = {}) {
                     changes: planned.changes.map((change, index) => index === 0 ? { ...change, action: 'replace' } : change),
                     dryRun: opts.dryRun, migration: { kind: 'legacy-v1', manifest: planned.manifest }, source: planned.source,
                     originalDigest: digest(original),
+                    ...(planned.unresolved.length > 0 ? { unresolved: planned.unresolved } : {}),
                 };
             }
             catch {
@@ -165,8 +185,8 @@ async function planSensorBootstrap(cwd = process.cwd(), input = {}) {
     }
     const planned = await projectSensors(project.projectRoot, opts.registryRoot, opts.pack, opts.packageRoot);
     if ('reason' in planned)
-        return blocked(project.projectRoot, project.manifestPath, opts.dryRun, planned.reason, planned.remedy, 'candidates' in planned ? planned.candidates : undefined);
-    return { kind: 'create', projectRoot: project.projectRoot, manifestPath: project.manifestPath, changes: planned.changes, dryRun: opts.dryRun, manifest: planned.manifest, source: planned.source, configure: opts.configure };
+        return blocked(project.projectRoot, project.manifestPath, opts.dryRun, planned.reason, planned.remedy, 'candidates' in planned ? planned.candidates : undefined, planned.unresolved);
+    return { kind: 'create', projectRoot: project.projectRoot, manifestPath: project.manifestPath, changes: planned.changes, dryRun: opts.dryRun, manifest: planned.manifest, source: planned.source, configure: opts.configure, ...(planned.unresolved.length > 0 ? { unresolved: planned.unresolved } : {}) };
 }
 /** Apply only a validated, non-dry-run create or migration plan. */
 function applySensorBootstrap(plan) {

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

@@ -16,6 +16,7 @@ const render_1 = require("./coverage/render");
 const registries_1 = require("../../core/registries");
 const verdict_1 = require("./verdict");
 const bootstrap_1 = require("./bootstrap");
+const unresolved_1 = require("./unresolved");
 /** Commander coercion for coverage recurrence emphasis. It deliberately runs
  * before the action, so an invalid value cannot trigger ledger I/O. */
 function parsePositiveSafeInteger(value) {
@@ -72,8 +73,10 @@ function registerSensorsCommand(program) {
         const registryRoot = opts.registryRoot ?? (0, registries_1.capabilityRoot)('sensor-packs') ?? undefined;
         try {
             const plan = await (0, bootstrap_1.planSensorBootstrap)(process.cwd(), { mode: 'project-sensors', registryRoot, configure: opts.configure, pack: opts.pack, packageRoot: opts.packageRoot });
-            if (plan.kind === 'blocked')
-                throw new Error(`${plan.reason}: ${plan.remedy}`);
+            if (plan.kind === 'blocked') {
+                const detail = (0, unresolved_1.describeUnresolved)(plan.unresolved);
+                throw new Error(`${plan.reason}: ${plan.remedy}${detail === '' ? '' : ` (${detail})`}`);
+            }
             if (plan.kind === 'noop') {
                 prompts_1.log.info('already-configured');
                 return;
@@ -83,8 +86,12 @@ function registerSensorsCommand(program) {
             const result = (0, bootstrap_1.applySensorBootstrap)(plan);
             const detected = plan.manifest.mode === 'project-sensors' ? plan.manifest.pack : 'none';
             prompts_1.log.success(`Detected: ${detected}`);
-            // Said BEFORE "Wrote .awm/sensors.json": the manifest about to be
-            // reported as written is not the one the detection implied.
+            // Said BEFORE "Wrote .awm/sensors.json": a partially resolved pack
+            // must not be reported as a clean write, and the manifest about to
+            // be reported as written is not the one the detection implied.
+            const skipped = (0, unresolved_1.describeUnresolved)(plan.unresolved);
+            if (skipped !== '')
+                prompts_1.log.warn(`not initialized (tool unavailable here): ${skipped}`);
             prompts_1.log.success(`${result} .awm/sensors.json`);
         }
         catch (e) {
@@ -102,7 +109,8 @@ function registerSensorsCommand(program) {
         try {
             const plan = await (0, bootstrap_1.planSensorBootstrap)(process.cwd(), { mode: opts.mode, reason: opts.reason, dryRun: opts.dryRun });
             if (plan.kind === 'blocked') {
-                prompts_1.log.error(`${plan.reason}: ${plan.remedy}`);
+                const detail = (0, unresolved_1.describeUnresolved)(plan.unresolved);
+                prompts_1.log.error(`${plan.reason}: ${plan.remedy}${detail === '' ? '' : ` (${detail})`}`);
                 process.exitCode = 1;
                 return;
             }
@@ -154,6 +162,12 @@ function registerSensorsCommand(program) {
             const mark = check.ok ? picocolors_1.default.green('✔') : picocolors_1.default.red('✘');
             console.log(`  ${mark}  ${name.padEnd(12)} ${check.detail}`);
         }
+        // A pack sensor that applies here but has no manifest entry is otherwise
+        // indistinguishable from one the pack never applied. It does not change
+        // the verdict; it is named so the gap is attributable. See #172.
+        for (const [name, gap] of Object.entries(status.uninitialized ?? {})) {
+            console.log(`  ${picocolors_1.default.yellow('–')}  ${name.padEnd(12)} not initialized: ${gap.state}/${gap.reason}`);
+        }
         console.log('');
         if (status.overall !== 'READY')
             process.exit(1);

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

@@ -11,6 +11,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const pack_source_1 = require("./compatibility/pack-source");
 const bootstrap_1 = require("./bootstrap");
+const unresolved_1 = require("./unresolved");
 /** Read a pack only through the shared source resolver.  Init is a registry
  * boundary: a pack path that is absent is harmless, but a symlink or escaping
  * claimed source is never silently downgraded to an empty manifest. */
@@ -155,8 +156,10 @@ async function initSensors(opts = {}) {
         mode: 'project-sensors', registryRoot: opts.registryRoot, configure: opts.configure,
         pack: opts.pack, packageRoot: opts.packageRoot,
     });
-    if (plan.kind === 'blocked')
-        throw new Error(`${plan.reason}: ${plan.remedy}`);
+    if (plan.kind === 'blocked') {
+        const detail = (0, unresolved_1.describeUnresolved)(plan.unresolved);
+        throw new Error(`${plan.reason}: ${plan.remedy}${detail === '' ? '' : ` (${detail})`}`);
+    }
     if (plan.kind === 'migrate')
         throw new Error('initSensors does not migrate existing v2 manifests; run awm sensors bootstrap');
     if (plan.kind === 'noop')
@@ -166,5 +169,5 @@ async function initSensors(opts = {}) {
             manifest: {}, detection: detectStack(detectionCwd), configured: [], status: 'already-configured',
         };
     (0, bootstrap_1.applySensorBootstrap)(plan);
-    return { manifest: plan.manifest, detection: detectStack(detectionCwd), configured: [], status: 'created' };
+    return { manifest: plan.manifest, detection: detectStack(detectionCwd), configured: [], status: 'created', ...(plan.unresolved && plan.unresolved.length > 0 ? { unresolved: plan.unresolved } : {}) };
 }

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

@@ -124,9 +124,40 @@ function resolveStaticV2Compatibility(cwd, manifest, source) {
                 : (0, resolve_1.resolveSensorCompatibility)(sensor, { ...resolutionEvidence, probe: { status: probeStatus } }, { pack: executionPack.name, sensor: name })];
     }));
 }
+/** Applicable pack sensors with no manifest entry, so the gap is attributable in
+ *  every `awm sensors status`, not only in the output of the `init` that skipped it. */
+function uninitializedSensors(manifest, compatibility) {
+    const entries = Object.entries(compatibility)
+        .filter(([name, evidence]) => evidence !== undefined && evidence.state !== 'not-applicable' && !Object.prototype.hasOwnProperty.call(manifest.sensors, name))
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, evidence]) => [name, { state: evidence.state, reason: evidence.reason }]);
+    return entries.length === 0 ? undefined : Object.fromEntries(entries);
+}
+/**
+ * Status never executes, so `discoverProjectEvidence` is called here without
+ * `pathToolVersion` and a `resolution: 'path'` tool is structurally invisible to
+ * it: `npm` on PATH resolves as `missing-tool`/`tool-not-found` whether it is
+ * installed or not. Reporting that as "compatibility drift" asserts something
+ * this command did not measure. `checkStructuredCommand` DOES consult PATH for
+ * exactly these commands, so defer to it rather than claim drift. Any other live
+ * state, or a genuinely different resolved variant, is still real drift.
+ *
+ * Today `missing-tool`/`tool-not-found` is the ONLY verdict a `path` tool can
+ * receive here, because discovery cannot see its version at all — so the state
+ * and reason conditions are unreachable as written. They are kept because every
+ * one of them can only make this guard NARROWER: a combination they reject falls
+ * through to the drift report, never past it. A future discovery that does read
+ * PATH would make them load-bearing rather than silently permissive.
+ */
+function unobservableOnPath(sensor, live) {
+    return sensor.command.resolution === 'path' && live.variantId === null
+        && live.state === 'missing-tool' && live.reason === 'tool-not-found';
+}
 function staticCompatibilityCheck(sensor, live) {
     if (!live)
         return { ok: false, detail: 'live compatibility unavailable' };
+    if (unobservableOnPath(sensor, live))
+        return null;
     if (live.variantId !== sensor.variantId) {
         return { ok: false, detail: `compatibility drift: initialized ${sensor.variantId}, resolved ${live.variantId ?? live.state}` };
     }
@@ -226,9 +257,11 @@ async function computeSensorStatus(cwd = process.cwd()) {
             checks[name] = sensor.enabled === false ? { ok: true, detail: 'disabled' }
                 : staticCompatibilityCheck(sensor, compatibility[name]) ?? checkStructuredCommand(sensor.command, packageRoot, sensor.assets);
         }
+        const uninitialized = uninitializedSensors(manifest, compatibility);
         return {
             overall: Object.keys(checks).length > 0 && Object.values(checks).every(check => check.ok) ? 'READY' : 'DEGRADED',
             pack: manifest.pack, checks,
+            ...(uninitialized ? { uninitialized } : {}),
             ...projectMetadata(project, 'project-sensors', sourceMeta.reason, { ...sourceMeta }),
         };
     }

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeUnresolved = describeUnresolved;
+/**
+ * `sensor-a: missing-tool/tool-not-found; sensor-b: incompatible/...` — which
+ * sensor and why. Before #172 an unresolvable sensor produced one code for the
+ * whole pack, so an operator could not tell that the other sensors were fine.
+ *
+ * Its own module so the command wiring and `initSensors` share one formatting,
+ * and so neither has to import the other to get it.
+ */
+function describeUnresolved(unresolved) {
+    if (!unresolved || unresolved.length === 0)
+        return '';
+    return [...unresolved]
+        .sort((left, right) => left.sensor.localeCompare(right.sensor))
+        .map(item => `${item.sensor}: ${item.state}/${item.reason}`)
+        .join('; ');
+}

package/dist/src/commands/update.js

@@ -40,7 +40,6 @@ const defaultDeps = {
     applyInstallPlan: install_transaction_1.applyInstallPlan,
     resyncInstalledHooks: resync_1.resyncInstalledHooks,
     offerSelfUpdate: async (mode) => {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
         const { offerSelfUpdate: real } = require('../core/update-check');
         await real({ mode });
     },

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

@@ -128,12 +128,16 @@ describe('planSensorBootstrap', () => {
         await (0, bootstrap_1.planSensorBootstrap)(root, { mode: 'project-sensors', packageRoot: 'packages/web' });
         expect(live_1.resolveParsedPackCompatibility).toHaveBeenCalledWith(path_1.default.resolve(root, 'packages/web'), pack);
     });
-    it('blocks project-sensors when compatibility cannot select every declared sensor variant', async () => {
+    // #172 narrowed this: one unresolvable sensor no longer aborts a pack whose
+    // other sensors resolved (see partial-pack-bootstrap.test.ts). What still
+    // blocks is a pack where sensors apply and NONE of them resolve, which is a
+    // different condition from a pack with no applicable sensor at all.
+    it('blocks project-sensors when sensors apply and compatibility can select no variant at all', async () => {
         const variant = { id: 'eslint-9', command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] }, assets: [] };
         pack_source_1.listPackSources.mockReturnValue([source]);
         contract_1.parseSensorPack.mockReturnValue({ kind: 'v2', pack: { schemaVersion: 2, name: 'js-ts', sensors: { lint: { variants: [variant] } } } });
-        live_1.resolveParsedPackCompatibility.mockResolvedValue({ pack: { schemaVersion: 2, name: 'js-ts', sensors: { lint: { variants: [variant] } } }, sensors: { lint: { variantId: null } } });
-        await expect((0, bootstrap_1.planSensorBootstrap)(root, { mode: 'project-sensors' })).resolves.toMatchObject({ kind: 'blocked', reason: 'sensor-variant-unresolvable', changes: [] });
+        live_1.resolveParsedPackCompatibility.mockResolvedValue({ pack: { schemaVersion: 2, name: 'js-ts', sensors: { lint: { variants: [variant] } } }, sensors: { lint: { state: 'missing-tool', reason: 'tool-not-found', variantId: null } } });
+        await expect((0, bootstrap_1.planSensorBootstrap)(root, { mode: 'project-sensors' })).resolves.toMatchObject({ kind: 'blocked', reason: 'no-sensor-resolvable', changes: [] });
     });
     it('omits explicit-opt-in sensors that are not applicable while retaining mandatory gates', async () => {
         const variant = { id: 'main', command: { executable: 'tool', resolution: 'path', args: ['run'] }, assets: [] };

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-jest.mock('@clack/prompts', () => ({ log: { success: jest.fn(), info: jest.fn(), error: jest.fn() } }));
+jest.mock('@clack/prompts', () => ({ log: { success: jest.fn(), info: jest.fn(), error: jest.fn(), warn: jest.fn() } }));
 jest.mock('picocolors', () => ({ green: (s) => s, yellow: (s) => s, red: (s) => s }));
 jest.mock('../../../src/commands/sensors/run', () => ({ runSensors: jest.fn() }));
 jest.mock('../../../src/commands/sensors/init', () => ({ initSensors: jest.fn() }));

package/dist/tests/commands/sensors/partial-pack-bootstrap.test.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('../../../src/commands/sensors/project', () => ({ resolveSensorProject: jest.fn() }));
+jest.mock('../../../src/commands/sensors/detection', () => ({ detectStack: jest.fn() }));
+jest.mock('../../../src/core/registries', () => ({ listRegistries: jest.fn(() => []) }));
+jest.mock('../../../src/commands/sensors/compatibility/pack-source', () => ({ listPackSources: jest.fn() }));
+jest.mock('../../../src/commands/sensors/compatibility/contract', () => ({ ...jest.requireActual('../../../src/commands/sensors/compatibility/contract'), parseSensorPack: jest.fn() }));
+jest.mock('../../../src/commands/sensors/compatibility/live', () => ({ resolveParsedPackCompatibility: jest.fn() }));
+jest.mock('../../../src/commands/sensors/compatibility/materialize', () => ({ materializePortableSensors: jest.fn() }));
+jest.mock('../../../src/commands/sensors/compatibility/safe-file', () => ({ writeProjectFile: jest.fn(), withProjectLease: jest.fn((_root, operation) => operation()) }));
+const bootstrap_1 = require("../../../src/commands/sensors/bootstrap");
+const unresolved_1 = require("../../../src/commands/sensors/unresolved");
+const project_1 = require("../../../src/commands/sensors/project");
+const detection_1 = require("../../../src/commands/sensors/detection");
+const pack_source_1 = require("../../../src/commands/sensors/compatibility/pack-source");
+const contract_1 = require("../../../src/commands/sensors/compatibility/contract");
+const live_1 = require("../../../src/commands/sensors/compatibility/live");
+// #172. One applicable sensor whose tool is absent used to abort the entire
+// manifest, including the sensors that DID resolve — so a project whose only gap
+// was semgrep could not configure sensors, could not pass preflight, and could
+// not be handed off. A missing tool is a gap in one sensor, not grounds to refuse
+// the pack.
+const root = '/project';
+const missing = { state: 'missing', projectRoot: root, manifestPath: `${root}/.awm/sensors.json` };
+const source = { path: '/registry/sensor-packs/js-ts/pack.json', content: '{}', registry: { name: 'baseline', remote: 'local', contentRoot: '/registry' } };
+const lintVariant = { id: 'eslint-10', command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] }, assets: [] };
+const securityVariant = { id: 'semgrep-js-ts', command: { executable: 'semgrep', resolution: 'path', args: ['--config', '.semgrep.awm.yml'] }, assets: ['.semgrep.awm.yml'] };
+function resolvedLint() {
+    return { state: 'certified', reason: 'range-and-probe', variantId: 'eslint-10', toolVersion: '10.4.1', runtimeVersion: '24.0.0', certifiedRange: '>=10 <11', evidence: [] };
+}
+function unresolvedSensor(state, reason) {
+    return { state, reason, variantId: null, toolVersion: null, runtimeVersion: null, certifiedRange: null, evidence: [] };
+}
+/** Wire the mocked pack + live resolution for one planning run. */
+function pack(sensors, live) {
+    const parsed = { schemaVersion: 2, name: 'js-ts', sensors };
+    pack_source_1.listPackSources.mockReturnValue([source]);
+    contract_1.parseSensorPack.mockReturnValue({ kind: 'v2', pack: parsed });
+    live_1.resolveParsedPackCompatibility.mockResolvedValue({ pack: parsed, sensors: live });
+}
+describe('project-sensors bootstrap with a partially resolvable pack', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        project_1.resolveSensorProject.mockReturnValue(missing);
+        detection_1.detectStack.mockReturnValue({ pack: 'js-ts', indicators: ['package.json'] });
+    });
+    it('writes the sensors that resolved and reports by name the applicable one that did not', async () => {
+        pack({ lint: { variants: [lintVariant] }, security: { variants: [securityVariant] } }, { lint: resolvedLint(), security: unresolvedSensor('missing-tool', 'tool-not-found') });
+        const plan = await (0, bootstrap_1.planSensorBootstrap)(root, { mode: 'project-sensors' });
+        expect(plan.kind).toBe('create');
+        const created = plan;
+        const manifest = created.manifest;
+        // The manifest contents are the assertion, not the exit code.
+        expect(Object.keys(manifest.sensors)).toEqual(['lint']);
+        expect(manifest.sensors.lint.variantId).toBe('eslint-10');
+        expect(created.unresolved).toEqual([{ sensor: 'security', state: 'missing-tool', reason: 'tool-not-found' }]);
+        // Nothing is invented for the skipped sensor: no entry, and none of its assets.
+        expect(created.changes.map(change => change.path)).toEqual(['.awm/sensors.json']);
+    });
+    it('carries a sensor with no manifest entry rather than a disabled entry with fabricated evidence', async () => {
+        pack({ lint: { variants: [lintVariant] }, security: { variants: [securityVariant] } }, { lint: resolvedLint(), security: unresolvedSensor('incompatible', 'no-operational-variant') });
+        const plan = await (0, bootstrap_1.planSensorBootstrap)(root, { mode: 'project-sensors' });
+        const manifest = plan.manifest;
+        expect(manifest.sensors).not.toHaveProperty('security');
+        expect(JSON.stringify(manifest)).not.toContain('semgrep');
+    });
+    it('still blocks, naming every sensor, when sensors apply and none of them resolve', async () => {
+        pack({ lint: { variants: [lintVariant] }, security: { variants: [securityVariant] } }, { lint: unresolvedSensor('missing-tool', 'tool-not-found'), security: unresolvedSensor('missing-tool', 'tool-not-found') });
+        const plan = await (0, bootstrap_1.planSensorBootstrap)(root, { mode: 'project-sensors' });
+        expect(plan).toMatchObject({ kind: 'blocked', reason: 'no-sensor-resolvable', changes: [] });
+        expect(plan.unresolved).toEqual([
+            { sensor: 'lint', state: 'missing-tool', reason: 'tool-not-found' },
+            { sensor: 'security', state: 'missing-tool', reason: 'tool-not-found' },
+        ]);
+    });
+    it('keeps the distinct honest-empty manifest when the pack declares no applicable sensor', async () => {
+        // This is NOT the same condition as "nothing resolved": it is the registry
+        // having no sensor for this stack, which preflight reports with its own
+        // remedy. Writing an empty manifest for an unresolvable pack would collide
+        // with that signal.
+        pack({ lint: { variants: [lintVariant] } }, { lint: unresolvedSensor('not-applicable', 'applicability-not-met') });
+        const plan = await (0, bootstrap_1.planSensorBootstrap)(root, { mode: 'project-sensors' });
+        const manifest = plan.manifest;
+        expect(plan.kind).toBe('create');
+        expect(manifest.sensors).toEqual({});
+        expect(plan.unresolved).toBeUndefined();
+    });
+    it('omits the unresolved field entirely when every applicable sensor resolved', async () => {
+        pack({ lint: { variants: [lintVariant] } }, { lint: resolvedLint() });
+        const plan = await (0, bootstrap_1.planSensorBootstrap)(root, { mode: 'project-sensors' });
+        expect(plan.unresolved).toBeUndefined();
+    });
+});
+describe('describeUnresolved', () => {
+    it('names each sensor with its state and reason, in a stable order', () => {
+        expect((0, unresolved_1.describeUnresolved)([
+            { sensor: 'security', state: 'missing-tool', reason: 'tool-not-found' },
+            { sensor: 'depcheck', state: 'incompatible', reason: 'no-operational-variant' },
+        ])).toBe('depcheck: incompatible/no-operational-variant; security: missing-tool/tool-not-found');
+    });
+    it('is empty for nothing unresolved, so callers add no punctuation for an empty gap', () => {
+        expect((0, unresolved_1.describeUnresolved)(undefined)).toBe('');
+        expect((0, unresolved_1.describeUnresolved)([])).toBe('');
+    });
+});

package/dist/tests/commands/sensors/partial-pack-status.test.js

@@ -0,0 +1,174 @@
+"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");
+const checks_1 = require("../../../src/commands/preflight/checks");
+// #172. `checks` only ever covered what the manifest declares, so a pack sensor
+// that applies to this project and could not be initialized was simply absent —
+// indistinguishable from one the pack never applied. These tests hold the gap
+// visible and attributable in every `awm sensors status`, not only in the output
+// of the `init` that skipped it.
+//
+// Isolated HOME/AWM_HOME per test: nothing here may read or write the real
+// `~/.awm`, which belongs to the installer.
+const ESLINT_VARIANT = {
+    id: 'eslint-10',
+    priority: 100,
+    requirements: { tool: 'eslint', toolRange: '>=10.0.0 <12.0.0', runtime: 'node', runtimeRange: '>=20.0.0' },
+    certifiedRange: '>=10.0.0 <11.0.0',
+    command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+    assets: [],
+    formatter: 'eslint',
+    probe: { kind: 'config-present' },
+};
+const SEMGREP_VARIANT = {
+    id: 'semgrep-js-ts',
+    priority: 10,
+    requirements: { tool: 'semgrep', toolRange: '>=1.0.0', runtime: 'node', runtimeRange: '>=20.0.0' },
+    certifiedRange: '>=1.0.0',
+    command: { executable: 'semgrep', resolution: 'path', args: ['--config', '.semgrep.awm.yml'] },
+    assets: [],
+    formatter: 'semgrep',
+    probe: { kind: 'version' },
+};
+function packJson(sensors) {
+    const detector = Object.keys(sensors)[0];
+    return JSON.stringify({
+        schemaVersion: 2, name: 'js-ts', description: '#172 fixture', detects: ['package.json'], sensors,
+        coverage: {
+            schemaVersion: 1,
+            classes: { 'lint-errors': { description: 'Findings', detectors: [{ sensor: detector }], remedy: { summary: 'Configure', command: 'awm sensors init --pack js-ts' } } },
+        },
+    });
+}
+function lintEntry() {
+    return {
+        enabled: true, variantId: 'eslint-10',
+        command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.'] },
+        initializedCompatibility: { state: 'certified', reason: 'range-and-probe', variantId: 'eslint-10', toolVersion: '10.4.1', runtimeVersion: '24.0.0', certifiedRange: '>=10.0.0 <11.0.0', evidence: [] },
+    };
+}
+function semgrepEntry() {
+    return {
+        enabled: true, variantId: 'semgrep-js-ts',
+        command: { executable: 'semgrep', resolution: 'path', args: ['--config', '.semgrep.awm.yml'] },
+        initializedCompatibility: { state: 'compatible-unverified', reason: 'operational-range-and-probe', variantId: 'semgrep-js-ts', toolVersion: '1.173.0', runtimeVersion: '24.0.0', certifiedRange: '>=1.0.0', evidence: [] },
+    };
+}
+describe('sensor status for a partially initialized pack', () => {
+    let root;
+    let project;
+    let pathDir;
+    let previous;
+    beforeEach(() => {
+        root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-172-'));
+        project = path_1.default.join(root, 'project');
+        pathDir = path_1.default.join(root, 'bin');
+        const registry = path_1.default.join(root, 'awm-home', 'registries', 'baseline', 'sensor-packs', 'js-ts');
+        fs_1.default.mkdirSync(registry, { recursive: true });
+        fs_1.default.mkdirSync(path_1.default.join(project, '.awm'), { recursive: true });
+        fs_1.default.mkdirSync(pathDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(root, 'awm-home', 'registries.json'), JSON.stringify([{ name: 'baseline', remote: 'fixture' }]));
+        fs_1.default.writeFileSync(path_1.default.join(project, 'package.json'), JSON.stringify({ name: 'fixture-172', private: true }));
+        fs_1.default.writeFileSync(path_1.default.join(project, 'eslint.config.mjs'), 'export default [];\n');
+        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({ name: 'eslint', version: '10.4.1' }));
+        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'), packJson({
+            lint: { applicability: { allFiles: ['package.json'] }, variants: [ESLINT_VARIANT] },
+            security: { applicability: { allFiles: ['package.json'] }, variants: [SEMGREP_VARIANT] },
+        }));
+        previous = { home: process.env.HOME, awmHome: process.env.AWM_HOME, path: process.env.PATH };
+        process.env.HOME = path_1.default.join(root, 'operator-home');
+        process.env.AWM_HOME = path_1.default.join(root, 'awm-home');
+        process.env.PATH = pathDir;
+    });
+    afterEach(() => {
+        for (const [key, value] of [['HOME', previous.home], ['AWM_HOME', previous.awmHome], ['PATH', previous.path]]) {
+            if (value === undefined)
+                delete process.env[key];
+            else
+                process.env[key] = value;
+        }
+        fs_1.default.rmSync(root, { recursive: true, force: true });
+    });
+    function writeManifest(sensors) {
+        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,
+        }));
+    }
+    function installOnPath(tool) {
+        const file = path_1.default.join(pathDir, tool);
+        fs_1.default.writeFileSync(file, '#!/bin/sh\nexit 0\n');
+        fs_1.default.chmodSync(file, 0o755);
+    }
+    it('names the applicable sensor that has no manifest entry, with its live reason', async () => {
+        writeManifest({ lint: lintEntry() });
+        const status = await (0, status_1.computeSensorStatus)(project);
+        expect(Object.keys(status.checks)).toEqual(['lint']);
+        expect(status.uninitialized).toEqual({ security: { state: 'missing-tool', reason: 'tool-not-found' } });
+    });
+    it('does not let an uninitialized sensor change the verdict, which stays a gate-policy decision', async () => {
+        writeManifest({ lint: lintEntry() });
+        const status = await (0, status_1.computeSensorStatus)(project);
+        expect(status.overall).toBe('READY');
+    });
+    it('omits the field when every applicable pack sensor has an entry', async () => {
+        installOnPath('semgrep');
+        writeManifest({ lint: lintEntry(), security: semgrepEntry() });
+        const status = await (0, status_1.computeSensorStatus)(project);
+        expect(status.uninitialized).toBeUndefined();
+    });
+    it('reports a not-applicable pack sensor as neither a check nor a gap', async () => {
+        const registry = path_1.default.join(root, 'awm-home', 'registries', 'baseline', 'sensor-packs', 'js-ts');
+        fs_1.default.writeFileSync(path_1.default.join(registry, 'pack.json'), packJson({
+            lint: { applicability: { allFiles: ['package.json'] }, variants: [ESLINT_VARIANT] },
+            security: { applicability: { allFiles: ['never-present.toml'] }, variants: [SEMGREP_VARIANT] },
+        }));
+        writeManifest({ lint: lintEntry() });
+        const status = await (0, status_1.computeSensorStatus)(project);
+        expect(status.uninitialized).toBeUndefined();
+        expect(status.checks).not.toHaveProperty('security');
+    });
+    it('preflight names the gap and still passes the manifest check, so one missing tool is not a dead end', async () => {
+        fs_1.default.mkdirSync(path_1.default.join(project, '.git'));
+        writeManifest({ lint: lintEntry() });
+        const report = await (0, checks_1.preflight)(project);
+        const manifest = report.checks.find(check => check.id === 'manifest');
+        expect(manifest).toMatchObject({ ok: true });
+        expect(manifest?.detail).toContain('1 applicable sensor(s) not initialized: security');
+    });
+    // `discoverProjectEvidence` is called here without `pathToolVersion` because
+    // status never executes, so a `resolution: 'path'` tool is invisible to it.
+    // Calling that "drift" asserts something this command did not measure.
+    it('does not claim drift for a PATH tool it cannot observe, and defers to the PATH check', async () => {
+        installOnPath('semgrep');
+        fs_1.default.writeFileSync(path_1.default.join(project, '.semgrep.awm.yml'), 'rules: []\n');
+        writeManifest({ security: semgrepEntry() });
+        const status = await (0, status_1.computeSensorStatus)(project);
+        expect(status.checks.security).toEqual({ ok: true, detail: 'semgrep' });
+        expect(status.overall).toBe('READY');
+    });
+    it('still fails a PATH sensor whose executable is genuinely absent from PATH', async () => {
+        writeManifest({ security: semgrepEntry() });
+        const status = await (0, status_1.computeSensorStatus)(project);
+        expect(status.checks.security.ok).toBe(false);
+        expect(status.checks.security.detail).toMatch(/semgrep not found in PATH/);
+    });
+    it('still reports real drift when the live resolution selects a different variant', async () => {
+        const registry = path_1.default.join(root, 'awm-home', 'registries', 'baseline', 'sensor-packs', 'js-ts');
+        fs_1.default.writeFileSync(path_1.default.join(registry, 'pack.json'), packJson({
+            lint: { applicability: { allFiles: ['package.json'] }, variants: [{ ...ESLINT_VARIANT, id: 'eslint-10-flat' }] },
+        }));
+        writeManifest({ lint: lintEntry() });
+        const status = await (0, status_1.computeSensorStatus)(project);
+        expect(status.checks.lint.ok).toBe(false);
+        expect(status.checks.lint.detail).toMatch(/compatibility drift: initialized eslint-10, resolved eslint-10-flat/);
+    });
+});

package/dist/tests/core/export/engine.test.js

@@ -77,7 +77,6 @@ describe('runExport (engine end-to-end)', () => {
         // La lectura sale exclusivamente de roots: un root vacío no resuelve nada.
         // Control negativo real: contentRoots() (el fallback al registry instalado)
         // no debe invocarse en absoluto cuando opts.roots viene dado explícitamente.
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
         const registries = require('../../../src/core/registries');
         const spy = jest.spyOn(registries, 'contentRoots');
         const empty = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-empty-root-'));

package/dist/tests/core/export/pack.test.js

@@ -7,7 +7,6 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const pack_1 = require("../../../src/core/export/pack");
-// eslint-disable-next-line @typescript-eslint/no-var-requires
 const childProcess = require('child_process');
 const okZip = (cwd, zipName) => {
     fs_1.default.writeFileSync(path_1.default.join(cwd, zipName), 'fake-zip');

package/dist/tests/structural/lint-covers-typescript.test.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+// #171: the lint gate linted 14 files — all js/mjs — and exited 0 on a
+// TypeScript CLI. `eslint.config.awm.mjs` imports a project config that does
+// not exist, swallows the failure, and its remaining objects declare no
+// `files`, so eslint's default universe (js/mjs/cjs) left every .ts out.
+//
+// The gate was green for months and the `lint` sensor certified on it, which
+// `plan admit --verify-sensors` then consumes as the unattended handoff gate.
+//
+// This asserts on the SET OF FILES LINTED, never on the exit code. An exit-code
+// assertion is exactly what let this survive: a lint that examines nothing
+// exits 0.
+const CLI_ROOT = path_1.default.resolve(__dirname, '../..');
+/** One eslint run for the whole suite. Invoked through node against eslint's own
+ *  js entrypoint rather than `npx`: on Windows `npx` resolves to `npx.cmd`, and
+ *  `execFileSync` cannot execute a `.cmd` without a shell — the exact trap this
+ *  repo already documents in tests/integration/published-doctor-evidence.e2e.test.ts,
+ *  and the one this test hit on both Windows legs of its first CI run. Going
+ *  through `process.execPath` needs no shell, so no argument escaping either. */
+function lint() {
+    const raw = (0, child_process_1.execFileSync)(process.execPath, [
+        path_1.default.join(CLI_ROOT, 'node_modules', 'eslint', 'bin', 'eslint.js'),
+        '.', '--config', 'eslint.config.awm.mjs', '--format', 'json',
+    ], { cwd: CLI_ROOT, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+    return JSON.parse(raw);
+}
+describe('the lint gate covers TypeScript (#171)', () => {
+    jest.setTimeout(10 * 60_000);
+    const results = lint();
+    const files = results.map(entry => entry.filePath);
+    const typescript = files.filter(file => file.endsWith('.ts'));
+    test('lints the TypeScript sources, not only the js/mjs tooling', () => {
+        // A floor, not a lock: adding sources must not fail this.
+        expect(typescript.length).toBeGreaterThan(400);
+        expect(typescript.some(file => file.includes(`${path_1.default.sep}src${path_1.default.sep}`))).toBe(true);
+        expect(typescript.some(file => file.includes(`${path_1.default.sep}tests${path_1.default.sep}`))).toBe(true);
+    });
+    test('lints this very file, so the assertion cannot be vacuous', () => {
+        expect(files).toContain(path_1.default.join(CLI_ROOT, 'tests', 'structural', 'lint-covers-typescript.test.ts'));
+    });
+    test('reports no unresolved rule references', () => {
+        // Four stale `eslint-disable @typescript-eslint/no-var-requires` comments
+        // survived precisely because .ts was never linted: eslint errors on a rule
+        // it cannot resolve, and nobody ever saw it. A new one must fail here
+        // rather than wait for the next person to turn the gate on.
+        const unresolved = results.flatMap(entry => entry.messages.filter(m => /Definition for rule .* was not found/.test(m.message))
+            .map(m => `${entry.filePath}: ${m.message}`));
+        expect(unresolved).toEqual([]);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-workflow-manager",
-  "version": "9.11.1",
+  "version": "9.11.3",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"
@@ -59,6 +59,7 @@
     "@types/js-yaml": "4.0.9",
     "@types/node": "^25.3.0",
     "@types/semver": "^7.7.1",
+    "@typescript-eslint/parser": "^8.70.0",
     "dependency-cruiser": "16.10.4",
     "eslint": "10.8.1",
     "jest": "^30.2.0",