agentic-workflow-manager 9.15.0 → 9.15.1

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

@@ -13,6 +13,7 @@ const capabilities_1 = require("../../core/model-policy/capabilities");
 const adapter_1 = require("../../core/journal/adapter");
 const process_1 = require("../../core/journal/process");
 const adapter_2 = require("../../core/journal/adapter");
+const durable_custody_1 = require("../../core/journal/durable-custody");
 const context_1 = require("../../core/tracks/context");
 const concurrency_1 = require("../../core/tracks/concurrency");
 const validate_1 = require("../../core/plan/validate");
@@ -20,6 +21,12 @@ const path_1 = __importDefault(require("path"));
 const archive_unused_1 = require("./archive-unused");
 const store_1 = require("../../core/journal/store");
 const fingerprint_1 = require("../../core/journal/fingerprint");
+function refuseIfDurableCustodySuspended() {
+    if (!(0, durable_custody_1.isDurableCustodySuspended)())
+        return;
+    process.stderr.write(`${durable_custody_1.DURABLE_CUSTODY_SUSPENDED_MESSAGE}\n`);
+    process.exit(1);
+}
 function currentBranch(cwd) {
     // stdio explicito (ver EXEC_STDIO en journal/process.ts): evita el relay
     // default de execFileSync del stderr de git hacia el stderr del llamante,
@@ -61,6 +68,9 @@ function registerWatchCommand(program) {
         // #168: sin esto el controller desatendido arranca y se cuelga en la
         // primera herramienta pidiendo aprobación. Se declara, no se adivina.
         .option('--controller-autonomy <postura>', `postura del controller desatendido (${adapter_1.CONTROLLER_AUTONOMIES.join(' | ')})`)
+        // Fail-closed for every watch verb (parent + subcommands) while durable
+        // custody is suspended. Help still works; only actions are refused.
+        .hook('preAction', () => { refuseIfDurableCustodySuspended(); })
         .action(async (opts) => {
         const repo = process.cwd();
         const branch = currentBranch(repo);

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

@@ -6,6 +6,7 @@ exports.sanitizeAdmissionReport = sanitizeAdmissionReport;
 exports.admitPlan = admitPlan;
 const providers_1 = require("../../providers");
 const paths_1 = require("../journal/paths");
+const durable_custody_1 = require("../journal/durable-custody");
 const resolve_1 = require("../model-policy/resolve");
 const capabilities_1 = require("../model-policy/capabilities");
 const UNKNOWN = {
@@ -242,10 +243,14 @@ async function admitPlan(input) {
         // The durable controller (journal + awm watch + jobs) is opt-in, as it
         // was before 9.8.0: native v1 dispatch with no journal on its branch
         // runs as one provider session. Creating a journal is the opt-in, and
-        // from then on it must be current. v2 routing custody lives in the
-        // journal, so awm-routed work still requires it.
+        // from then on it must be current. While durable custody is suspended
+        // (see durable-custody.ts), leftover journals must not trap native v1
+        // unattended work. v2 routing custody lives in the journal, so
+        // awm-routed work still requires it when that path is active.
         const observed = journalStatus(input, plan);
-        const journal = observed === 'missing' && plan.schema === 'compact-slices/v1' ? 'not-required' : observed;
+        const journal = plan.schema === 'compact-slices/v1' && (observed === 'missing' || (0, durable_custody_1.isDurableCustodySuspended)())
+            ? '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: sensorsReported, ...sensorEvidence });
         const capabilities = unattendedCapabilities(provider, input.controllerAutonomy);

package/dist/src/core/journal/durable-custody.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Durable custody = `awm watch` + journal-bound supervisor/controller relaunch.
+ *
+ * Suspended for every provider until routing/custody work resumes. The supported
+ * unattended path is the native provider session (compact-slices/v1, no journal).
+ *
+ * The Jest suite sets `AWM_ALLOW_DURABLE_CUSTODY=1` so the machinery stays tested
+ * for when this suspension is lifted. Operators never set that variable.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DURABLE_CUSTODY_SUSPENDED_MESSAGE = void 0;
+exports.isDurableCustodySuspended = isDurableCustodySuspended;
+exports.DURABLE_CUSTODY_SUSPENDED_MESSAGE = 'Durable custody (awm watch) is suspended for all providers until routing/custody work resumes. '
+    + 'Use native provider-session unattended (compact-slices/v1, no journal).';
+/** True for operators; false only when tests explicitly re-enable the machinery. */
+function isDurableCustodySuspended() {
+    return process.env.AWM_ALLOW_DURABLE_CUSTODY !== '1';
+}

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

@@ -177,6 +177,25 @@ describe('admitPlan', () => {
             expect(report.state).toBe('blocked');
             expect(report.diagnostics[0]).toMatchObject({ code: 'ADMISSION_CONTROLLER_AUTONOMY_REQUIRED' });
         });
+        // While Camino B is suspended, a leftover journal on the branch must not
+        // trap native v1 unattended admission. Jest sets AWM_ALLOW_DURABLE_CUSTODY=1
+        // for the rest of the suite; this case restores the operator default.
+        it('ignores leftover journals for native v1 while durable custody is suspended', async () => {
+            const previous = process.env.AWM_ALLOW_DURABLE_CUSTODY;
+            delete process.env.AWM_ALLOW_DURABLE_CUSTODY;
+            try {
+                const corrupt = await (0, admission_1.admitPlan)({ ...base(), journalCorrupt: true });
+                expect(corrupt).toMatchObject({ state: 'admitted', executionMode: 'desatendido', journal: 'not-required' });
+                const stale = await (0, admission_1.admitPlan)({ ...base(), journalState: { ...(0, types_1.emptyState)('main'), schema: 2, planBinding: { path: 'docs/plan.md', digest: 'b'.repeat(64), schema: 'compact-slices/v1', executionMode: 'desatendido', boundAt: '2026-09-15T00:00:00.000Z' } } });
+                expect(stale).toMatchObject({ state: 'admitted', journal: 'not-required' });
+            }
+            finally {
+                if (previous === undefined)
+                    delete process.env.AWM_ALLOW_DURABLE_CUSTODY;
+                else
+                    process.env.AWM_ALLOW_DURABLE_CUSTODY = previous;
+            }
+        });
     });
     // 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 —

package/dist/tests/core/journal/durable-custody.test.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const durable_custody_1 = require("../../../src/core/journal/durable-custody");
+const watch_1 = require("../../../src/commands/watch");
+describe('durable custody suspension', () => {
+    const original = process.env.AWM_ALLOW_DURABLE_CUSTODY;
+    afterEach(() => {
+        if (original === undefined)
+            delete process.env.AWM_ALLOW_DURABLE_CUSTODY;
+        else
+            process.env.AWM_ALLOW_DURABLE_CUSTODY = original;
+    });
+    it('is suspended for operators (env unset) and only re-enabled by the Jest harness', () => {
+        delete process.env.AWM_ALLOW_DURABLE_CUSTODY;
+        expect((0, durable_custody_1.isDurableCustodySuspended)()).toBe(true);
+        process.env.AWM_ALLOW_DURABLE_CUSTODY = '0';
+        expect((0, durable_custody_1.isDurableCustodySuspended)()).toBe(true);
+        process.env.AWM_ALLOW_DURABLE_CUSTODY = '1';
+        expect((0, durable_custody_1.isDurableCustodySuspended)()).toBe(false);
+    });
+    it('refuses every awm watch entry point while suspended', async () => {
+        delete process.env.AWM_ALLOW_DURABLE_CUSTODY;
+        const program = new commander_1.Command();
+        (0, watch_1.registerWatchCommand)(program);
+        const err = [];
+        const exit = jest.spyOn(process, 'exit').mockImplementation(((code) => {
+            throw Object.assign(new Error(`exit:${code ?? 0}`), { code });
+        }));
+        program.configureOutput({ writeErr: (s) => { err.push(String(s)); } });
+        // stderr write in the refusal helper bypasses configureOutput; capture it too.
+        const stderr = jest.spyOn(process.stderr, 'write').mockImplementation(((chunk) => {
+            err.push(String(chunk));
+            return true;
+        }));
+        await expect(program.parseAsync(['node', 'awm', 'watch', 'journal-status'])).rejects.toThrow(/exit:1/);
+        expect(err.join('')).toContain(durable_custody_1.DURABLE_CUSTODY_SUSPENDED_MESSAGE);
+        err.length = 0;
+        await expect(program.parseAsync(['node', 'awm', 'watch', '--init', '--plan', 'docs/plan.md'])).rejects.toThrow(/exit:1/);
+        expect(err.join('')).toContain(durable_custody_1.DURABLE_CUSTODY_SUSPENDED_MESSAGE);
+        exit.mockRestore();
+        stderr.mockRestore();
+    });
+});

package/package.json

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