agentic-workflow-manager 9.14.0 → 9.14.1

package/dist/src/core/admission/index.js

@@ -166,7 +166,7 @@ function sanitizeAdmissionReport(report) {
         invalidAdmission();
     if (value.cliCurrentness !== undefined && !CLI_CURRENTNESS.has(value.cliCurrentness))
         invalidAdmission();
-    if (value.sensorEvidence !== undefined && value.sensorEvidence !== 'generation-bound')
+    if (value.sensorEvidence !== undefined && value.sensorEvidence !== 'generation-bound' && value.sensorEvidence !== 'r8-registry-opt-out')
         invalidAdmission();
     if (value.planDigest !== undefined && (typeof value.planDigest !== 'string' || !/^[a-f0-9]{64}$/.test(value.planDigest)))
         invalidAdmission();
@@ -225,12 +225,18 @@ async function admitPlan(input) {
         if (input.compatibilityDiagnostics?.length)
             return blocked(input, input.compatibilityDiagnostics, { planDigest: plan.planDigest, provider, executionMode: mode, currentness: 'unverifiable', cliCurrentness });
     }
+    let sensorsReported = 'not-required';
+    let sensorEvidence = {};
     if (input.verifySensors) {
         if (!input.sensors)
             return blocked(input, [diagnostic('ADMISSION_SENSORS_REQUIRED', 'Sensor evidence was required but not supplied.')], { planDigest: plan.planDigest, provider, executionMode: mode, currentness: input.requireCurrent ? 'current' : 'not-checked', cliCurrentness });
         const sensors = sensorVerdict(input.sensors);
-        if (sensors !== 'pass')
+        const registryOptOut = sensors === 'not-certified' && input.sensorClosurePolicy === 'r8-registry-opt-out' && input.sensors.mode === 'opt-out';
+        if (sensors !== 'pass' && !registryOptOut)
             return blocked(input, [diagnostic('ADMISSION_SENSORS_BLOCKED', `Sensor verdict is ${sensors}.`)], { planDigest: plan.planDigest, provider, executionMode: mode, currentness: input.requireCurrent ? 'current' : 'not-checked', cliCurrentness, sensors });
+        sensorsReported = sensors;
+        if (registryOptOut)
+            sensorEvidence = { sensorEvidence: 'r8-registry-opt-out' };
     }
     if (mode === 'desatendido') {
         // The durable controller (journal + awm watch + jobs) is opt-in, as it
@@ -241,7 +247,7 @@ async function admitPlan(input) {
         const observed = journalStatus(input, plan);
         const journal = observed === 'missing' && plan.schema === 'compact-slices/v1' ? 'not-required' : observed;
         if (journal !== 'current' && journal !== 'not-required')
-            return blocked(input, [diagnostic('ADMISSION_JOURNAL_BINDING_REQUIRED', 'Unattended execution requires a healthy schema-2 journal binding for this exact plan; run watch --init --plan.')], { planDigest: plan.planDigest, provider, executionMode: mode, journal, currentness: input.requireCurrent ? 'current' : 'not-checked', cliCurrentness, sensors: input.verifySensors ? 'pass' : 'not-required' });
+            return blocked(input, [diagnostic('ADMISSION_JOURNAL_BINDING_REQUIRED', 'Unattended execution requires a healthy schema-2 journal binding for this exact plan; run watch --init --plan.')], { planDigest: plan.planDigest, provider, executionMode: mode, journal, currentness: input.requireCurrent ? 'current' : 'not-checked', cliCurrentness, sensors: sensorsReported, ...sensorEvidence });
         const capabilities = unattendedCapabilities(provider, input.controllerAutonomy);
         const resolution = { outcome: capabilities.unattendedController === 'supported' ? 'native' : 'blocked', provider, capabilities, evidenceVersion: 'r1-v1', diagnostics: [] };
         if (resolution.outcome === 'blocked') {
@@ -252,17 +258,17 @@ async function admitPlan(input) {
             const reason = exports.PROVIDER_EXECUTION_CAPABILITIES[provider].unattendedController !== 'supported'
                 ? diagnostic('ADMISSION_CAPABILITY_UNVERIFIED', `Provider ${provider} has no verified unattended execution capability.`)
                 : diagnostic('ADMISSION_CONTROLLER_AUTONOMY_REQUIRED', `Unattended dispatch on ${provider} requires an explicit controller autonomy posture; without it the controller blocks on its first tool call.`);
-            return blocked(input, [reason], { planDigest: plan.planDigest, provider, executionMode: mode, journal, currentness: input.requireCurrent ? 'current' : 'not-checked', cliCurrentness, sensors: input.verifySensors ? 'pass' : 'not-required', capabilityResolution: resolution });
+            return blocked(input, [reason], { planDigest: plan.planDigest, provider, executionMode: mode, journal, currentness: input.requireCurrent ? 'current' : 'not-checked', cliCurrentness, sensors: sensorsReported, ...sensorEvidence, capabilityResolution: resolution });
         }
         const routing = plan.schema === 'compact-slices/v2' ? input.routing ?? await input.routingReader?.() : input.routing;
-        return completeAdmission({ ...input, routing, routingReader: undefined }, plan, provider, mode, journal, input.requireCurrent ? 'current' : 'not-checked', input.verifySensors ? 'pass' : 'not-required', resolution, cliCurrentness);
+        return { ...completeAdmission({ ...input, routing, routingReader: undefined }, plan, provider, mode, journal, input.requireCurrent ? 'current' : 'not-checked', sensorsReported, resolution, cliCurrentness), ...sensorEvidence };
     }
     const capabilities = exports.PROVIDER_EXECUTION_CAPABILITIES[provider];
     const resolution = { outcome: capabilities.interactiveExecution === 'supported' ? 'native' : 'blocked', provider, capabilities, evidenceVersion: 'r1-v1', diagnostics: [] };
     if (resolution.outcome === 'blocked')
         return blocked(input, [diagnostic('ADMISSION_CAPABILITY_UNVERIFIED', `Provider ${provider} has no verified interactive execution capability.`)], { planDigest: plan.planDigest, provider, executionMode: mode, capabilityResolution: resolution });
     const routing = plan.schema === 'compact-slices/v2' ? input.routing ?? await input.routingReader?.() : input.routing;
-    return completeAdmission({ ...input, routing, routingReader: undefined }, plan, provider, mode, 'not-required', input.requireCurrent ? 'current' : 'not-checked', input.verifySensors ? 'pass' : 'not-required', resolution, cliCurrentness);
+    return { ...completeAdmission({ ...input, routing, routingReader: undefined }, plan, provider, mode, 'not-required', input.requireCurrent ? 'current' : 'not-checked', sensorsReported, resolution, cliCurrentness), ...sensorEvidence };
 }
 function completeAdmission(input, plan, provider, executionMode, journal, currentness, sensors, capabilityResolution, cliCurrentness = 'not-checked') {
     if (plan.schema === 'compact-slices/v1')

package/dist/src/core/admission/registry-contracts.js

@@ -271,6 +271,17 @@ function hasOwnedGenerationAdmission(input) {
         || (generation.wrapperRef !== undefined && generation.wrapperRef.spawnNonce === generation.spawnNonce
             && (0, process_1.refIsAlive)(generation.wrapperRef));
 }
+/** R8: only a content registry (its manifest at the sensor project root) may close on a deliberate opt-out. */
+function registryOptOutPolicy(sensors) {
+    if (sensors?.mode !== 'opt-out' || !sensors.projectRoot)
+        return undefined;
+    try {
+        return fs_1.default.statSync(path_1.default.join(sensors.projectRoot, registries_1.REGISTRY_MANIFEST_NAME)).isFile() ? 'r8-registry-opt-out' : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** One admission authority for the public command AND actual watch dispatch.
  * No empirical execution occurs before provenance/currentness/CLI-floor gates. */
 async function admitRegistryPlan(input, dependencies = {}) {
@@ -308,8 +319,9 @@ async function admitRegistryPlan(input, dependencies = {}) {
         return scope.provenance === 'proven';
     };
     let generationBound = false;
+    let sensorClosurePolicy;
     const compose = async (fields) => {
-        const report = await admission({ ...input, provenance: scope.provenance, consumedRegistryComponents: scope.consumedRegistryComponents, ...fields });
+        const report = await admission({ ...input, provenance: scope.provenance, consumedRegistryComponents: scope.consumedRegistryComponents, ...(sensorClosurePolicy ? { sensorClosurePolicy } : {}), ...fields });
         const withEvidence = generationBound && report.sensors === 'pass' ? { ...report, sensorEvidence: 'generation-bound' } : report;
         if (scope.provenanceDiagnostic && report.diagnostics.some(diagnostic => diagnostic.code === 'ADMISSION_CURRENTNESS_PROVENANCE_REQUIRED')) {
             return { ...withEvidence, diagnostics: report.diagnostics.map(diagnostic => diagnostic.code === 'ADMISSION_CURRENTNESS_PROVENANCE_REQUIRED' ? scope.provenanceDiagnostic : diagnostic) };
@@ -337,6 +349,7 @@ async function admitRegistryPlan(input, dependencies = {}) {
     const sensors = input.verifySensors ? input.sensors ?? (generationBound
         ? { sensors: [], overall: 'pass', reason: 'generation-bound-admission' }
         : await (dependencies.runSensors ?? run_1.runSensors)({ cwd: input.cwd, all: true, readOnly: true })) : undefined;
+    sensorClosurePolicy = registryOptOutPolicy(sensors);
     if (input.requireCurrent && input.verifySensors) {
         if (!refresh())
             return compose({ currentness, sensors });

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

@@ -309,6 +309,32 @@ describe('plan admit Commander wiring', () => {
             process.exitCode = undefined;
         }
     });
+    it.each([
+        ['a content registry', true, 'admitted'],
+        ['an ordinary project', false, 'blocked'],
+    ])('applies the R8 sensor opt-out exception only to %s', async (_name, isRegistry, expected) => {
+        const root = fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-admit-r8-')));
+        const output = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        if (isRegistry)
+            fs_1.default.writeFileSync(path_1.default.join(root, 'awm-registry.json'), JSON.stringify({ minCliVersion: '1.0.0' }));
+        const sensors = jest.fn().mockResolvedValue({ overall: 'not_certified', sensors: [], mode: 'opt-out', reason: 'opt-out-declared', projectRoot: root, manifestPath: path_1.default.join(root, '.awm', 'sensors.json') });
+        const program = new commander_1.Command();
+        (0, plan_1.registerPlanCommand)(program, { validatePlanFile: () => valid, listRegistries: () => [], readPreferences: () => ({ defaultAgent: 'codex', enabledAgents: ['codex'], installMethod: 'symlink', defaultScope: 'local' }), runSensors: sensors });
+        try {
+            await program.parseAsync(['node', 'awm', 'plan', 'admit', 'plan.md', '--provider', 'codex', '--cwd', root, '--execution-mode', 'interactivo', '--verify-sensors', '--json']);
+            const report = JSON.parse(String(output.mock.calls.at(-1)[0]));
+            expect(report).toMatchObject({ state: expected, sensors: 'not-certified' });
+            if (isRegistry)
+                expect(report.sensorEvidence).toBe('r8-registry-opt-out');
+            else
+                expect(report.diagnostics[0].code).toBe('ADMISSION_SENSORS_BLOCKED');
+        }
+        finally {
+            output.mockRestore();
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+            process.exitCode = undefined;
+        }
+    });
     it('derives desatendido from the canonical plan header; a native v1 plan needs no journal (opt-in durable custody)', async () => {
         const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-admit-header-'));
         const output = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);

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

@@ -161,21 +161,30 @@ describe('runCommand — exit codes and output', () => {
     });
     itLinux('never lets a structured capture file grow beyond maxBuffer', async () => {
         const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-exec-cap-'));
-        const marker = path_1.default.join(dir, 'written');
-        const existing = new Set(fs_1.default.readdirSync(os_1.default.tmpdir()).filter(name => name.startsWith('awm-sensor-output-')));
+        // The overflow watcher kills the child and deletes the capture as soon as
+        // the cap is reached, so polling for the file races that cleanup. Capture
+        // files only grow, so their size at deletion is the largest they ever were.
+        const captureSizes = [];
+        const rmSync = fs_1.default.rmSync.bind(fs_1.default);
+        const removal = jest.spyOn(fs_1.default, 'rmSync').mockImplementation((target, options) => {
+            if (typeof target === 'string' && path_1.default.basename(target).startsWith('awm-sensor-output-')) {
+                captureSizes.push(fs_1.default.statSync(path_1.default.join(target, 'stdout')).size);
+            }
+            return rmSync(target, options);
+        });
         try {
-            const result = (0, exec_1.runStructuredCommand)({
+            const result = await (0, exec_1.runStructuredCommand)({
                 executable: 'node',
                 resolution: 'path',
-                args: ['-e', `const fs = require('fs'); try { fs.writeSync(1, Buffer.alloc(8192, 'x')); } catch {} fs.writeFileSync(${JSON.stringify(marker)}, 'written'); setTimeout(() => {}, 1000);`],
+                args: ['-e', `const fs = require('fs'); try { fs.writeSync(1, Buffer.alloc(8192, 'x')); } catch {} setTimeout(() => {}, 1000);`],
             }, { timeout: 5_000, cwd: dir, maxBuffer: 1_024 });
-            expect(await until(() => fs_1.default.existsSync(marker))).toBe(true);
-            const capture = fs_1.default.readdirSync(os_1.default.tmpdir()).find(name => name.startsWith('awm-sensor-output-') && !existing.has(name));
-            expect(capture).toBeDefined();
-            expect(fs_1.default.statSync(path_1.default.join(os_1.default.tmpdir(), capture, 'stdout')).size).toBeLessThanOrEqual(1_024);
-            await expect(result).resolves.toMatchObject({ overflowed: true });
+            expect(result).toMatchObject({ overflowed: true });
+            expect(captureSizes).toHaveLength(1);
+            expect(captureSizes[0]).toBeGreaterThan(0);
+            expect(captureSizes[0]).toBeLessThanOrEqual(1_024);
         }
         finally {
+            removal.mockRestore();
             fs_1.default.rmSync(dir, { recursive: true, force: true });
         }
     });

package/dist/tests/core/admission/index.test.js

@@ -178,6 +178,45 @@ describe('admitPlan', () => {
             expect(report.diagnostics[0]).toMatchObject({ code: 'ADMISSION_CONTROLLER_AUTONOMY_REQUIRED' });
         });
     });
+    // R8: a content registry whose sensors are ALL deliberately disabled may close
+    // work; its release proof lives in CI. The local verdict stays not-certified —
+    // never reported as pass — and the exception is named in the evidence.
+    describe('the R8 registry opt-out closure exception', () => {
+        const optOut = { overall: 'not_certified', sensors: [], mode: 'opt-out', reason: 'opt-out-declared', projectRoot: '/r', manifestPath: '/r/.awm/sensors.json' };
+        const unattended = () => ({ ...valid, manifest: { ...valid.manifest, executionMode: 'desatendido' } });
+        const base = () => ({ plan: valid, provider: 'codex', cwd: process.cwd(), enabledAgents: ['codex'], verifySensors: true, sensors: optOut, sensorClosurePolicy: 'r8-registry-opt-out' });
+        it('admits interactive work without reporting the opt-out as a pass', async () => {
+            const report = await (0, admission_1.admitPlan)(base());
+            expect(report).toMatchObject({ state: 'admitted', sensors: 'not-certified', sensorEvidence: 'r8-registry-opt-out' });
+        });
+        it('admits journal-less unattended work under the same exception', async () => {
+            const report = await (0, admission_1.admitPlan)({ ...base(), plan: unattended(), planPath: 'docs/plan.md', controllerAutonomy: 'approval-free' });
+            expect(report).toMatchObject({ state: 'admitted', executionMode: 'desatendido', journal: 'not-required', sensors: 'not-certified', sensorEvidence: 'r8-registry-opt-out' });
+        });
+        it('reports the preserved verdict when a later gate blocks', async () => {
+            const report = await (0, admission_1.admitPlan)({ ...base(), plan: unattended(), planPath: 'docs/plan.md' });
+            expect(report).toMatchObject({ state: 'blocked', sensors: 'not-certified', sensorEvidence: 'r8-registry-opt-out' });
+            expect(report.diagnostics[0]).toMatchObject({ code: 'ADMISSION_CONTROLLER_AUTONOMY_REQUIRED' });
+        });
+        it.each([
+            ['no declared policy', { sensorClosurePolicy: undefined }],
+            ['a failing sensor', { sensors: { ...optOut, overall: 'fail', mode: 'project-sensors' } }],
+            ['an absent manifest', { sensors: { ...optOut, mode: 'missing', reason: 'manifest-absent' } }],
+            ['a native gate', { sensors: { ...optOut, mode: 'native-gate', reason: 'native-gate-declared' } }],
+            ['an unavailable sensor source', { sensors: { ...optOut, mode: 'source-unavailable' } }],
+            ['all-disabled legacy sensors', { sensors: { ...optOut, overall: 'skipped', mode: 'project-sensors' } }],
+        ])('keeps blocking with %s', async (_name, fields) => {
+            const report = await (0, admission_1.admitPlan)({ ...base(), ...fields });
+            expect(report.state).toBe('blocked');
+            expect(report.diagnostics[0]).toMatchObject({ code: 'ADMISSION_SENSORS_BLOCKED' });
+            expect(report.sensorEvidence).toBeUndefined();
+        });
+        it('accepts only the known sensor evidence values at the public sanitizer', () => {
+            const report = { state: 'admitted', planState: 'valid', journal: 'not-required', currentness: 'not-checked', sensors: 'not-certified', diagnostics: [] };
+            expect((0, admission_1.sanitizeAdmissionReport)({ ...report, sensorEvidence: 'r8-registry-opt-out' }).sensorEvidence).toBe('r8-registry-opt-out');
+            expect(() => (0, admission_1.sanitizeAdmissionReport)({ ...report, sensorEvidence: 'opt-out' })).toThrow('invalid report');
+        });
+    });
     it('admits unattended work only with an exact schema-2 plan binding', async () => {
         const unattended = { ...valid, manifest: { ...valid.manifest, executionMode: 'desatendido' } };
         const journal = { ...(0, types_1.emptyState)('main'), schema: 2, planBinding: { path: 'docs/plan.md', digest: 'a'.repeat(64), schema: 'compact-slices/v1', executionMode: 'desatendido', boundAt: '2026-09-15T00:00:00.000Z' } };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-workflow-manager",
-  "version": "9.14.0",
+  "version": "9.14.1",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"
@@ -65,7 +65,7 @@
     "dependency-cruiser": "16.10.4",
     "eslint": "10.8.1",
     "jest": "^30.2.0",
-    "node-gyp": "^11.5.0",
+    "node-gyp": "^12.4.0",
     "ts-jest": "^29.4.6",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"