agentic-workflow-manager 6.2.0 → 6.3.0

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

@@ -0,0 +1,132 @@
+"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 os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const git_fixture_1 = require("../../helpers/git-fixture");
+const git_1 = require("../../../src/core/tracks/git");
+function trackRef(worktreePath, branch) {
+    return {
+        trackId: 'x', worktreePath, branch,
+        ownership: [], sharedResources: [], dependsOn: [],
+        fencingToken: 'f'.repeat(32), phase: 'PREPARE_INTENT', readinessNonce: 'r'.repeat(32),
+    };
+}
+describe('git adapter', () => {
+    let repo;
+    afterEach(() => { if (repo)
+        fs_1.default.rmSync(repo, { recursive: true, force: true }); });
+    test('changedPaths usa commits y conserva ambos lados de rename (R5.2, R5.4)', () => {
+        repo = (0, git_fixture_1.initRepo)();
+        const base = (0, git_fixture_1.commitFile)(repo, 'old.ts', 'one');
+        fs_1.default.renameSync(path_1.default.join(repo, 'old.ts'), path_1.default.join(repo, 'new.ts'));
+        (0, child_process_1.execFileSync)('git', ['add', '-A'], { cwd: repo });
+        (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', 'commit', '-m', 'rename'], { cwd: repo });
+        expect((0, git_1.changedPaths)(repo, base, 'HEAD')).toEqual([
+            { status: 'R100', oldPath: 'old.ts', path: 'new.ts' },
+        ]);
+    });
+    test('changedPaths reporta modificaciones simples con status M', () => {
+        repo = (0, git_fixture_1.initRepo)();
+        const base = (0, git_fixture_1.commitFile)(repo, 'a.ts', 'one');
+        (0, git_fixture_1.commitFile)(repo, 'a.ts', 'two');
+        expect((0, git_1.changedPaths)(repo, base, 'HEAD')).toEqual([{ status: 'M', path: 'a.ts' }]);
+    });
+    test('changedPaths ignora el worktree sucio: solo compara commits (R5.2)', () => {
+        repo = (0, git_fixture_1.initRepo)();
+        const base = (0, git_fixture_1.commitFile)(repo, 'a.ts', 'one');
+        (0, git_fixture_1.commitFile)(repo, 'a.ts', 'two');
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'a.ts'), 'dirty, uncommitted');
+        expect((0, git_1.changedPaths)(repo, base, 'HEAD')).toEqual([{ status: 'M', path: 'a.ts' }]);
+    });
+    test('mergeBase encuentra el ancestro común de dos ramas', () => {
+        repo = (0, git_fixture_1.initRepo)();
+        const base = (0, git_fixture_1.commitFile)(repo, 'a.ts', 'one');
+        (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', 'branch', 'side'], { cwd: repo });
+        (0, git_fixture_1.commitFile)(repo, 'b.ts', 'two');
+        (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', 'checkout', '-q', 'side'], { cwd: repo });
+        (0, git_fixture_1.commitFile)(repo, 'c.ts', 'three');
+        expect((0, git_1.mergeBase)(repo, 'main', 'side')).toBe(base);
+    });
+    test.each(['valid-track', '..', '-x', 'a/b'])('git check-ref-format participa para %p (R1.3)', (id) => {
+        expect((0, git_1.gitCheckTrackId)(id)).toBe(id === 'valid-track');
+    });
+    describe('ownedWorktreeExists / removeOwnedBranch (Task 9, R4.2/R4.6/C11)', () => {
+        let worktreePath;
+        beforeEach(() => {
+            worktreePath = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-git-owned-wt-'));
+            fs_1.default.rmdirSync(worktreePath);
+        });
+        afterEach(() => {
+            fs_1.default.rmSync(worktreePath, { recursive: true, force: true });
+        });
+        test('false cuando el destino no existe (nada que reconocer como propio todavía)', () => {
+            repo = (0, git_fixture_1.initRepo)();
+            (0, git_fixture_1.commitFile)(repo, 'a.txt', 'x');
+            expect((0, git_1.ownedWorktreeExists)(repo, worktreePath, 'awm-track/x')).toBe(false);
+        });
+        test('false cuando el destino existe pero es genuinamente ajeno (R4.6 fail-closed)', () => {
+            repo = (0, git_fixture_1.initRepo)();
+            (0, git_fixture_1.commitFile)(repo, 'a.txt', 'x');
+            fs_1.default.mkdirSync(worktreePath, { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(worktreePath, 'foreign.txt'), 'ajeno');
+            expect((0, git_1.ownedWorktreeExists)(repo, worktreePath, 'awm-track/x')).toBe(false);
+            expect((0, git_1.foreignPathExists)(worktreePath)).toBe(true);
+        });
+        test('true cuando el destino YA es un worktree real registrado en la branch exacta (crash tras un `addWorktree` que sí corrió)', () => {
+            repo = (0, git_fixture_1.initRepo)();
+            const baseSha = (0, git_fixture_1.commitFile)(repo, 'a.txt', 'x');
+            const ref = trackRef(worktreePath, 'awm-track/x');
+            (0, git_1.addOwnedWorktree)(repo, ref, baseSha);
+            expect((0, git_1.ownedWorktreeExists)(repo, worktreePath, 'awm-track/x')).toBe(true);
+            // Una branch distinta al mismo path, o el mismo path con otra
+            // branch, nunca cuentan como "nuestro" (identidad completa: path
+            // Y branch deterministas, no solo uno de los dos).
+            expect((0, git_1.ownedWorktreeExists)(repo, worktreePath, 'awm-track/other')).toBe(false);
+        });
+        test('removeOwnedBranch borra la branch tras remover su worktree, y es idempotente si ya no existe', () => {
+            repo = (0, git_fixture_1.initRepo)();
+            const baseSha = (0, git_fixture_1.commitFile)(repo, 'a.txt', 'x');
+            const ref = trackRef(worktreePath, 'awm-track/x');
+            (0, git_1.addOwnedWorktree)(repo, ref, baseSha);
+            (0, git_1.removeOwnedWorktree)(repo, worktreePath);
+            expect(() => (0, git_1.removeOwnedBranch)(repo, 'awm-track/x')).not.toThrow();
+            const branches = (0, child_process_1.execFileSync)('git', ['branch', '--list', 'awm-track/x'], { cwd: repo, encoding: 'utf8' });
+            expect(branches.trim()).toBe('');
+            // Idempotente: ya no existe, un segundo llamado (retry tras crash) no lanza.
+            expect(() => (0, git_1.removeOwnedBranch)(repo, 'awm-track/x')).not.toThrow();
+        });
+        // Task 13 (R4.10/C9): endurece el guard — nunca `--force`, nunca `-D`.
+        test('removeOwnedWorktree bloquea (nombrando paths) en vez de forzar si el worktree está sucio', () => {
+            repo = (0, git_fixture_1.initRepo)();
+            const baseSha = (0, git_fixture_1.commitFile)(repo, 'a.txt', 'x');
+            const ref = trackRef(worktreePath, 'awm-track/x');
+            (0, git_1.addOwnedWorktree)(repo, ref, baseSha);
+            fs_1.default.writeFileSync(path_1.default.join(worktreePath, 'dirty.txt'), 'sin commitear');
+            expect(() => (0, git_1.removeOwnedWorktree)(repo, worktreePath)).toThrow(/sucio/);
+            expect(() => (0, git_1.removeOwnedWorktree)(repo, worktreePath)).toThrow(/dirty\.txt/);
+            // El worktree sigue vivo: nada se descartó a la fuerza.
+            expect(fs_1.default.existsSync(worktreePath)).toBe(true);
+            expect((0, git_1.ownedWorktreeExists)(repo, worktreePath, 'awm-track/x')).toBe(true);
+        });
+        test('removeOwnedBranch rehúsa borrar una branch que sigue checked out en un worktree vivo (nunca -D)', () => {
+            repo = (0, git_fixture_1.initRepo)();
+            const baseSha = (0, git_fixture_1.commitFile)(repo, 'a.txt', 'x');
+            const ref = trackRef(worktreePath, 'awm-track/x');
+            (0, git_1.addOwnedWorktree)(repo, ref, baseSha);
+            expect(() => (0, git_1.removeOwnedBranch)(repo, 'awm-track/x')).toThrow(/checked out/);
+            expect((0, git_1.branchExists)(repo, 'awm-track/x')).toBe(true);
+        });
+        test('branchExists refleja existencia real de la branch determinista', () => {
+            repo = (0, git_fixture_1.initRepo)();
+            (0, git_fixture_1.commitFile)(repo, 'a.txt', 'x');
+            expect((0, git_1.branchExists)(repo, 'awm-track/nope')).toBe(false);
+            (0, child_process_1.execFileSync)('git', ['branch', 'awm-track/x'], { cwd: repo });
+            expect((0, git_1.branchExists)(repo, 'awm-track/x')).toBe(true);
+        });
+    });
+});

package/dist/tests/core/tracks/join-reconcile.test.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Task 11 (R6.2/R6.3/R6.6-R6.9/C7): matriz completa MERGE_HEAD × HEAD para
+// `decideJoinReconciliation`. La función YA vive en `protocol.ts` desde
+// Task 1 (`reconcileProtocol` la llama para su handler de `join-observation`)
+// — por la regla de autoridad única, este archivo NO reimplementa nada; solo
+// importa el re-export de `join.ts` (`export { decideJoinReconciliation }
+// from './protocol'`, agregado por esta misma task) y prueba la matriz.
+//
+// Si esta matriz descubriera un caso que `decideJoinReconciliation` no
+// cubre, el fix va EN `protocol.ts` y hay que volver a correr la exploración
+// exhaustiva de Task 1 (`tests/core/tracks/protocol.test.ts`) en el mismo
+// commit — un fix que solo viviera acá invalidaría la prueba del gate.
+const join_1 = require("../../../src/core/tracks/join");
+const types_1 = require("../../../src/core/tracks/types");
+/** `expectedPlanHeadSha: 'plan'`, `expectedTrackHeadSha: 'track'` — mismos
+ *  literales opacos que usa la matriz del plan (Task 11, Step 1). */
+function intent() {
+    return { expectedPlanHeadSha: 'plan', expectedTrackHeadSha: 'track', strategy: types_1.JOIN_STRATEGY_NO_FF };
+}
+/** Helper local pedido por el plan: `obs(mergeHead, planHead, trackIsAncestor)`. */
+function obs(mergeHead, planHead, trackIsAncestor) {
+    return { mergeHead, planHead, trackIsAncestor };
+}
+const cases = [
+    { name: 'no empezó', observation: obs(null, 'plan', false), expected: { action: 'retry-merge' } },
+    { name: 'conflicto propio', observation: obs('track', 'plan', false), expected: { action: 'abort-own-merge' } },
+    { name: 'aplicado', observation: obs(null, 'merged', true), expected: { action: 'accept-merge', joinedCommitSha: 'merged' } },
+    { name: 'MERGE_HEAD ajeno', observation: obs('other', 'plan', false), expected: { action: 'block', reason: 'MERGE_HEAD ajeno' } },
+    { name: 'indemostrable', observation: obs(null, 'other', false), expected: { action: 'block', reason: 'estado de join indemostrable' } },
+];
+describe('decideJoinReconciliation — matriz MERGE_HEAD × HEAD (R6.8, R6.9)', () => {
+    test.each(cases)('$name (R6.8, R6.9)', ({ observation, expected }) => {
+        expect((0, join_1.decideJoinReconciliation)(intent(), observation)).toEqual(expected);
+    });
+    // Casos límite adicionales, fuera de la matriz literal del plan pero
+    // sobre el MISMO vocabulario — documentan por qué cada rama de
+    // `decideJoinReconciliation` existe (R6.6/R6.7: HEAD del plan movido).
+    test('HEAD del plan movió bajo nuestros pies sin merge en curso: indemostrable, nunca se asume (C7)', () => {
+        expect((0, join_1.decideJoinReconciliation)(intent(), obs(null, 'otro-plan-head', false)))
+            .toEqual({ action: 'block', reason: 'estado de join indemostrable' });
+    });
+    test('MERGE_HEAD propio pero el plan también se movió: NO se asume conflicto propio a ciegas (R6.6)', () => {
+        // `abort-own-merge` exige planHead === expectedPlanHeadSha; si además
+        // el HEAD del plan se movió, la ambigüedad (¿conflicto propio o plan
+        // movido?) es indemostrable con esta sola observación — bloquea, en
+        // vez de abortar un merge asumiendo un plan HEAD que ya no es el
+        // esperado. Documentado acá para que un futuro cambio en el orden de
+        // las ramas de `decideJoinReconciliation` no lo rompa en silencio.
+        expect((0, join_1.decideJoinReconciliation)(intent(), obs('track', 'otro-plan-head', false)))
+            .toEqual({ action: 'block', reason: 'estado de join indemostrable' });
+    });
+});

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

@@ -0,0 +1,197 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Task 10 (R5.2/R5.8/R5.9/R6.3/R6.4/R6.5/C7): precondiciones puras de join +
+// lock de integración real. `validateJoinReadiness`/`planJoinOrder` son
+// puras (sin I/O) — se prueban con fixtures en memoria. El lock y
+// `assertPlanHead` (git.ts) sí tocan el mundo real (fs + git) y se prueban
+// con un repo real, mismo patrón que `tests/commands/watch/lock.test.ts`.
+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 join_1 = require("../../../src/core/tracks/join");
+const git_1 = require("../../../src/core/tracks/git");
+const paths_1 = require("../../../src/core/journal/paths");
+const store_1 = require("../../../src/core/journal/store");
+function readyJoin(overrides = {}) {
+    return {
+        frozenHeadSha: 'track-head', actualHeadSha: 'track-head', dirtyPaths: [],
+        gatePass: true, liveJobs: 0, supervisorAlive: false, lockExists: false,
+        ...overrides,
+    };
+}
+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 });
+}
+describe('validateJoinReadiness (R6.4/R6.5)', () => {
+    test('join exige freeze SHA, árbol limpio, gate recalculado, cero jobs y lock libre (R6.4, R6.5)', () => {
+        const base = readyJoin({
+            frozenHeadSha: 'track-head', actualHeadSha: 'track-head', dirtyPaths: [],
+            gatePass: true, liveJobs: 0, supervisorAlive: false, lockExists: false,
+        });
+        expect((0, join_1.validateJoinReadiness)(base)).toEqual({ ok: true });
+        for (const mutation of [
+            { dirtyPaths: ['untracked.txt'] }, { gatePass: false }, { liveJobs: 1 },
+            { supervisorAlive: true }, { lockExists: true }, { actualHeadSha: 'moved' },
+        ]) {
+            expect((0, join_1.validateJoinReadiness)({ ...base, ...mutation })).toMatchObject({ ok: false });
+        }
+    });
+    test('dirty paths se nombran y nunca se descartan (R6.5)', () => {
+        expect((0, join_1.validateJoinReadiness)(readyJoin({ dirtyPaths: ['a.ts', 'new.txt'] })))
+            .toEqual({ ok: false, reasons: ['worktree sucio: a.ts, new.txt'] });
+    });
+    test('dirty paths se ordenan deterministicamente sin importar el orden de entrada (R6.5)', () => {
+        expect((0, join_1.validateJoinReadiness)(readyJoin({ dirtyPaths: ['z.ts', 'a.ts'] })))
+            .toEqual({ ok: false, reasons: ['worktree sucio: a.ts, z.ts'] });
+    });
+    test('múltiples hechos adversos se reportan TODOS, ninguno se pisa (R6.4)', () => {
+        const result = (0, join_1.validateJoinReadiness)(readyJoin({ gatePass: false, liveJobs: 2, lockExists: true }));
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            expect(result.reasons).toEqual(expect.arrayContaining(['gate local rojo', '2 jobs vivos', 'lock de track retenido']));
+            expect(result.reasons).toHaveLength(3);
+        }
+    });
+});
+describe('planJoinOrder (R5.7/R5.8/R5.9/C5)', () => {
+    test('ownership real fuera de scope serializa joins restantes, no ejecución (R5.8, R5.9)', () => {
+        const out = (0, join_1.planJoinOrder)(['a', 'b'], {
+            a: { outsideOwnership: ['outside.ts'], globalClasses: [] },
+            b: { outsideOwnership: [], globalClasses: [] },
+        });
+        expect(out).toEqual({
+            mode: 'serial-joins', order: ['a', 'b'],
+            violations: { a: ['outside.ts'] }, parallelInvalidatedBy: [],
+        });
+    });
+    test('una clase global tocada de verdad invalida el paralelismo de la cohorte (R5.7, C5)', () => {
+        const out = (0, join_1.planJoinOrder)(['a', 'b'], {
+            a: { outsideOwnership: ['package-lock.json'], globalClasses: ['lockfile:package-lock.json'] },
+            b: { outsideOwnership: [], globalClasses: [] },
+        });
+        expect(out.mode).toBe('serial-joins');
+        expect(out.parallelInvalidatedBy).toEqual(['a:lockfile:package-lock.json']);
+    });
+    test('ownership limpia en todos los tracks preserva paralelismo (caso feliz)', () => {
+        const out = (0, join_1.planJoinOrder)(['a', 'b'], {
+            a: { outsideOwnership: [], globalClasses: [] },
+            b: { outsideOwnership: [], globalClasses: [] },
+        });
+        expect(out).toEqual({ mode: 'parallel-joins', order: ['a', 'b'], violations: {}, parallelInvalidatedBy: [] });
+    });
+});
+describe('acquireIntegrationLock / releaseIntegrationLock (R5.8/R5.9/C7)', () => {
+    let repo;
+    beforeEach(() => { repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-integration-lock-')); });
+    afterEach(() => { fs_1.default.rmSync(repo, { recursive: true, force: true }); });
+    test('adquisición exclusiva: una segunda adquisición falla mientras la primera vive', () => {
+        const l1 = (0, join_1.acquireIntegrationLock)(repo, { planJournalId: 'j-1', expectedPlanHeadSha: 'sha-1' });
+        expect(fs_1.default.existsSync((0, paths_1.integrationLockPath)(repo))).toBe(true);
+        expect(() => (0, join_1.acquireIntegrationLock)(repo, { planJournalId: 'j-1', expectedPlanHeadSha: 'sha-1' })).toThrow(/integración activa/);
+        (0, join_1.releaseIntegrationLock)(l1);
+        expect(fs_1.default.existsSync((0, paths_1.integrationLockPath)(repo))).toBe(false);
+    });
+    test('el body persistido lleva planJournalId + expectedPlanHeadSha, no solo la identidad del proceso', () => {
+        const l1 = (0, join_1.acquireIntegrationLock)(repo, { planJournalId: 'j-42', expectedPlanHeadSha: 'sha-42' });
+        const onDisk = JSON.parse(fs_1.default.readFileSync((0, paths_1.integrationLockPath)(repo), 'utf8'));
+        expect(onDisk).toMatchObject({ planJournalId: 'j-42', expectedPlanHeadSha: 'sha-42', pid: process.pid });
+        (0, join_1.releaseIntegrationLock)(l1);
+    });
+    test('lock con identidad muerta PROBADA se reclama con reintento único', () => {
+        fs_1.default.mkdirSync(path_1.default.dirname((0, paths_1.integrationLockPath)(repo)), { recursive: true });
+        fs_1.default.writeFileSync((0, paths_1.integrationLockPath)(repo), JSON.stringify({
+            pid: 999999, startTime: 'gone', spawnNonce: 'x', argvDigest: 'y', processGroup: 999999, psArgsDigest: 'z',
+            planJournalId: 'j-old', expectedPlanHeadSha: 'sha-old',
+        }));
+        const l = (0, join_1.acquireIntegrationLock)(repo, { planJournalId: 'j-new', expectedPlanHeadSha: 'sha-new' });
+        expect(l.ref.pid).toBe(process.pid);
+        (0, join_1.releaseIntegrationLock)(l);
+    });
+    test('lock ilegible o con shape inválido => IntegrationLockBlockedError, JAMÁS se reclama', () => {
+        fs_1.default.mkdirSync(path_1.default.dirname((0, paths_1.integrationLockPath)(repo)), { recursive: true });
+        fs_1.default.writeFileSync((0, paths_1.integrationLockPath)(repo), '{roto');
+        expect(() => (0, join_1.acquireIntegrationLock)(repo, { planJournalId: 'j', expectedPlanHeadSha: 's' })).toThrow(join_1.IntegrationLockBlockedError);
+        fs_1.default.writeFileSync((0, paths_1.integrationLockPath)(repo), JSON.stringify({ pid: 1 })); // shape parcial: falta planJournalId/expectedPlanHeadSha
+        expect(() => (0, join_1.acquireIntegrationLock)(repo, { planJournalId: 'j', expectedPlanHeadSha: 's' })).toThrow(join_1.IntegrationLockBlockedError);
+        expect(fs_1.default.existsSync((0, paths_1.integrationLockPath)(repo))).toBe(true); // sigue ahí: nadie lo pisó
+    });
+    test('release solo borra el lock si sigue siendo el nuestro (spawnNonce coincide)', () => {
+        const l1 = (0, join_1.acquireIntegrationLock)(repo, { planJournalId: 'j-1', expectedPlanHeadSha: 'sha-1' });
+        // Simula que otro holder legítimo reclamó el lock después (ej. tras un
+        // release nuestro que ya ocurrió y una segunda adquisición ajena) —
+        // `releaseIntegrationLock` jamás borra un lock cuyo spawnNonce no es
+        // el propio.
+        fs_1.default.writeFileSync((0, paths_1.integrationLockPath)(repo), JSON.stringify({ ...l1.ref, spawnNonce: 'otro' }));
+        (0, join_1.releaseIntegrationLock)(l1);
+        expect(fs_1.default.existsSync((0, paths_1.integrationLockPath)(repo))).toBe(true);
+        fs_1.default.rmSync((0, paths_1.integrationLockPath)(repo));
+    });
+});
+describe('assertPlanHead (R5.8/R5.9/C7): TOCTOU entre intent y cualquier operación git', () => {
+    let repo;
+    beforeEach(() => { repo = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-assert-head-')); git(repo, 'init', '-q', '-b', 'main'); });
+    afterEach(() => { fs_1.default.rmSync(repo, { recursive: true, force: true }); });
+    test('HEAD sin cambios: no lanza', () => {
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'a.txt'), 'x');
+        git(repo, 'add', '.');
+        git(repo, 'commit', '-qm', 'c1');
+        const sha = (0, git_1.headSha)(repo);
+        expect(() => (0, git_1.assertPlanHead)(repo, sha)).not.toThrow();
+    });
+    test('TOCTOU: adquirir el lock de integración con un expectedPlanHeadSha, mutar el HEAD del plan (commit humano), assertPlanHead BLOQUEA sin proceder', async () => {
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'a.txt'), 'x');
+        git(repo, 'add', '.');
+        git(repo, 'commit', '-qm', 'c1');
+        const expectedSha = (0, git_1.headSha)(repo);
+        // Intent: se adquiere el lock de integración con el SHA observado en
+        // este instante — modela el "expected SHA" que cualquier operación
+        // Git de join (Task 11) debe reverificar antes/después de mutar.
+        const lock = (0, join_1.acquireIntegrationLock)(repo, { planJournalId: 'j-1', expectedPlanHeadSha: expectedSha });
+        expect(() => (0, git_1.assertPlanHead)(repo, expectedSha)).not.toThrow();
+        // Un humano muta el repo del plan MIENTRAS el lock está retenido —
+        // "un humano puede mutar el repo, pero la mutación se detecta y
+        // bloquea" (Step 5 del plan): jamás se procede con un merge sobre un
+        // HEAD que ya no es el que se congeló al pedir el lock.
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'b.txt'), 'y');
+        git(repo, 'add', '.');
+        git(repo, 'commit', '-qm', 'commit humano fuera de banda');
+        // La operación de merge simulada consulta `assertPlanHead` con el
+        // MISMO `expectedPlanHeadSha` que persistió el lock — BLOQUEA sin
+        // haber tocado el repo (sin merge, R6/C7's "BLOCKED sin merge").
+        expect(() => (0, git_1.assertPlanHead)(repo, expectedSha)).toThrow(/HEAD del plan cambió/);
+        // El SHA drifteado se ve en el mensaje — no es un bloqueo silencioso.
+        try {
+            (0, git_1.assertPlanHead)(repo, expectedSha);
+            throw new Error('no debería llegar acá');
+        }
+        catch (e) {
+            expect(e.message).toContain(expectedSha);
+        }
+        (0, join_1.releaseIntegrationLock)(lock);
+    });
+    test('fail-closed: repo ilegible (git falla) nunca se interpreta como "sin cambios"', () => {
+        const gone = path_1.default.join(repo, 'no-existe-mas');
+        expect(() => (0, git_1.assertPlanHead)(gone, 'cualquier-sha')).toThrow(/indemostrable/);
+    });
+});
+describe('stopControllerGenerationConfirmed (R5.8/C7)', () => {
+    const BRANCH = 'main';
+    let planRoot;
+    beforeEach(() => { planRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-stop-gen-')); (0, store_1.initJournal)(planRoot, BRANCH); });
+    afterEach(() => { fs_1.default.rmSync(planRoot, { recursive: true, force: true }); });
+    test('sin generación activa: no-op, no lanza', async () => {
+        await expect((0, join_1.stopControllerGenerationConfirmed)(planRoot, BRANCH, { termGraceMs: 10, killGraceMs: 10 })).resolves.toBeUndefined();
+    });
+    test('generación activa sin processRef/wrapperRef vivos: se marca terminated sin intentar señales', async () => {
+        const s = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        s.generations.push({ n: 1, token: 'tok-1', state: 'active', launchedAt: new Date().toISOString() });
+        (0, store_1.writeJournal)(planRoot, BRANCH, s);
+        await (0, join_1.stopControllerGenerationConfirmed)(planRoot, BRANCH, { termGraceMs: 10, killGraceMs: 10 });
+        const after = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        expect(after.generations[0].state).toBe('terminated');
+    });
+});

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

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ownership_1 = require("../../../src/core/tracks/ownership");
+test('sopa de globs soportados: dir/, dir/*, dir/** cubren descendientes (R5.1, R5.4)', () => {
+    for (const owner of ['cli/src/', 'cli/src/*', 'cli/src/**']) {
+        expect((0, ownership_1.ownershipPrefix)(owner)).toBe('cli/src/');
+    }
+    expect((0, ownership_1.ownershipPrefix)('cli/src/a.ts')).toBe('cli/src/a.ts');
+});
+test('un glob intermedio NO habilita paralelismo: falla cerrado (R5.1, R5.3)', () => {
+    // Antes esto no colisionaba con nada y dejaba pasar la cohorte entera.
+    expect(() => (0, ownership_1.ownershipPrefix)('src/**/a.ts')).toThrow(/no soporta este glob/);
+    expect((0, ownership_1.assessDeclaredIndependence)([
+        track('a', ['src/**/a.ts']), track('b', ['src/lib/a.ts']),
+    ])).toMatchObject({ parallel: false });
+    expect((0, ownership_1.assessDeclaredIndependence)([track('a', ['src/**/a.ts']), track('b', ['docs/'])]).reasons)
+        .toContain('unsupported-glob:src/**/a.ts');
+});
+test('un glob inexpandible tampoco PRUEBA propiedad post-hoc (R5.8)', () => {
+    expect((0, ownership_1.assessActualOwnership)(track('a', ['src/**/a.ts']), [{ status: 'M', path: 'src/lib/a.ts' }]))
+        .toMatchObject({ outsideOwnership: ['src/lib/a.ts'] });
+});
+test('colisiona exacto, case-insensitive y por descendiente (R5.1, R5.3, R5.4)', () => {
+    expect((0, ownership_1.assessDeclaredIndependence)([
+        track('a', ['src/api/']), track('b', ['SRC/API/user.ts']),
+    ])).toMatchObject({ parallel: false, reasons: ['path:SRC/API/user.ts'] });
+});
+test('rename cuenta path viejo y nuevo (R5.4)', () => {
+    const out = (0, ownership_1.assessActualOwnership)(track('a', ['src/new.ts']), [
+        { status: 'R100', oldPath: 'src/old.ts', path: 'src/new.ts' },
+    ]);
+    expect(out.outsideOwnership).toEqual(['src/old.ts']);
+});
+test('un solo lockfile invalida toda la cohorte (R5.7, C5, CA-4.3)', () => {
+    expect((0, ownership_1.assessDeclaredIndependence)([
+        track('a', ['src/a.ts']), track('b', ['package-lock.json']),
+    ])).toMatchObject({ parallel: false, reasons: ['global:lockfile:package-lock.json'] });
+});
+test('recursos usan clase:valor canónico y colisionan por igualdad (R5.5, R5.6)', () => {
+    expect((0, ownership_1.canonicalResource)('port:5432')).toBe('port:5432');
+    expect(() => (0, ownership_1.canonicalResource)('5432')).toThrow(/<clase>:<valor>/);
+    expect((0, ownership_1.assessDeclaredIndependence)([
+        track('a', ['a'], ['db:dev']), track('b', ['b'], ['db:dev']),
+    ])).toMatchObject({ parallel: false, reasons: ['resource:db:dev'] });
+});
+test('canonicalResource case-folds el valor, no solo la clase (R5.5, R5.6)', () => {
+    expect((0, ownership_1.canonicalResource)('db:Dev')).toBe((0, ownership_1.canonicalResource)('db:dev'));
+    expect((0, ownership_1.assessDeclaredIndependence)([
+        track('a', ['a'], ['db:Dev']), track('b', ['b'], ['db:dev']),
+    ])).toMatchObject({ parallel: false, reasons: ['resource:db:dev'] });
+});
+test('no afirma observar recursos runtime no declarados (C10)', () => {
+    const out = (0, ownership_1.assessDeclaredIndependence)([track('a', ['a']), track('b', ['b'])]);
+    expect(out).toEqual({ parallel: true, reasons: [] });
+    // La garantía es sobre declaraciones + archivos; no existe probe de puertos/bases.
+});
+test('paths estilo Windows normalizan a posix antes de comparar (R5.3)', () => {
+    expect((0, ownership_1.ownershipPrefix)('cli\\src\\')).toBe('cli/src/');
+    expect((0, ownership_1.assessDeclaredIndependence)([
+        track('a', ['cli\\src\\a.ts']), track('b', ['cli/src/a.ts']),
+    ])).toMatchObject({ parallel: false });
+    expect((0, ownership_1.assessActualOwnership)(track('a', ['cli/src/']), [{ status: 'M', path: 'cli\\src\\deep\\a.ts' }]))
+        .toMatchObject({ outsideOwnership: [] });
+});
+test('manifest (package.json) es clase global aunque solo un track lo toque (C5)', () => {
+    expect((0, ownership_1.assessDeclaredIndependence)([
+        track('a', ['src/a.ts']), track('b', ['package.json']),
+    ])).toMatchObject({ parallel: false, reasons: ['global:manifest:package.json'] });
+    expect((0, ownership_1.assessActualOwnership)(track('a', ['src/a.ts']), [{ status: 'M', path: 'package.json' }]).globalClasses)
+        .toEqual(['manifest:package.json']);
+});
+test('migraciones y snapshots también cuentan como clase global (C5)', () => {
+    expect((0, ownership_1.assessDeclaredIndependence)([
+        track('a', ['src/a.ts']), track('b', ['migrations/0001_init.sql']),
+    ])).toMatchObject({ parallel: false, reasons: ['global:migration:migrations/0001_init.sql'] });
+    expect((0, ownership_1.assessDeclaredIndependence)([
+        track('a', ['src/a.ts']), track('b', ['__snapshots__/a.snap']),
+    ])).toMatchObject({ parallel: false, reasons: ['global:snapshot:__snapshots__/a.snap'] });
+});
+test('directorios generados (dist/generated/coverage) también cuentan como clase global (C5)', () => {
+    expect((0, ownership_1.assessDeclaredIndependence)([
+        track('a', ['src/a.ts']), track('b', ['dist/bundle.js']),
+    ])).toMatchObject({ parallel: false, reasons: ['global:generated:dist/bundle.js'] });
+    expect((0, ownership_1.assessActualOwnership)(track('a', ['src/a.ts']), [{ status: 'M', path: 'coverage/lcov.info' }]).globalClasses)
+        .toEqual(['generated:coverage/lcov.info']);
+});
+test('recursos declarados distintos no colisionan; ownership propio no reporta outsideOwnership', () => {
+    expect((0, ownership_1.assessDeclaredIndependence)([
+        track('a', ['a'], ['db:dev']), track('b', ['b'], ['db:staging']),
+    ])).toEqual({ parallel: true, reasons: [] });
+    expect((0, ownership_1.assessActualOwnership)(track('a', ['cli/src/']), [{ status: 'M', path: 'cli/src/a.ts' }]))
+        .toEqual({ outsideOwnership: [], globalClasses: [] });
+});
+function track(trackId, ownership, sharedResources = []) {
+    return { trackId, taskIds: [trackId], ownership, sharedResources, dependsOn: [] };
+}

package/dist/tests/core/tracks/plan-parser.test.js

@@ -0,0 +1,94 @@
+"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 plan_parser_1 = require("../../../src/core/tracks/plan-parser");
+const fixture = (name) => fs_1.default.readFileSync(path_1.default.join(__dirname, '../../fixtures/tracks', name), 'utf8');
+/** Narrowing explícito: el retorno es una unión discriminada y `strict` no deja acceder sin estrecharla. */
+const parallel = (source) => {
+    const parsed = (0, plan_parser_1.parseTrackPlan)(source, () => true);
+    if (parsed.mode !== 'parallel-candidate')
+        throw new Error(`esperaba parallel-candidate, obtuve ${parsed.mode}`);
+    return parsed;
+};
+describe('parseTrackPlan', () => {
+    test('parsea membresía, ownership y argv sin shell (R1.1, R1.4, C4)', () => {
+        const p = parallel(fixture('two-independent.md'));
+        expect(p.integration).toEqual({
+            argv: ['npm', 'test', '--', '--runInBand'],
+            paths: ['cli/src/**', 'cli/tests/**'],
+        });
+        expect(p.tracks.cli.taskIds).toEqual(['1']);
+        expect(p.tracks.cli.ownership).toEqual(['cli/src/a.ts']);
+    });
+    test('ausencia completa conserva serial legacy (R1.2)', () => {
+        expect((0, plan_parser_1.parseTrackPlan)(fixture('legacy-serial.md'), () => true)).toEqual({ mode: 'serial', reason: 'no-tracks' });
+    });
+    test.each(['', '.', '..', '-x', 'a/b', 'a\\b'])('rechaza id peligroso %p aunque git lo aceptara parcialmente (R1.3)', (id) => {
+        const src = fixture('two-independent.md').replaceAll('cli', id);
+        expect(() => (0, plan_parser_1.parseTrackPlan)(src, () => true)).toThrow(/track id inválido/);
+    });
+    test('rechaza membresía sin fila y fila sin membresía (R1.6)', () => {
+        const src = fixture('two-independent.md').replace('| docs | none | [] |', '| extra | none | [] |');
+        expect(() => (0, plan_parser_1.parseTrackPlan)(src, () => true)).toThrow(/coincidencia exacta/);
+    });
+    test('degrada a serial si shared resources falta o Depends on no es none (R1.7, R1.8)', () => {
+        expect((0, plan_parser_1.parseTrackPlan)(fixture('two-independent.md').replace('[] |', ' |'), () => true)).toMatchObject({ mode: 'serial' });
+        expect((0, plan_parser_1.parseTrackPlan)(fixture('two-independent.md').replace('| docs | none |', '| docs | cli |'), () => true)).toMatchObject({ mode: 'serial' });
+    });
+    test('integration argv debe ser JSON string[] no vacío (C4)', () => {
+        const src = fixture('two-independent.md').replace('["npm","test","--","--runInBand"]', 'npm test');
+        expect(() => (0, plan_parser_1.parseTrackPlan)(src, () => true)).toThrow(/Integration argv/);
+    });
+    test('la ÚLTIMA task con Files y sin Track también se rechaza (R1.6)', () => {
+        // El chequeo del loop solo dispara al ver el siguiente `### Task`; sin este caso
+        // la última task del documento entra a paralelo con sus archivos sin dueño.
+        const src = fixture('two-independent.md').replace('**Track:** docs\n', '');
+        expect(() => (0, plan_parser_1.parseTrackPlan)(src, () => true)).toThrow(/tiene Files pero no Track/);
+    });
+    // --- Step 5: casos adicionales bajo-especificados por el plan ---
+    test('rechaza track id duplicado en la tabla ## Tracks', () => {
+        const src = fixture('two-independent.md').replace('| docs | none | [] |', '| cli | none | [] |');
+        expect(() => (0, plan_parser_1.parseTrackPlan)(src, () => true)).toThrow(/track duplicado/);
+    });
+    test('rechaza una segunda línea **Track:** para la misma task', () => {
+        const src = fixture('two-independent.md').replace('**Track:** cli\n', '**Track:** cli\n**Track:** cli\n');
+        expect(() => (0, plan_parser_1.parseTrackPlan)(src, () => true)).toThrow(/exactamente un Track/);
+    });
+    test('rechaza path absoluto en - Modify: (fuera del repo)', () => {
+        const src = fixture('two-independent.md').replace('`cli/src/a.ts`', '`/etc/passwd`');
+        expect(() => (0, plan_parser_1.parseTrackPlan)(src, () => true)).toThrow(/Files path fuera del repo/);
+    });
+    test('rechaza escape de repo vía ../ en - Modify:', () => {
+        const src = fixture('two-independent.md').replace('`cli/src/a.ts`', '`../../etc/passwd`');
+        expect(() => (0, plan_parser_1.parseTrackPlan)(src, () => true)).toThrow(/Files path fuera del repo/);
+    });
+    test('Integration argv/paths con elemento no-string (número) es rechazado (C4)', () => {
+        const src = fixture('two-independent.md').replace('["npm","test","--","--runInBand"]', '["npm",1]');
+        expect(() => (0, plan_parser_1.parseTrackPlan)(src, () => true)).toThrow(/Integration argv/);
+    });
+    test('Integration paths con elemento no-string (número) es rechazado (C4)', () => {
+        const src = fixture('two-independent.md').replace('["cli/src/**","cli/tests/**"]', '["cli/src/**",2]');
+        expect(() => (0, plan_parser_1.parseTrackPlan)(src, () => true)).toThrow(/Integration paths/);
+    });
+    test('rechaza track declarado en la tabla que ninguna task reclama vía **Track:** (R1.6)', () => {
+        // Guarda específicamente la rama `members.size !== declared.size`: una fila de
+        // ## Tracks ("extra") sin ninguna task que la reclame debe fallar por
+        // coincidencia exacta, distinto del caso ya cubierto de membresía sin fila.
+        const src = fixture('two-independent.md').replace('| docs | none | [] |', '| docs | none | [] |\n| extra | none | [] |');
+        expect(() => (0, plan_parser_1.parseTrackPlan)(src, () => true)).toThrow(/coincidencia exacta/);
+    });
+    test('un segundo encabezado ## Tracks hace que sus filas se ignoren silenciosamente; ' +
+        'la membresía a la fila "perdida" sigue fallando por coincidencia exacta (documenta comportamiento real, no deseado idealmente)', () => {
+        // El parser de tabla solo usa el PRIMER `## Tracks` (findIndex) y corta en la
+        // primera línea que empieza con `## ` tras ese punto — incluida una segunda
+        // `## Tracks`. Por eso la fila de `docs` colocada después del segundo encabezado
+        // nunca entra a `declared`, y la membresía posterior de Task 2 a `docs` revienta
+        // por "coincidencia exacta" en vez de por un error específico de tabla duplicada.
+        const src = fixture('two-independent.md').replace('| docs | none | [] |', '\n## Tracks\n\n| Track | Depends on | Shared resources |\n|---|---|---|\n| docs | none | [] |');
+        expect(() => (0, plan_parser_1.parseTrackPlan)(src, () => true)).toThrow(/coincidencia exacta/);
+    });
+});