agentic-workflow-manager 3.0.1 → 3.2.0

package/dist/src/commands/hooks/codex.js

@@ -0,0 +1,191 @@
+"use strict";
+// cli/src/commands/hooks/codex.ts
+//
+// Codex hook adapter: merges a single AWM SessionStart entry into
+// ~/.codex/hooks.json. Unlike Claude's wrapper-script model, the Codex
+// SessionStart entry invokes the installed script directly (no run-hook.cmd
+// indirection, no bootstrap-skill symlink).
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.awmCodexEntry = awmCodexEntry;
+exports.installCodexHook = installCodexHook;
+exports.computeCodexHookStatus = computeCodexHookStatus;
+exports.uninstallCodexHook = uninstallCodexHook;
+exports.resyncCodexHookFiles = resyncCodexHookFiles;
+exports.codexResyncSourcesExist = codexResyncSourcesExist;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const providers_1 = require("../../providers");
+const shared_1 = require("./shared");
+const atomic_file_1 = require("../../core/atomic-file");
+function codexMatcher() {
+    const config = (0, providers_1.getHookConfig)('codex');
+    if (!config || config.type !== 'codex-hooks-json') {
+        throw new Error('Codex hook configuration is unavailable');
+    }
+    return config.matcher;
+}
+function awmCodexEntry(scriptsDir) {
+    return {
+        matcher: codexMatcher(),
+        hooks: [{
+                type: 'command',
+                command: path_1.default.join(scriptsDir, 'session-start'),
+                statusMessage: 'Loading AWM session state',
+            }],
+    };
+}
+function isAwmCodexEntry(entry, scriptsDir) {
+    return (entry?.matcher === codexMatcher() &&
+        Array.isArray(entry?.hooks) &&
+        entry.hooks.some((h) => typeof h?.command === 'string' && h.command.includes(scriptsDir)));
+}
+function installCodexHook(options) {
+    const config = (0, providers_1.getHookConfig)('codex');
+    if (!config || config.type !== 'codex-hooks-json') {
+        throw new Error('Codex hook configuration is unavailable');
+    }
+    const source = path_1.default.join(options.registryRoot, 'hooks/codex-session-start');
+    if (!fs_1.default.existsSync(source)) {
+        throw new Error(`Codex hook source missing: ${source}. Run 'awm update' first.`);
+    }
+    const current = (0, shared_1.readStrictJson)(config.settingsPath);
+    const hooks = current.hooks && typeof current.hooks === 'object'
+        ? current.hooks
+        : {};
+    const entries = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
+    const matches = entries.filter((entry) => isAwmCodexEntry(entry, config.scriptsDir));
+    if (matches.length > 1) {
+        throw new Error('multiple AWM SessionStart entries in Codex hooks.json');
+    }
+    const newEntry = awmCodexEntry(config.scriptsDir);
+    if (matches.length === 1 && JSON.stringify(matches[0]) === JSON.stringify(newEntry)) {
+        return { status: 'already-up-to-date', scriptsDir: config.scriptsDir, settingsPath: config.settingsPath, backupPath: null };
+    }
+    const nextEntries = matches.length === 1
+        ? entries.map((entry) => isAwmCodexEntry(entry, config.scriptsDir) ? newEntry : entry)
+        : [...entries, newEntry];
+    const merged = { ...current, hooks: { ...hooks, SessionStart: nextEntries } };
+    const backupPath = (0, shared_1.backupManagedFile)(config.settingsPath);
+    (0, shared_1.syncExecutable)(source, path_1.default.join(config.scriptsDir, 'session-start'), options.installMethod);
+    (0, atomic_file_1.writeFileAtomic)(config.settingsPath, JSON.stringify(merged, null, 2) + '\n');
+    return { status: 'installed', scriptsDir: config.scriptsDir, settingsPath: config.settingsPath, backupPath };
+}
+function checkCodexSettingsEntry(settingsPath, scriptsDir, matcher, eventName) {
+    if (!fs_1.default.existsSync(settingsPath)) {
+        return { ok: false, detail: `hooks.json not found: ${settingsPath}` };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs_1.default.readFileSync(settingsPath, 'utf-8'));
+    }
+    catch {
+        return { ok: false, detail: 'hooks.json is not valid JSON' };
+    }
+    const entries = parsed?.hooks?.[eventName] ?? [];
+    const awmEntry = entries.find((e) => e?.matcher === matcher &&
+        (e?.hooks ?? []).some((h) => typeof h?.command === 'string' && h.command.includes(scriptsDir)));
+    if (!awmEntry) {
+        return { ok: false, detail: `no AWM SessionStart entry in ${settingsPath}` };
+    }
+    return { ok: true, detail: settingsPath };
+}
+function hashFile(file) {
+    return crypto_1.default.createHash('sha256').update(fs_1.default.readFileSync(file)).digest('hex');
+}
+/**
+ * Trust derives from ~/.awm/hooks/codex/heartbeat.json, a small file the
+ * running session-start hook is expected to write (out of scope for this
+ * task — we only read it here). No heartbeat yet => pending-trust (hook
+ * installed but never confirmed running). Heartbeat present but its stored
+ * hash doesn't match the currently installed script => stale (resynced or
+ * tampered with since the last confirmed run). Hash matches => healthy.
+ */
+function computeCodexTrust(scriptCheck, scriptPath, heartbeatPath) {
+    if (!scriptCheck.ok)
+        return undefined;
+    if (!fs_1.default.existsSync(heartbeatPath))
+        return 'pending-trust';
+    let heartbeat;
+    try {
+        heartbeat = JSON.parse(fs_1.default.readFileSync(heartbeatPath, 'utf-8'));
+    }
+    catch {
+        return 'stale';
+    }
+    return heartbeat?.hash === hashFile(scriptPath) ? 'healthy' : 'stale';
+}
+function computeCodexHookStatus(agent) {
+    const config = (0, providers_1.getHookConfig)(agent);
+    if (!config || config.type !== 'codex-hooks-json') {
+        throw new Error('Codex hook configuration is unavailable');
+    }
+    const scriptPath = path_1.default.join(config.scriptsDir, 'session-start');
+    const heartbeatPath = path_1.default.join(config.scriptsDir, 'heartbeat.json');
+    const sessionStartScript = (0, shared_1.checkExecutable)(scriptPath);
+    const settingsEntry = checkCodexSettingsEntry(config.settingsPath, config.scriptsDir, config.matcher, config.eventName);
+    const allOk = sessionStartScript.ok && settingsEntry.ok;
+    const settingsOnlyMissing = !settingsEntry.ok && sessionStartScript.ok;
+    let overall;
+    if (allOk)
+        overall = 'HEALTHY';
+    else if (settingsOnlyMissing)
+        overall = 'NOT_INSTALLED';
+    else
+        overall = 'DEGRADED';
+    // Trust only makes sense once the AWM entry is actually present in
+    // hooks.json — otherwise there's nothing installed to trust.
+    const trust = settingsEntry.ok
+        ? computeCodexTrust(sessionStartScript, scriptPath, heartbeatPath)
+        : undefined;
+    return {
+        overall,
+        trust,
+        checks: { sessionStartScript, settingsEntry },
+    };
+}
+function uninstallCodexHook(agent) {
+    const config = (0, providers_1.getHookConfig)(agent);
+    if (!config || config.type !== 'codex-hooks-json') {
+        throw new Error('Codex hook configuration is unavailable');
+    }
+    if (!fs_1.default.existsSync(config.settingsPath)) {
+        return { status: 'not-installed', backupPath: null };
+    }
+    const current = (0, shared_1.readStrictJson)(config.settingsPath);
+    const hooks = current.hooks && typeof current.hooks === 'object'
+        ? current.hooks
+        : {};
+    const entries = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
+    const beforeLength = entries.length;
+    const filtered = entries.filter((e) => !isAwmCodexEntry(e, config.scriptsDir));
+    if (filtered.length === beforeLength) {
+        return { status: 'not-installed', backupPath: null };
+    }
+    const backupPath = (0, shared_1.backupManagedFile)(config.settingsPath);
+    const nextHooks = { ...hooks };
+    if (filtered.length === 0) {
+        delete nextHooks.SessionStart;
+    }
+    else {
+        nextHooks.SessionStart = filtered;
+    }
+    const nextConfig = { ...current, hooks: nextHooks };
+    if (Object.keys(nextHooks).length === 0) {
+        delete nextConfig.hooks;
+    }
+    (0, atomic_file_1.writeFileAtomic)(config.settingsPath, JSON.stringify(nextConfig, null, 2) + '\n');
+    return { status: 'uninstalled', backupPath };
+}
+/** Refresh the Codex hook's script file in place (used by resync). Assumes the caller has verified the settings entry is already present. */
+function resyncCodexHookFiles(config, registryRoot, method) {
+    const source = path_1.default.join(registryRoot, 'hooks/codex-session-start');
+    (0, shared_1.syncExecutable)(source, path_1.default.join(config.scriptsDir, 'session-start'), method);
+}
+/** True when the registry has everything needed to resync the Codex hook files. */
+function codexResyncSourcesExist(registryRoot) {
+    return fs_1.default.existsSync(path_1.default.join(registryRoot, 'hooks/codex-session-start'));
+}

package/dist/src/commands/hooks/index.js

@@ -10,12 +10,17 @@ const config_1 = require("../../utils/config");
 const install_1 = require("./install");
 const uninstall_1 = require("./uninstall");
 const status_1 = require("./status");
+const providers_1 = require("../../providers");
 const registries_1 = require("../../core/registries");
+const HOOK_TARGETS = providers_1.AGENT_TARGETS.filter((a) => (0, providers_1.getHookConfig)(a));
+function targetOptionDescription() {
+    return `Target harness (${HOOK_TARGETS.join('|')})`;
+}
 function registerHooksCommand(program) {
     const hooks = program.command('hooks').description('Manage SessionStart bootstrap hooks');
     hooks.command('install')
         .description('Install the AWM bootstrap hook into the target harness')
-        .option('-t, --target <target>', 'Target harness (claude-code only in this version)', 'claude-code')
+        .option('-t, --target <target>', targetOptionDescription(), 'claude-code')
         .option('-y, --yes', 'Skip interactive confirmations', false)
         .action(async (options) => {
         const agent = (options.target ?? 'claude-code');
@@ -39,8 +44,10 @@ function registerHooksCommand(program) {
             console.log(picocolors_1.default.green('✓ AWM bootstrap hook installed.'));
             console.log('');
             console.log(`  Scripts:        ${result.scriptsDir}/session-start`);
-            console.log(`                  ${result.scriptsDir}/run-hook.cmd`);
-            console.log(`                  ${result.scriptsDir}/using-awm.md → ~/.awm/registries/baseline/skills/using-awm/SKILL.md`);
+            if (agent === 'claude-code') {
+                console.log(`                  ${result.scriptsDir}/run-hook.cmd`);
+                console.log(`                  ${result.scriptsDir}/using-awm.md → ~/.awm/registries/baseline/skills/using-awm/SKILL.md`);
+            }
             console.log('');
             console.log(`  Settings file:  ${result.settingsPath}`);
             if (result.backupPath) {
@@ -52,7 +59,7 @@ function registerHooksCommand(program) {
             console.log(`  Verify:         ${picocolors_1.default.cyan('awm hooks status')}`);
             console.log(`  Remove:         ${picocolors_1.default.cyan('awm hooks uninstall')}`);
             console.log('');
-            console.log(picocolors_1.default.yellow('  ⚠ Restart Claude Code to activate the hook in existing sessions.'));
+            console.log(picocolors_1.default.yellow(`  ⚠ Restart ${(0, providers_1.providerFor)(agent).label} to activate the hook in existing sessions.`));
         }
         catch (e) {
             console.error(picocolors_1.default.red(`✗ ${e.message}`));
@@ -61,7 +68,7 @@ function registerHooksCommand(program) {
     });
     hooks.command('uninstall')
         .description('Remove the AWM bootstrap hook')
-        .option('-t, --target <target>', 'Target harness (claude-code only in this version)', 'claude-code')
+        .option('-t, --target <target>', targetOptionDescription(), 'claude-code')
         .option('-y, --yes', 'Skip interactive confirmations', false)
         .action(async (options) => {
         const agent = (options.target ?? 'claude-code');
@@ -90,17 +97,25 @@ function registerHooksCommand(program) {
     });
     hooks.command('status')
         .description('Check the bootstrap hook installation status')
-        .option('-t, --target <target>', 'Target harness (claude-code only in this version)', 'claude-code')
+        .option('-t, --target <target>', targetOptionDescription(), 'claude-code')
         .action((options) => {
         const agent = (options.target ?? 'claude-code');
         try {
             const result = (0, status_1.computeHookStatus)(agent);
             const symbol = (ok) => ok ? picocolors_1.default.green('✓') : picocolors_1.default.red('✗');
             console.log('');
-            console.log(`  Bootstrap skill:    ${symbol(result.checks.bootstrapSkill.ok)} ${result.checks.bootstrapSkill.detail}`);
+            if (result.checks.bootstrapSkill) {
+                console.log(`  Bootstrap skill:    ${symbol(result.checks.bootstrapSkill.ok)} ${result.checks.bootstrapSkill.detail}`);
+            }
             console.log(`  Session-start:      ${symbol(result.checks.sessionStartScript.ok)} ${result.checks.sessionStartScript.detail}`);
-            console.log(`  Run-hook wrapper:   ${symbol(result.checks.runHookWrapper.ok)} ${result.checks.runHookWrapper.detail}`);
+            if (result.checks.runHookWrapper) {
+                console.log(`  Run-hook wrapper:   ${symbol(result.checks.runHookWrapper.ok)} ${result.checks.runHookWrapper.detail}`);
+            }
             console.log(`  Settings entry:     ${symbol(result.checks.settingsEntry.ok)} ${result.checks.settingsEntry.detail}`);
+            if (result.trust) {
+                const trustSymbol = result.trust === 'healthy' ? picocolors_1.default.green('✓') : result.trust === 'stale' ? picocolors_1.default.red('✗') : picocolors_1.default.yellow('…');
+                console.log(`  Trust:              ${trustSymbol} ${result.trust}`);
+            }
             console.log('');
             const overall = result.overall === 'HEALTHY' ? picocolors_1.default.green(result.overall) :
                 result.overall === 'NOT_INSTALLED' ? picocolors_1.default.yellow(result.overall) :

package/dist/src/commands/hooks/install.js

@@ -1,119 +1,23 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.syncFile = syncFile;
 exports.installHook = installHook;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
 const providers_1 = require("../../providers");
-const paths_1 = require("../../core/paths");
-function syncFile(source, dest, method) {
-    try {
-        fs_1.default.unlinkSync(dest);
-    }
-    catch { /* not exists, fine */ }
-    fs_1.default.mkdirSync(path_1.default.dirname(dest), { recursive: true });
-    if (method === 'symlink') {
-        fs_1.default.symlinkSync(source, dest);
-    }
-    else {
-        fs_1.default.copyFileSync(source, dest);
-        const srcMode = fs_1.default.statSync(source).mode;
-        fs_1.default.chmodSync(dest, srcMode);
-    }
-}
-function backupSettings(settingsPath) {
-    if (!fs_1.default.existsSync(settingsPath))
-        return null;
-    const backupDir = path_1.default.join((0, paths_1.awmHome)(), 'backups');
-    fs_1.default.mkdirSync(backupDir, { recursive: true });
-    const ts = new Date().toISOString().replace(/[:.]/g, '-').replace('T', '-').slice(0, 19);
-    const backupPath = path_1.default.join(backupDir, `settings.json.${ts}.bak`);
-    fs_1.default.copyFileSync(settingsPath, backupPath);
-    return backupPath;
-}
-function isAwmEntry(entry, scriptsDir, matcher) {
-    return (entry?.matcher === matcher &&
-        Array.isArray(entry?.hooks) &&
-        entry.hooks.some((h) => typeof h?.command === 'string' && h.command.includes(scriptsDir)));
-}
+const claude_1 = require("./claude");
+const codex_1 = require("./codex");
 function installHook(options) {
     const config = (0, providers_1.getHookConfig)(options.agent);
     if (!config) {
         throw new Error(`hooks not supported for agent target: ${options.agent}`);
     }
-    // 1. Verify registry sources exist FIRST (before touching settings)
-    const sourceHooks = path_1.default.join(options.registryRoot, 'hooks');
-    const sourceSkill = path_1.default.join(options.registryRoot, 'skills/using-awm/SKILL.md');
-    if (!fs_1.default.existsSync(path_1.default.join(sourceHooks, 'session-start'))) {
-        throw new Error(`AWM registry not found at ${sourceHooks}. Run 'awm update' to refresh the registry.`);
-    }
-    if (!fs_1.default.existsSync(sourceSkill)) {
-        throw new Error(`using-awm skill not found at ${sourceSkill}. Run 'awm update' first.`);
-    }
-    // 2. Sync scripts
-    fs_1.default.mkdirSync(config.scriptsDir, { recursive: true });
-    syncFile(path_1.default.join(sourceHooks, 'session-start'), path_1.default.join(config.scriptsDir, 'session-start'), options.installMethod);
-    syncFile(path_1.default.join(sourceHooks, 'run-hook.cmd'), path_1.default.join(config.scriptsDir, 'run-hook.cmd'), options.installMethod);
-    // 3. Link the skill (default: symlink so 'awm update' propagates; fall back to copy if symlink is unavailable, e.g. Windows without Developer Mode)
-    const skillDest = path_1.default.join(config.scriptsDir, 'using-awm.md');
-    try {
-        fs_1.default.unlinkSync(skillDest);
-    }
-    catch { /* not exists */ }
-    try {
-        fs_1.default.symlinkSync(sourceSkill, skillDest);
-    }
-    catch {
-        // best-effort: copy the single skill file; 'awm update' will not auto-propagate
-        fs_1.default.copyFileSync(sourceSkill, skillDest);
-    }
-    // 4. Backup settings if it exists
-    const backupPath = backupSettings(config.settingsPath);
-    // 5. Read or initialize settings
-    let settings = {};
-    if (fs_1.default.existsSync(config.settingsPath)) {
-        const raw = fs_1.default.readFileSync(config.settingsPath, 'utf-8');
-        try {
-            settings = JSON.parse(raw);
-        }
-        catch {
-            throw new Error(`${config.settingsPath} is not valid JSON. Backup created at ${backupPath}. Fix the file manually, then re-run.`);
+    switch (config.type) {
+        case 'cc-settings-merge':
+            return (0, claude_1.installClaudeHook)(options);
+        case 'codex-hooks-json':
+            return (0, codex_1.installCodexHook)(options);
+        /* istanbul ignore next -- HookConfig['type'] is exhaustively handled above */
+        default: {
+            const exhaustive = config.type;
+            throw new Error(`Unknown hook config type: ${String(exhaustive)}`);
         }
     }
-    else {
-        fs_1.default.mkdirSync(path_1.default.dirname(config.settingsPath), { recursive: true });
-    }
-    // 6. Merge AWM entry
-    if (!settings.hooks)
-        settings.hooks = {};
-    if (!settings.hooks[config.eventName])
-        settings.hooks[config.eventName] = [];
-    const entries = settings.hooks[config.eventName];
-    const awmEntryIdx = entries.findIndex((e) => isAwmEntry(e, config.scriptsDir, config.matcher));
-    const newEntry = {
-        matcher: config.matcher,
-        hooks: [{
-                type: 'command',
-                command: `${path_1.default.join(config.scriptsDir, 'run-hook.cmd')} session-start`,
-                async: false
-            }]
-    };
-    let status;
-    if (awmEntryIdx >= 0) {
-        if (JSON.stringify(entries[awmEntryIdx]) === JSON.stringify(newEntry)) {
-            return { status: 'already-up-to-date', scriptsDir: config.scriptsDir, settingsPath: config.settingsPath, backupPath: null };
-        }
-        entries[awmEntryIdx] = newEntry;
-        status = 'installed';
-    }
-    else {
-        entries.push(newEntry);
-        status = 'installed';
-    }
-    // 7. Write settings
-    fs_1.default.writeFileSync(config.settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
-    return { status, scriptsDir: config.scriptsDir, settingsPath: config.settingsPath, backupPath };
 }

package/dist/src/commands/hooks/resync.js

@@ -8,7 +8,8 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const providers_1 = require("../../providers");
 const status_1 = require("./status");
-const install_1 = require("./install");
+const claude_1 = require("./claude");
+const codex_1 = require("./codex");
 function detectInstallMethod(scriptsDir) {
     try {
         return fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'session-start')).isSymbolicLink() ? 'symlink' : 'copy';
@@ -17,9 +18,9 @@ function detectInstallMethod(scriptsDir) {
         return 'copy';
     }
 }
-function resyncInstalledHooks(registryRoot) {
+function resyncInstalledHooks(registryRoot, targets = [...providers_1.AGENT_TARGETS]) {
     const results = [];
-    for (const agent of Object.keys(providers_1.PROVIDERS)) {
+    for (const agent of targets) {
         const config = (0, providers_1.getHookConfig)(agent);
         if (!config)
             continue;
@@ -28,23 +29,32 @@ function resyncInstalledHooks(registryRoot) {
             results.push({ agent, action: 'not-installed' });
             continue;
         }
-        const sourceHooks = path_1.default.join(registryRoot, 'hooks');
-        const sourceSkill = path_1.default.join(registryRoot, 'skills/using-awm/SKILL.md');
-        if (!fs_1.default.existsSync(path_1.default.join(sourceHooks, 'session-start')) || !fs_1.default.existsSync(path_1.default.join(sourceHooks, 'run-hook.cmd')) || !fs_1.default.existsSync(sourceSkill)) {
-            results.push({ agent, action: 'registry-missing' });
-            continue;
-        }
         const method = detectInstallMethod(config.scriptsDir);
-        fs_1.default.mkdirSync(config.scriptsDir, { recursive: true });
-        (0, install_1.syncFile)(path_1.default.join(sourceHooks, 'session-start'), path_1.default.join(config.scriptsDir, 'session-start'), method);
-        (0, install_1.syncFile)(path_1.default.join(sourceHooks, 'run-hook.cmd'), path_1.default.join(config.scriptsDir, 'run-hook.cmd'), method);
-        const skillDest = path_1.default.join(config.scriptsDir, 'using-awm.md');
-        try {
-            fs_1.default.unlinkSync(skillDest);
+        switch (config.type) {
+            case 'cc-settings-merge': {
+                if (!(0, claude_1.claudeResyncSourcesExist)(registryRoot)) {
+                    results.push({ agent, action: 'registry-missing' });
+                    continue;
+                }
+                (0, claude_1.resyncClaudeHookFiles)(config, registryRoot, method);
+                results.push({ agent, action: 'resynced' });
+                break;
+            }
+            case 'codex-hooks-json': {
+                if (!(0, codex_1.codexResyncSourcesExist)(registryRoot)) {
+                    results.push({ agent, action: 'registry-missing' });
+                    continue;
+                }
+                (0, codex_1.resyncCodexHookFiles)(config, registryRoot, method);
+                results.push({ agent, action: 'resynced' });
+                break;
+            }
+            /* istanbul ignore next -- HookConfig['type'] is exhaustively handled above */
+            default: {
+                const exhaustive = config.type;
+                throw new Error(`Unknown hook config type: ${String(exhaustive)}`);
+            }
         }
-        catch { /* not exists */ }
-        fs_1.default.symlinkSync(sourceSkill, skillDest);
-        results.push({ agent, action: 'resynced' });
     }
     return results;
 }

package/dist/src/commands/hooks/shared.js

@@ -0,0 +1,94 @@
+"use strict";
+// cli/src/commands/hooks/shared.ts
+//
+// Small helpers shared between the per-agent hook adapters (claude.ts, codex.ts).
+// Each adapter owns its own entry shape / merge semantics; this module only
+// generalizes the parts that are identical regardless of which JSON file or
+// which single script is being managed.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncExecutable = syncExecutable;
+exports.backupManagedFile = backupManagedFile;
+exports.readStrictJson = readStrictJson;
+exports.checkExecutable = checkExecutable;
+exports.checkFile = checkFile;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../../core/paths");
+/**
+ * Sync a single managed file (script, wrapper, skill doc, ...) from `source`
+ * to `dest` via symlink (default; lets `awm update` propagate registry
+ * changes) or copy (fallback for platforms without symlink support).
+ */
+function syncExecutable(source, dest, method) {
+    try {
+        fs_1.default.unlinkSync(dest);
+    }
+    catch { /* not exists, fine */ }
+    fs_1.default.mkdirSync(path_1.default.dirname(dest), { recursive: true });
+    if (method === 'symlink') {
+        fs_1.default.symlinkSync(source, dest);
+    }
+    else {
+        fs_1.default.copyFileSync(source, dest);
+        const srcMode = fs_1.default.statSync(source).mode;
+        fs_1.default.chmodSync(dest, srcMode);
+    }
+}
+/**
+ * Backup any AWM-managed JSON config file (Claude's settings.json, Codex's
+ * hooks.json, ...) before mutating it. Returns null if the file doesn't
+ * exist yet (nothing to back up).
+ */
+function backupManagedFile(filePath) {
+    if (!fs_1.default.existsSync(filePath))
+        return null;
+    const backupDir = path_1.default.join((0, paths_1.awmHome)(), 'backups');
+    fs_1.default.mkdirSync(backupDir, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, '-').replace('T', '-').slice(0, 19);
+    const backupPath = path_1.default.join(backupDir, `${path_1.default.basename(filePath)}.${ts}.bak`);
+    fs_1.default.copyFileSync(filePath, backupPath);
+    return backupPath;
+}
+/**
+ * Parse a JSON config file. Missing file => {} (nothing configured yet).
+ * Malformed JSON => throws a clear, actionable error instead of silently
+ * clobbering whatever the user (or another tool) put there.
+ */
+function readStrictJson(filePath) {
+    if (!fs_1.default.existsSync(filePath))
+        return {};
+    const raw = fs_1.default.readFileSync(filePath, 'utf-8');
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`${filePath} is not valid JSON. Fix the file manually, then re-run.`);
+    }
+}
+function checkExecutable(file) {
+    if (!fs_1.default.existsSync(file)) {
+        return { ok: false, detail: `missing: ${file}` };
+    }
+    try {
+        fs_1.default.accessSync(file, fs_1.default.constants.X_OK);
+        return { ok: true, detail: file };
+    }
+    catch {
+        return { ok: false, detail: `not executable: ${file}` };
+    }
+}
+function checkFile(file) {
+    if (!fs_1.default.existsSync(file)) {
+        return { ok: false, detail: `missing: ${file}` };
+    }
+    try {
+        fs_1.default.statSync(file);
+        return { ok: true, detail: file };
+    }
+    catch {
+        return { ok: false, detail: `broken link: ${file}` };
+    }
+}

package/dist/src/commands/hooks/status.js

@@ -1,74 +1,23 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.computeHookStatus = computeHookStatus;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
 const providers_1 = require("../../providers");
-function checkExecutable(file) {
-    if (!fs_1.default.existsSync(file)) {
-        return { ok: false, detail: `missing: ${file}` };
-    }
-    try {
-        fs_1.default.accessSync(file, fs_1.default.constants.X_OK);
-        return { ok: true, detail: file };
-    }
-    catch {
-        return { ok: false, detail: `not executable: ${file}` };
-    }
-}
-function checkFile(file) {
-    if (!fs_1.default.existsSync(file)) {
-        return { ok: false, detail: `missing: ${file}` };
-    }
-    try {
-        fs_1.default.statSync(file);
-        return { ok: true, detail: file };
-    }
-    catch {
-        return { ok: false, detail: `broken link: ${file}` };
-    }
-}
-function checkSettingsEntry(settingsPath, scriptsDir, matcher, eventName) {
-    if (!fs_1.default.existsSync(settingsPath)) {
-        return { ok: false, detail: `settings.json not found: ${settingsPath}` };
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(fs_1.default.readFileSync(settingsPath, 'utf-8'));
-    }
-    catch {
-        return { ok: false, detail: 'settings.json is not valid JSON' };
-    }
-    const entries = parsed?.hooks?.[eventName] ?? [];
-    const awmEntry = entries.find((e) => e?.matcher === matcher &&
-        (e?.hooks ?? []).some((h) => typeof h?.command === 'string' && h.command.includes(scriptsDir)));
-    if (!awmEntry) {
-        return { ok: false, detail: `no AWM SessionStart entry in ${settingsPath}` };
-    }
-    return { ok: true, detail: settingsPath };
-}
+const claude_1 = require("./claude");
+const codex_1 = require("./codex");
 function computeHookStatus(agent) {
     const config = (0, providers_1.getHookConfig)(agent);
     if (!config) {
         throw new Error(`hooks not supported for agent target: ${agent}`);
     }
-    const checks = {
-        bootstrapSkill: checkFile(path_1.default.join(config.scriptsDir, 'using-awm.md')),
-        sessionStartScript: checkExecutable(path_1.default.join(config.scriptsDir, 'session-start')),
-        runHookWrapper: checkExecutable(path_1.default.join(config.scriptsDir, 'run-hook.cmd')),
-        settingsEntry: checkSettingsEntry(config.settingsPath, config.scriptsDir, config.matcher, config.eventName)
-    };
-    const allOk = Object.values(checks).every((c) => c.ok);
-    const settingsOnlyMissing = !checks.settingsEntry.ok && checks.bootstrapSkill.ok && checks.sessionStartScript.ok && checks.runHookWrapper.ok;
-    let overall;
-    if (allOk)
-        overall = 'HEALTHY';
-    else if (settingsOnlyMissing)
-        overall = 'NOT_INSTALLED';
-    else
-        overall = 'DEGRADED';
-    return { overall, checks };
+    switch (config.type) {
+        case 'cc-settings-merge':
+            return (0, claude_1.computeClaudeHookStatus)(agent);
+        case 'codex-hooks-json':
+            return (0, codex_1.computeCodexHookStatus)(agent);
+        /* istanbul ignore next -- HookConfig['type'] is exhaustively handled above */
+        default: {
+            const exhaustive = config.type;
+            throw new Error(`Unknown hook config type: ${String(exhaustive)}`);
+        }
+    }
 }