agentic-workflow-manager 3.1.0 → 3.2.1

package/dist/tests/core/context/strategies/codex-agents.test.js

@@ -0,0 +1,185 @@
+"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 os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const codex_agents_1 = require("../../../../src/core/context/strategies/codex-agents");
+const provider_1 = require("../../../../src/core/context/provider");
+describe('CodexAgentsStrategy', () => {
+    let tmpHome;
+    let tmpWork;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-codex-home-'));
+        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-codex-work-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+    });
+    afterEach(() => {
+        if (originalHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = originalHome;
+        if (originalAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalAwmHome;
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        fs_1.default.rmSync(tmpWork, { recursive: true, force: true });
+        jest.restoreAllMocks();
+    });
+    it('injects global AWM bootstrap without changing user rules', () => {
+        fs_1.default.mkdirSync(path_1.default.join(tmpHome, '.codex'), { recursive: true });
+        const file = path_1.default.join(tmpHome, '.codex/AGENTS.md');
+        fs_1.default.writeFileSync(file, '# Personal\n\nDo not delete.\n');
+        const result = new codex_agents_1.CodexAgentsStrategy().injectGlobal({
+            markdown: '# AWM\n\nUse `development-process`.',
+        });
+        expect(result).toBe('injected');
+        const written = fs_1.default.readFileSync(file, 'utf8');
+        expect(written).toContain('# Personal\n\nDo not delete.\n');
+        expect(written).toContain('Use `development-process`.');
+    });
+    it('creates the global file and returns unchanged on an idempotent repeat', () => {
+        const strategy = new codex_agents_1.CodexAgentsStrategy();
+        const context = { markdown: '# AWM\n\nBootstrap.' };
+        expect(strategy.injectGlobal(context)).toBe('injected');
+        expect(strategy.injectGlobal(context)).toBe('unchanged');
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.codex/AGENTS.md'))).toBe(true);
+    });
+    it('uses HOME at call time', () => {
+        const firstHome = tmpHome;
+        const secondHome = path_1.default.join(tmpWork, 'second-home');
+        const strategy = new codex_agents_1.CodexAgentsStrategy();
+        strategy.injectGlobal({ markdown: 'first' });
+        process.env.HOME = secondHome;
+        strategy.injectGlobal({ markdown: 'second' });
+        expect(fs_1.default.readFileSync(path_1.default.join(firstHome, '.codex/AGENTS.md'), 'utf8')).toContain('first');
+        expect(fs_1.default.readFileSync(path_1.default.join(secondHome, '.codex/AGENTS.md'), 'utf8')).toContain('second');
+    });
+    it('updates only its global managed block', () => {
+        const file = path_1.default.join(tmpHome, '.codex/AGENTS.md');
+        fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+        fs_1.default.writeFileSync(file, 'before\n');
+        const strategy = new codex_agents_1.CodexAgentsStrategy();
+        strategy.injectGlobal({ markdown: 'old' });
+        fs_1.default.appendFileSync(file, 'after\n');
+        strategy.injectGlobal({ markdown: 'new' });
+        expect(fs_1.default.readFileSync(file, 'utf8')).toBe('before\n\n<!-- AWM:START -->\n<!-- AWM:BOUNDARY prefix=1 suffix=1 -->\nnew\n<!-- AWM:END -->\nafter\n');
+    });
+    it('fails on ambiguous global markers without changing the file', () => {
+        const file = path_1.default.join(tmpHome, '.codex/AGENTS.md');
+        fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+        const ambiguous = '<!-- AWM:START -->\nuser';
+        fs_1.default.writeFileSync(file, ambiguous);
+        expect(() => new codex_agents_1.CodexAgentsStrategy().injectGlobal({ markdown: 'new' })).toThrow('unmatched');
+        expect(fs_1.default.readFileSync(file, 'utf8')).toBe(ambiguous);
+    });
+    it('rejects inline marker examples without changing the global file', () => {
+        const file = path_1.default.join(tmpHome, '.codex/AGENTS.md');
+        fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+        const ambiguous = '`<!-- AWM:START -->` example and `<!-- AWM:END -->` example';
+        fs_1.default.writeFileSync(file, ambiguous);
+        expect(() => new codex_agents_1.CodexAgentsStrategy().injectGlobal({ markdown: 'new' })).toThrow('standalone');
+        expect(fs_1.default.readFileSync(file, 'utf8')).toBe(ambiguous);
+    });
+    it.each([
+        '<!-- AWM:BOUNDARY prefix=9 suffix=1 -->',
+        '<!-- AWM:BOUNDARY prefix=1 suffix=2 -->',
+        '<!-- AWM:BOUNDARY prefix=1 suffix=1 -->\n<!-- AWM:BOUNDARY prefix=0 suffix=1 -->',
+        'owned\n<!-- AWM:BOUNDARY prefix=1 suffix=1 -->',
+        '<!-- AWM:BOUNDARY prefix=1',
+        'inline <!-- AWM:BOUNDARY prefix=1 suffix=1 -->',
+    ])('rejects ambiguous boundary metadata without changing the file: %j', (metadata) => {
+        const file = path_1.default.join(tmpHome, '.codex/AGENTS.md');
+        const materialized = path_1.default.join(tmpWork, 'awm-context.md');
+        const markdown = '# AWM\n\nExpected.';
+        const original = `<!-- AWM:START -->\n${metadata}\nowned\n<!-- AWM:END -->`;
+        fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+        fs_1.default.writeFileSync(file, original);
+        fs_1.default.writeFileSync(materialized, markdown);
+        const provider = codexProvider(file);
+        const input = injectionInput(materialized, markdown);
+        const strategy = new codex_agents_1.CodexAgentsStrategy();
+        expect(() => strategy.inject(input, provider)).toThrow('malformed AWM boundary metadata');
+        expect(() => strategy.remove(input, provider)).toThrow('malformed AWM boundary metadata');
+        expect(() => strategy.status(input, provider)).toThrow('malformed AWM boundary metadata');
+        expect(fs_1.default.readFileSync(file, 'utf8')).toBe(original);
+    });
+    it('injects project constitution guidance without owning the whole AGENTS.md', () => {
+        const project = path_1.default.join(tmpWork, 'repo');
+        fs_1.default.mkdirSync(project, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(project, 'CONSTITUTION.md'), '# Rules\n');
+        fs_1.default.writeFileSync(path_1.default.join(project, 'AGENTS.md'), '# Repo-owned rules\n');
+        const result = new codex_agents_1.CodexAgentsStrategy().injectProject(project);
+        expect(result).toBe('injected');
+        const written = fs_1.default.readFileSync(path_1.default.join(project, 'AGENTS.md'), 'utf8');
+        expect(written).toContain('# Repo-owned rules');
+        expect(written).toContain('Read and obey `CONSTITUTION.md` before work');
+    });
+    it('creates project guidance even before CONSTITUTION.md exists and is idempotent', () => {
+        const project = path_1.default.join(tmpWork, 'repo');
+        fs_1.default.mkdirSync(project, { recursive: true });
+        const strategy = new codex_agents_1.CodexAgentsStrategy();
+        expect(strategy.injectProject(project)).toBe('injected');
+        expect(strategy.injectProject(project)).toBe('unchanged');
+        expect(fs_1.default.readFileSync(path_1.default.join(project, 'AGENTS.md'), 'utf8'))
+            .toContain('when that file exists');
+    });
+    it('implements global status and remove while preserving user bytes', () => {
+        const file = path_1.default.join(tmpHome, '.codex/AGENTS.md');
+        const materialized = path_1.default.join(tmpWork, 'awm-context.md');
+        const markdown = '# AWM\n\nExpected.';
+        fs_1.default.writeFileSync(materialized, markdown);
+        const provider = codexProvider(file);
+        const input = injectionInput(materialized, markdown);
+        const strategy = new codex_agents_1.CodexAgentsStrategy();
+        expect(strategy.status(input, provider)).toBe('absent');
+        expect(strategy.inject(input, provider)).toBe('injected');
+        expect(strategy.status(input, provider)).toBe('injected');
+        const staleInput = {
+            ...input,
+            ref: { ...input.ref, contentHash: (0, provider_1.sha256)('# AWM\n\nUpdated.') },
+        };
+        expect(strategy.status(staleInput, provider)).toBe('stale');
+        fs_1.default.appendFileSync(file, 'user suffix\n');
+        strategy.remove(input, provider);
+        expect(fs_1.default.readFileSync(file, 'utf8')).toBe('user suffix\n');
+        expect(strategy.status(input, provider)).toBe('absent');
+    });
+    it('validates public inputs and never writes outside the configured roots', () => {
+        const strategy = new codex_agents_1.CodexAgentsStrategy();
+        expect(() => strategy.injectGlobal({ markdown: '' })).toThrow('markdown');
+        expect(() => strategy.injectGlobal(null)).toThrow('context');
+        expect(() => strategy.injectProject('')).toThrow('projectRoot');
+        const open = jest.spyOn(fs_1.default, 'openSync');
+        strategy.injectGlobal({ markdown: 'safe' });
+        strategy.injectProject(path_1.default.join(tmpWork, 'safe-project'));
+        const opened = open.mock.calls.map((call) => String(call[0]));
+        expect(opened.every((file) => file.startsWith(tmpHome) || file.startsWith(tmpWork))).toBe(true);
+    });
+});
+function codexProvider(globalPath) {
+    return {
+        label: 'Codex',
+        skill: { global: '', local: '', renderer: 'link' },
+        workflow: null,
+        agent: null,
+        injection: { type: 'managed-agents-md', globalPath, localFile: 'AGENTS.md' },
+    };
+}
+function injectionInput(absPath, markdown) {
+    return {
+        ref: { absPath, scope: 'global', contentHash: (0, provider_1.sha256)(markdown) },
+        registryRoot: '/registry',
+        installMethod: 'copy',
+        agent: 'codex',
+        scope: 'global',
+    };
+}

package/dist/tests/core/context/strategies/config-instructions.test.js

@@ -18,7 +18,7 @@ function setup(opencodeJson) {
     fs_1.default.mkdirSync(path_1.default.dirname(absPath), { recursive: true });
     fs_1.default.writeFileSync(absPath, 'CTX');
     const provider = {
-        label: 'OpenCode', skill: { global: '', local: '' }, workflow: null, agent: null,
+        label: 'OpenCode', skill: { global: '', local: '', renderer: 'link' }, workflow: null, agent: null,
         injection: { type: 'config-instructions', configPath, field: 'instructions' },
     };
     const input = {

package/dist/tests/core/diagnostics/checks.test.js

@@ -184,6 +184,25 @@ describe('machineChecks — global skill integrity', () => {
         expect(row?.remedy).toEqual({ kind: 'command', value: 'awm init' });
     });
 });
+describe('computeProviderOverall (Task 9)', () => {
+    const CHECK_IDS = ['binary.version', 'skills.global', 'agents.native', 'hook.trust', 'context.global'];
+    function providerWith(states) {
+        return {
+            id: 'codex',
+            label: 'Codex',
+            checks: states.map((state, i) => ({ id: CHECK_IDS[i % CHECK_IDS.length], state })),
+        };
+    }
+    it('healthy when every check is in an ok/pending/warn state', () => {
+        expect((0, checks_1.computeProviderOverall)([providerWith(['supported', 'healthy', 'shared', 'pending-trust', 'stale'])])).toBe('healthy');
+    });
+    it('degrades on a single broken/missing/absent/unsupported/conflict check', () => {
+        expect((0, checks_1.computeProviderOverall)([providerWith(['supported', 'absent'])])).toBe('degraded');
+    });
+    it('healthy for an empty provider list', () => {
+        expect((0, checks_1.computeProviderOverall)([])).toBe('healthy');
+    });
+});
 describe('machine.context.<agent> checks', () => {
     function machineWith(contextInjection) {
         return { ...healthyMachine(), contextInjection };

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

@@ -75,6 +75,34 @@ describe('gatherContext', () => {
         expect(ctx.machine.devCore.present).toBe(true);
         expect(ctx.machine.devCore.brokenLinks).toContain('brainstorming');
     });
+    // Regression coverage for the second BLOCKER-adjacent bug found while
+    // building the real Codex+OpenCode coexistence E2E test: OpenCode and
+    // Codex share ~/.agents/skills, but agent-type artifacts are per-agent
+    // (never shared, R12/R13). Before this fix, devCorePresent only looked
+    // at the skill link, so once OpenCode's own init had already linked the
+    // shared skill, Codex's gatherContext wrongly reported devCore as fully
+    // present/no-broken-links even though Codex's own native .toml had never
+    // been rendered — causing stepDevCore to skip forever.
+    it('machine: devCore surfaces a missing per-agent artifact even when the shared skill link is already present', () => {
+        const bundleWithAgent = () => ({
+            name: 'dev-core', description: '', version: '1.0.0', scope: 'baseline', visibility: 'public',
+            dependsOn: [], skills: [{ name: 'development-process', onSignal: false }],
+            workflows: [], agents: ['development-process'],
+        });
+        // Simulate OpenCode having already linked the shared ~/.agents/skills dir.
+        const sharedSkillsDir = path_1.default.join(tmpHome, '.agents', 'skills');
+        fs_1.default.mkdirSync(sharedSkillsDir, { recursive: true });
+        const target = path_1.default.join(tmpHome, 'targets', 'development-process');
+        fs_1.default.mkdirSync(target, { recursive: true });
+        fs_1.default.symlinkSync(target, path_1.default.join(sharedSkillsDir, 'development-process'), 'dir');
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const ctx = gatherContext({ cwd: tmpHome, bundles: [bundleWithAgent()], agent: 'codex' });
+        // The skill itself is linked (shared with OpenCode)...
+        expect(ctx.machine.devCore.present).toBe(true);
+        // ...but Codex's own native agent artifact was never installed, so it
+        // must surface as a broken/missing link — NOT a clean, skippable state.
+        expect(ctx.machine.devCore.brokenLinks).toContain('development-process.toml');
+    });
     it('machine: ambient wanted read from ~/.awm/config.json, installed reflects links', () => {
         fs_1.default.mkdirSync(path_1.default.join(tmpHome, '.awm'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(tmpHome, '.awm', 'config.json'), JSON.stringify({ ambient: ['personal-notion'] }));
@@ -144,6 +172,52 @@ describe('gatherContext', () => {
         expect(ctx.project.context).toEqual({ present: true, file: 'CLAUDE.md' });
     });
 });
+describe('gatherContext — providers matrix (Task 9)', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-doctor-providers-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        if (originalHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = originalHome;
+        if (originalAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalAwmHome;
+    });
+    function healthySharedSkills() {
+        return { valid: ['development-process'], repairable: [], dead: [] };
+    }
+    it('reports shared skills for both owners without scanning twice', () => {
+        // OpenCode and Codex both read/write ~/.agents/skills (providers/index.ts) —
+        // the physical directory must be scanned once and attributed to both owners.
+        const scan = jest.fn(() => healthySharedSkills());
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const report = gatherContext({ cwd: tmpHome, bundles: [], agents: ['opencode', 'codex'], scanSkills: scan });
+        expect(scan).toHaveBeenCalledTimes(1);
+        expect(report.providers.every((provider) => provider.checks.some((check) => check.state === 'shared'))).toBe(true);
+    });
+    it('marks skills.global healthy (not shared) for a single unshared provider', () => {
+        const scan = jest.fn(() => ({ valid: [], repairable: [], dead: [] }));
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const report = gatherContext({ cwd: tmpHome, bundles: [], agents: ['claude-code'], scanSkills: scan });
+        expect(scan).toHaveBeenCalledTimes(1);
+        const claude = report.providers.find((p) => p.id === 'claude-code');
+        const skillsCheck = claude.checks.find((c) => c.id === 'skills.global');
+        expect(skillsCheck.state).not.toBe('shared');
+        expect(skillsCheck.owners).toBeUndefined();
+    });
+});
 describe('gatherMachine — agnostic skill health (#4)', () => {
     it('classifies the target agent skills dir, not always Claude', () => {
         const home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-home-'));

package/dist/tests/core/diagnostics/provider-checks.test.js

@@ -0,0 +1,252 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// cli/tests/core/diagnostics/provider-checks.test.ts
+//
+// Code-quality review follow-up on commit 8f02a00. Two real, reproduced defects:
+//
+// 1. CRITICAL — agentsNativeCheck/hookTrustCheck/contextGlobalCheck returned
+//    `state: 'unsupported'` to mean "doesn't structurally apply to this
+//    provider" (Antigravity has no agent/hooks/injection config, OpenCode has
+//    no hooks, Claude Code's context.global is covered by its hook). But
+//    'unsupported' is ALSO what binaryVersionCheck uses for a genuine
+//    version-incompatibility failure, and both doctor's glyph logic and
+//    checks.ts's DEGRADING_PROVIDER_STATES treat it as a real failure. A
+//    fully-healthy claude-code-only (or opencode-only, or antigravity-only)
+//    `awm doctor` run could therefore never report `overall: 'healthy'`. Fixed
+//    by having those three functions return `null` (omitted entirely from
+//    `checks[]`) instead of a fabricated 'unsupported' row — this file proves
+//    the fix with realistic, fully-initialized single-provider fixtures, not
+//    just synthetic state-literal inputs.
+//
+// 2. IMPORTANT — skillsGlobalCheck set `state: 'shared'` unconditionally once
+//    a skills directory had more than one owner, even when it had broken/dead
+//    symlinks — masking real breakage behind a green checkmark and never
+//    degrading `overall`. Fixed by checking broken status BEFORE falling back
+//    to 'shared'.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+describe('gatherProviderChecks — realistic fully-healthy single-provider fixtures', () => {
+    let tmpHome;
+    let tmpWork;
+    let originalHome;
+    let originalAwmHome;
+    let writeSpy;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-provider-checks-home-'));
+        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-provider-checks-work-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        jest.resetModules();
+        writeSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    });
+    afterEach(() => {
+        writeSpy.mockRestore();
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        fs_1.default.rmSync(tmpWork, { recursive: true, force: true });
+        if (originalHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = originalHome;
+        if (originalAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalAwmHome;
+    });
+    /** Seeds a registry content root with a baseline bundle carrying a skill
+     *  and (optionally) a canonical agent artifact. Mirrors the fixture in
+     *  tests/integration/codex-provider-isolated.test.ts. */
+    function seedRegistry(root, opts) {
+        if (opts.withHooks) {
+            fs_1.default.mkdirSync(path_1.default.join(root, 'hooks'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(root, 'hooks/session-start'), '#!/bin/sh\necho "{}"\n', { mode: 0o755 });
+            fs_1.default.writeFileSync(path_1.default.join(root, 'hooks/run-hook.cmd'), '#!/bin/sh\nexec sh "$1"\n', { mode: 0o755 });
+        }
+        fs_1.default.mkdirSync(path_1.default.join(root, 'skills/using-awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(root, 'skills/using-awm/SKILL.md'), '---\nname: using-awm\n---\nMUST invoke skills.');
+        fs_1.default.mkdirSync(path_1.default.join(root, 'skills/development-process'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(root, 'skills/development-process/SKILL.md'), '---\nname: development-process\n---\nBody.');
+        const agents = [];
+        if (opts.withAgent) {
+            agents.push('development-process');
+            fs_1.default.mkdirSync(path_1.default.join(root, 'agents'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(root, 'agents/development-process.md'), '---\nname: development-process\ndescription: Orchestrates the dev lifecycle.\n---\nBody.');
+        }
+        fs_1.default.writeFileSync(path_1.default.join(root, 'catalog.json'), JSON.stringify({
+            version: 1,
+            bundles: [{ name: 'dev-core', source: 'bundles/dev-core', version: '1.0.0', scope: 'baseline', visibility: 'public' }],
+        }));
+        fs_1.default.mkdirSync(path_1.default.join(root, 'bundles/dev-core'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(root, 'bundles/dev-core/bundle.json'), JSON.stringify({
+            name: 'dev-core', description: '', version: '1.0.0', scope: 'baseline', visibility: 'public',
+            dependsOn: [], skills: ['development-process'], workflows: [], agents,
+        }));
+        fs_1.default.mkdirSync(path_1.default.join(tmpHome, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpHome, '.awm/registries.json'), JSON.stringify([{ name: 'baseline', remote: 'https://example.invalid/baseline.git' }], null, 2));
+    }
+    it('claude-code-only, fully initialized via a real `awm init`, reports overall: healthy', async () => {
+        seedRegistry(path_1.default.join(tmpHome, '.awm/registries/baseline'), { withAgent: true, withHooks: true });
+        const { runInit } = require('../../../src/commands/init');
+        const code = await runInit({ cwd: tmpWork, yes: true });
+        expect(code).toBeLessThanOrEqual(1);
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const { computeProviderOverall } = require('../../../src/core/diagnostics/checks');
+        const ctx = gatherContext({ cwd: tmpWork, agents: ['claude-code'] });
+        expect(computeProviderOverall(ctx.providers)).toBe('healthy');
+        const claude = ctx.providers[0];
+        // Claude's context.global is deliberately omitted (covered by hook.trust),
+        // not rendered as a fabricated 'unsupported' row.
+        expect(claude.checks.map((c) => c.id)).not.toContain('context.global');
+        expect(claude.checks.every((c) => !['unsupported', 'missing', 'broken', 'absent', 'conflict'].includes(c.state))).toBe(true);
+    });
+    it('opencode-only, fully installed via the real install/injection pipeline, reports overall: healthy', () => {
+        seedRegistry(path_1.default.join(tmpHome, '.awm/registries/baseline'), { withAgent: true, withHooks: false });
+        // OpenCode has no hook config — routed directly through the same real
+        // installBundle/InjectionOrchestrator functions `awm init` itself calls,
+        // rather than through runInit's step orchestration (a separate,
+        // pre-existing gap — stepHook unconditionally attempts a hook install
+        // for every agent, including ones with no hook mechanism at all — is out
+        // of scope for this fix and reported separately).
+        const { installBundle } = require('../../../src/core/bundle-install');
+        const { discoverAllBundles } = require('../../../src/core/bundles');
+        const { contentRoots } = require('../../../src/core/registries');
+        const { InjectionOrchestrator } = require('../../../src/core/context/orchestrator');
+        const bundles = discoverAllBundles();
+        const contentDir = contentRoots()[0];
+        installBundle({ bundleName: 'dev-core', bundles, agents: ['opencode'], method: 'symlink', projectRoot: tmpWork, contentDir });
+        new InjectionOrchestrator().installContext({
+            agent: 'opencode', scope: 'global', registryRoot: contentDir, installMethod: 'symlink', profileExtensions: [],
+        });
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const { computeProviderOverall } = require('../../../src/core/diagnostics/checks');
+        const ctx = gatherContext({ cwd: tmpWork, agents: ['opencode'] });
+        expect(computeProviderOverall(ctx.providers)).toBe('healthy');
+        const opencode = ctx.providers[0];
+        // OpenCode has no hooks — omitted, not a fabricated 'unsupported' row.
+        expect(opencode.checks.map((c) => c.id)).not.toContain('hook.trust');
+    });
+    it('antigravity-only, fully installed via the real install pipeline, reports overall: healthy', () => {
+        seedRegistry(path_1.default.join(tmpHome, '.awm/registries/baseline'), { withAgent: false, withHooks: false });
+        const { installBundle } = require('../../../src/core/bundle-install');
+        const { discoverAllBundles } = require('../../../src/core/bundles');
+        const { contentRoots } = require('../../../src/core/registries');
+        const bundles = discoverAllBundles();
+        installBundle({ bundleName: 'dev-core', bundles, agents: ['antigravity'], method: 'symlink', projectRoot: tmpWork, contentDir: contentRoots()[0] });
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const { computeProviderOverall } = require('../../../src/core/diagnostics/checks');
+        const ctx = gatherContext({ cwd: tmpWork, agents: ['antigravity'] });
+        expect(computeProviderOverall(ctx.providers)).toBe('healthy');
+        const antigravity = ctx.providers[0];
+        // Antigravity has no agent/hooks/injection config at all — all three
+        // checks omitted, not fabricated 'unsupported' rows. Only binary.version
+        // and skills.global structurally apply.
+        expect(antigravity.checks.map((c) => c.id).sort())
+            .toEqual(['binary.version', 'skills.global']);
+    });
+});
+describe('gatherProviderChecks — shared skills.global does not mask broken links', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-provider-checks-shared-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        if (originalHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = originalHome;
+        if (originalAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalAwmHome;
+    });
+    it('reports a degraded (not shared) skills.global state when the shared dir has broken links', () => {
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const { computeProviderOverall } = require('../../../src/core/diagnostics/checks');
+        // OpenCode and Codex share ~/.agents/skills (providers/index.ts). Stub the
+        // scan to report 2 broken/dead links on that shared directory.
+        const scanSkills = jest.fn(() => ({ valid: ['ok-skill'], repairable: ['stale-skill'], dead: ['ghost-skill'] }));
+        const ctx = gatherContext({ cwd: tmpHome, bundles: [], agents: ['opencode', 'codex'], scanSkills });
+        expect(scanSkills).toHaveBeenCalledTimes(1);
+        for (const provider of ctx.providers) {
+            const skillsCheck = provider.checks.find((c) => c.id === 'skills.global');
+            expect(skillsCheck.state).toBe('broken'); // NOT 'shared' — must not mask the breakage
+            expect(skillsCheck.owners).toEqual(['opencode', 'codex']); // still reports the shared ownership
+            expect(skillsCheck.detail).toContain('2 broken links');
+            expect(skillsCheck.remediationCode).toBe('repair-global-skills');
+        }
+        expect(computeProviderOverall(ctx.providers)).toBe('degraded');
+    });
+    it('still reports shared (healthy, non-degrading) when the shared dir has no broken links', () => {
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const { computeProviderOverall } = require('../../../src/core/diagnostics/checks');
+        const scanSkills = jest.fn(() => ({ valid: ['ok-skill'], repairable: [], dead: [] }));
+        const ctx = gatherContext({ cwd: tmpHome, bundles: [], agents: ['opencode', 'codex'], scanSkills });
+        for (const provider of ctx.providers) {
+            const skillsCheck = provider.checks.find((c) => c.id === 'skills.global');
+            expect(skillsCheck.state).toBe('shared');
+        }
+        // Other checks (binary.version missing codex, hook.trust absent, etc.) may
+        // still degrade `overall` on a bare HOME — this test only pins that a
+        // HEALTHY shared skills dir itself reports 'shared', not a false positive.
+        const skillsStates = ctx.providers.map((p) => p.checks.find((c) => c.id === 'skills.global').state);
+        expect(skillsStates).toEqual(['shared', 'shared']);
+    });
+});
+describe('gatherProviderChecks — agents.native reports broken on a malformed Codex .toml', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-provider-checks-broken-agent-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        if (originalHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = originalHome;
+        if (originalAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalAwmHome;
+    });
+    it('reports state: broken and remediationCode: reinstall-native-agents for a hand-edited/truncated .toml', () => {
+        // Codex's agent renderer is 'codex-agent-toml' (providers/index.ts) — its global
+        // dir is ~/.codex/agents. tomlAgentsHealthy (provider-checks.ts) treats a .toml as
+        // broken when it can't be read, or when it's missing the `developer_instructions = `
+        // key that renderCodexAgent (Task 4) always emits — i.e. hand-edited/truncated.
+        const agentsDir = path_1.default.join(tmpHome, '.codex/agents');
+        fs_1.default.mkdirSync(agentsDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(agentsDir, 'development-process.toml'), 'name = "development-process"\n# missing the developer_instructions key entirely\n');
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const scanSkills = jest.fn(() => ({ valid: [], repairable: [], dead: [] }));
+        const ctx = gatherContext({ cwd: tmpHome, bundles: [], agents: ['codex'], scanSkills });
+        const codex = ctx.providers.find((p) => p.id === 'codex');
+        const agentsNative = codex.checks.find((c) => c.id === 'agents.native');
+        expect(agentsNative).toMatchObject({
+            id: 'agents.native',
+            state: 'broken',
+            target: agentsDir,
+            detail: '1 malformed .toml',
+            remediationCode: 'reinstall-native-agents',
+        });
+    });
+});

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

@@ -41,4 +41,24 @@ describe('Executor Engine', () => {
         const dest = path_1.default.join(targetDir, 'does-not-exist');
         expect(() => (0, executor_1.removeArtifact)(dest)).toThrow('Artifact not found');
     });
+    it('never removes the live target before staging succeeds', () => {
+        const missingSource = path_1.default.join(sourceDir, 'does-not-exist-source');
+        const target = path_1.default.join(targetDir, 'target');
+        fs_1.default.mkdirSync(target, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(target, 'sentinel'), 'before');
+        expect(() => (0, executor_1.installArtifact)(missingSource, target, 'copy')).toThrow('Source path does not exist');
+        expect(fs_1.default.readFileSync(path_1.default.join(target, 'sentinel'), 'utf8')).toBe('before'); // verifies R17
+    });
+    it('stageArtifact stages next to the target without touching it, replaceArtifact swaps it in', () => {
+        const target = path_1.default.join(targetDir, 'staged-target');
+        fs_1.default.mkdirSync(target, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(target, 'sentinel'), 'before');
+        const staged = (0, executor_1.stageArtifact)(sourceDir, target, 'copy');
+        expect(fs_1.default.readFileSync(path_1.default.join(target, 'sentinel'), 'utf8')).toBe('before'); // untouched pre-replace
+        expect(fs_1.default.existsSync(path_1.default.join(staged, 'test.txt'))).toBe(true);
+        (0, executor_1.replaceArtifact)(staged, target);
+        expect(fs_1.default.existsSync(path_1.default.join(target, 'sentinel'))).toBe(false);
+        expect(fs_1.default.existsSync(path_1.default.join(target, 'test.txt'))).toBe(true);
+        expect(fs_1.default.existsSync(staged)).toBe(false);
+    });
 });

package/dist/tests/core/export/engine.test.js

@@ -91,9 +91,10 @@ describe('runExport (engine end-to-end)', () => {
         const originalCwd = process.cwd();
         process.chdir(cwdTmp);
         try {
+            const actualCwd = process.cwd();
             const summary = (0, export_1.runExport)({ name: 'mermaid', roots: [root], zip: okZip }); // sin `out`
-            expect(summary.outDir).toBe(path_1.default.join(cwdTmp, 'awm-export', 'claude-ai'));
-            expect(fs_1.default.existsSync(path_1.default.join(cwdTmp, 'awm-export/claude-ai/mermaid/SKILL.md'))).toBe(true);
+            expect(summary.outDir).toBe(path_1.default.join(actualCwd, 'awm-export', 'claude-ai'));
+            expect(fs_1.default.existsSync(path_1.default.join(actualCwd, 'awm-export/claude-ai/mermaid/SKILL.md'))).toBe(true);
         }
         finally {
             process.chdir(originalCwd);