agentic-workflow-manager 9.16.1 → 9.18.0

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

@@ -14,6 +14,7 @@ const resolve_1 = require("./compatibility/resolve");
 const project_1 = require("./project");
 const source_1 = require("./compatibility/source");
 const registries_1 = require("../../core/registries");
+const manifest_1 = require("./compatibility/manifest");
 /** First non-flag token after `npx` — the tool the command actually runs. */
 function npxTool(parts) {
     for (let i = 1; i < parts.length; i++) {
@@ -197,6 +198,90 @@ function invalidStatus(project, pack, reason = 'manifest-malformed', remedy = 'r
         ...projectMetadata(project, 'invalid', reason, { remedy }),
     };
 }
+function hasSelectedPack(manifest) {
+    return typeof manifest.pack === 'string' && manifest.pack.length > 0;
+}
+function projectSensorCheck(sensor, cwd) {
+    if (sensor.enabled === false) {
+        return { ok: true, detail: 'disabled (project-declared)', certification: 'project-declared' };
+    }
+    const check = checkStructuredCommand(sensor.command, cwd, sensor.assets);
+    return {
+        ok: check.ok,
+        detail: check.ok ? `project-declared: ${check.detail}` : `${check.detail} (project-declared)`,
+        certification: 'project-declared',
+    };
+}
+function packBoundOnly(manifest) {
+    const sensors = Object.fromEntries(Object.entries(manifest.sensors).filter(([, sensor]) => !(0, manifest_1.isProjectDeclaredSensor)(sensor)));
+    const pack = 'pack' in manifest && typeof manifest.pack === 'string' ? manifest.pack : '';
+    return { schemaVersion: 2, pack, sensors };
+}
+/** Live pack sensor ids, or null when the pack cannot be resolved (fail closed). */
+function livePackSensorIds(source) {
+    try {
+        const parsed = (0, contract_1.parseSensorPack)(JSON.parse(source.content), source.path);
+        if (parsed.kind !== 'v2')
+            return null;
+        return new Set(Object.keys(parsed.pack.sensors));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * RF-1.7 status: never label a colliding project id as project-declared READY.
+ * When pack is selected and live is unavailable, fail closed rather than claiming
+ * the project override is safe.
+ */
+function projectDeclaredOrCollisionCheck(name, sensor, packageRoot, packSelected, liveIds) {
+    if (packSelected && (liveIds === null || liveIds.has(name))) {
+        return {
+            ok: false,
+            detail: liveIds === null
+                ? `project-sensor-name-collision: ${name} (live pack unavailable)`
+                : `project-sensor-name-collision: ${name}; pack sensor kept`,
+        };
+    }
+    return projectSensorCheck(sensor, packageRoot);
+}
+/** Soft-isolate valid siblings into checks while authority remains invalid (RF soft-parse). */
+function softIsolatedChecks(project) {
+    const recovered = (0, project_1.softRecoverInvalidProject)(project);
+    if (!recovered)
+        return {};
+    const checks = {};
+    const v3Project = recovered.manifest.kind === 'v3' && recovered.manifest.pack.mode === 'project-sensors'
+        ? recovered.manifest.pack
+        : null;
+    const sensors = v3Project?.sensors ?? {};
+    // RF-1.7: same collision path as configured status — live pack probe when pack is selected.
+    const packSelected = v3Project !== null && hasSelectedPack(v3Project);
+    let liveIds = null;
+    if (packSelected) {
+        try {
+            const resolution = (0, source_1.resolveSensorSource)(recovered.manifest, { registries: (0, registries_1.listRegistries)() });
+            liveIds = 'source' in resolution ? livePackSensorIds(resolution.source) : null;
+        }
+        catch {
+            liveIds = null;
+        }
+    }
+    for (const [name, sensor] of Object.entries(sensors)) {
+        if ((0, manifest_1.isProjectDeclaredSensor)(sensor)) {
+            checks[name] = projectDeclaredOrCollisionCheck(name, sensor, recovered.packageRoot, packSelected, liveIds);
+            continue;
+        }
+        const packSensor = sensor;
+        checks[name] = packSensor.enabled === false
+            ? { ok: true, detail: 'disabled' }
+            : checkStructuredCommand(packSensor.command, recovered.packageRoot, packSensor.assets);
+    }
+    for (const entry of recovered.invalidEntries) {
+        checks[entry.name] = { ok: false, detail: entry.reason };
+    }
+    return checks;
+}
 async function computeSensorStatus(cwd = process.cwd()) {
     let project;
     try {
@@ -211,15 +296,40 @@ async function computeSensorStatus(cwd = process.cwd()) {
     }
     if (project.state === 'invalid') {
         let pack = null;
+        let reason = 'manifest-malformed';
+        let remedy = 'repair-sensor-manifest';
         try {
-            const raw = JSON.parse(fs_1.default.readFileSync(project.manifestPath, 'utf-8'));
-            if (raw && typeof raw === 'object' && !Array.isArray(raw) && !('schemaVersion' in raw) && typeof raw.pack === 'string') {
-                pack = raw.pack;
+            const text = fs_1.default.readFileSync(project.manifestPath, 'utf-8');
+            try {
+                const raw = JSON.parse(text);
+                if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+                    const record = raw;
+                    if (!('schemaVersion' in record) && typeof record.pack === 'string')
+                        pack = record.pack;
+                    else if (typeof record.pack === 'string')
+                        pack = record.pack;
+                }
+                // JSON.parse succeeded — this is schema invalidity, not "not valid JSON" (RF-4.1).
+                if (project.reason.includes('unsupported manifest schemaVersion')) {
+                    reason = 'schema-unsupported';
+                }
+                else {
+                    reason = `schema-invalid: ${project.reason}`;
+                    // Project-entry schema failures must not lead with `awm sensors init` (RF-3.3).
+                    remedy = 'repair-the-invalid-sensor-entry-in-sensors-json';
+                }
+            }
+            catch {
+                reason = 'manifest-malformed';
             }
         }
-        catch { /* malformed JSON is not configured */ }
-        const reason = project.reason.includes('unsupported manifest schemaVersion') ? 'schema-unsupported' : 'manifest-malformed';
-        return invalidStatus(project, pack, reason);
+        catch { /* unreadable manifest stays malformed */ }
+        // Soft-isolate valid siblings into checks (same WithIssues path as run) while
+        // keeping mode=invalid so preflight RF-4.1 still sees schema-invalid authority.
+        return {
+            ...invalidStatus(project, pack, reason, remedy),
+            checks: softIsolatedChecks(project),
+        };
     }
     const packageRoot = project.packageRoot;
     const parsed = project.manifest;
@@ -229,38 +339,73 @@ async function computeSensorStatus(cwd = process.cwd()) {
             ...projectMetadata(project, parsed.pack.mode, `${parsed.pack.mode}-declared`, { declarationReason: parsed.pack.reason }),
         };
     }
+    if (parsed.kind === 'v3' && parsed.pack.mode === 'project-sensors' && !hasSelectedPack(parsed.pack)) {
+        // Only-project: no pack source to resolve. Report each project sensor with
+        // project-declared provenance rather than an empty Pack:none DEGRADED (RF-2.8).
+        const checks = {};
+        for (const [name, sensor] of Object.entries(parsed.pack.sensors)) {
+            if ((0, manifest_1.isProjectDeclaredSensor)(sensor)) {
+                checks[name] = projectSensorCheck(sensor, packageRoot);
+            }
+            else {
+                checks[name] = { ok: false, detail: 'pack-bound sensor requires a nonempty pack' };
+            }
+        }
+        return {
+            overall: Object.keys(checks).length > 0 && Object.values(checks).every(check => check.ok) ? 'READY' : 'DEGRADED',
+            pack: null,
+            checks,
+            ...projectMetadata(project, 'project-sensors', 'project-declared-only'),
+        };
+    }
     if (parsed.kind === 'v2' || parsed.kind === 'v3') {
         const parsedPack = parsed.pack;
+        const packId = typeof parsedPack.pack === 'string' ? parsedPack.pack : null;
+        const packSelected = typeof parsedPack.pack === 'string' && parsedPack.pack.length > 0;
         let resolution;
         try {
             resolution = (0, source_1.resolveSensorSource)(parsed, { registries: (0, registries_1.listRegistries)() });
         }
         catch {
-            return invalidStatus(project, parsedPack.pack, 'sensor-source-invalid', 'repair-or-run-awm-update');
+            return invalidStatus(project, packId, 'sensor-source-invalid', 'repair-or-run-awm-update');
         }
         if (!('source' in resolution))
-            return sourceFailure(project, parsedPack.pack, resolution);
+            return sourceFailure(project, packId ?? 'unknown', resolution);
         const sourceMeta = resolvedSourceMetadata(resolution);
-        const manifest = parsedPack;
+        const liveIds = livePackSensorIds(resolution.source);
+        const packManifest = packBoundOnly(parsedPack);
         const checks = {};
         let compatibility;
         try {
-            compatibility = resolveStaticV2Compatibility(packageRoot, manifest, resolution.source);
+            compatibility = resolveStaticV2Compatibility(packageRoot, packManifest, resolution.source);
         }
         catch (error) {
             const detail = error instanceof Error ? error.message : 'live compatibility unavailable';
-            for (const [name, sensor] of Object.entries(manifest.sensors))
-                checks[name] = sensor.enabled === false ? { ok: true, detail: 'disabled' } : { ok: false, detail };
-            return { overall: 'DEGRADED', pack: manifest.pack, checks, ...projectMetadata(project, 'project-sensors', sourceMeta.reason, { ...sourceMeta }) };
+            for (const [name, sensor] of Object.entries(parsedPack.sensors)) {
+                if ((0, manifest_1.isProjectDeclaredSensor)(sensor)) {
+                    checks[name] = projectDeclaredOrCollisionCheck(name, sensor, packageRoot, packSelected, liveIds);
+                }
+                else {
+                    checks[name] = sensor.enabled === false
+                        ? { ok: true, detail: 'disabled' }
+                        : { ok: false, detail };
+                }
+            }
+            return { overall: 'DEGRADED', pack: packId, checks, ...projectMetadata(project, 'project-sensors', sourceMeta.reason, { ...sourceMeta }) };
         }
-        for (const [name, sensor] of Object.entries(manifest.sensors)) {
-            checks[name] = sensor.enabled === false ? { ok: true, detail: 'disabled' }
-                : staticCompatibilityCheck(sensor, compatibility[name]) ?? checkStructuredCommand(sensor.command, packageRoot, sensor.assets);
+        for (const [name, sensor] of Object.entries(parsedPack.sensors)) {
+            if ((0, manifest_1.isProjectDeclaredSensor)(sensor)) {
+                checks[name] = projectDeclaredOrCollisionCheck(name, sensor, packageRoot, packSelected, liveIds);
+                continue;
+            }
+            const packSensor = sensor;
+            checks[name] = packSensor.enabled === false ? { ok: true, detail: 'disabled' }
+                : staticCompatibilityCheck(packSensor, compatibility[name]) ?? checkStructuredCommand(packSensor.command, packageRoot, packSensor.assets);
         }
-        const uninitialized = uninitializedSensors(manifest, compatibility);
+        const uninitialized = uninitializedSensors(packManifest, compatibility);
         return {
             overall: Object.keys(checks).length > 0 && Object.values(checks).every(check => check.ok) ? 'READY' : 'DEGRADED',
-            pack: manifest.pack, checks,
+            pack: packId, checks,
             ...(uninitialized ? { uninitialized } : {}),
             ...projectMetadata(project, 'project-sensors', sourceMeta.reason, { ...sourceMeta }),
         };

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

@@ -160,6 +160,9 @@ function registerWatchCommand(program) {
         }
         else {
             process.stdout.write(`awm watch: ${outcome === 'stopped' ? 'detenido' : 'track congelado'}; ciclo ${final.cycleState ?? final.state} — sin certificacion de cierre\n`);
+            // exitCode only — never process.exit here: in-process tests call parseAsync
+            // inside Jest; a hard exit kills the worker (CI exit 130 on every OS).
+            // exitCode=130 is intentional Darwin CI flake harden (reopened-196), not operator-environments scope.
             if (outcome === 'stopped')
                 process.exitCode = 130;
             else if (outcome === 'complete' || final.state !== 'present')

package/dist/src/core/environments/resolve.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTEXT_INJECT_MAX_CHARS = void 0;
+exports.statusFor = statusFor;
+exports.buildInjection = buildInjection;
+/** Fixed budget for `inject: context` fresh values (RF-3.2). */
+exports.CONTEXT_INJECT_MAX_CHARS = 2048;
+function assertValidNow(now) {
+    if (!(now instanceof Date) || !Number.isFinite(now.getTime())) {
+        throw new Error('now must be a Date with a finite getTime()');
+    }
+}
+function effectiveStatus(definitionDurability, stored, now) {
+    if (!stored)
+        return 'missing';
+    if (stored.status === 'missing')
+        return 'missing';
+    if (stored.status === 'stale')
+        return 'stale';
+    // Durable never time-stales (RF-2.3).
+    if (definitionDurability === 'durable') {
+        return stored.status === 'fresh' ? 'fresh' : stored.status;
+    }
+    // Volatile: fail closed — missing/invalid expiresAt or now >= expiresAt → stale (RF-2.4).
+    if (typeof stored.expiresAt !== 'string' || stored.expiresAt.trim() === '') {
+        return 'stale';
+    }
+    const expiresMs = Date.parse(stored.expiresAt);
+    if (!Number.isFinite(expiresMs) || now.getTime() >= expiresMs) {
+        return 'stale';
+    }
+    return stored.status === 'fresh' ? 'fresh' : stored.status;
+}
+/**
+ * Per-catalog-id status against the store. Missing → `missing` with no default (RF-2.5).
+ */
+function statusFor(catalog, store, now = new Date()) {
+    if (!catalog || typeof catalog !== 'object' || !catalog.facts) {
+        throw new Error('statusFor: catalog with facts is required');
+    }
+    if (!store || typeof store !== 'object') {
+        throw new Error('statusFor: store must be an object');
+    }
+    assertValidNow(now);
+    const out = {};
+    for (const [id, def] of Object.entries(catalog.facts)) {
+        out[id] = effectiveStatus(def.durability, store[id], now);
+    }
+    return out;
+}
+/**
+ * Build injection payload. Default / explicit `reference` exposes path + ids only (RF-3.1).
+ * `context` includes fresh `inject: context` values under budget; overflow degrades (RF-3.2).
+ */
+function buildInjection(opts) {
+    if (!opts || typeof opts !== 'object') {
+        throw new Error('buildInjection: options object is required');
+    }
+    if (!opts.catalog?.facts) {
+        throw new Error('buildInjection: catalog with facts is required');
+    }
+    if (typeof opts.storePath !== 'string' || opts.storePath.trim() === '') {
+        throw new Error('buildInjection: storePath must be a non-empty string');
+    }
+    if (!opts.store || typeof opts.store !== 'object') {
+        throw new Error('buildInjection: store must be an object');
+    }
+    const rawInject = opts.inject ?? 'reference';
+    // Unknown/typo must not fall through into context (fail-open). Prefer reference (RNF-2).
+    const inject = rawInject === 'reference' || rawInject === 'context' ? rawInject : 'reference';
+    const maxChars = opts.maxChars ?? exports.CONTEXT_INJECT_MAX_CHARS;
+    if (typeof maxChars !== 'number' || !Number.isFinite(maxChars) || maxChars < 0) {
+        throw new Error('buildInjection: maxChars must be a non-negative finite number');
+    }
+    const now = opts.now ?? new Date();
+    assertValidNow(now);
+    if (opts.factIds !== undefined) {
+        if (!Array.isArray(opts.factIds) || opts.factIds.some((id) => typeof id !== 'string' || id === '')) {
+            throw new Error('buildInjection: factIds must be an array of non-empty strings');
+        }
+    }
+    const factIds = opts.factIds ?? Object.keys(opts.catalog.facts);
+    const statuses = statusFor(opts.catalog, opts.store, now);
+    const referenceResult = () => ({
+        mode: 'reference',
+        storePath: opts.storePath,
+        factIds: [...factIds],
+    });
+    if (inject !== 'context') {
+        return referenceResult();
+    }
+    // Context mode: only fresh values whose catalog inject is `context` (RF-3.2).
+    const contextValues = {};
+    let totalChars = 0;
+    for (const id of factIds) {
+        const def = opts.catalog.facts[id];
+        if (!def || def.inject !== 'context')
+            continue;
+        if (statuses[id] !== 'fresh')
+            continue;
+        const stored = opts.store[id];
+        if (!stored || typeof stored.value !== 'string')
+            continue;
+        totalChars += stored.value.length;
+        contextValues[id] = stored.value;
+    }
+    if (Object.keys(contextValues).length === 0) {
+        return referenceResult();
+    }
+    if (totalChars > maxChars) {
+        return {
+            ...referenceResult(),
+            warning: `Context inject budget exceeded (${totalChars} > ${maxChars} chars); degraded to reference`,
+        };
+    }
+    return {
+        mode: 'context',
+        storePath: opts.storePath,
+        factIds: [...factIds],
+        values: contextValues,
+    };
+}