agentic-workflow-manager 9.6.0 → 9.7.0

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([]);
+    });
 });

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

@@ -1,6 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const text_1 = require("../../src/core/text");
+describe('sanitizeDiagnosticText', () => {
+    it.each([
+        ['a\r\nb\rc\nd\te', 'a b c d e'],
+        ['a\x00\x07\x1b[31m\x7f\x85\x9bz', 'a[31mz'],
+        ['a\u2028b\u2029c', 'a b c'],
+        ['plain *markdown* — café', 'plain *markdown* — café'],
+    ])('sanitizes a single diagnostic field: %j', (input, expected) => {
+        expect((0, text_1.sanitizeDiagnosticText)(input)).toBe(expected);
+    });
+});
 describe('stripControlChars', () => {
     it('elimina ESC y demas bytes de control C0', () => {
         expect((0, text_1.stripControlChars)('a\x1b[31mb\x00c\x07d')).toBe('a[31mbcd');

package/dist/tests/core/tracks/git.test.js

@@ -128,5 +128,12 @@ describe('git adapter', () => {
             (0, child_process_1.execFileSync)('git', ['branch', 'awm-track/x'], { cwd: repo });
             expect((0, git_1.branchExists)(repo, 'awm-track/x')).toBe(true);
         });
+        test('branchExists falla cerrado cuando git no puede probar la ausencia', () => {
+            repo = (0, git_fixture_1.initRepo)();
+            (0, git_fixture_1.commitFile)(repo, 'a.txt', 'x');
+            const gitDir = path_1.default.join(repo, '.git');
+            fs_1.default.renameSync(gitDir, `${gitDir}.unavailable`);
+            expect(() => (0, git_1.branchExists)(repo, 'awm-track/nope')).toThrow(/indemostrable/);
+        });
     });
 });

package/dist/tests/core/tracks/protocol.test.js

@@ -34,6 +34,109 @@ describe('parallel-track protocol model', () => {
         expect(() => (0, protocol_1.observeProtocolEffect)(s, { kind: 'enter-serial', reason: 'x' }, { kind: 'effect-applied', effect: { kind: 'enter-serial', reason: 'x' } }))
             .toThrow(/SERIAL prohíbe recursos paralelos activos/);
     });
+    test.each([
+        {
+            name: 'observación de ownership ajeno',
+            observation: { kind: 'teardown-observation', trackId: 'cli', foreignWorktree: true },
+        },
+        {
+            name: 'fallo de begin-teardown',
+            observation: {
+                kind: 'effect-failed', trackId: 'cli', effect: 'begin-teardown', detail: 'ownership indemostrable',
+            },
+        },
+    ])('teardown indemostrable bloquea track y cohorte: $name (TR-REQ-05)', ({ observation }) => {
+        const s = (0, protocol_1.initialCohort)('journal-1', ids);
+        s.cohortPhase = 'FALLBACK_PENDING';
+        s.fallbackReason = 'controller-requested:cli';
+        s.tracks.cli.phase = 'TEARDOWN_REQUESTED';
+        s.tracks.docs.phase = 'REMOVED';
+        const out = (0, protocol_1.reconcileProtocol)(s, observation);
+        expect(out.tracks.cli.phase).toBe('BLOCKED');
+        expect(out.cohortPhase).toBe('BLOCKED');
+        expect((0, protocol_1.nextProtocolEffect)(out)).toBeNull();
+    });
+    test('fallo de begin-teardown para track inexistente falla cerrado (TR-REQ-05)', () => {
+        const s = (0, protocol_1.initialCohort)('journal-1', ids);
+        s.cohortPhase = 'FALLBACK_PENDING';
+        expect(() => (0, protocol_1.reconcileProtocol)(s, {
+            kind: 'effect-failed', trackId: 'missing', effect: 'begin-teardown', detail: 'ownership indemostrable',
+        })).toThrow('track desconocido: missing');
+    });
+    test('remove cancela toda la cohorte activa y conserva DECLARED/BLOCKED (TR-REQ-03, TR-REQ-05)', () => {
+        const s = (0, protocol_1.initialCohort)('journal-1', ['active', 'declared', 'blocked']);
+        s.cohortPhase = 'ACTIVE';
+        s.tracks.active.phase = 'ACTIVE';
+        s.tracks.declared.phase = 'DECLARED';
+        s.tracks.blocked.phase = 'BLOCKED';
+        const out = (0, protocol_1.reconcileProtocol)(s, { kind: 'teardown-requested', trackId: 'active' });
+        expect(out.cohortPhase).toBe('FALLBACK_PENDING');
+        expect(out.fallbackReason).toBe('controller-requested:active');
+        expect(out.tracks.active.phase).toBe('TEARDOWN_REQUESTED');
+        expect(out.tracks.declared.phase).toBe('DECLARED');
+        expect(out.tracks.blocked.phase).toBe('BLOCKED');
+        expect((0, protocol_1.nextProtocolEffect)(out)).toBeNull();
+    });
+    test('remove durante FINAL_INTERLOCK invalida evidencia final antes de pedir teardown (issue #93)', () => {
+        const s = (0, protocol_1.initialCohort)('journal-1', ids);
+        s.cohortPhase = 'FINAL_INTERLOCK';
+        s.globalQaHeadSha = 'qa-head';
+        s.finalIntegrationJobId = 'integration-job';
+        for (const track of Object.values(s.tracks)) {
+            track.phase = 'MERGED_UNVERIFIED';
+            track.frozenHeadSha = `${track.trackId}-head`;
+        }
+        const out = (0, protocol_1.reconcileProtocol)(s, { kind: 'teardown-requested', trackId: 'cli' });
+        expect(out.cohortPhase).toBe('FALLBACK_PENDING');
+        expect(out.globalQaHeadSha).toBeUndefined();
+        expect(out.finalIntegrationJobId).toBeUndefined();
+        expect(Object.values(out.tracks).every((track) => track.phase === 'TEARDOWN_REQUESTED')).toBe(true);
+    });
+    test('remove repetido no rebobina teardown ni reemplaza la causa (TR-REQ-08)', () => {
+        const s = (0, protocol_1.initialCohort)('journal-1', ids);
+        s.cohortPhase = 'FALLBACK_PENDING';
+        s.fallbackReason = 'controller-requested:cli';
+        s.tracks.cli.phase = 'SUPERVISOR_STOPPED';
+        s.tracks.docs.phase = 'TEARDOWN_REQUESTED';
+        const out = (0, protocol_1.reconcileProtocol)(s, { kind: 'teardown-requested', trackId: 'docs' });
+        expect(out.fallbackReason).toBe('controller-requested:cli');
+        expect(out.tracks.cli.phase).toBe('SUPERVISOR_STOPPED');
+        expect(out.tracks.docs.phase).toBe('TEARDOWN_REQUESTED');
+    });
+    test.each(['SERIAL', 'COMPLETE'])('remove es no-op protocolar en cohorte terminal %s (TR-REQ-09)', (cohortPhase) => {
+        const s = (0, protocol_1.initialCohort)('journal-1', ids);
+        s.cohortPhase = cohortPhase;
+        for (const track of Object.values(s.tracks)) {
+            track.phase = cohortPhase === 'SERIAL' ? 'REMOVED' : 'JOINED';
+            if (cohortPhase === 'COMPLETE')
+                track.frozenHeadSha = `${track.trackId}-head`;
+        }
+        expect((0, protocol_1.reconcileProtocol)(s, { kind: 'teardown-requested', trackId: 'cli' })).toEqual(s);
+    });
+    test('remove es no-op protocolar en cohorte BLOCKED y no reanuda teardown (TR-REQ-10)', () => {
+        const s = (0, protocol_1.initialCohort)('journal-1', ids);
+        s.cohortPhase = 'BLOCKED';
+        s.tracks.cli.phase = 'BLOCKED';
+        s.tracks.cli.blockedReason = 'ownership indemostrable';
+        s.tracks.docs.phase = 'REMOVED';
+        const out = (0, protocol_1.reconcileProtocol)(s, { kind: 'teardown-requested', trackId: 'docs' });
+        expect(out).toEqual(s);
+        expect(out.cohortPhase).toBe('BLOCKED');
+        expect((0, protocol_1.nextProtocolEffect)(out)).toBeNull();
+    });
+    test('remove converge a serial solo después de desmontar la cohorte (TR-REQ-06)', () => {
+        let s = (0, protocol_1.initialCohort)('journal-1', ids);
+        for (const track of Object.values(s.tracks))
+            track.phase = 'ACTIVE';
+        s.cohortPhase = 'ACTIVE';
+        s = (0, protocol_1.reconcileProtocol)(s, { kind: 'teardown-requested', trackId: 'cli' });
+        expect((0, protocol_1.nextProtocolEffect)(s)).toEqual({ kind: 'begin-teardown', trackId: 'cli' });
+        s.tracks.cli.phase = 'REMOVED';
+        s.tracks.docs.phase = 'REMOVED';
+        expect((0, protocol_1.nextProtocolEffect)(s)).toEqual({
+            kind: 'enter-serial', reason: 'controller-requested:cli',
+        });
+    });
     test('ningún merge empieza antes de que todos los tracks estén FROZEN (C3)', () => {
         const s = (0, protocol_1.initialCohort)('journal-1', ids);
         s.cohortPhase = 'JOINING';

package/dist/tests/integration/context-orchestrators-e2e.test.js

@@ -14,13 +14,13 @@ function seedRegistry() {
     const home = fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-ctx-e2e-')));
     const awmHome = path_1.default.join(home, '.awm');
     const root = path_1.default.join(awmHome, 'registries', 'test-registry');
-    fs_1.default.mkdirSync(path_1.default.join(root, 'skills', 'using-awm'), { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.join(root, 'skills', 'ejemplo-proceso'), { recursive: true });
     fs_1.default.writeFileSync(path_1.default.join(awmHome, 'registries.json'), JSON.stringify([{ name: 'test-registry', remote: 'https://example.invalid/test.git' }]));
     fs_1.default.writeFileSync(path_1.default.join(root, 'awm-registry.json'), JSON.stringify({
         minCliVersion: '8.5.0',
         orchestrator: { name: 'ejemplo-proceso', appliesWhen: 'cuando hay una tarea sin plan', terminatesTo: 'development-process' },
     }));
-    fs_1.default.writeFileSync(path_1.default.join(root, 'skills', 'using-awm', 'SKILL.md'), '---\nname: using-awm\nversion: "1.0.0"\n---\n\n# using-awm\n');
+    fs_1.default.writeFileSync(path_1.default.join(root, 'skills', 'ejemplo-proceso', 'SKILL.md'), '---\nname: ejemplo-proceso\nversion: "1.0.0"\n---\n\n# ejemplo-proceso\n');
     return home;
 }
 /**
@@ -36,7 +36,7 @@ function seedRealisticRegistry() {
     const home = fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-ctx-e2e-real-')));
     const awmHome = path_1.default.join(home, '.awm');
     const root = path_1.default.join(awmHome, 'registries', 'test-registry');
-    fs_1.default.mkdirSync(path_1.default.join(root, 'skills', 'using-awm'), { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.join(root, 'skills', 'task_capture_process'), { recursive: true });
     fs_1.default.writeFileSync(path_1.default.join(awmHome, 'registries.json'), JSON.stringify([{ name: 'test-registry', remote: 'https://example.invalid/test.git' }]));
     fs_1.default.writeFileSync(path_1.default.join(root, 'awm-registry.json'), JSON.stringify({
         minCliVersion: '8.5.0',
@@ -46,7 +46,7 @@ function seedRealisticRegistry() {
             terminatesTo: 'development-process',
         },
     }));
-    fs_1.default.writeFileSync(path_1.default.join(root, 'skills', 'using-awm', 'SKILL.md'), '---\nname: using-awm\nversion: "1.0.0"\n---\n\n# using-awm\n');
+    fs_1.default.writeFileSync(path_1.default.join(root, 'skills', 'task_capture_process', 'SKILL.md'), '---\nname: task_capture_process\nversion: "1.0.0"\n---\n\n# task_capture_process\n');
     return home;
 }
 /**
@@ -63,7 +63,7 @@ function seedMixedRegistries() {
     const awmHome = path_1.default.join(home, '.awm');
     const sanoRoot = path_1.default.join(awmHome, 'registries', 'sano-registry');
     const rotoRoot = path_1.default.join(awmHome, 'registries', 'roto-registry');
-    fs_1.default.mkdirSync(path_1.default.join(sanoRoot, 'skills', 'using-awm'), { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.join(sanoRoot, 'skills', 'proceso-sano'), { recursive: true });
     fs_1.default.mkdirSync(path_1.default.join(rotoRoot, 'skills', 'using-awm'), { recursive: true });
     fs_1.default.writeFileSync(path_1.default.join(awmHome, 'registries.json'), JSON.stringify([
         { name: 'sano-registry', remote: 'https://example.invalid/sano.git' },
@@ -79,8 +79,20 @@ function seedMixedRegistries() {
         minCliVersion: '8.5.0',
         orchestrator: { name: 'proceso-roto', appliesWhen: 'cuando algo pasa' },
     }));
-    fs_1.default.writeFileSync(path_1.default.join(sanoRoot, 'skills', 'using-awm', 'SKILL.md'), '---\nname: using-awm\nversion: "1.0.0"\n---\n\n# using-awm\n');
-    fs_1.default.writeFileSync(path_1.default.join(rotoRoot, 'skills', 'using-awm', 'SKILL.md'), '---\nname: using-awm\nversion: "1.0.0"\n---\n\n# using-awm\n');
+    fs_1.default.writeFileSync(path_1.default.join(sanoRoot, 'skills', 'proceso-sano', 'SKILL.md'), '---\nname: proceso-sano\nversion: "1.0.0"\n---\n\n# proceso-sano\n');
+    return home;
+}
+function seedPhantomRegistry() {
+    const home = fs_1.default.realpathSync(fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-ctx-e2e-phantom-')));
+    const awmHome = path_1.default.join(home, '.awm');
+    const root = path_1.default.join(awmHome, 'registries', 'test-registry');
+    fs_1.default.mkdirSync(path_1.default.join(root, 'skills', 'real-skill'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(awmHome, 'registries.json'), JSON.stringify([{ name: 'test-registry', remote: 'https://example.invalid/test.git' }]));
+    fs_1.default.writeFileSync(path_1.default.join(root, 'awm-registry.json'), JSON.stringify({
+        minCliVersion: '8.5.0',
+        orchestrator: { name: 'phantom-process', appliesWhen: 'cuando hay una tarea sin plan', terminatesTo: 'development-process' },
+    }));
+    fs_1.default.writeFileSync(path_1.default.join(root, 'skills', 'real-skill', 'SKILL.md'), '---\nname: real-skill\nversion: "1.0.0"\n---\n\n# real-skill\n');
     return home;
 }
 function run(home, ...args) {
@@ -142,3 +154,41 @@ describe('awm context orchestrators -- diagnosticos + sanos mezclados (binario r
         expect(r.stderr).toContain('terminatesTo');
     });
 });
+describe('awm context orchestrators -- declaracion phantom (binario real)', () => {
+    let home;
+    beforeAll(() => { home = seedPhantomRegistry(); });
+    afterAll(() => fs_1.default.rmSync(home, { recursive: true, force: true }));
+    it('--verify devuelve 2 y diagnostica una declaracion sin skill resoluble', () => {
+        const r = run(home, 'context', 'orchestrators', '--verify', 'phantom-process');
+        expect(r.status).toBe(2);
+        expect(r.stderr).toMatch(/phantom-process/);
+        expect(r.stderr).toMatch(/declaration dropped|skill/i);
+    });
+});
+describe('awm context orchestrators -- dropped sanitized collision (real binary)', () => {
+    let home;
+    beforeAll(() => {
+        home = seedPhantomRegistry();
+        const awmHome = path_1.default.join(home, '.awm');
+        const phantomRoot = path_1.default.join(awmHome, 'registries', 'test-registry');
+        const retainedRoot = path_1.default.join(awmHome, 'registries', 'retained');
+        fs_1.default.writeFileSync(path_1.default.join(awmHome, 'registries.json'), JSON.stringify([
+            { name: 'test-registry', remote: 'unused' }, { name: 'retained', remote: 'unused' },
+        ]));
+        fs_1.default.writeFileSync(path_1.default.join(phantomRoot, 'awm-registry.json'), JSON.stringify({
+            orchestrator: { name: 'foo_bar', appliesWhen: 'x', terminatesTo: 'none' },
+        }));
+        fs_1.default.mkdirSync(path_1.default.join(retainedRoot, 'skills', 'foobar'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(retainedRoot, 'skills', 'foobar', 'SKILL.md'), '# foobar\n');
+        fs_1.default.writeFileSync(path_1.default.join(retainedRoot, 'awm-registry.json'), JSON.stringify({
+            orchestrator: { name: 'foobar', appliesWhen: 'x', terminatesTo: 'none' },
+        }));
+    });
+    afterAll(() => fs_1.default.rmSync(home, { recursive: true, force: true }));
+    it('verifies the retained raw name and rejects the dropped raw name', () => {
+        expect(run(home, 'context', 'orchestrators', '--verify', 'foobar').status).toBe(0);
+        const dropped = run(home, 'context', 'orchestrators', '--verify', 'foo_bar');
+        expect(dropped.status).toBe(2);
+        expect(dropped.stderr).toContain('declaration dropped');
+    });
+});

package/package.json

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