agentic-workflow-manager 4.1.1 → 5.0.1

package/dist/src/commands/init.js

@@ -270,8 +270,20 @@ async function runInit(opts = {}) {
             json: opts.json,
         });
     }
-    // `result` mirrors the exit code, so a consumer can branch on one field
-    // instead of correlating stdout with $?: ok → 0, degraded → 1, failed → 2.
+    // `result` distinguishes `ok` from `degraded` in the JSON; the EXIT CODE does
+    // not, on purpose (D-008).
+    //
+    // `degraded` used to exit `1`. It does not mean init failed — it means the
+    // harness still has `pending` steps, which is the NORMAL outcome of a first run:
+    // `CONSTITUTION.md` and `AGENTS.md` are written by an agent session, not by the
+    // CLI. So a run where nothing broke reported failure, and `awm init --yes && …`
+    // died under `set -e` — in the one command whose entire job is bootstrapping a
+    // script. Three independent readers called it a bug before it was one; the docs
+    // had grown a warning box asking people to ignore the exit code.
+    //
+    // The exit code now answers "did init do its job?". "Is the harness fully
+    // healthy?" is `awm doctor`'s question, and `result` still carries it here for
+    // any consumer that wants to branch on it.
     const result = outcome.after.overall === 'healthy' ? 'ok' : 'degraded';
     if (opts.json) {
         process.stdout.write(JSON.stringify({ result, ...outcome }, null, 2) + '\n');
@@ -279,7 +291,7 @@ async function runInit(opts = {}) {
     else {
         process.stdout.write(renderInitOutcome(outcome) + '\n');
     }
-    return result === 'ok' ? 0 : 1;
+    return 0;
 }
 // ---------------------------------------------------------------------------
 // Extension confirmation factory

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

@@ -125,6 +125,14 @@ function projectChecks(p) {
             detail: `${p.orphanLinks.repairable.length} repairable, ${p.orphanLinks.dead.length} dead`,
             remedy: cmd('awm sync') });
     }
+    // Fila aparte de `project.orphans`, y con OTRO remedio: `awm sync` solo toca
+    // symlinks, asi que sobre un directorio real que piso nuestro link corre limpio sin
+    // cambiar nada. Mandar ahi al usuario seria peor que no ofrecer remedio (D-007).
+    if (p.orphanLinks.usurped.length > 0) {
+        out.push({ id: 'project.usurped', level: 'project', label: 'skill links replaced by non-AWM content',
+            status: 'warn', detail: p.orphanLinks.usurped.join(', '),
+            remedy: cmd(`awm remove <bundle> --yes && awm add <bundle> --yes`) });
+    }
     // project.sensors
     out.push(p.sensors.present
         ? { id: 'project.sensors', level: 'project', label: 'sensors', status: 'ok', remedy: none }

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

@@ -280,10 +280,15 @@ function gatherProject(root, bundles, agent = 'claude-code') {
     // 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 orphanScan = (0, skill_integrity_1.classifySkillLinks)(localSkillsDir, (0, registries_1.contentRoots)(), (0, skill_integrity_1.managedLinkTargets)(safeReadArtifactState()));
     const orphanLinks = {
         repairable: orphanScan.repairable.filter((n) => !expected.includes(n)),
         dead: orphanScan.dead.filter((n) => !expected.includes(n)),
+        // Usurpados NO se filtran contra `expected`: lo huerfano es lo que sobra, y esto
+        // es lo contrario — una skill que el profile SI reclama, cuyo link reemplazo un
+        // tercero por contenido suyo. Se reporta aparte porque el remedio difiere: `awm
+        // sync` cura symlinks colgantes y sobre un directorio real no hace nada.
+        usurped: orphanScan.usurped,
     };
     let context = { present: false };
     if (fs_1.default.existsSync(path_1.default.join(root, 'CLAUDE.md')))

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

@@ -18,6 +18,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const providers_1 = require("../../providers");
 const skill_integrity_1 = require("../skill-integrity");
+const artifact_state_1 = require("../artifact-state");
 const provider_version_1 = require("../provider-version");
 const status_1 = require("../../commands/hooks/status");
 const orchestrator_1 = require("../context/orchestrator");
@@ -208,14 +209,24 @@ function workflowsGlobalCheck(agent) {
     // Los workflows se instalan con el renderer `link`, asi que un symlink colgante es
     // exactamente la misma clase de rotura que en skills — y se clasifica con la misma
     // funcion, no con una copia local que pueda divergir.
-    const integrity = (0, skill_integrity_1.classifySkillLinks)(dir, (0, registries_1.contentRoots)());
+    //
+    // El ledger va SIEMPRE que se escanee un dir gestionado. Cuando se agrego la
+    // deteccion de usurpaciones (D-007) se cableo en el seam `scanSkills`, que alimenta
+    // `skills.global` — y este sitio, que llama al clasificador directo, quedo afuera:
+    // detectaba links colgantes y no un workflow reemplazado por contenido ajeno. Es el
+    // mismo hermano-sin-tratar que ya aparecio varias veces en este archivo.
+    const integrity = (0, skill_integrity_1.classifySkillLinks)(dir, (0, registries_1.contentRoots)(), (0, skill_integrity_1.managedLinkTargets)(safeArtifactState()));
     const broken = integrity.repairable.length + integrity.dead.length;
+    const usurped = integrity.usurped.length;
     return {
         id: 'workflows.global',
-        state: broken > 0 ? 'broken' : 'healthy',
+        state: broken > 0 || usurped > 0 ? 'broken' : 'healthy',
         target: dir,
-        detail: broken > 0 ? `${broken} broken link(s)` : undefined,
-        remediationCode: broken > 0 ? 'awm-init' : undefined,
+        detail: [
+            broken > 0 ? `${broken} broken link(s)` : null,
+            usurped > 0 ? `${usurped} replaced by non-AWM content (${integrity.usurped.join(', ')})` : null,
+        ].filter(Boolean).join('; ') || undefined,
+        remediationCode: usurped > 0 ? 'reinstall-usurped-skills' : broken > 0 ? 'awm-init' : undefined,
     };
 }
 function agentsNativeCheck(agent) {
@@ -253,7 +264,35 @@ function agentsNativeCheck(agent) {
             remediationCode: broken > 0 ? 'reinstall-native-agents' : undefined,
         };
     }
-    return { id: 'agents.native', state: 'healthy', target: dir };
+    // Renderer `link` (claude-code, `~/.claude/agents`): esto devolvia `healthy` fijo
+    // con solo mirar que el dir no estuviera vacio. Un symlink colgante ahi adentro
+    // pasaba, y un artefacto reemplazado por contenido de un tercero tambien — el
+    // agente cargaba el ajeno mientras doctor daba verde. El dir es gestionado igual
+    // que el de skills, asi que se verifica igual.
+    const integrity = (0, skill_integrity_1.classifySkillLinks)(dir, (0, registries_1.contentRoots)(), (0, skill_integrity_1.managedLinkTargets)(safeArtifactState()));
+    const broken = integrity.repairable.length + integrity.dead.length;
+    const usurped = integrity.usurped.length;
+    return {
+        id: 'agents.native',
+        state: broken > 0 || usurped > 0 ? 'broken' : 'healthy',
+        target: dir,
+        detail: [
+            broken > 0 ? `${broken} broken link(s)` : null,
+            usurped > 0 ? `${usurped} replaced by non-AWM content (${integrity.usurped.join(', ')})` : null,
+        ].filter(Boolean).join('; ') || undefined,
+        remediationCode: usurped > 0 ? 'reinstall-usurped-skills' : broken > 0 ? 'reinstall-native-agents' : undefined,
+    };
+}
+/** El ledger de propiedad, best-effort: un archivo ausente o corrupto degrada a "no
+ *  puedo detectar usurpaciones", nunca revienta un comando de diagnostico. Mismo
+ *  criterio que `safeReadArtifactState` en context.ts. */
+function safeArtifactState() {
+    try {
+        return (0, artifact_state_1.readArtifactState)();
+    }
+    catch {
+        return [];
+    }
 }
 function hookTrustCheck(agent) {
     const provider = (0, providers_1.providerFor)(agent);

package/dist/src/release/orchestrator.js

@@ -109,8 +109,54 @@ function release(opts, io) {
         throw publishError;
     }
     if (opts.push) {
-        io.run('git', ['push', 'origin', opts.branch]);
+        // El TAG primero, y a proposito.
+        //
+        // Despues de un publish exitoso ya no hay vuelta atras: npm tiene la version. A
+        // partir de aca todo fallo de git deja a npm adelantado respecto del repo, y lo
+        // unico que decide cuan grave es eso es CUANTO alcanzo a quedar registrado.
+        //
+        // Un tag no puede entrar en conflicto — es una ref nueva —, asi que se empuja
+        // antes: en el peor caso queda el tag que identifica exactamente que se publico,
+        // y lo unico que falta es el commit de bump, que una persona puede reponer. Al
+        // reves (main primero) un push rechazado se lleva puesta tambien la identidad de
+        // la version, que es lo que paso con la 4.0.1: publicada, sin tag, sin CHANGELOG.
         io.run('git', ['push', 'origin', `v${version}`]);
+        // El push de `main` SI puede perder una carrera. Se reintenta rebaseando: el commit
+        // de bump toca solo `cli/package.json` y `CHANGELOG.md`, y lleva `[skip ci]`.
+        pushBranchWithRebase(io, opts.branch, version);
     }
     return { released: true, version };
 }
+const PUSH_ATTEMPTS = 3;
+/**
+ * Empuja `branch` reintentando con `pull --rebase` ante un rechazo. Si agota los
+ * intentos tira un error que NOMBRA el estado real del mundo — npm publicado, git a
+ * medias — en vez de un "failed to push some refs" que no dice que hacer.
+ *
+ * El `concurrency` de release.yml deberia hacer que esto no llegue a usarse nunca.
+ * Esta igual porque serializar evita la carrera CONOCIDA, y este es el unico punto del
+ * pipeline donde un fallo es irreversible a medias.
+ */
+function pushBranchWithRebase(io, branch, version) {
+    for (let attempt = 1; attempt <= PUSH_ATTEMPTS; attempt++) {
+        try {
+            io.run('git', ['push', 'origin', branch]);
+            return;
+        }
+        catch (err) {
+            if (attempt === PUSH_ATTEMPTS) {
+                throw new Error(`v${version} YA SE PUBLICO en npm, pero el commit de bump no se pudo ` +
+                    `empujar a '${branch}' despues de ${PUSH_ATTEMPTS} intentos. El tag ` +
+                    `v${version} si esta en el remoto. Para reconciliar: rebasar el commit ` +
+                    `'chore(release): v${version}' sobre origin/${branch} y empujarlo a mano. ` +
+                    `NO re-publicar. Causa: ${err.message}`);
+            }
+            // Un fallo de red no lo arregla el rebase, pero tampoco lo empeora: el
+            // siguiente intento reintenta el push igual.
+            try {
+                io.run('git', ['pull', '--rebase', 'origin', branch]);
+            }
+            catch { /* el retry decide */ }
+        }
+    }
+}

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

@@ -109,14 +109,17 @@ describe('runInit', () => {
             expect(caveatCalls).toHaveLength(0);
         });
     });
-    it('returns exit 1 on a bare HOME and never prompts with --yes (cache stubbed)', async () => {
+    it('returns exit 0 on a bare HOME and never prompts with --yes (cache stubbed)', async () => {
         const { runInit } = require('../../src/commands/init');
         const code = await runInit({
             cwd: tmpHome,
             yes: true,
             actions: { syncCache: async () => { }, installHook: () => ({ status: 'installed' }) },
         });
-        expect(code).toBe(1); // cache/hook/devCore siguen ausentes (syncCache no-op) → degradado
+        // Degradado (cache/hook/devCore siguen ausentes con syncCache no-op) pero NADA
+        // fallo, y el exit code de `init` responde por init, no por la salud del
+        // harness — ver D-008. Esto salia 1 y rompia `awm init --yes && …` bajo `set -e`.
+        expect(code).toBe(0);
     });
     it('--json emits a parseable InitOutcome', async () => {
         const { runInit } = require('../../src/commands/init');
@@ -131,7 +134,10 @@ describe('runInit', () => {
         expect(Array.isArray(parsed.steps)).toBe(true);
         expect(parsed.after.overall).toBe('degraded');
         expect(parsed.result).toBe('degraded'); // success envelope is self-describing too
-        expect(code).toBe(1);
+        // El exit code deja de duplicar `result`: la distincion ok/degradado sigue
+        // disponible para quien la quiera, en el campo, no en `$?` (D-008).
+        expect(parsed.failed).toBe(0);
+        expect(code).toBe(0);
     });
     const prefsFile = () => path_1.default.join(process.env.AWM_HOME, 'preferences.json');
     const readPreferences = () => JSON.parse(fs_1.default.readFileSync(prefsFile(), 'utf-8'));
@@ -239,6 +245,40 @@ describe('runInit', () => {
             .toEqual(['claude-code', 'codex', 'opencode']);
     });
     // -----------------------------------------------------------------------
+    // D-008 — el exit code de `init` responde por init, no por la salud del harness
+    // -----------------------------------------------------------------------
+    //
+    // El contrato entero en un solo lugar, porque el sitio que lo rompia era el
+    // ausente: ningun test preguntaba "¿un script puede encadenar `awm init &&`?".
+    // Habia dos assertions de `toBe(1)`, y las dos *documentaban* el bug en vez de
+    // detenerlo. Tres lectores independientes lo reportaron como fallo antes de que
+    // lo fuera, y la doc habia crecido un recuadro pidiendo ignorar el exit code.
+    it('a degraded-but-successful run exits 0, so `awm init && next` survives set -e', async () => {
+        const { runInit } = require('../../src/commands/init');
+        const code = await runInit({
+            cwd: tmpHome,
+            yes: true,
+            json: true,
+            actions: { syncCache: async () => { }, installHook: () => ({ status: 'installed' }) },
+        });
+        const parsed = JSON.parse(writeSpy.mock.calls.map((c) => c[0]).join(''));
+        // Las tres afirmaciones juntas son el punto: degradado, sin nada fallado, exit 0.
+        // Cualquiera de las tres sola se puede satisfacer sin el fix.
+        expect(parsed.result).toBe('degraded');
+        expect(parsed.failed).toBe(0);
+        expect(code).toBe(0);
+    });
+    it('still refuses with exit 2 when a gate rejects — 0 does not mean "always succeed"', async () => {
+        const { runInit } = require('../../src/commands/init');
+        const code = await runInit({
+            cwd: tmpHome,
+            agent: 'codex',
+            yes: true,
+            assertProviderSupported: () => { throw new Error('requires Codex >= 0.145.0'); },
+        });
+        expect(code).toBe(2);
+    });
+    // -----------------------------------------------------------------------
     // Step 1 — gate ordering, backup/rollback atomicity, Codex/Claude coexistence
     // -----------------------------------------------------------------------
     it('gates Codex before preferences or provider writes', async () => {

package/dist/tests/core/diagnostics/checks.test.js

@@ -16,7 +16,7 @@ function healthyProject() {
         root: '/repo/belanz',
         profile: { present: true, extensions: ['frontend'] },
         activeBundles: { expected: ['frontend-craft'], linked: ['frontend-craft'], broken: [] },
-        orphanLinks: { repairable: [], dead: [] },
+        orphanLinks: { repairable: [], dead: [], usurped: [] },
         sensors: { present: true },
         constitution: { present: true },
         context: { present: true, file: 'CLAUDE.md' },

package/dist/tests/core/init/steps.test.js

@@ -31,7 +31,7 @@ function project(over = {}) {
         root: '/repo',
         profile: { present: true, extensions: [] },
         activeBundles: { expected: [], linked: [], broken: [] },
-        orphanLinks: { repairable: [], dead: [] },
+        orphanLinks: { repairable: [], dead: [], usurped: [] },
         sensors: { present: true },
         constitution: { present: true },
         context: { present: true, file: 'CLAUDE.md' },

package/dist/tests/core/usurped-skill-links.test.js

@@ -124,3 +124,73 @@ describe('awm doctor degrades on a usurped global skill', () => {
         expect(checkFor([]).state).not.toBe('broken');
     });
 });
+// ---------------------------------------------------------------------------
+// Los hermanos: `agents.native` y `workflows.global` escanean dirs igual de
+// gestionados, y no recibieron el tratamiento cuando se agrego la deteccion.
+// ---------------------------------------------------------------------------
+//
+// Encontrado validando la v5.0.0: una sonda apunto sin querer a
+// `~/.claude/agents/development-process.md`, lo reemplazo por un directorio ajeno, y
+// `doctor` siguio diciendo `healthy`. `agents.native` con renderer `link` devolvia
+// `healthy` fijo con solo mirar que el dir no estuviera vacio — ni siquiera detectaba
+// un symlink colgante. Tres hermanos, uno tratado.
+describe('agents.native gets the same treatment as skills.global', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = (0, tmp_1.mkCanonicalTmpDir)('awm-usurp-agents-');
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        // registries.ts cachea AWM_HOME al require: hay que re-requerir por test.
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        if (originalHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = originalHome;
+        if (originalAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalAwmHome;
+    });
+    /** Deja en `~/.claude/agents` una entrada real (no symlink) y la declara nuestra. */
+    function seedUsurpedAgent(name) {
+        const dir = path_1.default.join(tmpHome, '.claude', 'agents');
+        fs_1.default.mkdirSync(dir, { recursive: true });
+        fs_1.default.mkdirSync(path_1.default.join(dir, name), { recursive: true });
+        const stateDir = path_1.default.join(tmpHome, '.awm', 'state');
+        fs_1.default.mkdirSync(stateDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(stateDir, 'artifacts.json'), JSON.stringify([{
+                name, type: 'agent', scope: 'global',
+                targetPath: path_1.default.join(dir, name),
+                sourcePath: '/registry/agents/' + name,
+                renderer: 'link', owners: ['claude-code'],
+            }], null, 2));
+    }
+    function agentsCheck() {
+        const { gatherProviderChecks } = require('../../src/core/diagnostics/provider-checks');
+        const scan = jest.fn(() => ({ valid: [], repairable: [], dead: [], usurped: [] }));
+        const facts = gatherProviderChecks(['claude-code'], scan);
+        return facts[0].checks.find((c) => c.id === 'agents.native');
+    }
+    it('reports broken and names the replaced agent', () => {
+        seedUsurpedAgent('development-process');
+        const check = agentsCheck();
+        expect(check.state).toBe('broken');
+        expect(check.detail).toContain('development-process');
+        expect(check.remediationCode).toBe('reinstall-usurped-skills');
+    });
+    it('stays healthy when the directory holds only entries AWM never claimed', () => {
+        // Lo que el usuario puso a mano sigue sin ser problema nuestro — el mismo
+        // limite que en skills.global. Sin ledger no hay usurpacion posible.
+        const dir = path_1.default.join(tmpHome, '.claude', 'agents');
+        fs_1.default.mkdirSync(dir, { recursive: true });
+        fs_1.default.mkdirSync(path_1.default.join(dir, 'my-own-agent'), { recursive: true });
+        expect(agentsCheck().state).toBe('healthy');
+    });
+});

package/dist/tests/release/orchestrator.test.js

@@ -186,3 +186,57 @@ describe('parseArgs', () => {
         expect(() => (0, index_1.parseArgs)(['--branch'])).toThrow(/--branch requiere/i);
     });
 });
+// ---------------------------------------------------------------------------
+// D-009 — despues del publish, un fallo de git no puede quedar en silencio
+// ---------------------------------------------------------------------------
+//
+// La 4.0.1 existe en npm y no existe en git: sin tag, sin CHANGELOG. Dos corridas
+// de release concurrentes (mergear un PR mientras el release del anterior estaba en
+// vuelo) dejaron a la segunda adelantando `main`, y la primera murio en
+// `git push origin main` con non-fast-forward DESPUES de publicar.
+//
+// El publish es irreversible; el push no. Ningun test cubria el orden entre ambos ni
+// que pasa si el push falla — el happy path afirmaba que las dos lineas existen, no
+// en que orden ni con que recuperacion.
+describe('release — el push despues de un publish exitoso', () => {
+    it('empuja el TAG antes que la rama: en el peor caso queda la identidad de lo publicado', () => {
+        const { io, calls } = makeIO({ commits: `feat: x${core_1.US}${core_1.RS}` });
+        (0, orchestrator_1.release)(opts(), io);
+        const tagPush = calls.findIndex((c) => c === 'git push origin v2.2.0');
+        const branchPush = calls.findIndex((c) => c === 'git push origin main');
+        expect(tagPush).toBeGreaterThanOrEqual(0);
+        expect(branchPush).toBeGreaterThanOrEqual(0);
+        expect(tagPush).toBeLessThan(branchPush);
+    });
+    it('reintenta con rebase cuando la rama se movio bajo los pies', () => {
+        let branchPushes = 0;
+        const { io, calls } = makeIO({ commits: `feat: x${core_1.US}${core_1.RS}` });
+        const inner = io.run;
+        io.run = (cmd, args) => {
+            if (cmd === 'git' && args[0] === 'push' && args[2] === 'main') {
+                branchPushes++;
+                // Exactamente el fallo real: la primera vez rechazado, despues del rebase pasa.
+                if (branchPushes === 1)
+                    throw new Error('! [rejected] main -> main (non-fast-forward)');
+            }
+            return inner(cmd, args);
+        };
+        expect(() => (0, orchestrator_1.release)(opts(), io)).not.toThrow();
+        expect(branchPushes).toBe(2);
+        expect(calls.join('\n')).toMatch(/git pull --rebase origin main/);
+    });
+    it('si el push no se recupera, el error NOMBRA que npm ya tiene la version', () => {
+        const { io } = makeIO({ commits: `feat: x${core_1.US}${core_1.RS}` });
+        const inner = io.run;
+        io.run = (cmd, args) => {
+            if (cmd === 'git' && args[0] === 'push' && args[2] === 'main') {
+                throw new Error('! [rejected] main -> main (non-fast-forward)');
+            }
+            return inner(cmd, args);
+        };
+        // Un "failed to push some refs" pelado no le dice a nadie que npm quedo adelantado
+        // ni que NO hay que re-publicar. Eso es lo que se asserta, no que tire.
+        expect(() => (0, orchestrator_1.release)(opts(), io)).toThrow(/YA SE PUBLICO en npm/);
+        expect(() => (0, orchestrator_1.release)(opts(), io)).toThrow(/NO re-publicar/);
+    });
+});

package/dist/tests/structural/managed-dir-scans-consult-the-ledger.test.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// `classifySkillLinks` sin el ledger no puede ver una usurpacion. Ese tercer
+// argumento es opcional a proposito — hay llamadores legitimos que no tienen ledger a
+// mano — y por eso mismo es facil de omitir sin que nada se queje.
+//
+// Ya paso: cuando se agrego la deteccion (D-007) se cableo en el seam `scanSkills`,
+// que alimenta `skills.global`, y los otros dos checks del mismo archivo que llaman al
+// clasificador directo — `workflows.global` y `agents.native` — quedaron afuera. Tres
+// hermanos, uno tratado. Es el patron que mas se repitio en este repo, y la unica
+// contramedida que funciona es que el compilador o un test lo cuenten por vos.
+//
+// Este guard es deliberadamente estrecho: solo mira `core/diagnostics/`, que es donde
+// vive el reporte de salud. Un llamador de otro modulo puede omitir el ledger sin que
+// esto se queje; lo que no puede pasar es que un CHECK diga `healthy` sobre un
+// directorio gestionado que nunca comparo contra el ledger.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const DIAGNOSTICS = path_1.default.join(__dirname, '..', '..', 'src', 'core', 'diagnostics');
+function sourceFiles(dir) {
+    return fs_1.default.readdirSync(dir)
+        .filter((f) => f.endsWith('.ts'))
+        .map((f) => path_1.default.join(dir, f));
+}
+/** Cada `classifySkillLinks(...)` del archivo, con su lista de argumentos en crudo.
+ *  Contar comas de nivel superior alcanza: los argumentos reales son identificadores y
+ *  llamadas simples, sin literales de objeto ni genericos con coma. */
+function classifyCalls(source) {
+    const out = [];
+    const needle = 'classifySkillLinks(';
+    let from = 0;
+    for (;;) {
+        const at = source.indexOf(needle, from);
+        if (at === -1)
+            return out;
+        from = at + needle.length;
+        let depth = 1;
+        let i = from;
+        while (i < source.length && depth > 0) {
+            if (source[i] === '(')
+                depth++;
+            else if (source[i] === ')')
+                depth--;
+            i++;
+        }
+        out.push({
+            args: source.slice(from, i - 1),
+            line: source.slice(0, at).split('\n').length,
+        });
+    }
+}
+function topLevelArgCount(args) {
+    if (args.trim() === '')
+        return 0;
+    let depth = 0;
+    let count = 1;
+    for (const ch of args) {
+        if (ch === '(' || ch === '[' || ch === '{')
+            depth++;
+        else if (ch === ')' || ch === ']' || ch === '}')
+            depth--;
+        else if (ch === ',' && depth === 0)
+            count++;
+    }
+    return count;
+}
+describe('every diagnostics scan of a managed directory consults the ownership ledger', () => {
+    it('no classifySkillLinks call under core/diagnostics/ omits the managed-targets argument', () => {
+        const offenders = [];
+        for (const file of sourceFiles(DIAGNOSTICS)) {
+            const source = fs_1.default.readFileSync(file, 'utf8');
+            for (const call of classifyCalls(source)) {
+                // La definicion importada no es una llamada; el parser solo ve `nombre(`.
+                if (topLevelArgCount(call.args) < 3) {
+                    offenders.push(`${path_1.default.basename(file)}:${call.line} — ${call.args.trim()}`);
+                }
+            }
+        }
+        expect(offenders).toEqual([]);
+    });
+    it('the guard can actually see a violation (it is not vacuously green)', () => {
+        // Si el parser se rompiera, el test de arriba pasaria para siempre sin mirar nada.
+        expect(topLevelArgCount('dir, contentRoots()')).toBe(2);
+        expect(topLevelArgCount('dir, contentRoots(), managedLinkTargets(state())')).toBe(3);
+    });
+    it('there is at least one call to guard, so the sweep is not scanning an empty set', () => {
+        const total = sourceFiles(DIAGNOSTICS)
+            .reduce((n, f) => n + classifyCalls(fs_1.default.readFileSync(f, 'utf8')).length, 0);
+        expect(total).toBeGreaterThan(0);
+    });
+});

package/package.json

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