agentic-workflow-manager 9.13.1 → 9.14.0

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

@@ -245,14 +245,18 @@ function recoveryWhitelistBlocker(state) {
     // Pending work is the normal reason to launch (or retry launching) the
     // controller.  It is not recovery evidence and therefore cannot turn a
     // transient launch failure into permanent custody.  Conversely, once a
-    // non-empty task set claims completion, missing required evidence is an
-    // unsafe recovery fact and must remain fail-closed.
+    // non-empty task set claims completion, a required verifier that no plan
+    // contains, or a task-level item left unsatisfied, is an unsafe recovery
+    // fact and must remain fail-closed. A cycle-level item that was planned
+    // but never requested is not: it is the pending closure a relaunched
+    // controller exists to perform (#196, v1 smoke), and the gate still
+    // demands its evidence before COMPLETE.
     if (state.tasks.length === 0 || state.tasks.some(task => task.status !== 'done'))
         return undefined;
     const verificationItems = [...state.cycleVerificationPlan, ...state.tasks.flatMap(task => task.verificationPlan)];
     for (const required of state.requiredVerifiers) {
         const requiredItems = verificationItems.filter(item => item.kind === required);
-        if (requiredItems.length === 0 || requiredItems.some(item => item.satisfiedBy === undefined))
+        if (requiredItems.length === 0 || requiredItems.some(item => item.satisfiedBy === undefined && !state.cycleVerificationPlan.includes(item)))
             return `falta evidencia del verificador requerido: ${required}`;
     }
     return undefined;
@@ -483,18 +487,23 @@ class Supervisor {
                 const job = before0.state.jobs[id];
                 return job !== undefined && job.verdict === 'pass' && !staleJob;
             };
-            const verificationItems = [...before0.state.cycleVerificationPlan, ...before0.state.tasks.flatMap(task => task.verificationPlan)];
-            const tests = verificationItems.filter(item => item.kind === 'test');
-            const sensorItems = verificationItems.filter(item => item.kind === 'sensors');
+            const cycleItems = before0.state.cycleVerificationPlan;
+            const verificationItems = [...cycleItems, ...before0.state.tasks.flatMap(task => task.verificationPlan)];
+            // Planned cycle items never requested are closure work, not
+            // evidence; every requested or task-level item is still judged.
+            const judged = (items) => items.filter(item => item.satisfiedBy !== undefined || !cycleItems.includes(item));
+            const tests = judged(verificationItems.filter(item => item.kind === 'test'));
+            const sensorItems = judged(verificationItems.filter(item => item.kind === 'sensors'));
             // `computeGate` is the single authority for every verification
             // kind (review, QA and interlock included). Reuse its evidence
             // semantics instead of maintaining a weaker recovery subset.
             const evidenceGate = (0, gate_1.computeGate)(before0.state, false, this.fingerprintNow);
             const terminalTaskClaims = before0.state.tasks.length > 0 && before0.state.tasks.every(task => task.status === 'done');
-            const unresolvedVerification = terminalTaskClaims && evidenceGate.reasons.some(reason => [
-                'dangling-reference', 'unsatisfied-plan', 'adverse-verdict',
+            const closurePending = terminalTaskClaims && cycleItems.some(item => item.satisfiedBy === undefined);
+            const unresolvedVerification = terminalTaskClaims && (evidenceGate.reasons.some(reason => [
+                'dangling-reference', 'adverse-verdict',
                 'stale-fingerprint', 'open-obligation', 'open-fix',
-            ].includes(reason.category));
+            ].includes(reason.category)) || verificationItems.some(item => item.satisfiedBy === undefined && !cycleItems.includes(item)));
             const hasStaleReview = before0.state.verdicts.some(verdict => verdict.fingerprint === '' || (verdict.argv.length > 0 && (() => {
                 try {
                     return (0, fingerprint_1.computeFingerprint)(this.repoRoot, verdict.argv, verdict.paths, verdict.cwd).fingerprint !== verdict.fingerprint;
@@ -524,7 +533,7 @@ class Supervisor {
                 sensors: !terminalTaskClaims || sensorItems.length === 0 || sensorItems.every(item => passed(item.satisfiedBy)) ? 'pass' : 'missing',
                 verdicts: hasStaleReview ? 'stale' : (openReviewOrFix || unresolvedVerification) ? 'missing' : 'current',
             });
-            (0, store_1.appendEvent)(this.repoRoot, this.branch, { kind: 'unattended-recovery', nextAction: recovery.nextAction, activeJobIds: recovery.activeJobIds, diagnostics: recovery.diagnostics });
+            (0, store_1.appendEvent)(this.repoRoot, this.branch, { kind: 'unattended-recovery', nextAction: recovery.nextAction, activeJobIds: recovery.activeJobIds, diagnostics: recovery.diagnostics, closurePending });
             if (recovery.state !== 'ready') {
                 const staleReasons = terminalTaskClaims ? evidenceGate.reasons.filter(reason => reason.category === 'stale-fingerprint') : [];
                 const remedy = staleReasons.length > 0
@@ -533,7 +542,7 @@ class Supervisor {
                 (0, generations_1.enterCustody)(this.repoRoot, this.branch, `recovery no autorizado: ${recovery.diagnostics.join(', ')}${remedy}`);
                 return 'custody';
             }
-            recoveryResumeAction = { schema: 'controller-recovery/v1', kind: recovery.nextAction === 'reconcile-active-jobs' ? 'reconcile-active-jobs' : 'resume-next-action' };
+            recoveryResumeAction = { schema: 'controller-recovery/v1', kind: recovery.nextAction === 'reconcile-active-jobs' ? 'reconcile-active-jobs' : closurePending ? 'resume-cycle' : 'resume-next-action' };
         }
         // R6.2/R6.8/C7 (Task 11): reconciliar un `MERGE_HEAD` abierto por un
         // crash a mitad de un merge ANTES de cualquier guard general — hoy
@@ -792,6 +801,11 @@ class Supervisor {
         const decision = snap === null && safeToReplace === 'safe' ? 'resolve-generation' : (0, generations_1.decideStall)({ heartbeatAgeMs, activityFrozenMs, safeToReplace }, { heartbeatTimeoutMs: this.cfg.heartbeatTimeoutMs, activityWindowMs: this.cfg.activityWindowMs });
         if (decision === 'healthy') {
             this.backoff.reset();
+            if (gen.state === 'controller-suspected-stall') {
+                gen.state = 'active'; // heartbeat reanudado: la sospecha se levanta
+                (0, store_1.writeJournal)(this.repoRoot, this.branch, s);
+                (0, store_1.appendEvent)(this.repoRoot, this.branch, { kind: 'controller-stall-cleared', n: gen.n });
+            }
             return 'ok';
         }
         if (decision === 'suspected-stall-observe') {

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

@@ -233,8 +233,14 @@ async function admitPlan(input) {
             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 });
     }
     if (mode === 'desatendido') {
-        const journal = journalStatus(input, plan);
-        if (journal !== 'current')
+        // 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.
+        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' });
         const capabilities = unattendedCapabilities(provider, input.controllerAutonomy);
         const resolution = { outcome: capabilities.unattendedController === 'supported' ? 'native' : 'blocked', provider, capabilities, evidenceVersion: 'r1-v1', diagnostics: [] };

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

@@ -309,7 +309,7 @@ describe('plan admit Commander wiring', () => {
             process.exitCode = undefined;
         }
     });
-    it('derives desatendido from the canonical plan header and requires a journal without a flag', async () => {
+    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);
         try {
@@ -327,7 +327,11 @@ describe('plan admit Commander wiring', () => {
                 readPreferences: () => ({ defaultAgent: 'codex', enabledAgents: ['codex'], installMethod: 'symlink', defaultScope: 'local' }),
             });
             await program.parseAsync(['node', 'awm', 'plan', 'admit', 'plan.md', '--provider', 'codex', '--cwd', root, '--json']);
-            expect(JSON.parse(String(output.mock.calls[0][0]))).toMatchObject({ state: 'blocked', executionMode: 'desatendido', journal: expect.stringMatching(/missing|corrupt/) });
+            const withoutPosture = JSON.parse(String(output.mock.calls[0][0]));
+            expect(withoutPosture).toMatchObject({ state: 'blocked', executionMode: 'desatendido', journal: 'not-required' });
+            expect(withoutPosture.diagnostics[0]).toMatchObject({ code: 'ADMISSION_CONTROLLER_AUTONOMY_REQUIRED' });
+            await program.parseAsync(['node', 'awm', 'plan', 'admit', 'plan.md', '--provider', 'codex', '--cwd', root, '--controller-autonomy', 'approval-free', '--json']);
+            expect(JSON.parse(String(output.mock.calls[1][0]))).toMatchObject({ state: 'admitted', executionMode: 'desatendido', journal: 'not-required' });
         }
         finally {
             output.mockRestore();

package/dist/tests/commands/watch/supervisor-loop.test.js

@@ -621,6 +621,88 @@ describe('supervisor loop', () => {
         expect(spawns).toBe(0);
         expect((0, store_1.readJournal)(repo, 'main').state.cycle.status).toBe('BLOCKED');
     });
+    // v1 smoke 2026-09-26 (#196): the Codex controller exited after the last
+    // review, before requesting the cycle-level verifications it had planned.
+    // Tasks done + planned-but-never-requested cycle items is pending closure
+    // work, not an unsafe recovery claim: relaunch the controller to close.
+    function closurePendingState(repoRoot) {
+        initUnattendedFixture(repoRoot);
+        const state = (0, store_1.readJournal)(repoRoot, 'main').state;
+        const verdict = (id, obligationId) => {
+            const argv = ['awm-review', obligationId];
+            return { id, obligationId, result: 'pass', detail: 'ok', receivedAt: new Date().toISOString(),
+                fingerprint: (0, fingerprint_1.computeFingerprint)(repoRoot, argv, [], '.').fingerprint, argv, paths: [], cwd: '.' };
+        };
+        state.requiredVerifiers = ['test', 'sensors'];
+        state.tasks.push({ id: 'S1', title: 'terminada', status: 'done', attempts: 1, verificationPlan: [], reviewObligations: [
+                { id: 'o-spec', taskId: 'S1', kind: 'spec', verdictId: 'v-spec' },
+                { id: 'o-quality', taskId: 'S1', kind: 'quality', verdictId: 'v-quality' },
+            ] });
+        state.verdicts.push(verdict('v-spec', 'o-spec'), verdict('v-quality', 'o-quality'));
+        state.cycleVerificationPlan.push({ id: 'cycle-test', kind: 'test' }, { id: 'cycle-sensors', kind: 'sensors' }, { id: 'cycle-qa', kind: 'qa' }, { id: 'cycle-interlock', kind: 'interlock' });
+        return state;
+    }
+    test('cierre pendiente: tareas terminadas + verificaciones de ciclo nunca pedidas => relanza el controller para cerrar, sin custodia', async () => {
+        const state = closurePendingState(repo);
+        (0, store_1.writeJournal)(repo, 'main', state);
+        (0, generations_1.beginGeneration)(repo, 'main'); // el reemplazo que el loop abre tras la salida del anterior
+        let spawns = 0;
+        const outcome = await new supervisor_1.Supervisor(repo, 'main', supervisor_1.DEFAULT_SUPERVISOR_CONFIG, () => { spawns++; }, undefined, admitted).tick();
+        expect(outcome).not.toBe('custody');
+        const after = (0, store_1.readJournal)(repo, 'main').state;
+        expect(after.cycle.status).toBe('IN_PROGRESS');
+        expect(spawns).toBe(1);
+        expect((0, generations_1.activeGeneration)(after).resumeAction?.kind).toBe('resume-cycle');
+        expect(after.tasks.map(task => [task.id, task.status, task.attempts])).toEqual([['S1', 'done', 1]]); // nada se redespacha
+    });
+    test.each([
+        ['un item de tarea sin satisfacer tras declararla terminada', (s) => {
+                s.tasks[0].verificationPlan.push({ id: 'task-test', kind: 'test' });
+            }],
+        ['un item de ciclo que cita un job inexistente', (s) => {
+                s.cycleVerificationPlan[0].satisfiedBy = 'job-fantasma';
+            }],
+        ['una revision obligatoria sin verdict', (s) => {
+                s.tasks[0].reviewObligations[1].verdictId = undefined;
+            }],
+        ['un verdict de revision adverso sin fix cerrado', (s) => {
+                s.verdicts[1].result = 'fail';
+            }],
+        ['un verificador requerido que ningun plan contiene', (s) => {
+                s.cycleVerificationPlan.splice(0, 1);
+            }],
+    ])('cierre pendiente sigue fail-closed con %s: custodia sin controller', async (_name, mutate) => {
+        const state = closurePendingState(repo);
+        mutate(state);
+        (0, store_1.writeJournal)(repo, 'main', state);
+        (0, generations_1.beginGeneration)(repo, 'main'); // mismo reemplazo: solo cambia la evidencia
+        let spawns = 0;
+        const outcome = await new supervisor_1.Supervisor(repo, 'main', supervisor_1.DEFAULT_SUPERVISOR_CONFIG, () => { spawns++; }, undefined, admitted).tick();
+        expect(outcome).toBe('custody');
+        expect(spawns).toBe(0);
+        expect((0, store_1.readJournal)(repo, 'main').state.cycle.status).toBe('BLOCKED');
+    });
+    // A controller that resumes heartbeating is healthy again; leaving the
+    // generation marked as a suspected stall misreports the cycle.
+    test('una generacion en sospecha de stall vuelve a active cuando el heartbeat se reanuda', async () => {
+        initUnattendedFixture(repo);
+        (0, generations_1.beginGeneration)(repo, 'main');
+        const { child, ref } = (0, process_1.spawnStructured)(['node', '-e', 'setTimeout(()=>{}, 20000)'], process.cwd(), 'nBack');
+        try {
+            const s = (0, store_1.readJournal)(repo, 'main').state;
+            const gen = (0, generations_1.activeGeneration)(s);
+            gen.processRef = ref;
+            gen.state = 'controller-suspected-stall';
+            s.controllerHeartbeatAt = new Date().toISOString();
+            (0, store_1.writeJournal)(repo, 'main', s);
+            const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, provider: 'codex', heartbeatTimeoutMs: 60000, activityWindowMs: 60000, tickMs: 20 };
+            expect(await new supervisor_1.Supervisor(repo, 'main', cfg, fakeSpawner, undefined, admitted).tick()).not.toBe('custody');
+            expect((0, generations_1.activeGeneration)((0, store_1.readJournal)(repo, 'main').state).state).toBe('active');
+        }
+        finally {
+            child.kill('SIGKILL');
+        }
+    });
     test('un journal schema-1 legacy no despacha controller ni jobs aunque contenga trabajo pendiente', async () => {
         (0, store_1.initJournal)(repo, 'main');
         const legacy = (0, store_1.readJournal)(repo, 'main').state;

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

@@ -143,12 +143,40 @@ describe('admitPlan', () => {
         expect(report).toMatchObject({ state: 'blocked', executionMode: 'interactivo', provider: 'cursor', journal: 'not-required' });
         expect(report.diagnostics[0].code).toBe('ADMISSION_CAPABILITY_UNVERIFIED');
     });
-    it('reports the schema-2 journal prerequisite for otherwise admissible unattended work', async () => {
-        const unattended = { ...valid, manifest: { ...valid.manifest, executionMode: 'desatendido' } };
-        const report = await (0, admission_1.admitPlan)({ plan: unattended, provider: 'codex', cwd: process.cwd(), enabledAgents: ['codex'] });
-        expect(report).toMatchObject({ state: 'blocked', executionMode: 'desatendido', journal: 'missing' });
-        expect(report.diagnostics[0]).toMatchObject({ code: 'ADMISSION_JOURNAL_BINDING_REQUIRED' });
-        expect(report.forecast).toBeUndefined();
+    // The durable controller (journal + awm watch + jobs) is opt-in again for
+    // native v1 dispatch, as it was before 9.8.0: a v1 unattended plan with no
+    // journal on its branch runs as one native provider session. Creating a
+    // journal (awm watch --init) is the opt-in, after which it must be current.
+    // v2 routing custody lives in the journal, so awm-routed still requires it.
+    describe('the durable journal is opt-in for native v1 unattended work', () => {
+        const unattended = () => ({ ...valid, manifest: { ...valid.manifest, executionMode: 'desatendido' } });
+        const base = () => ({ plan: unattended(), provider: 'codex', cwd: process.cwd(), enabledAgents: ['codex'], planPath: 'docs/plan.md', controllerAutonomy: 'approval-free' });
+        it('admits a v1 unattended plan with no journal as journal not-required', async () => {
+            const report = await (0, admission_1.admitPlan)(base());
+            expect(report).toMatchObject({ state: 'admitted', executionMode: 'desatendido', journal: 'not-required' });
+            expect(report.diagnostics.map(d => d.code)).not.toContain('ADMISSION_JOURNAL_BINDING_REQUIRED');
+        });
+        it('keeps a journal that exists (the opt-in) fail-closed when it is corrupt or stale', async () => {
+            const corrupt = await (0, admission_1.admitPlan)({ ...base(), journalCorrupt: true });
+            expect(corrupt).toMatchObject({ state: 'blocked', journal: 'corrupt' });
+            expect(corrupt.diagnostics[0]).toMatchObject({ code: 'ADMISSION_JOURNAL_BINDING_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: 'blocked', journal: 'stale' });
+            const legacy = await (0, admission_1.admitPlan)({ ...base(), journalState: (0, types_1.emptyState)('main') });
+            expect(legacy).toMatchObject({ state: 'blocked', journal: 'stale' });
+        });
+        it('still requires the journal for awm-routed v2 unattended work', async () => {
+            const v2Unattended = { ...valid, schema: 'compact-slices/v2', manifest: { ...valid.manifest, executionMode: 'desatendido', schema: 'compact-slices/v2', slices: valid.manifest.slices.map(slice => ({ ...slice, implementerProfile: 'mechanical' })) } };
+            const report = await (0, admission_1.admitPlan)({ ...base(), plan: v2Unattended });
+            expect(report).toMatchObject({ state: 'blocked', executionMode: 'desatendido', journal: 'missing' });
+            expect(report.diagnostics[0]).toMatchObject({ code: 'ADMISSION_JOURNAL_BINDING_REQUIRED' });
+            expect(report.forecast).toBeUndefined();
+        });
+        it('keeps the controller posture gate for journal-less unattended work', async () => {
+            const report = await (0, admission_1.admitPlan)({ ...base(), controllerAutonomy: undefined });
+            expect(report.state).toBe('blocked');
+            expect(report.diagnostics[0]).toMatchObject({ code: 'ADMISSION_CONTROLLER_AUTONOMY_REQUIRED' });
+        });
     });
     it('admits unattended work only with an exact schema-2 plan binding', async () => {
         const unattended = { ...valid, manifest: { ...valid.manifest, executionMode: 'desatendido' } };

package/package.json

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