agentic-workflow-manager 3.1.0 → 3.2.0

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

@@ -0,0 +1,224 @@
+"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 install_planner_1 = require("../../src/core/install-planner");
+describe('install-planner', () => {
+    let tmpHome;
+    let tmpWork;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        // Isolate ~ (and thus provider global paths, per CLAUDE.md: no test may
+        // touch the real ~/.awm or ~/.agents). HOME also drives providerFor()'s
+        // global dirs, which is exactly what makes opencode/codex "share" a
+        // physical skills directory in these tests.
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-planner-home-'));
+        tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-planner-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(() => {
+        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;
+    });
+    function skillArtifact(name) {
+        return {
+            name,
+            installName: name,
+            type: 'skill',
+            sourcePath: path_1.default.join(tmpWork, 'registry', 'skills', name),
+        };
+    }
+    function agentArtifact(name) {
+        return {
+            name,
+            installName: `${name}.md`,
+            type: 'agent',
+            sourcePath: path_1.default.join(tmpWork, 'registry', 'agents', `${name}.md`),
+        };
+    }
+    function workflowArtifact(name) {
+        return {
+            name,
+            installName: `${name}.md`,
+            type: 'workflow',
+            sourcePath: path_1.default.join(tmpWork, 'registry', 'workflows', `${name}.md`),
+        };
+    }
+    function recordOwnedBy(name, owners) {
+        return {
+            name,
+            type: 'skill',
+            scope: 'global',
+            targetPath: path_1.default.join(tmpHome, '.agents', 'skills', name),
+            sourcePath: path_1.default.join(tmpWork, 'registry', 'skills', name),
+            renderer: 'link',
+            owners,
+        };
+    }
+    describe('planInstall', () => {
+        it('deduplicates the OpenCode/Codex physical skill write and reports both owners', () => {
+            const plan = (0, install_planner_1.planInstall)({
+                artifacts: [skillArtifact('development-process')],
+                selectedAgents: ['opencode', 'codex'],
+                enabledAgents: ['claude-code', 'opencode', 'codex'],
+                scope: 'global',
+                projectRoot: tmpWork,
+                method: 'symlink',
+            });
+            expect(plan.operations).toHaveLength(1); // verifies R15
+            expect(plan.operations[0].owners).toEqual(['opencode', 'codex']); // verifies R15.1
+        });
+        it('aborts a skill change for an incomplete shared target group before writes', () => {
+            expect(() => (0, install_planner_1.planInstall)({
+                artifacts: [skillArtifact('development-process')],
+                selectedAgents: ['codex'],
+                enabledAgents: ['opencode', 'codex'],
+                scope: 'global',
+                projectRoot: tmpWork,
+                method: 'symlink',
+            })).toThrow('select the complete shared target group: opencode,codex'); // verifies R14
+        });
+        it('does not apply the shared-domain restriction to independently addressed agents', () => {
+            const plan = (0, install_planner_1.planInstall)({
+                artifacts: [agentArtifact('development-process')],
+                selectedAgents: ['codex'],
+                enabledAgents: ['opencode', 'codex'],
+                scope: 'global',
+                projectRoot: tmpWork,
+                method: 'symlink',
+            });
+            expect(plan.operations[0].owners).toEqual(['codex']); // verifies R13
+        });
+        it('returns no operations for an empty artifacts array', () => {
+            const plan = (0, install_planner_1.planInstall)({
+                artifacts: [],
+                selectedAgents: ['claude-code'],
+                enabledAgents: ['claude-code'],
+                scope: 'global',
+                projectRoot: tmpWork,
+                method: 'symlink',
+            });
+            expect(plan).toEqual({ operations: [], records: [], reports: [] });
+        });
+        it('returns no operations for an empty selectedAgents array', () => {
+            const plan = (0, install_planner_1.planInstall)({
+                artifacts: [skillArtifact('development-process')],
+                selectedAgents: [],
+                enabledAgents: ['claude-code'],
+                scope: 'global',
+                projectRoot: tmpWork,
+                method: 'symlink',
+            });
+            expect(plan).toEqual({ operations: [], records: [], reports: [] });
+        });
+        it('skips an artifact type unsupported by an agent instead of throwing (workflow on claude-code)', () => {
+            const plan = (0, install_planner_1.planInstall)({
+                artifacts: [workflowArtifact('wf-ext')],
+                selectedAgents: ['claude-code'],
+                enabledAgents: ['claude-code'],
+                scope: 'global',
+                projectRoot: tmpWork,
+                method: 'symlink',
+            });
+            expect(plan.operations).toEqual([]);
+        });
+        it('resolves a local-scope target beneath projectRoot', () => {
+            const plan = (0, install_planner_1.planInstall)({
+                artifacts: [skillArtifact('development-process')],
+                selectedAgents: ['claude-code'],
+                enabledAgents: ['claude-code'],
+                scope: 'local',
+                projectRoot: tmpWork,
+                method: 'symlink',
+            });
+            expect(plan.operations[0].targetPath).toBe(path_1.default.join(tmpWork, '.claude', 'skills', 'development-process'));
+        });
+        it('dedupes two intents that share both targetPath and sourcePath into one operation', () => {
+            // e.g. the same skill pulled in twice via different bundles in a
+            // closure — same physical target, same backing source: fine.
+            const plan = (0, install_planner_1.planInstall)({
+                artifacts: [skillArtifact('development-process'), skillArtifact('development-process')],
+                selectedAgents: ['claude-code'],
+                enabledAgents: ['claude-code'],
+                scope: 'global',
+                projectRoot: tmpWork,
+                method: 'symlink',
+            });
+            expect(plan.operations).toHaveLength(1);
+        });
+        it('throws when two intents share a targetPath but have different sourcePaths', () => {
+            // e.g. the same skill name shipped by two different registries —
+            // one physical target can't be backed by two different sources.
+            const registryA = {
+                name: 'development-process',
+                installName: 'development-process',
+                type: 'skill',
+                sourcePath: path_1.default.join(tmpWork, 'registry-a', 'skills', 'development-process'),
+            };
+            const registryB = {
+                name: 'development-process',
+                installName: 'development-process',
+                type: 'skill',
+                sourcePath: path_1.default.join(tmpWork, 'registry-b', 'skills', 'development-process'),
+            };
+            expect(() => (0, install_planner_1.planInstall)({
+                artifacts: [registryA, registryB],
+                selectedAgents: ['claude-code'],
+                enabledAgents: ['claude-code'],
+                scope: 'global',
+                projectRoot: tmpWork,
+                method: 'symlink',
+            })).toThrow(/physical target already claimed by a different source/);
+        });
+    });
+    describe('planRemoval', () => {
+        it('retains a target while a non-selected enabled owner remains', () => {
+            const result = (0, install_planner_1.planRemoval)({
+                records: [recordOwnedBy('development-process', ['opencode', 'codex'])],
+                selectedAgents: ['codex'],
+                enabledAgents: ['opencode', 'codex'],
+                artifactNames: ['development-process'],
+            });
+            expect(result.operations).toEqual([]);
+            expect(result.records[0].owners).toEqual(['opencode']); // verifies R16
+        });
+        it('produces an unlink once the last enabled owner is removed', () => {
+            const result = (0, install_planner_1.planRemoval)({
+                records: [recordOwnedBy('development-process', ['codex'])],
+                selectedAgents: ['codex'],
+                enabledAgents: ['opencode', 'codex'],
+                artifactNames: ['development-process'],
+            });
+            expect(result.records).toEqual([]);
+            expect(result.operations).toHaveLength(1);
+            expect(result.operations[0].action).toBe('unlink');
+        });
+        it('leaves records for artifacts not named in artifactNames untouched', () => {
+            const other = recordOwnedBy('other-skill', ['codex']);
+            const result = (0, install_planner_1.planRemoval)({
+                records: [other],
+                selectedAgents: ['codex'],
+                enabledAgents: ['opencode', 'codex'],
+                artifactNames: ['development-process'],
+            });
+            expect(result.records).toEqual([other]);
+            expect(result.operations).toEqual([]);
+        });
+    });
+});

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

@@ -0,0 +1,257 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// tests/core/install-transaction.test.ts
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const install_transaction_1 = require("../../src/core/install-transaction");
+const artifact_state_1 = require("../../src/core/artifact-state");
+// Per CLAUDE.md: no test may touch the real ~/.awm. Every test here backs up
+// or transacts through awmHome(), so HOME/AWM_HOME must point at an isolated
+// tmpdir (pattern from tests/commands/hooks/install.test.ts).
+let tmpHome;
+let tmpWork;
+let originalHome;
+let originalAwmHome;
+beforeEach(() => {
+    tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-txn-home-'));
+    tmpWork = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-txn-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(() => {
+    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;
+});
+function makeOp(name, overrides = {}) {
+    return {
+        name,
+        type: 'skill',
+        scope: 'local',
+        targetPath: path_1.default.join(tmpWork, name),
+        sourcePath: path_1.default.join(tmpWork, `${name}-source`),
+        renderer: 'link',
+        owners: ['claude-code'],
+        method: 'copy',
+        output: 'link',
+        ...overrides,
+    };
+}
+function planWithTwoTargets() {
+    const a = makeOp('a');
+    const b = makeOp('b');
+    return { operations: [a, b], records: [], reports: [] };
+}
+function planWithThreeTargets() {
+    const a = makeOp('a');
+    const b = makeOp('b');
+    const c = makeOp('c');
+    return { operations: [a, b, c], records: [], reports: [] };
+}
+/**
+ * Builds a plan whose second operation ("b") is guaranteed to be replaced
+ * (real filesystem write) before verification runs, letting the test force a
+ * verification failure via a `verify` override while still exercising the
+ * REAL default backup/stage/replace/rollback pipeline underneath.
+ */
+function planThatFailsSecondVerification(original) {
+    const sourceA = path_1.default.join(tmpWork, 'source-a');
+    fs_1.default.mkdirSync(sourceA, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(sourceA, 'file.txt'), 'new-a');
+    const sourceB = path_1.default.join(tmpWork, 'source-b');
+    fs_1.default.mkdirSync(sourceB, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(sourceB, 'file.txt'), 'new-b');
+    const opA = makeOp('a', { targetPath: original, sourcePath: sourceA });
+    const opB = makeOp('b', { targetPath: path_1.default.join(tmpWork, 'target-b'), sourcePath: sourceB });
+    return { operations: [opA, opB], records: [], reports: [] };
+}
+describe('applyInstallPlan', () => {
+    it('validates and backs up every target before the first replacement', () => {
+        const calls = [];
+        (0, install_transaction_1.applyInstallPlan)(planWithTwoTargets(), {
+            validate: (op) => calls.push(`validate:${op.name}`),
+            backup: (op) => { calls.push(`backup:${op.name}`); return null; },
+            stage: (op) => { calls.push(`stage:${op.name}`); return `/staged/${op.name}`; },
+            replace: (op) => calls.push(`replace:${op.name}`),
+            verify: (op) => calls.push(`verify:${op.name}`),
+            rollback: (op) => calls.push(`rollback:${op.name}`),
+        });
+        expect(calls.indexOf('validate:a')).toBeLessThan(calls.indexOf('backup:a'));
+        expect(calls.indexOf('backup:b')).toBeLessThan(calls.indexOf('replace:a')); // verifies R24.1
+    });
+    it('restores already replaced targets when verification fails', () => {
+        const original = path_1.default.join(tmpWork, 'target-a');
+        fs_1.default.mkdirSync(original, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(original, 'sentinel'), 'before');
+        const plan = planThatFailsSecondVerification(original);
+        const deps = {
+            ...(0, install_transaction_1.defaultTransactionDeps)(),
+            verify: (op) => {
+                if (op.name === 'b')
+                    throw new Error('verification failed: forced for test');
+            },
+        };
+        expect(() => (0, install_transaction_1.applyInstallPlan)(plan, deps)).toThrow('verification failed');
+        expect(fs_1.default.readFileSync(path_1.default.join(original, 'sentinel'), 'utf8')).toBe('before'); // verifies R25
+    });
+    it('returns a transactionId and the list of modified files on success', () => {
+        const sourceA = path_1.default.join(tmpWork, 'source-a');
+        fs_1.default.mkdirSync(sourceA, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(sourceA, 'file.txt'), 'content-a');
+        const targetA = path_1.default.join(tmpWork, 'target-a');
+        const plan = {
+            operations: [makeOp('a', { targetPath: targetA, sourcePath: sourceA })],
+            records: [],
+            reports: [{ owner: 'claude-code', targetPath: targetA, action: 'install' }],
+        };
+        const summary = (0, install_transaction_1.applyInstallPlan)(plan);
+        expect(summary.transactionId).toBeTruthy();
+        expect(summary.modifiedFiles).toEqual([targetA]);
+        expect(fs_1.default.existsSync(path_1.default.join(targetA, 'file.txt'))).toBe(true);
+        const backupDir = path_1.default.join(process.env.AWM_HOME, 'backups', summary.transactionId);
+        expect(fs_1.default.existsSync(path_1.default.join(backupDir, 'manifest.json'))).toBe(true);
+    });
+    it('is a safe no-op for an empty plan', () => {
+        const summary = (0, install_transaction_1.applyInstallPlan)({ operations: [], records: [], reports: [] });
+        expect(summary.installed).toEqual([]);
+        expect(summary.modifiedFiles).toEqual([]);
+        expect(summary.transactionId).toBeTruthy();
+    });
+    it('keeps rolling back remaining targets, and still surfaces the original error, when a MIDDLE rollback fails', () => {
+        // 3 ops (a, b, c) all replaced; verification fails on 'c', so rollback
+        // runs in reverse order: c, b, a. Making 'b' — the middle op in that
+        // reversed order, with an op both before and after it in the loop —
+        // the one that throws is what actually proves the per-op try/catch
+        // isolates failures: 'a' still runs AFTER 'b' throws, not just
+        // trivially "nothing left to run" as a last-in-order failure would.
+        const calls = [];
+        const plan = planWithThreeTargets();
+        expect(() => (0, install_transaction_1.applyInstallPlan)(plan, {
+            validate: () => { },
+            backup: () => null,
+            stage: (op) => `/staged/${op.name}`,
+            replace: (op) => calls.push(`replace:${op.name}`),
+            verify: (op) => { if (op.name === 'c')
+                throw new Error('verification failed: forced'); },
+            rollback: (op) => {
+                calls.push(`rollback:${op.name}`);
+                if (op.name === 'b')
+                    throw new Error('rollback failed for b (simulated)');
+            },
+        })).toThrow('verification failed: forced');
+        // All three replaced ops got a rollback attempt, in reverse order —
+        // including 'a', which runs strictly after 'b' throws, proving the
+        // loop doesn't stop or skip ahead when a non-terminal rollback fails.
+        expect(calls).toEqual(['replace:a', 'replace:b', 'replace:c', 'rollback:c', 'rollback:b', 'rollback:a']);
+    });
+    describe('artifact-state persistence across multiple calls (BLOCKER regression)', () => {
+        // A real `awm init` run makes several separate applyInstallPlan calls
+        // in sequence — one per bundle (dev-core, each ambient bundle, each
+        // synced project extension). Each call's plan.records only covers the
+        // artifacts THAT call touched. Persisting must be additive: an
+        // earlier call's ownership records must survive a later call, not be
+        // silently discarded by a wholesale overwrite of state/artifacts.json.
+        function sourceFor(name) {
+            const src = path_1.default.join(tmpWork, `${name}-source`);
+            fs_1.default.mkdirSync(src, { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(src, 'file.txt'), name);
+            return src;
+        }
+        function planFor(name, targetPath) {
+            const op = makeOp(name, { targetPath, sourcePath: sourceFor(name) });
+            return { operations: [op], records: [op], reports: [{ owner: 'claude-code', targetPath, action: 'install' }] };
+        }
+        it('preserves an earlier applyInstallPlan call’s records after a later call for a DIFFERENT target', () => {
+            const targetA = path_1.default.join(tmpWork, 'target-a');
+            const targetB = path_1.default.join(tmpWork, 'target-b');
+            (0, install_transaction_1.applyInstallPlan)(planFor('a', targetA));
+            (0, install_transaction_1.applyInstallPlan)(planFor('b', targetB));
+            const state = (0, artifact_state_1.readArtifactState)();
+            expect(state.map((r) => r.targetPath).sort()).toEqual([targetA, targetB].sort());
+        });
+        it('replaces (does not duplicate) the record for a targetPath touched by two separate applyInstallPlan calls', () => {
+            const targetA = path_1.default.join(tmpWork, 'target-a');
+            (0, install_transaction_1.applyInstallPlan)(planFor('a', targetA));
+            const secondOp = makeOp('a', { targetPath: targetA, sourcePath: sourceFor('a2'), owners: ['claude-code', 'codex'] });
+            (0, install_transaction_1.applyInstallPlan)({
+                operations: [secondOp],
+                records: [secondOp],
+                reports: [{ owner: 'codex', targetPath: targetA, action: 'retain' }],
+            });
+            const state = (0, artifact_state_1.readArtifactState)();
+            expect(state).toHaveLength(1);
+            expect(state[0].targetPath).toBe(targetA);
+            expect(state[0].owners).toEqual(['claude-code', 'codex']);
+        });
+    });
+});
+describe('beginBackupSession / restoreBackup', () => {
+    it('backs up existing targets before mutation and restores them on rollback', () => {
+        const fileA = path_1.default.join(tmpWork, 'a.json');
+        const fileB = path_1.default.join(tmpWork, 'b.json');
+        fs_1.default.writeFileSync(fileA, 'A-before');
+        fs_1.default.writeFileSync(fileB, 'B-before');
+        const session = (0, install_transaction_1.beginBackupSession)([fileA, fileB]);
+        fs_1.default.writeFileSync(fileA, 'A-after');
+        fs_1.default.writeFileSync(fileB, 'B-after');
+        session.rollback();
+        expect(fs_1.default.readFileSync(fileA, 'utf8')).toBe('A-before');
+        expect(fs_1.default.readFileSync(fileB, 'utf8')).toBe('B-before');
+    });
+    it('removes a target that did not exist before the session, on rollback', () => {
+        const newFile = path_1.default.join(tmpWork, 'created.json');
+        const session = (0, install_transaction_1.beginBackupSession)([newFile]);
+        fs_1.default.writeFileSync(newFile, 'created content');
+        session.rollback();
+        expect(fs_1.default.existsSync(newFile)).toBe(false);
+    });
+    it('commit marks the manifest committed without restoring anything', () => {
+        const fileA = path_1.default.join(tmpWork, 'c.json');
+        fs_1.default.writeFileSync(fileA, 'C-before');
+        const session = (0, install_transaction_1.beginBackupSession)([fileA]);
+        fs_1.default.writeFileSync(fileA, 'C-after');
+        session.commit();
+        expect(fs_1.default.readFileSync(fileA, 'utf8')).toBe('C-after');
+        const manifestPath = path_1.default.join(process.env.AWM_HOME, 'backups', session.transactionId, 'manifest.json');
+        const manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf8'));
+        expect(manifest.committed).toBe(true);
+    });
+    it('refuses to back up a filesystem root', () => {
+        expect(() => (0, install_transaction_1.beginBackupSession)(['/'])).toThrow('refusing to back up a filesystem root');
+    });
+    it('creates the backup directory and manifest with restrictive permissions, no content leaked', () => {
+        const fileA = path_1.default.join(tmpWork, 'perm.json');
+        fs_1.default.writeFileSync(fileA, 'secret-content');
+        const session = (0, install_transaction_1.beginBackupSession)([fileA]);
+        const backupDir = path_1.default.join(process.env.AWM_HOME, 'backups', session.transactionId);
+        const dirMode = fs_1.default.statSync(backupDir).mode & 0o777;
+        const manifestPath = path_1.default.join(backupDir, 'manifest.json');
+        const manifestMode = fs_1.default.statSync(manifestPath).mode & 0o777;
+        expect(dirMode).toBe(0o700);
+        expect(manifestMode).toBe(0o600);
+        const manifestRaw = fs_1.default.readFileSync(manifestPath, 'utf8');
+        expect(manifestRaw).not.toContain('secret-content');
+    });
+    it('restoreBackup restores exactly the manifest targets', () => {
+        const fileA = path_1.default.join(tmpWork, 'd.json');
+        fs_1.default.writeFileSync(fileA, 'D-before');
+        const session = (0, install_transaction_1.beginBackupSession)([fileA]);
+        fs_1.default.writeFileSync(fileA, 'D-after');
+        const result = (0, install_transaction_1.restoreBackup)(session.transactionId);
+        expect(result.restored).toEqual([fileA]);
+        expect(fs_1.default.readFileSync(fileA, 'utf8')).toBe('D-before');
+    });
+});

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

@@ -0,0 +1,64 @@
+"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 provider_artifacts_1 = require("../../src/core/provider-artifacts");
+describe('preflightLinkArtifactPairs', () => {
+    it('rejects a mixed Codex selection before any installer call', () => {
+        const install = jest.fn();
+        expect(() => {
+            const pairs = [
+                { agent: 'codex', artifact: { type: 'skill', name: 'linked-skill' } },
+                { agent: 'codex', artifact: { type: 'agent', name: 'toml-agent' } },
+            ];
+            (0, provider_artifacts_1.preflightLinkArtifactPairs)(pairs);
+            for (const item of pairs)
+                install(item);
+        }).toThrow("Renderer 'codex-agent-toml' for codex agent artifacts is not implemented yet");
+        expect(install).not.toHaveBeenCalled();
+    });
+});
+describe('scanLegacyArtifacts', () => {
+    const originalHome = process.env.HOME;
+    const originalAwmHome = process.env.AWM_HOME;
+    let tmpHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-provider-artifacts-'));
+        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 });
+    });
+    it('never lists Codex TOML agents for legacy removal', () => {
+        const skillPath = path_1.default.join(tmpHome, '.agents/skills/linked-skill');
+        const agentPath = path_1.default.join(tmpHome, '.codex/agents/protected.toml');
+        fs_1.default.mkdirSync(skillPath, { recursive: true });
+        fs_1.default.mkdirSync(path_1.default.dirname(agentPath), { recursive: true });
+        fs_1.default.writeFileSync(agentPath, 'name = "protected"\n');
+        const listed = (0, provider_artifacts_1.scanLegacyArtifacts)(['codex'], 'global');
+        const legacyRemove = jest.fn((target) => fs_1.default.rmSync(target, {
+            recursive: true,
+            force: true,
+        }));
+        for (const artifact of listed) {
+            for (const fullPath of artifact.fullPaths)
+                legacyRemove(fullPath);
+        }
+        expect(listed.map((artifact) => artifact.name)).toEqual(['linked-skill']);
+        expect(legacyRemove).not.toHaveBeenCalledWith(agentPath);
+        expect(fs_1.default.existsSync(agentPath)).toBe(true);
+    });
+});

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const provider_version_1 = require("../../src/core/provider-version");
+describe('assertProviderSupported', () => {
+    it('accepts the current stable Codex line', () => {
+        const exec = jest.fn(() => Buffer.from('codex-cli 0.145.0\n'));
+        expect((0, provider_version_1.assertProviderSupported)('codex', exec)).toEqual({
+            provider: 'codex',
+            version: '0.145.0',
+        });
+        expect(exec).toHaveBeenCalledWith('codex', ['--version'], expect.any(Object));
+    });
+    it.each(['0.145.1', '0.146.0', '1.0.0'])('accepts stable Codex version %s above the minimum', (version) => {
+        expect((0, provider_version_1.assertProviderSupported)('codex', () => Buffer.from(`codex-cli ${version}\n`))).toEqual({ provider: 'codex', version });
+    });
+    it.each([
+        [Buffer.from('codex-cli 0.144.9\n'), 'requires Codex >= 0.145.0'],
+        [Buffer.from('unknown\n'), 'could not parse Codex version'],
+        [Buffer.from('codex-cli 0.145.0-beta.1\n'), 'could not parse Codex version'],
+        [Buffer.from('codex-cli v0.145.0\n'), 'could not parse Codex version'],
+        [Buffer.from('codex-cli 0.145\n'), 'could not parse Codex version'],
+        [Buffer.from('unexpected-tool 9.9.9\n'), 'could not parse Codex version'],
+        [Buffer.from('notice: codex-cli 0.145.0\n'), 'could not parse Codex version'],
+        [Buffer.from('codex-cli stable 0.145.0\n'), 'could not parse Codex version'],
+        [Buffer.from('codex-cli 0.145.0 trailing\n'), 'could not parse Codex version'],
+    ])('rejects unsupported output without mutation', (output, message) => {
+        expect(() => (0, provider_version_1.assertProviderSupported)('codex', () => output)).toThrow(message);
+    });
+    it('returns a null version for providers without a version gate', () => {
+        const exec = jest.fn();
+        expect((0, provider_version_1.assertProviderSupported)('claude-code', exec)).toEqual({
+            provider: 'claude-code',
+            version: null,
+        });
+        expect(exec).not.toHaveBeenCalled();
+    });
+    it('reports a missing Codex binary distinctly', () => {
+        const missing = Object.assign(new Error('spawnSync codex ENOENT'), { code: 'ENOENT' });
+        expect(() => (0, provider_version_1.assertProviderSupported)('codex', () => { throw missing; }))
+            .toThrow('Codex is not installed or not available on PATH');
+    });
+    it('reports other Codex probe failures distinctly', () => {
+        expect(() => (0, provider_version_1.assertProviderSupported)('codex', () => {
+            throw new Error('permission denied');
+        })).toThrow('Codex version probe failed: permission denied');
+    });
+    it('fails loudly for invalid runtime provider input', () => {
+        const exec = jest.fn();
+        expect(() => (0, provider_version_1.assertProviderSupported)('invalid', exec))
+            .toThrow('Unknown agent target');
+        expect(exec).not.toHaveBeenCalled();
+    });
+});