agentic-workflow-manager 2.0.0

package/dist/src/providers/index.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDERS = void 0;
+exports.getTargetPath = getTargetPath;
+exports.getHookConfig = getHookConfig;
+exports.getInjection = getInjection;
+// src/providers/index.ts
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const homedir = process.env.HOME || os_1.default.homedir();
+const awmHome = process.env.AWM_HOME || path_1.default.join(homedir, '.awm');
+exports.PROVIDERS = {
+    antigravity: {
+        label: 'Antigravity',
+        skill: { global: path_1.default.join(homedir, '.gemini/antigravity/skills'), local: '.agent/skills' },
+        workflow: { global: path_1.default.join(homedir, '.gemini/antigravity/global_workflows'), local: '.agent/workflows' },
+        agent: null
+    },
+    opencode: {
+        label: 'OpenCode',
+        skill: { global: path_1.default.join(homedir, '.agents/skills'), local: '.agents/skills' },
+        workflow: null,
+        agent: { global: path_1.default.join(homedir, '.config/opencode/agents'), local: '.agents/profiles' },
+        injection: {
+            type: 'config-instructions',
+            configPath: path_1.default.join(homedir, '.config/opencode/opencode.json'),
+            field: 'instructions',
+        },
+    },
+    'claude-code': {
+        label: 'Claude Code',
+        skill: { global: path_1.default.join(homedir, '.claude/skills'), local: '.claude/skills' },
+        workflow: null,
+        agent: { global: path_1.default.join(homedir, '.claude/agents'), local: '.claude/agents' },
+        hooks: {
+            type: 'cc-settings-merge',
+            settingsPath: path_1.default.join(homedir, '.claude/settings.json'),
+            scriptsDir: path_1.default.join(awmHome, 'hooks'),
+            matcher: 'startup|clear|compact',
+            eventName: 'SessionStart'
+        },
+        injection: { type: 'cc-settings-merge' }
+    }
+};
+function getTargetPath(type, agent, scope) {
+    const provider = exports.PROVIDERS[agent];
+    if (!provider)
+        throw new Error(`Unknown agent target: ${agent}`);
+    const config = provider[type];
+    if (!config)
+        throw new Error(`${type}s are not supported by ${provider.label}.`);
+    return config[scope];
+}
+function getHookConfig(agent) {
+    const provider = exports.PROVIDERS[agent];
+    return provider?.hooks;
+}
+function getInjection(agent) {
+    return exports.PROVIDERS[agent]?.injection;
+}

package/dist/src/utils/config.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPreferences = getPreferences;
+exports.savePreferences = savePreferences;
+// src/utils/config.ts
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const DEFAULT_PREFS = {
+    defaultAgent: 'antigravity',
+    installMethod: 'symlink',
+    defaultScope: 'local'
+};
+function prefsDir() {
+    return process.env.AWM_HOME || path_1.default.join(process.env.HOME || os_1.default.homedir(), '.awm');
+}
+function getPreferences() {
+    const file = path_1.default.join(prefsDir(), 'preferences.json');
+    if (!fs_1.default.existsSync(file)) {
+        savePreferences(DEFAULT_PREFS);
+        return DEFAULT_PREFS;
+    }
+    const raw = fs_1.default.readFileSync(file, 'utf-8');
+    return JSON.parse(raw);
+}
+function savePreferences(prefs) {
+    const dir = prefsDir();
+    if (!fs_1.default.existsSync(dir)) {
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    }
+    fs_1.default.writeFileSync(path_1.default.join(dir, 'preferences.json'), JSON.stringify(prefs, null, 2), 'utf-8');
+}

package/dist/src/utils/grouping.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGroupedOptions = buildGroupedOptions;
+function buildGroupedOptions(artifacts, bundles, formatLabel) {
+    const grouped = new Map();
+    const standalone = new Map();
+    for (const a of artifacts) {
+        let foundParent = false;
+        const baseName = (a.type === 'workflow' || a.type === 'agent') ? a.name.replace(/\.md$/, '') : a.name;
+        for (const p of bundles) {
+            const skillNames = p.skills.map((s) => s.name);
+            if ((a.type === 'skill' && skillNames.includes(baseName)) ||
+                (a.type === 'workflow' && p.workflows.includes(baseName)) ||
+                (a.type === 'agent' && p.agents.includes(baseName))) {
+                if (!grouped.has(p.name))
+                    grouped.set(p.name, new Map());
+                const procGroup = grouped.get(p.name);
+                if (!procGroup.has(baseName))
+                    procGroup.set(baseName, []);
+                procGroup.get(baseName).push(a);
+                foundParent = true;
+            }
+        }
+        if (!foundParent) {
+            if (!standalone.has(baseName))
+                standalone.set(baseName, []);
+            standalone.get(baseName).push(a);
+        }
+    }
+    const options = [];
+    for (const [procName, baseNameMap] of grouped.entries()) {
+        const proc = bundles.find(p => p.name === procName);
+        const children = Array.from(baseNameMap.entries()).map(([baseName, arr]) => ({ baseName, artifacts: arr }));
+        options.push({
+            value: { _group: true, processName: procName, children },
+            label: `📦 ${procName}`,
+            hint: `${proc.description} — ${children.length} artifacts`
+        });
+        children.forEach((c, idx) => {
+            const prefix = idx === children.length - 1 ? '  └─ ' : '  ├─ ';
+            options.push({ value: { _child: true, combined: c }, label: `${prefix}${formatLabel(c)}` });
+        });
+    }
+    if (standalone.size > 0) {
+        Array.from(standalone.entries()).forEach(([baseName, arr]) => {
+            const c = { baseName, artifacts: arr };
+            options.push({ value: { _child: true, combined: c }, label: `🔹 ${formatLabel(c)}` });
+        });
+    }
+    return options;
+}

package/dist/src/utils/registry-view.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_SENTINEL = exports.STANDALONE_NAME = void 0;
+exports.buildPackageView = buildPackageView;
+exports.artifactCountLabel = artifactCountLabel;
+exports.packageSummaryLines = packageSummaryLines;
+exports.packageDetailLines = packageDetailLines;
+exports.findPackage = findPackage;
+exports.artifactValue = artifactValue;
+exports.buildLevel1Options = buildLevel1Options;
+exports.buildLevel2Options = buildLevel2Options;
+exports.resolveLevel2Selection = resolveLevel2Selection;
+const picocolors_1 = __importDefault(require("picocolors"));
+const registries_1 = require("../core/registries");
+exports.STANDALONE_NAME = 'standalone';
+function makePackage(name, description, isStandalone, visibility, artifacts) {
+    return {
+        name,
+        description,
+        isStandalone,
+        visibility,
+        artifacts,
+        counts: {
+            skills: artifacts.filter((a) => a.type === 'skill').length,
+            workflows: artifacts.filter((a) => a.type === 'workflow').length,
+            agents: artifacts.filter((a) => a.type === 'agent').length,
+        },
+    };
+}
+function buildPackageView(skills, workflows, agents, bundles) {
+    const all = [
+        ...skills.map((s) => ({ name: s.name, type: 'skill', sourcePath: s.path, installName: s.name, description: s.description ?? '', overrode: s.overrode })),
+        ...workflows.map((w) => ({ name: w.name, type: 'workflow', sourcePath: w.path, installName: `${w.name}.md`, description: w.description ?? '', overrode: w.overrode })),
+        ...agents.map((a) => ({ name: a.name, type: 'agent', sourcePath: a.path, installName: `${a.name}.md`, description: a.description ?? '', overrode: a.overrode })),
+    ];
+    const packages = [];
+    const claimed = new Set();
+    for (const b of bundles) {
+        const skillNames = b.skills.map((s) => s.name);
+        const arts = all.filter((a) => (a.type === 'skill' && skillNames.includes(a.name)) ||
+            (a.type === 'workflow' && b.workflows.includes(a.name)) ||
+            (a.type === 'agent' && b.agents.includes(a.name)));
+        if (arts.length === 0)
+            continue;
+        arts.forEach((a) => claimed.add(a));
+        packages.push(makePackage(b.name, b.description, false, b.visibility, arts));
+    }
+    const orphans = all.filter((a) => !claimed.has(a));
+    if (orphans.length > 0) {
+        packages.push(makePackage(exports.STANDALONE_NAME, 'Artifacts not part of any package', true, 'public', orphans));
+    }
+    return packages;
+}
+const TYPE_ICON = { skill: '', workflow: '⚡ ', agent: '🤖 ' };
+function plural(n, noun) {
+    return `${n} ${noun}${n === 1 ? '' : 's'}`;
+}
+function artifactCountLabel(counts) {
+    const parts = [];
+    if (counts.skills > 0)
+        parts.push(plural(counts.skills, 'skill'));
+    if (counts.workflows > 0)
+        parts.push(plural(counts.workflows, 'workflow'));
+    if (counts.agents > 0)
+        parts.push(plural(counts.agents, 'agent'));
+    if (parts.length === 0)
+        return '0 artifacts';
+    return parts.join(' · ');
+}
+function packageIcon(pkg) {
+    return pkg.isStandalone ? '🔹' : '📦';
+}
+function packageSummaryLines(packages) {
+    const uniqueSkillNames = new Set(packages.flatMap((p) => p.artifacts.filter((a) => a.type === 'skill').map((a) => a.name)));
+    const totalSkills = uniqueSkillNames.size;
+    const lines = [`AWM Registry — ${plural(packages.length, 'package')}, ${plural(totalSkills, 'skill')}`, ''];
+    const nameWidth = Math.max(0, ...packages.map((p) => p.name.length));
+    const countLabels = packages.map((p) => (p.isStandalone ? plural(p.artifacts.length, 'artifact') : artifactCountLabel(p.counts)));
+    const countWidth = Math.max(0, ...countLabels.map((c) => c.length));
+    packages.forEach((p, i) => {
+        const name = p.name.padEnd(nameWidth);
+        const count = countLabels[i].padEnd(countWidth);
+        const desc = p.isStandalone ? '' : p.description;
+        lines.push(`${packageIcon(p)} ${name}   ${count}   ${desc}`.trimEnd());
+    });
+    return lines;
+}
+function packageDetailLines(pkg) {
+    const lines = [];
+    const header = pkg.isStandalone
+        ? `${packageIcon(pkg)} ${pkg.name} — ${plural(pkg.artifacts.length, 'artifact')}`
+        : `${packageIcon(pkg)} ${pkg.name} — ${pkg.description}  [${artifactCountLabel(pkg.counts)}]`;
+    lines.push(header);
+    pkg.artifacts.forEach((a) => {
+        const mark = a.overrode
+            ? picocolors_1.default.yellow(`  ← ${(0, registries_1.registryNameForPath)(a.sourcePath) ?? 'unknown'} (override)`)
+            : '';
+        lines.push(`  ${TYPE_ICON[a.type]}${a.name}${mark}`);
+        if (a.description)
+            lines.push(`     ${a.description}`);
+    });
+    return lines;
+}
+function findPackage(packages, query) {
+    const q = query.toLowerCase();
+    const exact = packages.find((p) => p.name.toLowerCase() === q);
+    if (exact)
+        return { match: exact };
+    const contains = packages.find((p) => p.name.toLowerCase().includes(q) || q.includes(p.name.toLowerCase()));
+    if (contains)
+        return { suggestion: contains.name };
+    let best;
+    let bestPrefix = -1;
+    for (const p of packages) {
+        const name = p.name.toLowerCase();
+        let i = 0;
+        while (i < name.length && i < q.length && name[i] === q[i])
+            i++;
+        if (i > bestPrefix) {
+            bestPrefix = i;
+            best = p;
+        }
+    }
+    return { suggestion: best?.name };
+}
+exports.ALL_SENTINEL = '__ALL__';
+function artifactValue(a) {
+    return `${a.type}:${a.name}`;
+}
+function buildLevel1Options(packages) {
+    return packages.map((p) => {
+        const count = p.isStandalone ? plural(p.artifacts.length, 'artifact') : artifactCountLabel(p.counts);
+        const desc = p.isStandalone ? '' : ` · ${p.description}`;
+        return { value: p.name, label: `${packageIcon(p)} ${p.name}  ${picocolors_1.default.dim(`${count}${desc}`)}` };
+    });
+}
+function buildLevel2Options(pkg) {
+    const installAll = { value: exports.ALL_SENTINEL, label: `✨ Install entire package (${pkg.artifacts.length})` };
+    const rest = pkg.artifacts.map((a) => {
+        const title = `${TYPE_ICON[a.type]}${a.name}`;
+        const label = a.description ? `${title}\n     ${picocolors_1.default.dim(a.description)}` : title;
+        return { value: artifactValue(a), label };
+    });
+    return [installAll, ...rest];
+}
+function resolveLevel2Selection(pkg, selectedValues) {
+    if (selectedValues.includes(exports.ALL_SENTINEL))
+        return [...pkg.artifacts];
+    const wanted = new Set(selectedValues);
+    return pkg.artifacts.filter((a) => wanted.has(artifactValue(a)));
+}

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

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const doctor_1 = require("../../src/commands/doctor");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+function report(partial = {}) {
+    return {
+        results: [
+            { id: 'machine.cli', level: 'machine', label: 'CLI v1.0.0', status: 'ok', remedy: { kind: 'none' } },
+            { id: 'machine.hook', level: 'machine', label: 'hook SessionStart', status: 'missing',
+                remedy: { kind: 'command', value: 'awm init' } },
+        ],
+        overall: 'degraded',
+        hasProject: false,
+        ...partial,
+    };
+}
+describe('renderReport', () => {
+    it('renders the machine block with glyphs and remedies', () => {
+        const out = (0, doctor_1.renderReport)(report());
+        expect(out).toContain('AWM · estado del harness');
+        expect(out).toContain('Máquina (global)');
+        expect(out).toContain('✔ CLI v1.0.0');
+        expect(out).toContain('✖ hook SessionStart');
+        expect(out).toContain('→ awm init');
+        expect(out).toContain('estado: degradado · 1 acciones sugeridas');
+    });
+    it('omits the project block and shows a hint when hasProject is false', () => {
+        const out = (0, doctor_1.renderReport)(report());
+        expect(out).toContain('(sin proyecto en el cwd)');
+        expect(out).not.toContain('Proyecto:');
+    });
+    it('renders the detail field in parentheses when present', () => {
+        const out = (0, doctor_1.renderReport)(report({
+            results: [
+                { id: 'machine.cli', level: 'machine', label: 'CLI v1.2.0', status: 'warn',
+                    detail: 'cache desactualizado', remedy: { kind: 'command', value: 'awm update' } },
+            ],
+        }));
+        expect(out).toContain('CLI v1.2.0');
+        expect(out).toContain('(cache desactualizado)');
+        expect(out).toContain('→ awm update');
+    });
+    it('renders the project block titled with projectName', () => {
+        const out = (0, doctor_1.renderReport)(report({
+            hasProject: true,
+            projectName: 'belanz',
+            results: [
+                { id: 'project.constitution', level: 'project', label: 'CONSTITUTION.md ausente',
+                    status: 'missing', remedy: { kind: 'skill', value: 'project-constitution' } },
+            ],
+        }));
+        expect(out).toContain('Proyecto: belanz');
+        expect(out).toContain('→ skill: project-constitution');
+    });
+});
+describe('runDoctor', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    let writeSpy;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-doctor-run-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        writeSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    });
+    afterEach(() => {
+        writeSpy.mockRestore();
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        if (originalHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = originalHome;
+        if (originalAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalAwmHome;
+    });
+    it('returns exit code 1 when the harness is degraded (bare HOME, no project)', () => {
+        const code = (0, doctor_1.runDoctor)({ cwd: tmpHome });
+        expect(code).toBe(1);
+    });
+    it('--json emits a parseable CheckReport 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);
+        expect(parsed.overall).toBe('degraded');
+        expect(Array.isArray(parsed.results)).toBe(true);
+        expect(code).toBe(1);
+    });
+});

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

@@ -0,0 +1,149 @@
+"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"));
+describe('installHook (happy path + merge)', () => {
+    let tmpHome;
+    let tmpRegistry;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-install-'));
+        tmpRegistry = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-registry-'));
+        // Mock registry layout (content root — no registry/ prefix)
+        const regHooks = path_1.default.join(tmpRegistry, 'hooks');
+        const regSkill = path_1.default.join(tmpRegistry, 'skills/using-awm');
+        fs_1.default.mkdirSync(regHooks, { recursive: true });
+        fs_1.default.mkdirSync(regSkill, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(regHooks, 'session-start'), '#!/usr/bin/env bash\necho "{}"', { mode: 0o755 });
+        fs_1.default.writeFileSync(path_1.default.join(regHooks, 'run-hook.cmd'), '#!/usr/bin/env bash\nexec bash "$1"', { mode: 0o755 });
+        fs_1.default.writeFileSync(path_1.default.join(regSkill, 'SKILL.md'), '---\nname: using-awm\n---\nMUST invoke skills.');
+        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;
+    });
+    it('installs on a clean system, creating settings.json with the AWM entry', () => {
+        const { installHook } = require('../../../src/commands/hooks/install');
+        const result = installHook({
+            agent: 'claude-code',
+            registryRoot: tmpRegistry,
+            installMethod: 'symlink'
+        });
+        expect(result.status).toBe('installed');
+        const scriptsDir = path_1.default.join(tmpHome, '.awm/hooks');
+        expect(fs_1.default.existsSync(path_1.default.join(scriptsDir, 'session-start'))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(scriptsDir, 'run-hook.cmd'))).toBe(true);
+        expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'using-awm.md')).isSymbolicLink()).toBe(true);
+        const settings = JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmpHome, '.claude/settings.json'), 'utf-8'));
+        expect(settings.hooks.SessionStart).toHaveLength(1);
+        expect(settings.hooks.SessionStart[0].matcher).toBe('startup|clear|compact');
+        expect(settings.hooks.SessionStart[0].hooks[0].command).toContain('run-hook.cmd');
+        expect(result.backupPath).toBeNull();
+    });
+    it('merges with pre-existing SessionStart entry from another plugin', () => {
+        const claudeDir = path_1.default.join(tmpHome, '.claude');
+        fs_1.default.mkdirSync(claudeDir, { recursive: true });
+        const preExisting = {
+            theme: 'dark',
+            hooks: {
+                SessionStart: [{
+                        matcher: 'startup',
+                        hooks: [{ type: 'command', command: '/some/other/plugin/hook' }]
+                    }]
+            }
+        };
+        fs_1.default.writeFileSync(path_1.default.join(claudeDir, 'settings.json'), JSON.stringify(preExisting, null, 2));
+        const { installHook } = require('../../../src/commands/hooks/install');
+        const result = installHook({
+            agent: 'claude-code',
+            registryRoot: tmpRegistry,
+            installMethod: 'symlink'
+        });
+        expect(result.status).toBe('installed');
+        expect(result.backupPath).not.toBeNull();
+        expect(fs_1.default.existsSync(result.backupPath)).toBe(true);
+        const settings = JSON.parse(fs_1.default.readFileSync(path_1.default.join(claudeDir, 'settings.json'), 'utf-8'));
+        expect(settings.theme).toBe('dark');
+        expect(settings.hooks.SessionStart).toHaveLength(2);
+        expect(settings.hooks.SessionStart[0].hooks[0].command).toBe('/some/other/plugin/hook');
+        expect(settings.hooks.SessionStart[1].hooks[0].command).toContain('run-hook.cmd');
+    });
+    it('is idempotent — second install does not duplicate', () => {
+        const { installHook } = require('../../../src/commands/hooks/install');
+        installHook({ agent: 'claude-code', registryRoot: tmpRegistry, installMethod: 'symlink' });
+        const result2 = installHook({ agent: 'claude-code', registryRoot: tmpRegistry, installMethod: 'symlink' });
+        expect(result2.status).toBe('already-up-to-date');
+        const settings = JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmpHome, '.claude/settings.json'), 'utf-8'));
+        expect(settings.hooks.SessionStart).toHaveLength(1);
+    });
+    it('replaces a stale AWM entry when paths change', () => {
+        const claudeDir = path_1.default.join(tmpHome, '.claude');
+        fs_1.default.mkdirSync(claudeDir, { recursive: true });
+        const scriptsDir = path_1.default.join(tmpHome, '.awm/hooks');
+        fs_1.default.writeFileSync(path_1.default.join(claudeDir, 'settings.json'), JSON.stringify({
+            hooks: {
+                SessionStart: [{
+                        matcher: 'startup|clear|compact',
+                        hooks: [{ type: 'command', command: `${scriptsDir}/old-script session-start`, async: true }]
+                    }]
+            }
+        }, null, 2));
+        const { installHook } = require('../../../src/commands/hooks/install');
+        const result = installHook({ agent: 'claude-code', registryRoot: tmpRegistry, installMethod: 'symlink' });
+        expect(result.status).toBe('installed');
+        const settings = JSON.parse(fs_1.default.readFileSync(path_1.default.join(claudeDir, 'settings.json'), 'utf-8'));
+        expect(settings.hooks.SessionStart).toHaveLength(1);
+        expect(settings.hooks.SessionStart[0].hooks[0].command).toContain('run-hook.cmd');
+        expect(settings.hooks.SessionStart[0].hooks[0].async).toBe(false);
+    });
+    it('aborts and backs up when settings.json is invalid JSON', () => {
+        const claudeDir = path_1.default.join(tmpHome, '.claude');
+        fs_1.default.mkdirSync(claudeDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(claudeDir, 'settings.json'), '{ this is not json');
+        const { installHook } = require('../../../src/commands/hooks/install');
+        expect(() => installHook({ agent: 'claude-code', registryRoot: tmpRegistry, installMethod: 'symlink' }))
+            .toThrow(/not valid JSON/);
+        // Original file untouched
+        expect(fs_1.default.readFileSync(path_1.default.join(claudeDir, 'settings.json'), 'utf-8')).toBe('{ this is not json');
+        // Backup created
+        const backups = fs_1.default.readdirSync(path_1.default.join(tmpHome, '.awm/backups'));
+        expect(backups.length).toBeGreaterThan(0);
+    });
+    it('fails fast when registry is missing', () => {
+        fs_1.default.rmSync(path_1.default.join(tmpRegistry, 'hooks'), { recursive: true });
+        const { installHook } = require('../../../src/commands/hooks/install');
+        expect(() => installHook({ agent: 'claude-code', registryRoot: tmpRegistry, installMethod: 'symlink' }))
+            .toThrow(/registry not found/);
+        // Did not create settings.json
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.claude/settings.json'))).toBe(false);
+    });
+    it('symlinks using-awm.md even when installMethod is copy (UX choice)', () => {
+        const { installHook } = require('../../../src/commands/hooks/install');
+        installHook({ agent: 'claude-code', registryRoot: tmpRegistry, installMethod: 'copy' });
+        const skillPath = path_1.default.join(tmpHome, '.awm/hooks/using-awm.md');
+        expect(fs_1.default.lstatSync(skillPath).isSymbolicLink()).toBe(true);
+    });
+    it('throws for unsupported agent target', () => {
+        const { installHook } = require('../../../src/commands/hooks/install');
+        expect(() => installHook({ agent: 'antigravity', registryRoot: tmpRegistry, installMethod: 'symlink' }))
+            .toThrow(/not supported/);
+    });
+});