agentic-workflow-manager 3.11.0 → 3.13.0

package/dist/tests/core/init/mutation-targets.test.js

@@ -19,6 +19,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
+const materializer_1 = require("../../../src/core/context/materializer");
 function bundle(name, scope, skills) {
     return {
         name, description: '', version: '1.0.0', scope, visibility: 'public',
@@ -146,6 +147,8 @@ describe('planInitMutationTargets', () => {
             ];
             const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'claude-code', bundles });
             const skillsDir = providerFor('claude-code').skill.global;
+            if (skillsDir === null)
+                throw new Error('claude-code skill.global must not be null');
             expect(targets).toContain(path_1.default.join(skillsDir, 'using-awm'));
             expect(targets).toContain(path_1.default.join(skillsDir, 'ambient-skill'));
             // project-scope bundles are only enumerated via .awm/profile.json
@@ -192,6 +195,55 @@ describe('planInitMutationTargets', () => {
             expect(targets.some((t) => t.endsWith(path_1.default.join('.awm', 'profile.json')))).toBe(false);
             expect(targets.some((t) => t.endsWith(path_1.default.join('.awm', 'sensors.json')))).toBe(false);
         });
+        it('includes the materialized .awm/context/awm-context.md path for a local-scope-context provider (cursor)', () => {
+            // Finding: stepContextInjection (steps.ts) materializes its source content
+            // under <projectRoot>/.awm/context/awm-context.md BEFORE injecting it into
+            // the local AGENTS.md/.mdc target, for any provider whose managed-agents-md
+            // injection has no global path (globalPath === null). That materialized
+            // write is a real one this run can make and must be covered by the backup
+            // session, same reasoning as the target file itself just below.
+            const { planInitMutationTargets, providerFor } = load();
+            const projectRoot = makeProjectRoot();
+            const provider = providerFor('cursor');
+            expect(provider.injection?.type).toBe('managed-agents-md');
+            expect(provider.injection.globalPath).toBeNull();
+            const targets = planInitMutationTargets({ cwd: projectRoot, agent: 'cursor', bundles: [] });
+            expect(targets).toContain((0, materializer_1.projectContextPath)(projectRoot));
+        });
+        it('includes the materialized .awm/context/awm-context.md path for a local-scope-context provider (copilot)', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            const projectRoot = makeProjectRoot();
+            const provider = providerFor('copilot');
+            expect(provider.injection?.type).toBe('managed-agents-md');
+            expect(provider.injection.globalPath).toBeNull();
+            const targets = planInitMutationTargets({ cwd: projectRoot, agent: 'copilot', bundles: [] });
+            expect(targets).toContain((0, materializer_1.projectContextPath)(projectRoot));
+        });
+        it('does NOT include the materialized .awm/context/awm-context.md path for a global-scope-context provider (codex)', () => {
+            // Codex's managed-agents-md injection has a non-null globalPath, so its
+            // context is delivered at GLOBAL scope — the local materialized-source
+            // path is never written for it and must not be enumerated.
+            const { planInitMutationTargets, providerFor } = load();
+            const projectRoot = makeProjectRoot();
+            const provider = providerFor('codex');
+            expect(provider.injection.globalPath).not.toBeNull();
+            const targets = planInitMutationTargets({ cwd: projectRoot, agent: 'codex', bundles: [] });
+            expect(targets).not.toContain((0, materializer_1.projectContextPath)(projectRoot));
+        });
+        it('includes .cursor/rules/awm.mdc (the redundant carrier) only for agent === cursor', () => {
+            const { planInitMutationTargets } = load();
+            const projectRoot = makeProjectRoot();
+            const cursorTargets = planInitMutationTargets({ cwd: projectRoot, agent: 'cursor', bundles: [] });
+            expect(cursorTargets).toContain(path_1.default.join(projectRoot, '.cursor', 'rules', 'awm.mdc'));
+        });
+        it('does NOT include .cursor/rules/awm.mdc for copilot or other agents', () => {
+            const { planInitMutationTargets } = load();
+            const projectRoot = makeProjectRoot();
+            for (const agent of ['copilot', 'codex', 'claude-code', 'opencode', 'antigravity']) {
+                const targets = planInitMutationTargets({ cwd: projectRoot, agent, bundles: [] });
+                expect(targets).not.toContain(path_1.default.join(projectRoot, '.cursor', 'rules', 'awm.mdc'));
+            }
+        });
         it('ignores an extension named in the profile that no longer resolves to a known bundle', () => {
             const { planInitMutationTargets, providerFor } = load();
             const projectRoot = makeProjectRoot();
@@ -212,6 +264,15 @@ describe('planInitMutationTargets', () => {
                 expect(targets).toContain(providerFor(agent).skill.global);
             }
         });
+        it('Gap C — adds no global skills-directory target for an agent whose skill.global is null (copilot), and does not crash', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            expect(providerFor('copilot').skill.global).toBeNull();
+            const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'copilot', bundles: [] });
+            // No null ever lands in the returned target list, and nothing crashes
+            // trying to path.join/backup a null skills directory.
+            expect(targets).not.toContain(null);
+            expect(targets.every((t) => typeof t === 'string')).toBe(true);
+        });
         it('the skills-directory target covers orphaned entries repairGlobalSkills would mutate, not just bundle-derived subpaths', () => {
             // Regression guard for the logic gap: before the fix, only
             // bundle-DERIVED skill paths (e.g. .../skills/using-awm) were
@@ -225,6 +286,8 @@ describe('planInitMutationTargets', () => {
             const bundles = [bundle('dev-core', 'baseline', ['using-awm'])];
             const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'claude-code', bundles });
             const skillsDir = providerFor('claude-code').skill.global;
+            if (skillsDir === null)
+                throw new Error('claude-code skill.global must not be null');
             expect(targets).toContain(skillsDir);
             // Sanity: the orphan path itself is a child of the now-covered dir,
             // even though it is never separately enumerated.

package/dist/tests/core/init/provider-facts.test.js

@@ -74,6 +74,22 @@ describe('gatherProviderFacts / assertClaudeBaselinePreserved', () => {
         const after = gatherProviderFacts('claude-code');
         expect(before.hash).not.toBe(after.hash);
     });
+    it('Gap C — gatherProviderFacts skips a null skill.global (copilot) cleanly instead of crashing', () => {
+        const { gatherProviderFacts } = require('../../../src/core/init/provider-facts');
+        const { providerFor } = require('../../../src/providers');
+        expect(providerFor('copilot').skill.global).toBeNull();
+        const { assertClaudeBaselinePreserved } = require('../../../src/core/init/provider-facts');
+        const facts = gatherProviderFacts('copilot');
+        // providerManagedPaths guards `provider.skill.global !== null` (and every
+        // other managed path copilot lacks: no hooks, no global injection, no
+        // workflow/agent config) before adding anything — copilot manages NOTHING
+        // at the machine level, so the inspected path list is empty, and the call
+        // itself must not throw.
+        expect(facts.paths).toEqual([]);
+        expect(typeof facts.hash).toBe('string');
+        // Two snapshots of the same (empty) state are still identical/no-throw.
+        expect(() => assertClaudeBaselinePreserved(facts, facts)).not.toThrow();
+    });
     it('throws a distinct message when comparing facts for mismatched agents', () => {
         const { gatherProviderFacts, assertClaudeBaselinePreserved } = require('../../../src/core/init/provider-facts');
         const claude = gatherProviderFacts('claude-code');

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

@@ -389,6 +389,17 @@ describe('stepGlobalSkillsRepair', () => {
         expect(r.action).toBe('applied');
         expect(a.repairGlobalSkills).toHaveBeenCalledWith((0, providers_1.providerFor)('opencode').skill.global, expect.any(Array));
     });
+    it('Gap C — skips cleanly for an agent whose skill.global is null (copilot), even with broken links reported', () => {
+        const a = spies();
+        expect((0, providers_1.providerFor)('copilot').skill.global).toBeNull();
+        const m = machine();
+        // Broken-count is nonzero, so the ONLY thing that can make this skip is the
+        // null-global-dir guard itself, not the "nothing broken" early return above.
+        m.globalSkills = { valid: [], repairable: ['b'], dead: ['c'] };
+        const r = (0, steps_1.stepGlobalSkillsRepair)(deps({ machine: m, project: null }, a, { agent: 'copilot' }));
+        expect(r.action).toBe('skipped');
+        expect(a.repairGlobalSkills).not.toHaveBeenCalled();
+    });
 });
 describe('stepConstitutionInjection (#6)', () => {
     it('injects for a config-instructions agent when CONSTITUTION.md is present', () => {
@@ -464,4 +475,30 @@ describe('stepContextInjection', () => {
         expect(r.action).toBe('applied');
         expect(a.installContext).toHaveBeenCalledWith(expect.objectContaining({ agent: 'codex', scope: 'global' }));
     });
+    it('installs Copilot context at local scope with projectRoot (no global AGENTS.md-equivalent)', () => {
+        const a = spies();
+        a.contextStatus.mockReturnValue('absent');
+        const r = (0, steps_1.stepContextInjection)(deps({ machine: machine(), project: null }, a, { agent: 'copilot', cwd: '/repo' }));
+        expect(r.action).toBe('applied');
+        expect(a.installContext).toHaveBeenCalledWith(expect.objectContaining({ agent: 'copilot', scope: 'local', projectRoot: '/repo' }));
+    });
+    it('regression: uses the discovered project root, not raw cwd, when awm init runs from a subdirectory (R4 QA blocker 2b)', () => {
+        // mutation-targets.ts's planInitMutationTargets computes its local-scope backup
+        // target via findProjectRoot(cwd), which walks UP from cwd to the real project
+        // root. If this step passed raw d.cwd as projectRoot instead, a run from a
+        // subdirectory would write to <cwd>/AGENTS.md while the backup session snapshotted
+        // <root>/AGENTS.md — a failed init's rollback would miss the real write entirely.
+        const a = spies();
+        a.contextStatus.mockReturnValue('absent');
+        const r = (0, steps_1.stepContextInjection)(deps({ machine: machine(), project: project({ root: '/repo' }) }, a, { agent: 'copilot', cwd: '/repo/packages/sub' }));
+        expect(r.action).toBe('applied');
+        expect(a.installContext).toHaveBeenCalledWith(expect.objectContaining({ agent: 'copilot', scope: 'local', projectRoot: '/repo' }));
+    });
+    it('falls back to raw cwd when no project was discovered', () => {
+        const a = spies();
+        a.contextStatus.mockReturnValue('absent');
+        const r = (0, steps_1.stepContextInjection)(deps({ machine: machine(), project: null }, a, { agent: 'copilot', cwd: '/nowhere' }));
+        expect(r.action).toBe('applied');
+        expect(a.installContext).toHaveBeenCalledWith(expect.objectContaining({ agent: 'copilot', scope: 'local', projectRoot: '/nowhere' }));
+    });
 });

package/dist/tests/core/install-planner.test.js

@@ -71,6 +71,19 @@ describe('install-planner', () => {
             owners,
         };
     }
+    describe('agentsSharingSkillTarget', () => {
+        it('excludes a candidate that does not support this scope at all, instead of throwing', () => {
+            // Regression: used to call skillTargetDir(candidate, ...) unguarded
+            // inside .filter() — Copilot at 'global' throws (no global skill
+            // dir), which crashed the whole call for every OTHER candidate too.
+            const group = (0, install_planner_1.agentsSharingSkillTarget)('claude-code', ['claude-code', 'copilot'], 'global', tmpWork);
+            expect(group).toEqual(['claude-code']);
+        });
+        it('still finds real shared targets when a non-sharing, scope-unsupported candidate is also present', () => {
+            const group = (0, install_planner_1.agentsSharingSkillTarget)('opencode', ['opencode', 'codex', 'copilot'], 'global', tmpWork);
+            expect(group.sort()).toEqual(['codex', 'opencode']);
+        });
+    });
     describe('planInstall', () => {
         it('deduplicates the OpenCode/Codex physical skill write and reports both owners', () => {
             const plan = (0, install_planner_1.planInstall)({
@@ -105,6 +118,26 @@ describe('install-planner', () => {
             });
             expect(plan.operations[0].owners).toEqual(['codex']); // verifies R13
         });
+        it('does not crash when a provider with no global skill support (Copilot) is merely enabled, not selected', () => {
+            // Regression: assertCompleteSharedGroup's inner `enabled.filter(...)`
+            // used to call physicalTarget() unguarded for every enabled agent,
+            // including ones that don't support this scope at all (Copilot has
+            // no global skill directory — skill.global is null). That threw
+            // inside the filter callback, uncaught, crashing this ENTIRE
+            // install for claude-code even though Copilot has nothing to do
+            // with it — just having Copilot in enabledAgents (e.g. from an
+            // earlier local-scope install) broke every subsequent global
+            // install for every other agent.
+            const plan = (0, install_planner_1.planInstall)({
+                artifacts: [skillArtifact('development-process')],
+                selectedAgents: ['claude-code'],
+                enabledAgents: ['claude-code', 'copilot'],
+                scope: 'global',
+                projectRoot: tmpWork,
+                method: 'symlink',
+            });
+            expect(plan.operations[0].owners).toEqual(['claude-code']);
+        });
         it('returns no operations for an empty artifacts array', () => {
             const plan = (0, install_planner_1.planInstall)({
                 artifacts: [],
@@ -186,6 +219,91 @@ describe('install-planner', () => {
                 method: 'symlink',
             })).toThrow(/physical target already claimed by a different source/);
         });
+        describe('renderer-driven filename computation (Task 4.3)', () => {
+            it('renders the Cursor skill target with a .mdc extension, stripping any pre-existing extension', () => {
+                const plan = (0, install_planner_1.planInstall)({
+                    artifacts: [skillArtifact('development-process')],
+                    selectedAgents: ['cursor'],
+                    enabledAgents: ['cursor'],
+                    scope: 'local',
+                    projectRoot: tmpWork,
+                    method: 'symlink',
+                });
+                expect(plan.operations[0].targetPath).toBe(path_1.default.join(tmpWork, '.cursor', 'rules', 'development-process.mdc'));
+                expect(plan.operations[0].renderer).toBe('cursor-mdc');
+            });
+            it('renders the Copilot skill target with a .instructions.md extension (not .md.instructions.md)', () => {
+                const plan = (0, install_planner_1.planInstall)({
+                    artifacts: [skillArtifact('development-process')],
+                    selectedAgents: ['copilot'],
+                    enabledAgents: ['copilot'],
+                    scope: 'local',
+                    projectRoot: tmpWork,
+                    method: 'symlink',
+                });
+                expect(plan.operations[0].targetPath).toBe(path_1.default.join(tmpWork, '.github', 'instructions', 'development-process.instructions.md'));
+                expect(plan.operations[0].renderer).toBe('copilot-instructions');
+            });
+            it('strips an installName that already carries an extension before appending .instructions.md', () => {
+                const withExtension = {
+                    name: 'development-process',
+                    installName: 'development-process.md',
+                    type: 'skill',
+                    sourcePath: path_1.default.join(tmpWork, 'registry', 'skills', 'development-process'),
+                };
+                const plan = (0, install_planner_1.planInstall)({
+                    artifacts: [withExtension],
+                    selectedAgents: ['copilot'],
+                    enabledAgents: ['copilot'],
+                    scope: 'local',
+                    projectRoot: tmpWork,
+                    method: 'symlink',
+                });
+                expect(path_1.default.basename(plan.operations[0].targetPath)).toBe('development-process.instructions.md');
+            });
+            it('does not truncate an installName with an embedded, non-extension dot (e.g. "v1.2-migration")', () => {
+                // Regression: physicalTarget used to derive the base name via
+                // path.parse(...).name, which strips everything after the LAST
+                // dot — not just a genuine trailing .md extension. A skill
+                // literally named `v1.2-migration` would silently truncate to
+                // `v1`, dropping `2-migration` and risking a collision with any
+                // other skill named `v1`.
+                const dottedName = {
+                    name: 'v1.2-migration',
+                    installName: 'v1.2-migration',
+                    type: 'skill',
+                    sourcePath: path_1.default.join(tmpWork, 'registry', 'skills', 'v1.2-migration'),
+                };
+                const plan = (0, install_planner_1.planInstall)({
+                    artifacts: [dottedName],
+                    selectedAgents: ['cursor'],
+                    enabledAgents: ['cursor'],
+                    scope: 'local',
+                    projectRoot: tmpWork,
+                    method: 'symlink',
+                });
+                expect(path_1.default.basename(plan.operations[0].targetPath)).toBe('v1.2-migration.mdc');
+                expect(path_1.default.basename(plan.operations[0].targetPath)).not.toBe('v1.mdc');
+            });
+            it('still strips a real trailing .md extension for Cursor (not v1.2-migration.md.mdc)', () => {
+                const withMdExtension = {
+                    name: 'using-awm',
+                    installName: 'using-awm.md',
+                    type: 'skill',
+                    sourcePath: path_1.default.join(tmpWork, 'registry', 'skills', 'using-awm'),
+                };
+                const plan = (0, install_planner_1.planInstall)({
+                    artifacts: [withMdExtension],
+                    selectedAgents: ['cursor'],
+                    enabledAgents: ['cursor'],
+                    scope: 'local',
+                    projectRoot: tmpWork,
+                    method: 'symlink',
+                });
+                expect(path_1.default.basename(plan.operations[0].targetPath)).toBe('using-awm.mdc');
+                expect(path_1.default.basename(plan.operations[0].targetPath)).not.toBe('using-awm.md.mdc');
+            });
+        });
     });
     describe('planRemoval', () => {
         it('retains a target while a non-selected enabled owner remains', () => {

package/dist/tests/core/install-transaction.test.js

@@ -198,6 +198,115 @@ describe('applyInstallPlan', () => {
         });
     });
 });
+describe('defaultTransactionDeps — cursor-mdc / copilot-instructions renderers (Task 4.3)', () => {
+    // Both renderers are always 'skill'-type: sourcePath is the skill's
+    // DIRECTORY (install-transaction.ts's readSkillMdSource), matching how
+    // discovery.ts/bundle-install.ts set ArtifactIntent.sourcePath for
+    // skills — mirrors the shape makeOp() already assumes for 'link' skills.
+    function makeSkillSource(description, body) {
+        const dir = fs_1.default.mkdtempSync(path_1.default.join(tmpWork, 'skill-source-'));
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'SKILL.md'), `---\nname: sample-skill\ndescription: ${description}\n---\n\n${body}\n`);
+        return dir;
+    }
+    it('renders a real Cursor .mdc file through the full validate/stage/replace/verify pipeline', () => {
+        const sourceDir = makeSkillSource('A sample skill', 'Body content for the skill.');
+        const targetPath = path_1.default.join(tmpWork, 'sample-skill.mdc');
+        const plan = {
+            operations: [makeOp('sample-skill', {
+                    type: 'skill', renderer: 'cursor-mdc', output: 'cursor-mdc',
+                    sourcePath: sourceDir, targetPath,
+                })],
+            records: [],
+            reports: [{ owner: 'cursor', targetPath, action: 'install' }],
+        };
+        const summary = (0, install_transaction_1.applyInstallPlan)(plan);
+        expect(summary.modifiedFiles).toEqual([targetPath]);
+        const content = fs_1.default.readFileSync(targetPath, 'utf8');
+        expect(content).toContain('description: A sample skill');
+        expect(content).toContain('alwaysApply: false');
+        expect(content).toContain('Body content for the skill.');
+    });
+    it('renders a real Copilot .instructions.md file through the full validate/stage/replace/verify pipeline', () => {
+        const sourceDir = makeSkillSource('A sample skill', 'Body content for the skill.');
+        const targetPath = path_1.default.join(tmpWork, 'sample-skill.instructions.md');
+        const plan = {
+            operations: [makeOp('sample-skill', {
+                    type: 'skill', renderer: 'copilot-instructions', output: 'copilot-instructions',
+                    sourcePath: sourceDir, targetPath,
+                })],
+            records: [],
+            reports: [{ owner: 'copilot', targetPath, action: 'install' }],
+        };
+        const summary = (0, install_transaction_1.applyInstallPlan)(plan);
+        expect(summary.modifiedFiles).toEqual([targetPath]);
+        const content = fs_1.default.readFileSync(targetPath, 'utf8');
+        expect(content).toContain('applyTo: "**"');
+        expect(content).toContain('Body content for the skill.');
+    });
+    it('validate rejects a malformed skill source (missing description) before any backup/replace happens', () => {
+        const dir = fs_1.default.mkdtempSync(path_1.default.join(tmpWork, 'skill-source-'));
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'SKILL.md'), '---\nname: broken\n---\nBody with no description field.');
+        const targetPath = path_1.default.join(tmpWork, 'broken.mdc');
+        fs_1.default.writeFileSync(targetPath, 'pre-existing content');
+        const plan = {
+            operations: [makeOp('broken', {
+                    type: 'skill', renderer: 'cursor-mdc', output: 'cursor-mdc',
+                    sourcePath: dir, targetPath,
+                })],
+            records: [],
+            reports: [{ owner: 'cursor', targetPath, action: 'install' }],
+        };
+        expect(() => (0, install_transaction_1.applyInstallPlan)(plan)).toThrow();
+        // No backup/replace should have touched the pre-existing target.
+        expect(fs_1.default.readFileSync(targetPath, 'utf8')).toBe('pre-existing content');
+    });
+    it('verify rejects a corrupt/malformed staged .mdc (mirrors the codex-agent-toml malformed-verify case)', () => {
+        const sourceDir = makeSkillSource('A sample skill', 'Body content.');
+        const targetPath = path_1.default.join(tmpWork, 'corrupt.mdc');
+        const plan = {
+            operations: [makeOp('corrupt', {
+                    type: 'skill', renderer: 'cursor-mdc', output: 'cursor-mdc',
+                    sourcePath: sourceDir, targetPath,
+                })],
+            records: [],
+            reports: [{ owner: 'cursor', targetPath, action: 'install' }],
+        };
+        const deps = {
+            ...(0, install_transaction_1.defaultTransactionDeps)(),
+            stage(op) {
+                const parent = path_1.default.dirname(op.targetPath);
+                fs_1.default.mkdirSync(parent, { recursive: true });
+                const staged = path_1.default.join(parent, `.${path_1.default.basename(op.targetPath)}.corrupt-test.staged`);
+                fs_1.default.writeFileSync(staged, 'not a valid rendered .mdc file at all');
+                return staged;
+            },
+        };
+        expect(() => (0, install_transaction_1.applyInstallPlan)(plan, deps)).toThrow('does not look like rendered Cursor .mdc');
+    });
+    it('verify rejects a corrupt/malformed staged .instructions.md', () => {
+        const sourceDir = makeSkillSource('A sample skill', 'Body content.');
+        const targetPath = path_1.default.join(tmpWork, 'corrupt.instructions.md');
+        const plan = {
+            operations: [makeOp('corrupt', {
+                    type: 'skill', renderer: 'copilot-instructions', output: 'copilot-instructions',
+                    sourcePath: sourceDir, targetPath,
+                })],
+            records: [],
+            reports: [{ owner: 'copilot', targetPath, action: 'install' }],
+        };
+        const deps = {
+            ...(0, install_transaction_1.defaultTransactionDeps)(),
+            stage(op) {
+                const parent = path_1.default.dirname(op.targetPath);
+                fs_1.default.mkdirSync(parent, { recursive: true });
+                const staged = path_1.default.join(parent, `.${path_1.default.basename(op.targetPath)}.corrupt-test.staged`);
+                fs_1.default.writeFileSync(staged, 'not a valid rendered instructions file at all');
+                return staged;
+            },
+        };
+        expect(() => (0, install_transaction_1.applyInstallPlan)(plan, deps)).toThrow('does not look like rendered Copilot instructions');
+    });
+});
 describe('beginBackupSession / restoreBackup', () => {
     it('backs up existing targets before mutation and restores them on rollback', () => {
         const fileA = path_1.default.join(tmpWork, 'a.json');

package/dist/tests/core/provider-artifacts.test.js

@@ -61,4 +61,15 @@ describe('scanLegacyArtifacts', () => {
         expect(legacyRemove).not.toHaveBeenCalledWith(agentPath);
         expect(fs_1.default.existsSync(agentPath)).toBe(true);
     });
+    it('Gap C — an agent with a null global skill dir (copilot) at global scope skips cleanly instead of crashing', () => {
+        // Copilot's skill.global is null (no user-level skill discovery mechanism —
+        // providers/index.ts) and its skill renderer is 'copilot-instructions', not
+        // 'link', so scanLegacyArtifacts's `dir === null` guard (config[scope]) is
+        // the same defensive shape this task's null-skip audit covers for the other
+        // 4 files. Proves the call is a clean no-op for copilot at 'global' scope —
+        // no crash, nothing listed — rather than throwing on a null target dir.
+        expect(() => (0, provider_artifacts_1.scanLegacyArtifacts)(['copilot'], 'global')).not.toThrow();
+        const listed = (0, provider_artifacts_1.scanLegacyArtifacts)(['copilot'], 'global');
+        expect(listed).toEqual([]);
+    });
 });

package/dist/tests/core/renderers/copilot-instructions.test.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const copilot_instructions_1 = require("../../../src/core/renderers/copilot-instructions");
+// Real SKILL.md frontmatter shape (mirrors skills/using-awm/SKILL.md).
+const skill = `---
+name: using-awm
+version: "1.2.3"
+description: Use when starting any development conversation
+---
+
+# Using AWM
+
+MUST invoke skills per the tiered policy.
+`;
+it('renders Copilot .instructions.md frontmatter with applyTo: "**" and the body verbatim', () => {
+    expect((0, copilot_instructions_1.renderCopilotInstructions)(skill)).toBe(`---
+applyTo: "**"
+---
+
+# Using AWM
+
+MUST invoke skills per the tiered policy.
+`);
+});
+it('embeds the body content even when the description contains a colon (description is not itself rendered)', () => {
+    const source = `---
+name: colon-skill
+description: Use when starting: development conversation
+---
+
+Body content survives.
+`;
+    const rendered = (0, copilot_instructions_1.renderCopilotInstructions)(source);
+    expect(rendered).toBe(`---
+applyTo: "**"
+---
+
+Body content survives.
+`);
+});
+it.each([
+    ['no frontmatter at all', 'just a plain markdown body'],
+    ['missing description', '---\nname: ok\n---\nBody.'],
+    ['empty body', '---\nname: ok\ndescription: fine\n---\n'],
+])('rejects invalid skill sources before rendering (%s)', (_label, source) => {
+    expect(() => (0, copilot_instructions_1.renderCopilotInstructions)(source)).toThrow();
+});

package/dist/tests/core/renderers/cursor-mdc.test.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cursor_mdc_1 = require("../../../src/core/renderers/cursor-mdc");
+// Real SKILL.md frontmatter shape (mirrors skills/using-awm/SKILL.md).
+const skill = `---
+name: using-awm
+version: "1.2.3"
+description: Use when starting any development conversation
+---
+
+# Using AWM
+
+MUST invoke skills per the tiered policy.
+`;
+it('renders Cursor .mdc frontmatter as an Agent Requested rule (description + blank globs + alwaysApply: false)', () => {
+    expect((0, cursor_mdc_1.renderCursorMdc)(skill)).toBe(`---
+description: Use when starting any development conversation
+globs:
+alwaysApply: false
+---
+
+# Using AWM
+
+MUST invoke skills per the tiered policy.
+`);
+});
+it('quotes a description containing a colon so it does not break YAML parsing', () => {
+    const source = `---
+name: colon-skill
+description: Use when starting: development conversation
+---
+
+Body content.
+`;
+    const rendered = (0, cursor_mdc_1.renderCursorMdc)(source);
+    expect(rendered).toContain('description: "Use when starting: development conversation"');
+    // Sanity: the naive unquoted form would be invalid YAML (parsed as a
+    // nested mapping key) — this asserts we never emit it.
+    expect(rendered).not.toContain('description: Use when starting: development conversation');
+});
+it('quotes a description starting with a YAML-special character', () => {
+    const source = `---
+name: special-skill
+description: "*starred description"
+---
+
+Body content.
+`;
+    const rendered = (0, cursor_mdc_1.renderCursorMdc)(source);
+    expect(rendered).toContain('description: "*starred description"');
+});
+it('throws rather than embedding a literal block-scalar indicator as the description', () => {
+    // Regression: a YAML block scalar (`description: >-` / `|-`) means the
+    // real text lives on the FOLLOWING indented lines, not on this line —
+    // the original code took the bare indicator itself as the description,
+    // which would have rendered the literal string ">-" into the .mdc file.
+    const source = `---
+name: block-skill
+description: >-
+  This description spans
+  multiple lines.
+---
+
+Body content.
+`;
+    expect(() => (0, cursor_mdc_1.renderCursorMdc)(source)).toThrow('non-empty description');
+});
+it('quotes a description containing a mid-string " #" (starts a YAML comment, truncating the rest)', () => {
+    // Regression: the original YAML_UNSAFE regex only caught `#` at the START
+    // of the string — a `#` preceded by whitespace ANYWHERE in a plain scalar
+    // also starts a comment. Unquoted, "Use this #important skill" would
+    // render as YAML that silently truncates to "Use this".
+    const source = `---
+name: hash-skill
+description: Use this #important skill
+---
+
+Body content.
+`;
+    const rendered = (0, cursor_mdc_1.renderCursorMdc)(source);
+    expect(rendered).toContain('description: "Use this #important skill"');
+    expect(rendered).not.toContain('description: Use this #important skill');
+});
+it('quotes a description containing an embedded null byte / control character instead of emitting it raw', () => {
+    // Regression: an embedded control/null byte is invalid in a YAML plain
+    // scalar regardless of position — the original code's YAML_UNSAFE regex
+    // needed the [\x00-\x1f\x7f] class to catch this; without it, a null byte
+    // would have been emitted unquoted straight into the frontmatter.
+    const nul = String.fromCharCode(0);
+    const source = `---
+name: nul-skill
+description: Use this${nul}description
+---
+
+Body content.
+`;
+    const rendered = (0, cursor_mdc_1.renderCursorMdc)(source);
+    // JSON.stringify \u-escapes control bytes — the rendered frontmatter must
+    // carry the escaped, quoted form, never the literal raw byte.
+    expect(rendered).toContain(`description: ${JSON.stringify(`Use this${nul}description`)}`);
+    expect(rendered).not.toContain(`description: Use this${nul}description\n`);
+});
+it('escapes an embedded DEL (0x7F) byte, which JSON.stringify alone does not escape', () => {
+    // Regression: JSON.stringify \u-escapes \x00-\x1F but NOT \x7F (DEL isn't in
+    // JSON's own required-escape set), so quoting via JSON.stringify alone would
+    // leave a raw, non-conformant DEL byte inside the YAML double-quoted scalar.
+    // yamlString must escape it itself after JSON.stringify runs.
+    const del = String.fromCharCode(0x7f);
+    const source = `---
+name: del-skill
+description: Use this${del}description
+---
+
+Body content.
+`;
+    const rendered = (0, cursor_mdc_1.renderCursorMdc)(source);
+    expect(rendered).toContain('description: "Use this\\u007fdescription"');
+    expect(rendered).not.toContain(`description: Use this${del}description\n`);
+    expect(rendered).not.toMatch(new RegExp(`description: "[^"]*${del}`));
+});
+it('leaves a plain description unquoted', () => {
+    const source = `---
+name: plain-skill
+description: A perfectly ordinary description
+---
+
+Body content.
+`;
+    expect((0, cursor_mdc_1.renderCursorMdc)(source)).toContain('description: A perfectly ordinary description');
+});
+it.each([
+    ['no frontmatter at all', 'just a plain markdown body'],
+    ['missing description', '---\nname: ok\n---\nBody.'],
+    ['empty body', '---\nname: ok\ndescription: fine\n---\n'],
+])('rejects invalid skill sources before rendering (%s)', (_label, source) => {
+    expect(() => (0, cursor_mdc_1.renderCursorMdc)(source)).toThrow();
+});

package/dist/tests/core/skill-integrity.test.js

@@ -98,6 +98,24 @@ describe('reconcileAllSkillLinks (#4 — awm update, all providers)', () => {
             fs_1.default.rmSync(home, { recursive: true, force: true });
         }
     });
+    it('Gap C — skips an agent whose skill.global is null (copilot) cleanly instead of crashing', () => {
+        const home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-home-'));
+        const prevHome = process.env.HOME;
+        process.env.HOME = home;
+        try {
+            jest.resetModules();
+            const { reconcileAllSkillLinks } = require('../../src/core/skill-integrity');
+            const { providerFor } = require('../../src/providers');
+            expect(providerFor('copilot').skill.global).toBeNull();
+            const res = reconcileAllSkillLinks([path_1.default.join(home, 'no-registry')]);
+            expect(() => reconcileAllSkillLinks([path_1.default.join(home, 'no-registry')])).not.toThrow();
+            expect(res.find((r) => r.agent === 'copilot')).toBeFalsy();
+        }
+        finally {
+            process.env.HOME = prevHome;
+            fs_1.default.rmSync(home, { recursive: true, force: true });
+        }
+    });
 });
 describe('repairGlobalSkills', () => {
     it('re-links repairable to registry content dir and prunes dead; valid untouched; idempotent', () => {