agentic-workflow-manager 5.0.0 → 5.0.2

package/dist/src/commands/hooks/codex.js

@@ -129,18 +129,24 @@ function computeCodexHookStatus(agent) {
     const settingsEntry = checkCodexSettingsEntry(config.settingsPath, config.scriptsDir, config.matcher, config.eventName);
     const allOk = sessionStartScript.ok && settingsEntry.ok;
     const settingsOnlyMissing = !settingsEntry.ok && sessionStartScript.ok;
-    let overall;
-    if (allOk)
-        overall = 'HEALTHY';
-    else if (settingsOnlyMissing)
-        overall = 'NOT_INSTALLED';
-    else
-        overall = 'DEGRADED';
     // Trust only makes sense once the AWM entry is actually present in
     // hooks.json — otherwise there's nothing installed to trust.
     const trust = settingsEntry.ok
         ? computeCodexTrust(sessionStartScript, scriptPath, heartbeatPath)
         : undefined;
+    // `overall` IGNORABA `trust` por completo, asi que `awm hooks status` imprimia
+    // `Status: HEALTHY` dos lineas debajo de `Trust: … pending-trust`. Una corrida real
+    // del playbook leyo esa salida y concluyo que el hook andaba. `doctor --json` decia
+    // la verdad; la vista humana, no — y es la que mira una persona. Ver D-010.
+    let overall;
+    if (!allOk)
+        overall = settingsOnlyMissing ? 'NOT_INSTALLED' : 'DEGRADED';
+    else if (trust === 'stale')
+        overall = 'DEGRADED';
+    else if (trust === 'pending-trust')
+        overall = 'PENDING_TRUST';
+    else
+        overall = 'HEALTHY';
     return {
         overall,
         trust,

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

@@ -13,6 +13,16 @@ const status_1 = require("./status");
 const providers_1 = require("../../providers");
 const registries_1 = require("../../core/registries");
 const HOOK_TARGETS = providers_1.AGENT_TARGETS.filter((a) => (0, providers_1.getHookConfig)(a));
+/**
+ * `hooks` nacio con `-t, --target` y el resto del CLI (`add`, `remove`, `sync`,
+ * `update`, `doctor`) usa `-a, --agent`. La asimetria se cobro una corrida real del
+ * playbook: `awm hooks status --agent codex` fallaba con `unknown option`. Se acepta
+ * `--agent` como alias en vez de renombrar, para no romper a quien ya scriptea
+ * `--target`. Ver D-010.
+ */
+function resolveHookTarget(options) {
+    return (options.agent ?? options.target ?? 'claude-code');
+}
 function targetOptionDescription() {
     return `Target harness (${HOOK_TARGETS.join('|')})`;
 }
@@ -21,9 +31,10 @@ function registerHooksCommand(program) {
     hooks.command('install')
         .description('Install the AWM bootstrap hook into the target harness')
         .option('-t, --target <target>', targetOptionDescription(), 'claude-code')
+        .option('-a, --agent <agent>', 'Alias de --target, por simetria con el resto del CLI')
         .option('-y, --yes', 'Skip interactive confirmations', false)
         .action(async (options) => {
-        const agent = (options.target ?? 'claude-code');
+        const agent = resolveHookTarget(options);
         const prefs = (0, config_1.getPreferences)();
         const hooksRoot = (0, registries_1.capabilityRoot)('hooks');
         if (!hooksRoot) {
@@ -69,9 +80,10 @@ function registerHooksCommand(program) {
     hooks.command('uninstall')
         .description('Remove the AWM bootstrap hook')
         .option('-t, --target <target>', targetOptionDescription(), 'claude-code')
+        .option('-a, --agent <agent>', 'Alias de --target, por simetria con el resto del CLI')
         .option('-y, --yes', 'Skip interactive confirmations', false)
         .action(async (options) => {
-        const agent = (options.target ?? 'claude-code');
+        const agent = resolveHookTarget(options);
         if (!options.yes && process.stdin.isTTY) {
             const ok = await (0, prompts_1.confirm)({ message: 'Remove AWM bootstrap hook from settings.json?' });
             if ((0, prompts_1.isCancel)(ok) || ok !== true) {
@@ -98,8 +110,9 @@ function registerHooksCommand(program) {
     hooks.command('status')
         .description('Check the bootstrap hook installation status')
         .option('-t, --target <target>', targetOptionDescription(), 'claude-code')
+        .option('-a, --agent <agent>', 'Alias de --target, por simetria con el resto del CLI')
         .action((options) => {
-        const agent = (options.target ?? 'claude-code');
+        const agent = resolveHookTarget(options);
         try {
             const result = (0, status_1.computeHookStatus)(agent);
             const symbol = (ok) => ok ? picocolors_1.default.green('✓') : picocolors_1.default.red('✗');
@@ -118,10 +131,17 @@ function registerHooksCommand(program) {
             }
             console.log('');
             const overall = result.overall === 'HEALTHY' ? picocolors_1.default.green(result.overall) :
-                result.overall === 'NOT_INSTALLED' ? picocolors_1.default.yellow(result.overall) :
-                    picocolors_1.default.red(result.overall);
+                result.overall === 'NOT_INSTALLED' || result.overall === 'PENDING_TRUST'
+                    ? picocolors_1.default.yellow(result.overall)
+                    : picocolors_1.default.red(result.overall);
             console.log(`  Status: ${overall}`);
-            if (result.overall !== 'HEALTHY') {
+            if (result.overall === 'PENDING_TRUST') {
+                console.log(picocolors_1.default.dim('  El hook esta instalado y bien formado, pero nunca se lo vio correr.'));
+                console.log(picocolors_1.default.dim('  Abri una sesion del agente; si sigue igual, no se esta disparando.'));
+            }
+            // PENDING_TRUST no sale 1: no hay nada roto que arreglar, y salir 1 en
+            // toda instalacion recien hecha convertiria el comando en ruido.
+            if (result.overall !== 'HEALTHY' && result.overall !== 'PENDING_TRUST') {
                 process.exit(1);
             }
         }

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/hooks/codex.test.js

@@ -167,6 +167,27 @@ describe('installHook / computeHookStatus / uninstallHook — Codex adapter', ()
         const { computeHookStatus } = require('../../../src/commands/hooks/status');
         expect(computeHookStatus('codex').trust).toBe(expected); // verifies R18
     });
+    // `overall` NUNCA se assertaba — solo `.trust` — y por eso el bug vivio: se calculaba
+    // ignorando trust por completo, asi que `awm hooks status` imprimia `Status: HEALTHY`
+    // dos lineas debajo de `Trust: … pending-trust`. Una corrida real del playbook leyo esa
+    // salida y concluyo que el hook andaba. Ver D-010.
+    it.each([
+        [false, 'PENDING_TRUST'],
+        [true, 'HEALTHY'],
+    ])('overall refleja el trust, no solo la presencia de archivos (heartbeat=%s)', (heartbeat, expected) => {
+        installCodexFixture({ heartbeat: heartbeat });
+        const { computeHookStatus } = require('../../../src/commands/hooks/status');
+        expect(computeHookStatus('codex').overall).toBe(expected);
+    });
+    it('un heartbeat obsoleto degrada: el script cambio desde la ultima corrida confirmada', () => {
+        installCodexFixture({ heartbeat: true });
+        fs_1.default.writeFileSync(path_1.default.join(codexScriptsDir, 'session-start'), '#!/usr/bin/env bash\necho "changed"', { mode: 0o755 });
+        const { computeHookStatus } = require('../../../src/commands/hooks/status');
+        const status = computeHookStatus('codex');
+        expect(status.trust).toBe('stale');
+        // Esto era `HEALTHY`: la rotura mas clara de las tres, reportada en verde.
+        expect(status.overall).toBe('DEGRADED');
+    });
     it('reports stale trust when the heartbeat hash no longer matches the installed script', () => {
         installCodexFixture({ heartbeat: true });
         fs_1.default.writeFileSync(path_1.default.join(codexScriptsDir, 'session-start'), '#!/usr/bin/env bash\necho "changed"', { mode: 0o755 });

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": "5.0.0",
+  "version": "5.0.2",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"