agentic-workflow-manager 8.2.0 → 8.3.0

package/dist/tests/commands/hooks/install.test.js

@@ -51,7 +51,10 @@ describe('installHook (happy path + merge)', () => {
         const scriptsDir = path_1.default.join(tmpHome, '.awm/hooks');
         expect(fs_1.default.existsSync(path_1.default.join(scriptsDir, 'session-start'))).toBe(true);
         expect(fs_1.default.existsSync(path_1.default.join(scriptsDir, 'run-hook.cmd'))).toBe(true);
-        expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'using-awm.md')).isSymbolicLink()).toBe(true);
+        // Task 6: using-awm.md is now a materialized file (buildContext's output), not a
+        // symlink to the raw SKILL.md — so declared orchestrators actually reach Claude Code.
+        expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'using-awm.md')).isSymbolicLink()).toBe(false);
+        expect(fs_1.default.readFileSync(path_1.default.join(scriptsDir, 'using-awm.md'), 'utf-8')).toContain('MUST invoke skills.');
         const settings = JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmpHome, '.claude/settings.json'), 'utf-8'));
         expect(settings.hooks.SessionStart).toHaveLength(1);
         expect(settings.hooks.SessionStart[0].matcher).toBe('startup|clear|compact');
@@ -135,11 +138,126 @@ describe('installHook (happy path + merge)', () => {
         // Did not create settings.json
         expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.claude/settings.json'))).toBe(false);
     });
-    it('symlinks using-awm.md even when installMethod is copy (UX choice)', () => {
+    // Task 6: using-awm.md is materialized (buildContext's composed output), never a
+    // symlink, regardless of installMethod — superseding the pre-Task-6 "UX choice" of
+    // always symlinking this one file even under installMethod 'copy'.
+    it('materializes using-awm.md (never a symlink) even when installMethod is copy', () => {
         const { installHook } = require('../../../src/commands/hooks/install');
         installHook({ agent: 'claude-code', registryRoot: tmpRegistry, installMethod: 'copy' });
         const skillPath = path_1.default.join(tmpHome, '.awm/hooks/using-awm.md');
-        expect(fs_1.default.lstatSync(skillPath).isSymbolicLink()).toBe(true);
+        expect(fs_1.default.lstatSync(skillPath).isSymbolicLink()).toBe(false);
+        expect(fs_1.default.readFileSync(skillPath, 'utf-8')).toContain('MUST invoke skills.');
+    });
+    // Non-regression net (Task 5, Step 1): fixes the hook's observable
+    // contract before Task 6 replaces the symlink with a materialized
+    // file write in claude.ts. Verifies R6.1.
+    it('el hook queda apuntando a un archivo legible con el contenido de using-awm', () => {
+        const { installHook } = require('../../../src/commands/hooks/install');
+        installHook({ agent: 'claude-code', registryRoot: tmpRegistry, installMethod: 'symlink' });
+        const skillDest = path_1.default.join(tmpHome, '.awm/hooks/using-awm.md');
+        expect(fs_1.default.existsSync(skillDest)).toBe(true);
+        const content = fs_1.default.readFileSync(skillDest, 'utf-8');
+        expect(content).toContain('MUST invoke skills.');
+    });
+    // Task 6, Step 1: closes the bypass — everything buildContext composes (declared
+    // orchestrators, Tasks 1-4) must actually reach Claude Code's using-awm.md, not just
+    // the raw SKILL.md. Verifies R1.1.
+    //
+    // Investigation note: the plan's literal sample writes `awm-registry.json` straight
+    // into `tmpRegistry` and expects `collectAndWarn()` to pick it up via `listRegistries()`
+    // — but `listRegistries()` reads registries.json under AWM_HOME, and `tmpRegistry` here
+    // is a bare mkdtemp dir, never registered there via `awm registry add`. Writing the
+    // manifest into an unregistered dir would leave `declared` empty and this test green
+    // for the wrong reason (or red for the wrong reason, pre-fix). Instead this test
+    // registers a REAL listed registry via `writeRegistriesConfig` + `registryContentRoot`
+    // (the same pattern `tests/core/context/orchestrator.test.ts` already uses for this
+    // exact situation) and installs FROM that registry, so `options.registryRoot` and the
+    // one entry `listRegistries()` returns are the same directory — exercising the real
+    // collection path end to end.
+    it('el hook recibe los orquestadores declarados, no el SKILL.md crudo', () => {
+        const { installHook } = require('../../../src/commands/hooks/install');
+        const { writeRegistriesConfig, registryContentRoot } = require('../../../src/core/registries');
+        writeRegistriesConfig([{ name: 'declaring-test', remote: 'unused' }]);
+        const registryRoot = registryContentRoot('declaring-test');
+        const regHooks = path_1.default.join(registryRoot, 'hooks');
+        const regSkill = path_1.default.join(registryRoot, 'skills/using-awm');
+        fs_1.default.mkdirSync(regHooks, { recursive: true });
+        fs_1.default.mkdirSync(regSkill, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(regHooks, 'session-start'), '#!/usr/bin/env bash\necho "{}"', { mode: 0o755 });
+        fs_1.default.writeFileSync(path_1.default.join(regHooks, 'run-hook.cmd'), '#!/usr/bin/env bash\nexec bash "$1"', { mode: 0o755 });
+        fs_1.default.writeFileSync(path_1.default.join(regSkill, 'SKILL.md'), '---\nname: using-awm\n---\nMUST invoke skills.');
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'awm-registry.json'), JSON.stringify({ orchestrator: { name: 'mi-proceso', appliesWhen: 'al arrancar', terminatesTo: 'development-process' } }));
+        installHook({ agent: 'claude-code', registryRoot, installMethod: 'symlink' });
+        const content = fs_1.default.readFileSync(path_1.default.join(tmpHome, '.awm', 'hooks', 'using-awm.md'), 'utf-8');
+        expect(content).toContain('mi-proceso'); // la composicion LLEGA a Claude Code
+        expect(content).toContain('MUST invoke skills.'); // y el skill sigue entero
+    });
+    // Finding 2 (code quality review, Task 6): regression-locks what the reviewer verified
+    // by hand — a pre-Task-6 install left using-awm.md as a REAL symlink to the registry's
+    // raw SKILL.md. writeMaterializedSkill() must fs.unlinkSync() that symlink (removing
+    // only the directory entry) before writing the materialized file, never dereference it
+    // and clobber the registry's own SKILL.md.
+    it('migrates a pre-Task-6 symlinked using-awm.md to a materialized file without touching the registry SKILL.md', () => {
+        const scriptsDir = path_1.default.join(tmpHome, '.awm/hooks');
+        fs_1.default.mkdirSync(scriptsDir, { recursive: true });
+        const skillDest = path_1.default.join(scriptsDir, 'using-awm.md');
+        const registrySkillPath = path_1.default.join(tmpRegistry, 'skills/using-awm/SKILL.md');
+        const originalSkillContent = fs_1.default.readFileSync(registrySkillPath, 'utf-8');
+        fs_1.default.symlinkSync(registrySkillPath, skillDest, 'file');
+        expect(fs_1.default.lstatSync(skillDest).isSymbolicLink()).toBe(true);
+        const { installHook } = require('../../../src/commands/hooks/install');
+        installHook({ agent: 'claude-code', registryRoot: tmpRegistry, installMethod: 'symlink' });
+        expect(fs_1.default.lstatSync(skillDest).isSymbolicLink()).toBe(false);
+        expect(fs_1.default.readFileSync(skillDest, 'utf-8')).toContain('MUST invoke skills.');
+        // The registry's own SKILL.md must be untouched — proves unlinkSync removed only
+        // the directory entry and never dereferenced/deleted the symlink's target.
+        expect(fs_1.default.existsSync(registrySkillPath)).toBe(true);
+        expect(fs_1.default.readFileSync(registrySkillPath, 'utf-8')).toBe(originalSkillContent);
+    });
+    // Finding 2 (post-implementation-qa, Release 2): R5.1's fail-safe guarantee (a broken
+    // declaration in one registry never blocks context construction for the others) was
+    // already regression-tested for the generic InjectionOrchestrator/opencode path
+    // (tests/core/context/orchestrator.test.ts, 'installContext still succeeds when a
+    // DIFFERENT installed registry has a broken declaration') but not through
+    // installClaudeHook/resyncClaudeHookFiles — Task 6's own highest-risk change. Mirrors
+    // that test's two-registries setup (one valid orchestrator declaration, one broken
+    // JSON) via writeRegistriesConfig/registryContentRoot, same as 'el hook recibe los
+    // orquestadores declarados...' above, but installs from the VALID registry and asserts
+    // the broken sibling never surfaces as a thrown error.
+    it('installHook succeeds and materializes the valid registry\'s orchestrator when a sibling registry has a broken declaration', () => {
+        const { installHook } = require('../../../src/commands/hooks/install');
+        const { writeRegistriesConfig, registryContentRoot } = require('../../../src/core/registries');
+        writeRegistriesConfig([
+            { name: 'broken-sibling', remote: 'unused' },
+            { name: 'valid-declaring', remote: 'unused' },
+        ]);
+        // Broken sibling: unparsable awm-registry.json. No hooks/skill content needed —
+        // it is never the registryRoot passed to installHook, only a sibling
+        // collectAndWarn() walks while gathering declared orchestrators.
+        const brokenRoot = registryContentRoot('broken-sibling');
+        fs_1.default.mkdirSync(brokenRoot, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(brokenRoot, 'awm-registry.json'), '{ not json');
+        // Valid registry: the one actually installed from.
+        const registryRoot = registryContentRoot('valid-declaring');
+        const regHooks = path_1.default.join(registryRoot, 'hooks');
+        const regSkill = path_1.default.join(registryRoot, 'skills/using-awm');
+        fs_1.default.mkdirSync(regHooks, { recursive: true });
+        fs_1.default.mkdirSync(regSkill, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(regHooks, 'session-start'), '#!/usr/bin/env bash\necho "{}"', { mode: 0o755 });
+        fs_1.default.writeFileSync(path_1.default.join(regHooks, 'run-hook.cmd'), '#!/usr/bin/env bash\nexec bash "$1"', { mode: 0o755 });
+        fs_1.default.writeFileSync(path_1.default.join(regSkill, 'SKILL.md'), '---\nname: using-awm\n---\nMUST invoke skills.');
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'awm-registry.json'), JSON.stringify({ orchestrator: { name: 'proceso-valido', appliesWhen: 'al arrancar', terminatesTo: 'development-process' } }));
+        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        let result;
+        expect(() => {
+            result = installHook({ agent: 'claude-code', registryRoot, installMethod: 'symlink' });
+        }).not.toThrow();
+        expect(result.status).toBe('installed');
+        const content = fs_1.default.readFileSync(path_1.default.join(tmpHome, '.awm', 'hooks', 'using-awm.md'), 'utf-8');
+        expect(content).toContain('proceso-valido'); // valid registry's declared orchestrator reached Claude Code
+        expect(content).toContain('MUST invoke skills.'); // and the skill body is intact
+        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('warning:')); // broken sibling warned, not thrown
+        warnSpy.mockRestore();
     });
     it('throws for unsupported agent target', () => {
         const { installHook } = require('../../../src/commands/hooks/install');

package/dist/tests/commands/hooks/resync.test.js

@@ -70,7 +70,10 @@ describe('resyncInstalledHooks', () => {
         expect(synced).toContain('NEW VERSION');
         expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'session-start')).isSymbolicLink()).toBe(false);
         expect(() => fs_1.default.accessSync(path_1.default.join(scriptsDir, 'session-start'), fs_1.default.constants.X_OK)).not.toThrow();
-        expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'using-awm.md')).isSymbolicLink()).toBe(true);
+        // Task 6: using-awm.md is materialized (buildContext's output), not a symlink to the
+        // raw SKILL.md — resync must not regress the install path back to a raw symlink.
+        expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'using-awm.md')).isSymbolicLink()).toBe(false);
+        expect(fs_1.default.readFileSync(path_1.default.join(scriptsDir, 'using-awm.md'), 'utf-8')).toContain('MUST invoke skills.');
     });
     it('does NOT touch anything when the hook was never installed (no settings entry)', () => {
         writeRegistry('#!/usr/bin/env bash\necho "NEW VERSION"');
@@ -82,6 +85,39 @@ describe('resyncInstalledHooks', () => {
         ]);
         expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/hooks/session-start'))).toBe(false);
     });
+    // Task 6, Step 5 regression guard: the exact staleness the plan calls "el hallazgo mas
+    // importante" — if resyncClaudeHookFiles ever regressed back to symlinking the raw
+    // SKILL.md (instead of writing buildContext's materialized output, same as
+    // installClaudeHook), `awm update` would silently strip declared orchestrators back
+    // out of Claude Code's context on the very next resync after a correct install.
+    it('re-materializes using-awm.md with declared orchestrators on resync, not a raw-SKILL.md symlink', () => {
+        const { writeRegistriesConfig, registryContentRoot } = require('../../../src/core/registries');
+        writeRegistriesConfig([{ name: 'declaring-resync-test', remote: 'unused' }]);
+        const registryRoot = registryContentRoot('declaring-resync-test');
+        const regHooks = path_1.default.join(registryRoot, 'hooks');
+        const regSkill = path_1.default.join(registryRoot, 'skills/using-awm');
+        fs_1.default.mkdirSync(regHooks, { recursive: true });
+        fs_1.default.mkdirSync(regSkill, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(regHooks, 'session-start'), '#!/usr/bin/env bash\necho "{}"', { mode: 0o755 });
+        fs_1.default.writeFileSync(path_1.default.join(regHooks, 'run-hook.cmd'), '#!/usr/bin/env bash\nexec bash "$1"', { mode: 0o755 });
+        fs_1.default.writeFileSync(path_1.default.join(regSkill, 'SKILL.md'), '---\nname: using-awm\n---\nMUST invoke skills.');
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'awm-registry.json'), JSON.stringify({ orchestrator: { name: 'mi-proceso', appliesWhen: 'al arrancar', terminatesTo: 'development-process' } }));
+        const { installHook } = require('../../../src/commands/hooks/install');
+        installHook({ agent: 'claude-code', registryRoot, installMethod: 'symlink' });
+        const scriptsDir = path_1.default.join(tmpHome, '.awm/hooks');
+        const skillDest = path_1.default.join(scriptsDir, 'using-awm.md');
+        expect(fs_1.default.readFileSync(skillDest, 'utf-8')).toContain('mi-proceso');
+        const { resyncInstalledHooks } = require('../../../src/commands/hooks/resync');
+        const results = resyncInstalledHooks(registryRoot);
+        expect(results).toEqual([
+            { agent: 'claude-code', action: 'resynced' },
+            { agent: 'codex', action: 'not-installed' },
+        ]);
+        expect(fs_1.default.lstatSync(skillDest).isSymbolicLink()).toBe(false);
+        const content = fs_1.default.readFileSync(skillDest, 'utf-8');
+        expect(content).toContain('mi-proceso');
+        expect(content).toContain('MUST invoke skills.');
+    });
     it('preserves symlink install method', () => {
         writeRegistry('#!/usr/bin/env bash\necho "V2"');
         const scriptsDir = path_1.default.join(tmpHome, '.awm/hooks');
@@ -96,7 +132,9 @@ describe('resyncInstalledHooks', () => {
             { agent: 'codex', action: 'not-installed' },
         ]);
         expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'session-start')).isSymbolicLink()).toBe(true);
-        expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'using-awm.md')).isSymbolicLink()).toBe(true);
+        // Task 6: using-awm.md is materialized regardless of the scripts' install method —
+        // it was never governed by `method` in the first place, before or after this change.
+        expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'using-awm.md')).isSymbolicLink()).toBe(false);
     });
     it('skips with registry-missing when the registry has no hooks dir', () => {
         const scriptsDir = path_1.default.join(tmpHome, '.awm/hooks');

package/dist/tests/commands/registry/add.test.js

@@ -8,6 +8,20 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const child_process_1 = require("child_process");
+// @clack/prompts ships as ESM; mock it so Jest (CommonJS mode) can load
+// `commands/registry/index.ts` (same pattern as hooks/router.test.ts and
+// commands/update.test.ts). Only the CLI-wiring describe block below exercises
+// this — the rest of this file talks to `addRegistry` directly and never
+// touches @clack/prompts.
+jest.mock('@clack/prompts', () => ({
+    intro: jest.fn(),
+    outro: jest.fn(),
+    confirm: jest.fn(),
+    isCancel: jest.fn(() => false),
+    spinner: jest.fn(() => ({ start: jest.fn(), stop: jest.fn() })),
+    multiselect: jest.fn(),
+    select: jest.fn(),
+}));
 const GIT = (cwd, cmd) => (0, child_process_1.execSync)(`git -c user.email=t@t.t -c user.name=t ${cmd}`, { cwd, stdio: 'pipe' });
 function makeSourceRepo(base, opts) {
     const dir = path_1.default.join(base, `src-${opts.skill ?? 'empty'}`);
@@ -212,6 +226,33 @@ describe('addRegistry', () => {
         const { readRegistriesConfig } = require('../../../src/core/registries');
         expect(readRegistriesConfig().map((r) => r.name)).toEqual(['personal']);
     });
+    it('reporta una declaracion de orquestador invalida sin abortar la instalacion', async () => {
+        // Registry local con layout valido y declaracion rota
+        const src = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-src-'));
+        fs_1.default.mkdirSync(path_1.default.join(src, 'skills/mi-proceso'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(src, 'skills/mi-proceso/SKILL.md'), '---\nname: mi-proceso\n---\nx');
+        fs_1.default.writeFileSync(path_1.default.join(src, 'awm-registry.json'), JSON.stringify({ orchestrator: { name: 'roto' } }));
+        GIT(src, 'init -q');
+        GIT(src, 'add -A');
+        GIT(src, 'commit -qm init');
+        const { addRegistry } = require('../../../src/commands/registry/add');
+        const result = await addRegistry(src, 'roto-reg');
+        expect(result.ok).toBe(true); // la instalacion NO se aborta por esto
+        expect(result.ok && result.orchestratorDiagnostics).toBeDefined();
+        expect(result.ok && result.orchestratorDiagnostics.join('\n')).toMatch(/appliesWhen/);
+    });
+    it('un registry sin declaracion se instala sin diagnosticos', async () => {
+        const src = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-src-'));
+        fs_1.default.mkdirSync(path_1.default.join(src, 'skills/otro'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(src, 'skills/otro/SKILL.md'), '---\nname: otro\n---\nx');
+        GIT(src, 'init -q');
+        GIT(src, 'add -A');
+        GIT(src, 'commit -qm init');
+        const { addRegistry } = require('../../../src/commands/registry/add');
+        const result = await addRegistry(src, 'sin-decl');
+        expect(result.ok).toBe(true);
+        expect(result.ok && (result.orchestratorDiagnostics ?? [])).toEqual([]);
+    });
 });
 describe('registry add + bundle install (post-add flow)', () => {
     let tmpHome;
@@ -315,3 +356,66 @@ describe('registry add + bundle install (post-add flow)', () => {
         expect(fs_1.default.existsSync(skillLink)).toBe(false);
     });
 });
+describe('registry add — CLI wiring prints orchestrator diagnostics', () => {
+    let tmpHome;
+    let tmpWork;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-regadd-cli-home-'));
+        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-regadd-cli-work-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        fs_1.default.rmSync(tmpWork, { 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;
+    });
+    // Task 2 added a `console.warn` loop after a successful `awm registry add` that
+    // prints each orchestrator diagnostic (`result.orchestratorDiagnostics`) returned
+    // by `addRegistry`. `addRegistry` itself is already covered above ("reporta una
+    // declaracion de orquestador invalida sin abortar la instalacion"), but nothing
+    // proved the CLI command actually surfaces those diagnostics to the user — this
+    // drives the real commander-wired `registry add` action end-to-end (same pattern
+    // as tests/commands/sensors/index.test.ts's `program.parseAsync`).
+    it('prints each orchestrator diagnostic via console.warn after a successful add', async () => {
+        const src = fs_1.default.mkdtempSync(path_1.default.join(tmpWork, 'awm-cli-src-'));
+        fs_1.default.mkdirSync(path_1.default.join(src, 'skills/mi-proceso'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(src, 'skills/mi-proceso/SKILL.md'), '---\nname: mi-proceso\n---\nx');
+        // Broken orchestrator declaration: missing appliesWhen/terminatesTo.
+        fs_1.default.writeFileSync(path_1.default.join(src, 'awm-registry.json'), JSON.stringify({ orchestrator: { name: 'roto' } }));
+        GIT(src, 'init -q');
+        GIT(src, 'add -A');
+        GIT(src, 'commit -qm init');
+        const { Command } = require('commander');
+        const { registerRegistryCommand } = require('../../../src/commands/registry/index');
+        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => undefined);
+        const logSpy = jest.spyOn(console, 'log').mockImplementation(() => undefined);
+        try {
+            const program = new Command();
+            registerRegistryCommand(program);
+            await program.parseAsync(['node', 'awm', 'registry', 'add', src, '--name', 'cli-roto', '--no-install']);
+            expect(warnSpy).toHaveBeenCalled();
+            const warned = warnSpy.mock.calls.map((c) => String(c[0])).join('\n');
+            expect(warned).toMatch(/appliesWhen/);
+            expect(warned).toMatch(/terminatesTo/);
+            const { readRegistriesConfig } = require('../../../src/core/registries');
+            expect(readRegistriesConfig().map((r) => r.name)).toEqual(['cli-roto']);
+        }
+        finally {
+            warnSpy.mockRestore();
+            logSpy.mockRestore();
+        }
+    });
+});

package/dist/tests/commands/sensors/compatibility/probe.test.js

@@ -53,4 +53,31 @@ describe('runCompatibilityProbe', () => {
         await (0, probe_1.runCompatibilityProbe)({ kind: 'version' }, { ...evidence, toolExecutable, toolResolution: 'python-environment' }, fakeExecutor);
         expect(fakeExecutor).toHaveBeenCalledWith(expect.objectContaining({ executable: toolExecutable, resolution: 'python-environment', args: ['--version'] }), expect.any(Object));
     });
+    // A pack asset is never named the tool's own default (e.g. `eslint.config.awm.mjs`,
+    // not `eslint.config.js`) so the real command always pins it via `--config`. A probe
+    // that omits the same flag never finds a config to load and always reports
+    // not-matched — a false negative on every AWM-configured project. The probe must
+    // mirror the variant's own `--config` argument, not guess a bare invocation.
+    it('carries the variant\'s --config argument into an eslint-print-config probe', async () => {
+        await (0, probe_1.runCompatibilityProbe)({ kind: 'eslint-print-config' }, {
+            ...evidence, variantArgs: ['.', '--config', 'eslint.config.awm.mjs', '--cache', '--format', 'json'],
+        }, fakeExecutor);
+        expect(fakeExecutor).toHaveBeenCalledWith(expect.objectContaining({ args: ['--config', 'eslint.config.awm.mjs', '--print-config', 'eslint.config.js'] }), expect.any(Object));
+    });
+    it('carries the variant\'s --config argument into a typescript-show-config probe', async () => {
+        await (0, probe_1.runCompatibilityProbe)({ kind: 'typescript-show-config' }, {
+            ...evidence, variantArgs: ['--config', 'tsconfig.awm.json', '--noEmit'],
+        }, fakeExecutor);
+        expect(fakeExecutor).toHaveBeenCalledWith(expect.objectContaining({ args: ['--config', 'tsconfig.awm.json', '--showConfig'] }), expect.any(Object));
+    });
+    it('carries the variant\'s --config argument into a semgrep-validate probe', async () => {
+        await (0, probe_1.runCompatibilityProbe)({ kind: 'semgrep-validate' }, {
+            ...evidence, variantArgs: ['--config', '.semgrep.awm.yml', '--json', '.'],
+        }, fakeExecutor);
+        expect(fakeExecutor).toHaveBeenCalledWith(expect.objectContaining({ args: ['--config', '.semgrep.awm.yml', '--validate'] }), expect.any(Object));
+    });
+    it('omits --config from the probe when the variant command declares none', async () => {
+        await (0, probe_1.runCompatibilityProbe)({ kind: 'eslint-print-config' }, { ...evidence, variantArgs: ['.', '--cache'] }, fakeExecutor);
+        expect(fakeExecutor).toHaveBeenCalledWith(expect.objectContaining({ args: ['--print-config', 'eslint.config.js'] }), expect.any(Object));
+    });
 });

package/dist/tests/commands/sensors/status.test.js

@@ -182,6 +182,64 @@ describe('computeSensorStatus', () => {
         expect(result.pack).toBe('python');
         expect(result.checks).toEqual({});
     });
+    it('resolves v2 compatibility and structured-command assets against packageRoot in a monorepo', async () => {
+        // Monorepo support (mirrors run.ts/init.ts): the manifest lives at the repo
+        // root, but package.json/node_modules/the config asset all live under the
+        // declared packageRoot subdirectory. Without threading packageRoot through,
+        // detection finds no package.json at the manifest's own directory and every
+        // sensor reads back "not-applicable" — a false compatibility drift on every
+        // check, even immediately after a correct `awm sensors init --package-root`.
+        const previousHome = process.env.AWM_HOME;
+        const home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-home-'));
+        try {
+            process.env.AWM_HOME = home;
+            const registry = path_1.default.join(home, 'registries', 'baseline');
+            fs_1.default.mkdirSync(path_1.default.join(registry, 'sensor-packs', 'js-ts'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(home, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: 'https://example.test/baseline.git' }]));
+            fs_1.default.writeFileSync(path_1.default.join(registry, 'sensor-packs', 'js-ts', 'pack.json'), JSON.stringify({
+                schemaVersion: 2, name: 'js-ts', description: 'test', detects: ['package.json'],
+                coverage: { schemaVersion: 1, classes: { lint: { description: 'lint', detectors: [{ sensor: 'lint' }], remedy: { summary: 'fix lint', command: 'awm sensors init --pack js-ts' } } } },
+                sensors: { lint: {
+                        applicability: { allFiles: ['package.json'] },
+                        variants: [{
+                                id: 'eslint-10', priority: 10, certifiedRange: '>=10.0.0 <11.0.0',
+                                requirements: { tool: 'eslint', toolRange: '>=10.0.0 <11.0.0', runtime: 'node', runtimeRange: '>=0.0.0' },
+                                assets: ['eslint.config.awm.mjs'], formatter: 'eslint-llm', probe: { kind: 'package-script-present' },
+                                command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.', '--config', 'eslint.config.awm.mjs'] },
+                            }],
+                    } },
+            }));
+            const packageDir = path_1.default.join(tmpDir, 'cli');
+            fs_1.default.mkdirSync(packageDir, { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(packageDir, 'package.json'), JSON.stringify({ devDependencies: { eslint: '^10.0.0' }, scripts: { lint: 'eslint .' } }));
+            fs_1.default.mkdirSync(path_1.default.join(packageDir, 'node_modules', 'eslint'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(packageDir, 'node_modules', 'eslint', 'package.json'), JSON.stringify({ version: '10.4.1' }));
+            fs_1.default.mkdirSync(path_1.default.join(packageDir, 'node_modules', '.bin'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(packageDir, 'node_modules', '.bin', 'eslint'), '');
+            fs_1.default.writeFileSync(path_1.default.join(packageDir, 'eslint.config.awm.mjs'), 'export default []');
+            fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
+                schemaVersion: 2, pack: 'js-ts', packageRoot: 'cli', registryRoot: registry,
+                sensors: { lint: {
+                        enabled: true, variantId: 'eslint-10', command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.', '--config', 'eslint.config.awm.mjs'] },
+                        assets: ['eslint.config.awm.mjs'],
+                        initializedCompatibility: { state: 'certified', reason: 'range-and-probe', variantId: 'eslint-10', toolVersion: '10.4.1', runtimeVersion: process.versions.node, certifiedRange: '>=10.0.0 <11.0.0', evidence: [] },
+                    } },
+            }));
+            const result = await (0, status_1.computeSensorStatus)(tmpDir);
+            expect(result.checks.lint).toMatchObject({ ok: true });
+            expect(result.overall).toBe('READY');
+            expect(runCommand).not.toHaveBeenCalled();
+            expect(runStructuredCommand).not.toHaveBeenCalled();
+        }
+        finally {
+            if (previousHome === undefined)
+                delete process.env.AWM_HOME;
+            else
+                process.env.AWM_HOME = previousHome;
+            fs_1.default.rmSync(home, { recursive: true, force: true });
+        }
+    });
     it('marks disabled sensors as ok', async () => {
         fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({

package/dist/tests/core/context/orchestrator.test.js

@@ -17,6 +17,26 @@ jest.mock('../../../src/commands/hooks/status', () => ({
 const install_1 = require("../../../src/commands/hooks/install");
 const uninstall_1 = require("../../../src/commands/hooks/uninstall");
 const status_1 = require("../../../src/commands/hooks/status");
+const registries_1 = require("../../../src/core/registries");
+// inputFor/statusInputFor now call listRegistries() (collectDeclaredOrchestrators) on every
+// install/status. Without isolating AWM_HOME here, that reads the REAL ~/.awm/registries.json
+// of whatever machine runs the suite — exactly what CLAUDE.md's testing rule forbids ("ningun
+// test puede tocar el ~/.awm real. Todos usan tmpdirs aislados"). An empty isolated AWM_HOME
+// makes listRegistries() return [] deterministically, matching pre-change behavior everywhere.
+let isolatedAwmHome;
+let originalAwmHomeEnv;
+beforeEach(() => {
+    isolatedAwmHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-orch-isolated-home-'));
+    originalAwmHomeEnv = process.env.AWM_HOME;
+    process.env.AWM_HOME = isolatedAwmHome;
+});
+afterEach(() => {
+    if (originalAwmHomeEnv === undefined)
+        delete process.env.AWM_HOME;
+    else
+        process.env.AWM_HOME = originalAwmHomeEnv;
+    fs_1.default.rmSync(isolatedAwmHome, { recursive: true, force: true });
+});
 function tmpRegistry() {
     const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-orch-'));
     const dir = path_1.default.join(root, 'skills/using-awm');
@@ -221,3 +241,69 @@ describe('InjectionOrchestrator (local scope materializes under the project, not
         expect(orch.contextStatus(op)).toBe('injected');
     });
 });
+describe('InjectionOrchestrator (declared orchestrators from an installed registry reach status too)', () => {
+    // Regression guard for R5.1's wiring: installContext (inputFor) and contextStatus
+    // (statusInputFor) must collect the SAME declared-orchestrator set. If only inputFor
+    // did, the materialized file's hash would include the declared orchestrator while
+    // statusInputFor's "expected" hash would not — contextStatus would report 'stale'
+    // forever, even immediately after a correct install.
+    it('contextStatus reports injected (not stale) right after installing with a declared orchestrator', () => {
+        // The global beforeEach already points AWM_HOME at an isolated, empty home —
+        // register one real registry in it so listRegistries()/collectDeclaredOrchestrators
+        // actually has something to find.
+        (0, registries_1.writeRegistriesConfig)([{ name: 'declaring', remote: 'unused' }]);
+        const registryRoot = (0, registries_1.registryContentRoot)('declaring');
+        fs_1.default.mkdirSync(path_1.default.join(registryRoot, 'skills/using-awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'skills/using-awm/SKILL.md'), '---\nversion: "1.0.0"\n---\nBODY');
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'awm-registry.json'), JSON.stringify({
+            orchestrator: { name: 'mi-proceso', appliesWhen: 'al arrancar', terminatesTo: 'development-process' },
+        }));
+        const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-oc-declared-'));
+        const configPath = path_1.default.join(dir, 'opencode.json');
+        const absPath = path_1.default.join(dir, 'awm-context.md');
+        const orch = new orchestrator_1.InjectionOrchestrator({
+            providerOverride: {
+                label: 'OpenCode', configHome: { envVar: null, dir: '.test', resolved: '/tmp/test-config-home' }, skill: { global: '', local: '', renderer: 'link' }, workflow: null, agent: null,
+                injection: { type: 'config-instructions', configPath, field: 'instructions' },
+            },
+            contextPathOverride: absPath,
+        });
+        const args = { agent: 'opencode', scope: 'global', registryRoot, installMethod: 'symlink', profileExtensions: [] };
+        orch.installContext(args);
+        expect(fs_1.default.readFileSync(absPath, 'utf-8')).toContain('mi-proceso');
+        expect(orch.contextStatus(args)).toBe('injected');
+        fs_1.default.rmSync(dir, { recursive: true, force: true });
+    });
+    it('installContext still succeeds when a DIFFERENT installed registry has a broken declaration', () => {
+        // Two registries installed: "broken" has an unparsable awm-registry.json, "clean"
+        // is the one actually being operated on. The broken one must not block install.
+        (0, registries_1.writeRegistriesConfig)([
+            { name: 'broken', remote: 'unused' },
+            { name: 'clean', remote: 'unused' },
+        ]);
+        const brokenRoot = (0, registries_1.registryContentRoot)('broken');
+        fs_1.default.mkdirSync(brokenRoot, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(brokenRoot, 'awm-registry.json'), '{ not json');
+        const registryRoot = (0, registries_1.registryContentRoot)('clean');
+        fs_1.default.mkdirSync(path_1.default.join(registryRoot, 'skills/using-awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(registryRoot, 'skills/using-awm/SKILL.md'), '---\nversion: "1.0.0"\n---\nBODY');
+        const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-oc-brokensibling-'));
+        const configPath = path_1.default.join(dir, 'opencode.json');
+        const absPath = path_1.default.join(dir, 'awm-context.md');
+        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        const orch = new orchestrator_1.InjectionOrchestrator({
+            providerOverride: {
+                label: 'OpenCode', configHome: { envVar: null, dir: '.test', resolved: '/tmp/test-config-home' }, skill: { global: '', local: '', renderer: 'link' }, workflow: null, agent: null,
+                injection: { type: 'config-instructions', configPath, field: 'instructions' },
+            },
+            contextPathOverride: absPath,
+        });
+        const args = { agent: 'opencode', scope: 'global', registryRoot, installMethod: 'symlink', profileExtensions: [] };
+        expect(() => orch.installContext(args)).not.toThrow();
+        expect(fs_1.default.readFileSync(absPath, 'utf-8')).toContain('BODY');
+        expect(orch.contextStatus(args)).toBe('injected');
+        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('warning:'));
+        warnSpy.mockRestore();
+        fs_1.default.rmSync(dir, { recursive: true, force: true });
+    });
+});