agentic-workflow-manager 6.4.0 → 6.4.2

package/dist/src/commands/add.js

@@ -52,13 +52,30 @@ function runAddBundleCore(options, prefs, bundles, deps = {}) {
         console.error(picocolors_1.default.red('No project root found (need a .git/, package.json, or .awm/profile.json here). Run inside a project, or pass --global.'));
         return { code: 1, selectedAgents };
     }
+    // `--method` used to be accepted here and silently discarded — this branch
+    // hardcoded 'symlink' regardless of what was passed. Since D-001 made bundle
+    // names the ONLY thing `add [name]` resolves against, this is the sole live
+    // path for any real invocation; the interactive/`--all` path below still has
+    // its own (correct) method resolution, but a valid bundle name never reaches
+    // it. Found running the issue #55 Windows playbook's WIN-02: `--method copy`
+    // on native Windows still produced a Junction, because 'symlink' was the
+    // only value that ever actually reached the installer. The no-flag default
+    // stays 'symlink' (unchanged) — only the explicit-override case was broken.
+    let methodVal = 'symlink';
+    if (options.method) {
+        if (options.method !== 'symlink' && options.method !== 'copy') {
+            console.error(picocolors_1.default.red(`Invalid method "${options.method}". Use: symlink or copy.`));
+            return { code: 1, selectedAgents };
+        }
+        methodVal = options.method;
+    }
     let result;
     try {
         result = d.addBundle({
             bundleName: matchedBundle.name,
             bundles,
             agents: selectedAgents,
-            method: 'symlink',
+            method: methodVal,
             projectRoot: projectRoot ?? cwd,
             scopeOverride,
         });

package/dist/src/commands/init.js

@@ -128,8 +128,17 @@ async function runInit(opts = {}) {
     // Fires at most once per `awm init` run (native Windows only) — this is
     // the single emission point; `renderReport`/`renderInitOutcome` below do
     // NOT also embed it (that used to triple-fire the same text: once here,
-    // once in the "Initial state" render, once in "Final state").
-    (0, paths_1.noteWindowsCaveat)((m) => console.log(picocolors_1.default.dim(`ℹ ${m}`)));
+    // once in the "Initial state" render, once in "Final state"). In `--json`
+    // mode it goes to stderr instead of stdout: stdout must stay pure JSON for
+    // `awm init --yes --json > init.json` (documented in core-acceptance.md
+    // CORE-03) — a stray banner ahead of the `{` broke that contract on every
+    // native-Windows `--json` run.
+    if (opts.json) {
+        (0, paths_1.noteWindowsCaveat)((m) => process.stderr.write(picocolors_1.default.dim(`ℹ ${m}`) + '\n'));
+    }
+    else {
+        (0, paths_1.noteWindowsCaveat)((m) => console.log(picocolors_1.default.dim(`ℹ ${m}`)));
+    }
     const cwd = opts.cwd ?? process.cwd();
     const agent = opts.agent === undefined ? 'claude-code' : (0, providers_1.requireAgentTarget)(opts.agent);
     // R2: gate BEFORE anything is read or written — an unsupported provider

package/dist/src/commands/job/gate.js

@@ -22,6 +22,8 @@ function evaluateEvidence(state, fingerprintNow, scope) {
             reasons.push({ category: 'pending-task', detail: `task ${t.id} en ${t.status}` });
         }
     }
+    const allPlans = [...tasksInScope.flatMap((t) => t.verificationPlan), ...state.cycleVerificationPlan];
+    const presentKinds = new Set(allPlans.map((i) => i.kind));
     if (scope.requireGlobalKinds) {
         if (state.cycleVerificationPlan.length === 0) {
             reasons.push({ category: 'empty-cycle-plan', detail: 'CycleVerificationPlan vacio: un ciclo sin plan de cierre jamas certifica (R1.4b)' });
@@ -31,16 +33,28 @@ function evaluateEvidence(state, fingerprintNow, scope) {
                 reasons.push({ category: 'missing-verifier', detail: `CycleVerificationPlan requiere '${required}'` });
             }
         }
-    }
-    // Verificadores requeridos por la config REAL del repo (watch --init):
-    // cada kind requerido debe existir en algun plan (R1.4b, R3.6).
-    const allPlans = [...tasksInScope.flatMap((t) => t.verificationPlan), ...state.cycleVerificationPlan];
-    const presentKinds = new Set(allPlans.map((i) => i.kind));
-    for (const mechanical of ['test', 'sensors']) {
-        if (!state.requiredVerifiers.includes(mechanical)) {
-            reasons.push({ category: 'missing-verifier', detail: `el repo no tiene '${mechanical}' configurado; no se certifica por ausencia (R3.6)` });
+        // R3.6 es una afirmación sobre la CONFIG DEL REPO ("este repo no tiene test/sensors,
+        // así que no se certifica por ausencia"), y por eso vive del lado global del scope.
+        //
+        // Estaba afuera del guard, y eso hacía imposible que un track se congelara NUNCA:
+        // `computeTrackGate` pasa `requireGlobalKinds: false` precisamente porque el journal
+        // de un track no evalúa los kinds globales, pero heredaba igual esta exigencia — y
+        // `requiredVerifiers` de un journal de track es SIEMPRE `[]`, porque
+        // `initTrackJournal` llama a `initJournal` y no a `initWatch`, así que la detección
+        // mecánica nunca corre ahí. Gate local rojo para siempre => `attemptFreeze` devolvía
+        // `continue` en cada tick => la cohorte no podía congelarse => sin C3 no hay merge, y
+        // por lo tanto no hay `COMPLETE`. Se observó en la certificación con supervisor vivo:
+        // `alpha` con el freeze pedido, su worktree limpio, cero jobs vivos, y estas dos
+        // razones como único motivo.
+        for (const mechanical of ['test', 'sensors']) {
+            if (!state.requiredVerifiers.includes(mechanical)) {
+                reasons.push({ category: 'missing-verifier', detail: `el repo no tiene '${mechanical}' configurado; no se certifica por ausencia (R3.6)` });
+            }
         }
     }
+    // Este otro sí es por scope: "lo que el repo exige tiene que estar en ALGÚN plan del
+    // scope". En un journal de track es un no-op (`requiredVerifiers` vacío), y si algún día
+    // se poblara, exigirlo sobre los planes del track es lo correcto.
     for (const required of state.requiredVerifiers) {
         if (!presentKinds.has(required)) {
             reasons.push({ category: 'missing-verifier', detail: `el repo exige verificador '${required}' y ningun plan lo contiene` });

package/dist/src/commands/track/emit.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.emitTrackRequest = emitTrackRequest;
+exports.emitFinalizeRequest = emitFinalizeRequest;
 // Emisores de requests de track (R6.1): `add`/`join`/`remove` jamas mutan
 // Git ni el journal directamente — el unico efecto observable es publicar
 // una request inmutable que el supervisor del plan consume despues (mismo
@@ -13,6 +14,7 @@ exports.emitTrackRequest = emitTrackRequest;
 // intents distintos sobre el mismo track jamas colisionan.
 const crypto_1 = __importDefault(require("crypto"));
 const requests_1 = require("../../core/journal/requests");
+const git_1 = require("../../core/tracks/git");
 function emitTrackRequest(repoRoot, branch, generationToken, kind, trackId) {
     if (trackId.length === 0)
         throw new Error('trackId obligatorio');
@@ -24,3 +26,41 @@ function emitTrackRequest(repoRoot, branch, generationToken, kind, trackId) {
         payload,
     });
 }
+/**
+ * `track-finalize-request`: el autoreporte del controller del PLAN — "corrí la QA global
+ * sobre el HEAD ya mergeado de todos los tracks, corregí los hallazgos y comiteé; este es
+ * mi HEAD limpio".
+ *
+ * Es PLAN-scoped y no lleva `trackId`, por eso no pasa por `emitTrackRequest`.
+ *
+ * Sin este emisor la cohorte no tenía salida: `runRequestGlobalQa` (watch/tracks.ts) espera
+ * `s.qaFinalizeRequested`, que solo se puebla aplicando esta request, y NADA en el producto
+ * la emitía — el único lugar del repo que la producía era el harness de tests, llamando
+ * `emitRequest` directo. Es decir, `COMPLETE` era alcanzable solo desde adentro de los
+ * tests: en producción, con todos los tracks en `MERGED_UNVERIFIED`, el supervisor esperaba
+ * para siempre una evidencia que ningún controller tenía forma de producir.
+ *
+ * El HEAD se LEE del repo, no se recibe por flag: el controller reporta el suyo, y un flag
+ * solo abriría la puerta a reportar un HEAD ajeno. El árbol sucio se rechaza acá, en el
+ * borde, para que el fallo diga qué falta en vez de manifestarse como una espera muda — pero
+ * eso NO reemplaza la re-verificación independiente del supervisor (HEAD real + árbol
+ * limpio en el momento de consumir la request), que sigue siendo la autoridad fail-closed.
+ * El chequeo del borde es un diagnóstico, nunca la prueba.
+ */
+function emitFinalizeRequest(repoRoot, branch, generationToken) {
+    const dirty = (0, git_1.dirtyPaths)(repoRoot);
+    if (dirty.length > 0) {
+        throw new Error(`el arbol del plan tiene ${dirty.length} ruta(s) sin comitear (${dirty.slice(0, 3).join(', ')}${dirty.length > 3 ? ', …' : ''}): `
+            + 'la QA global se reporta sobre un HEAD limpio — comiteá las correcciones antes de finalizar');
+    }
+    const qaHeadSha = (0, git_1.headSha)(repoRoot);
+    // La key liga el SHA: re-reportar el mismo HEAD colapsa (retry seguro), y un HEAD nuevo
+    // — porque la QA encontró algo más y se comiteó otra corrección — es una request nueva.
+    const emitted = (0, requests_1.emitRequest)(repoRoot, branch, {
+        kind: 'track-finalize-request', generationToken,
+        idempotencyKey: crypto_1.default.createHash('sha256')
+            .update(`track-finalize-request\0${branch}\0${qaHeadSha}`).digest('hex'),
+        payload: { qaHeadSha },
+    });
+    return { ...emitted, qaHeadSha };
+}

package/dist/src/commands/track/index.js

@@ -85,8 +85,33 @@ function registerTrackCommand(program) {
         const r = (0, emit_1.emitTrackRequest)(repo, branch, opts.generation, 'track-join-request', trackId);
         process.stdout.write(JSON.stringify({ requestId: r.requestId, idempotencyKey: r.idempotencyKey }, null, 2) + '\n');
     });
+    track.command('finalize')
+        .description('emite track-finalize-request — autoreporte de QA global del controller del plan sobre el HEAD ya mergeado (R7.2)')
+        .requiredOption('--generation <token>', 'token de la generacion vigente')
+        .action((opts) => {
+        const repo = process.cwd();
+        const branch = branchOf(repo);
+        // Plan-scoped, igual que `list`/`status`: la QA global corre sobre el HEAD del
+        // PLAN con todos los tracks ya mergeados. Emitirla desde el worktree de un track
+        // escribiría el autoreporte en el journal equivocado, donde nadie lo espera.
+        assertPlanCwd(repo, branch);
+        let r;
+        try {
+            r = (0, emit_1.emitFinalizeRequest)(repo, branch, opts.generation);
+        }
+        catch (e) {
+            failGuard(`track finalize: ${e.message}`);
+        }
+        process.stdout.write(JSON.stringify({ requestId: r.requestId, idempotencyKey: r.idempotencyKey, qaHeadSha: r.qaHeadSha }, null, 2) + '\n');
+    });
+    // NO IMPLEMENTADO del lado del supervisor: no hay handler para `track-teardown-request`,
+    // así que la request se emite y el supervisor la RECHAZA (`request-rejected-invalid`).
+    // La descripción lo dice en vez de prometer un desmantelamiento que no ocurre — hasta
+    // este release afirmaba que el supervisor desmantelaba worktree/rama, y no lo hacía.
+    // El teardown que sí funciona es el automático de la degradación a serial
+    // (`begin-teardown` desde `FALLBACK_PENDING`), que no pasa por este verbo.
     track.command('remove')
-        .description('emite track-teardown-request — el supervisor del plan desmantela worktree/rama (R6.1)')
+        .description('NO IMPLEMENTADO: emite track-teardown-request, que el supervisor todavía no sabe aplicar y rechaza')
         .requiredOption('--generation <token>', 'token de la generacion vigente')
         .argument('<trackId>')
         .action((trackId, opts) => {

package/dist/src/commands/track/supervisor-wrapper.js

@@ -18,6 +18,11 @@ const atomic_file_1 = require("../../core/atomic-file");
 const store_1 = require("../../core/journal/store");
 const paths_1 = require("../../core/journal/paths");
 const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/** Fases desde las cuales el track YA tiene trabajo propio que atender, así que su
+ *  supervisor debe estar corriendo. Es el conjunto monótono "ACTIVE o posterior": el plan
+ *  puede haber avanzado varias fases entre dos polls de este wrapper, y perderse el arranque
+ *  por no haber visto la fase exacta deja al track sin nadie que consuma sus requests. */
+const LAUNCH_PHASES = ['ACTIVE', 'JOIN_REQUESTED', 'FROZEN', 'JOIN_INTENT', 'MERGED_UNVERIFIED', 'JOINED'];
 function localBranch(worktreePath) {
     return (0, child_process_2.execFileSync)('git', ['branch', '--show-current'], { cwd: worktreePath, encoding: 'utf8', stdio: process_1.EXEC_STDIO }).trim();
 }
@@ -67,7 +72,18 @@ async function runSupervisorWrapper(opts) {
         const r = (0, store_1.readJournal)(opts.planRoot, opts.planBranch);
         if (!r.corrupt && r.state !== null) {
             const ref = r.state.tracks?.find((t) => t.trackId === opts.trackId);
-            if (ref?.phase === 'ACTIVE')
+            // MONOTONO, nunca la igualdad exacta con `ACTIVE`. Esperar a ver una fase
+            // puntual con un poll de 2 s es una carrera: el plan puede cruzar `ACTIVE` entre
+            // dos lecturas y este wrapper quedarse esperando para siempre una fase que ya
+            // pasó — sin lanzar `awm watch`, así que las requests cross-journal del plan
+            // (empezando por `track-freeze-request`) no las consume nadie y la cohorte se
+            // traba en el freeze.
+            //
+            // Pasó de verdad: al reparar el join, un track podía ir `ARMED -> ACTIVE ->
+            // JOIN_REQUESTED` dentro de un mismo `reconcileTracks`, y la ventana `ACTIVE`
+            // dejó de ser observable. La igualdad exacta solo funcionaba mientras el join
+            // estaba roto y los tracks se quedaban parados en `ACTIVE`.
+            if (ref !== undefined && LAUNCH_PHASES.includes(ref.phase))
                 break;
             // BLOCKED/REMOVED: el plan ya decidió que este track no avanza —
             // el wrapper nunca lanza `awm watch` para un track que el plan

package/dist/src/commands/update.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateOutro = updateOutro;
 exports.runUpdateCore = runUpdateCore;
 // src/commands/update.ts
 //
@@ -24,6 +25,7 @@ const paths_1 = require("../core/paths");
 const config_1 = require("../utils/config");
 const agent_targets_1 = require("../core/agent-targets");
 const registries_1 = require("../core/registries");
+const paths_2 = require("../core/paths");
 const regenerate_1 = require("../core/context/regenerate");
 const reconciliation_1 = require("../core/reconciliation");
 const install_transaction_1 = require("../core/install-transaction");
@@ -35,12 +37,34 @@ const defaultDeps = {
     planReconciliation: reconciliation_1.planReconciliation,
     applyInstallPlan: install_transaction_1.applyInstallPlan,
     resyncInstalledHooks: resync_1.resyncInstalledHooks,
-    offerSelfUpdate: async () => {
+    offerSelfUpdate: async (mode) => {
         // eslint-disable-next-line @typescript-eslint/no-var-requires
         const { offerSelfUpdate: real } = require('../core/update-check');
-        await real();
+        await real({ mode });
     },
 };
+const NO_REGISTRIES = { configured: 0, synced: 0, failed: [] };
+/**
+ * El texto de cierre, derivado del resultado. Vive acá y no en la registración de
+ * Commander porque el literal de `index.ts` era el defecto: decía
+ * "✅ Registries, skills and hooks updated." con `code === 0`, y `code` valía 0 pase lo
+ * que pase — así que una máquina SIN NINGÚN registry configurado recibía la confirmación
+ * de que se le habían actualizado los registries, los skills y los hooks. Un comando que
+ * miente es peor que uno que falla: el que falla te manda a mirar, el que miente te manda
+ * a otro lado a buscar el problema.
+ */
+function updateOutro(result) {
+    const { registries: reg } = result;
+    if (reg.configured === 0)
+        return 'Nothing updated — no registries configured on this machine.';
+    if (result.code !== 0)
+        return 'Update failed — see errors above.';
+    if (reg.failed.length > 0) {
+        return `⚠ Updated with stale content — ${reg.synced}/${reg.configured} registries synced, `
+            + `kept on-disk content for: ${reg.failed.join(', ')}.`;
+    }
+    return `✅ ${reg.synced} ${reg.synced === 1 ? 'registry' : 'registries'}, skills and hooks updated.`;
+}
 /**
  * Core, UI-free `awm update` logic: resolves agent targets, runs every stage
  * in order (registry sync → CLI-version gate → context regen → artifact
@@ -58,7 +82,7 @@ async function runUpdateCore(options = {}, deps = {}) {
     const resolved = (0, agent_targets_1.resolveAgentTargetsOrError)({ prefs, explicit: options.agent });
     if (!resolved.ok) {
         console.error(picocolors_1.default.red(resolved.error));
-        return { code: 1, selectedAgents: [] };
+        return { code: 1, selectedAgents: [], registries: NO_REGISTRIES };
     }
     const selectedAgents = resolved.targets;
     const registryResults = await d.syncRegistries();
@@ -68,12 +92,39 @@ async function runUpdateCore(options = {}, deps = {}) {
         else
             console.log(picocolors_1.default.green(`  ✓ Registry ${r.name} ${r.action === 'pulled' ? 'updated' : 're-cloned'} @ ${r.version}`));
     }
+    const registries = {
+        configured: registryResults.length,
+        synced: registryResults.filter((r) => r.action !== 'error').length,
+        failed: registryResults.filter((r) => r.action === 'error').map((r) => r.name),
+    };
+    // Cero registries no es "todo al día": es una máquina que nunca corrió `awm init`
+    // (o cuyo registries.json se perdió). Seguir adelante regenera contexto vacío,
+    // reconcilia contra cero content roots y no re-sincroniza ningún hook — cada etapa
+    // "pasa" porque no tiene nada que hacer, y el comando terminaba anunciando éxito.
+    // Se corta acá, nombrando el archivo que falta y el comando que lo crea.
+    if (registries.configured === 0) {
+        console.error(picocolors_1.default.red(`No registries configured in ${(0, paths_2.awmHome)()} — nothing to update.`));
+        console.error(picocolors_1.default.dim("  This machine was never initialized: run 'awm init' first."));
+        return { code: 1, selectedAgents, registries };
+    }
+    // Falla CERRADO solo cuando el registry quedó sin contenido en disco: ahí lo que sigue
+    // leería un árbol inexistente y el fallo reaparecería más tarde, disfrazado de otra
+    // etapa. Un registry que falló pero conserva su contenido queda stale, no roto — se
+    // sigue (doctrina de `unusableSyncedRegistries`: un registry secundario flaky nunca
+    // aborta la corrida) y el cierre lo nombra en vez de declarar éxito parejo.
+    try {
+        (0, registries_1.assertSyncedRegistriesUsable)(registryResults);
+    }
+    catch (e) {
+        console.error(picocolors_1.default.red(e.message));
+        return { code: 1, selectedAgents, registries };
+    }
     try {
         (0, registries_1.assertRegistryGates)(d.verifyMinCliVersions());
     }
     catch (e) {
         console.error(picocolors_1.default.red(e.message));
-        return { code: 1, selectedAgents };
+        return { code: 1, selectedAgents, registries };
     }
     const regen = d.regenerateGlobalContext(selectedAgents);
     const refreshed = regen.filter((r) => r.action === 'refreshed').map((r) => r.agent);
@@ -86,7 +137,7 @@ async function runUpdateCore(options = {}, deps = {}) {
     }
     catch (e) {
         console.error(picocolors_1.default.red(`Artifact reconciliation failed: ${e.message}`));
-        return { code: 1, selectedAgents };
+        return { code: 1, selectedAgents, registries };
     }
     if (artifactResult.installed.length > 0) {
         console.log(picocolors_1.default.green(`  ✓ Reconciled artifacts: ${artifactResult.installed.join(', ')}`));
@@ -103,9 +154,12 @@ async function runUpdateCore(options = {}, deps = {}) {
         }
         catch (e) {
             console.error(picocolors_1.default.red(`Hook resync failed: ${e.message}`));
-            return { code: 1, selectedAgents };
+            return { code: 1, selectedAgents, registries };
         }
     }
-    await d.offerSelfUpdate();
-    return { code: 0, selectedAgents };
+    // `--yes` es consentimiento explícito para reemplazar el binario global. Sin él se
+    // pasa `undefined` a propósito, para que la decisión la tome `defaultSelfUpdateMode()`
+    // según haya o no un humano en stdin — no este llamador.
+    await d.offerSelfUpdate(options.yes === true ? 'assume-yes' : undefined);
+    return { code: 0, selectedAgents, registries };
 }

package/dist/src/commands/watch/apply.js

@@ -223,6 +223,33 @@ function applyRequestToState(s, env, digest, repoRoot) {
         (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied', resultRef: trackId });
         return;
     }
+    if (env.kind === 'track-join-request') {
+        // R6.1: el ÚNICO efecto es marcar la intención. Quien decide si eso mueve la fase es
+        // el reducer puro (`reconcileProtocol`, rama `join-requested`: solo un track en
+        // `ACTIVE` pasa a `JOIN_REQUESTED`), y quien congela/mergea es `reconcileTracks` —
+        // jamás este consumo transaccional. Mismo criterio declarativo que
+        // `track-freeze-request` arriba.
+        //
+        // Este handler NO EXISTÍA: `awm track join` emitía la request, `applyRequestToState`
+        // se caía por el final sin reconocer el kind, y `consumePendingRequests` la contaba
+        // como `applied` y borraba el archivo. El comando salía 0 imprimiendo un requestId,
+        // el supervisor sumaba una request "aplicada", y el track se quedaba en `ACTIVE`
+        // para siempre: la cohorte no podía congelarse (C3), así que jamás llegaba a
+        // `MERGED_UNVERIFIED` ni a `COMPLETE`. `join-requested` era la única observación del
+        // protocolo con CERO productores en todo `src/`.
+        const p = env.payload;
+        if (typeof p.trackId !== 'string' || p.trackId.length === 0)
+            throw new Error('track-join-request requiere trackId');
+        const trackId = p.trackId;
+        const ref = s.tracks?.find((t) => t.trackId === trackId);
+        // Fail-closed: un join sobre un track que no existe es un error del emisor, no algo
+        // que se absorba en silencio (que es exactamente lo que hacía la ausencia de handler).
+        if (ref === undefined)
+            throw new Error(`track-join-request: track desconocido: ${trackId}`);
+        ref.joinRequested = true;
+        (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied', resultRef: trackId });
+        return;
+    }
     if (env.kind === 'track-freeze-request') {
         // R5.2/R6.3 (Task 10): request administrativa CROSS-JOURNAL — el
         // supervisor del PLAN la emite directamente al `requestsDir` de ESTE
@@ -443,6 +470,18 @@ function applyRequestToState(s, env, digest, repoRoot) {
         (0, requests_1.applyOutcome)(s, { ...base, outcome: 'applied', resultRef: verdictId });
         return;
     }
+    // FALLA CERRADO ante un kind sin handler. Antes esta función simplemente se caía por el
+    // final: `consumePendingRequests` no veía excepción, hacía `applied++` y BORRABA el
+    // archivo. Una request emitida por un comando real quedaba contada como aplicada, sin
+    // evento, sin cambio de estado y sin error — el modo de falla más caro que existe, porque
+    // todo el sistema reporta éxito. Así vivió `track-join-request` (ver su handler arriba):
+    // el comando salía 0, el journal sumaba una request "aplicada", y la cohorte no avanzaba.
+    //
+    // Con este throw, un kind sin handler se convierte en `request-rejected-invalid`: queda en
+    // `requestProblems`, deja evento durable, y el archivo se renombra a `.rejected` en vez de
+    // desaparecer. Agregar un `RequestKind` sin su handler pasa a ser ruidoso — que es la
+    // única forma de que no se repita.
+    throw new Error(`request kind sin handler en el supervisor: ${env.kind} — emitida pero nunca aplicada`);
 }
 /** Consume TODAS las requests pendientes en orden. ORDEN CRITICO (R1.3,
  *  bloqueador 4): (1) mutar estado, (2) writeJournal, (3) borrar archivos,

package/dist/src/commands/watch/tracks.js

@@ -70,6 +70,12 @@ const RUNTIME_EFFECTS = new Set([
     // `runRunFinalInterlock` más abajo).
     'request-global-qa', 'request-final-integration', 'run-final-interlock',
 ]);
+/** Fases en las que un `joinRequested` todavía tiene futuro: el track aún no llegó a
+ *  `ACTIVE`, así que el pedido espera a que llegue en vez de perderse. `ACTIVE` está incluida
+ *  porque es justamente donde se aplica; cualquier otra fase lo vuelve moot. */
+const JOIN_PENDING_PHASES = [
+    'DECLARED', 'PREPARE_INTENT', 'WORKTREE_CREATED', 'JOURNAL_CREATED', 'SUPERVISOR_STARTING', 'ARMED', 'ACTIVE',
+];
 function toProtocol(state, maxParallel) {
     const tracks = {};
     for (const ref of state.tracks ?? []) {
@@ -812,6 +818,51 @@ async function reconcileTracks(planRoot, branch, state, runtime, maxParallel) {
         if (s.tracks === undefined || s.tracks.length < 2 || s.cohortPhase === undefined) {
             return { state: s, effectExecuted: null };
         }
+        // El pedido de join del controller (`joinRequested`, marcado declarativamente al
+        // consumir `track-join-request`) se convierte ACÁ en la observación que el reducer
+        // entiende. La regla de si eso mueve la fase vive en `reconcileProtocol` (solo
+        // `ACTIVE` pasa a `JOIN_REQUESTED`), no acá: este bloque solo produce la observación
+        // que hasta ahora nadie producía. Se consume una por vuelta y se persiste, para no
+        // colapsar dos fronteras en un mismo call (mismo invariante que el resto del loop).
+        //
+        // El pedido es DURABLE mientras el track todavía no llegó a `ACTIVE`. Un join que
+        // llega antes de la activación no es un error del controller: es la carrera normal
+        // — 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`.
+        // Se observó en la certificación: dos joins emitidos con ambos tracks en `ARMED`.
+        // Descartarlos ahí (que es lo que hacía la primera versión de este bloque) devuelve
+        // el mismo modo de falla que este cambio vino a cerrar — un pedido que reporta éxito
+        // y no pasa nada — y solo sobrevivía porque el controller scripteado los re-emite.
+        const pendingJoin = (s.tracks ?? []).find((t) => t.joinRequested === true && t.phase === 'ACTIVE');
+        if (pendingJoin !== undefined) {
+            const protocolBefore = toProtocol(s, maxParallel);
+            const observed = (0, protocol_1.reconcileProtocol)(protocolBefore, { kind: 'join-requested', trackId: pendingJoin.trackId });
+            const next = applyProtocolToState(s, observed);
+            for (const t of next.tracks ?? [])
+                if (t.trackId === pendingJoin.trackId)
+                    t.joinRequested = undefined;
+            s = persist(planRoot, branch, next);
+            (0, store_1.appendEvent)(planRoot, branch, {
+                kind: 'track-join-observed', trackId: pendingJoin.trackId,
+                phase: s.tracks?.find((t) => t.trackId === pendingJoin.trackId)?.phase,
+            });
+            continue;
+        }
+        // Pedido que ya no puede aplicarse nunca: el track pasó de `ACTIVE` (join duplicado,
+        // o el relevo de un controller que re-emite) o quedó `BLOCKED`. Se limpia la marca
+        // — dejarla prendida la haría reevaluar en cada tick sin progreso posible. Lo que NO
+        // se limpia es el pedido de un track anterior a `ACTIVE`: ese sigue esperando.
+        const mootJoin = (s.tracks ?? []).find((t) => t.joinRequested === true
+            && !JOIN_PENDING_PHASES.includes(t.phase));
+        if (mootJoin !== undefined) {
+            const next = structuredClone(s);
+            for (const t of next.tracks ?? [])
+                if (t.trackId === mootJoin.trackId)
+                    t.joinRequested = undefined;
+            s = persist(planRoot, branch, next);
+            (0, store_1.appendEvent)(planRoot, branch, { kind: 'track-join-moot', trackId: mootJoin.trackId, phase: mootJoin.phase });
+            continue;
+        }
         const protocol = toProtocol(s, maxParallel);
         const effect = (0, protocol_1.nextProtocolEffect)(protocol);
         if (effect === null)

package/dist/src/core/provider-version.js

@@ -4,6 +4,7 @@ exports.assertProviderSupported = assertProviderSupported;
 const child_process_1 = require("child_process");
 const providers_1 = require("../providers");
 const versioning_1 = require("./versioning");
+const paths_1 = require("./paths");
 function assertProviderSupported(agent, exec = child_process_1.execFileSync) {
     const provider = (0, providers_1.providerFor)(agent);
     if (!provider.versionCommand || !provider.minimumVersion) {
@@ -15,17 +16,40 @@ function assertProviderSupported(agent, exec = child_process_1.execFileSync) {
             encoding: 'utf8',
             stdio: ['ignore', 'pipe', 'pipe'],
             timeout: 5000,
+            // Windows can't CreateProcess a `.cmd` shim directly (npm installs
+            // `codex` as `codex.cmd`, not `codex.exe`) — execFileSync needs a
+            // shell to resolve and run it, or it throws ENOENT even though
+            // typing `codex --version` in the same shell works fine. Safe here
+            // (unlike sensors.json's `cmd`, core/paths.ts's resolveOnPath):
+            // `provider.versionCommand.command`/`args` are hardcoded first-party
+            // config (providers/index.ts), never attacker-controlled input.
+            // Found running the issue #55 Windows playbook: `awm init -a codex`
+            // reported "Codex is not installed" on a machine where it plainly
+            // was — `codex --version` worked fine typed directly.
+            shell: (0, paths_1.isWindowsNative)(),
         }).toString();
     }
     catch (error) {
-        const code = error.code;
+        const err = error;
         // `provider.label` y `versionCommand`, no "Codex" literal. Esta funcion es
         // generica sobre AgentTarget desde siempre, pero cada mensaje y el patron de
         // parseo nombraban al unico provider que hoy declara `versionCommand` — el
         // segundo en declararlo habria reportado "Codex no esta instalado" al no
         // encontrar SU binario, y habria fallado a parsear una salida perfectamente
         // valida contra el formato de otro programa.
-        if (code === 'ENOENT') {
+        //
+        // Two distinct "not found" shapes to catch now that Windows goes through
+        // a shell (see `shell: isWindowsNative()` above): without a shell, a
+        // missing binary is a spawn-level ENOENT; through cmd.exe, the shell
+        // itself spawns fine and the missing command instead surfaces as a
+        // non-zero exit with "'codex' is not recognized..." on stderr — no
+        // ENOENT anywhere. Missing this second shape was a real regression:
+        // windows-latest CI (no codex installed at all) started reporting
+        // "version probe failed" instead of "not installed", because the exit
+        // code alone doesn't say WHY the shell failed.
+        const shellCommandNotFound = (0, paths_1.isWindowsNative)()
+            && /is not recognized as an internal or external command/i.test(String(err.stderr ?? ''));
+        if (err.code === 'ENOENT' || shellCommandNotFound) {
             throw new Error(`${provider.label} is not installed or not available on PATH ` +
                 `(tried \`${provider.versionCommand.command}\`). Install it, then re-run.`);
         }

package/dist/src/core/update-check.js

@@ -8,6 +8,7 @@ exports.writeUpdateCache = writeUpdateCache;
 exports.fetchLatestVersion = fetchLatestVersion;
 exports.spawnRefreshWorker = spawnRefreshWorker;
 exports.maybeNotifyUpdate = maybeNotifyUpdate;
+exports.defaultSelfUpdateMode = defaultSelfUpdateMode;
 exports.offerSelfUpdate = offerSelfUpdate;
 // cli/src/core/update-check.ts
 //
@@ -92,20 +93,39 @@ function maybeNotifyUpdate(opts) {
     if (!cache || now - cache.lastCheck > TTL_MS)
         spawnWorker();
 }
-/** Capa 2 — en `awm update`: detecta, pregunta, ejecuta npm i -g; degrada a aviso. */
+/**
+ * Sin nadie del otro lado, un prompt no es una pregunta: es un cuelgue. `awm update`
+ * corre en CI, en cron y dentro de sesiones agénticas, y ahí el confirm de self-update
+ * bloqueaba el proceso indefinidamente — el comando quedaba a mitad de camino y ningún
+ * humano podía destrabarlo. La ausencia de TTY en stdin es la evidencia POSITIVA de que
+ * no hay quien conteste, así que se degrada al aviso.
+ *
+ * Degrada a `skip`, jamás a `assume-yes`: nadie pidió reemplazar el binario global de la
+ * máquina, y hacerlo por iniciativa propia porque "no había a quién preguntarle" es
+ * exactamente la clase de acción que el silencio no autoriza.
+ */
+function defaultSelfUpdateMode() {
+    return process.stdin.isTTY === true ? 'prompt' : 'skip';
+}
+/** Capa 2 — en `awm update`: detecta, pregunta (si hay a quién), ejecuta npm i -g; degrada a aviso. */
 async function offerSelfUpdate(deps = {}) {
     if (process.env.AWM_NO_UPDATE_CHECK)
         return;
     const current = deps.current ?? (0, cli_version_1.cliVersion)();
+    const mode = deps.mode ?? defaultSelfUpdateMode();
     const latest = deps.latest !== undefined ? deps.latest : await fetchLatestVersion(deps.fetchImpl ?? fetch);
     writeUpdateCache({ lastCheck: Date.now(), latest: latest ?? null });
     if (!latest || !isNewer(latest, current))
         return;
+    if (mode === 'skip') {
+        console.log(picocolors_1.default.dim(`  ⬆ awm v${latest} available — to update: npm i -g ${cli_version_1.CLI_PACKAGE_NAME}`));
+        return;
+    }
     const confirmImpl = deps.confirmImpl ?? (async (message) => {
         const r = await (0, prompts_1.confirm)({ message });
         return !(0, prompts_1.isCancel)(r) && r === true;
     });
-    const yes = await confirmImpl(`Update awm v${current} → v${latest} now?`);
+    const yes = mode === 'assume-yes' ? true : await confirmImpl(`Update awm v${current} → v${latest} now?`);
     if (!yes) {
         console.log(picocolors_1.default.dim(`  To update later: npm i -g ${cli_version_1.CLI_PACKAGE_NAME}`));
         return;

package/dist/src/index.js

@@ -122,7 +122,7 @@ program.command('add [name]')
     if (name) {
         const allBundles = (0, bundles_1.discoverAllBundles)();
         const prefs = (0, config_1.getPreferences)();
-        const outcome = (0, add_1.runAddBundleCore)({ name, agent: options.agent, scope: options.scope }, prefs, allBundles);
+        const outcome = (0, add_1.runAddBundleCore)({ name, agent: options.agent, scope: options.scope, method: options.method }, prefs, allBundles);
         if (outcome.code !== 0)
             process.exit(outcome.code);
         (0, prompts_1.outro)('Done.');
@@ -403,10 +403,15 @@ program.command('add [name]')
 program.command('update')
     .description('Sync all configured registries, reconcile artifacts and re-sync hooks')
     .option('-a, --agent <agent>', `Target agent(s), comma-separated: ${providers_1.AGENT_TARGETS.join(', ')} (defaults to every enabled agent)`)
+    .option('-y, --yes', 'Non-interactive: never prompt, and self-update the CLI without asking')
     .action(async (options) => {
     (0, prompts_1.intro)(picocolors_1.default.bgCyan(picocolors_1.default.black(' AWM - Update Registries ')));
     const result = await (0, update_1.runUpdateCore)(options);
-    (0, prompts_1.outro)(result.code === 0 ? '✅ Registries, skills and hooks updated.' : picocolors_1.default.red('Update failed — see errors above.'));
+    // El cierre lo DERIVA `updateOutro` del resultado. No se recorta a `code === 0` con
+    // un literal fijo: eso es lo que hacía que una máquina sin registries recibiera la
+    // confirmación de que se le habían actualizado.
+    const message = (0, update_1.updateOutro)(result);
+    (0, prompts_1.outro)(result.code === 0 ? message : picocolors_1.default.red(message));
     process.exitCode = result.code;
 });
 program.command('sync')
@@ -529,12 +534,17 @@ program.command('remove [name]')
         targetAgents = agentChoice;
     }
     let scopeVal;
-    if (options.scope) {
-        if (options.scope !== 'local' && options.scope !== 'global') {
-            console.error(picocolors_1.default.red(`Invalid scope "${options.scope}". Use: local or global.`));
+    if (options.scope || options.yes) {
+        // Same reasoning as the --agent default just above: `--yes` means ZERO
+        // prompts. Without the `options.yes` half of this condition, `awm remove
+        // <bundle> --yes` still opened the scope picker and hung any
+        // non-interactive caller — the flag promised no-interactive and wasn't.
+        const resolved = (0, config_1.resolveScopeOption)(options.scope, prefs.defaultScope);
+        if (!resolved.ok) {
+            console.error(picocolors_1.default.red(resolved.error));
             process.exit(1);
         }
-        scopeVal = options.scope;
+        scopeVal = resolved.scope;
     }
     else {
         const scopeChoice = await (0, prompts_1.select)({