agentic-workflow-manager 6.4.0 → 6.4.2

package/dist/src/utils/config.js

@@ -9,6 +9,7 @@ exports.getPreferences = getPreferences;
 exports.loadPreferences = loadPreferences;
 exports.savePreferences = savePreferences;
 exports.enableAgent = enableAgent;
+exports.resolveScopeOption = resolveScopeOption;
 // src/utils/config.ts
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -158,3 +159,19 @@ function enableAgent(prefs, agent) {
         ? prefs
         : { ...prefs, enabledAgents: [...prefs.enabledAgents, agent] };
 }
+/**
+ * Resolve `--scope` the same way across every non-interactive command path: an
+ * explicit value wins (validated), otherwise fall back to the caller's default
+ * instead of prompting. Pulled out of `remove`'s Commander closure (D-006) after
+ * `--yes` was found to still open the scope picker with no `--scope` given —
+ * `--yes` means zero prompts, and this is the one call site that had drifted
+ * from that rule (the sibling --agent default sits right next to it in index.ts).
+ */
+function resolveScopeOption(explicit, fallback) {
+    if (explicit === undefined)
+        return { ok: true, scope: fallback };
+    if (explicit !== 'local' && explicit !== 'global') {
+        return { ok: false, error: `Invalid scope "${explicit}". Use: local or global.` };
+    }
+    return { ok: true, scope: explicit };
+}

package/dist/tests/commands/add.test.js

@@ -94,3 +94,45 @@ it('awm add demo materializes a real Copilot .instructions.md file end-to-end',
     fs_1.default.rmSync(content, { recursive: true, force: true });
     fs_1.default.rmSync(projectRoot, { recursive: true, force: true });
 });
+// Regression for WIN-02 (issue #55 Windows playbook): `--method copy` was
+// silently discarded by this exact function — `runAddBundleCore` hardcoded
+// 'symlink' regardless of what the CLI parsed, so a real Windows machine got
+// a Junction back no matter what `--method` asked for.
+describe('runAddBundleCore --method', () => {
+    const claudeCodePrefs = {
+        defaultAgent: 'claude-code', enabledAgents: ['claude-code'], installMethod: 'symlink', defaultScope: 'local',
+    };
+    it('honours an explicit --method copy: a real directory, not a symlink', () => {
+        const content = makeContentFixture();
+        const projectRoot = makeProjectRoot();
+        const bundles = (0, bundles_1.discoverBundles)(content);
+        const outcome = (0, add_1.runAddBundleCore)({ name: 'demo', agent: 'claude-code', method: 'copy', cwd: projectRoot }, claudeCodePrefs, bundles);
+        expect(outcome.code).toBe(0);
+        const skillPath = path_1.default.join(projectRoot, '.claude/skills/demo-skill');
+        expect(fs_1.default.lstatSync(skillPath).isSymbolicLink()).toBe(false);
+        expect(fs_1.default.readFileSync(path_1.default.join(skillPath, 'SKILL.md'), 'utf8')).toContain('Follow the demo skill body.');
+        fs_1.default.rmSync(content, { recursive: true, force: true });
+        fs_1.default.rmSync(projectRoot, { recursive: true, force: true });
+    });
+    it('still defaults to symlink when --method is omitted (unchanged behavior)', () => {
+        const content = makeContentFixture();
+        const projectRoot = makeProjectRoot();
+        const bundles = (0, bundles_1.discoverBundles)(content);
+        const outcome = (0, add_1.runAddBundleCore)({ name: 'demo', agent: 'claude-code', cwd: projectRoot }, claudeCodePrefs, bundles);
+        expect(outcome.code).toBe(0);
+        const skillPath = path_1.default.join(projectRoot, '.claude/skills/demo-skill');
+        expect(fs_1.default.lstatSync(skillPath).isSymbolicLink()).toBe(true);
+        fs_1.default.rmSync(content, { recursive: true, force: true });
+        fs_1.default.rmSync(projectRoot, { recursive: true, force: true });
+    });
+    it('rejects an invalid --method value without touching the filesystem', () => {
+        const content = makeContentFixture();
+        const projectRoot = makeProjectRoot();
+        const bundles = (0, bundles_1.discoverBundles)(content);
+        const outcome = (0, add_1.runAddBundleCore)({ name: 'demo', agent: 'claude-code', method: 'bogus', cwd: projectRoot }, claudeCodePrefs, bundles);
+        expect(outcome.code).toBe(1);
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.claude/skills/demo-skill'))).toBe(false);
+        fs_1.default.rmSync(content, { recursive: true, force: true });
+        fs_1.default.rmSync(projectRoot, { recursive: true, force: true });
+    });
+});

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

@@ -108,6 +108,29 @@ describe('runInit', () => {
             const caveatCalls = logSpy.mock.calls.filter((c) => /awm watch/i.test(String(c[0])));
             expect(caveatCalls).toHaveLength(0);
         });
+        // Regression: `awm init --yes --json > init.json` on native Windows used to
+        // write the caveat to stdout via console.log AHEAD of the JSON payload,
+        // so the documented core-acceptance.md CORE-03 flow produced a file that
+        // wasn't valid JSON (banner text, then `{...}`). The caveat must still
+        // reach the operator — it now goes to stderr instead of vanishing.
+        it('does not pollute --json stdout with the caveat on native Windows', async () => {
+            Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
+            const errSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+            const { runInit } = require('../../src/commands/init');
+            await runInit({
+                cwd: tmpHome,
+                yes: true,
+                json: true,
+                actions: { syncCache: async () => { }, installHook: () => ({ status: 'installed' }) },
+            });
+            const written = writeSpy.mock.calls.map((c) => c[0]).join('');
+            expect(() => JSON.parse(written)).not.toThrow();
+            const caveatOnStdout = logSpy.mock.calls.filter((c) => /awm watch/i.test(String(c[0])));
+            expect(caveatOnStdout).toHaveLength(0);
+            const caveatOnStderr = errSpy.mock.calls.filter((c) => /awm watch/i.test(String(c[0])));
+            expect(caveatOnStderr).toHaveLength(1);
+            errSpy.mockRestore();
+        });
     });
     it('returns exit 0 on a bare HOME and never prompts with --yes (cache stubbed)', async () => {
         const { runInit } = require('../../src/commands/init');

package/dist/tests/commands/job/gate-reconcile.test.js

@@ -278,6 +278,23 @@ describe('computeTrackGate — gate local de un track (C6, R3.5)', () => {
         expect((0, gate_1.computeTrackGate)(s, false, () => 'same')).toEqual({ pass: true, reasons: [] });
         expect((0, gate_1.computeGate)(s, false, () => 'same').pass).toBe(false);
     });
+    // El journal de un track REAL tiene `requiredVerifiers: []`: `initTrackJournal` llama a
+    // `initJournal`, no a `initWatch`, así que la detección mecánica de verificadores nunca
+    // corre sobre el worktree del track. La fixture de arriba los pobla a mano y por eso
+    // tapaba el defecto — R3.6 ("el repo no tiene test/sensors configurado") vivía FUERA del
+    // guard `requireGlobalKinds`, así que el gate local de todo track quedaba rojo para
+    // siempre, `attemptFreeze` devolvía `continue` en cada tick, y sin freeze no hay merge
+    // (C3) ni `COMPLETE`. Observado en la certificación con supervisor vivo.
+    test('un journal de track SIN requiredVerifiers (el caso real) certifica igual: R3.6 es del gate global', () => {
+        const s = stateWithCompletedTrackTask();
+        s.requiredVerifiers = [];
+        const g = (0, gate_1.computeTrackGate)(s, false, () => 'same');
+        expect(g.reasons.filter((r) => /no se certifica por ausencia/.test(r.detail))).toEqual([]);
+        expect(g).toEqual({ pass: true, reasons: [] });
+        // El gate GLOBAL sí sigue exigiéndolo: la regla no se debilitó, se puso en su scope.
+        const global = (0, gate_1.computeGate)({ ...s, requiredVerifiers: [] }, false, () => 'same');
+        expect(global.reasons.some((r) => /no se certifica por ausencia/.test(r.detail))).toBe(true);
+    });
     test('corrupcion o journal ausente bloquea con categoria propia (corrupt-state)', () => {
         const g = (0, gate_1.computeTrackGate)(null, true, () => 'same');
         expect(g.pass).toBe(false);

package/dist/tests/commands/multi-agent-targeting.test.js

@@ -18,6 +18,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
+/** Un registry sincronizado con éxito. `awm update` con CERO registries es una máquina sin
+ *  `awm init`: falla en vez de anunciar que actualizó (ver `tests/commands/update.test.ts`),
+ *  así que los tests de acá — que miden targeting de agentes y el caveat de Windows, no
+ *  registries — necesitan al menos uno para llegar a las etapas que sí les importan. */
+const SYNCED_REGISTRY = { name: 'baseline', action: 'pulled', version: 'v1.0.0' };
 describe('multi-agent targeting (add/remove/sync/update/doctor)', () => {
     let tmpHome;
     let originalHome;
@@ -95,7 +100,7 @@ describe('multi-agent targeting (add/remove/sync/update/doctor)', () => {
                 const { runUpdateCore } = require('../../src/commands/update');
                 let captured = [];
                 const outcome = await runUpdateCore({ agent: explicit }, {
-                    syncRegistries: async () => [],
+                    syncRegistries: async () => [SYNCED_REGISTRY],
                     verifyMinCliVersions: () => [],
                     regenerateGlobalContext: () => [],
                     planReconciliation: (o) => { captured = o.targets; return { operations: [], records: [], reports: [] }; },
@@ -174,7 +179,7 @@ describe('multi-agent targeting (add/remove/sync/update/doctor)', () => {
         fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'hooks'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(process.env.AWM_HOME, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: 'https://example.com/baseline.git' }], null, 2));
         const { runUpdateCore } = require('../../src/commands/update');
-        const syncRegistries = jest.fn(async () => []);
+        const syncRegistries = jest.fn(async () => [SYNCED_REGISTRY]);
         const planReconciliation = jest.fn((o) => ({ operations: [], records: [], reports: [] }));
         const applyInstallPlan = jest.fn(() => ({ installed: [], skipped: [], transactionId: 'tx', modifiedFiles: [] }));
         const resyncInstalledHooks = jest.fn(() => []);
@@ -198,7 +203,7 @@ describe('multi-agent targeting (add/remove/sync/update/doctor)', () => {
         writePrefs(['claude-code'], 'claude-code');
         const { runUpdateCore } = require('../../src/commands/update');
         const outcome = await runUpdateCore({}, {
-            syncRegistries: async () => [],
+            syncRegistries: async () => [SYNCED_REGISTRY],
             verifyMinCliVersions: () => [],
             regenerateGlobalContext: () => [],
             planReconciliation: () => { throw new Error('reconciliation exploded'); },
@@ -231,7 +236,7 @@ describe('multi-agent targeting (add/remove/sync/update/doctor)', () => {
             writePrefs(['claude-code']);
             const { runUpdateCore } = require('../../src/commands/update');
             const deps = {
-                syncRegistries: async () => [],
+                syncRegistries: async () => [SYNCED_REGISTRY],
                 verifyMinCliVersions: () => [],
                 regenerateGlobalContext: () => [],
                 planReconciliation: () => ({ operations: [], records: [], reports: [] }),

package/dist/tests/commands/track/supervisor-wrapper.test.js

@@ -93,6 +93,27 @@ describe('runSupervisorWrapper — claim exact-once + espera read-only del ACTIV
         expect(second).toBe('already-claimed');
         expect(secondLaunched).toBe(false);
     });
+    // El wrapper esperaba la IGUALDAD EXACTA con `ACTIVE`, con un poll de 2 s en producción.
+    // Eso es una carrera: el plan puede cruzar `ACTIVE` entre dos lecturas y dejar al wrapper
+    // esperando para siempre una fase que ya pasó — sin `awm watch`, nadie consume las
+    // requests cross-journal del track (empezando por `track-freeze-request`) y la cohorte se
+    // traba en el freeze. Se observó al reparar el join: un track podía ir
+    // `ARMED -> ACTIVE -> JOIN_REQUESTED` dentro de un mismo `reconcileTracks`.
+    test.each(['ACTIVE', 'JOIN_REQUESTED', 'FROZEN'])('lanza watch con el track ya en %s: la condición es monótona, no la igualdad con ACTIVE', async (phase) => {
+        seedTrackRef(phase);
+        let launched = null;
+        const outcome = await (0, supervisor_wrapper_1.runSupervisorWrapper)({
+            worktreePath, trackId: 'cli', nonce: NONCE, readinessNonce: 'nonce-cli'.padEnd(32, '0'), fencingToken: 'fence',
+            planRoot, planBranch: 'main', pollMs: 5,
+            launchWatch: (wt) => {
+                launched = wt;
+                fs_1.default.mkdirSync(path_1.default.dirname((0, paths_1.supervisorLockPath)(wt)), { recursive: true });
+                fs_1.default.writeFileSync((0, paths_1.supervisorLockPath)(wt), '{}');
+            },
+        });
+        expect(outcome).toBe('active');
+        expect(launched).toBe(worktreePath);
+    });
     test('si el plan bloquea el track, el wrapper jamás lanza `awm watch` (C1, R4.9)', async () => {
         seedTrackRef('BLOCKED');
         let launched = false;

package/dist/tests/commands/track/verbs.test.js

@@ -31,6 +31,11 @@ function git(repo, args) {
 function gitInit(repo, branch) {
     (0, child_process_1.execFileSync)('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', 'init', '-q', '-b', branch], { cwd: repo });
     fs_1.default.writeFileSync(path_1.default.join(repo, 'f.txt'), 'x');
+    // `.awm/` gitignoreado, igual que lo deja `awm watch --init` (watch/init.ts) y que
+    // `runPrepareTrack` EXIGE en cada worktree nuevo: sin esto el journal propio hace que
+    // `git status` reporte el árbol sucio para siempre, y cualquier test que dependa de un
+    // árbol limpio mediría un repo que en producción no existe.
+    fs_1.default.writeFileSync(path_1.default.join(repo, '.gitignore'), '.awm/\n');
     (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 });
 }
@@ -98,6 +103,48 @@ describe('awm track — verbos mutantes son request-only (R6.1)', () => {
         expect(git(repo, ['rev-parse', 'HEAD'])).toBe(beforeHead);
         expect(fs_1.default.readFileSync((0, paths_1.statePath)(repo, branch), 'utf8')).toBe(beforeState);
     });
+    // `finalize` es PLAN-scoped y sin <trackId>, así que no entra en las matrices de
+    // add/join/remove — pero comparte con ellas la propiedad que define a la superficie:
+    // emite una request y no toca Git ni state.json.
+    test('finalize emite track-finalize-request con el HEAD del plan, y no muta Git/state (R7.2)', async () => {
+        const beforeHead = git(repo, ['rev-parse', 'HEAD']);
+        const beforeState = fs_1.default.readFileSync((0, paths_1.statePath)(repo, branch), 'utf8');
+        const out = await runCli(repo, ['track', 'finalize', '--generation', 'g1']);
+        expect(out.exitCode).toBe(0);
+        expect(readPendingKinds(repo, branch)).toContain('track-finalize-request');
+        const pending = (0, requests_1.listPendingRequests)(repo, branch).find((p) => !p.corrupt && p.envelope.kind === 'track-finalize-request');
+        // El HEAD se LEE del repo: es el autoreporte del controller sobre SU propio HEAD,
+        // no un valor que el llamador pueda elegir.
+        expect((pending?.envelope.payload).qaHeadSha).toBe(beforeHead);
+        expect(git(repo, ['rev-parse', 'HEAD'])).toBe(beforeHead);
+        expect(fs_1.default.readFileSync((0, paths_1.statePath)(repo, branch), 'utf8')).toBe(beforeState);
+    });
+    test('finalize exige --generation', async () => {
+        const out = await runCli(repo, ['track', 'finalize']);
+        expect(out.exitCode).not.toBe(0);
+        expect(readPendingKinds(repo, branch)).toEqual([]);
+    });
+    test('finalize con el árbol sucio falla nombrando lo que falta, en vez de emitir un autoreporte que el supervisor va a rechazar en silencio', async () => {
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'pendiente.txt'), 'sin comitear');
+        const out = await runCli(repo, ['track', 'finalize', '--generation', 'g1']);
+        expect(out.exitCode).not.toBe(0);
+        expect(out.err).toMatch(/sin comitear/);
+        expect(readPendingKinds(repo, branch)).toEqual([]);
+    });
+    test('re-reportar el MISMO HEAD colapsa por idempotencyKey; un HEAD nuevo es una request nueva', async () => {
+        await runCli(repo, ['track', 'finalize', '--generation', 'g1']);
+        const first = (0, requests_1.listPendingRequests)(repo, branch).filter((p) => !p.corrupt).map((p) => p.envelope.idempotencyKey);
+        await runCli(repo, ['track', 'finalize', '--generation', 'g1']);
+        const second = (0, requests_1.listPendingRequests)(repo, branch).filter((p) => !p.corrupt).map((p) => p.envelope.idempotencyKey);
+        expect(new Set(second)).toEqual(new Set(first)); // mismo HEAD => misma key
+        // La QA encontró algo más, se corrigió y se comiteó: HEAD nuevo, request nueva.
+        fs_1.default.writeFileSync(path_1.default.join(repo, 'fix.txt'), 'correccion de QA');
+        (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', 'fix'], { cwd: repo });
+        await runCli(repo, ['track', 'finalize', '--generation', 'g1']);
+        const third = new Set((0, requests_1.listPendingRequests)(repo, branch).filter((p) => !p.corrupt).map((p) => p.envelope.idempotencyKey));
+        expect(third.size).toBe(new Set(first).size + 1);
+    });
     test.each(['add', 'join', 'remove'])('%s exige --generation (Commander valida antes de emitir)', async (verb) => {
         const out = await runCli(repo, ['track', verb, 'cli']);
         expect(out.exitCode).not.toBe(0);
@@ -316,10 +363,10 @@ describe('awm track status — sale 1 con gate rojo a nivel CLI (Gap: solo se pr
         expect(parsed.tracks.cli.gate.reasons.some((r) => r.category === 'pending-task')).toBe(true);
     });
 });
-describe('awm track --help lista exactamente los 6 verbos', () => {
-    test('help incluye add, list, status, verify-independence, join, remove', async () => {
+describe('awm track --help lista exactamente los 7 verbos', () => {
+    test('help incluye add, list, status, verify-independence, join, remove, finalize', async () => {
         const out = await runCli(process.cwd(), ['track', '--help']);
-        for (const verb of ['add', 'list', 'status', 'verify-independence', 'join', 'remove']) {
+        for (const verb of ['add', 'list', 'status', 'verify-independence', 'join', 'remove', 'finalize']) {
             expect(out.out).toContain(verb);
         }
     });

package/dist/tests/commands/update.test.js

@@ -0,0 +1,243 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// `awm update` no debe anunciar trabajo que no hizo, ni colgarse esperando a un humano
+// que no está.
+//
+// Los dos defectos que estos tests dejan cerrados se reprodujeron en un HOME aislado
+// contra el binario publicado (v6.3.0):
+//
+//   1. Sobre un AWM_HOME recién creado, SIN NINGÚN registry configurado, el comando
+//      imprimía "✅ Registries, skills and hooks updated." y salía 0. No había registries,
+//      no había skills y no había hooks: cada etapa "pasaba" porque no tenía nada que
+//      hacer, y `runUpdateCore` devolvía `{ code: 0 }` incondicionalmente al final. El
+//      literal del outro en `index.ts` solo podía decir "actualizado".
+//   2. Con un TTY en stdin, el comando quedaba colgado para siempre en el confirm de
+//      self-update ("Update awm v6.2.1 → v6.3.0 now?"). Con `< /dev/null` terminaba bien
+//      — es decir, el cuelgue aparecía exactamente cuando había un humano, y desaparecía
+//      cuando no lo había, que es al revés de lo que hace falta: en CI, cron o una sesión
+//      agéntica no hay nadie para contestar.
+//
+// Ambos se testean por el VALOR DE RETORNO y por el texto derivado, no scrapeando consola:
+// el defecto vivía justamente en que el retorno no llevaba la información que el mensaje
+// necesitaba.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+// `@clack/prompts` es ESM-only y el transform CommonJS de ts-jest no puede cargarlo; se
+// mockea para poder `require` `core/update-check` desde acá (mismo patrón que
+// `tests/core/update-check.test.ts`). Los tests inyectan su propio `confirmImpl`, así que
+// este doble nunca llega a usarse: solo evita que el import de nivel de módulo explote.
+jest.mock('@clack/prompts', () => ({
+    confirm: jest.fn(),
+    isCancel: jest.fn(),
+}));
+/** Preferencias mínimas válidas en el AWM_HOME activo (`normalizePreferences` exige los
+ *  cuatro campos). Se llama despues de fijar HOME/AWM_HOME, nunca antes. */
+function writePrefs() {
+    const { savePreferences } = require('../../src/utils/config');
+    savePreferences({
+        defaultAgent: 'claude-code',
+        enabledAgents: ['claude-code'],
+        installMethod: 'symlink',
+        defaultScope: 'local',
+    });
+}
+describe('awm update — honest outcome', () => {
+    const realHome = process.env.HOME;
+    const realAwmHome = process.env.AWM_HOME;
+    let tmpHome;
+    let logSpy;
+    let warnSpy;
+    let errSpy;
+    beforeEach(() => {
+        // Ningún test toca el `~/.awm` real (CLAUDE.md): HOME y AWM_HOME apuntan al tmpdir.
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-update-'));
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        fs_1.default.mkdirSync(process.env.AWM_HOME, { recursive: true });
+        writePrefs();
+        logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
+        warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        errSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+        jest.resetModules();
+    });
+    afterEach(() => {
+        logSpy.mockRestore();
+        warnSpy.mockRestore();
+        errSpy.mockRestore();
+        if (realHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = realHome;
+        if (realAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = realAwmHome;
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+    });
+    function deps(overrides = {}) {
+        return {
+            syncRegistries: async () => [{ name: 'baseline', action: 'pulled', version: 'v1.15.1' }],
+            verifyMinCliVersions: () => [],
+            regenerateGlobalContext: () => [],
+            planReconciliation: () => ({ operations: [], records: [], reports: [] }),
+            applyInstallPlan: () => ({ installed: [], skipped: [], transactionId: 'tx', modifiedFiles: [] }),
+            resyncInstalledHooks: () => [],
+            offerSelfUpdate: async () => { },
+            ...overrides,
+        };
+    }
+    it('sin registries configurados NO declara éxito: sale != 0 y manda a `awm init`', async () => {
+        const { runUpdateCore, updateOutro } = require('../../src/commands/update');
+        const result = await runUpdateCore({}, deps({ syncRegistries: async () => [] }));
+        expect(result.code).not.toBe(0);
+        expect(result.registries).toEqual({ configured: 0, synced: 0, failed: [] });
+        // El cierre nunca puede afirmar que se actualizó algo.
+        expect(updateOutro(result)).toBe('Nothing updated — no registries configured on this machine.');
+        expect(updateOutro(result)).not.toMatch(/updated\./i);
+        expect(errSpy.mock.calls.flat().join('\n')).toMatch(/awm init/);
+    });
+    it('sin registries no sigue con las etapas posteriores (que "pasarían" por vacías)', async () => {
+        const { runUpdateCore } = require('../../src/commands/update');
+        const planReconciliation = jest.fn(() => ({ operations: [], records: [], reports: [] }));
+        const resyncInstalledHooks = jest.fn(() => []);
+        const offerSelfUpdate = jest.fn(async () => { });
+        await runUpdateCore({}, deps({
+            syncRegistries: async () => [],
+            planReconciliation, resyncInstalledHooks, offerSelfUpdate,
+        }));
+        expect(planReconciliation).not.toHaveBeenCalled();
+        expect(resyncInstalledHooks).not.toHaveBeenCalled();
+        expect(offerSelfUpdate).not.toHaveBeenCalled();
+    });
+    it('con registries sincronizados sí declara éxito, y dice cuántos', async () => {
+        const { runUpdateCore, updateOutro } = require('../../src/commands/update');
+        const result = await runUpdateCore({}, deps({
+            syncRegistries: async () => [
+                { name: 'baseline', action: 'pulled', version: 'v1.15.1' },
+                { name: 'docs', action: 'recloned', version: 'v2.0.0' },
+            ],
+        }));
+        expect(result.code).toBe(0);
+        expect(result.registries).toEqual({ configured: 2, synced: 2, failed: [] });
+        expect(updateOutro(result)).toBe('✅ 2 registries, skills and hooks updated.');
+    });
+    it('un registry que falló y NO dejó contenido en disco falla cerrado', async () => {
+        const { runUpdateCore } = require('../../src/commands/update');
+        const result = await runUpdateCore({}, deps({
+            syncRegistries: async () => [{ name: 'baseline', action: 'error', error: 'network unreachable' }],
+        }));
+        expect(result.code).toBe(1);
+        expect(result.registries.failed).toEqual(['baseline']);
+    });
+    it('un registry que falló pero conserva contenido sigue, y el cierre lo nombra en vez de anunciar éxito parejo', async () => {
+        // `unusableSyncedRegistries` mira contenido EN DISCO: se siembra el content root
+        // y el registries.json para que `docs` cuente como stale, no como roto.
+        const registriesDir = path_1.default.join(process.env.AWM_HOME, 'registries');
+        fs_1.default.mkdirSync(path_1.default.join(registriesDir, 'docs'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(process.env.AWM_HOME, 'registries.json'), JSON.stringify([{ name: 'docs', remote: 'https://example.test/docs.git' }]));
+        const { runUpdateCore, updateOutro } = require('../../src/commands/update');
+        const result = await runUpdateCore({}, deps({
+            syncRegistries: async () => [
+                { name: 'baseline', action: 'pulled', version: 'v1.15.1' },
+                { name: 'docs', action: 'error', error: 'network unreachable' },
+            ],
+        }));
+        expect(result.code).toBe(0);
+        expect(result.registries).toEqual({ configured: 2, synced: 1, failed: ['docs'] });
+        const outro = updateOutro(result);
+        expect(outro).toMatch(/stale/i);
+        expect(outro).toMatch(/docs/);
+        expect(outro).not.toMatch(/^✅/);
+    });
+});
+describe('awm update — nunca se cuelga esperando a un humano que no está', () => {
+    const realHome = process.env.HOME;
+    const realAwmHome = process.env.AWM_HOME;
+    let tmpHome;
+    let logSpy;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-update-tty-'));
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        fs_1.default.mkdirSync(process.env.AWM_HOME, { recursive: true });
+        writePrefs();
+        logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
+        jest.resetModules();
+    });
+    afterEach(() => {
+        logSpy.mockRestore();
+        if (realHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = realHome;
+        if (realAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = realAwmHome;
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+    });
+    function updateDeps(offerSelfUpdate) {
+        return {
+            syncRegistries: async () => [{ name: 'baseline', action: 'pulled', version: 'v1.15.1' }],
+            verifyMinCliVersions: () => [],
+            regenerateGlobalContext: () => [],
+            planReconciliation: () => ({ operations: [], records: [], reports: [] }),
+            applyInstallPlan: () => ({ installed: [], skipped: [], transactionId: 'tx', modifiedFiles: [] }),
+            resyncInstalledHooks: () => [],
+            offerSelfUpdate,
+        };
+    }
+    it('`--yes` pide assume-yes; sin flag delega la decisión al modo por defecto', async () => {
+        const { runUpdateCore } = require('../../src/commands/update');
+        const withFlag = jest.fn(async () => { });
+        await runUpdateCore({ yes: true }, updateDeps(withFlag));
+        expect(withFlag).toHaveBeenCalledWith('assume-yes');
+        const withoutFlag = jest.fn(async () => { });
+        await runUpdateCore({}, updateDeps(withoutFlag));
+        // `undefined`, no `'prompt'`: quién decide es `defaultSelfUpdateMode()`, según
+        // haya o no alguien en stdin. Fijar 'prompt' acá reintroduciría el cuelgue.
+        expect(withoutFlag).toHaveBeenCalledWith(undefined);
+    });
+    describe('defaultSelfUpdateMode / offerSelfUpdate', () => {
+        const realIsTTY = process.stdin.isTTY;
+        const realNoCheck = process.env.AWM_NO_UPDATE_CHECK;
+        beforeEach(() => { delete process.env.AWM_NO_UPDATE_CHECK; });
+        afterEach(() => {
+            Object.defineProperty(process.stdin, 'isTTY', { value: realIsTTY, configurable: true });
+            if (realNoCheck === undefined)
+                delete process.env.AWM_NO_UPDATE_CHECK;
+            else
+                process.env.AWM_NO_UPDATE_CHECK = realNoCheck;
+        });
+        it('sin TTY el modo por defecto es skip; con TTY es prompt', () => {
+            const { defaultSelfUpdateMode } = require('../../src/core/update-check');
+            Object.defineProperty(process.stdin, 'isTTY', { value: undefined, configurable: true });
+            expect(defaultSelfUpdateMode()).toBe('skip');
+            Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true });
+            expect(defaultSelfUpdateMode()).toBe('prompt');
+        });
+        it('sin TTY no pregunta ni actualiza: avisa y sigue', async () => {
+            const { offerSelfUpdate } = require('../../src/core/update-check');
+            Object.defineProperty(process.stdin, 'isTTY', { value: undefined, configurable: true });
+            const confirmImpl = jest.fn(async () => true);
+            const runner = jest.fn(() => ({ status: 0 }));
+            await offerSelfUpdate({ current: '6.2.1', latest: '6.3.0', confirmImpl, runner });
+            expect(confirmImpl).not.toHaveBeenCalled();
+            // El silencio no autoriza reemplazar el binario global de la máquina.
+            expect(runner).not.toHaveBeenCalled();
+            expect(logSpy.mock.calls.flat().join('\n')).toMatch(/npm i -g/);
+        });
+        it("modo 'assume-yes' actualiza sin preguntar", async () => {
+            const { offerSelfUpdate } = require('../../src/core/update-check');
+            const confirmImpl = jest.fn(async () => true);
+            const runner = jest.fn(() => ({ status: 0 }));
+            await offerSelfUpdate({ current: '6.2.1', latest: '6.3.0', mode: 'assume-yes', confirmImpl, runner });
+            expect(confirmImpl).not.toHaveBeenCalled();
+            expect(runner).toHaveBeenCalledWith('npm', ['i', '-g', expect.stringContaining('@latest')]);
+        });
+    });
+});

package/dist/tests/commands/watch/apply.test.js

@@ -478,6 +478,56 @@ describe('aplicacion transaccional de requests', () => {
         expect(fs_1.default.existsSync(`${r.file}.rejected`)).toBe(true);
         expect((0, store_1.readJournal)(repo, 'rama').state.trackIntegration).toBeUndefined();
     });
+    // El modo de falla que estos dos tests cierran: `applyRequestToState` era una cadena de
+    // `if (env.kind === …) { …; return; }` que se caía POR EL FINAL ante un kind sin handler.
+    // El caller no veía excepción, hacía `applied++` y BORRABA el archivo. `awm track join`
+    // vivió así: salía 0 con su requestId, el journal contaba la request como aplicada, y el
+    // track se quedaba en `ACTIVE` para siempre — la cohorte no podía congelarse (C3) y por
+    // lo tanto nunca llegaba a `COMPLETE`.
+    test('track-join-request marca la intención de join sobre un track existente (declarativo, R6.1)', () => {
+        const s0 = (0, store_1.readJournal)(repo, 'rama').state;
+        const alpha = {
+            trackId: 'alpha', worktreePath: path_1.default.join(repo, '.track-alpha'), branch: 'awm-track/alpha',
+            ownership: [], sharedResources: [], dependsOn: [],
+            fencingToken: 'f'.repeat(32), phase: 'ACTIVE', readinessNonce: 'n'.repeat(32),
+        };
+        s0.tracks = [alpha];
+        (0, store_1.writeJournal)(repo, 'rama', s0);
+        (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'track-join-request', generationToken: 'g1', idempotencyKey: 'join-alpha',
+            payload: { trackId: 'alpha' },
+        });
+        expect((0, apply_1.consumePendingRequests)(repo, 'rama', 'g1').applied).toBe(1);
+        const s = (0, store_1.readJournal)(repo, 'rama').state;
+        expect(s.tracks.find((t) => t.trackId === 'alpha').joinRequested).toBe(true);
+        // La FASE no la mueve este consumo: eso es del reducer puro vía `reconcileTracks`.
+        expect(s.tracks.find((t) => t.trackId === 'alpha').phase).toBe('ACTIVE');
+    });
+    test('un join sobre un track inexistente se RECHAZA en vez de absorberse en silencio', () => {
+        const r = (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'track-join-request', generationToken: 'g1', idempotencyKey: 'join-fantasma',
+            payload: { trackId: 'no-existe' },
+        });
+        const out = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        expect(out.applied).toBe(0);
+        expect(out.rejectedInvalid).toBe(1);
+        expect(fs_1.default.existsSync(`${r.file}.rejected`)).toBe(true);
+    });
+    test('un kind SIN handler falla cerrado: rechazo visible, no un `applied` que borra el archivo', () => {
+        // `track-teardown-request` es un kind real, emitido por `awm track remove`, que hoy
+        // no tiene handler en el supervisor. Antes de este cambio se contaba como aplicado y
+        // desaparecía sin dejar rastro; ahora queda registrado como problema y el archivo se
+        // conserva con sufijo `.rejected`, que es lo que permite darse cuenta.
+        const r = (0, requests_1.emitRequest)(repo, 'rama', {
+            kind: 'track-teardown-request', generationToken: 'g1', idempotencyKey: 'teardown-1',
+            payload: { trackId: 'alpha' },
+        });
+        const out = (0, apply_1.consumePendingRequests)(repo, 'rama', 'g1');
+        expect(out.applied).toBe(0);
+        expect(out.rejectedInvalid).toBe(1);
+        expect(fs_1.default.existsSync(`${r.file}.rejected`)).toBe(true);
+        expect((0, store_1.readJournal)(repo, 'rama').state.requestProblems.some((p) => p.kind === 'rejected')).toBe(true);
+    });
     test('track-finalize-request persiste el autoreporte del controller (qaFinalizeRequested) — puramente declarativo (R7.2)', () => {
         (0, requests_1.emitRequest)(repo, 'rama', {
             kind: 'track-finalize-request', generationToken: 'g1', idempotencyKey: 'finalize-1',