agentic-workflow-manager 3.13.5 → 3.13.7

package/dist/src/core/install-planner.js

@@ -23,6 +23,7 @@ exports.planRemoval = planRemoval;
 // persistence (artifact-state.ts). This module only computes the plan.
 const path_1 = __importDefault(require("path"));
 const providers_1 = require("../providers");
+const registry_1 = require("./renderers/registry");
 /** Resolves the single physical filesystem location an intent renders to for one agent. */
 /**
  * Resolves the physical target path + renderer for one artifact intent on one
@@ -44,21 +45,27 @@ function physicalTarget(intent, agent, scope, projectRoot) {
     // trailing `.md` (if any) on intent.installName, so e.g. `using-awm`
     // (skills carry no extension) or `using-awm.md` both become
     // `using-awm.instructions.md`, never `using-awm.md.instructions.md`.
-    // Deliberately NOT path.parse(...).name: it strips everything after the
-    // LAST dot, not just a real trailing extension — a skill literally named
-    // `v1.2-migration` would silently truncate to `v1.mdc`, dropping
-    // `2-migration` and risking a collision with any other skill named `v1`.
-    // `.md` is the only extension a skill's installName is ever expected to
-    // carry (skills are markdown files), so stripping that literal suffix is
-    // both sufficient and precise.
-    const baseName = intent.installName.endsWith('.md')
-        ? intent.installName.slice(0, -'.md'.length)
-        : intent.installName;
-    const filename = config.renderer === 'codex-agent-toml' ? `${baseName}.toml`
-        : config.renderer === 'cursor-mdc' ? `${baseName}.mdc`
-            : config.renderer === 'copilot-instructions' ? `${baseName}.instructions.md`
-                : intent.installName;
-    return { targetPath: path_1.default.join(dir, filename), renderer: config.renderer };
+    // `renderedFilename` (core/renderers/registry.ts) es la unica fuente de
+    // verdad de este mapeo. Antes vivia inline aca y re-derivado a mano en tres
+    // lectores mas, uno de los cuales lo omitia por completo — y ese era
+    // justamente el que decidia si un artefacto estaba instalado.
+    const filename = (0, registry_1.renderedFilename)(intent.installName, config.renderer);
+    const targetPath = path_1.default.join(dir, filename);
+    // Asercion de contencion: el destino resuelto DEBE caer dentro del
+    // directorio del provider. `dir` es el ancla de confianza real (sale de la
+    // config del provider, no del contenido), asi que verificarlo aca atrapa
+    // cualquier camino — presente o futuro — que construya un `installName` sin
+    // pasar por `assertSafeArtifactName`. Los nombres llegan desde el
+    // `bundle.json` de un registry, y el instalador borra el destino de forma
+    // recursiva antes de enlazar: un escape aca no es un archivo mal ubicado,
+    // es borrado arbitrario fuera del sandbox.
+    const resolvedDir = path_1.default.resolve(dir);
+    const resolved = path_1.default.resolve(targetPath);
+    if (resolved !== resolvedDir && !resolved.startsWith(resolvedDir + path_1.default.sep)) {
+        throw new Error(`refusing to install outside the target directory: ${JSON.stringify(intent.installName)} ` +
+            `resolves to ${resolved}, which is not inside ${resolvedDir}`);
+    }
+    return { targetPath, renderer: config.renderer };
 }
 /**
  * The physical directory `agent`'s skill artifacts resolve to at `scope` —
@@ -121,7 +128,19 @@ function assertCompleteSharedGroup(intent, selected, enabled, scope, projectRoot
     if (intent.type !== 'skill')
         return;
     for (const agent of selected) {
-        const target = physicalTarget(intent, agent, scope, projectRoot).targetPath;
+        // El `.filter()` de abajo ya tenia esta guarda; esta linea no — y es la
+        // que corre PRIMERO. Con copilot en `selected` (que es lo que hace
+        // `awm update`, que apunta a todos los agentes habilitados) tiraba aca,
+        // antes de llegar al loop de planificacion, rompiendo el comando para
+        // TODOS los demas agentes de la maquina. Un agente que no soporta este
+        // scope no tiene grupo compartido que verificar: no es parte del grupo.
+        let target;
+        try {
+            target = physicalTarget(intent, agent, scope, projectRoot).targetPath;
+        }
+        catch {
+            continue;
+        }
         // Same reasoning as agentsSharingSkillTarget above: a candidate in
         // `enabled` that doesn't support this scope (e.g. Copilot at `global`)
         // can't be part of the shared-target group — it just isn't a
@@ -172,7 +191,33 @@ function planInstall(params) {
     }
     const groups = new Map();
     for (const intent of artifacts) {
-        for (const agent of selectedAgents) {
+        // Agentes que estructuralmente NO pueden recibir este artefacto en este
+        // scope — hoy: copilot en scope global, que no tiene mecanismo de
+        // descubrimiento de skills a nivel usuario.
+        //
+        // Se saltean, pero SOLO si algun otro agente seleccionado si puede. La
+        // distincion es deliberada:
+        //  - `awm update` / `awm add <bundle>` corren sobre TODOS los agentes
+        //    habilitados. Que uno no pueda no es un error del usuario, y hacer
+        //    tirar todo el plan rompia el comando para TODOS los demas agentes
+        //    de la maquina — incluido el re-sync de hooks, que ni se alcanzaba.
+        //  - `awm add x -a copilot -s global` es una peticion EXPLICITA. Ahi no
+        //    hay a quien saltear, asi que sigue tirando con la explicacion
+        //    (`globalUnsupportedReason`), que es justo lo que el usuario
+        //    necesita leer.
+        const capable = selectedAgents.filter((agent) => {
+            if (!(0, providers_1.providerFor)(agent)[intent.type])
+                return false;
+            try {
+                physicalTarget(intent, agent, scope, projectRoot);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+        const effectiveAgents = capable.length > 0 ? capable : selectedAgents;
+        for (const agent of effectiveAgents) {
             const config = (0, providers_1.providerFor)(agent)[intent.type];
             if (!config)
                 continue;

package/dist/src/core/install-transaction.js

@@ -41,8 +41,20 @@ const executor_1 = require("./executor");
  * accepts. Strips both `:` and `.` (an ISO timestamp has both) so the result
  * is filesystem- and regex-safe either way.
  */
+/** Id de transaccion: timestamp + sufijo aleatorio.
+ *
+ *  El timestamp solo tiene resolucion de 1 ms y NO era unico. Dos
+ *  transacciones en el mismo milisegundo (p. ej. `syncProfile`, que corre una
+ *  por extension en un loop) producian el mismo id, y como cada una reescribe
+ *  `manifest.json` con SUS entradas y numera los slots de backup desde 0, la
+ *  segunda pisaba el backup de la primera: el respaldo del archivo original del
+ *  usuario quedaba irrecuperable y `awm backup restore <id>` restauraba el
+ *  target equivocado. Es un agujero en el unico mecanismo del que depende toda
+ *  la promesa de "siempre se puede revertir". El regex de `restoreBackup` ya
+ *  acepta este formato. */
 function sanitizeTransactionTimestamp() {
-    return new Date().toISOString().replace(/[:.]/g, '-');
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    return `${stamp}-${crypto_1.default.randomBytes(4).toString('hex')}`;
 }
 function ensureBackupDir(backupDir) {
     fs_1.default.mkdirSync(backupDir, { recursive: true });

package/dist/src/core/journal/adapter.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.WATCH_PROVIDERS = void 0;
+exports.isWatchProvider = isWatchProvider;
 exports.adapterFor = adapterFor;
 const process_1 = require("./process");
 const RESUME_PROMPT_PREFIX = 'Sos el orquestador SDD de este repo. Corre `awm job reconcile` y ejecuta ';
@@ -18,10 +20,17 @@ const claudeAdapter = {
     activity: process_1.activitySnapshot,
     safeToReplace: baseSafeToReplace,
 };
+/** Los providers que `awm watch` sabe supervisar. Exportado para que el CLI valide en
+ *  el borde en vez de dejar que un `--provider` invalido llegue hasta el primer tick,
+ *  ya con el journal tocado y el lock tomado. */
+exports.WATCH_PROVIDERS = ['codex', 'claude-code'];
+function isWatchProvider(value) {
+    return typeof value === 'string' && exports.WATCH_PROVIDERS.includes(value);
+}
 function adapterFor(provider) {
     if (provider === 'codex')
         return codexAdapter;
     if (provider === 'claude-code')
         return claudeAdapter;
-    throw new Error(`provider desconocido: ${provider} (validos: codex, claude-code)`);
+    throw new Error(`provider desconocido: ${provider} (validos: ${exports.WATCH_PROVIDERS.join(', ')})`);
 }

package/dist/src/core/paths.js

@@ -17,8 +17,8 @@ exports.resolveOnPath = resolveOnPath;
 // Functions are evaluated at CALL TIME (not require time) so env overrides are
 // always honored and tests need no jest.resetModules().
 const os_1 = __importDefault(require("os"));
+const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const child_process_1 = require("child_process");
 /** User home directory with a robust fallback. Never returns a raw, possibly-empty process.env.HOME. */
 function homeDir() {
     return process.env.HOME || os_1.default.homedir();
@@ -74,14 +74,67 @@ function noteWindowsCaveat(log) {
     if (isWindowsNative())
         log(exports.WINDOWS_KNOWN_GAP);
 }
-/** Resolve a binary on PATH portably: `where` on win32, POSIX `command -v` elsewhere. */
+/**
+ * Resolve a binary on PATH, IN PROCESS — no shell, no subprocess.
+ *
+ * SECURITY (this is the whole reason for the implementation below): this used
+ * to build `command -v ${bin}` / `where ${bin}` and hand it to `execSync`,
+ * which runs it through a shell. `bin` is the first token of a sensor's `cmd`,
+ * and that string comes from `.awm/sensors.json` — a file committed in the
+ * repo, and also regenerated from a registry sensor-pack's `defaultCmd`. So a
+ * cloned untrusted repo, or a third-party registry, could put shell syntax
+ * there. The token can't contain whitespace (it's a split token), but `${IFS}`
+ * and `$(...)` make that irrelevant. Confirmed against the real binary: a
+ * crafted `cmd` executed an arbitrary command during `awm sensors status` —
+ * a read-only inspection command — which then reported the sensor HEALTHY,
+ * because the injected command exited 0.
+ *
+ * Resolving PATH ourselves removes the interpreter entirely, so there is
+ * nothing left to inject into on any platform. It's also faster (no process
+ * spawn) and more predictable than depending on `where`/`command -v` being
+ * present and well-behaved.
+ */
 function resolveOnPath(bin) {
-    const cmd = isWindowsNative() ? `where ${bin}` : `command -v ${bin}`;
-    try {
-        (0, child_process_1.execSync)(cmd, { stdio: 'pipe' });
-        return true;
-    }
-    catch {
+    if (typeof bin !== 'string' || bin.trim() === '')
         return false;
+    // win32 resolves `eslint` to `eslint.cmd`/`eslint.exe` via PATHEXT. Missing
+    // this broke every npm-shim-backed sensor on Windows (real bug, published in
+    // v3.9.0). POSIX has no such concept — the name is the name.
+    const extensions = isWindowsNative()
+        ? (process.env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean)
+        : [];
+    const isExecutable = (candidate) => {
+        try {
+            if (!fs_1.default.statSync(candidate).isFile())
+                return false;
+        }
+        catch {
+            return false;
+        }
+        // On win32 the executable bit doesn't exist; being a file with a PATHEXT
+        // extension is the whole contract.
+        if (isWindowsNative())
+            return true;
+        try {
+            fs_1.default.accessSync(candidate, fs_1.default.constants.X_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    // PATHEXT is conventionally uppercase (`.COM;.EXE;.BAT;.CMD`) while the files
+    // on disk are usually lowercase (`eslint.cmd`). On real Windows that's a
+    // non-issue because the filesystem is case-insensitive — but it IS an issue
+    // on any case-sensitive volume, so try both spellings rather than depend on
+    // filesystem behavior we don't control.
+    const matches = (base) => isExecutable(base) ||
+        extensions.some((ext) => isExecutable(base + ext) || isExecutable(base + ext.toLowerCase()));
+    // A name carrying a separator is a path, not a PATH lookup — resolve it
+    // directly instead of joining it onto every PATH entry.
+    if (bin.includes('/') || (isWindowsNative() && bin.includes('\\'))) {
+        return matches(path_1.default.resolve(bin));
     }
+    const entries = (process.env.PATH ?? '').split(path_1.default.delimiter).filter(Boolean);
+    return entries.some((dir) => matches(path_1.default.join(dir, bin)));
 }

package/dist/src/core/profile.js

@@ -125,6 +125,18 @@ function ensureSkillsGitignored(root, agents) {
             const config = provider[type];
             if (!config)
                 continue;
+            // Solo se ignoran los artefactos que son SYMLINKS especificos de la
+            // maquina (renderer `link`), que es lo que `awm sync` reconstruye.
+            // Un renderer que produce CONTENIDO (`.mdc` de cursor,
+            // `.instructions.md` de copilot) genera archivos reales que el
+            // equipo necesita commitear — y para copilot ese es su UNICO canal
+            // de entrega, asi que ignorarlos hacia que los companeros no
+            // recibieran absolutamente nada. Tambien arrastraba a
+            // `.cursor/rules/awm.mdc`, el carrier que existe justamente para
+            // que el contexto sobreviva al Background Agent de Cursor, que lee
+            // del checkout de git.
+            if (config.renderer !== 'link')
+                continue;
             const entry = config.local.endsWith('/') ? config.local : `${config.local}/`;
             if (!toIgnore.includes(entry))
                 toIgnore.push(entry);

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

@@ -8,39 +8,64 @@ exports.scanLegacyArtifacts = scanLegacyArtifacts;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const providers_1 = require("../providers");
+const artifact_state_1 = require("./artifact-state");
 const ARTIFACT_TYPES = ['skill', 'workflow', 'agent'];
 function preflightLinkArtifactPairs(pairs) {
     for (const { agent, artifact } of pairs) {
         (0, providers_1.assertLinkRenderer)(artifact.type, agent);
     }
 }
-function scanLegacyArtifacts(agents, scope) {
+/**
+ * Artefactos instalados que AWM puede ofrecer para remover.
+ *
+ * Cuatro defectos corregidos aca, todos con perdida de datos o no-operacion:
+ *
+ *  1. **Clave por nombre solo**, a traves de TODOS los tipos y agentes. Un
+ *     workflow `deploy.md` de antigravity y un agent `deploy.md` de claude-code
+ *     colapsaban en UNA entrada, asi que elegir "deploy.md" borraba los dos. El
+ *     escritor (`planInstall`) siempre clavea por ubicacion fisica.
+ *  2. **Scope local resuelto contra `process.cwd()`**: `config.local` es
+ *     relativo (`.claude/skills`), asi que desde un subdirectorio no encontraba
+ *     nada, y cuando encontraba algo le pasaba una ruta RELATIVA a `fs.rmSync`.
+ *     Ahora recibe el projectRoot explicito, como todos los demas consumidores.
+ *  3. **Listaba el directorio entero**, ofreciendo borrar skills que el usuario
+ *     escribio a mano. Ahora se cruza contra `readArtifactState()`: solo se
+ *     ofrece lo que AWM realmente instalo. El registro de propiedad existe
+ *     justamente para poder distinguirlo.
+ *  4. **Se tragaba `UnsupportedRendererError`**, asi que era un no-op permanente
+ *     para skills de cursor/copilot y agents de codex: `awm remove -a cursor`
+ *     decia "no hay artefactos instalados" con el directorio lleno.
+ */
+function scanLegacyArtifacts(agents, scope, projectRoot = process.cwd(), owned = (0, artifact_state_1.readArtifactState)()) {
     const artifacts = new Map();
+    const ownedPaths = new Set(owned.map((r) => path_1.default.resolve(r.targetPath)));
     for (const agent of agents) {
         for (const type of ARTIFACT_TYPES) {
-            let config;
-            try {
-                config = (0, providers_1.assertLinkRenderer)(type, agent);
-            }
-            catch (error) {
-                if (error instanceof providers_1.UnsupportedRendererError)
-                    continue;
-                throw error;
-            }
+            const config = (0, providers_1.providerFor)(agent)[type];
             if (!config)
                 continue;
-            const dir = config[scope];
+            // Se usa la config del provider directamente: `assertLinkRenderer`
+            // TIRA para renderers que producen contenido, y atrapar ese throw
+            // convertia a cursor/copilot/codex en invisibles para `awm remove`.
+            const dir = scope === 'local' ? path_1.default.join(projectRoot, config.local) : config.global;
             if (dir === null || !fs_1.default.existsSync(dir))
                 continue;
             for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
                 const fullPath = path_1.default.join(dir, entry.name);
-                const existing = artifacts.get(entry.name);
+                // Solo lo que AWM instalo. Un archivo del usuario en el mismo
+                // directorio no es nuestro para ofrecerlo en un menu de borrado.
+                if (!ownedPaths.has(path_1.default.resolve(fullPath)))
+                    continue;
+                // Clave por TIPO + nombre: dos artefactos de tipos distintos con
+                // el mismo nombre son cosas distintas en lugares distintos.
+                const key = `${type}\u0000${entry.name}`;
+                const existing = artifacts.get(key);
                 if (existing) {
                     existing.installedIn.push(agent);
                     existing.fullPaths.push(fullPath);
                 }
                 else {
-                    artifacts.set(entry.name, {
+                    artifacts.set(key, {
                         name: entry.name,
                         type,
                         installedIn: [agent],

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

@@ -19,18 +19,24 @@ function assertProviderSupported(agent, exec = child_process_1.execFileSync) {
     }
     catch (error) {
         const code = error.code;
+        // `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') {
-            throw new Error('Codex is not installed or not available on PATH. ' +
-                'Install the current stable @openai/codex release, then re-run.');
+            throw new Error(`${provider.label} is not installed or not available on PATH ` +
+                `(tried \`${provider.versionCommand.command}\`). Install it, then re-run.`);
         }
-        throw new Error(`Codex version probe failed: ${error.message}`);
+        throw new Error(`${provider.label} version probe failed: ${error.message}`);
     }
-    const match = output.trim().match(/^codex-cli (\d+\.\d+\.\d+)$/);
+    const match = output.trim().match(provider.versionCommand.versionPattern);
     if (!match) {
-        throw new Error(`could not parse Codex version from: ${output.trim()}`);
+        throw new Error(`could not parse ${provider.label} version from: ${output.trim()}`);
     }
     if ((0, versioning_1.compareSemver)(match[1], provider.minimumVersion) < 0) {
-        throw new Error(`requires Codex >= ${provider.minimumVersion}; found ${match[1]}`);
+        throw new Error(`requires ${provider.label} >= ${provider.minimumVersion}; found ${match[1]}`);
     }
     return { provider: agent, version: match[1] };
 }

package/dist/src/core/registries.js

@@ -3,7 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.REGISTRY_MANIFEST_NAME = exports.CONTENT_DIR_NAMES = exports.REGISTRIES_CONFIG_PATH = exports.REGISTRIES_DIR = void 0;
+exports.REGISTRY_MANIFEST_NAME = exports.CONTENT_DIR_NAMES = void 0;
+exports.registriesDir = registriesDir;
+exports.registriesConfigPath = registriesConfigPath;
 exports.registryContentRoot = registryContentRoot;
 exports.readRegistriesConfig = readRegistriesConfig;
 exports.writeRegistriesConfig = writeRegistriesConfig;
@@ -30,49 +32,57 @@ const versioning_1 = require("./versioning");
 const cli_version_1 = require("./cli-version");
 const paths_1 = require("./paths");
 // Computed at require-time by calling the shared resolver (single source of truth: core/paths.ts).
-const AWM_HOME = (0, paths_1.awmHome)();
-exports.REGISTRIES_DIR = path_1.default.join(AWM_HOME, 'registries');
-exports.REGISTRIES_CONFIG_PATH = path_1.default.join(AWM_HOME, 'registries.json');
+// Funciones, no constantes de nivel de modulo. `awmHome()` lee AWM_HOME/HOME EN CADA
+// LLAMADA a proposito (paths.ts) — resolverlo una sola vez al hacer `require` congelaba
+// la respuesta en el instante del import, asi que cualquier cosa que fijara AWM_HOME
+// despues (un test, un comando que cambia de home) seguia apuntando al viejo. Este
+// modulo era el unico lugar que contradecia esa regla.
+function registriesDir() {
+    return path_1.default.join((0, paths_1.awmHome)(), 'registries');
+}
+function registriesConfigPath() {
+    return path_1.default.join((0, paths_1.awmHome)(), 'registries.json');
+}
 exports.CONTENT_DIR_NAMES = ['skills', 'bundles', 'workflows', 'agents'];
 function registryContentRoot(name) {
-    const root = path_1.default.join(exports.REGISTRIES_DIR, name);
-    if (!path_1.default.resolve(root).startsWith(path_1.default.resolve(exports.REGISTRIES_DIR) + path_1.default.sep)) {
+    const root = path_1.default.join(registriesDir(), name);
+    if (!path_1.default.resolve(root).startsWith(path_1.default.resolve(registriesDir()) + path_1.default.sep)) {
         throw new Error(`Invalid registry name "${name}" — must not contain path separators`);
     }
     return root;
 }
 function readRegistriesConfig() {
-    if (!fs_1.default.existsSync(exports.REGISTRIES_CONFIG_PATH))
+    if (!fs_1.default.existsSync(registriesConfigPath()))
         return [];
     let raw;
     try {
-        raw = JSON.parse(fs_1.default.readFileSync(exports.REGISTRIES_CONFIG_PATH, 'utf-8'));
+        raw = JSON.parse(fs_1.default.readFileSync(registriesConfigPath(), 'utf-8'));
     }
     catch (e) {
-        throw new Error(`Invalid registries config at ${exports.REGISTRIES_CONFIG_PATH}: ${e instanceof Error ? e.message : String(e)}`);
+        throw new Error(`Invalid registries config at ${registriesConfigPath()}: ${e instanceof Error ? e.message : String(e)}`);
     }
     if (!Array.isArray(raw)) {
-        throw new Error(`Invalid registries config at ${exports.REGISTRIES_CONFIG_PATH}: expected a JSON array`);
+        throw new Error(`Invalid registries config at ${registriesConfigPath()}: expected a JSON array`);
     }
     for (const entry of raw) {
         if (typeof entry?.name !== 'string' || typeof entry?.remote !== 'string') {
-            throw new Error(`Invalid registries config at ${exports.REGISTRIES_CONFIG_PATH}: malformed entry ${JSON.stringify(entry)}`);
+            throw new Error(`Invalid registries config at ${registriesConfigPath()}: malformed entry ${JSON.stringify(entry)}`);
         }
         if (entry.name === '.' || entry.name.includes('/') || entry.name.includes('\\') || entry.name.includes('..')) {
-            throw new Error(`Invalid registries config at ${exports.REGISTRIES_CONFIG_PATH}: malformed entry name "${entry.name}" (path traversal)`);
+            throw new Error(`Invalid registries config at ${registriesConfigPath()}: malformed entry name "${entry.name}" (path traversal)`);
         }
     }
     return raw;
 }
 function writeRegistriesConfig(entries) {
-    fs_1.default.mkdirSync(AWM_HOME, { recursive: true });
-    fs_1.default.writeFileSync(exports.REGISTRIES_CONFIG_PATH, JSON.stringify(entries, null, 2) + '\n', 'utf-8');
+    fs_1.default.mkdirSync((0, paths_1.awmHome)(), { recursive: true });
+    fs_1.default.writeFileSync(registriesConfigPath(), JSON.stringify(entries, null, 2) + '\n', 'utf-8');
 }
 /** Bootstrap de máquina (awm init): si no hay registries.json, lo crea con la
  *  entrada baseline (remote por cadena WS-2: env > prefs > default).
  *  Devuelve true si sembró. Nunca toca un registries.json existente. */
 function seedBaselineRegistry() {
-    if (fs_1.default.existsSync(exports.REGISTRIES_CONFIG_PATH))
+    if (fs_1.default.existsSync(registriesConfigPath()))
         return false;
     writeRegistriesConfig([{ name: 'baseline', remote: (0, registry_1.resolveBaseRemote)() }]);
     return true;
@@ -111,7 +121,7 @@ async function syncRegistries() {
         try {
             const freshClone = !fs_1.default.existsSync(reg.contentRoot);
             if (freshClone) {
-                fs_1.default.mkdirSync(exports.REGISTRIES_DIR, { recursive: true });
+                fs_1.default.mkdirSync(registriesDir(), { recursive: true });
                 try {
                     await (0, simple_git_1.default)().clone(reg.remote, reg.contentRoot);
                 }
@@ -219,11 +229,11 @@ function readRegistryManifest(root) {
     }
     return { overrides: new Set(overrides), minCliVersion };
 }
-/** Nombre del registry dueño de un path: el nombre del clone bajo REGISTRIES_DIR,
+/** Nombre del registry dueño de un path: el nombre del clone bajo registriesDir(),
  *  o null si no pertenece a ninguno. */
 function registryNameForPath(p) {
     const resolved = path_1.default.resolve(p);
-    const regsRoot = path_1.default.resolve(exports.REGISTRIES_DIR) + path_1.default.sep;
+    const regsRoot = path_1.default.resolve(registriesDir()) + path_1.default.sep;
     if (resolved.startsWith(regsRoot)) {
         const first = resolved.slice(regsRoot.length).split(path_1.default.sep)[0];
         return first || null;
@@ -243,8 +253,19 @@ function verifyMinCliVersions(current = (0, cli_version_1.cliVersion)()) {
         catch {
             continue;
         }
-        if (min && (0, versioning_1.compareSemver)(current, min) < 0)
+        // Falla CERRADO: si alguna de las dos versiones no es legible, se
+        // reporta el fallo en vez de dejar pasar. Antes `compareSemver`
+        // devolvia NaN y `NaN < 0` es false, asi que un `minCliVersion`
+        // malformado hacia que el gate se saltara en silencio.
+        if (!min)
+            continue;
+        try {
+            if ((0, versioning_1.compareSemver)(current, min) < 0)
+                failures.push({ name: reg.name, min });
+        }
+        catch {
             failures.push({ name: reg.name, min });
+        }
     }
     return failures;
 }

package/dist/src/core/renderers/registry.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderedFilename = renderedFilename;
+exports.rendererExtension = rendererExtension;
+/** Extension que el renderer estampa sobre el nombre base, o `null` cuando el
+ *  artefacto se instala con el nombre tal cual (renderer `link`). */
+const RENDERER_EXTENSION = {
+    link: null,
+    'codex-agent-toml': '.toml',
+    'cursor-mdc': '.mdc',
+    'copilot-instructions': '.instructions.md',
+};
+/** `.md` es la unica extension que un `installName` de artefacto puede traer.
+ *  Deliberadamente NO se usa `path.parse().name`: eso corta desde el ULTIMO
+ *  punto, asi que un skill llamado `v1.2-migration` se truncaria a `v1`,
+ *  perdiendo `2-migration` y arriesgando colision con otro skill `v1`. */
+function stripMarkdownSuffix(installName) {
+    return installName.endsWith('.md') ? installName.slice(0, -'.md'.length) : installName;
+}
+/**
+ * Nombre de archivo FISICO que `renderer` produce para `installName`.
+ *
+ * Es la funcion que deben usar por igual el escritor (al planificar la
+ * instalacion) y todo lector (al preguntar "¿esta instalado?"). Que ambos lados
+ * salgan de aca es lo que hace estructuralmente imposible que vuelvan a
+ * discrepar.
+ */
+function renderedFilename(installName, renderer) {
+    const extension = RENDERER_EXTENSION[renderer];
+    return extension === null ? installName : `${stripMarkdownSuffix(installName)}${extension}`;
+}
+/** Extension del renderer, o `null` si instala con el nombre tal cual. Para los
+ *  pocos casos que necesitan la extension suelta (p. ej. "¿hay ALGUN archivo
+ *  renderizado en este directorio?") en vez de un nombre concreto. */
+function rendererExtension(renderer) {
+    return RENDERER_EXTENSION[renderer];
+}