agentic-workflow-manager 9.5.0 → 9.6.1

package/dist/tests/core/discovery-safe-read.test.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const discovery_1 = require("../../src/core/discovery");
+jest.mock('fs');
+const root = path_1.default.resolve('registry');
+const skillDir = path_1.default.join(root, 'skills', 'safe');
+const skillFile = path_1.default.join(skillDir, 'SKILL.md');
+const content = '---\ndescription: >-\n  Ordinary skill\n---\n';
+const descriptor = 42;
+const inspected = {
+    dev: 7n, ino: 9007199254740993n, size: BigInt(Buffer.byteLength(content)),
+    isFile: () => true, isSymbolicLink: () => false, isDirectory: () => false,
+};
+const directory = { dev: 7n, ino: 8n, isFile: () => false, isSymbolicLink: () => false, isDirectory: () => true };
+describe.each([true, false])('skill descriptor safety (O_NOFOLLOW available: %s)', (noFollowAvailable) => {
+    beforeEach(() => {
+        jest.resetAllMocks();
+        const actual = jest.requireActual('fs');
+        jest.replaceProperty(fs_1.default, 'constants', {
+            ...actual.constants,
+            O_NOFOLLOW: noFollowAvailable ? 0x20000 : undefined,
+            O_NONBLOCK: 0x800,
+        });
+        fs_1.default.existsSync.mockReturnValue(true);
+        fs_1.default.readdirSync.mockReturnValue([{ name: 'safe', isDirectory: () => true }]);
+        fs_1.default.lstatSync.mockImplementation((file) => {
+            if (file === skillFile)
+                return inspected;
+            if (file.endsWith('awm-registry.json'))
+                throw Object.assign(new Error('missing'), { code: 'ENOENT' });
+            return directory;
+        });
+        fs_1.default.openSync.mockReturnValue(descriptor);
+        fs_1.default.fstatSync.mockReturnValue(inspected);
+        fs_1.default.readFileSync.mockReturnValue(content);
+    });
+    afterEach(() => jest.restoreAllMocks());
+    it('reads an ordinary skill from the validated descriptor and closes it', () => {
+        expect((0, discovery_1.discoverSkills)([root])).toEqual([{ name: 'safe', path: skillDir, description: 'Ordinary skill' }]);
+        expect(fs_1.default.readFileSync).toHaveBeenCalledWith(descriptor, 'utf-8');
+        expect(fs_1.default.closeSync).toHaveBeenCalledWith(descriptor);
+        const flags = fs_1.default.openSync.mock.calls[0][1];
+        expect(typeof flags).toBe('number');
+        if (noFollowAvailable)
+            expect(flags & fs_1.default.constants.O_NOFOLLOW).toBe(fs_1.default.constants.O_NOFOLLOW);
+        expect(flags & fs_1.default.constants.O_NONBLOCK).toBe(fs_1.default.constants.O_NONBLOCK);
+    });
+    it.each([
+        ['another inode', { ino: inspected.ino + 1n }],
+        ['another device', { dev: inspected.dev + 1n }],
+        ['changed size', { size: inspected.size + 1n }],
+        ['FIFO replacement', { isFile: () => false }],
+        ['symlink replacement', { isFile: () => false, isSymbolicLink: () => true }],
+        ['unobservable device', { dev: undefined }],
+        ['unobservable inode', { ino: undefined }],
+    ])('rejects %s after inspection, without reading replacement bytes', (_label, change) => {
+        fs_1.default.fstatSync.mockReturnValue({ ...inspected, ...change });
+        expect(() => (0, discovery_1.discoverSkills)([root])).toThrow(/SKILL\.md.*(identity|regular|size|symbolic)/i);
+        expect(fs_1.default.readFileSync).not.toHaveBeenCalled();
+        expect(fs_1.default.closeSync).toHaveBeenCalledWith(descriptor);
+    });
+    it('opens nonblocking so a FIFO replacement cannot hang before fstat rejects it', () => {
+        // No FIFO is created: the open mock enforces the flag needed to avoid blocking.
+        fs_1.default.openSync.mockImplementation((_file, flags) => {
+            if (!(flags & fs_1.default.constants.O_NONBLOCK))
+                throw new Error('would block opening FIFO');
+            return descriptor;
+        });
+        fs_1.default.fstatSync.mockReturnValue({ ...inspected, isFile: () => false });
+        expect(() => (0, discovery_1.discoverSkills)([root])).toThrow(/regular file/i);
+        expect(fs_1.default.readFileSync).not.toHaveBeenCalled();
+        expect(fs_1.default.closeSync).toHaveBeenCalledWith(descriptor);
+    });
+    it.each(['openSync', 'fstatSync', 'readFileSync'])('fails closed on %s errors', (operation) => {
+        fs_1.default[operation].mockImplementation(() => { throw new Error('replaced or unreadable'); });
+        expect(() => (0, discovery_1.discoverSkills)([root])).toThrow(/SKILL\.md.*replaced or unreadable/);
+        if (operation === 'openSync')
+            expect(fs_1.default.closeSync).not.toHaveBeenCalled();
+        else
+            expect(fs_1.default.closeSync).toHaveBeenCalledWith(descriptor);
+        if (operation !== 'readFileSync')
+            expect(fs_1.default.readFileSync).not.toHaveBeenCalled();
+    });
+    it.each([root, path_1.default.join(root, 'skills'), skillDir])('rejects an observable directory symlink at %s', (linked) => {
+        const lstat = fs_1.default.lstatSync.getMockImplementation();
+        fs_1.default.lstatSync.mockImplementation((file, options) => file === linked
+            ? { ...directory, isDirectory: () => false, isSymbolicLink: () => true }
+            : lstat(file, options));
+        expect(() => (0, discovery_1.discoverSkills)([root])).toThrow(/symbolic link/i);
+        expect(fs_1.default.openSync).not.toHaveBeenCalled();
+        expect(fs_1.default.readFileSync).not.toHaveBeenCalled();
+    });
+    it.each(['dev', 'ino', 'size'])('fails closed when inspected %s is unobservable', (field) => {
+        const unknown = { ...inspected, [field]: undefined };
+        const lstat = fs_1.default.lstatSync.getMockImplementation();
+        fs_1.default.lstatSync.mockImplementation((file, options) => file === skillFile ? unknown : lstat(file, options));
+        fs_1.default.fstatSync.mockReturnValue(unknown);
+        expect(() => (0, discovery_1.discoverSkills)([root])).toThrow(/identity|size/i);
+        expect(fs_1.default.readFileSync).not.toHaveBeenCalled();
+    });
+    it.each(['dev', 'ino'])('fails closed when parent %s is unobservable', (field) => {
+        const lstat = fs_1.default.lstatSync.getMockImplementation();
+        fs_1.default.lstatSync.mockImplementation((file, options) => file === skillDir
+            ? { ...directory, [field]: undefined }
+            : lstat(file, options));
+        expect(() => (0, discovery_1.discoverSkills)([root])).toThrow(/directory identity/i);
+        expect(fs_1.default.openSync).not.toHaveBeenCalled();
+        expect(fs_1.default.readFileSync).not.toHaveBeenCalled();
+    });
+});

package/dist/tests/core/discovery.test.js

@@ -15,16 +15,30 @@ const WORKFLOWS_ROOT = CONTENT_ROOT;
 // For backward-compat with mock expectations that check SKILLS_DIR-style paths:
 const SKILLS_DIR = path_1.default.join(CONTENT_ROOT, 'skills');
 const WORKFLOWS_DIR = path_1.default.join(CONTENT_ROOT, 'workflows');
+const directoryStat = { dev: 1n, ino: 3n, isDirectory: () => true, isSymbolicLink: () => false };
+const skillStat = { dev: 1n, ino: 2n, size: 0n, isFile: () => true, isSymbolicLink: () => false };
 describe('Artifact Discovery', () => {
     beforeEach(() => {
         jest.clearAllMocks();
-        fs_1.default.lstatSync.mockImplementation(() => {
+        fs_1.default.lstatSync.mockImplementation((p) => {
+            if (!p.endsWith('.md') && !p.endsWith('.json'))
+                return directoryStat;
             const error = Object.assign(new Error('missing'), { code: 'ENOENT' });
             throw error;
         });
+        fs_1.default.openSync.mockReturnValue(42);
+        fs_1.default.fstatSync.mockReturnValue(skillStat);
+        fs_1.default.readFileSync.mockReturnValue('');
     });
     describe('discoverSkills', () => {
         it('should return a list of skill directories that contain a SKILL.md', () => {
+            fs_1.default.lstatSync.mockImplementation((p) => {
+                if (p.endsWith('SKILL.md'))
+                    return skillStat;
+                if (!p.endsWith('.json'))
+                    return directoryStat;
+                throw Object.assign(new Error('missing'), { code: 'ENOENT' });
+            });
             fs_1.default.existsSync.mockImplementation((p) => {
                 if (p === SKILLS_DIR)
                     return true;
@@ -48,6 +62,19 @@ describe('Artifact Discovery', () => {
             const skills = (0, discovery_1.discoverSkills)([SKILLS_ROOT]);
             expect(skills).toEqual([]);
         });
+        it.each(['fifo', 'symlink'])('rejects a %s SKILL.md before attempting any read', (kind) => {
+            fs_1.default.existsSync.mockReturnValue(true);
+            fs_1.default.readdirSync.mockReturnValue([{ name: 'unsafe', isDirectory: () => true }]);
+            fs_1.default.lstatSync.mockImplementation((p) => {
+                if (p.endsWith('SKILL.md'))
+                    return { isFile: () => false, isSymbolicLink: () => kind === 'symlink' };
+                if (!p.endsWith('.json'))
+                    return directoryStat;
+                throw Object.assign(new Error('missing'), { code: 'ENOENT' });
+            });
+            expect(() => (0, discovery_1.discoverSkills)([SKILLS_ROOT])).toThrow(/regular file|symbolic link/);
+            expect(fs_1.default.readFileSync).not.toHaveBeenCalled();
+        });
         it('should skip skill directories without a SKILL.md', () => {
             fs_1.default.existsSync.mockImplementation((p) => {
                 if (p === SKILLS_DIR)

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

@@ -135,7 +135,9 @@ describe('runInitSteps — orchestrator', () => {
         const deps = buildDeps(root);
         const { runInitSteps } = require('../../../src/core/init/orchestrator');
         const out = await runInitSteps(deps);
-        expect(out.steps.some((s) => s.id === 'project.sensors' && s.action === 'applied')).toBe(true);
+        // The sensor step is always represented; whether this fixture's pack is
+        // portable is orthogonal to activation/constitution orchestration.
+        expect(out.steps.some((s) => s.id === 'project.sensors')).toBe(true);
         expect(out.steps.find((s) => s.id === 'project.constitution').action).toBe('pending');
         expect(out.steps.find((s) => s.id === 'project.context').action).toBe('pending');
     });

package/dist/tests/core/orchestrators.test.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
+const command_result_1 = require("../../src/core/command-result");
 const orchestrators_1 = require("../../src/core/orchestrators");
 const registries_1 = require("../../src/core/registries");
 function registryWith(manifest) {
@@ -16,6 +17,7 @@ function registryWith(manifest) {
 describe('readDeclaredOrchestrators', () => {
     const created = [];
     afterEach(() => {
+        jest.restoreAllMocks();
         for (const r of created.splice(0))
             fs_1.default.rmSync(r, { recursive: true, force: true });
     });
@@ -176,6 +178,62 @@ describe('readDeclaredOrchestrators', () => {
         expect(diagnostics[0].split('\n')).toHaveLength(1);
         expect(diagnostics[0]).toContain(JSON.stringify('evil\nfake-warning: injected line'));
     });
+    describe('single-line diagnostic boundary', () => {
+        const hostile = 'before\u2028\u2029\u0085\r\n\t'
+            + String.fromCharCode(...Array.from({ length: 32 }, (_, i) => i))
+            + String.fromCharCode(...Array.from({ length: 33 }, (_, i) => 127 + i)) + 'after';
+        it('sanitizes unknown metadata keys without accepting the declaration', () => {
+            const root = registryWith({
+                orchestrator: { name: 'x', appliesWhen: 'y', terminatesTo: 'none', [hostile]: true },
+            });
+            created.push(root);
+            const result = (0, orchestrators_1.readDeclaredOrchestrators)(root);
+            expect(result.orchestrators).toEqual([]);
+            expect(result.diagnostics).toHaveLength(1);
+            expect(result.diagnostics[0]).toContain('unknown field');
+            expect(result.diagnostics[0]).toContain('before');
+            expect(result.diagnostics[0]).toContain('after');
+            const stderrBoundary = jest.fn(command_result_1.diagnosticsToStderr);
+            stderrBoundary(result.diagnostics);
+            expect(stderrBoundary.mock.calls[0][0].join('')).not.toMatch(/[\u2028\u0085]/);
+            expect(stderrBoundary.mock.results[0].value).not.toMatch(/[\u2028\u0085]/);
+            // eslint-disable-next-line no-control-regex -- reject all terminal controls and line separators
+            expect(result.diagnostics[0]).not.toMatch(/[\x00-\x1f\x7f-\x9f\u2028\u2029]/);
+        });
+        it.each(['inspection', 'read', 'parse', 'shape', 'fields'])('sanitizes %s diagnostics, including paths and error text', (branch) => {
+            // Mock hostile paths instead of creating filenames that are invalid on Windows.
+            const root = path_1.default.join(os_1.default.tmpdir(), hostile);
+            const error = new Error(hostile);
+            jest.spyOn(fs_1.default, 'lstatSync').mockImplementation(() => {
+                if (branch === 'inspection')
+                    throw error;
+                return { isFile: () => true, isSymbolicLink: () => false };
+            });
+            jest.spyOn(fs_1.default, 'readFileSync').mockImplementation(() => {
+                if (branch === 'read')
+                    throw error;
+                if (branch === 'parse')
+                    return `{ ${hostile}`;
+                return JSON.stringify({ orchestrator: branch === 'shape' ? [] : {} });
+            });
+            if (branch === 'parse')
+                jest.spyOn(JSON, 'parse').mockImplementationOnce(() => { throw new SyntaxError(hostile); });
+            const result = (0, orchestrators_1.readDeclaredOrchestrators)(root);
+            expect(result.orchestrators).toEqual([]);
+            expect(result.diagnostics).toHaveLength(1);
+            expect(result.diagnostics[0]).toContain('awm-registry.json');
+            expect(result.diagnostics[0]).toContain('before');
+            expect(result.diagnostics[0]).toContain('after');
+            // eslint-disable-next-line no-control-regex -- reject all terminal controls and line separators
+            expect(result.diagnostics[0]).not.toMatch(/[\x00-\x1f\x7f-\x9f\u2028\u2029]/);
+        });
+        it('preserves valid raw fields and structural parsing without skill discovery', () => {
+            const declaration = { name: hostile, appliesWhen: hostile, terminatesTo: hostile };
+            const root = registryWith({ orchestrator: declaration });
+            created.push(root);
+            expect((0, orchestrators_1.readDeclaredOrchestrators)(root)).toEqual({ orchestrators: [declaration], diagnostics: [] });
+        });
+    });
 });
 describe('collectDeclaredOrchestrators', () => {
     // Isolates AWM_HOME per CLAUDE.md's testing rule ("ningun test puede tocar el ~/.awm
@@ -199,6 +257,11 @@ describe('collectDeclaredOrchestrators', () => {
         fs_1.default.mkdirSync(root, { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(root, 'awm-registry.json'), JSON.stringify(manifest));
     }
+    function writeSkill(registryName, skillName) {
+        const skillDir = path_1.default.join((0, registries_1.registryContentRoot)(registryName), 'skills', skillName);
+        fs_1.default.mkdirSync(skillDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(skillDir, 'SKILL.md'), `---\nname: ${skillName}\n---\n\n# ${skillName}\n`);
+    }
     it('dedupea por nombre entre dos registries, conservando el primero por orden de registries.json', () => {
         (0, registries_1.writeRegistriesConfig)([
             { name: 'first', remote: 'unused' },
@@ -210,6 +273,7 @@ describe('collectDeclaredOrchestrators', () => {
         writeManifest('second', {
             orchestrator: { name: 'shared', appliesWhen: 'segundo', terminatesTo: 'b' },
         });
+        writeSkill('first', 'shared');
         const { declared, diagnostics } = (0, orchestrators_1.collectDeclaredOrchestrators)();
         expect(declared).toHaveLength(1);
         expect(declared[0]).toEqual({ name: 'shared', appliesWhen: 'primero', terminatesTo: 'a' });
@@ -217,23 +281,60 @@ describe('collectDeclaredOrchestrators', () => {
         expect(diagnostics[0]).toMatch(/shared/);
         expect(diagnostics[0]).toMatch(/duplicate|shadow/i);
     });
-    it('sanea el nombre antes de interpolarlo en el diagnostico de duplicado', () => {
-        (0, registries_1.writeRegistriesConfig)([
-            { name: 'first', remote: 'unused' },
-            { name: 'second', remote: 'unused' },
-        ]);
-        const nombreHostil = 'shared\x1b[31m';
+    it('keeps missing-skill diagnostics single-line with hostile metadata and portable paths', () => {
+        (0, registries_1.writeRegistriesConfig)([{ name: 'first', remote: 'unused' }]);
+        const nombreHostil = 'shared\r\nforged\t\x1b[31m\x00\x7f\x85\x9b\u2028\u2029';
         writeManifest('first', {
             orchestrator: { name: nombreHostil, appliesWhen: 'primero', terminatesTo: 'a' },
         });
-        writeManifest('second', {
-            orchestrator: { name: nombreHostil, appliesWhen: 'segundo', terminatesTo: 'b' },
-        });
+        writeSkill('first', 'real-skill');
         const { diagnostics } = (0, orchestrators_1.collectDeclaredOrchestrators)();
         expect(diagnostics).toHaveLength(1);
-        // eslint-disable-next-line no-control-regex -- verificamos la ausencia deliberada de C0
-        expect(diagnostics[0]).not.toMatch(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/);
-        expect(diagnostics[0]).toContain('shared[31m');
+        // eslint-disable-next-line no-control-regex -- diagnostic must contain no terminal controls or line separators
+        expect(diagnostics[0]).not.toMatch(/[\x00-\x1f\x7f-\x9f\u2028\u2029]/);
+        expect(diagnostics[0]).toContain('shared');
+        expect(diagnostics[0]).toContain('forged');
+        expect(diagnostics[0]).toContain('declaration dropped');
+    });
+    it('keeps discovery diagnostics single-line for hostile override metadata', () => {
+        (0, registries_1.writeRegistriesConfig)([{ name: 'hostile', remote: 'unused' }]);
+        writeManifest('hostile', { overrides: ['../forged\r\nwarning:\t\x1b[31m\x85\u2028'] });
+        writeSkill('hostile', 'real-skill');
+        const { diagnostics } = (0, orchestrators_1.collectDeclaredOrchestrators)();
+        expect(diagnostics).toHaveLength(1);
+        expect(diagnostics[0]).toContain('discovery unavailable');
+        expect(diagnostics[0]).toContain('forged');
+        // eslint-disable-next-line no-control-regex -- diagnostic must contain no terminal controls or line separators
+        expect(diagnostics[0]).not.toMatch(/[\x00-\x1f\x7f-\x9f\u2028\u2029]/);
+    });
+    it('excludes a later colliding root without losing earlier or subsequent healthy roots', () => {
+        (0, registries_1.writeRegistriesConfig)(['first', 'collision', 'last'].map((name) => ({ name, remote: 'unused' })));
+        for (const name of ['first', 'collision', 'last']) {
+            writeManifest(name, { orchestrator: { name: `${name}-process`, appliesWhen: 'x', terminatesTo: 'none' } });
+            writeSkill(name, `${name}-process`);
+        }
+        writeSkill('first', 'shared');
+        writeSkill('collision', 'shared');
+        // This name belongs only to the excluded root and must not poison later admission.
+        writeSkill('collision', 'last-process');
+        const { declared, diagnostics } = (0, orchestrators_1.collectDeclaredOrchestrators)();
+        expect(declared.map((d) => d.name)).toEqual(['first-process', 'last-process']);
+        expect(diagnostics).toHaveLength(2);
+        expect(diagnostics[0]).toMatch(/collision.*discovery unavailable.*Artifact name collision/);
+        expect(diagnostics[1]).toMatch(/collision-process.*not discoverable/);
+    });
+    it('admits a later root with a declared override', () => {
+        (0, registries_1.writeRegistriesConfig)(['first', 'override'].map((name) => ({ name, remote: 'unused' })));
+        writeSkill('first', 'shared');
+        writeSkill('override', 'shared');
+        writeSkill('override', 'override-process');
+        writeManifest('override', {
+            overrides: ['shared'],
+            orchestrator: { name: 'override-process', appliesWhen: 'x', terminatesTo: 'none' },
+        });
+        const { declared, diagnostics } = (0, orchestrators_1.collectDeclaredOrchestrators)();
+        expect(declared.map((d) => d.name)).toEqual(['override-process']);
+        expect(diagnostics).toEqual([]);
     });
     it('emite un diagnostico de colision post-saneo entre nombres crudos distintos, sin descartar ninguno', () => {
         (0, registries_1.writeRegistriesConfig)([
@@ -244,12 +345,14 @@ describe('collectDeclaredOrchestrators', () => {
             orchestrator: { name: 'foo_bar', appliesWhen: 'x', terminatesTo: 'a' },
         });
         writeManifest('second', {
-            orchestrator: { name: 'foo*bar', appliesWhen: 'y', terminatesTo: 'b' },
+            orchestrator: { name: 'foobar', appliesWhen: 'y', terminatesTo: 'b' },
         });
+        writeSkill('first', 'foo_bar');
+        writeSkill('second', 'foobar');
         const { declared, diagnostics } = (0, orchestrators_1.collectDeclaredOrchestrators)();
         // Ambas declaraciones son genuinamente distintas (nombre crudo distinto) — ninguna se descarta.
         expect(declared).toHaveLength(2);
-        expect(declared.map((d) => d.name).sort()).toEqual(['foo*bar', 'foo_bar']);
+        expect(declared.map((d) => d.name).sort()).toEqual(['foo_bar', 'foobar']);
         // Pero se advierte de la colision post-saneo (ambas renderizan como "foobar").
         expect(diagnostics).toHaveLength(1);
         expect(diagnostics[0]).toMatch(/foobar/);
@@ -266,9 +369,63 @@ describe('collectDeclaredOrchestrators', () => {
         writeManifest('second', {
             orchestrator: { name: 'dos', appliesWhen: 'y', terminatesTo: 'b' },
         });
+        writeSkill('first', 'uno');
+        writeSkill('second', 'dos');
         const { declared, diagnostics } = (0, orchestrators_1.collectDeclaredOrchestrators)();
         expect(declared).toHaveLength(2);
         expect(declared.map((d) => d.name).sort()).toEqual(['dos', 'uno']);
         expect(diagnostics).toEqual([]);
     });
+    it('omite una declaracion cuyo skill no existe y la diagnostica', () => {
+        (0, registries_1.writeRegistriesConfig)([{ name: 'phantom', remote: 'unused' }]);
+        writeManifest('phantom', {
+            orchestrator: { name: 'phantom-process', appliesWhen: 'x', terminatesTo: 'none' },
+        });
+        writeSkill('phantom', 'real-skill');
+        const { declared, diagnostics } = (0, orchestrators_1.collectDeclaredOrchestrators)();
+        expect(declared).toEqual([]);
+        expect(diagnostics).toHaveLength(1);
+        expect(diagnostics[0]).toMatch(/phantom-process/);
+        expect(diagnostics[0]).toMatch(/declaration dropped|skill/i);
+    });
+    it('resuelve una declaracion contra un skill de otro registry configurado', () => {
+        (0, registries_1.writeRegistriesConfig)([
+            { name: 'declarations', remote: 'unused' },
+            { name: 'skills', remote: 'unused' },
+        ]);
+        writeManifest('declarations', {
+            orchestrator: { name: 'cross-registry', appliesWhen: 'x', terminatesTo: 'none' },
+        });
+        writeSkill('skills', 'cross-registry');
+        const { declared, diagnostics } = (0, orchestrators_1.collectDeclaredOrchestrators)();
+        expect(declared).toEqual([{ name: 'cross-registry', appliesWhen: 'x', terminatesTo: 'none' }]);
+        expect(diagnostics).toEqual([]);
+    });
+    it('diagnostica un root cuyo discovery falla y conserva una declaracion sana', () => {
+        (0, registries_1.writeRegistriesConfig)([
+            { name: 'broken', remote: 'unused' },
+            { name: 'healthy', remote: 'unused' },
+        ]);
+        writeManifest('broken', {
+            orchestrator: { name: 'broken-process', appliesWhen: 'x', terminatesTo: 'none' },
+        });
+        fs_1.default.writeFileSync(path_1.default.join((0, registries_1.registryContentRoot)('broken'), 'skills'), 'not a directory');
+        writeManifest('healthy', {
+            orchestrator: { name: 'healthy-process', appliesWhen: 'x', terminatesTo: 'none' },
+        });
+        writeSkill('healthy', 'healthy-process');
+        const { declared, diagnostics } = (0, orchestrators_1.collectDeclaredOrchestrators)();
+        expect(declared).toEqual([{ name: 'healthy-process', appliesWhen: 'x', terminatesTo: 'none' }]);
+        expect(diagnostics.join('\n')).toMatch(/broken.*discovery unavailable/i);
+    });
+    it('conserva terminatesTo aunque no corresponda a un skill descubierto', () => {
+        (0, registries_1.writeRegistriesConfig)([{ name: 'registry', remote: 'unused' }]);
+        writeManifest('registry', {
+            orchestrator: { name: 'entry-process', appliesWhen: 'x', terminatesTo: 'missing-successor' },
+        });
+        writeSkill('registry', 'entry-process');
+        const { declared, diagnostics } = (0, orchestrators_1.collectDeclaredOrchestrators)();
+        expect(declared).toEqual([{ name: 'entry-process', appliesWhen: 'x', terminatesTo: 'missing-successor' }]);
+        expect(diagnostics).toEqual([]);
+    });
 });