agentic-workflow-manager 3.13.5 → 3.13.6

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

@@ -10,6 +10,7 @@ exports.syncProfile = syncProfile;
 // src/core/bundle-install.ts
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const artifact_name_1 = require("./artifact-name");
 const bundles_1 = require("./bundles");
 const providers_1 = require("../providers");
 const profile_1 = require("./profile");
@@ -18,14 +19,24 @@ const config_1 = require("../utils/config");
 const install_planner_1 = require("./install-planner");
 const install_transaction_1 = require("./install-transaction");
 function bundleArtifacts(b, contentDir) {
+    // Estos nombres vienen VERBATIM del `bundle.json` de un registry — contenido
+    // de terceros. Sin validar, `path.join(installDir, name)` con `../../.ssh`
+    // escapaba del directorio destino, y como el instalador hace
+    // `rmSync(target, {recursive:true})` antes de enlazar, eso BORRABA el ~/.ssh
+    // real del usuario. Se valida en el origen, donde el mensaje puede nombrar
+    // el artefacto culpable; `physicalTarget` ademas asegura contencion
+    // estructural sobre la ruta ya resuelta.
     const refs = [];
     for (const s of b.skills) {
+        (0, artifact_name_1.assertSafeArtifactName)(s.name, 'skill');
         refs.push({ name: s.name, type: 'skill', installName: s.name, sourcePath: path_1.default.join(contentDir, 'skills', s.name) });
     }
     for (const w of b.workflows) {
+        (0, artifact_name_1.assertSafeArtifactName)(w, 'workflow');
         refs.push({ name: w, type: 'workflow', installName: `${w}.md`, sourcePath: path_1.default.join(contentDir, 'workflows', `${w}.md`) });
     }
     for (const a of b.agents) {
+        (0, artifact_name_1.assertSafeArtifactName)(a, 'agent');
         refs.push({ name: a, type: 'agent', installName: `${a}.md`, sourcePath: path_1.default.join(contentDir, 'agents', `${a}.md`) });
     }
     return refs;
@@ -109,30 +120,62 @@ function addBundle(opts) {
  */
 function syncProfile(opts) {
     const profile = (0, profile_1.readProfile)(opts.projectRoot);
-    const installed = [];
     const skipped = [];
-    const modifiedFiles = [];
-    const transactionIds = [];
+    // ONE plan for the whole sync, not one per extension.
+    //
+    // This used to loop `installBundle` over `profile.extensions`, so N extensions
+    // meant N independent `applyInstallPlan` transactions. Each is atomic on its own;
+    // none is atomic with the others. A failure on the third extension left the first
+    // two committed and the tree in a state matching neither before nor after — and
+    // `awm sync` is the command a team runs to make a checkout match its profile, so
+    // "partially matches" is the one outcome it must not produce.
+    //
+    // Merging is safe because the two halves were already built for it: expanding a
+    // bundle (`expandBundleArtifacts`) is pure, and `planInstall` dedups by physical
+    // target across ALL the artifacts it is handed — which is also why two extensions
+    // sharing a dependency now collapse into one operation instead of racing to write
+    // the same path twice. `applyInstallPlan` backs up and rolls back per plan, so one
+    // plan is precisely what makes the sync atomic.
+    const intents = [];
     for (const ext of profile.extensions) {
-        if (!opts.bundles.some((b) => b.name === ext)) {
+        const bundle = opts.bundles.find((b) => b.name === ext);
+        if (!bundle) {
             skipped.push(`${ext} (bundle not found in registry — remove with \`awm remove ${ext}\`)`);
             continue;
         }
-        const summary = installBundle({
+        intents.push(...expandBundleArtifacts({
             bundleName: ext,
             bundles: opts.bundles,
             agents: opts.agents,
             method: opts.method,
             projectRoot: opts.projectRoot,
             contentDir: opts.contentDir,
-            applyPlan: opts.applyPlan,
-        });
-        installed.push(...summary.installed);
-        skipped.push(...summary.skipped);
-        modifiedFiles.push(...summary.modifiedFiles);
-        transactionIds.push(summary.transactionId);
+        }));
     }
     if (profile.extensions.length > 0)
         (0, profile_1.ensureSkillsGitignored)(opts.projectRoot, opts.agents);
-    return { installed, skipped, extensions: profile.extensions, transactionIds, modifiedFiles };
+    // Nothing resolvable: no plan, no transaction, nothing to name to `awm backup
+    // restore`. An empty `transactionIds` is the honest answer, not a phantom id.
+    if (intents.length === 0) {
+        return { installed: [], skipped, extensions: profile.extensions, transactionIds: [], modifiedFiles: [] };
+    }
+    const plan = (0, install_planner_1.planInstall)({
+        artifacts: intents,
+        selectedAgents: opts.agents,
+        enabledAgents: (0, config_1.getPreferences)().enabledAgents,
+        // Every extension in the profile is a project-scope bundle by construction
+        // (`shouldRecordExtension` only records those), so the whole sync resolves to
+        // one scope — which is what lets it be one plan.
+        scope: 'local',
+        projectRoot: opts.projectRoot,
+        method: opts.method,
+    });
+    const summary = (opts.applyPlan ?? install_transaction_1.applyInstallPlan)(plan);
+    return {
+        installed: summary.installed,
+        skipped: [...skipped, ...summary.skipped],
+        extensions: profile.extensions,
+        transactionIds: [summary.transactionId],
+        modifiedFiles: summary.modifiedFiles,
+    };
 }

package/dist/src/core/bundles.js

@@ -16,15 +16,59 @@ const registries_1 = require("./registries");
 function catalogPath(contentDir) {
     return path_1.default.join(contentDir, 'catalog.json');
 }
+/** Lee `catalog.json` de un registry.
+ *
+ *  El contenido de un registry es INPUT NO CONFIABLE (un registry de equipo,
+ *  interno, o agregado con `awm registry add`), asi que se valida forma antes de
+ *  desreferenciar. Sin esto, un solo archivo malformado en CUALQUIER registry
+ *  — incluido uno que llega por un `awm update` rutinario — hacia que `awm list`
+ *  y `awm add` murieran con un stack trace crudo de Node y ningun mensaje
+ *  accionable. Los demas lectores de contenido de registry de este repo
+ *  (readRegistriesConfig, readRegistryManifest, readProfile) ya validaban; estos
+ *  dos eran los que faltaban. */
 function readCatalog(contentDir) {
     const file = catalogPath(contentDir);
     if (!fs_1.default.existsSync(file))
         return [];
-    const parsed = JSON.parse(fs_1.default.readFileSync(file, 'utf-8'));
-    return parsed.bundles ?? [];
+    let parsed;
+    try {
+        parsed = JSON.parse(fs_1.default.readFileSync(file, 'utf-8'));
+    }
+    catch {
+        throw new Error(`${file} is not valid JSON. Fix the file in its registry, then re-run \`awm update\`.`);
+    }
+    if (parsed === null || typeof parsed !== 'object') {
+        throw new Error(`${file} must contain a JSON object.`);
+    }
+    const bundles = parsed.bundles;
+    if (bundles === undefined)
+        return [];
+    if (!Array.isArray(bundles)) {
+        throw new Error(`${file}: "bundles" must be an array.`);
+    }
+    // Una entrada sin `source` usable haria que `path.join` tirara un
+    // TypeError opaco mas adelante; se descarta aca, nombrando el archivo.
+    return bundles.filter((entry) => entry !== null && typeof entry === 'object' && typeof entry.source === 'string');
 }
+/** Tolera `skills` ausente o mal formado: lo que no sea un array se trata como
+ *  vacio en vez de tirar `(raw ?? []).map is not a function`, y cada entrada se
+ *  valida individualmente. */
 function normalizeSkillRefs(raw) {
-    return (raw ?? []).map((s) => typeof s === 'string' ? { name: s, onSignal: false } : { name: s.name, onSignal: s.onSignal === true });
+    if (!Array.isArray(raw))
+        return [];
+    return raw.flatMap((s) => {
+        if (typeof s === 'string')
+            return [{ name: s, onSignal: false }];
+        if (s !== null && typeof s === 'object' && typeof s.name === 'string') {
+            return [{ name: s.name, onSignal: s.onSignal === true }];
+        }
+        return [];
+    });
+}
+/** Array de strings, o vacio. Cualquier otra forma en el contenido del registry
+ *  se ignora en vez de propagarse hasta un crash aguas abajo. */
+function stringArray(raw) {
+    return Array.isArray(raw) ? raw.filter((v) => typeof v === 'string') : [];
 }
 function discoverBundles(contentDir) {
     const entries = readCatalog(contentDir);
@@ -33,17 +77,32 @@ function discoverBundles(contentDir) {
         const manifestPath = path_1.default.join(contentDir, entry.source, 'bundle.json');
         if (!fs_1.default.existsSync(manifestPath))
             continue;
-        const raw = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf-8'));
+        let raw;
+        try {
+            raw = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf-8'));
+        }
+        catch {
+            throw new Error(`${manifestPath} is not valid JSON. Fix the file in its registry, then re-run \`awm update\`.`);
+        }
+        if (raw === null || typeof raw !== 'object') {
+            throw new Error(`${manifestPath} must contain a JSON object.`);
+        }
+        const m = raw;
+        // Un bundle sin nombre usable no es instalable y solo produciria errores
+        // opacos mas adelante — se nombra el archivo y se falla aca.
+        if (typeof m.name !== 'string' || m.name === '') {
+            throw new Error(`${manifestPath}: "name" must be a non-empty string.`);
+        }
         bundles.push({
-            name: raw.name,
-            description: raw.description ?? '',
-            version: raw.version ?? '0.0.0',
-            scope: raw.scope ?? 'project',
-            visibility: raw.visibility ?? 'public',
-            dependsOn: raw.dependsOn ?? [],
-            skills: normalizeSkillRefs(raw.skills),
-            workflows: raw.workflows ?? [],
-            agents: raw.agents ?? [],
+            name: m.name,
+            description: typeof m.description === 'string' ? m.description : '',
+            version: typeof m.version === 'string' ? m.version : '0.0.0',
+            scope: m.scope ?? 'project',
+            visibility: m.visibility ?? 'public',
+            dependsOn: stringArray(m.dependsOn),
+            skills: normalizeSkillRefs(m.skills),
+            workflows: stringArray(m.workflows),
+            agents: stringArray(m.agents),
             contentRoot: contentDir,
         });
     }

package/dist/src/core/context/regenerate.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.regenerateGlobalContext = regenerateGlobalContext;
 // W3 — Regeneración del contexto global tras `awm update`.
-// Para cada agente con inyección config-instructions cuya config exista:
+// Para cada agente con un mecanismo de inyección aplicable:
 //   - 'stale'    (sentinel presente, archivo materializado ausente/viejo) → re-materializa.
 //   - 'injected' (ya fresco)                                              → no toca nada.
 //   - 'absent'   (sentinel ausente)                                       → no inyecta (eso es `awm init`).
@@ -21,10 +21,27 @@ function regenerateGlobalContext(targets = [...providers_1.AGENT_TARGETS], orch
     const out = [];
     for (const agent of targets) {
         const inj = (0, providers_1.providerFor)(agent).injection;
-        if (!inj || inj.type !== 'config-instructions')
-            continue;
-        if (!fs_1.default.existsSync(inj.configPath))
+        if (!inj)
             continue;
+        // Antes esto exigia `type === 'config-instructions'`, o sea que SOLO se
+        // regeneraba OpenCode: para codex, cursor y copilot (`managed-agents-md`)
+        // `awm update` era un no-op silencioso — ni un aviso — y el unico modo
+        // de refrescar su contexto era volver a correr `awm init`. Peor: doctor
+        // marcaba ⚠ pero seguia reportando `status: healthy` / exit 0, asi que
+        // un AGENTS.md desactualizado era invisible para cualquier gate de CI
+        // que mirara el codigo de salida.
+        //
+        // El destino global de `managed-agents-md` puede ser null (cursor y
+        // copilot no tienen archivo de contexto global); ahi no hay nada global
+        // que regenerar y se saltea limpio.
+        if (inj.type === 'config-instructions') {
+            if (!fs_1.default.existsSync(inj.configPath))
+                continue;
+        }
+        else if (inj.type === 'managed-agents-md') {
+            if (inj.globalPath === null)
+                continue;
+        }
         const op = {
             agent,
             scope: 'global',

package/dist/src/core/context/strategies/codex-agents.js

@@ -101,9 +101,25 @@ class CodexAgentsStrategy {
         // separate global file, so this is the only writer of the project AGENTS.md.
         const injection = provider.injection;
         const contextCoversThisFile = injection?.type === 'managed-agents-md' && injection.globalPath === null;
-        const result = contextCoversThisFile
+        // La guarda de arriba solo mira a ESTE provider. Pero el bloque es uno
+        // solo por archivo, y OTRO provider ya habilitado (cursor/copilot, cuyo
+        // contexto ES este archivo) pudo haberlo escrito antes — con el contexto
+        // AWM completo, del que PROJECT_GUIDANCE es apenas la cola. Sin este
+        // chequeo, un `awm init -a codex` posterior lo reemplazaba por las 6
+        // lineas de PROJECT_GUIDANCE: 140 -> 6, y para Copilot ese archivo es su
+        // UNICO canal de entrega, asi que se quedaba sin nada. Y al reves otra
+        // vez en el siguiente init. Se compara contra el bloque real en disco en
+        // vez de asumir quien escribio: si ya cubre PROJECT_GUIDANCE, lo que hay
+        // es un superconjunto y pisarlo seria perder informacion.
+        const agentsMdPath = path_1.default.join(projectRoot, 'AGENTS.md');
+        const existingBody = fs_1.default.existsSync(agentsMdPath)
+            ? (0, managed_block_1.managedBlockBody)(fs_1.default.readFileSync(agentsMdPath, 'utf-8'))
+            : null;
+        const alreadyCovered = existingBody !== null &&
+            (0, managed_block_1.normalizeManagedBody)(existingBody).includes((0, managed_block_1.normalizeManagedBody)(PROJECT_GUIDANCE));
+        const result = contextCoversThisFile || alreadyCovered
             ? 'unchanged'
-            : injectFile(path_1.default.join(projectRoot, 'AGENTS.md'), PROJECT_GUIDANCE);
+            : injectFile(agentsMdPath, PROJECT_GUIDANCE);
         let carrierResult = 'unchanged';
         if (agent === 'cursor') {
             // Cursor's Background/Cloud Agent does not reliably read AGENTS.md (open,

package/dist/src/core/diagnostics/checks.js

@@ -30,7 +30,15 @@ function machineChecks(m) {
             detail: `git ${m.registryCache.gitState ?? 'unknown'}`, remedy: none });
     }
     // machine.hook
-    if (m.hook.present && !m.hook.degraded) {
+    // Un provider sin mecanismo de hooks no puede "tener el hook instalado":
+    // no se emite fila alguna, igual que ya hacen el paso de init
+    // (init/steps.ts, "no hook mechanism for this agent") y el reporte por
+    // provider (provider-checks.ts, que descarta la fila). Emitir `missing`
+    // aca era lo que ponia `awm init` en exit 1 para 4 de los 6 providers.
+    if (!m.hook.applicable) {
+        // sin fila
+    }
+    else if (m.hook.present && !m.hook.degraded) {
         out.push({ id: 'machine.hook', level: 'machine', label: 'hook SessionStart', status: 'ok', remedy: none });
     }
     else if (m.hook.present) {
@@ -106,6 +114,17 @@ function projectChecks(p) {
         out.push({ id: 'project.activation', level: 'project', label: 'active bundles', status: 'missing',
             detail: `${missingLinks.length} missing, ${p.activeBundles.broken.length} broken`, remedy: cmd('awm sync') });
     }
+    // project.orphans — links colgantes que ya no pertenecen a ninguna extension.
+    // Fila propia y no parte de `project.activation`: ese check mide "falta lo que el
+    // profile pide", y esto es lo contrario — sobra lo que el profile ya no pide. Sin
+    // separarlos, un proyecto con todo lo esperado instalado reportaba `ok` mientras
+    // arrastraba skills muertas que el agente sigue intentando leer.
+    const orphans = p.orphanLinks.repairable.length + p.orphanLinks.dead.length;
+    if (orphans > 0) {
+        out.push({ id: 'project.orphans', level: 'project', label: 'orphaned skill links', status: 'warn',
+            detail: `${p.orphanLinks.repairable.length} repairable, ${p.orphanLinks.dead.length} dead`,
+            remedy: cmd('awm sync') });
+    }
     // project.sensors
     out.push(p.sensors.present
         ? { id: 'project.sensors', level: 'project', label: 'sensors', status: 'ok', remedy: none }
@@ -137,7 +156,12 @@ function projectChecks(p) {
 // actionable-but-expected transient states (rendered with ◷/⚠, not ✖) and
 // do not by themselves degrade `overall`, mirroring how a 'warn' CheckResult
 // doesn't degrade the machine+project report either.
-const DEGRADING_PROVIDER_STATES = ['missing', 'unsupported', 'broken', 'absent', 'conflict'];
+// `stale` cuenta como degradado: un contexto desactualizado es exactamente la
+// clase de problema que un gate de CI tiene que ver. Antes doctor imprimia ⚠
+// junto a `status: healthy` y exit 0, asi que un AGENTS.md viejo — o sobrescrito
+// por otro provider — era invisible para cualquier script que mirara el codigo
+// de salida. Un aviso que no cambia el veredicto no es un aviso, es ruido.
+const DEGRADING_PROVIDER_STATES = ['missing', 'unsupported', 'broken', 'absent', 'conflict', 'stale'];
 function computeProviderOverall(providers) {
     const degraded = providers.some((p) => p.checks.some((c) => DEGRADING_PROVIDER_STATES.includes(c.state)));
     return degraded ? 'degraded' : 'healthy';

package/dist/src/core/diagnostics/context.js

@@ -9,6 +9,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const providers_1 = require("../../providers");
+const registry_1 = require("../renderers/registry");
 const registries_1 = require("../registries");
 const orchestrator_1 = require("../context/orchestrator");
 const status_1 = require("../../commands/hooks/status");
@@ -31,15 +32,29 @@ function linkState(dir, skill) {
         return fs_1.default.existsSync(p) ? 'present' : 'broken';
     return 'present'; // un dir/archivo real también cuenta como presente
 }
-function classifyLinks(skillNames, dir) {
+/** Clasifica artefactos por su presencia en disco.
+ *
+ *  `renderer` NO es opcional a proposito. El escritor (`physicalTarget`) estampa
+ *  la extension del renderer sobre el nombre — `using-awm.mdc`,
+ *  `using-awm.instructions.md` — y este lector buscaba el nombre pelado
+ *  (`using-awm`), asi que para Cursor y Copilot NADA figuraba nunca como
+ *  instalado: `awm init` reinstalaba el baseline completo en cada corrida (2
+ *  directorios de backup sin podar por corrida) y `awm doctor` mostraba un rojo
+ *  permanente cuyo remedio no podia satisfacerlo. Exigir el renderer obliga a
+ *  cada caller a declarar de que artefacto habla, y `renderedFilename` es la
+ *  misma funcion que usa el escritor — no pueden volver a discrepar.
+ *
+ *  Los nombres devueltos son los LOGICOS (los de entrada), no los fisicos: los
+ *  consumidores comparan contra listas de nombres de bundle. */
+function classifyLinks(names, dir, renderer) {
     const linked = [];
     const broken = [];
-    for (const s of skillNames) {
-        const st = linkState(dir, s);
+    for (const name of names) {
+        const st = linkState(dir, (0, registry_1.renderedFilename)(name, renderer));
         if (st === 'present')
-            linked.push(s);
+            linked.push(name);
         else if (st === 'broken')
-            broken.push(s);
+            broken.push(name);
     }
     return { linked, broken };
 }
@@ -91,7 +106,7 @@ function gatherContextInjection() {
     }
     return out;
 }
-function gatherMachine(bundles, agent = 'claude-code') {
+function gatherMachine(bundles, agent = 'claude-code', projectRoot) {
     // registryCache: estado del primer registry configurado (baseline en una máquina sembrada)
     const regs = (0, registries_1.listRegistries)();
     const first = regs[0];
@@ -105,21 +120,33 @@ function gatherMachine(bundles, agent = 'claude-code') {
     // caught while building this task's real end-to-end init test).
     let hookPresent = false;
     let hookDegraded = false;
-    try {
-        const hs = (0, status_1.computeHookStatus)(agent);
-        hookPresent = hs.checks.settingsEntry.ok;
-        hookDegraded = hs.overall === 'DEGRADED';
+    // La aplicabilidad se computa DONDE el provider esta en alcance, no se
+    // infiere de que `computeHookStatus` haya tirado (un throw puede ser "no
+    // soporta hooks" o un error real, y confundirlos fue el bug).
+    const hookApplicable = (0, providers_1.providerFor)(agent).hooks !== undefined;
+    if (hookApplicable) {
+        try {
+            const hs = (0, status_1.computeHookStatus)(agent);
+            hookPresent = hs.checks.settingsEntry.ok;
+            hookDegraded = hs.overall === 'DEGRADED';
+        }
+        catch { /* soporta hooks pero no se pudo leer el estado → ausente */ }
     }
-    catch { /* sin soporte de hooks → ausente */ }
     // devCore (bundle baseline) — skillsDir is null only for providers with no global skill
     // discovery mechanism (today: Copilot); for those, there is no global-scope devCore
     // concept to satisfy at all, so it's treated as trivially satisfied (see below).
     const skillsDir = (0, providers_1.providerFor)(agent).skill.global;
-    const baseline = bundles.find((b) => b.scope === 'baseline');
+    // TODOS los baseline, igual que `stepDevCore` los instala y que
+    // `reconciliation.ts` los reconcilia. Con `find`, el hecho que decide si el
+    // baseline esta satisfecho miraba solo el primero, asi que un segundo bundle
+    // baseline sin instalar reportaba `healthy` — y el step, que lee este mismo
+    // hecho, nunca lo instalaba.
+    const baselines = bundles.filter((b) => b.scope === 'baseline');
+    const baseline = baselines[0];
     let devCorePresent = false;
     let brokenLinks = [];
     if (baseline) {
-        const skillNames = (0, bundles_1.resolveBundleSkills)(baseline.name, bundles);
+        const skillNames = [...new Set(baselines.flatMap((b) => (0, bundles_1.resolveBundleSkills)(b.name, bundles)))];
         if (skillsDir === null) {
             // No global skill directory for this agent (today: Copilot) — there is no
             // global-scope devCore/baseline-bundle concept to satisfy for it at all, so
@@ -131,10 +158,28 @@ function gatherMachine(bundles, agent = 'claude-code') {
             // (init/steps.ts) would fall through on every run and call installBundle at
             // global scope, which throws (skill.global === null), rolling back the
             // ENTIRE `awm init -a copilot` transaction, 100% of the time.
-            devCorePresent = true;
+            // Sin directorio global de skills (hoy: Copilot) el baseline se
+            // instala a nivel PROYECTO — `stepDevCore` lo hace con
+            // scopeOverride 'local'. Antes esto se declaraba "trivialmente
+            // satisfecho" incondicionalmente: eso evitaba el crash-loop del
+            // install global, pero significaba que Copilot terminaba con CERO
+            // skills mientras init imprimia `✔ dev-core` y doctor decia
+            // `healthy`. Ahora se mira donde el artefacto REALMENTE va.
+            if (projectRoot) {
+                const localDir = path_1.default.join(projectRoot, (0, providers_1.providerFor)(agent).skill.local);
+                const { linked, broken } = classifyLinks(skillNames, localDir, (0, providers_1.providerFor)(agent).skill.renderer);
+                const absent = skillNames.filter((s) => !linked.includes(s) && !broken.includes(s));
+                devCorePresent = skillNames.length > 0 && (linked.length + broken.length) > 0;
+                brokenLinks = [...broken, ...absent];
+            }
+            else {
+                // Fuera de un proyecto no hay destino local: no hay nada que
+                // reclamar como faltante.
+                devCorePresent = true;
+            }
         }
         else {
-            const { linked, broken } = classifyLinks(skillNames, skillsDir);
+            const { linked, broken } = classifyLinks(skillNames, skillsDir, (0, providers_1.providerFor)(agent).skill.renderer);
             const absent = skillNames.filter((s) => !linked.includes(s) && !broken.includes(s));
             devCorePresent = skillNames.length > 0 && (linked.length + broken.length) > 0;
             brokenLinks = [...broken, ...absent];
@@ -151,12 +196,24 @@ function gatherMachine(bundles, agent = 'claude-code') {
         // (tests/integration/codex-provider-isolated.test.ts).
         const agentConfig = (0, providers_1.providerFor)(agent).agent;
         if (agentConfig && agentConfig.global !== null) {
-            const agentNames = (0, bundles_1.resolveBundleAgents)(baseline.name, bundles);
+            const agentNames = [...new Set(baselines.flatMap((b) => (0, bundles_1.resolveBundleAgents)(b.name, bundles)))];
             if (agentNames.length > 0) {
-                const filenames = agentNames.map((n) => agentConfig.renderer === 'codex-agent-toml' ? `${n}.toml` : n);
-                const { linked: agentLinked, broken: agentBroken } = classifyLinks(filenames, agentConfig.global);
+                // El installName real de un artefacto `agent` es `<n>.md`
+                // (bundle-install.ts), y el renderer decide la extension final:
+                // `.toml` para codex, `.md` tal cual para los renderers `link`.
+                // El ternario anterior devolvia `n` pelado para `link`, asi que
+                // `machine.devCore` quedaba permanentemente roto para
+                // claude-code — el provider por DEFECTO — contra el registry real.
+                const filenames = agentNames.map((n) => `${n}.md`);
+                const { linked: agentLinked, broken: agentBroken } = classifyLinks(filenames, agentConfig.global, agentConfig.renderer);
                 const agentAbsent = filenames.filter((f) => !agentLinked.includes(f) && !agentBroken.includes(f));
-                brokenLinks = [...brokenLinks, ...agentBroken, ...agentAbsent];
+                // `brokenLinks` es de diagnostico: se le muestra al usuario para
+                // que vaya a buscar ese archivo. Por eso se reportan los nombres
+                // FISICOS (`development-process.toml`), aunque la clasificacion
+                // trabaje con los logicos — que es lo que necesitan las
+                // comparaciones por cantidad de arriba.
+                const physical = (n) => (0, registry_1.renderedFilename)(n, agentConfig.renderer);
+                brokenLinks = [...brokenLinks, ...agentBroken.map(physical), ...agentAbsent.map(physical)];
             }
         }
     }
@@ -183,17 +240,17 @@ function gatherMachine(bundles, agent = 'claude-code') {
         const skillNames = (0, bundles_1.resolveBundleSkills)(name, bundles);
         if (skillNames.length === 0)
             return false;
-        const { linked } = classifyLinks(skillNames, skillsDir);
+        const { linked } = classifyLinks(skillNames, skillsDir, (0, providers_1.providerFor)(agent).skill.renderer);
         return linked.length === skillNames.length;
     });
     return {
         registryCache: { present: cachePresent, gitState },
-        hook: { present: hookPresent, degraded: hookDegraded },
+        hook: { present: hookPresent, degraded: hookDegraded, applicable: hookApplicable },
         devCore: { present: devCorePresent, brokenLinks },
         ambient: { wanted, installed },
         contextInjection: gatherContextInjection(),
         globalSkills: skillsDir !== null
-            ? (0, skill_integrity_1.classifyGlobalSkills)(skillsDir, (0, registries_1.contentRoots)())
+            ? (0, skill_integrity_1.classifySkillLinks)(skillsDir, (0, registries_1.contentRoots)())
             : { valid: [], repairable: [], dead: [] },
     };
 }
@@ -207,7 +264,15 @@ function gatherProject(root, bundles, agent = 'claude-code') {
             if (!expected.includes(s))
                 expected.push(s);
     }
-    const { linked, broken } = classifyLinks(expected, localSkillsDir);
+    const { linked, broken } = classifyLinks(expected, localSkillsDir, (0, providers_1.providerFor)(agent).skill.renderer);
+    // Huerfanos: symlinks colgantes que el profile ya no reclama. Se clasifican sobre
+    // el dir REAL, no sobre la lista esperada — que es justamente lo que `linked`/
+    // `broken` de arriba no pueden ver. `awm sync` los cura o los poda.
+    const orphanScan = (0, skill_integrity_1.classifySkillLinks)(localSkillsDir, (0, registries_1.contentRoots)());
+    const orphanLinks = {
+        repairable: orphanScan.repairable.filter((n) => !expected.includes(n)),
+        dead: orphanScan.dead.filter((n) => !expected.includes(n)),
+    };
     let context = { present: false };
     if (fs_1.default.existsSync(path_1.default.join(root, 'CLAUDE.md')))
         context = { present: true, file: 'CLAUDE.md' };
@@ -217,6 +282,7 @@ function gatherProject(root, bundles, agent = 'claude-code') {
         root,
         profile: { present: profilePresent, extensions: profile.extensions },
         activeBundles: { expected, linked, broken },
+        orphanLinks,
         sensors: { present: fs_1.default.existsSync(path_1.default.join(root, '.awm', 'sensors.json')) },
         constitution: { present: fs_1.default.existsSync(path_1.default.join(root, 'CONSTITUTION.md')) },
         context,
@@ -228,9 +294,9 @@ function gatherContext(opts = {}) {
     const agent = opts.agent ?? 'claude-code';
     const root = (0, profile_1.findProjectRoot)(cwd);
     const agents = opts.agents ?? [agent];
-    const scanSkills = opts.scanSkills ?? ((dir) => (0, skill_integrity_1.classifyGlobalSkills)(dir, (0, registries_1.contentRoots)()));
+    const scanSkills = opts.scanSkills ?? ((dir) => (0, skill_integrity_1.classifySkillLinks)(dir, (0, registries_1.contentRoots)()));
     return {
-        machine: gatherMachine(bundles, agent),
+        machine: gatherMachine(bundles, agent, root ?? undefined),
         project: root ? gatherProject(root, bundles, agent) : null,
         providers: (0, provider_checks_1.gatherProviderChecks)(agents, scanSkills, root ?? undefined),
     };