agentic-workflow-manager 6.4.0 → 6.4.2

package/dist/tests/commands/watch/track-join-request.test.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// El camino `awm track join` -> fase `JOIN_REQUESTED`, que NO EXISTÍA.
+//
+// `applyRequestToState` era una cadena de `if (env.kind === …) { …; return; }` sin rama para
+// `track-join-request`: se caía por el final sin lanzar, el caller no veía excepción, hacía
+// `applied++` y BORRABA el archivo. El comando salía 0 con su requestId, el journal contaba
+// la request como aplicada, y el track se quedaba en `ACTIVE` para siempre — como C3 exige la
+// cohorte entera congelada antes de mergear, jamás llegaba a `MERGED_UNVERIFIED` ni a
+// `COMPLETE`. Confirmación cruzada en su momento: `join-requested` era la ÚNICA observación
+// del protocolo con cero productores en todo `src/`.
+//
+// Estos tests cubren las tres propiedades del camino reparado:
+//   1. un join sobre un track `ACTIVE` mueve la fase (vía el reducer, no acá);
+//   2. un join que llega ANTES de la activación ESPERA en vez de perderse;
+//   3. un join que ya no puede aplicarse nunca se limpia, sin girar en cada tick.
+//
+// (2) es un bug encontrado en la certificación con supervisor vivo, sobre la PRIMERA versión
+// de este fix: con `maxParallel` chico la cohorte activa de a un track por vez, así que el
+// controller termina su trabajo y pide el join mientras su track sigue en `ARMED`. Descartar
+// el pedido ahí reintroduce exactamente el modo de falla que este cambio vino a cerrar — un
+// pedido que reporta éxito y no hace nada — y solo pasaba desapercibido porque el controller
+// scripteado re-emite el join en cada vuelta.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const git_fixture_1 = require("../../helpers/git-fixture");
+const tracks_1 = require("../../../src/commands/watch/tracks");
+const apply_1 = require("../../../src/commands/watch/apply");
+const emit_1 = require("../../../src/commands/track/emit");
+const store_1 = require("../../../src/core/journal/store");
+const paths_1 = require("../../../src/core/journal/paths");
+const BRANCH = 'main';
+describe('awm track join -> JOIN_REQUESTED (R6.1)', () => {
+    let planRoot;
+    let baseSha;
+    beforeEach(() => {
+        planRoot = (0, git_fixture_1.initRepo)();
+        (0, git_fixture_1.commitFile)(planRoot, '.gitignore', '.awm/\n');
+        baseSha = (0, git_fixture_1.commitFile)(planRoot, 'seed.txt', 'seed');
+        (0, store_1.initJournal)(planRoot, BRANCH);
+    });
+    afterEach(() => { fs_1.default.rmSync(planRoot, { recursive: true, force: true }); });
+    function declareCohort(phaseA, phaseB = 'ACTIVE') {
+        const s = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        s.cohortPhase = 'ACTIVE';
+        s.cohortBaseSha = baseSha;
+        // `assertProtocolInvariants` exige `frozenHeadSha` en todo track congelado o
+        // posterior: la fixture lo provee en vez de bajarle el estándar al invariante.
+        const frozen = ['FROZEN', 'JOIN_INTENT', 'MERGED_UNVERIFIED', 'JOINED'];
+        s.tracks = [
+            {
+                trackId: 'a', worktreePath: path_1.default.join(planRoot, '../nope-a'), branch: 'awm-track/a',
+                ownership: [], sharedResources: [], dependsOn: [],
+                fencingToken: 'fence-a'.padEnd(32, '0'), phase: phaseA, readinessNonce: 'ready-a'.padEnd(32, '0'),
+                frozenHeadSha: frozen.includes(phaseA) ? baseSha : undefined,
+            },
+            {
+                trackId: 'b', worktreePath: path_1.default.join(planRoot, '../nope-b'), branch: 'awm-track/b',
+                ownership: [], sharedResources: [], dependsOn: [],
+                fencingToken: 'fence-b'.padEnd(32, '0'), phase: phaseB, readinessNonce: 'ready-b'.padEnd(32, '0'),
+            },
+        ];
+        (0, store_1.writeJournal)(planRoot, BRANCH, s);
+        return (0, store_1.readJournal)(planRoot, BRANCH).state;
+    }
+    /** Runtime que explota ante cualquier efecto real: estos tests miden SOLO la producción
+     *  de la observación de join, nunca un freeze/merge de verdad. */
+    function inertRuntime() {
+        const real = (0, tracks_1.defaultTrackRuntime)(planRoot, BRANCH);
+        return {
+            ...real,
+            addWorktree: () => { throw new Error('no debería llamarse'); },
+            initTrackJournal: () => { throw new Error('no debería llamarse'); },
+            spawnSupervisor: () => { throw new Error('no debería llamarse'); },
+            observeSupervisor: () => ({ kind: 'absent' }),
+        };
+    }
+    function events() {
+        let raw = '';
+        try {
+            raw = fs_1.default.readFileSync((0, paths_1.eventsPath)(planRoot, BRANCH), 'utf8');
+        }
+        catch {
+            return [];
+        }
+        return raw.split('\n').filter((l) => l.trim().length > 0).map((l) => JSON.parse(l));
+    }
+    function phaseOf(s, trackId) {
+        return s.tracks?.find((t) => t.trackId === trackId)?.phase;
+    }
+    function joinFlagOf(s, trackId) {
+        return s.tracks?.find((t) => t.trackId === trackId)?.joinRequested;
+    }
+    it('el join de un track ACTIVE llega hasta la fase, pasando por la request real del CLI', async () => {
+        declareCohort('ACTIVE');
+        // La request se emite con el MISMO emisor que usa `awm track join`, no a mano: lo que
+        // estaba roto era justamente el tramo entre ese emisor y el estado.
+        (0, emit_1.emitTrackRequest)(planRoot, BRANCH, 'g1', 'track-join-request', 'a');
+        expect((0, apply_1.consumePendingRequests)(planRoot, BRANCH, 'g1').applied).toBe(1);
+        const s1 = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        expect(joinFlagOf(s1, 'a')).toBe(true);
+        expect(phaseOf(s1, 'a')).toBe('ACTIVE'); // el consumo transaccional NO mueve fases
+        const out = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s1, inertRuntime(), 2);
+        expect(phaseOf(out.state, 'a')).toBe('JOIN_REQUESTED');
+        expect(joinFlagOf(out.state, 'a')).toBeUndefined();
+        expect(events().some((e) => e.kind === 'track-join-observed' && e.trackId === 'a')).toBe(true);
+    });
+    it('un join que llega ANTES de la activación espera, y se aplica cuando el track activa', async () => {
+        // Carrera real de la certificación: `maxParallel` 1 activa de a un track, así que el
+        // controller pide el join de `a` mientras `a` sigue en ARMED.
+        declareCohort('ARMED', 'ACTIVE');
+        (0, emit_1.emitTrackRequest)(planRoot, BRANCH, 'g1', 'track-join-request', 'a');
+        (0, apply_1.consumePendingRequests)(planRoot, BRANCH, 'g1');
+        let s = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        s = (await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, s, inertRuntime(), 1)).state;
+        // Sigue pendiente: no se descartó por haber llegado temprano.
+        expect(joinFlagOf(s, 'a')).toBe(true);
+        expect(phaseOf(s, 'a')).toBe('ARMED');
+        // El track activa (lo hace el protocolo cuando hay cupo) y recién ahí el join aplica.
+        const activated = (0, store_1.readJournal)(planRoot, BRANCH).state;
+        for (const t of activated.tracks ?? [])
+            if (t.trackId === 'a')
+                t.phase = 'ACTIVE';
+        (0, store_1.writeJournal)(planRoot, BRANCH, activated);
+        const out = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        expect(phaseOf(out.state, 'a')).toBe('JOIN_REQUESTED');
+        expect(joinFlagOf(out.state, 'a')).toBeUndefined();
+    });
+    it('un join que ya no puede aplicarse nunca se limpia y no gira en cada tick', async () => {
+        // `a` ya está mergeado: un join re-emitido por un controller relevado es moot.
+        declareCohort('MERGED_UNVERIFIED', 'ACTIVE');
+        (0, emit_1.emitTrackRequest)(planRoot, BRANCH, 'g1', 'track-join-request', 'a');
+        (0, apply_1.consumePendingRequests)(planRoot, BRANCH, 'g1');
+        const out = await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        expect(joinFlagOf(out.state, 'a')).toBeUndefined();
+        expect(phaseOf(out.state, 'a')).toBe('MERGED_UNVERIFIED');
+        expect(events().filter((e) => e.kind === 'track-join-moot')).toHaveLength(1);
+        // Un segundo pase no vuelve a emitir nada: la marca ya no está.
+        await (0, tracks_1.reconcileTracks)(planRoot, BRANCH, (0, store_1.readJournal)(planRoot, BRANCH).state, inertRuntime(), 2);
+        expect(events().filter((e) => e.kind === 'track-join-moot')).toHaveLength(1);
+    });
+});

package/dist/tests/core/provider-version.test.js

@@ -10,6 +10,47 @@ describe('assertProviderSupported', () => {
         });
         expect(exec).toHaveBeenCalledWith('codex', ['--version'], expect.any(Object));
     });
+    // Regression: npm installs `codex` as `codex.cmd` on Windows, and
+    // execFileSync can't CreateProcess a `.cmd` shim without a shell — it threw
+    // ENOENT here even on a machine where `codex --version` worked fine typed
+    // directly. `provider.versionCommand` is hardcoded first-party config
+    // (providers/index.ts), never attacker-controlled, so `shell: true` here
+    // carries none of the injection risk core/paths.ts's resolveOnPath was
+    // built to avoid for sensors.json's user/registry-supplied `cmd`.
+    describe('on native Windows', () => {
+        const realPlatform = process.platform;
+        afterEach(() => {
+            Object.defineProperty(process, 'platform', { value: realPlatform, configurable: true });
+        });
+        it('runs the version probe through a shell so the .cmd shim resolves', () => {
+            Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+            const exec = jest.fn(() => Buffer.from('codex-cli 0.145.0\n'));
+            (0, provider_version_1.assertProviderSupported)('codex', exec);
+            expect(exec).toHaveBeenCalledWith('codex', ['--version'], expect.objectContaining({ shell: true }));
+        });
+        it('does not use a shell on non-Windows platforms', () => {
+            Object.defineProperty(process, 'platform', { value: 'darwin', configurable: true });
+            const exec = jest.fn(() => Buffer.from('codex-cli 0.145.0\n'));
+            (0, provider_version_1.assertProviderSupported)('codex', exec);
+            expect(exec).toHaveBeenCalledWith('codex', ['--version'], expect.objectContaining({ shell: false }));
+        });
+        // Regression from the fix above: shipping shell:true changed how a
+        // GENUINELY missing binary fails. Without a shell it's a spawn-level
+        // ENOENT; through cmd.exe the shell itself starts fine and the missing
+        // command surfaces as a non-zero exit with this exact stderr text — no
+        // ENOENT anywhere. windows-latest CI (no codex installed) caught this:
+        // it started reporting "version probe failed" instead of "not
+        // installed" the first time shell:true shipped without this branch.
+        it('still reports "not installed" when the shell itself says the command is unknown', () => {
+            Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+            const shellNotFound = Object.assign(new Error('Command failed: codex --version'), {
+                status: 1,
+                stderr: Buffer.from("'codex' is not recognized as an internal or external command,\r\noperable program or batch file.\r\n"),
+            });
+            expect(() => (0, provider_version_1.assertProviderSupported)('codex', () => { throw shellNotFound; }))
+                .toThrow('Codex is not installed or not available on PATH');
+        });
+    });
     it.each(['0.145.1', '0.146.0', '1.0.0'])('accepts stable Codex version %s above the minimum', (version) => {
         expect((0, provider_version_1.assertProviderSupported)('codex', () => Buffer.from(`codex-cli ${version}\n`))).toEqual({ provider: 'codex', version });
     });

package/dist/tests/core/update-check.test.js

@@ -91,7 +91,11 @@ describe('update-check', () => {
         const m = require('../../src/core/update-check');
         const runner = jest.fn().mockReturnValue({ status: 1 });
         const warn = jest.spyOn(console, 'warn').mockImplementation(() => { });
-        await m.offerSelfUpdate({ current: '2.0.0', latest: '2.1.0', confirmImpl: async () => true, runner });
+        // `mode: 'prompt'` explícito: la premisa de este test es que HAY un humano
+        // confirmando. Bajo jest stdin no es un TTY, y el modo por defecto pasó a ser
+        // `skip` justamente para que `awm update` no se cuelgue donde no hay a quién
+        // preguntarle — sin declarar el modo, este test mediría el camino desatendido.
+        await m.offerSelfUpdate({ current: '2.0.0', latest: '2.1.0', mode: 'prompt', confirmImpl: async () => true, runner });
         expect(runner).toHaveBeenCalled();
         expect(warn.mock.calls.flat().join('\n')).toContain('npm i -g agentic-workflow-manager');
         warn.mockRestore();

package/dist/tests/utils/config.test.js

@@ -6,6 +6,27 @@ 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 config_1 = require("../../src/utils/config");
+// Regression for the `awm remove <bundle> --yes` gap found running the issue #55
+// Windows playbook (CORE-17): `--yes` skipped the agent prompt but not the scope
+// one, so a supposedly non-interactive removal still hung waiting on a picker.
+// D-006's own stated rule is "`--yes` implica cero prompts" — this closes the one
+// call site that had drifted from it.
+describe('resolveScopeOption', () => {
+    it('falls back to the default when nothing explicit was passed (the --yes path)', () => {
+        expect((0, config_1.resolveScopeOption)(undefined, 'local')).toEqual({ ok: true, scope: 'local' });
+        expect((0, config_1.resolveScopeOption)(undefined, 'global')).toEqual({ ok: true, scope: 'global' });
+    });
+    it('an explicit valid value wins over the default', () => {
+        expect((0, config_1.resolveScopeOption)('global', 'local')).toEqual({ ok: true, scope: 'global' });
+    });
+    it('rejects a value that is neither local nor global', () => {
+        expect((0, config_1.resolveScopeOption)('bogus', 'local')).toEqual({
+            ok: false,
+            error: 'Invalid scope "bogus". Use: local or global.',
+        });
+    });
+});
 describe('Preferences Manager', () => {
     let tmpHome;
     let tmpWork;

package/package.json

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