agentic-workflow-manager 3.1.0 → 3.2.1

package/dist/tests/commands/doctor.test.js

@@ -60,11 +60,29 @@ describe('renderReport', () => {
 });
 describe('runDoctor', () => {
     let tmpHome;
+    let tmpWork;
     let originalHome;
     let originalAwmHome;
     let writeSpy;
+    function stdout() {
+        return writeSpy.mock.calls.map((c) => c[0]).join('');
+    }
+    function prefsWith(enabledAgents) {
+        return {
+            defaultAgent: enabledAgents[0],
+            enabledAgents,
+            installMethod: 'symlink',
+            defaultScope: 'local',
+        };
+    }
+    function writePrefs(prefs) {
+        const dir = path_1.default.join(tmpHome, '.awm');
+        fs_1.default.mkdirSync(dir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'preferences.json'), JSON.stringify(prefs, null, 2) + '\n');
+    }
     beforeEach(() => {
         tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-doctor-run-'));
+        tmpWork = tmpHome;
         originalHome = process.env.HOME;
         originalAwmHome = process.env.AWM_HOME;
         process.env.HOME = tmpHome;
@@ -87,12 +105,55 @@ describe('runDoctor', () => {
         const code = (0, doctor_1.runDoctor)({ cwd: tmpHome });
         expect(code).toBe(1);
     });
-    it('--json emits a parseable CheckReport and keeps the same exit code', () => {
+    it('--json emits a parseable provider report and keeps the same exit code', () => {
         const code = (0, doctor_1.runDoctor)({ cwd: tmpHome, json: true });
-        const written = writeSpy.mock.calls.map((c) => c[0]).join('');
-        const parsed = JSON.parse(written);
+        const parsed = JSON.parse(stdout());
         expect(parsed.overall).toBe('degraded');
-        expect(Array.isArray(parsed.results)).toBe(true);
+        expect(Array.isArray(parsed.providers)).toBe(true);
         expect(code).toBe(1);
     });
+    it('reports every enabled provider and stable remediation codes in JSON', () => {
+        writePrefs(prefsWith(['claude-code', 'opencode', 'codex']));
+        const code = (0, doctor_1.runDoctor)({ cwd: tmpWork, json: true });
+        const report = JSON.parse(stdout());
+        expect(report.providers.map((provider) => provider.id))
+            .toEqual(['claude-code', 'opencode', 'codex']); // verifies R12
+        expect(report.providers.find((provider) => provider.id === 'codex'))
+            .toMatchObject({
+            checks: expect.arrayContaining([
+                expect.objectContaining({ id: 'binary.version' }),
+                expect.objectContaining({ id: 'skills.global' }),
+                expect.objectContaining({ id: 'agents.native' }),
+                expect.objectContaining({ id: 'hook.trust' }),
+            ]),
+        }); // verifies R2, R7, R8, R18
+        expect(code).toBe(1);
+    });
+    it('reports a clear, specific error for an invalid --agent value, not a generic "internal error"', () => {
+        const errSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        try {
+            const code = (0, doctor_1.runDoctor)({ cwd: tmpHome, agent: 'not-a-real-agent' });
+            expect(code).toBe(2);
+            const written = errSpy.mock.calls.map((c) => c[0]).join('');
+            expect(written).toContain('awm doctor: Invalid agent "not-a-real-agent"');
+            expect(written).not.toContain('internal error');
+        }
+        finally {
+            errSpy.mockRestore();
+        }
+    });
+    it('reports a clear error when --agent names a target that is not enabled', () => {
+        const errSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        try {
+            // Bare HOME → default preferences enable only claude-code.
+            const code = (0, doctor_1.runDoctor)({ cwd: tmpHome, agent: 'codex' });
+            expect(code).toBe(2);
+            const written = errSpy.mock.calls.map((c) => c[0]).join('');
+            expect(written).toContain('awm doctor: codex is not enabled');
+            expect(written).not.toContain('internal error');
+        }
+        finally {
+            errSpy.mockRestore();
+        }
+    });
 });

package/dist/tests/commands/hooks/codex.test.js

@@ -0,0 +1,230 @@
+"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 path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const crypto_1 = __importDefault(require("crypto"));
+describe('installHook / computeHookStatus / uninstallHook — Codex adapter', () => {
+    let tmpHome;
+    let tmpRegistry;
+    let hooksJson;
+    let codexScriptsDir;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-codex-'));
+        tmpRegistry = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-codex-registry-'));
+        hooksJson = path_1.default.join(tmpHome, '.codex/hooks.json');
+        codexScriptsDir = path_1.default.join(tmpHome, '.awm/hooks/codex');
+        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 });
+        fs_1.default.rmSync(tmpRegistry, { 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 writeRegistry(content = '#!/usr/bin/env bash\necho "{}"') {
+        const regHooks = path_1.default.join(tmpRegistry, 'hooks');
+        fs_1.default.mkdirSync(regHooks, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(regHooks, 'codex-session-start'), content, { mode: 0o755 });
+    }
+    function awmSessionStartEntry() {
+        return {
+            matcher: 'startup|resume|clear|compact',
+            hooks: [{
+                    type: 'command',
+                    command: path_1.default.join(codexScriptsDir, 'session-start'),
+                    statusMessage: 'Loading AWM session state',
+                }],
+        };
+    }
+    it('merges one AWM SessionStart group and preserves user hooks', () => {
+        fs_1.default.mkdirSync(path_1.default.dirname(hooksJson), { recursive: true });
+        fs_1.default.writeFileSync(hooksJson, JSON.stringify({
+            description: 'user hooks',
+            hooks: { Stop: [{ hooks: [{ type: 'command', command: 'echo stop' }] }] },
+        }));
+        writeRegistry();
+        const { installHook } = require('../../../src/commands/hooks/install');
+        installHook({ agent: 'codex', registryRoot: tmpRegistry, installMethod: 'copy' });
+        const cfg = JSON.parse(fs_1.default.readFileSync(hooksJson, 'utf8'));
+        expect(cfg.description).toBe('user hooks');
+        expect(cfg.hooks.Stop).toHaveLength(1);
+        expect(cfg.hooks.SessionStart).toEqual([{
+                matcher: 'startup|resume|clear|compact',
+                hooks: [{
+                        type: 'command',
+                        command: path_1.default.join(tmpHome, '.awm/hooks/codex/session-start'),
+                        statusMessage: 'Loading AWM session state',
+                    }],
+            }]); // verifies R3, R3.1
+        expect(fs_1.default.existsSync(path_1.default.join(codexScriptsDir, 'session-start'))).toBe(true);
+    });
+    it('installs cleanly with no pre-existing hooks.json', () => {
+        writeRegistry();
+        const { installHook } = require('../../../src/commands/hooks/install');
+        const result = installHook({ agent: 'codex', registryRoot: tmpRegistry, installMethod: 'symlink' });
+        expect(result.status).toBe('installed');
+        expect(result.backupPath).toBeNull();
+        const cfg = JSON.parse(fs_1.default.readFileSync(hooksJson, 'utf8'));
+        expect(cfg.hooks.SessionStart).toEqual([awmSessionStartEntry()]);
+        expect(fs_1.default.lstatSync(path_1.default.join(codexScriptsDir, 'session-start')).isSymbolicLink()).toBe(true);
+    });
+    it('fails fast when the registry has no codex-session-start source', () => {
+        const { installHook } = require('../../../src/commands/hooks/install');
+        expect(() => installHook({ agent: 'codex', registryRoot: tmpRegistry, installMethod: 'copy' }))
+            .toThrow(/Codex hook source missing/);
+        expect(fs_1.default.existsSync(hooksJson)).toBe(false);
+    });
+    it('refuses duplicate AWM entries without rewriting hooks.json', () => {
+        writeRegistry();
+        fs_1.default.mkdirSync(path_1.default.dirname(hooksJson), { recursive: true });
+        const duplicateAwmHookConfig = {
+            hooks: {
+                SessionStart: [awmSessionStartEntry(), awmSessionStartEntry()],
+            },
+        };
+        fs_1.default.writeFileSync(hooksJson, JSON.stringify(duplicateAwmHookConfig, null, 2));
+        const before = fs_1.default.readFileSync(hooksJson, 'utf8');
+        const { installHook } = require('../../../src/commands/hooks/install');
+        expect(() => installHook({ agent: 'codex', registryRoot: tmpRegistry, installMethod: 'copy' }))
+            .toThrow('multiple AWM SessionStart entries'); // verifies R17
+        expect(fs_1.default.readFileSync(hooksJson, 'utf8')).toBe(before);
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/backups'))).toBe(false);
+    });
+    it('replaces a stale AWM entry in place when the script path changes', () => {
+        writeRegistry();
+        fs_1.default.mkdirSync(path_1.default.dirname(hooksJson), { recursive: true });
+        fs_1.default.writeFileSync(hooksJson, JSON.stringify({
+            hooks: {
+                SessionStart: [{
+                        matcher: 'startup|resume|clear|compact',
+                        hooks: [{
+                                type: 'command',
+                                command: path_1.default.join(codexScriptsDir, 'session-start'),
+                                statusMessage: 'stale message',
+                            }],
+                    }],
+            },
+        }, null, 2));
+        const { installHook } = require('../../../src/commands/hooks/install');
+        installHook({ agent: 'codex', registryRoot: tmpRegistry, installMethod: 'copy' });
+        const cfg = JSON.parse(fs_1.default.readFileSync(hooksJson, 'utf8'));
+        expect(cfg.hooks.SessionStart).toHaveLength(1);
+        expect(cfg.hooks.SessionStart[0].hooks[0].statusMessage).toBe('Loading AWM session state');
+    });
+    it('is a no-op on a second install when nothing changed (idempotent, no backup/write churn)', () => {
+        writeRegistry();
+        const { installHook } = require('../../../src/commands/hooks/install');
+        const first = installHook({ agent: 'codex', registryRoot: tmpRegistry, installMethod: 'copy' });
+        expect(first.status).toBe('installed');
+        const scriptPath = path_1.default.join(codexScriptsDir, 'session-start');
+        const contentBefore = fs_1.default.readFileSync(hooksJson, 'utf8');
+        const hooksJsonMtimeBefore = fs_1.default.statSync(hooksJson).mtimeMs;
+        const scriptMtimeBefore = fs_1.default.statSync(scriptPath).mtimeMs;
+        const second = installHook({ agent: 'codex', registryRoot: tmpRegistry, installMethod: 'copy' });
+        expect(second.status).toBe('already-up-to-date');
+        expect(second.backupPath).toBeNull();
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/backups'))).toBe(false); // no backup churn
+        expect(fs_1.default.readFileSync(hooksJson, 'utf8')).toBe(contentBefore);
+        expect(fs_1.default.statSync(hooksJson).mtimeMs).toBe(hooksJsonMtimeBefore);
+        expect(fs_1.default.statSync(scriptPath).mtimeMs).toBe(scriptMtimeBefore);
+    });
+    function hashOf(file) {
+        return crypto_1.default.createHash('sha256').update(fs_1.default.readFileSync(file)).digest('hex');
+    }
+    function installCodexFixture({ heartbeat }) {
+        fs_1.default.mkdirSync(codexScriptsDir, { recursive: true });
+        const scriptPath = path_1.default.join(codexScriptsDir, 'session-start');
+        fs_1.default.writeFileSync(scriptPath, '#!/usr/bin/env bash\necho "hi"', { mode: 0o755 });
+        fs_1.default.mkdirSync(path_1.default.dirname(hooksJson), { recursive: true });
+        fs_1.default.writeFileSync(hooksJson, JSON.stringify({
+            hooks: { SessionStart: [awmSessionStartEntry()] },
+        }, null, 2));
+        if (heartbeat) {
+            fs_1.default.writeFileSync(path_1.default.join(codexScriptsDir, 'heartbeat.json'), JSON.stringify({ hash: hashOf(scriptPath), ts: new Date().toISOString() }));
+        }
+    }
+    it.each([
+        [false, 'pending-trust'],
+        [true, 'healthy'],
+    ])('derives trust from a current heartbeat (heartbeat present=%s)', (heartbeat, expected) => {
+        installCodexFixture({ heartbeat: heartbeat });
+        const { computeHookStatus } = require('../../../src/commands/hooks/status');
+        expect(computeHookStatus('codex').trust).toBe(expected); // verifies R18
+    });
+    it('reports stale trust when the heartbeat hash no longer matches the installed script', () => {
+        installCodexFixture({ heartbeat: true });
+        fs_1.default.writeFileSync(path_1.default.join(codexScriptsDir, 'session-start'), '#!/usr/bin/env bash\necho "changed"', { mode: 0o755 });
+        const { computeHookStatus } = require('../../../src/commands/hooks/status');
+        expect(computeHookStatus('codex').trust).toBe('stale');
+    });
+    it('degrades to stale (not throwing) when heartbeat.json is malformed JSON', () => {
+        installCodexFixture({ heartbeat: false });
+        fs_1.default.writeFileSync(path_1.default.join(codexScriptsDir, 'heartbeat.json'), '{ not valid json');
+        const { computeHookStatus } = require('../../../src/commands/hooks/status');
+        let result;
+        expect(() => { result = computeHookStatus('codex'); }).not.toThrow();
+        expect(result.trust).toBe('stale');
+    });
+    it('omits trust entirely when the AWM entry is not present in hooks.json', () => {
+        // Script + heartbeat both exist (e.g. left over from a prior install),
+        // but hooks.json has no AWM SessionStart entry — nothing to trust.
+        fs_1.default.mkdirSync(codexScriptsDir, { recursive: true });
+        const scriptPath = path_1.default.join(codexScriptsDir, 'session-start');
+        fs_1.default.writeFileSync(scriptPath, '#!/usr/bin/env bash\necho "hi"', { mode: 0o755 });
+        fs_1.default.writeFileSync(path_1.default.join(codexScriptsDir, 'heartbeat.json'), JSON.stringify({ hash: hashOf(scriptPath), ts: new Date().toISOString() }));
+        const { computeHookStatus } = require('../../../src/commands/hooks/status');
+        const result = computeHookStatus('codex');
+        expect(result.checks.settingsEntry.ok).toBe(false);
+        expect(result.trust).toBeUndefined();
+    });
+    it('reports HEALTHY overall with no bootstrapSkill/runHookWrapper checks', () => {
+        installCodexFixture({ heartbeat: true });
+        const { computeHookStatus } = require('../../../src/commands/hooks/status');
+        const result = computeHookStatus('codex');
+        expect(result.overall).toBe('HEALTHY');
+        expect(result.checks.sessionStartScript.ok).toBe(true);
+        expect(result.checks.settingsEntry.ok).toBe(true);
+        expect(result.checks.bootstrapSkill).toBeUndefined();
+        expect(result.checks.runHookWrapper).toBeUndefined();
+    });
+    it('uninstall removes only the AWM entry and preserves other Codex hooks', () => {
+        fs_1.default.mkdirSync(path_1.default.dirname(hooksJson), { recursive: true });
+        fs_1.default.writeFileSync(hooksJson, JSON.stringify({
+            description: 'user hooks',
+            hooks: {
+                Stop: [{ hooks: [{ type: 'command', command: 'echo stop' }] }],
+                SessionStart: [awmSessionStartEntry()],
+            },
+        }, null, 2));
+        const { uninstallHook } = require('../../../src/commands/hooks/uninstall');
+        const result = uninstallHook({ agent: 'codex' });
+        expect(result.status).toBe('uninstalled');
+        expect(result.backupPath).not.toBeNull();
+        const cfg = JSON.parse(fs_1.default.readFileSync(hooksJson, 'utf8'));
+        expect(cfg.description).toBe('user hooks');
+        expect(cfg.hooks.Stop).toHaveLength(1);
+        expect(cfg.hooks.SessionStart).toBeUndefined();
+    });
+    it('uninstall is a no-op when hooks.json does not exist', () => {
+        const { uninstallHook } = require('../../../src/commands/hooks/uninstall');
+        const result = uninstallHook({ agent: 'codex' });
+        expect(result.status).toBe('not-installed');
+        expect(result.backupPath).toBeNull();
+    });
+});

package/dist/tests/commands/hooks/install.test.js

@@ -144,6 +144,25 @@ describe('installHook (happy path + merge)', () => {
     it('throws for unsupported agent target', () => {
         const { installHook } = require('../../../src/commands/hooks/install');
         expect(() => installHook({ agent: 'antigravity', registryRoot: tmpRegistry, installMethod: 'symlink' }))
-            .toThrow(/not supported/);
+            .toThrow(/hooks not supported/);
+    });
+    // Characterization test (Task 7, Step 1): freezes the Claude adapter's
+    // observable contract — matcher, ordering, and untouched unrelated
+    // settings/hooks keys — before the Claude-specific logic moves into
+    // claude.ts. Verifies R19.
+    it('keeps the Claude SessionStart matcher and unrelated settings unchanged', () => {
+        const claudeDir = path_1.default.join(tmpHome, '.claude');
+        fs_1.default.mkdirSync(claudeDir, { recursive: true });
+        const settingsPath = path_1.default.join(claudeDir, 'settings.json');
+        fs_1.default.writeFileSync(settingsPath, JSON.stringify({
+            permissions: { allow: ['Read'] },
+            hooks: { SessionEnd: [{ hooks: [{ type: 'command', command: 'echo bye' }] }] },
+        }));
+        const { installHook } = require('../../../src/commands/hooks/install');
+        installHook({ agent: 'claude-code', registryRoot: tmpRegistry, installMethod: 'copy' });
+        const settings = JSON.parse(fs_1.default.readFileSync(settingsPath, 'utf8'));
+        expect(settings.permissions).toEqual({ allow: ['Read'] });
+        expect(settings.hooks.SessionEnd).toHaveLength(1);
+        expect(settings.hooks.SessionStart[0].matcher).toBe('startup|clear|compact');
     });
 });

package/dist/tests/commands/hooks/resync.test.js

@@ -62,7 +62,10 @@ describe('resyncInstalledHooks', () => {
         writeSettingsWithAwmEntry(scriptsDir);
         const { resyncInstalledHooks } = require('../../../src/commands/hooks/resync');
         const results = resyncInstalledHooks(tmpRegistry);
-        expect(results).toEqual([{ agent: 'claude-code', action: 'resynced' }]);
+        expect(results).toEqual([
+            { agent: 'claude-code', action: 'resynced' },
+            { agent: 'codex', action: 'not-installed' },
+        ]);
         const synced = fs_1.default.readFileSync(path_1.default.join(scriptsDir, 'session-start'), 'utf-8');
         expect(synced).toContain('NEW VERSION');
         expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'session-start')).isSymbolicLink()).toBe(false);
@@ -73,7 +76,10 @@ describe('resyncInstalledHooks', () => {
         writeRegistry('#!/usr/bin/env bash\necho "NEW VERSION"');
         const { resyncInstalledHooks } = require('../../../src/commands/hooks/resync');
         const results = resyncInstalledHooks(tmpRegistry);
-        expect(results).toEqual([{ agent: 'claude-code', action: 'not-installed' }]);
+        expect(results).toEqual([
+            { agent: 'claude-code', action: 'not-installed' },
+            { agent: 'codex', action: 'not-installed' },
+        ]);
         expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/hooks/session-start'))).toBe(false);
     });
     it('preserves symlink install method', () => {
@@ -85,7 +91,10 @@ describe('resyncInstalledHooks', () => {
         writeSettingsWithAwmEntry(scriptsDir);
         const { resyncInstalledHooks } = require('../../../src/commands/hooks/resync');
         const results = resyncInstalledHooks(tmpRegistry);
-        expect(results).toEqual([{ agent: 'claude-code', action: 'resynced' }]);
+        expect(results).toEqual([
+            { agent: 'claude-code', action: 'resynced' },
+            { agent: 'codex', action: 'not-installed' },
+        ]);
         expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'session-start')).isSymbolicLink()).toBe(true);
         expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'using-awm.md')).isSymbolicLink()).toBe(true);
     });
@@ -96,7 +105,10 @@ describe('resyncInstalledHooks', () => {
         writeSettingsWithAwmEntry(scriptsDir);
         const { resyncInstalledHooks } = require('../../../src/commands/hooks/resync');
         const results = resyncInstalledHooks(tmpRegistry);
-        expect(results).toEqual([{ agent: 'claude-code', action: 'registry-missing' }]);
+        expect(results).toEqual([
+            { agent: 'claude-code', action: 'registry-missing' },
+            { agent: 'codex', action: 'not-installed' },
+        ]);
         expect(fs_1.default.readFileSync(path_1.default.join(scriptsDir, 'session-start'), 'utf-8')).toContain('OLD');
     });
     it('re-creates session-start as copy when scriptsDir exists but session-start is missing', () => {
@@ -108,7 +120,10 @@ describe('resyncInstalledHooks', () => {
         writeSettingsWithAwmEntry(scriptsDir);
         const { resyncInstalledHooks } = require('../../../src/commands/hooks/resync');
         const results = resyncInstalledHooks(tmpRegistry);
-        expect(results).toEqual([{ agent: 'claude-code', action: 'resynced' }]);
+        expect(results).toEqual([
+            { agent: 'claude-code', action: 'resynced' },
+            { agent: 'codex', action: 'not-installed' },
+        ]);
         expect(fs_1.default.existsSync(path_1.default.join(scriptsDir, 'session-start'))).toBe(true);
         // detectInstallMethod fell back to copy since lstatSync threw
         expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'session-start')).isSymbolicLink()).toBe(false);
@@ -128,8 +143,40 @@ describe('resyncInstalledHooks', () => {
         writeSettingsWithAwmEntry(scriptsDir);
         const { resyncInstalledHooks } = require('../../../src/commands/hooks/resync');
         const results = resyncInstalledHooks(tmpRegistry);
-        expect(results).toEqual([{ agent: 'claude-code', action: 'registry-missing' }]);
+        expect(results).toEqual([
+            { agent: 'claude-code', action: 'registry-missing' },
+            { agent: 'codex', action: 'not-installed' },
+        ]);
         // old script left intact — never leave user without hook
         expect(fs_1.default.readFileSync(path_1.default.join(scriptsDir, 'session-start'), 'utf-8')).toContain('OLD');
     });
+    it('refreshes an installed Codex hook script and skips the untouched Claude target', () => {
+        const codexScriptsDir = path_1.default.join(tmpHome, '.awm/hooks/codex');
+        fs_1.default.mkdirSync(codexScriptsDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(codexScriptsDir, 'session-start'), '#!/usr/bin/env bash\necho "OLD CODEX"', { mode: 0o755 });
+        const codexHooksPath = path_1.default.join(tmpHome, '.codex/hooks.json');
+        fs_1.default.mkdirSync(path_1.default.dirname(codexHooksPath), { recursive: true });
+        fs_1.default.writeFileSync(codexHooksPath, JSON.stringify({
+            hooks: {
+                SessionStart: [{
+                        matcher: 'startup|resume|clear|compact',
+                        hooks: [{
+                                type: 'command',
+                                command: path_1.default.join(codexScriptsDir, 'session-start'),
+                                statusMessage: 'Loading AWM session state',
+                            }],
+                    }],
+            },
+        }, null, 2));
+        const regHooks = path_1.default.join(tmpRegistry, 'hooks');
+        fs_1.default.mkdirSync(regHooks, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(regHooks, 'codex-session-start'), '#!/usr/bin/env bash\necho "NEW CODEX"', { mode: 0o755 });
+        const { resyncInstalledHooks } = require('../../../src/commands/hooks/resync');
+        const results = resyncInstalledHooks(tmpRegistry);
+        expect(results).toEqual([
+            { agent: 'claude-code', action: 'not-installed' },
+            { agent: 'codex', action: 'resynced' },
+        ]);
+        expect(fs_1.default.readFileSync(path_1.default.join(codexScriptsDir, 'session-start'), 'utf-8')).toContain('NEW CODEX');
+    });
 });

package/dist/tests/commands/hooks/status.test.js

@@ -85,4 +85,14 @@ describe('computeHookStatus', () => {
         const { computeHookStatus } = require('../../../src/commands/hooks/status');
         expect(() => computeHookStatus('antigravity')).toThrow(/hooks not supported/i);
     });
+    it('dispatches Codex targets to the Codex status checks (not the Claude ones)', () => {
+        // No Codex hook installed in this tmpHome — should report NOT/DEGRADED
+        // via the Codex-specific checks (sessionStartScript, settingsEntry),
+        // never touching Claude's settings.json path.
+        const { computeHookStatus } = require('../../../src/commands/hooks/status');
+        const result = computeHookStatus('codex');
+        expect(result.checks.settingsEntry.detail).toContain('.codex/hooks.json');
+        expect(result.checks.bootstrapSkill).toBeUndefined();
+        expect(result.checks.runHookWrapper).toBeUndefined();
+    });
 });

package/dist/tests/commands/hooks/uninstall.test.js

@@ -101,4 +101,16 @@ describe('uninstallHook', () => {
         expect(result.backupPath).not.toBeNull();
         expect(fs_1.default.existsSync(result.backupPath)).toBe(true);
     });
+    it('is a no-op for Codex when hooks.json has no AWM entry (dispatch sanity check)', () => {
+        const codexDir = path_1.default.join(tmpHome, '.codex');
+        const hooksPath = path_1.default.join(codexDir, 'hooks.json');
+        const original = '{ "description": "user content" }\n';
+        fs_1.default.mkdirSync(codexDir, { recursive: true });
+        fs_1.default.writeFileSync(hooksPath, original);
+        const { uninstallHook } = require('../../../src/commands/hooks/uninstall');
+        const result = uninstallHook({ agent: 'codex' });
+        expect(result.status).toBe('not-installed');
+        expect(fs_1.default.readFileSync(hooksPath, 'utf-8')).toBe(original);
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/backups'))).toBe(false);
+    });
 });