agentic-workflow-manager 9.7.0 → 9.8.0

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

@@ -25,11 +25,28 @@ const tracks_1 = require("../../../src/commands/watch/tracks");
 const supervisor_1 = require("../../../src/commands/watch/supervisor");
 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 request_1 = require("../../../src/commands/job/request");
 const requests_1 = require("../../../src/core/journal/requests");
 const fingerprint_1 = require("../../../src/core/journal/fingerprint");
 const store_1 = require("../../../src/core/journal/store");
 const paths_1 = require("../../../src/core/journal/paths");
+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' });
 }
@@ -283,7 +300,7 @@ describe('Supervisor.tick() — freeze de un track individual (R5.2/R6.3)', () =
             payload: { verdictId, obligationId, result: 'pass', detail: 'ok', fingerprint: fp, argv, paths: [], cwd: '.' } });
     }
     function setUpGreenTrack() {
-        (0, init_1.initWatch)(repo, BRANCH);
+        initCompactWatch(repo, BRANCH);
         // `initWatch` ESCRIBE `.gitignore` (`.awm/`) pero no lo commitea — un
         // `.gitignore` sin trackear es en sí mismo un path "untracked" para
         // `git status --porcelain` (R6.4's chequeo de limpieza no distingue
@@ -328,7 +345,7 @@ describe('Supervisor.tick() — freeze de un track individual (R5.2/R6.3)', () =
     test('freeze completo: drena jobs vivos, exige gate local + worktree limpio, termina la generación propia, persiste frozen (R5.2/R6.3)', async () => {
         setUpGreenTrack(); // sin freeze todavía: el track hace su trabajo real primero, como en el mundo real
         const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, tickMs: 10, provider: 'codex' };
-        const sup = new supervisor_1.Supervisor(repo, BRANCH, cfg, fakeSpawner);
+        const sup = new supervisor_1.Supervisor(repo, BRANCH, cfg, fakeSpawner, undefined, admitted);
         // Drenar el trabajo real (2 jobs) ANTES de que el plan pida el
         // freeze — mismo orden que el mundo real (freeze llega cuando el
         // track ya terminó su verificación).
@@ -351,7 +368,7 @@ describe('Supervisor.tick() — freeze de un track individual (R5.2/R6.3)', () =
     test('job varado en spawn-intent con refs muertas justo al pedirse el freeze SI se reintenta y drena — el freeze converge en vez de quedar en `continue` para siempre (regresión R6.3: `dispatch:false` no debe suprimir retry-same-intent)', async () => {
         setUpGreenTrack();
         const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, tickMs: 10, provider: 'codex' };
-        const sup = new supervisor_1.Supervisor(repo, BRANCH, cfg, fakeSpawner);
+        const sup = new supervisor_1.Supervisor(repo, BRANCH, cfg, fakeSpawner, undefined, admitted);
         await tickUntil(sup, () => {
             const s = (0, store_1.readJournal)(repo, BRANCH).state;
             return Object.values(s.jobs).length === 2 && Object.values(s.jobs).every((j) => j.executionState === 'exited' && j.verdict === 'pass');
@@ -365,10 +382,11 @@ describe('Supervisor.tick() — freeze de un track individual (R5.2/R6.3)', () =
         // `setUpGreenTrack`) — lo unico que debe bloquear la convergencia
         // del freeze es que siga contando como LIVE en `attemptFreeze`.
         const dead = { pid: 999999, startTime: 'gone', spawnNonce: 'stuck-nonce', argvDigest: 'd', processGroup: 999999, psArgsDigest: 'x' };
+        const fingerprint = (0, fingerprint_1.computeFingerprint)(repo, ['node', '-e', 'process.exit(0)'], [], '.');
         const s1 = (0, store_1.readJournal)(repo, BRANCH).state;
         s1.jobs['stuck-job'] = {
-            id: 'stuck-job', fingerprint: 'fp', commandDigest: 'cd', argv: ['node', '-e', 'process.exit(0)'], cwd: '.',
-            paths: [], expandedPaths: [], executionState: 'spawn-intent', observationState: 'progressing',
+            id: 'stuck-job', fingerprint: fingerprint.fingerprint, commandDigest: fingerprint.commandDigest, argv: ['node', '-e', 'process.exit(0)'], cwd: '.',
+            paths: [], expandedPaths: fingerprint.expandedPaths, executionState: 'spawn-intent', observationState: 'progressing',
             spawnNonce: 'stuck-nonce', processRef: dead, wrapperRef: dead,
             phaseTimestamps: { received: new Date(Date.now() - 120000).toISOString(), 'spawn-intent': new Date(Date.now() - 120000).toISOString() },
         };
@@ -389,7 +407,7 @@ describe('Supervisor.tick() — freeze de un track individual (R5.2/R6.3)', () =
         expect(final.frozen.headSha).toBe((0, child_process_1.execFileSync)('git', ['rev-parse', 'HEAD'], { cwd: repo, encoding: 'utf8' }).trim());
     });
     test('deja de despachar trabajo NUEVO mientras el freeze está pendiente: un job-request llega pero no se spawnea (paso 1)', async () => {
-        (0, init_1.initWatch)(repo, BRANCH);
+        initCompactWatch(repo, BRANCH);
         const s = (0, store_1.readJournal)(repo, BRANCH).state;
         s.trackContext = { trackId: 'a', taskIds: [], planDigest: '', baseSha: 'seed', planJournalId: 'j-plan' };
         (0, store_1.writeJournal)(repo, BRANCH, s);
@@ -397,7 +415,7 @@ describe('Supervisor.tick() — freeze de un track individual (R5.2/R6.3)', () =
         let spawnCalls = 0;
         const countingSpawner = () => { spawnCalls++; };
         const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, tickMs: 10, provider: 'codex' };
-        const sup = new supervisor_1.Supervisor(repo, BRANCH, cfg, countingSpawner);
+        const sup = new supervisor_1.Supervisor(repo, BRANCH, cfg, countingSpawner, undefined, admitted);
         await sup.tick(); // consume el freeze-request => freezeRequested:true
         (0, request_1.requestJob)(repo, BRANCH, 'g0', ['node', '-e', 'process.exit(0)'], [], '.');
         await sup.tick();
@@ -407,36 +425,31 @@ describe('Supervisor.tick() — freeze de un track individual (R5.2/R6.3)', () =
         expect(after.freezeRequested).toBe(true);
         expect(Object.values(after.jobs)[0].executionState).toBe('received'); // nunca avanzó a spawn-intent
     });
-    test('worktree sucio bloquea la finalización del freeze hasta que se commitea (paso 4)', async () => {
+    test('worktree sucio observado en modo compacto entra en custodia y no congela evidencia potencialmente stale', async () => {
         setUpGreenTrack();
         const cfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, tickMs: 10, provider: 'codex' };
-        const sup = new supervisor_1.Supervisor(repo, BRANCH, cfg, fakeSpawner);
+        const sup = new supervisor_1.Supervisor(repo, BRANCH, cfg, fakeSpawner, undefined, admitted);
         await tickUntil(sup, () => {
             const s = (0, store_1.readJournal)(repo, BRANCH).state;
             return Object.values(s.jobs).length === 2 && Object.values(s.jobs).every((j) => j.executionState === 'exited' && j.verdict === 'pass');
         });
         requestFreeze();
+        // Los jobs ya terminados no participan del guard de árbol de recovery.
+        // Este intento vivo, fuera del plan de verificación, aísla el hecho
+        // relevante: el cambio posterior invalida SU fingerprint y debe
+        // bloquear antes de intentar congelar.
+        const fingerprint = (0, fingerprint_1.computeFingerprint)(repo, ['node', '-e', 'process.exit(0)'], [], '.');
+        const state = (0, store_1.readJournal)(repo, BRANCH).state;
+        state.jobs['fingerprint-sentinel'] = {
+            id: 'fingerprint-sentinel', fingerprint: fingerprint.fingerprint, commandDigest: fingerprint.commandDigest,
+            argv: ['node', '-e', 'process.exit(0)'], cwd: '.', paths: [], expandedPaths: fingerprint.expandedPaths,
+            executionState: 'spawn-intent', observationState: 'progressing', phaseTimestamps: { received: new Date().toISOString(), 'spawn-intent': new Date().toISOString() },
+        };
+        (0, store_1.writeJournal)(repo, BRANCH, state);
         fs_1.default.writeFileSync(path_1.default.join(repo, 'dirty.txt'), 'sin commitear'); // untracked: worktree sucio
-        let sawFrozenWhileDirty = false;
-        for (let i = 0; i < 20; i++) {
-            const outcome = await sup.tick();
-            if (outcome === 'frozen')
-                sawFrozenWhileDirty = true;
-            await new Promise((r) => setTimeout(r, 15));
-        }
-        expect(sawFrozenWhileDirty).toBe(false);
+        expect(await sup.tick()).toBe('custody');
         expect((0, store_1.readJournal)(repo, BRANCH).state.frozen).toBeUndefined();
-        // Se resuelve lo pendiente QUITANDO el archivo sin commitear (en vez
-        // de commitearlo): commitear un archivo NUEVO cambia el árbol que
-        // las evidencias ya persistidas (`v1`/`v-sensors`) fingerprintearon,
-        // invalidándolas de verdad (`stale-fingerprint`) — comportamiento
-        // CORRECTO del gate, pero un concern DISTINTO al que este test
-        // ejercita (paso 4, limpieza — no re-vigencia de evidencia, ya
-        // cubierta en `gate.test.ts`). Quitar el archivo deja el árbol
-        // BYTE A BYTE igual al que las evidencias ya certificaron.
-        fs_1.default.rmSync(path_1.default.join(repo, 'dirty.txt'));
-        const outcome = await tickUntil(sup, () => (0, store_1.readJournal)(repo, BRANCH).state.frozen !== undefined);
-        expect(outcome).toBe('frozen');
+        expect((0, store_1.readJournal)(repo, BRANCH).state.cycle.blockedReason).toContain('git-fingerprint-changed');
     });
 });
 // --- Parte 3: loop end-to-end de DOS Supervisors reales ---------------------
@@ -512,7 +525,7 @@ describe('loop end-to-end: plan (reconcileTracks) + track (Supervisor.tick) cier
     }
     test('reconcileTracks real (plan) + Supervisor.tick real (track), en loop contra dos worktrees reales, cierran request -> drenaje -> persist -> observación -> FROZEN', async () => {
         // --- lado TRACK: registrar el trabajo y drenarlo con un Supervisor REAL ---
-        (0, init_1.initWatch)(trackWorktree, TRACK_BRANCH);
+        initCompactWatch(trackWorktree, TRACK_BRANCH);
         const ts0 = (0, store_1.readJournal)(trackWorktree, TRACK_BRANCH).state;
         ts0.trackContext = { trackId: 'a', taskIds: ['T1'], planDigest: '', baseSha, planJournalId: 'j-plan' };
         (0, store_1.writeJournal)(trackWorktree, TRACK_BRANCH, ts0);
@@ -525,7 +538,7 @@ describe('loop end-to-end: plan (reconcileTracks) + track (Supervisor.tick) cier
         (0, requests_1.emitRequest)(trackWorktree, TRACK_BRANCH, { kind: 'register-entity', generationToken: 'g0', idempotencyKey: 'e3',
             payload: { entity: 'task-status', taskId: 'T1', status: 'done' } });
         const trackCfg = { ...supervisor_1.DEFAULT_SUPERVISOR_CONFIG, tickMs: 10, provider: 'codex' };
-        const trackSup = new supervisor_1.Supervisor(trackWorktree, TRACK_BRANCH, trackCfg, fakeSpawner);
+        const trackSup = new supervisor_1.Supervisor(trackWorktree, TRACK_BRANCH, trackCfg, fakeSpawner, undefined, admitted);
         for (let i = 0; i < 400; i++) {
             const s = (0, store_1.readJournal)(trackWorktree, TRACK_BRANCH).state;
             if (Object.values(s.jobs).length === 2 && Object.values(s.jobs).every((j) => j.executionState === 'exited' && j.verdict === 'pass'))

package/dist/tests/commands/watch/track-state-dependency.test.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const watchRoot = path_1.default.resolve(__dirname, '../../../src/commands/watch');
+describe('watch state dependency boundary', () => {
+    test('teardown driver consumes shared state through the neutral track-state module', () => {
+        const source = fs_1.default.readFileSync(path_1.default.join(watchRoot, 'teardown-driver.ts'), 'utf8');
+        expect(source).toContain("from './track-state'");
+        expect(source).not.toMatch(/from '\.\/tracks';/);
+    });
+});

package/dist/tests/commands/watch/watch-init.test.js

@@ -6,8 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
+const child_process_1 = require("child_process");
+const commander_1 = require("commander");
 const init_1 = require("../../../src/commands/watch/init");
+const watch_1 = require("../../../src/commands/watch");
 const store_1 = require("../../../src/core/journal/store");
+const paths_1 = require("../../../src/core/journal/paths");
+const validate_1 = require("../../../src/core/plan/validate");
+const git_fixture_1 = require("../../helpers/git-fixture");
 describe('watch --init: plan-vs-repo mecanico', () => {
     let repo;
     beforeEach(() => { repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-init-')); });
@@ -32,6 +38,117 @@ describe('watch --init: plan-vs-repo mecanico', () => {
     test('repo sin verificadores => lista vacia (el gate degrada por empty-cycle-plan igualmente, R3.6)', () => {
         expect((0, init_1.detectRequiredVerifiers)(repo)).toEqual([]);
     });
+    test('falla cerradamente ante un arbol de paquetes demasiado profundo o grande', () => {
+        let cursor = repo;
+        for (let depth = 0; depth < 65; depth++) {
+            cursor = path_1.default.join(cursor, `d${depth}`);
+            fs_1.default.mkdirSync(cursor);
+        }
+        expect(() => (0, init_1.detectRequiredVerifiers)(repo)).toThrow(/límite|limit/i);
+    });
+    test('falla cerradamente ante package.json que excede el límite de lectura', () => {
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'package.json'), '{"scripts":{"test":"x"},"padding":"' + 'x'.repeat(1024 * 1024) + '"}');
+        expect(() => (0, init_1.detectRequiredVerifiers)(repo)).toThrow(/package\.json.*(?:límite|limit|oversized)/i);
+    });
+    test('falla cerradamente al superar el límite de entradas del escaneo', () => {
+        for (let index = 0; index <= 10000; index++)
+            fs_1.default.writeFileSync(path_1.default.join(repo, `entry-${index}`), '');
+        expect(() => (0, init_1.detectRequiredVerifiers)(repo)).toThrow(/entry limit/i);
+    });
+    test('falla cerradamente ante un package.json ilegible o malformado', () => {
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'package.json'), '{not json');
+        expect(() => (0, init_1.detectRequiredVerifiers)(repo)).toThrow(/rejected package\.json/i);
+    });
+    test.each(['growth', 'leaf-swap', 'parent-swap'])('rejects stale Dirent %s before journal or gitignore mutations', attack => {
+        const directory = attack === 'parent-swap' ? path_1.default.join(repo, 'child') : repo;
+        fs_1.default.mkdirSync(directory, { recursive: true });
+        const packageFile = path_1.default.join(directory, 'package.json');
+        fs_1.default.writeFileSync(packageFile, '{"scripts":{"test":"jest"}}');
+        const outside = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-init-outside-'));
+        fs_1.default.writeFileSync(path_1.default.join(outside, 'package.json'), '{"scripts":{"test":"outside-command"}}');
+        fs_1.default.writeFileSync(path_1.default.join(repo, '.gitignore'), 'existing-rule\n');
+        const nativeReaddir = fs_1.default.readdirSync;
+        const nativeStat = fs_1.default.statSync;
+        let attacked = false;
+        const stat = jest.spyOn(fs_1.default, 'statSync').mockImplementation(((...args) => {
+            if (String(args[0]) === packageFile && attack === 'growth')
+                return { size: 2 };
+            return Reflect.apply(nativeStat, fs_1.default, args);
+        }));
+        const readdir = jest.spyOn(fs_1.default, 'readdirSync').mockImplementation(((...args) => {
+            const entries = Reflect.apply(nativeReaddir, fs_1.default, args);
+            if (!attacked && String(args[0]) === directory) {
+                attacked = true;
+                if (attack === 'growth')
+                    fs_1.default.writeFileSync(packageFile, JSON.stringify({ scripts: { test: 'jest' }, padding: 'x'.repeat(256 * 1024) }));
+                else if (attack === 'leaf-swap') {
+                    fs_1.default.renameSync(packageFile, `${packageFile}.original`);
+                    fs_1.default.symlinkSync(path_1.default.join(outside, 'package.json'), packageFile, 'file');
+                }
+                else {
+                    fs_1.default.renameSync(directory, `${directory}.original`);
+                    fs_1.default.symlinkSync(outside, directory, 'dir');
+                }
+            }
+            return entries;
+        }));
+        try {
+            expect(() => (0, init_1.initWatch)(repo, 'rama')).toThrow(/package\.json|bounded|regular|unsafe/i);
+            expect(attacked).toBe(true);
+            expect(fs_1.default.readFileSync(path_1.default.join(repo, '.gitignore'), 'utf8')).toBe('existing-rule\n');
+            expect((0, store_1.readJournal)(repo, 'rama').state).toBeNull();
+        }
+        finally {
+            stat.mockRestore();
+            readdir.mockRestore();
+            fs_1.default.rmSync(outside, { recursive: true, force: true });
+        }
+    });
+    test.each(['symlink', 'directory'])('rejects an explicitly declared nonregular package.json %s rather than treating it as absence', kind => {
+        const packageFile = path_1.default.join(repo, 'package.json');
+        if (kind === 'directory')
+            fs_1.default.mkdirSync(packageFile);
+        else {
+            fs_1.default.writeFileSync(path_1.default.join(repo, 'outside-package'), '{}');
+            fs_1.default.symlinkSync(path_1.default.join(repo, 'outside-package'), packageFile, 'file');
+        }
+        fs_1.default.writeFileSync(path_1.default.join(repo, '.gitignore'), 'unchanged\n');
+        expect(() => (0, init_1.initWatch)(repo, 'rama')).toThrow(/package\.json|regular/i);
+        expect(fs_1.default.readFileSync(path_1.default.join(repo, '.gitignore'), 'utf8')).toBe('unchanged\n');
+        expect((0, store_1.readJournal)(repo, 'rama').state).toBeNull();
+    });
+    test.each(['symlink', 'dangling-link', 'directory', 'oversized', 'malformed'])('rejects unsafe sibling sensors.json %s before init mutations', fault => {
+        fs_1.default.mkdirSync(path_1.default.join(repo, '.awm'));
+        const sensors = path_1.default.join(repo, '.awm', 'sensors.json');
+        if (fault === 'directory')
+            fs_1.default.mkdirSync(sensors);
+        else if (fault === 'symlink' || fault === 'dangling-link') {
+            const destination = path_1.default.join(repo, 'outside-sensors');
+            if (fault === 'symlink')
+                fs_1.default.writeFileSync(destination, '{}');
+            fs_1.default.symlinkSync(destination, sensors, 'file');
+        }
+        else
+            fs_1.default.writeFileSync(sensors, fault === 'oversized' ? ' '.repeat(256 * 1024 + 1) : '{bad json');
+        fs_1.default.writeFileSync(path_1.default.join(repo, '.gitignore'), 'unchanged\n');
+        expect(() => (0, init_1.initWatch)(repo, 'rama')).toThrow(/sensors\.json/i);
+        expect(fs_1.default.readFileSync(path_1.default.join(repo, '.gitignore'), 'utf8')).toBe('unchanged\n');
+        expect((0, store_1.readJournal)(repo, 'rama').state).toBeNull();
+    });
+    test('falla cerradamente cuando no puede leer un directorio durante el escaneo', () => {
+        const original = fs_1.default.readdirSync;
+        const readdir = jest.spyOn(fs_1.default, 'readdirSync').mockImplementation(((target, options) => {
+            if (String(target) === repo)
+                throw new Error('EACCES');
+            return original(target, options);
+        }));
+        try {
+            expect(() => (0, init_1.detectRequiredVerifiers)(repo)).toThrow(/cannot read/i);
+        }
+        finally {
+            readdir.mockRestore();
+        }
+    });
     test('initWatch persiste requiredVerifiers y gitignorea el journal (R1.1/R1.4b)', () => {
         fs_1.default.writeFileSync(path_1.default.join(repo, 'package.json'), JSON.stringify({ scripts: { test: 'jest' } }));
         const out = (0, init_1.initWatch)(repo, 'rama');
@@ -40,4 +157,131 @@ describe('watch --init: plan-vs-repo mecanico', () => {
         expect(fs_1.default.readFileSync(path_1.default.join(repo, '.gitignore'), 'utf8')).toContain('.awm/');
         expect(() => (0, init_1.initWatch)(repo, 'rama')).not.toThrow(); // idempotente
     });
+    test('no escribe .gitignore cuando es un symlink', () => {
+        const outside = path_1.default.join(repo, 'outside-gitignore');
+        fs_1.default.writeFileSync(outside, 'outside\n');
+        fs_1.default.symlinkSync(outside, path_1.default.join(repo, '.gitignore'));
+        expect(() => (0, init_1.initWatch)(repo, 'rama')).toThrow(/gitignore.*symlink|symlink.*gitignore/i);
+        expect(fs_1.default.readFileSync(outside, 'utf8')).toBe('outside\n');
+    });
+    test('watch --init --plan crea una sola vinculacion schema-2 desatendida', () => {
+        const plan = {
+            state: 'valid', schema: 'compact-slices/v1', planDigest: 'a'.repeat(64),
+            executionMode: 'desatendido',
+            manifest: { schema: 'compact-slices/v1', planId: 'fixture', requirements: [], sources: [], commands: [], slices: [], closureCommands: [] },
+        };
+        const out = (0, init_1.initWatch)(repo, 'rama', { path: 'docs/plan.md', report: plan });
+        expect(out.planBinding).toEqual(expect.objectContaining({ path: 'docs/plan.md', digest: 'a'.repeat(64), schema: 'compact-slices/v1', executionMode: 'desatendido' }));
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(state.schema).toBe(2);
+        expect(state.planBinding).toEqual(expect.objectContaining({ path: 'docs/plan.md', digest: 'a'.repeat(64) }));
+        expect(() => (0, init_1.initWatch)(repo, 'rama', { path: 'docs/plan.md', report: plan })).toThrow(/sobrescribir|overwrite/i);
+    });
+    test('watch --init --plan bloquea un plan no valido antes de crear journal', () => {
+        const invalid = { state: 'invalid', diagnostics: [{ code: 'PLAN_SHAPE', message: 'bad' }] };
+        expect(() => (0, init_1.initWatch)(repo, 'rama', { path: 'docs/plan.md', report: invalid })).toThrow(/válido/i);
+        expect((0, store_1.readJournal)(repo, 'rama').corrupt).toBe(true);
+    });
+    test('watch --init --plan rechaza un plan interactivo antes de crear un binding desatendido', () => {
+        const interactive = { ...validPlan('a'), executionMode: 'interactivo' };
+        expect(() => (0, init_1.initWatch)(repo, 'rama', { path: 'docs/plan.md', report: interactive })).toThrow(/desatendido/i);
+        expect((0, store_1.readJournal)(repo, 'rama').state).toBeNull();
+    });
+    test('watch --init --plan rechaza paths con caracteres de control antes de persistir', () => {
+        const report = { state: 'valid', schema: 'compact-slices/v1', planDigest: 'a'.repeat(64), executionMode: 'desatendido', manifest: {} };
+        expect(() => (0, init_1.initWatch)(repo, 'rama', { path: 'docs/plan\u0000.md', report })).toThrow(/path inválido/);
+        expect((0, store_1.readJournal)(repo, 'rama').state).toBeNull();
+    });
+    test('rebind no atribuye prueba nueva a un binding legacy aunque el ciclo diga COMPLETE', () => {
+        const original = validPlan('a');
+        (0, init_1.initWatch)(repo, 'rama', { path: 'docs/plan.md', report: original });
+        const completed = (0, store_1.readJournal)(repo, 'rama').state;
+        completed.cycle.status = 'COMPLETE';
+        delete completed.cycle.nextAction;
+        (0, store_1.writeJournal)(repo, 'rama', completed);
+        const before = (0, store_1.readJournal)(repo, 'rama').raw;
+        expect(() => (0, init_1.rebindWatchPlan)(repo, 'rama', { path: 'docs/plan.md', report: validPlan('b') })).toThrow(/sin prueba/i);
+        expect((0, store_1.readJournal)(repo, 'rama').raw).toBe(before);
+        expect(fs_1.default.existsSync((0, paths_1.supervisorLockPath)(repo))).toBe(false);
+    });
+    test('rebind rechaza un ciclo en curso y conserva toda su evidencia ligada al digest anterior', () => {
+        (0, init_1.initWatch)(repo, 'rama', { path: 'docs/plan.md', report: validPlan('a') });
+        const before = (0, store_1.readJournal)(repo, 'rama').raw;
+        expect(() => (0, init_1.rebindWatchPlan)(repo, 'rama', { path: 'docs/plan.md', report: validPlan('b') })).toThrow(/ciclo.*curso/i);
+        expect((0, store_1.readJournal)(repo, 'rama').raw).toBe(before);
+    });
+    test('rebind rechaza una ruta canónica distinta y deja el journal byte-a-byte intacto', () => {
+        (0, init_1.initWatch)(repo, 'rama', { path: 'docs/plan.md', report: validPlan('a') });
+        const before = (0, store_1.readJournal)(repo, 'rama').raw;
+        expect(() => (0, init_1.rebindWatchPlan)(repo, 'rama', { path: 'docs/other.md', report: validPlan('b') })).toThrow(/misma ruta/i);
+        expect((0, store_1.readJournal)(repo, 'rama').raw).toBe(before);
+    });
+    test('rebind rechaza un binding ya vigente y no inventa historia duplicada', () => {
+        (0, init_1.initWatch)(repo, 'rama', { path: 'docs/plan.md', report: validPlan('a') });
+        const before = (0, store_1.readJournal)(repo, 'rama').raw;
+        expect(() => (0, init_1.rebindWatchPlan)(repo, 'rama', { path: 'docs/plan.md', report: validPlan('a') })).toThrow(/ya está vigente/i);
+        expect((0, store_1.readJournal)(repo, 'rama').raw).toBe(before);
+    });
+    test('rebind rechaza evidencia adversa durable y no reescribe el binding obsoleto', () => {
+        (0, init_1.initWatch)(repo, 'rama', { path: 'docs/plan.md', report: validPlan('a') });
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.verdicts.push({ id: 'v-1', obligationId: 'o-1', result: 'fail', detail: 'adverso', receivedAt: new Date().toISOString(), fingerprint: '', argv: [], paths: [], cwd: '.' });
+        (0, store_1.writeJournal)(repo, 'rama', state);
+        expect(() => (0, init_1.rebindWatchPlan)(repo, 'rama', { path: 'docs/plan.md', report: validPlan('b') })).toThrow(/evidencia adversa/i);
+        expect((0, store_1.readJournal)(repo, 'rama').state.planBinding.digest).toBe('a'.repeat(64));
+    });
+    test('rebind rechaza jobs no terminales y conserva el estado recuperable', () => {
+        (0, init_1.initWatch)(repo, 'rama', { path: 'docs/plan.md', report: validPlan('a') });
+        const state = (0, store_1.readJournal)(repo, 'rama').state;
+        state.jobs.pending = { id: 'pending', fingerprint: '', commandDigest: '', argv: [], cwd: '.', paths: [], expandedPaths: [], executionState: 'received', observationState: 'progressing', phaseTimestamps: {} };
+        (0, store_1.writeJournal)(repo, 'rama', state);
+        const before = (0, store_1.readJournal)(repo, 'rama').raw;
+        expect(() => (0, init_1.rebindWatchPlan)(repo, 'rama', { path: 'docs/plan.md', report: validPlan('b') })).toThrow(/no terminales/i);
+        expect((0, store_1.readJournal)(repo, 'rama').raw).toBe(before);
+        expect(fs_1.default.existsSync((0, paths_1.supervisorLockPath)(repo))).toBe(false);
+    });
+    test('help declara rebind como ruta intencional separada de --init', () => {
+        const program = new commander_1.Command();
+        (0, watch_1.registerWatchCommand)(program);
+        const watch = program.commands.find(command => command.name() === 'watch');
+        expect(watch.helpInformation()).toContain('rebind');
+        expect(watch.commands.find(command => command.name() === 'rebind').description()).toMatch(/reconcilia/i);
+    });
+    test('CLI compilado acepta exactamente `watch rebind --plan` y reconcilia el digest', () => {
+        const cliRepo = (0, git_fixture_1.initRepo)();
+        try {
+            const planPath = path_1.default.join(cliRepo, 'docs', 'plan.md');
+            fs_1.default.mkdirSync(path_1.default.dirname(planPath), { recursive: true });
+            const plan = `**Modo de ejecución:** desatendido\n\n${fs_1.default.readFileSync(path_1.default.join(__dirname, '../../core/plan/fixtures/compact-slices-v1/valid.md'), 'utf8')}`;
+            fs_1.default.writeFileSync(planPath, plan);
+            fs_1.default.writeFileSync(path_1.default.join(cliRepo, 'source.md'), '## Canonical source\nfixture source\n');
+            (0, init_1.initWatch)(cliRepo, 'main', { path: 'docs/plan.md', report: validatePlan(cliRepo, 'docs/plan.md') });
+            fs_1.default.appendFileSync(planPath, '<!-- awm-qa-complete: 2026-09-16 -->\n');
+            const result = (0, child_process_1.spawnSync)(process.execPath, [path_1.default.resolve(__dirname, '../../../dist/src/index.js'), 'watch', 'rebind', '--plan', 'docs/plan.md'], {
+                cwd: cliRepo, encoding: 'utf8', env: { ...process.env, AWM_NO_UPDATE_CHECK: '1' },
+            });
+            expect(result.status).toBe(0);
+            expect(result.stderr).not.toContain('required option');
+            expect((0, store_1.readJournal)(cliRepo, 'main').state.planBinding.digest).toBe(validatePlan(cliRepo, 'docs/plan.md').planDigest);
+            expect((0, store_1.readJournal)(cliRepo, 'main').state.cycle.status).toBe('IN_PROGRESS');
+        }
+        finally {
+            fs_1.default.rmSync(cliRepo, { recursive: true, force: true });
+        }
+    });
 });
+function validPlan(digestCharacter) {
+    return {
+        state: 'valid', schema: 'compact-slices/v1', planDigest: digestCharacter.repeat(64),
+        executionMode: 'desatendido',
+        manifest: { schema: 'compact-slices/v1', planId: 'fixture', requirements: [], sources: [], commands: [], slices: [], closureCommands: [] },
+    };
+}
+function validatePlan(repo, relativePath) {
+    // Keep the external process test tied to the real compact validator, not a
+    // hand-built report that could diverge from a lifecycle edit on disk.
+    const report = (0, validate_1.validatePlanFile)(relativePath, repo);
+    if (report.state !== 'valid')
+        throw new Error(`fixture plan unexpectedly invalid: ${JSON.stringify(report)}`);
+    return report;
+}

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const admission_1 = require("../../../src/core/admission");
+const types_1 = require("../../../src/core/journal/types");
+const valid = {
+    state: 'valid', schema: 'compact-slices/v1', planDigest: 'a'.repeat(64),
+    manifest: {
+        schema: 'compact-slices/v1', planId: 'admission-fixture', requirements: ['RF-2.2'],
+        sources: [], commands: [], closureCommands: [],
+        slices: [{ id: 'S1', title: 'one', requirements: ['RF-2.2'], dependsOn: [], sectionAnchor: 's1', sources: [], redCommands: [], greenCommands: [], reviewEvidence: ['specification', 'code-quality'], risk: 'bounded', fallback: [] }],
+    },
+};
+describe('admitPlan', () => {
+    it('rejects a forecast whose total or role topology does not match its slices', () => {
+        const forecast = { kind: 'topology', slices: 2, roles: { implementer: 2, 'specification-reviewer': 2, 'code-quality-reviewer': 2, 'final-reviewer': 1, 'track-a-qa': 1, 'track-b-qa': 1, documentation: 1, retro: 1, finishing: 1 }, total: 99 };
+        expect(() => (0, admission_1.sanitizeAdmissionReport)({ state: 'admitted', planState: 'valid', journal: 'not-required', currentness: 'not-checked', sensors: 'not-required', diagnostics: [], forecast })).toThrow(/invalid report/);
+        forecast.total = 12;
+        forecast.roles.implementer = 1;
+        expect(() => (0, admission_1.sanitizeAdmissionReport)({ state: 'admitted', planState: 'valid', journal: 'not-required', currentness: 'not-checked', sensors: 'not-required', diagnostics: [], forecast })).toThrow(/invalid report/);
+    });
+    it('preserves the distinct unsupported plan state and bounded validator diagnostic', async () => {
+        const report = await (0, admission_1.admitPlan)({ plan: { state: 'unsupported', schema: 'compact-slices/v9', diagnostics: [{ code: 'PLAN_UNSUPPORTED_SCHEMA', message: `future\u001b${'x'.repeat(5000)}` }] }, provider: 'codex', cwd: process.cwd() });
+        expect(report).toMatchObject({ state: 'blocked', planState: 'unsupported', currentness: 'not-checked', sensors: 'not-required' });
+        expect(report.diagnostics.map(diagnostic => diagnostic.code)).toEqual(['ADMISSION_PLAN_UNSUPPORTED', 'PLAN_UNSUPPORTED_SCHEMA']);
+        expect(report.diagnostics[1].message).toHaveLength(4096);
+        expect(report.diagnostics[1].message).not.toMatch(/[\u0000-\u001f\u007f-\u009f]/);
+    });
+    it('does not block a private registry only when declared plan provenance proves it unconsumed', async () => {
+        const report = await (0, admission_1.admitPlan)({
+            plan: valid, provider: 'codex', cwd: process.cwd(), enabledAgents: ['codex'], requireCurrent: true,
+            currentness: { checkedAt: '2026-01-01T00:00:00.000Z', compatibility: { status: 'not-checked' }, components: [
+                    { component: 'cli', installed: '1.0.0', latest: '1.0.0', channel: 'stable', source: 'npm', checkedAt: '2026-01-01T00:00:00.000Z', status: 'current', detail: 'ok', remedy: 'none' },
+                    { component: 'registry:private', installed: null, latest: null, channel: 'stable', source: 'private', checkedAt: '2026-01-01T00:00:00.000Z', status: 'unverifiable', detail: 'no', remedy: 'none' },
+                ] },
+            consumedRegistryComponents: [], provenance: 'proven',
+        });
+        expect(report).toMatchObject({ state: 'admitted', currentness: 'current', sensors: 'not-required' });
+    });
+    it('blocks currentness when registry-contract provenance is not sufficient to prove irrelevance', async () => {
+        const report = await (0, admission_1.admitPlan)({ plan: valid, provider: 'codex', cwd: process.cwd(), enabledAgents: ['codex'], requireCurrent: true, currentness: { checkedAt: 'x', compatibility: { status: 'not-checked' }, components: [] } });
+        expect(report).toMatchObject({ state: 'blocked', currentness: 'unverifiable', sensors: 'not-required' });
+        expect(report.diagnostics[0].code).toBe('ADMISSION_CURRENTNESS_PROVENANCE_REQUIRED');
+    });
+    it('blocks when a proven consumed registry has no currentness component', async () => {
+        const report = await (0, admission_1.admitPlan)({ plan: valid, provider: 'codex', cwd: process.cwd(), enabledAgents: ['codex'], requireCurrent: true, provenance: 'proven', consumedRegistryComponents: ['registry:private'], currentness: { checkedAt: 'x', compatibility: { status: 'not-checked' }, components: [{ component: 'cli', installed: '1.0.0', latest: '1.0.0', channel: 'stable', source: 'npm', checkedAt: 'x', status: 'current', detail: 'ok', remedy: 'none' }] } });
+        expect(report).toMatchObject({ state: 'blocked', currentness: 'unverifiable' });
+        expect(report.diagnostics[0].code).toBe('ADMISSION_CURRENTNESS_MISSING_COMPONENT');
+    });
+    it('blocks a bogus execution mode instead of treating it as interactive', async () => {
+        const report = await (0, admission_1.admitPlan)({ plan: valid, provider: 'codex', cwd: process.cwd(), enabledAgents: ['codex'], executionMode: 'background' });
+        expect(report).toMatchObject({ state: 'blocked', executionMode: 'interactivo' });
+        expect(report.diagnostics[0].code).toBe('ADMISSION_EXECUTION_MODE_INVALID');
+    });
+    it('stops at an unmarked plan before checking any later boundary', async () => {
+        const report = await (0, admission_1.admitPlan)({ plan: { state: 'migration-required', reason: 'unmarked-plan' }, provider: 'codex', cwd: process.cwd() });
+        expect(report).toMatchObject({ state: 'blocked', planState: 'migration-required', journal: 'not-required' });
+        expect(report.diagnostics[0].code).toBe('ADMISSION_PLAN_MIGRATION_REQUIRED');
+        expect(report.currentness).toBe('not-checked');
+        expect(report.sensors).toBe('not-required');
+    });
+    it('blocks a disabled provider before remote currentness or sensors', async () => {
+        const report = await (0, admission_1.admitPlan)({ plan: valid, provider: 'codex', cwd: process.cwd(), enabledAgents: ['claude-code'] });
+        expect(report).toMatchObject({ state: 'blocked', planDigest: valid.planDigest, provider: 'codex' });
+        expect(report.diagnostics[0].code).toBe('ADMISSION_PROVIDER_DISABLED');
+        expect(report.currentness).toBe('not-checked');
+    });
+    it('does not let an unverified execution capability admit interactive work', async () => {
+        const report = await (0, admission_1.admitPlan)({ plan: valid, provider: 'cursor', cwd: process.cwd(), enabledAgents: ['cursor'] });
+        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();
+    });
+    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' } };
+        const admitted = await (0, admission_1.admitPlan)({ plan: unattended, provider: 'codex', cwd: process.cwd(), enabledAgents: ['codex'], journalState: journal, planPath: 'docs/plan.md' });
+        expect(admitted).toMatchObject({ state: 'admitted', journal: 'current', executionMode: 'desatendido' });
+        const stale = await (0, admission_1.admitPlan)({ plan: unattended, provider: 'codex', cwd: process.cwd(), enabledAgents: ['codex'], journalState: { ...journal, planBinding: { ...journal.planBinding, digest: 'b'.repeat(64) } }, planPath: 'docs/plan.md' });
+        expect(stale).toMatchObject({ state: 'blocked', journal: 'stale' });
+    });
+});

package/dist/tests/core/bundle-install.test.js

@@ -41,6 +41,7 @@ const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const bundles_1 = require("../../src/core/bundles");
 const bundle_install_1 = require("../../src/core/bundle-install");
+const providers_1 = require("../../src/providers");
 const profile_1 = require("../../src/core/profile");
 const executor_1 = require("../../src/core/executor");
 const executor = __importStar(require("../../src/core/executor"));
@@ -139,6 +140,41 @@ function makeFixture() {
     return { content, projectRoot, bundles: (0, bundles_1.discoverBundles)(content) };
 }
 describe('installBundle', () => {
+    it('expands canonical and legacy manifests into byte-identical artifacts for every agent target', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-binstall-compat-'));
+        const content = path_1.default.join(root, 'registry');
+        const writeManifests = (legacy) => {
+            const skills = (names) => legacy
+                ? names.map((name, index) => ({ name, onSignal: index % 2 === 0 }))
+                : names;
+            fs_1.default.writeFileSync(path_1.default.join(content, 'bundles/base/bundle.json'), JSON.stringify({
+                name: 'base', scope: 'project', dependsOn: [],
+                skills: skills(['shared', 'base-only']), workflows: [], agents: [],
+            }));
+            fs_1.default.writeFileSync(path_1.default.join(content, 'bundles/extension/bundle.json'), JSON.stringify({
+                name: 'extension', scope: 'project', dependsOn: ['base'],
+                skills: skills(['shared', 'extension-only']), workflows: [], agents: [],
+            }));
+        };
+        for (const bundle of ['base', 'extension'])
+            fs_1.default.mkdirSync(path_1.default.join(content, 'bundles', bundle), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(content, 'catalog.json'), JSON.stringify({ bundles: [{ name: 'base', source: './bundles/base' }, { name: 'extension', source: './bundles/extension' }] }));
+        writeManifests(false);
+        const canonicalWarnings = [];
+        const legacyWarnings = [];
+        const canonicalReporter = (0, bundles_1.createBundleDiagnosticReporter)((message) => canonicalWarnings.push(message));
+        const legacyReporter = (0, bundles_1.createBundleDiagnosticReporter)((message) => legacyWarnings.push(message));
+        const canonicalBundles = (0, bundles_1.discoverBundles)(content, canonicalReporter);
+        writeManifests(true);
+        const legacyBundles = (0, bundles_1.discoverBundles)(content, legacyReporter);
+        for (const agent of providers_1.AGENT_TARGETS) {
+            const canonicalArtifacts = (0, bundle_install_1.expandBundleArtifacts)({ bundleName: 'extension', bundles: canonicalBundles, agents: [agent], method: 'copy', projectRoot: root, contentDir: content });
+            const legacyArtifacts = (0, bundle_install_1.expandBundleArtifacts)({ bundleName: 'extension', bundles: legacyBundles, agents: [agent], method: 'copy', projectRoot: root, contentDir: content });
+            expect(Buffer.from(JSON.stringify(canonicalArtifacts))).toEqual(Buffer.from(JSON.stringify(legacyArtifacts)));
+        }
+        expect(canonicalWarnings).toEqual([]);
+        expect(legacyWarnings).toHaveLength(2);
+    });
     it('materializes the bundle closure as local symlinks (deps + own skills)', () => {
         const { content, projectRoot, bundles } = makeFixture();
         const result = (0, bundle_install_1.installBundle)({