agentic-workflow-manager 9.7.0 → 9.8.0

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

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -17,7 +50,14 @@ const store_1 = require("../../../src/core/journal/store");
 const paths_1 = require("../../../src/core/journal/paths");
 const process_1 = require("../../../src/core/journal/process");
 const fingerprint_1 = require("../../../src/core/journal/fingerprint");
+const fingerprint = __importStar(require("../../../src/core/journal/fingerprint"));
 const tracks_1 = require("../../../src/commands/watch/tracks");
+const validate_1 = require("../../../src/core/plan/validate");
+const registryInventory = __importStar(require("../../../src/core/registries"));
+const currentnessCheck = __importStar(require("../../../src/core/currentness/check"));
+const sensorCommands = __importStar(require("../../../src/commands/sensors/run"));
+const preferencesConfig = __importStar(require("../../../src/utils/config"));
+const providers_1 = require("../../../src/providers");
 jest.setTimeout(60000);
 // runSupervisorLoop's full external-controller lifecycle (spawn stub codex ->
 // identity captured by the wrapper -> adopted via collectControllerGeneration's
@@ -49,6 +89,28 @@ function setupRepo() {
     fs_1.default.writeFileSync(path_1.default.join(repo, '.awm', 'sensors.json'), '{}');
     return repo;
 }
+const admitted = async () => ({
+    state: 'admitted', planState: 'valid', executionMode: 'desatendido',
+    journal: 'current', currentness: 'current', sensors: 'pass', diagnostics: [],
+});
+/** Legacy fixtures predate compact-only admission; make their execution contract explicit. */
+function initUnattendedFixture(repo) {
+    (0, init_1.initWatch)(repo, 'main');
+    const planPath = path_1.default.join(repo, 'plans', 'fixture.md');
+    fs_1.default.mkdirSync(path_1.default.dirname(planPath), { recursive: true });
+    fs_1.default.writeFileSync(planPath, fs_1.default.readFileSync(path_1.default.join(__dirname, '../../core/plan/fixtures/compact-slices-v1/valid.md'), 'utf8'));
+    fs_1.default.writeFileSync(path_1.default.join(repo, 'source.md'), '## Canonical source\nfixture source\n');
+    const plan = (0, validate_1.validatePlanFile)('plans/fixture.md', repo);
+    if (plan.state !== 'valid')
+        throw new Error('compact fixture must validate');
+    const state = (0, store_1.readJournal)(repo, 'main').state;
+    state.schema = 2;
+    state.planBinding = {
+        path: 'plans/fixture.md', digest: plan.planDigest, schema: plan.schema,
+        executionMode: 'desatendido', boundAt: new Date().toISOString(),
+    };
+    (0, store_1.writeJournal)(repo, 'main', state);
+}
 function emitVerdict(repo, token, obligationId, verdictId) {
     const argv = ['awm-review', obligationId];
     const fp = (0, fingerprint_1.computeFingerprint)(repo, argv, [], '.').fingerprint;
@@ -160,43 +222,70 @@ describe('supervisor loop', () => {
         process.env.PATH = `${stubBin}${path_1.default.delimiter}${process.env.PATH}`;
     });
     afterEach(() => {
+        jest.restoreAllMocks();
         process.env.PATH = oldPath;
         fs_1.default.rmSync(repo, { recursive: true, force: true });
         fs_1.default.rmSync(stubBin, { recursive: true, force: true });
     });
     test('ticks drenan y declaran COMPLETE solo con gate verde + cero vivos (R4.5)', async () => {
-        (0, init_1.initWatch)(repo, 'main'); // sin package.json => requiredVerifiers []
+        initUnattendedFixture(repo);
         const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, provider: 'codex', tickMs: 50, reconcileGraceMs: 10000 };
-        const sup = new supervisor_1.Supervisor(repo, 'main', cfg, fakeSpawner);
+        // Recovery classification has its own unit suite. This lifecycle test
+        // owns draining/COMPLETE, so pin the recovered schema-2 fixture green
+        // and do not leak the external controller stub merely to test wrappers.
+        const recovery = jest.spyOn(fingerprint, 'reconcileUnattendedRecovery').mockReturnValue({
+            state: 'ready', nextAction: 'select-work', activeJobIds: [], diagnostics: [],
+        });
+        let controllerSpawnAttempts = 0;
+        const lifecycleSpawner = (job, nonce, logsRoot, repoRoot) => {
+            if (job.argv[0] === 'codex') {
+                controllerSpawnAttempts++;
+                return;
+            }
+            fakeSpawner(job, nonce, logsRoot, repoRoot);
+        };
+        const sup = new supervisor_1.Supervisor(repo, 'main', cfg, lifecycleSpawner, undefined, admitted);
+        // The schema-2 recovery path only consumes requests authorized by the
+        // active generation. Establish it before issuing the scenario facts;
+        // the legacy fixture's hard-coded `g0` was never consumed and left the
+        // fake controller running forever in `select-work`.
+        const generation = (0, generations_1.beginGeneration)(repo, 'main');
         // el controlador (aqui: el test) registra plan de ciclo + task + jobs enlazados
-        (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: 'g0', idempotencyKey: 'e1',
+        (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: generation.token, idempotencyKey: 'e1',
             payload: { entity: 'task', taskId: 'T1', title: 't', verificationPlan: [{ id: 'v1', kind: 'test' }, { id: 'v-sensors', kind: 'sensors' }], reviewObligations: [{ id: 'o-spec', kind: 'spec' }, { id: 'o-quality', kind: 'quality' }] } });
-        (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: 'g0', idempotencyKey: 'e2',
+        (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: generation.token, idempotencyKey: 'e2',
             payload: { entity: 'cycle-plan', items: [{ id: 'cv1', kind: 'qa' }, { id: 'cv-interlock', kind: 'interlock' }] } });
-        (0, request_1.requestJob)(repo, 'main', 'g0', ['node', '-e', 'setTimeout(()=>process.exit(0), 400)'], [], '.', { satisfies: 'v1' });
-        (0, request_1.requestJob)(repo, 'main', 'g0', ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: 'v-sensors' });
-        (0, request_1.requestJob)(repo, 'main', 'g0', ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: 'cv1' });
-        (0, request_1.requestJob)(repo, 'main', 'g0', ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: 'cv-interlock' });
-        emitVerdict(repo, 'g0', 'o-spec', 'verd-spec');
-        emitVerdict(repo, 'g0', 'o-quality', 'verd-quality');
-        (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: 'g0', idempotencyKey: 'e3',
+        (0, request_1.requestJob)(repo, 'main', generation.token, ['node', '-e', 'setTimeout(()=>process.exit(0), 400)'], [], '.', { satisfies: 'v1' });
+        (0, request_1.requestJob)(repo, 'main', generation.token, ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: 'v-sensors' });
+        (0, request_1.requestJob)(repo, 'main', generation.token, ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: 'cv1' });
+        (0, request_1.requestJob)(repo, 'main', generation.token, ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: 'cv-interlock' });
+        emitVerdict(repo, generation.token, 'o-spec', 'verd-spec');
+        emitVerdict(repo, generation.token, 'o-quality', 'verd-quality');
+        (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: generation.token, idempotencyKey: 'e3',
             payload: { entity: 'task-status', taskId: 'T1', status: 'done' } });
-        let sawContinueWithLiveJob = false;
-        let outcome = 'continue';
-        for (let i = 0; i < 400 && outcome !== 'complete'; i++) {
-            outcome = await sup.tick();
-            const s = (0, store_1.readJournal)(repo, 'main').state;
-            const live = Object.values(s.jobs).some((j) => ['received', 'spawn-intent', 'claimed', 'running'].includes(j.executionState));
-            if (outcome === 'continue' && live)
-                sawContinueWithLiveJob = true; // drenaje ANTES de COMPLETE
-            await new Promise((r) => setTimeout(r, 50));
+        try {
+            let sawContinueWithLiveJob = false;
+            let outcome = 'continue';
+            for (let i = 0; i < 400 && outcome !== 'complete'; i++) {
+                outcome = await sup.tick();
+                const s = (0, store_1.readJournal)(repo, 'main').state;
+                const live = Object.values(s.jobs).some((j) => ['received', 'spawn-intent', 'claimed', 'running'].includes(j.executionState));
+                if (outcome === 'continue' && live)
+                    sawContinueWithLiveJob = true; // drenaje ANTES de COMPLETE
+                await new Promise((r) => setTimeout(r, 50));
+            }
+            expect(outcome).toBe('complete');
+            expect(sawContinueWithLiveJob).toBe(true);
+            const final = (0, store_1.readJournal)(repo, 'main').state;
+            expect(final.cycle.status).toBe('COMPLETE');
+            expect(typeof final.cycle.completedAt).toBe('string');
+            expect(Object.values(final.jobs).every((j) => j.executionState === 'exited' && j.verdict === 'pass')).toBe(true);
+            expect(final.generations.every((entry) => entry.state === 'terminated' && entry.processRef === undefined)).toBe(true);
+            expect(controllerSpawnAttempts).toBeGreaterThan(0);
+        }
+        finally {
+            recovery.mockRestore();
         }
-        expect(outcome).toBe('complete');
-        expect(sawContinueWithLiveJob).toBe(true);
-        const final = (0, store_1.readJournal)(repo, 'main').state;
-        expect(final.cycle.status).toBe('COMPLETE');
-        expect(typeof final.cycle.completedAt).toBe('string');
-        expect(Object.values(final.jobs).every((j) => j.executionState === 'exited' && j.verdict === 'pass')).toBe(true);
     });
     // Regresion (post-review #2, Task 12/R7 — Finding 2 de la segunda ronda
     // de re-review): la version anterior de esta prueba armaba el escenario
@@ -215,7 +304,7 @@ describe('supervisor loop', () => {
     // vivos) y confirma que `cycle.status` llega a COMPLETE por ese camino
     // generico, exactamente como lo haria un plan sin tracks en absoluto.
     test('una cohorte que cayo a fallback SERIAL via el reducer real no cuelga el ciclo: COMPLETE llega igual por el camino generico (regresion post-review R7, ronda 2)', async () => {
-        (0, init_1.initWatch)(repo, 'main');
+        initUnattendedFixture(repo);
         const tracksRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-loop-tracks-'));
         try {
             const baseSha = (0, child_process_1.execFileSync)('git', ['rev-parse', 'HEAD'], { cwd: repo, encoding: 'utf8' }).trim();
@@ -240,20 +329,32 @@ describe('supervisor loop', () => {
             // --- Fase 2: sobre ESE MISMO journal, completar el ciclo por el
             // camino generico (task done + qa/interlock satisfechos + cero
             // jobs vivos) — la misma receta que la prueba R4.5 de arriba.
-            (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: 'g0', idempotencyKey: 'e1',
+            const generation = (0, generations_1.beginGeneration)(repo, 'main');
+            (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: generation.token, idempotencyKey: 'e1',
                 payload: { entity: 'task', taskId: 'T1', title: 't', verificationPlan: [{ id: 'v1', kind: 'test' }, { id: 'v-sensors', kind: 'sensors' }], reviewObligations: [{ id: 'o-spec', kind: 'spec' }, { id: 'o-quality', kind: 'quality' }] } });
-            (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: 'g0', idempotencyKey: 'e2',
+            (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: generation.token, idempotencyKey: 'e2',
                 payload: { entity: 'cycle-plan', items: [{ id: 'cv1', kind: 'qa' }, { id: 'cv-interlock', kind: 'interlock' }] } });
-            (0, request_1.requestJob)(repo, 'main', 'g0', ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: 'v1' });
-            (0, request_1.requestJob)(repo, 'main', 'g0', ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: 'v-sensors' });
-            (0, request_1.requestJob)(repo, 'main', 'g0', ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: 'cv1' });
-            (0, request_1.requestJob)(repo, 'main', 'g0', ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: 'cv-interlock' });
-            emitVerdict(repo, 'g0', 'o-spec', 'verd-spec');
-            emitVerdict(repo, 'g0', 'o-quality', 'verd-quality');
-            (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: 'g0', idempotencyKey: 'e3',
+            (0, request_1.requestJob)(repo, 'main', generation.token, ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: 'v1' });
+            (0, request_1.requestJob)(repo, 'main', generation.token, ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: 'v-sensors' });
+            (0, request_1.requestJob)(repo, 'main', generation.token, ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: 'cv1' });
+            (0, request_1.requestJob)(repo, 'main', generation.token, ['node', '-e', 'process.exit(0)'], [], '.', { satisfies: 'cv-interlock' });
+            emitVerdict(repo, generation.token, 'o-spec', 'verd-spec');
+            emitVerdict(repo, generation.token, 'o-quality', 'verd-quality');
+            (0, requests_1.emitRequest)(repo, 'main', { kind: 'register-entity', generationToken: generation.token, idempotencyKey: 'e3',
                 payload: { entity: 'task-status', taskId: 'T1', status: 'done' } });
             const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, provider: 'codex', tickMs: 50, reconcileGraceMs: 10000 };
-            const sup = new supervisor_1.Supervisor(repo, 'main', cfg, fakeSpawner);
+            // The compact recovery reducer is verified independently. This test
+            // exercises the fallback SERIAL completion path, so avoid an
+            // external controller process while keeping real job wrappers.
+            jest.spyOn(fingerprint, 'reconcileUnattendedRecovery').mockReturnValue({
+                state: 'ready', nextAction: 'select-work', activeJobIds: [], diagnostics: [],
+            });
+            const lifecycleSpawner = (job, nonce, logsRoot, repoRoot) => {
+                if (job.argv[0] === 'codex')
+                    return;
+                fakeSpawner(job, nonce, logsRoot, repoRoot);
+            };
+            const sup = new supervisor_1.Supervisor(repo, 'main', cfg, lifecycleSpawner, undefined, admitted);
             let outcome = 'continue';
             for (let i = 0; i < 400 && outcome !== 'complete'; i++) {
                 outcome = await sup.tick();
@@ -265,34 +366,120 @@ describe('supervisor loop', () => {
             expect(final.cohortPhase).toBe('SERIAL'); // nunca inventa una transicion SERIAL -> COMPLETE
             for (const t of final.tracks)
                 expect(['REMOVED', 'DECLARED']).toContain(t.phase);
+            const { refIsAlive } = require('../../../src/core/journal/process');
+            expect(final.generations.every((entry) => entry.state === 'terminated' && (entry.processRef === undefined || !refIsAlive(entry.processRef)))).toBe(true);
         }
         finally {
             fs_1.default.rmSync(tracksRoot, { recursive: true, force: true });
         }
     });
     test('tick verifica branch antes del launch y un ciclo COMPLETE no lanza otro controller', async () => {
-        (0, init_1.initWatch)(repo, 'main');
+        initUnattendedFixture(repo);
         let calls = 0;
         const spy = () => { calls++; };
         const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, tickMs: 10 };
         const s = (0, store_1.readJournal)(repo, 'main').state;
         s.cycle.status = 'COMPLETE';
         (0, store_1.writeJournal)(repo, 'main', s);
-        expect(await new supervisor_1.Supervisor(repo, 'main', cfg, spy).tick()).toBe('complete');
+        expect(await new supervisor_1.Supervisor(repo, 'main', cfg, spy, undefined, admitted).tick()).toBe('complete');
         expect(calls).toBe(0);
         const reset = (0, store_1.readJournal)(repo, 'main').state;
         reset.cycle.status = 'IN_PROGRESS';
         (0, store_1.writeJournal)(repo, 'main', reset);
         git(repo, 'checkout', '-qb', 'otra');
-        await expect(new supervisor_1.Supervisor(repo, 'main', cfg, spy).tick()).rejects.toThrow(/rama|branch/i);
+        await expect(new supervisor_1.Supervisor(repo, 'main', cfg, spy, undefined, admitted).tick()).rejects.toThrow(/rama|branch/i);
         expect(calls).toBe(0);
     });
+    test('una admisión compacta bloqueada no lanza controlador ni wrappers', async () => {
+        initUnattendedFixture(repo);
+        const state = (0, store_1.readJournal)(repo, 'main').state;
+        state.schema = 2;
+        state.planBinding = { path: 'plans/exact.md', digest: 'a'.repeat(64), schema: 'compact-slices/v1', executionMode: 'desatendido', boundAt: new Date().toISOString() };
+        (0, store_1.writeJournal)(repo, 'main', state);
+        (0, request_1.requestJob)(repo, 'main', 'g0', ['node', '-e', 'process.exit(0)'], [], '.');
+        let spawns = 0;
+        const blocked = async () => ({ state: 'blocked', planState: 'valid', journal: 'current', currentness: 'stale', sensors: 'not-required', diagnostics: [{ code: 'ADMISSION_CURRENTNESS_BLOCKED', message: 'stale' }] });
+        const outcome = await new supervisor_1.Supervisor(repo, 'main', supervisor_1.DEFAULT_SUPERVISOR_CONFIG, () => { spawns++; }, undefined, blocked).tick();
+        expect(outcome).toBe('custody');
+        expect(spawns).toBe(0);
+        expect((0, store_1.readJournal)(repo, 'main').state.cycle.status).toBe('BLOCKED');
+    });
+    test('native default admission blocks an actual incompatible runtime supplier on a project-only plan before sensors or dispatch', async () => {
+        initUnattendedFixture(repo);
+        const oldHome = process.env.HOME;
+        process.env.HOME = path_1.default.join(repo, 'isolated-home');
+        const registryRoot = path_1.default.join(repo, 'supplier-registry');
+        const skillSource = path_1.default.join(registryRoot, 'skills', 'using-awm');
+        fs_1.default.mkdirSync(skillSource, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(skillSource, 'SKILL.md'), 'runtime contract');
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'awm-registry.json'), '{"minCliVersion":"999.0.0"}');
+        const installed = (0, providers_1.providerFor)('codex').skill.global;
+        fs_1.default.mkdirSync(installed, { recursive: true });
+        fs_1.default.symlinkSync(skillSource, path_1.default.join(installed, 'using-awm'), process.platform === 'win32' ? 'junction' : 'dir');
+        const inventory = jest.spyOn(registryInventory, 'listRegistries').mockReturnValue([{ name: 'supplier', remote: 'https://example.invalid/supplier.git', contentRoot: registryRoot }]);
+        const preferences = jest.spyOn(preferencesConfig, 'readPreferences').mockReturnValue({ defaultAgent: 'codex', enabledAgents: ['codex'], installMethod: 'symlink', defaultScope: 'local' });
+        const currentness = jest.spyOn(currentnessCheck, 'checkCurrentness').mockResolvedValue({ checkedAt: 'x', compatibility: { status: 'not-checked' }, components: ['cli', 'registry:supplier'].map(component => ({ component, installed: '1.0.0', latest: '1.0.0', channel: 'stable', source: 'fixture', checkedAt: 'x', status: 'current', detail: 'ok', remedy: 'none' })) });
+        const sensors = jest.spyOn(sensorCommands, 'runSensors').mockResolvedValue({ overall: 'pass', sensors: [] });
+        let dispatches = 0;
+        try {
+            const outcome = await new supervisor_1.Supervisor(repo, 'main', supervisor_1.DEFAULT_SUPERVISOR_CONFIG, () => { dispatches++; }).tick();
+            expect(outcome).toBe('custody');
+            expect(sensors).not.toHaveBeenCalled();
+            expect(dispatches).toBe(0);
+            expect((0, store_1.readJournal)(repo, 'main').state.cycle.status).toBe('BLOCKED');
+            expect((0, store_1.readJournal)(repo, 'main').state.cycle.blockedReason).toContain('ADMISSION_REGISTRY_CLI_INCOMPATIBLE');
+            expect((0, store_1.readJournal)(repo, 'main').state.cycle.blockedReason).toContain('999.0.0');
+        }
+        finally {
+            inventory.mockRestore();
+            preferences.mockRestore();
+            currentness.mockRestore();
+            sensors.mockRestore();
+            if (oldHome === undefined)
+                delete process.env.HOME;
+            else
+                process.env.HOME = oldHome;
+        }
+    });
+    test.each([
+        ['cycle BLOCKED', (s) => { s.cycle.status = 'BLOCKED'; }],
+        ['request problem durable', (s) => { s.requestProblems.push({ file: 'x.request.json', kind: 'rejected', detail: 'x', at: new Date().toISOString() }); }],
+        ['verificador requerido ausente tras tasks completadas', (s) => {
+                s.tasks.push({ id: 'T1', title: 'terminada', status: 'done', attempts: 1, verificationPlan: [], reviewObligations: [] });
+                s.requiredVerifiers = ['test'];
+            }],
+    ])('recovery fail-closed: %s entra en custodia sin controller ni dispatch', async (_name, mutate) => {
+        initUnattendedFixture(repo);
+        const state = (0, store_1.readJournal)(repo, 'main').state;
+        mutate(state);
+        (0, store_1.writeJournal)(repo, 'main', state);
+        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');
+    });
+    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;
+        legacy.jobs.pending = {
+            id: 'pending', fingerprint: '', commandDigest: '', argv: ['node', '-e', 'process.exit(0)'], cwd: '.', paths: [], expandedPaths: [],
+            executionState: 'received', observationState: 'progressing', phaseTimestamps: {},
+        };
+        (0, store_1.writeJournal)(repo, 'main', legacy);
+        let spawns = 0;
+        const outcome = await new supervisor_1.Supervisor(repo, 'main', supervisor_1.DEFAULT_SUPERVISOR_CONFIG, () => { spawns++; }).tick();
+        expect(outcome).toBe('custody');
+        expect(spawns).toBe(0);
+        expect((0, store_1.readJournal)(repo, 'main').state.generations).toEqual([]);
+        expect((0, store_1.readJournal)(repo, 'main').state.jobs.pending.executionState).toBe('received');
+    });
     test('fallo de launch queda durable y entra en backoff sin tumbar el supervisor (R4.3)', async () => {
-        (0, init_1.initWatch)(repo, 'main');
+        initUnattendedFixture(repo);
         (0, generations_1.beginGeneration)(repo, 'main');
         let calls = 0;
         const failing = () => { calls++; throw new Error('provider unavailable'); };
-        const sup = new supervisor_1.Supervisor(repo, 'main', { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, tickMs: 10 }, failing);
+        const sup = new supervisor_1.Supervisor(repo, 'main', { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, tickMs: 10 }, failing, undefined, admitted);
         await expect(sup.tick()).resolves.toBe('continue');
         expect(calls).toBe(1);
         const intent = (0, generations_1.activeGeneration)((0, store_1.readJournal)(repo, 'main').state);
@@ -302,7 +489,7 @@ describe('supervisor loop', () => {
         expect(calls).toBe(1); // primer backoff es 60 s: no hace hot-loop
     });
     test('custodia: doble senial + indeterminate => tick custody, lock retenido, proceso intacto (R4.2b/R4.5)', async () => {
-        (0, store_1.initJournal)(repo, 'main');
+        initUnattendedFixture(repo);
         (0, generations_1.beginGeneration)(repo, 'main');
         const { child, ref } = (0, process_1.spawnStructured)(['node', '-e', 'setTimeout(()=>{}, 20000)'], process.cwd(), 'nCtl');
         let s = (0, store_1.readJournal)(repo, 'main').state;
@@ -312,7 +499,7 @@ describe('supervisor loop', () => {
         fs_1.default.mkdirSync(path_1.default.dirname((0, paths_1.supervisorLockPath)(repo)), { recursive: true });
         fs_1.default.writeFileSync((0, paths_1.supervisorLockPath)(repo), 'lock-del-loop'); // el loop lo tendria: NO debe borrarse
         const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, provider: 'codex', heartbeatTimeoutMs: 1, activityWindowMs: 50, tickMs: 20 };
-        const sup = new supervisor_1.Supervisor(repo, 'main', cfg, fakeSpawner);
+        const sup = new supervisor_1.Supervisor(repo, 'main', cfg, fakeSpawner, undefined, admitted);
         await sup.tick(); // primer tick: arranca el tracking de actividad
         await new Promise((r) => setTimeout(r, 150)); // actividad congelada > ventana
         const out = await sup.tick();
@@ -324,9 +511,12 @@ describe('supervisor loop', () => {
         child.kill('SIGKILL');
     });
     itPosix('runSupervisorLoop: bootstrap gen-1 con stub codex, COMPLETE => libera lock y termina su generacion (R4.1/R4.5/R2.4)', async () => {
-        (0, init_1.initWatch)(repo, 'main');
+        initUnattendedFixture(repo);
+        jest.spyOn(fingerprint, 'reconcileUnattendedRecovery').mockReturnValue({
+            state: 'ready', nextAction: 'select-work', activeJobIds: [], diagnostics: [],
+        });
         const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, provider: 'codex', tickMs: 50, termGraceMs: 300, killGraceMs: 300 };
-        const loop = (0, supervisor_1.runSupervisorLoop)(repo, 'main', cfg, fakeSpawner);
+        const loop = (0, supervisor_1.runSupervisorLoop)(repo, 'main', cfg, fakeSpawner, undefined, admitted);
         await until(() => {
             const r = (0, store_1.readJournal)(repo, 'main');
             return r.state !== null && (0, generations_1.activeGeneration)(r.state) !== undefined && fs_1.default.existsSync((0, paths_1.supervisorLockPath)(repo));
@@ -346,13 +536,17 @@ describe('supervisor loop', () => {
         // generacion propia terminada: cero procesos codex huerfanos (R2.4)
         const { refIsAlive } = require('../../../src/core/journal/process');
         expect(gen.processRef === undefined || !refIsAlive(gen.processRef)).toBe(true);
+        expect(gen.state).toBe('terminated');
     });
     itPosix('reinicio tras crash entre beginGeneration y spawn recupera la misma generacion sin quedar wedged', async () => {
-        (0, init_1.initWatch)(repo, 'main');
+        initUnattendedFixture(repo);
+        jest.spyOn(fingerprint, 'reconcileUnattendedRecovery').mockReturnValue({
+            state: 'ready', nextAction: 'select-work', activeJobIds: [], diagnostics: [],
+        });
         const begun = (0, generations_1.beginGeneration)(repo, 'main'); // crash simulado: intent durable, sin ProcessRef
         const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, provider: 'codex', tickMs: 25, reconcileGraceMs: 300,
             termGraceMs: 300, killGraceMs: 300 };
-        const loop = (0, supervisor_1.runSupervisorLoop)(repo, 'main', cfg, fakeSpawner);
+        const loop = (0, supervisor_1.runSupervisorLoop)(repo, 'main', cfg, fakeSpawner, undefined, admitted);
         let recovered = false;
         try {
             await until(() => {
@@ -369,6 +563,10 @@ describe('supervisor loop', () => {
         }
         await loop;
         expect(recovered).toBe(true);
-        expect((0, store_1.readJournal)(repo, 'main').state.generations).toHaveLength(1);
+        const final = (0, store_1.readJournal)(repo, 'main').state;
+        expect(final.generations).toHaveLength(1);
+        expect(final.generations[0].state).toBe('terminated');
+        const { refIsAlive } = require('../../../src/core/journal/process');
+        expect(final.generations[0].processRef === undefined || !refIsAlive(final.generations[0].processRef)).toBe(true);
     });
 });

package/dist/tests/commands/watch/track-finalize.test.js

@@ -26,6 +26,7 @@ const supervisor_1 = require("../../../src/commands/watch/supervisor");
 const tracks_1 = require("../../../src/commands/watch/tracks");
 const exec_wrapper_1 = require("../../../src/commands/job/exec-wrapper");
 const init_1 = require("../../../src/commands/watch/init");
+const validate_1 = require("../../../src/core/plan/validate");
 const requests_1 = require("../../../src/core/journal/requests");
 const apply_1 = require("../../../src/commands/watch/apply");
 const generations_1 = require("../../../src/commands/watch/generations");
@@ -35,6 +36,22 @@ const fingerprint_1 = require("../../../src/core/journal/fingerprint");
 const paths_1 = require("../../../src/core/journal/paths");
 const types_1 = require("../../../src/core/journal/types");
 const git_fixture_1 = require("../../helpers/git-fixture");
+const admitted = async () => ({
+    state: 'admitted', planState: 'valid', executionMode: 'desatendido',
+    journal: 'current', currentness: 'current', sensors: 'pass', diagnostics: [],
+});
+function initCompactWatch(repoRoot, branch) {
+    const planPath = path_1.default.join(repoRoot, 'plans', 'fixture.md');
+    fs_1.default.mkdirSync(path_1.default.dirname(planPath), { recursive: true });
+    fs_1.default.writeFileSync(planPath, fs_1.default.readFileSync(path_1.default.join(__dirname, '../../core/plan/fixtures/compact-slices-v1/valid.md'), 'utf8'));
+    fs_1.default.writeFileSync(path_1.default.join(repoRoot, 'source.md'), '## Canonical source\nfixture source\n');
+    git(repoRoot, 'add', 'plans/fixture.md', 'source.md');
+    git(repoRoot, 'commit', '-qm', 'compact plan fixture');
+    const report = (0, validate_1.validatePlanFile)('plans/fixture.md', repoRoot);
+    if (report.state !== 'valid')
+        throw new Error(`compact fixture must validate: ${JSON.stringify(report)}`);
+    (0, init_1.initWatch)(repoRoot, branch, { path: 'plans/fixture.md', report });
+}
 function git(cwd, ...args) {
     (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', ...args], { cwd, stdio: 'pipe' });
 }
@@ -242,7 +259,7 @@ function finalizerHarness(trackIds) {
     git(repo, 'commit', '-qm', 'seed');
     fs_1.default.mkdirSync(path_1.default.join(repo, '.awm'), { recursive: true });
     fs_1.default.writeFileSync(path_1.default.join(repo, '.awm', 'sensors.json'), '{}');
-    (0, init_1.initWatch)(repo, 'main'); // gitignora .awm, detecta requiredVerifiers (test+sensors, R3.6)
+    initCompactWatch(repo, 'main'); // gitignora .awm, detecta requiredVerifiers (test+sensors, R3.6)
     git(repo, 'add', '.gitignore');
     git(repo, 'commit', '-qm', 'gitignore .awm');
     const baseSha = (0, child_process_1.execFileSync)('git', ['rev-parse', 'HEAD'], { cwd: repo, encoding: 'utf8' }).trim();
@@ -282,7 +299,7 @@ function finalizerHarness(trackIds) {
         payload: { entity: 'track-integration', argv: INTEGRATION_ARGV, paths: INTEGRATION_PATHS, planDigest: 'plan-1' },
     });
     const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, tickMs: 10, provider: 'codex' };
-    let sup = new supervisor_1.Supervisor(repo, 'main', cfg, spawner);
+    let sup = new supervisor_1.Supervisor(repo, 'main', cfg, spawner, undefined, admitted);
     const realFingerprintNow = (argv, paths, cwd) => {
         try {
             return (0, fingerprint_1.computeFingerprint)(repo, argv, paths, cwd).fingerprint;
@@ -360,7 +377,7 @@ function finalizerHarness(trackIds) {
                 .map((j) => ({ argv: j.argv, paths: j.paths, cwd: j.cwd, satisfies: [...(j.satisfies ?? [])].sort() }));
         },
         integrationWrapperCalls() { return integrationCalls; },
-        crashAndRestart() { sup = new supervisor_1.Supervisor(repo, 'main', cfg, spawner); },
+        crashAndRestart() { sup = new supervisor_1.Supervisor(repo, 'main', cfg, spawner, undefined, admitted); },
         interlock() {
             const s = (0, store_1.readJournal)(repo, 'main').state;
             return (0, gate_1.computeGate)(s, false, realFingerprintNow);