agentic-workflow-manager 6.2.1 → 6.3.0

package/dist/tests/core/journal/types.test.js

@@ -75,4 +75,93 @@ describe('journal types', () => {
         badStatus.cycle.status = 'FINISHED';
         expect((0, types_1.isWellFormedState)(badStatus)).toBe(false);
     });
+    test('emptyState genera journalId estable y único (R9.1)', () => {
+        const a = (0, types_1.emptyState)('main');
+        const b = (0, types_1.emptyState)('main');
+        expect(a.journalId).toMatch(/^j-[0-9a-f-]{36}$/);
+        expect(b.journalId).not.toBe(a.journalId);
+    });
+    test('isWellFormedState exige journalId no vacio (R9.1)', () => {
+        const bad = (0, types_1.emptyState)('x');
+        delete bad.journalId;
+        expect((0, types_1.isWellFormedState)(bad)).toBe(false);
+        bad.journalId = '';
+        expect((0, types_1.isWellFormedState)(bad)).toBe(false);
+    });
+    test('TrackRef exige intents y nonces con shape completa (R9.2, R9.7)', () => {
+        const state = (0, types_1.emptyState)('main');
+        state.tracks = [{
+                trackId: 'cli', worktreePath: '/tmp/wt', branch: 'awm-track/cli', ownership: ['cli/'],
+                sharedResources: [], dependsOn: [], fencingToken: 'f'.repeat(32), phase: 'DECLARED',
+                readinessNonce: 'r'.repeat(32),
+            }];
+        expect((0, types_1.isWellFormedState)(state)).toBe(true);
+        state.tracks[0].fencingToken = '';
+        expect((0, types_1.isWellFormedState)(state)).toBe(false);
+        state.tracks[0].fencingToken = 'f'.repeat(32);
+        state.tracks[0].readinessNonce = '';
+        expect((0, types_1.isWellFormedState)(state)).toBe(false);
+        state.tracks[0].readinessNonce = 'r'.repeat(32);
+        state.tracks[0].phase = 'NOT_A_PHASE';
+        expect((0, types_1.isWellFormedState)(state)).toBe(false);
+    });
+    test('TrackRef y TrackContext rechazan una key requerida AUSENTE, no solo vaciada (R9.2, R9.7)', () => {
+        const fullTrack = {
+            trackId: 'cli', worktreePath: '/tmp/wt', branch: 'awm-track/cli', ownership: ['cli/'],
+            sharedResources: [], dependsOn: [], fencingToken: 'f'.repeat(32), phase: 'DECLARED',
+            readinessNonce: 'r'.repeat(32),
+        };
+        // sanity: la shape completa sigue siendo valida por si misma
+        const sane = (0, types_1.emptyState)('main');
+        sane.tracks = [{ ...fullTrack }];
+        expect((0, types_1.isWellFormedState)(sane)).toBe(true);
+        for (const key of Object.keys(fullTrack)) {
+            const partial = { ...fullTrack };
+            delete partial[key]; // key AUSENTE por completo, no ''
+            const state = (0, types_1.emptyState)('main');
+            state.tracks = [partial];
+            expect((0, types_1.isWellFormedState)(state)).toBe(false);
+        }
+        const fullContext = { trackId: 'cli', taskIds: ['t1'], planDigest: 'd', baseSha: 'abc', planJournalId: 'j-plan' };
+        const saneContext = (0, types_1.emptyState)('main');
+        saneContext.trackContext = { ...fullContext };
+        expect((0, types_1.isWellFormedState)(saneContext)).toBe(true);
+        for (const key of Object.keys(fullContext)) {
+            const partial = { ...fullContext };
+            delete partial[key];
+            const state = (0, types_1.emptyState)('main');
+            state.trackContext = partial;
+            expect((0, types_1.isWellFormedState)(state)).toBe(false);
+        }
+    });
+    test('TrackRef valida intents opcionales cuando presentes (R9.2, R9.7)', () => {
+        const state = (0, types_1.emptyState)('main');
+        state.tracks = [{
+                trackId: 'cli', worktreePath: '/tmp/wt', branch: 'awm-track/cli', ownership: ['cli/'],
+                sharedResources: [], dependsOn: [], fencingToken: 'f'.repeat(32), phase: 'ARMED',
+                readinessNonce: 'r'.repeat(32),
+                supervisorIntent: { nonce: 'n', argv: ['awm', 'watch'], claimPath: '/tmp/claim' },
+                joinIntent: { expectedPlanHeadSha: 'a', expectedTrackHeadSha: 'b', strategy: 'no-ff' },
+                teardownIntent: { worktreePath: '/tmp/wt', branch: 'awm-track/cli' },
+            }];
+        expect((0, types_1.isWellFormedState)(state)).toBe(true);
+        state.tracks[0].supervisorIntent.nonce = '';
+        expect((0, types_1.isWellFormedState)(state)).toBe(false);
+    });
+    test('trackContext, cohortPhase y trackIntegration validan shape cuando presentes (R9.1, R9.3)', () => {
+        const state = (0, types_1.emptyState)('main');
+        state.trackContext = { trackId: 'cli', taskIds: ['t1'], planDigest: 'd', baseSha: 'abc', planJournalId: 'j-plan' };
+        state.cohortPhase = 'ACTIVE';
+        state.cohortBaseSha = 'abc';
+        state.trackIntegration = { argv: ['npm', 'test'], paths: ['**/*.ts'], planDigest: 'd' };
+        expect((0, types_1.isWellFormedState)(state)).toBe(true);
+        state.cohortPhase = 'NOT_A_PHASE';
+        expect((0, types_1.isWellFormedState)(state)).toBe(false);
+    });
+    test('requiredVerifiers y VerificationItem aceptan el nuevo kind track-integration (C8)', () => {
+        const state = (0, types_1.emptyState)('main');
+        state.requiredVerifiers = ['track-integration'];
+        state.cycleVerificationPlan = [{ id: 'v1', kind: 'track-integration' }];
+        expect((0, types_1.isWellFormedState)(state)).toBe(true);
+    });
 });

package/dist/tests/core/same-existing-path.test.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// El bug que motiva esto costó 18 tests en Windows y NINGUNO en Linux/macOS: comparar
+// `fs.realpathSync(a) !== fs.realpathSync(b)` como strings. En Windows el mismo directorio
+// tiene dos grafías legítimas (8.3 `RUNNER~1` vs nombre largo, backslash vs slash) y
+// `realpathSync` no las reconcilia, así que `ownedWorktreeExists` negaba un worktree propio.
+//
+// El caso 8.3 no se puede reproducir en Linux. Lo que SÍ se puede probar acá es el contrato
+// del helper — identidad por filesystem, no por texto — que es lo que hace correcto el fix.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../../src/core/paths");
+describe('sameExistingPath', () => {
+    let root;
+    beforeEach(() => { root = fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-samepath-'))); });
+    afterEach(() => { fs_1.default.rmSync(root, { recursive: true, force: true }); });
+    it('dos grafías del mismo directorio son la misma ruta', () => {
+        const real = path_1.default.join(root, 'destino');
+        fs_1.default.mkdirSync(real);
+        const alias = path_1.default.join(root, 'alias');
+        fs_1.default.symlinkSync(real, alias, 'dir');
+        // Strings distintos, mismo inode. Esta es la propiedad que el fix compra.
+        expect(alias).not.toBe(real);
+        expect((0, paths_1.sameExistingPath)(alias, real)).toBe(true);
+    });
+    it('directorios distintos NO son la misma ruta', () => {
+        const a = path_1.default.join(root, 'a');
+        const b = path_1.default.join(root, 'b');
+        fs_1.default.mkdirSync(a);
+        fs_1.default.mkdirSync(b);
+        expect((0, paths_1.sameExistingPath)(a, b)).toBe(false);
+    });
+    it('una ruta inexistente nunca "coincide" — la identidad no se afirma sin prueba', () => {
+        const a = path_1.default.join(root, 'a');
+        fs_1.default.mkdirSync(a);
+        expect((0, paths_1.sameExistingPath)(a, path_1.default.join(root, 'fantasma'))).toBe(false);
+        expect((0, paths_1.sameExistingPath)(path_1.default.join(root, 'fantasma'), path_1.default.join(root, 'fantasma'))).toBe(false);
+    });
+    it('sobrevive a separadores y segmentos redundantes', () => {
+        const a = path_1.default.join(root, 'a');
+        fs_1.default.mkdirSync(a);
+        expect((0, paths_1.sameExistingPath)(a, path_1.default.join(root, '.', 'a', '..', 'a'))).toBe(true);
+    });
+});

package/dist/tests/core/tracks/concurrency.test.js

@@ -0,0 +1,134 @@
+"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 os_1 = __importDefault(require("os"));
+const concurrency_1 = require("../../../src/core/tracks/concurrency");
+describe('deriveDefaultParallelism (R10.3)', () => {
+    test('elige el mayor N con p95 <= 1.5x y costo <=20% del tick', () => {
+        expect((0, concurrency_1.deriveDefaultParallelism)({
+            cpuCount: 8, tickMs: 5000,
+            samples: [
+                { supervisors: 1, p95Ms: 100 }, { supervisors: 2, p95Ms: 130 },
+                { supervisors: 3, p95Ms: 149 }, { supervisors: 4, p95Ms: 170 },
+            ],
+        })).toBe(3);
+    });
+    test('si ninguna medición habilita N>1 queda serial (R10.2)', () => {
+        expect((0, concurrency_1.deriveDefaultParallelism)({
+            cpuCount: 2, tickMs: 100,
+            samples: [{ supervisors: 1, p95Ms: 90 }, { supervisors: 2, p95Ms: 180 }],
+        })).toBe(1);
+    });
+    test('cpuCount:1 acota el tope aunque el costo esté dentro de budget', () => {
+        expect((0, concurrency_1.deriveDefaultParallelism)({
+            cpuCount: 1, tickMs: 5000,
+            samples: [{ supervisors: 1, p95Ms: 100 }, { supervisors: 2, p95Ms: 105 }],
+        })).toBe(1);
+    });
+    test('ignora muestras que excedan cpuCount', () => {
+        expect((0, concurrency_1.deriveDefaultParallelism)({
+            cpuCount: 2, tickMs: 5000,
+            samples: [
+                { supervisors: 1, p95Ms: 100 }, { supervisors: 2, p95Ms: 110 },
+                { supervisors: 3, p95Ms: 115 },
+            ],
+        })).toBe(2);
+    });
+    test('lanza sobre budget sin baseline N=1', () => {
+        expect(() => (0, concurrency_1.deriveDefaultParallelism)({ cpuCount: 4, tickMs: 5000, samples: [{ supervisors: 2, p95Ms: 10 }] }))
+            .toThrow(/baseline/);
+    });
+    test('lanza sobre budget inválido (cpuCount no entero o sin samples)', () => {
+        expect(() => (0, concurrency_1.deriveDefaultParallelism)({ cpuCount: 0, tickMs: 5000, samples: [{ supervisors: 1, p95Ms: 10 }] }))
+            .toThrow(/inválido/);
+        expect(() => (0, concurrency_1.deriveDefaultParallelism)({ cpuCount: 4, tickMs: 5000, samples: [] })).toThrow(/inválido/);
+    });
+});
+describe('parseMaxParallel', () => {
+    test('acepta enteros >= 1', () => {
+        expect((0, concurrency_1.parseMaxParallel)('1')).toBe(1);
+        expect((0, concurrency_1.parseMaxParallel)('4')).toBe(4);
+    });
+    test('rechaza 0, negativos, no-enteros y no-numéricos', () => {
+        expect(() => (0, concurrency_1.parseMaxParallel)('0')).toThrow(/entero >= 1/);
+        expect(() => (0, concurrency_1.parseMaxParallel)('-1')).toThrow(/entero >= 1/);
+        expect(() => (0, concurrency_1.parseMaxParallel)('1.5')).toThrow(/entero >= 1/);
+        expect(() => (0, concurrency_1.parseMaxParallel)('abc')).toThrow(/entero >= 1/);
+    });
+});
+describe('scheduleTracks', () => {
+    test('arranca hasta la capacidad libre, el resto espera', () => {
+        expect((0, concurrency_1.scheduleTracks)(['a', 'b', 'c'], new Set(['a']), 2)).toEqual({ start: ['b'], waiting: ['c'] });
+    });
+    test('sin capacidad libre todos quedan waiting', () => {
+        expect((0, concurrency_1.scheduleTracks)(['a', 'b', 'c'], new Set(['a', 'b']), 2)).toEqual({ start: [], waiting: ['c'] });
+    });
+    test('capacidad de sobra arranca todos los candidatos', () => {
+        expect((0, concurrency_1.scheduleTracks)(['a', 'b', 'c'], new Set(), 5)).toEqual({ start: ['a', 'b', 'c'], waiting: [] });
+    });
+    test('rechaza maxParallel invalido', () => {
+        expect(() => (0, concurrency_1.scheduleTracks)(['a'], new Set(), 0)).toThrow(/entero >= 1/);
+    });
+});
+describe('loadDefaultParallelism', () => {
+    // startDir es un tmpdir aislado en cada test — nunca toca ~/.awm ni depende
+    // del árbol real del repo (patrón de tmpdirs aislados de este repo, ver
+    // cli/tests/core/tracks/context.test.ts).
+    let tmp;
+    beforeEach(() => {
+        tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-concurrency-load-'));
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmp, { recursive: true, force: true });
+    });
+    function artifactPathUnder(dir) {
+        return path_1.default.join(dir, 'docs', 'research', 'r5', 'fingerprint-budget.json');
+    }
+    test('artefacto ausente en todo el árbol de directorios -> serial (1)', () => {
+        expect((0, concurrency_1.loadDefaultParallelism)(tmp)).toBe(1);
+    });
+    test('artefacto con JSON inválido/corrupto -> serial (1)', () => {
+        const p = artifactPathUnder(tmp);
+        fs_1.default.mkdirSync(path_1.default.dirname(p), { recursive: true });
+        fs_1.default.writeFileSync(p, '{ esto no es json');
+        expect((0, concurrency_1.loadDefaultParallelism)(tmp)).toBe(1);
+    });
+    test('derivedDefault ausente -> serial (1)', () => {
+        const p = artifactPathUnder(tmp);
+        fs_1.default.mkdirSync(path_1.default.dirname(p), { recursive: true });
+        fs_1.default.writeFileSync(p, JSON.stringify({ cpuCount: 4, tickMs: 5000, samples: [] }));
+        expect((0, concurrency_1.loadDefaultParallelism)(tmp)).toBe(1);
+    });
+    test('derivedDefault no entero -> serial (1)', () => {
+        const p = artifactPathUnder(tmp);
+        fs_1.default.mkdirSync(path_1.default.dirname(p), { recursive: true });
+        fs_1.default.writeFileSync(p, JSON.stringify({ derivedDefault: 2.5 }));
+        expect((0, concurrency_1.loadDefaultParallelism)(tmp)).toBe(1);
+    });
+    test('derivedDefault fuera de rango (< 1) -> serial (1)', () => {
+        const p = artifactPathUnder(tmp);
+        fs_1.default.mkdirSync(path_1.default.dirname(p), { recursive: true });
+        fs_1.default.writeFileSync(p, JSON.stringify({ derivedDefault: 0 }));
+        expect((0, concurrency_1.loadDefaultParallelism)(tmp)).toBe(1);
+    });
+    test('artefacto válido -> devuelve el derivedDefault real, buscando hacia arriba desde un subdirectorio', () => {
+        const p = artifactPathUnder(tmp);
+        fs_1.default.mkdirSync(path_1.default.dirname(p), { recursive: true });
+        fs_1.default.writeFileSync(p, JSON.stringify({
+            sourceHead: 'a'.repeat(40), node: process.version, platform: process.platform,
+            cpuCount: 4, tickMs: 5000, samples: [{ supervisors: 1, p50Ms: 10, p95Ms: 12 }], derivedDefault: 3,
+        }));
+        const nested = path_1.default.join(tmp, 'cli', 'dist', 'src', 'core', 'tracks');
+        fs_1.default.mkdirSync(nested, { recursive: true });
+        expect((0, concurrency_1.loadDefaultParallelism)(nested)).toBe(3);
+    });
+    test('sin override, resuelve desde __dirname del propio módulo (integración real)', () => {
+        const n = (0, concurrency_1.loadDefaultParallelism)();
+        expect(Number.isInteger(n)).toBe(true);
+        expect(n).toBeGreaterThanOrEqual(1);
+    });
+});

package/dist/tests/core/tracks/context.test.js

@@ -0,0 +1,177 @@
+"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 os_1 = __importDefault(require("os"));
+const child_process_1 = require("child_process");
+const context_1 = require("../../../src/core/tracks/context");
+const descriptor_1 = require("../../../src/core/tracks/descriptor");
+const store_1 = require("../../../src/core/journal/store");
+const types_1 = require("../../../src/core/journal/types");
+function gitInit(repo) {
+    (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', 'init', '-q', '-b', 'main'], { cwd: repo });
+    fs_1.default.writeFileSync(path_1.default.join(repo, 'f.txt'), 'x');
+    (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', 'add', '.'], { cwd: repo });
+    (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', 'commit', '-qm', 'c'], { cwd: repo });
+}
+function descriptorFor(overrides, planRoot) {
+    return { schema: 1, planRoot, planBranch: 'main', trackId: 'cli', planJournalId: 'j-1', fencingToken: 'f'.repeat(32), ...overrides };
+}
+function trackRefFor(overrides, worktreePath) {
+    return {
+        trackId: 'cli', worktreePath, branch: 'track/cli', ownership: [], sharedResources: [], dependsOn: [],
+        fencingToken: 'f'.repeat(32), phase: 'ACTIVE', readinessNonce: 'n'.repeat(8), ...overrides,
+    };
+}
+function planStateWith(journalId, fencingToken, worktreePath) {
+    const s = (0, types_1.emptyState)('main');
+    s.journalId = journalId;
+    s.tracks = [trackRefFor({ fencingToken }, worktreePath)];
+    return s;
+}
+function trackStateWith(overrides = {}) {
+    const s = (0, types_1.emptyState)('track/cli');
+    s.trackContext = { trackId: 'cli', taskIds: ['1'], planDigest: 'expected', baseSha: 'sha', planJournalId: 'j-1', ...overrides };
+    return s;
+}
+function trackContextFixture(overrides = {}) {
+    return { trackId: 'cli', taskIds: ['1', '2'], planDigest: 'expected', baseSha: 'sha', planJournalId: 'j-1', ...overrides };
+}
+describe('resolveAuthenticatedContext (R2.5, R2.6, R9.4)', () => {
+    let trackRoot;
+    let otherRoot;
+    let planRoot;
+    beforeEach(() => {
+        trackRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-ctx-track-'));
+        otherRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-ctx-other-'));
+        planRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-ctx-plan-'));
+    });
+    afterEach(() => {
+        for (const dir of [trackRoot, otherRoot, planRoot])
+            fs_1.default.rmSync(dir, { recursive: true, force: true });
+    });
+    test('sin descriptor => modo plan, devuelve el journal local tal cual', () => {
+        const local = (0, types_1.emptyState)('main');
+        expect((0, context_1.resolveAuthenticatedContext)(trackRoot, local)).toEqual({ mode: 'plan', repoRoot: fs_1.default.realpathSync(trackRoot), journal: local });
+    });
+    test('descriptor debe coincidir por realpath, journalId y fencing (R2.5, R2.6, R9.4)', () => {
+        (0, descriptor_1.writeDescriptor)(trackRoot, descriptorFor({ planJournalId: 'j-1', fencingToken: 'f'.repeat(32) }, planRoot));
+        const local = trackStateWith({ planJournalId: 'j-1', trackId: 'cli' });
+        expect((0, context_1.resolveAuthenticatedContext)(trackRoot, local, planStateWith('j-1', 'f'.repeat(32), trackRoot))).toMatchObject({ mode: 'track' });
+        expect(() => (0, context_1.resolveAuthenticatedContext)(trackRoot, local, planStateWith('j-1', 'x'.repeat(32), trackRoot))).toThrow(/fencingToken/);
+        (0, descriptor_1.writeDescriptor)(otherRoot, descriptorFor({ planJournalId: 'j-1', fencingToken: 'f'.repeat(32) }, planRoot));
+        // el TrackRef del plan sigue apuntando a trackRoot: otherRoot nunca puede autenticarse contra el (R9.4)
+        expect(() => (0, context_1.resolveAuthenticatedContext)(otherRoot, local, planStateWith('j-1', 'f'.repeat(32), trackRoot))).toThrow(/realpath/);
+    });
+    test('descriptor presente sin trackContext en el journal local lanza', () => {
+        (0, descriptor_1.writeDescriptor)(trackRoot, descriptorFor({}, planRoot));
+        const local = (0, types_1.emptyState)('track/cli'); // sin trackContext
+        expect(() => (0, context_1.resolveAuthenticatedContext)(trackRoot, local, planStateWith('j-1', 'f'.repeat(32), trackRoot)))
+            .toThrow(/trackContext/);
+    });
+    test('journalId del plan divergente del descriptor lanza (planJournalId)', () => {
+        (0, descriptor_1.writeDescriptor)(trackRoot, descriptorFor({ planJournalId: 'j-1' }, planRoot));
+        const local = trackStateWith({ planJournalId: 'j-1' });
+        expect(() => (0, context_1.resolveAuthenticatedContext)(trackRoot, local, planStateWith('j-OTRO', 'f'.repeat(32), trackRoot)))
+            .toThrow(/planJournalId/);
+    });
+    test('planJournalId del trackContext local divergente del descriptor tambien lanza', () => {
+        (0, descriptor_1.writeDescriptor)(trackRoot, descriptorFor({ planJournalId: 'j-1' }, planRoot));
+        const local = trackStateWith({ planJournalId: 'j-DISTINTO' });
+        expect(() => (0, context_1.resolveAuthenticatedContext)(trackRoot, local, planStateWith('j-1', 'f'.repeat(32), trackRoot)))
+            .toThrow(/planJournalId/);
+    });
+    test('TrackRef ausente en el journal del plan lanza', () => {
+        (0, descriptor_1.writeDescriptor)(trackRoot, descriptorFor({ trackId: 'fantasma', planJournalId: 'j-1' }, planRoot));
+        const local = trackStateWith({ planJournalId: 'j-1', trackId: 'fantasma' });
+        const plan = planStateWith('j-1', 'f'.repeat(32), trackRoot); // tracks=[{trackId:'cli',...}], no 'fantasma'
+        expect(() => (0, context_1.resolveAuthenticatedContext)(trackRoot, local, plan)).toThrow(/TrackRef ausente/);
+    });
+    test('planRoot == cwd (un track no puede autenticarse contra si mismo) lanza como realpath', () => {
+        (0, descriptor_1.writeDescriptor)(planRoot, descriptorFor({ planJournalId: 'j-1' }, planRoot));
+        const local = trackStateWith({ planJournalId: 'j-1' });
+        expect(() => (0, context_1.resolveAuthenticatedContext)(planRoot, local, planStateWith('j-1', 'f'.repeat(32), planRoot)))
+            .toThrow(/realpath/);
+    });
+    test('trackId del trackContext local distinto del descriptor lanza (trackId no coincide)', () => {
+        (0, descriptor_1.writeDescriptor)(trackRoot, descriptorFor({ trackId: 'cli', planJournalId: 'j-1' }, planRoot));
+        // el TrackRef existe para 'cli' y fencing/realpath calzan, pero el trackContext local declara OTRO trackId
+        const local = trackStateWith({ planJournalId: 'j-1', trackId: 'otro-track' });
+        expect(() => (0, context_1.resolveAuthenticatedContext)(trackRoot, local, planStateWith('j-1', 'f'.repeat(32), trackRoot)))
+            .toThrow(/trackId no coincide/);
+    });
+});
+describe('assertTrackTask (R2.3, R2.4)', () => {
+    test('planDigest divergente bloquea y task ajena se rechaza (R2.3, R2.4)', () => {
+        const ctx = trackContextFixture({ taskIds: ['1', '2'], planDigest: 'expected' });
+        expect(() => (0, context_1.assertTrackTask)(ctx, '3', 'expected')).toThrow(/fuera de la asignación/);
+        expect(() => (0, context_1.assertTrackTask)(ctx, '1', 'actual')).toThrow(/planDigest/);
+    });
+    test('task asignada con planDigest vigente no lanza', () => {
+        const ctx = trackContextFixture({ taskIds: ['1', '2'], planDigest: 'expected' });
+        expect(() => (0, context_1.assertTrackTask)(ctx, '1', 'expected')).not.toThrow();
+    });
+});
+describe('planDigest', () => {
+    test('normaliza CRLF antes de hashear, para que checkouts con distinto line-ending no diverjan', () => {
+        expect((0, context_1.planDigest)('a\r\nb\n')).toBe((0, context_1.planDigest)('a\nb\n'));
+        expect((0, context_1.planDigest)('a\nb\n')).not.toBe((0, context_1.planDigest)('a\nc\n'));
+    });
+});
+describe('resolveCommandContext (R9.4): guard de entrada para awm job/watch', () => {
+    let trackRoot;
+    let planRoot;
+    beforeEach(() => {
+        trackRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-cmdctx-track-'));
+        planRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-cmdctx-plan-'));
+        gitInit(trackRoot);
+        gitInit(planRoot);
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(trackRoot, { recursive: true, force: true });
+        fs_1.default.rmSync(planRoot, { recursive: true, force: true });
+    });
+    test('sin descriptor => modo plan, SIN leer ningun journal (no lanza aunque no exista journal alguno)', () => {
+        expect((0, context_1.resolveCommandContext)(trackRoot, 'main')).toEqual({ mode: 'plan' });
+    });
+    test('descriptor autentica correctamente => modo track', () => {
+        (0, store_1.initJournal)(planRoot, 'main');
+        const planState = { ...(readState(planRoot, 'main')) };
+        planState.journalId = 'j-1';
+        planState.tracks = [trackRefFor({ fencingToken: 'f'.repeat(32) }, trackRoot)];
+        (0, store_1.writeJournal)(planRoot, 'main', planState);
+        (0, store_1.initJournal)(trackRoot, 'track/cli');
+        const localState = { ...(readState(trackRoot, 'track/cli')) };
+        localState.trackContext = { trackId: 'cli', taskIds: ['1'], planDigest: 'x', baseSha: 'y', planJournalId: 'j-1' };
+        (0, store_1.writeJournal)(trackRoot, 'track/cli', localState);
+        (0, descriptor_1.writeDescriptor)(trackRoot, descriptorFor({ planJournalId: 'j-1', fencingToken: 'f'.repeat(32) }, planRoot));
+        const out = (0, context_1.resolveCommandContext)(trackRoot, 'track/cli');
+        expect(out.mode).toBe('track');
+    });
+    test('descriptor presente pero fencingToken no coincide => rechaza con "cwd no autenticado"', () => {
+        (0, store_1.initJournal)(planRoot, 'main');
+        const planState = { ...(readState(planRoot, 'main')) };
+        planState.journalId = 'j-1';
+        planState.tracks = [trackRefFor({ fencingToken: 'f'.repeat(32) }, trackRoot)];
+        (0, store_1.writeJournal)(planRoot, 'main', planState);
+        (0, store_1.initJournal)(trackRoot, 'track/cli');
+        const localState = { ...(readState(trackRoot, 'track/cli')) };
+        localState.trackContext = { trackId: 'cli', taskIds: ['1'], planDigest: 'x', baseSha: 'y', planJournalId: 'j-1' };
+        (0, store_1.writeJournal)(trackRoot, 'track/cli', localState);
+        (0, descriptor_1.writeDescriptor)(trackRoot, descriptorFor({ planJournalId: 'j-1', fencingToken: 'x'.repeat(32) }, planRoot));
+        expect(() => (0, context_1.resolveCommandContext)(trackRoot, 'track/cli')).toThrow(/cwd no autenticado/);
+    });
+    test('descriptor presente pero el journal local aun no existe => rechaza con "cwd no autenticado" (fail-closed)', () => {
+        (0, descriptor_1.writeDescriptor)(trackRoot, descriptorFor({ planJournalId: 'j-1', fencingToken: 'f'.repeat(32) }, planRoot));
+        expect(() => (0, context_1.resolveCommandContext)(trackRoot, 'track/cli')).toThrow(/cwd no autenticado/);
+    });
+});
+function readState(repo, branch) {
+    const r = (0, store_1.readJournal)(repo, branch);
+    if (r.state === null)
+        throw new Error('journal no inicializado en el fixture de test');
+    return r.state;
+}

package/dist/tests/core/tracks/descriptor.test.js

@@ -0,0 +1,76 @@
+"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 os_1 = __importDefault(require("os"));
+const descriptor_1 = require("../../../src/core/tracks/descriptor");
+function descriptor(overrides = {}, planRoot) {
+    return {
+        schema: 1, planRoot, planBranch: 'main', trackId: 'cli',
+        planJournalId: 'j-1', fencingToken: 'f'.repeat(32), ...overrides,
+    };
+}
+describe('descriptor de track (R2.5)', () => {
+    let trackRoot;
+    let planRoot;
+    beforeEach(() => {
+        trackRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-desc-track-'));
+        planRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-desc-plan-'));
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(trackRoot, { recursive: true, force: true });
+        fs_1.default.rmSync(planRoot, { recursive: true, force: true });
+    });
+    test('sin descriptor, readDescriptor devuelve null (caso comun)', () => {
+        expect((0, descriptor_1.readDescriptor)(trackRoot)).toBeNull();
+    });
+    test('write + read hace roundtrip; planRoot se normaliza a realpath', () => {
+        (0, descriptor_1.writeDescriptor)(trackRoot, descriptor({}, planRoot));
+        const out = (0, descriptor_1.readDescriptor)(trackRoot);
+        expect(out).toEqual({
+            schema: 1, planRoot: fs_1.default.realpathSync(planRoot), planBranch: 'main',
+            trackId: 'cli', planJournalId: 'j-1', fencingToken: 'f'.repeat(32),
+        });
+    });
+    test('el archivo se escribe con permisos 0600 (R1.2)', () => {
+        (0, descriptor_1.writeDescriptor)(trackRoot, descriptor({}, planRoot));
+        const mode = fs_1.default.statSync((0, descriptor_1.descriptorPath)(trackRoot)).mode & 0o777;
+        // win32 no sintetiza el bit de grupo/otros: mismo tratamiento que el resto de la
+        // suite tras el barrido de R6 (`atomic-file-durable`, `journal/store`,
+        // `install-transaction`). Este archivo nació en la rama R5, anterior al barrido.
+        expect(mode).toBe(process.platform === 'win32' ? 0o666 : 0o600);
+    });
+    test('rechaza schema distinto de 1', () => {
+        expect(() => (0, descriptor_1.writeDescriptor)(trackRoot, descriptor({ schema: 2 }, planRoot))).toThrow(/inválido/);
+    });
+    test('rechaza planRoot relativo', () => {
+        expect(() => (0, descriptor_1.writeDescriptor)(trackRoot, descriptor({}, 'relative/path'))).toThrow(/inválido/);
+    });
+    test('rechaza trackId vacio', () => {
+        expect(() => (0, descriptor_1.writeDescriptor)(trackRoot, descriptor({ trackId: '' }, planRoot))).toThrow(/inválido/);
+    });
+    test('rechaza planJournalId vacio', () => {
+        expect(() => (0, descriptor_1.writeDescriptor)(trackRoot, descriptor({ planJournalId: '' }, planRoot))).toThrow(/inválido/);
+    });
+    test('rechaza fencingToken corto (< 32 chars)', () => {
+        expect(() => (0, descriptor_1.writeDescriptor)(trackRoot, descriptor({ fencingToken: 'short' }, planRoot))).toThrow(/inválido/);
+    });
+    test('un track.json con forma invalida lanza en vez de autenticar por omision (R1.6)', () => {
+        fs_1.default.mkdirSync(path_1.default.dirname((0, descriptor_1.descriptorPath)(trackRoot)), { recursive: true });
+        fs_1.default.writeFileSync((0, descriptor_1.descriptorPath)(trackRoot), JSON.stringify({ schema: 1, planRoot, planBranch: 'main' }));
+        expect(() => (0, descriptor_1.readDescriptor)(trackRoot)).toThrow(/corrupto/);
+    });
+    test('un track.json con JSON sintacticamente invalido lanza (no crashea silenciosamente en null)', () => {
+        fs_1.default.mkdirSync(path_1.default.dirname((0, descriptor_1.descriptorPath)(trackRoot)), { recursive: true });
+        fs_1.default.writeFileSync((0, descriptor_1.descriptorPath)(trackRoot), '{ esto no es json');
+        expect(() => (0, descriptor_1.readDescriptor)(trackRoot)).toThrow();
+    });
+    test('writeDescriptor es durable: sobrevive a una segunda escritura (idempotente en forma)', () => {
+        (0, descriptor_1.writeDescriptor)(trackRoot, descriptor({}, planRoot));
+        (0, descriptor_1.writeDescriptor)(trackRoot, descriptor({ fencingToken: 'g'.repeat(32) }, planRoot));
+        expect((0, descriptor_1.readDescriptor)(trackRoot).fencingToken).toBe('g'.repeat(32));
+    });
+});