agentic-workflow-manager 3.0.1 → 3.2.0

package/dist/tests/core/renderers/codex-agent.test.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const codex_agent_1 = require("../../../src/core/renderers/codex-agent");
+const canonical = `---
+name: development-process
+description: Orchestrates the development lifecycle
+mode: primary
+---
+
+# Development Process
+
+Invoke the \`development-process\` skill before implementation.
+`;
+it('renders deterministic native Codex TOML', () => {
+    expect((0, codex_agent_1.renderCodexAgent)(canonical)).toBe(`name = "development-process"
+description = "Orchestrates the development lifecycle"
+developer_instructions = """
+# Development Process
+
+Invoke the \`development-process\` skill before implementation.
+"""
+`); // verifies R8, R9
+});
+it.each([
+    ['---\nname: Bad Name\ndescription: x\n---\nbody', 'invalid agent name'],
+    ['---\nname: ok\ndescription:\n---\nbody', 'non-empty description'],
+    ['---\nname: ok\ndescription: x\n---\n', 'non-empty instruction body'],
+    ['name: ok', 'frontmatter'],
+])('rejects invalid canonical agents before rendering', (source, message) => {
+    expect(() => (0, codex_agent_1.renderCodexAgent)(source)).toThrow(message); // verifies R17
+});
+it('escapes an embedded backslash and runs of double quotes of varying length in the instructions body', () => {
+    const instructionsBody = [
+        'Backslash: \\',
+        'One quote: "',
+        'Three quotes: """',
+        'Four quotes: """"',
+        'Five quotes: """""',
+        'Seven quotes: """""""',
+        'Eight quotes: """"""""',
+    ].join('\n');
+    const source = `---
+name: quote-agent
+description: Handles many quotes
+---
+
+${instructionsBody}
+`;
+    expect((0, codex_agent_1.renderCodexAgent)(source)).toBe(`name = "quote-agent"
+description = "Handles many quotes"
+developer_instructions = """
+Backslash: \\\\
+One quote: \\"
+Three quotes: \\"\\"\\"
+Four quotes: \\"\\"\\"\\"
+Five quotes: \\"\\"\\"\\"\\"
+Seven quotes: \\"\\"\\"\\"\\"\\"\\"
+Eight quotes: \\"\\"\\"\\"\\"\\"\\"\\"
+"""
+`); // verifies R8, R9 (guards against greedy triple-quote-run escaping producing invalid TOML)
+});
+it('escapes U+007F (DEL) in single-line TOML string fields', () => {
+    const source = `---
+name: ok
+description: hasdel
+---
+
+Body text.
+`;
+    expect((0, codex_agent_1.renderCodexAgent)(source)).toBe(`name = "ok"
+description = "has\\u007fdel"
+developer_instructions = """
+Body text.
+"""
+`); // verifies R8, R9
+});
+it('escapes U+007F (DEL) embedded in the multiline instructions body', () => {
+    const del = String.fromCharCode(0x7f);
+    const source = `---
+name: ok
+description: fine
+---
+
+Body${del}text.
+`;
+    expect((0, codex_agent_1.renderCodexAgent)(source)).toBe(`name = "ok"
+description = "fine"
+developer_instructions = """
+Body\\u007ftext.
+"""
+`); // verifies R8, R9
+});
+it('escapes other C0 control characters (e.g. NUL, U+000B) embedded in the multiline instructions body while leaving tab and newline raw', () => {
+    const nul = String.fromCharCode(0x00);
+    const vt = String.fromCharCode(0x0b);
+    const unitSep = String.fromCharCode(0x1f);
+    const source = `---
+name: ok
+description: fine
+---
+
+Body${nul}with${vt}control${unitSep}chars\tand\na newline.
+`;
+    expect((0, codex_agent_1.renderCodexAgent)(source)).toBe(`name = "ok"
+description = "fine"
+developer_instructions = """
+Body\\u0000with\\u000bcontrol\\u001fchars\tand
+a newline.
+"""
+`); // verifies R8, R9
+});
+it('escapes other C0 control characters (e.g. NUL, U+000B) in single-line TOML string fields', () => {
+    const nul = String.fromCharCode(0x00);
+    const vt = String.fromCharCode(0x0b);
+    const source = `---
+name: ok
+description: has${nul}nul${vt}vt
+---
+
+Body text.
+`;
+    expect((0, codex_agent_1.renderCodexAgent)(source)).toBe(`name = "ok"
+description = "has\\u0000nul\\u000bvt"
+developer_instructions = """
+Body text.
+"""
+`); // verifies R8, R9
+});

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

@@ -152,7 +152,7 @@ describe('versioning core', () => {
         it('lee channel dev y pin por nombre desde preferences', () => {
             const awmDir = path_1.default.join(tmpHome, '.awm');
             fs_1.default.mkdirSync(awmDir, { recursive: true });
-            fs_1.default.writeFileSync(path_1.default.join(awmDir, 'preferences.json'), JSON.stringify({ defaultAgent: 'claude', installMethod: 'symlink', defaultScope: 'local', channel: 'dev', pins: { base: '1.2.0', equipo: '0.3.0' } }));
+            fs_1.default.writeFileSync(path_1.default.join(awmDir, 'preferences.json'), JSON.stringify({ defaultAgent: 'claude-code', installMethod: 'symlink', defaultScope: 'local', channel: 'dev', pins: { base: '1.2.0', equipo: '0.3.0' } }));
             const { machineVersionOpts } = require('../../src/core/versioning');
             expect(machineVersionOpts('base')).toEqual({ pin: '1.2.0', channel: 'dev' });
             expect(machineVersionOpts('equipo')).toEqual({ pin: '0.3.0', channel: 'dev' });

package/dist/tests/integration/codex-provider-isolated.test.js

@@ -0,0 +1,206 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// cli/tests/integration/codex-provider-isolated.test.ts
+//
+// Task 9, Step 5 — a genuinely-real, isolated-home E2E: unlike the rest of the
+// suite (which stubs installBundle/installHook/etc. to observe call shape),
+// this test lets `awm init --agent codex` run its REAL pipeline end-to-end
+// (real symlinks, real Codex TOML rendering, real preferences writes) against
+// a hand-seeded registry fixture, then asserts on the actual resulting
+// filesystem — never against the real `~/.awm` (CLAUDE.md's "never touch
+// ~/.awm" rule; HOME/AWM_HOME are isolated tmpdirs for the whole test, same
+// pattern as tests/commands/hooks/install.test.ts).
+//
+// Matches the plan's illustrative Task 9 Step 5 snippet: OpenCode is enabled
+// (and really initialized) alongside Claude Code BEFORE the real
+// `awm init --agent codex` run, exactly the "OpenCode already enabled, then
+// Codex joins" scenario this whole plan exists to support. This used to trip
+// install-planner.ts's `assertCompleteSharedGroup` (R14, Task 5) — OpenCode
+// and Codex share the exact same physical skills directory (~/.agents/skills,
+// providers/index.ts) — because `core/init/steps.ts`'s `stepDevCore`/
+// `stepAmbient` passed a `[agent]` singleton as `selectedAgents`, which R14
+// refuses whenever a co-owner of the shared target is independently enabled.
+// That was a confirmed BLOCKER (found in post-implementation QA): it made
+// `awm init --agent codex` structurally fail whenever OpenCode was already
+// enabled, and vice versa. Fixed by having `stepDevCore`/`stepAmbient`
+// compute the complete shared-skill-target group among currently-enabled
+// agents (`install-planner.ts`'s `agentsSharingSkillTarget`, used via
+// `steps.ts`'s `sharedInstallAgents`) instead of a singleton — see
+// tests/core/init/steps.test.ts for the unit-level coverage of that
+// computation. This test proves the real end-to-end flow now succeeds.
+//
+// While building this fixture, this test also caught and fixed a real,
+// previously-untested bug: `runInit` called `assertClaudeBaselinePreserved`
+// unconditionally, even when the run's OWN target was claude-code — meaning
+// any genuinely successful `awm init` (no --agent, the CLI's default/most
+// common path) with real registry content would falsely throw "Claude Code
+// baseline changed during a non-Claude init" and exit 2. See
+// src/commands/init.ts's `beforeClaudeFacts` guard.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+describe('codex provider — isolated home E2E (Task 9)', () => {
+    let tmpHome;
+    let tmpWork;
+    let originalHome;
+    let originalAwmHome;
+    let writeSpy;
+    function stdout() {
+        return writeSpy.mock.calls.map((c) => c[0]).join('');
+    }
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-e2e-home-'));
+        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-e2e-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();
+        // Every runInit/runDoctor call in this suite writes a full text report to
+        // stdout — mock it so the real test suite's own output stays readable, and
+        // recover it via `stdout()` where a test needs to inspect the JSON payload.
+        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;
+    });
+    /** Hand-seeds a registry content root with everything a real `awm init` needs:
+     *  hooks (Claude + Codex), the bootstrap skill, one baseline bundle providing
+     *  both a skill and a Codex-native agent artifact. No git repo involved — the
+     *  registry cache is content-root-shaped, exactly what a real clone produces. */
+    function seedPublicRegistryFixture(root) {
+        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.writeFileSync(path_1.default.join(root, 'hooks/codex-session-start'), '#!/bin/sh\necho "{}"\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---\nOrchestrates the dev lifecycle.');
+        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---\nFollow the AWM development process end to end.');
+        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: ['development-process'],
+        }));
+        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));
+    }
+    function writePrefs(prefs) {
+        const { savePreferences } = require('../../src/utils/config');
+        savePreferences(prefs);
+    }
+    function prefsWith(enabledAgents) {
+        return { defaultAgent: enabledAgents[0], enabledAgents, installMethod: 'symlink', defaultScope: 'local' };
+    }
+    function readPrefs() {
+        return JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmpHome, '.awm/preferences.json'), 'utf8'));
+    }
+    /** Cheap recursive content snapshot for "did this subtree change at all" assertions
+     *  (same shape as tests/commands/init.test.ts's snapshotTree). */
+    function snapshotTree(dir) {
+        if (!fs_1.default.existsSync(dir))
+            return null;
+        const walk = (p) => {
+            const st = fs_1.default.lstatSync(p);
+            if (st.isSymbolicLink())
+                return { type: 'symlink', target: fs_1.default.readlinkSync(p) };
+            if (st.isDirectory()) {
+                const entries = fs_1.default.readdirSync(p).sort();
+                return { type: 'dir', entries: Object.fromEntries(entries.map((e) => [e, walk(path_1.default.join(p, e))])) };
+            }
+            return { type: 'file', content: fs_1.default.readFileSync(p, 'utf8') };
+        };
+        return walk(dir);
+    }
+    it('initializes Codex beside a real Claude Code + OpenCode install without touching Claude files', async () => {
+        expect(process.env.HOME).toBe(tmpHome);
+        expect(process.env.AWM_HOME).toBe(path_1.default.join(tmpHome, '.awm'));
+        seedPublicRegistryFixture(path_1.default.join(tmpHome, '.awm/registries/baseline'));
+        const { runInit } = require('../../src/commands/init');
+        // Real, full, unstubbed init for claude-code — installs the real hook,
+        // real global skill symlink and real global agent symlink.
+        const claudeCode = await runInit({ cwd: tmpWork, yes: true });
+        expect(claudeCode).toBeLessThanOrEqual(1);
+        expect(fs_1.default.lstatSync(path_1.default.join(tmpHome, '.claude/skills/development-process')).isSymbolicLink()).toBe(true);
+        expect(readPrefs().enabledAgents).toEqual(['claude-code']);
+        // Real, full, unstubbed init for opencode — enables it alongside Claude
+        // Code and materializes its real ~/.agents/skills symlink, the exact
+        // physical directory Codex shares (providers/index.ts). This is the
+        // scenario the plan's own Task 9 Step 5 snippet illustrates ("OpenCode
+        // already enabled, then Codex joins") and the one the BLOCKER fixed in
+        // core/init/steps.ts (sharedInstallAgents) makes work end-to-end.
+        const opencode = await runInit({ cwd: tmpWork, yes: true, agent: 'opencode' });
+        expect(opencode).toBeLessThanOrEqual(1);
+        expect(readPrefs().enabledAgents).toEqual(['claude-code', 'opencode']);
+        const opencodeSkillLinkBefore = fs_1.default.realpathSync(path_1.default.join(tmpHome, '.agents/skills/development-process'));
+        const claudeBefore = snapshotTree(path_1.default.join(tmpHome, '.claude'));
+        // Real, full, unstubbed init for codex — real Codex hook, real shared
+        // skill symlink (co-owned with OpenCode), real Codex-native TOML agent
+        // render. Before the fix, this call threw: "Shared skill target cannot
+        // diverge; select the complete shared target group: opencode,codex".
+        const codex = await runInit({
+            cwd: tmpWork,
+            yes: true,
+            agent: 'codex',
+            // Real `codex --version` execution is unreliable inside this sandboxed
+            // test runner (subprocess exec of freshly-written fixture binaries is
+            // blocked even with PATH correctly set — verified directly; see task
+            // notes). Every other real-pipeline test in the suite (init.test.ts's
+            // `codexInitOptions`) uses this exact seam for the same reason — R2's
+            // gate itself is unit-tested separately in provider-version.test.ts.
+            assertProviderSupported: () => ({ provider: 'codex', version: '0.150.0' }),
+        });
+        expect(codex).toBeLessThanOrEqual(1);
+        expect(readPrefs().enabledAgents).toEqual(['claude-code', 'opencode', 'codex']);
+        // R1/R7: Codex's global skill dir (~/.agents/skills, shared by design with
+        // OpenCode — providers/index.ts) got a real symlink into the registry —
+        // the SAME physical link OpenCode's own init already produced, now
+        // co-owned by both agents (R15/R15.1) rather than fought over.
+        const skillLink = path_1.default.join(tmpHome, '.agents/skills/development-process');
+        expect(fs_1.default.lstatSync(skillLink).isSymbolicLink()).toBe(true);
+        expect(fs_1.default.realpathSync(skillLink)).toContain(path_1.default.join('.awm/registries/baseline/skills/development-process'));
+        // OpenCode's own skill link is untouched — same physical target, same source.
+        expect(fs_1.default.realpathSync(skillLink)).toBe(opencodeSkillLinkBefore);
+        // R8: the canonical agent got rendered into Codex's native .toml shape.
+        const tomlPath = path_1.default.join(tmpHome, '.codex/agents/development-process.toml');
+        const toml = fs_1.default.readFileSync(tomlPath, 'utf8');
+        expect(toml).toContain('developer_instructions = """');
+        expect(toml).toContain('name = "development-process"');
+        // R18: the Codex hook got installed for real.
+        const hooksJson = JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmpHome, '.codex/hooks.json'), 'utf8'));
+        expect(hooksJson.hooks.SessionStart).toHaveLength(1);
+        // R19/R19.1/R23: nothing under Claude's baseline moved during the Codex run.
+        expect(snapshotTree(path_1.default.join(tmpHome, '.claude'))).toEqual(claudeBefore);
+    });
+    it('doctor reports the isolated Codex install as supported/healthy, not against the real ~/.awm', () => {
+        seedPublicRegistryFixture(path_1.default.join(tmpHome, '.awm/registries/baseline'));
+        writePrefs(prefsWith(['claude-code', 'codex']));
+        const { runDoctor } = require('../../src/commands/doctor');
+        // R20: doctor resolves a single explicit provider without needing every
+        // enabled agent to be independently initialized first.
+        runDoctor({ cwd: tmpWork, json: true, agent: 'codex' });
+        const report = JSON.parse(stdout());
+        expect(report.providers.map((p) => p.id)).toEqual(['codex']);
+        const codexReport = report.providers[0];
+        expect(codexReport.checks.find((c) => c.id === 'binary.version').state).toBe('missing');
+    });
+});

package/dist/tests/providers/hooks-config.test.js

@@ -1,25 +1,50 @@
 "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 providers_1 = require("../../src/providers");
 describe('Hook configuration in providers', () => {
+    const originalHome = process.env.HOME;
+    const originalAwmHome = process.env.AWM_HOME;
+    let tmpHome;
+    let tmpWork;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-hook-home-'));
+        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-hook-work-'));
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpWork, '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 });
+    });
     it('claude-code provider defines a HookConfig', () => {
-        const cc = providers_1.PROVIDERS['claude-code'];
+        const cc = (0, providers_1.providerFor)('claude-code');
         expect(cc.hooks).toBeDefined();
         expect(cc.hooks?.type).toBe('cc-settings-merge');
         expect(cc.hooks?.eventName).toBe('SessionStart');
         expect(cc.hooks?.matcher).toBe('startup|clear|compact');
     });
-    it('claude-code settingsPath resolves to ~/.claude/settings.json', () => {
-        const cc = providers_1.PROVIDERS['claude-code'];
-        expect(cc.hooks?.settingsPath).toMatch(/\.claude\/settings\.json$/);
+    it('preserves the legacy Claude Code AWM_HOME hooks directory', () => {
+        const cc = (0, providers_1.providerFor)('claude-code');
+        expect(cc.hooks?.settingsPath).toBe(path_1.default.join(tmpHome, '.claude/settings.json'));
+        expect(cc.hooks?.scriptsDir).toBe(path_1.default.join(process.env.AWM_HOME, 'hooks'));
     });
-    it('claude-code scriptsDir resolves to ~/.awm/hooks/', () => {
-        const cc = providers_1.PROVIDERS['claude-code'];
-        expect(cc.hooks?.scriptsDir).toMatch(/\.awm\/hooks$/);
-    });
-    it('antigravity and opencode have no hooks (single-harness scope)', () => {
-        expect(providers_1.PROVIDERS['antigravity'].hooks).toBeUndefined();
-        expect(providers_1.PROVIDERS['opencode'].hooks).toBeUndefined();
+    it('antigravity and opencode have no hooks', () => {
+        expect((0, providers_1.providerFor)('antigravity').hooks).toBeUndefined();
+        expect((0, providers_1.providerFor)('opencode').hooks).toBeUndefined();
     });
     it('getHookConfig returns config for supported target', () => {
         const config = (0, providers_1.getHookConfig)('claude-code');
@@ -27,19 +52,12 @@ describe('Hook configuration in providers', () => {
         expect(config?.type).toBe('cc-settings-merge');
     });
     it('getHookConfig returns undefined for unsupported target', () => {
-        const config = (0, providers_1.getHookConfig)('antigravity');
-        expect(config).toBeUndefined();
-    });
-    it('respects AWM_HOME env var override for scriptsDir', () => {
-        const originalEnv = process.env.AWM_HOME;
-        process.env.AWM_HOME = '/tmp/awm-test';
-        // Re-import to pick up env change
-        jest.resetModules();
-        const { PROVIDERS: P } = require('../../src/providers');
-        expect(P['claude-code'].hooks.scriptsDir).toBe('/tmp/awm-test/hooks');
-        if (originalEnv === undefined)
-            delete process.env.AWM_HOME;
-        else
-            process.env.AWM_HOME = originalEnv;
+        expect((0, providers_1.getHookConfig)('antigravity')).toBeUndefined();
+    });
+    it('respects AWM_HOME changes at call time', () => {
+        const nextAwmHome = path_1.default.join(tmpWork, 'next-awm');
+        process.env.AWM_HOME = nextAwmHome;
+        expect((0, providers_1.getHookConfig)('claude-code')?.scriptsDir)
+            .toBe(path_1.default.join(nextAwmHome, 'hooks'));
     });
 });

package/dist/tests/providers/index.test.js

@@ -3,56 +3,161 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-// tests/providers/index.test.ts
-const providers_1 = require("../../src/providers");
+const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const providers_1 = require("../../src/providers");
 describe('Providers Routing', () => {
-    // ── Existing Antigravity tests (preserved) ──
-    it('routes antigravity global skills correctly', () => {
-        const result = (0, providers_1.getTargetPath)('skill', 'antigravity', 'global');
-        expect(result).toBe(`${os_1.default.homedir()}/.gemini/antigravity/skills`);
+    const originalHome = process.env.HOME;
+    const originalAwmHome = process.env.AWM_HOME;
+    let tmpHome;
+    let tmpWork;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-provider-home-'));
+        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-provider-work-'));
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm-test');
     });
-    it('routes opencode local skills correctly', () => {
-        const result = (0, providers_1.getTargetPath)('skill', 'opencode', 'local');
-        expect(result).toBe('.agents/skills');
+    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 });
     });
-    it('routes antigravity global workflows correctly', () => {
-        const result = (0, providers_1.getTargetPath)('workflow', 'antigravity', 'global');
-        expect(result).toBe(`${os_1.default.homedir()}/.gemini/antigravity/global_workflows`);
+    it('resolves Codex paths from the current HOME at call time', () => {
+        const first = fs_1.default.mkdtempSync(path_1.default.join(tmpWork, 'awm-home-a-'));
+        const second = fs_1.default.mkdtempSync(path_1.default.join(tmpWork, 'awm-home-b-'));
+        process.env.HOME = first;
+        expect((0, providers_1.getTargetPath)('skill', 'codex', 'global'))
+            .toBe(path_1.default.join(first, '.agents/skills'));
+        process.env.HOME = second;
+        expect((0, providers_1.getTargetPath)('agent', 'codex', 'global'))
+            .toBe(path_1.default.join(second, '.codex/agents'));
     });
-    it('throws on opencode workflow', () => {
-        expect(() => (0, providers_1.getTargetPath)('workflow', 'opencode', 'global')).toThrow('not supported');
+    it('returns a fresh provider graph using current HOME and AWM_HOME', () => {
+        const first = (0, providers_1.providers)();
+        const nextHome = path_1.default.join(tmpWork, 'next-home');
+        const nextAwmHome = path_1.default.join(tmpWork, 'next-awm');
+        process.env.HOME = nextHome;
+        process.env.AWM_HOME = nextAwmHome;
+        const second = (0, providers_1.providers)();
+        expect(second).not.toBe(first);
+        expect(second.codex.skill.global).toBe(path_1.default.join(nextHome, '.agents/skills'));
+        expect(second.codex.hooks?.scriptsDir).toBe(path_1.default.join(nextAwmHome, 'hooks/codex'));
+        expect(first.codex.skill.global).toBe(path_1.default.join(tmpHome, '.agents/skills'));
     });
-    // ── New Claude Code tests ──
-    it('routes claude-code global skills correctly', () => {
-        const result = (0, providers_1.getTargetPath)('skill', 'claude-code', 'global');
-        expect(result).toBe(`${os_1.default.homedir()}/.claude/skills`);
+    it('declares the complete Codex capability metadata', () => {
+        expect((0, providers_1.providerFor)('codex')).toEqual({
+            label: 'Codex',
+            minimumVersion: '0.145.0',
+            versionCommand: { command: 'codex', args: ['--version'] },
+            skill: {
+                global: path_1.default.join(tmpHome, '.agents/skills'),
+                local: '.agents/skills',
+                renderer: 'link',
+            },
+            workflow: null,
+            agent: {
+                global: path_1.default.join(tmpHome, '.codex/agents'),
+                local: '.codex/agents',
+                renderer: 'codex-agent-toml',
+            },
+            hooks: {
+                type: 'codex-hooks-json',
+                settingsPath: path_1.default.join(tmpHome, '.codex/hooks.json'),
+                scriptsDir: path_1.default.join(process.env.AWM_HOME, 'hooks/codex'),
+                matcher: 'startup|resume|clear|compact',
+                eventName: 'SessionStart',
+            },
+            injection: {
+                type: 'managed-agents-md',
+                globalPath: path_1.default.join(tmpHome, '.codex/AGENTS.md'),
+                localFile: 'AGENTS.md',
+            },
+        });
     });
-    it('routes claude-code local skills correctly', () => {
-        const result = (0, providers_1.getTargetPath)('skill', 'claude-code', 'local');
-        expect(result).toBe('.claude/skills');
+    it('keeps Claude Code, OpenCode, and Antigravity contracts unchanged', () => {
+        const graph = (0, providers_1.providers)();
+        expect(graph.antigravity).toEqual({
+            label: 'Antigravity',
+            skill: {
+                global: path_1.default.join(tmpHome, '.gemini/antigravity/skills'),
+                local: '.agent/skills',
+                renderer: 'link',
+            },
+            workflow: {
+                global: path_1.default.join(tmpHome, '.gemini/antigravity/global_workflows'),
+                local: '.agent/workflows',
+                renderer: 'link',
+            },
+            agent: null,
+        });
+        expect(graph.opencode).toEqual({
+            label: 'OpenCode',
+            skill: {
+                global: path_1.default.join(tmpHome, '.agents/skills'),
+                local: '.agents/skills',
+                renderer: 'link',
+            },
+            workflow: null,
+            agent: {
+                global: path_1.default.join(tmpHome, '.config/opencode/agents'),
+                local: '.agents/profiles',
+                renderer: 'link',
+            },
+            injection: {
+                type: 'config-instructions',
+                configPath: path_1.default.join(tmpHome, '.config/opencode/opencode.json'),
+                field: 'instructions',
+            },
+        });
+        expect(graph['claude-code']).toEqual({
+            label: 'Claude Code',
+            skill: {
+                global: path_1.default.join(tmpHome, '.claude/skills'),
+                local: '.claude/skills',
+                renderer: 'link',
+            },
+            workflow: null,
+            agent: {
+                global: path_1.default.join(tmpHome, '.claude/agents'),
+                local: '.claude/agents',
+                renderer: 'link',
+            },
+            hooks: {
+                type: 'cc-settings-merge',
+                settingsPath: path_1.default.join(tmpHome, '.claude/settings.json'),
+                scriptsDir: path_1.default.join(process.env.AWM_HOME, 'hooks'),
+                matcher: 'startup|clear|compact',
+                eventName: 'SessionStart',
+            },
+            injection: { type: 'cc-settings-merge' },
+        });
     });
-    it('routes claude-code global agents correctly', () => {
-        const result = (0, providers_1.getTargetPath)('agent', 'claude-code', 'global');
-        expect(result).toBe(`${os_1.default.homedir()}/.claude/agents`);
+    it('keeps Claude Code and OpenCode destinations unchanged', () => {
+        expect((0, providers_1.getTargetPath)('skill', 'claude-code', 'global'))
+            .toBe(path_1.default.join(process.env.HOME, '.claude/skills'));
+        expect((0, providers_1.getTargetPath)('skill', 'opencode', 'global'))
+            .toBe(path_1.default.join(process.env.HOME, '.agents/skills'));
     });
-    it('routes claude-code local agents correctly', () => {
-        const result = (0, providers_1.getTargetPath)('agent', 'claude-code', 'local');
-        expect(result).toBe('.claude/agents');
+    it('uses AGENT_TARGETS as the single iterable target catalog', () => {
+        expect(providers_1.AGENT_TARGETS).toEqual(['antigravity', 'opencode', 'claude-code', 'codex']);
+        expect(Object.keys((0, providers_1.providers)())).toEqual([...providers_1.AGENT_TARGETS]);
     });
-    it('throws on claude-code workflow', () => {
+    it('throws on unsupported artifacts', () => {
+        expect(() => (0, providers_1.getTargetPath)('workflow', 'opencode', 'global')).toThrow('not supported');
         expect(() => (0, providers_1.getTargetPath)('workflow', 'claude-code', 'global')).toThrow('not supported');
+        expect(() => (0, providers_1.getTargetPath)('agent', 'antigravity', 'local')).toThrow('not supported');
     });
-    it('throws on unknown agent target', () => {
-        expect(() => (0, providers_1.getTargetPath)('skill', 'unknown-agent', 'global')).toThrow('Unknown agent target');
-    });
-    // ── PROVIDERS map structure tests ──
-    it('exports PROVIDERS with all three targets', () => {
-        expect(Object.keys(providers_1.PROVIDERS)).toEqual(expect.arrayContaining(['antigravity', 'opencode', 'claude-code']));
-    });
-    it('marks unsupported artifact types as null', () => {
-        expect(providers_1.PROVIDERS['antigravity'].agent).toBeNull();
-        expect(providers_1.PROVIDERS['opencode'].workflow).toBeNull();
-        expect(providers_1.PROVIDERS['claude-code'].workflow).toBeNull();
+    it('fails loudly for invalid runtime provider input', () => {
+        expect(() => (0, providers_1.providerFor)('unknown-agent')).toThrow('Unknown agent target');
+        expect(() => (0, providers_1.getTargetPath)('skill', 'unknown-agent', 'global'))
+            .toThrow('Unknown agent target');
     });
 });