agentic-workflow-manager 6.3.0 → 6.4.1

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/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

@@ -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')

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',

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/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/structural/sensor-configs-are-present.test.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Guard estructural — un sensor declarado cuyo archivo de configuración no existe no es un
+// sensor: es un `fail` o un `inconclusive` permanente que entrena a ignorar el rojo.
+//
+// Pasó dos veces en este repo, y las dos veces sobrevivió meses:
+//   - `depcheck` apuntaba a `.dep-cruiser.awm.js`, que NUNCA existió en ninguna rama →
+//     `awm sensors run` daba `fail` permanente.
+//   - `security` apuntaba a `.semgrep.awm.yml`, que existía en el sensor-pack pero el
+//     `.gitignore` del repo (`*.awm.*`) impedía versionarlo → `inconclusive` permanente.
+//
+// La regla no enumera esos dos: deriva los configs del PROPIO `sensors.json`, así que un
+// sensor agregado mañana la hereda sin que nadie se acuerde de este comentario.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const CLI_ROOT = path_1.default.resolve(__dirname, '..', '..');
+const SENSORS = path_1.default.join(CLI_ROOT, '.awm', 'sensors.json');
+/** Extrae los archivos de config que un comando de sensor referencia. Se buscan por la
+ *  convención `*.awm.*` que usan todos los packs, no por una lista de nombres — un pack
+ *  nuevo con otro linter queda cubierto igual. */
+function configFilesIn(cmd) {
+    return cmd.split(/\s+/).filter((token) => /\.awm\./.test(token) && !token.startsWith('-'));
+}
+describe('configs de sensores: declarados <=> presentes', () => {
+    const manifest = fs_1.default.existsSync(SENSORS)
+        ? JSON.parse(fs_1.default.readFileSync(SENSORS, 'utf8'))
+        : null;
+    it('el manifiesto de sensores existe y declara sensores', () => {
+        expect(manifest?.sensors).toBeDefined();
+        expect(Object.keys(manifest.sensors).length).toBeGreaterThan(0);
+    });
+    it('cada archivo de config que un sensor referencia existe en el repo', () => {
+        const missing = [];
+        for (const [name, sensor] of Object.entries(manifest?.sensors ?? {})) {
+            for (const cmd of [sensor.cmd, sensor.changedCmd].filter((c) => typeof c === 'string')) {
+                for (const file of configFilesIn(cmd)) {
+                    if (!fs_1.default.existsSync(path_1.default.join(CLI_ROOT, file)))
+                        missing.push(`${name} -> ${file}`);
+                }
+            }
+        }
+        // El mensaje nombra sensor y archivo: un rojo que no dice cuál de los dos falta
+        // termina resuelto borrando el sensor, que es la salida equivocada.
+        expect(missing.join('\n') || 'todos presentes').toBe('todos presentes');
+    });
+});

package/package.json

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