agentic-workflow-manager 2.0.0

package/dist/tests/core/context/orchestrator.test.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// cli/tests/core/context/orchestrator.test.ts
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const orchestrator_1 = require("../../../src/core/context/orchestrator");
+jest.mock('../../../src/commands/hooks/install', () => ({ installHook: jest.fn() }));
+jest.mock('../../../src/commands/hooks/uninstall', () => ({ uninstallHook: jest.fn() }));
+jest.mock('../../../src/commands/hooks/status', () => ({
+    computeHookStatus: jest.fn().mockReturnValue({ overall: 'NOT_INSTALLED' }),
+}));
+const install_1 = require("../../../src/commands/hooks/install");
+const uninstall_1 = require("../../../src/commands/hooks/uninstall");
+const status_1 = require("../../../src/commands/hooks/status");
+function tmpRegistry() {
+    const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-orch-'));
+    const dir = path_1.default.join(root, 'skills/using-awm');
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(dir, 'SKILL.md'), '---\nversion: "1.0.0"\n---\nBODY');
+    return root;
+}
+describe('InjectionOrchestrator (claude-code dispatch via HookMergeStrategy)', () => {
+    const ccOverride = {
+        label: 'Claude Code', skill: { global: '', local: '' }, workflow: null, agent: null,
+        injection: { type: 'cc-settings-merge' },
+        hooks: { type: 'cc-settings-merge', settingsPath: '', scriptsDir: '', matcher: '', eventName: '' },
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('installContext delegates to installHook', () => {
+        const reg = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-cc-reg-'));
+        const dir = path_1.default.join(reg, 'skills/using-awm');
+        fs_1.default.mkdirSync(dir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'SKILL.md'), '---\nversion: "1.0.0"\n---\nBODY');
+        const ctxPath = path_1.default.join(reg, 'awm-context.md');
+        const orch = new orchestrator_1.InjectionOrchestrator({ providerOverride: ccOverride, contextPathOverride: ctxPath });
+        orch.installContext({ agent: 'claude-code', scope: 'global', registryRoot: reg, installMethod: 'symlink', profileExtensions: [] });
+        expect(install_1.installHook).toHaveBeenCalledWith(expect.objectContaining({ agent: 'claude-code' }));
+    });
+    it('uninstallContext delegates to uninstallHook', () => {
+        const orch = new orchestrator_1.InjectionOrchestrator({ providerOverride: ccOverride });
+        orch.uninstallContext({ agent: 'claude-code', scope: 'global', registryRoot: '/any', installMethod: 'symlink', profileExtensions: [] });
+        expect(uninstall_1.uninstallHook).toHaveBeenCalledWith(expect.objectContaining({ agent: 'claude-code' }));
+    });
+    it('contextStatus delegates to computeHookStatus and returns absent when NOT_INSTALLED', () => {
+        status_1.computeHookStatus.mockReturnValue({ overall: 'NOT_INSTALLED' });
+        const orch = new orchestrator_1.InjectionOrchestrator({ providerOverride: ccOverride });
+        const state = orch.contextStatus({ agent: 'claude-code', scope: 'global', registryRoot: '/any', installMethod: 'symlink', profileExtensions: [] });
+        expect(status_1.computeHookStatus).toHaveBeenCalledWith('claude-code');
+        expect(state).toBe('absent');
+    });
+    it('contextStatus returns injected when hook reports HEALTHY', () => {
+        status_1.computeHookStatus.mockReturnValue({ overall: 'HEALTHY' });
+        const orch = new orchestrator_1.InjectionOrchestrator({ providerOverride: ccOverride });
+        const state = orch.contextStatus({ agent: 'claude-code', scope: 'global', registryRoot: '/any', installMethod: 'symlink', profileExtensions: [] });
+        expect(state).toBe('injected');
+    });
+    it('throws when providerOverride has no injection (does not fall through to real agent config)', () => {
+        const noInjection = { label: 'Test', skill: { global: '', local: '' }, workflow: null, agent: null };
+        const orch = new orchestrator_1.InjectionOrchestrator({ providerOverride: noInjection });
+        expect(() => orch.installContext({ agent: 'claude-code', scope: 'global', registryRoot: '/any', installMethod: 'symlink', profileExtensions: [] }))
+            .toThrow('no injection mechanism');
+    });
+});
+describe('InjectionOrchestrator (opencode, real strategy)', () => {
+    let configPath;
+    let absPath;
+    let orch;
+    let registryRoot;
+    beforeEach(() => {
+        const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-oc-'));
+        configPath = path_1.default.join(dir, 'opencode.json');
+        absPath = path_1.default.join(dir, 'awm-context.md');
+        registryRoot = tmpRegistry();
+        orch = new orchestrator_1.InjectionOrchestrator({
+            providerOverride: {
+                label: 'OpenCode', skill: { global: '', local: '' }, workflow: null, agent: null,
+                injection: { type: 'config-instructions', configPath, field: 'instructions' },
+            },
+            contextPathOverride: absPath,
+        });
+    });
+    it('installContext materializes content and injects the sentinel; status reports injected', () => {
+        orch.installContext({ agent: 'opencode', scope: 'global', registryRoot, installMethod: 'symlink', profileExtensions: [] });
+        expect(fs_1.default.existsSync(absPath)).toBe(true);
+        const cfg = JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
+        expect(cfg.instructions).toContain(absPath);
+        expect(orch.contextStatus({ agent: 'opencode', scope: 'global', registryRoot, installMethod: 'symlink', profileExtensions: [] })).toBe('injected');
+    });
+    it('uninstallContext removes the sentinel; status reports absent', () => {
+        const args = { agent: 'opencode', scope: 'global', registryRoot, installMethod: 'symlink', profileExtensions: [] };
+        orch.installContext(args);
+        orch.uninstallContext(args);
+        expect(orch.contextStatus(args)).toBe('absent');
+    });
+    it('throws when the agent has no injection mechanism', () => {
+        const bare = new orchestrator_1.InjectionOrchestrator();
+        expect(() => bare.installContext({ agent: 'antigravity', scope: 'global', registryRoot, installMethod: 'symlink', profileExtensions: [] }))
+            .toThrow('no injection mechanism');
+    });
+    it('contextStatus returns stale when the materialized file drifts without re-materializing it', () => {
+        const args = { agent: 'opencode', scope: 'global', registryRoot, installMethod: 'symlink', profileExtensions: [] };
+        orch.installContext(args);
+        // Drift the materialized file content after install
+        fs_1.default.writeFileSync(absPath, 'DRIFTED CONTENT');
+        // contextStatus must detect stale without correcting the file
+        expect(orch.contextStatus(args)).toBe('stale');
+        // Confirm the drifted content is still on disk (not silently corrected)
+        expect(fs_1.default.readFileSync(absPath, 'utf-8')).toBe('DRIFTED CONTENT');
+    });
+    it('uninstallContext succeeds even when the registry does not exist', () => {
+        const args = { agent: 'opencode', scope: 'global', registryRoot, installMethod: 'symlink', profileExtensions: [] };
+        orch.installContext(args);
+        // Remove the registry to simulate a degraded state
+        fs_1.default.rmSync(registryRoot, { recursive: true, force: true });
+        // uninstallContext must not throw 'using-awm skill not found'
+        expect(() => orch.uninstallContext(args)).not.toThrow();
+        // After removal the sentinel must be gone from opencode.json
+        const cfg = JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
+        expect((cfg.instructions ?? []).includes(absPath)).toBe(false);
+    });
+});

package/dist/tests/core/context/project-constitution-inject.test.js

@@ -0,0 +1,82 @@
+"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 project_constitution_inject_1 = require("../../../src/core/context/project-constitution-inject");
+function tmpProject(withConstitution) {
+    const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-const-'));
+    if (withConstitution)
+        fs_1.default.writeFileSync(path_1.default.join(root, 'CONSTITUTION.md'), '# rules\n');
+    return root;
+}
+describe('injectProjectConstitution (#6)', () => {
+    it('writes project-local opencode.json with a relative CONSTITUTION.md instruction', () => {
+        const root = tmpProject(true);
+        try {
+            expect((0, project_constitution_inject_1.injectProjectConstitution)(root, 'opencode')).toBe('injected');
+            const cfg = JSON.parse(fs_1.default.readFileSync(path_1.default.join(root, 'opencode.json'), 'utf-8'));
+            expect(cfg.instructions).toEqual(['CONSTITUTION.md']);
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('is idempotent (no duplicate entry on a second run)', () => {
+        const root = tmpProject(true);
+        try {
+            (0, project_constitution_inject_1.injectProjectConstitution)(root, 'opencode');
+            expect((0, project_constitution_inject_1.injectProjectConstitution)(root, 'opencode')).toBe('already');
+            const cfg = JSON.parse(fs_1.default.readFileSync(path_1.default.join(root, 'opencode.json'), 'utf-8'));
+            expect(cfg.instructions).toEqual(['CONSTITUTION.md']);
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('preserves existing instructions and appends', () => {
+        const root = tmpProject(true);
+        try {
+            fs_1.default.writeFileSync(path_1.default.join(root, 'opencode.json'), JSON.stringify({ $schema: 'x', instructions: ['./AGENTS.md'] }, null, 2));
+            expect((0, project_constitution_inject_1.injectProjectConstitution)(root, 'opencode')).toBe('injected');
+            const cfg = JSON.parse(fs_1.default.readFileSync(path_1.default.join(root, 'opencode.json'), 'utf-8'));
+            expect(cfg.instructions).toEqual(['./AGENTS.md', 'CONSTITUTION.md']);
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('returns no-constitution and writes nothing when CONSTITUTION.md is absent', () => {
+        const root = tmpProject(false);
+        try {
+            expect((0, project_constitution_inject_1.injectProjectConstitution)(root, 'opencode')).toBe('no-constitution');
+            expect(fs_1.default.existsSync(path_1.default.join(root, 'opencode.json'))).toBe(false);
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('returns not-applicable for Claude (hook delivers it) and writes nothing', () => {
+        const root = tmpProject(true);
+        try {
+            expect((0, project_constitution_inject_1.injectProjectConstitution)(root, 'claude-code')).toBe('not-applicable');
+            expect(fs_1.default.existsSync(path_1.default.join(root, 'opencode.json'))).toBe(false);
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('throws a clear error when instructions is a non-array', () => {
+        const root = tmpProject(true);
+        try {
+            fs_1.default.writeFileSync(path_1.default.join(root, 'opencode.json'), JSON.stringify({ instructions: 'oops' }));
+            expect(() => (0, project_constitution_inject_1.injectProjectConstitution)(root, 'opencode')).toThrow(/must be an array/);
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+});

package/dist/tests/core/context/provider.test.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// cli/tests/core/context/provider.test.ts
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const provider_1 = require("../../../src/core/context/provider");
+function tmpRegistry(skillBody) {
+    const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-reg-'));
+    const dir = path_1.default.join(root, 'skills/using-awm');
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(dir, 'SKILL.md'), skillBody);
+    return root;
+}
+describe('sha256', () => {
+    it('is deterministic and hex-encoded', () => {
+        expect((0, provider_1.sha256)('hello')).toBe((0, provider_1.sha256)('hello'));
+        expect((0, provider_1.sha256)('hello')).toMatch(/^[0-9a-f]{64}$/);
+        expect((0, provider_1.sha256)('hello')).not.toBe((0, provider_1.sha256)('world'));
+    });
+});
+describe('buildContext', () => {
+    it('embeds the using-awm body, version from frontmatter, and active extensions', () => {
+        const reg = tmpRegistry('---\nname: using-awm\nversion: "2.1.0"\n---\nBODY-MARKER');
+        const ctx = (0, provider_1.buildContext)({ registryRoot: reg, profileExtensions: ['frontend', 'docs'] });
+        expect(ctx.markdown).toContain('BODY-MARKER');
+        expect(ctx.markdown).toContain('frontend, docs');
+        expect(ctx.sourceVersion).toBe('2.1.0');
+        expect(ctx.contentHash).toBe((0, provider_1.sha256)(ctx.markdown));
+    });
+    it('falls back to version 0.0.0 when frontmatter has no version', () => {
+        const reg = tmpRegistry('---\nname: using-awm\n---\nBODY');
+        expect((0, provider_1.buildContext)({ registryRoot: reg, profileExtensions: [] }).sourceVersion).toBe('0.0.0');
+    });
+    it('throws an actionable error when the using-awm skill is missing', () => {
+        const reg = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-empty-'));
+        expect(() => (0, provider_1.buildContext)({ registryRoot: reg, profileExtensions: [] })).toThrow('using-awm skill not found');
+    });
+});
+// NOTE: the 'generic robustness invariant' test that validated specific prose in the
+// using-awm SKILL.md has been removed — content now lives in awm-baseline-registry
+// (an external repo), not in this monorepo. Content-level tests belong there.

package/dist/tests/core/context/regenerate.test.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// cli/tests/core/context/regenerate.test.ts
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+describe('regenerateGlobalContext', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-regen-'));
+        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 });
+        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;
+    });
+    // Crea un registry falso con el skill canónico using-awm que buildContext lee.
+    // Escribe registries.json apuntando al content root y crea el skill en la raíz del content root.
+    function seedRegistry(body = '---\nname: using-awm\nversion: "1.0.0"\n---\nUSING-AWM-BODY') {
+        const awmHome = path_1.default.join(tmpHome, '.awm');
+        const contentRoot = path_1.default.join(awmHome, 'registries', 'baseline');
+        const dir = path_1.default.join(contentRoot, 'skills', 'using-awm');
+        fs_1.default.mkdirSync(dir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'SKILL.md'), body);
+        // Write registries.json so capabilityRoot('skills') resolves to contentRoot
+        fs_1.default.writeFileSync(path_1.default.join(awmHome, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: 'https://example.com/baseline.git' }], null, 2) + '\n');
+    }
+    // Escribe un opencode.json con instructions[] = entries.
+    function seedOpencode(entries) {
+        const ocDir = path_1.default.join(tmpHome, '.config', 'opencode');
+        fs_1.default.mkdirSync(ocDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(ocDir, 'opencode.json'), JSON.stringify({ $schema: 'https://opencode.ai/config.json', instructions: entries }, null, 2));
+    }
+    function contextPath() {
+        return path_1.default.join(tmpHome, '.awm', 'context', 'awm-context.md');
+    }
+    it('returns empty when no config-instructions agent has a config file', () => {
+        seedRegistry();
+        const { regenerateGlobalContext } = require('../../../src/core/context/regenerate');
+        expect(regenerateGlobalContext()).toEqual([]);
+    });
+    it('skips an agent whose config exists but has no AWM sentinel', () => {
+        seedRegistry();
+        seedOpencode(['docs/rules.md']); // sin el sentinel
+        const { regenerateGlobalContext } = require('../../../src/core/context/regenerate');
+        expect(regenerateGlobalContext()).toEqual([{ agent: 'opencode', action: 'skipped' }]);
+        expect(fs_1.default.existsSync(contextPath())).toBe(false); // no se crea el archivo
+    });
+    it('refreshes a stale agent (sentinel present, materialized file absent) and recreates the file', () => {
+        seedRegistry();
+        seedOpencode([contextPath()]); // sentinel presente, pero el archivo no existe → stale
+        expect(fs_1.default.existsSync(contextPath())).toBe(false);
+        const { regenerateGlobalContext } = require('../../../src/core/context/regenerate');
+        expect(regenerateGlobalContext()).toEqual([{ agent: 'opencode', action: 'refreshed' }]);
+        expect(fs_1.default.existsSync(contextPath())).toBe(true);
+        expect(fs_1.default.readFileSync(contextPath(), 'utf-8')).toContain('USING-AWM-BODY');
+    });
+    it('reports fresh (no rewrite) when the agent is already injected', () => {
+        seedRegistry();
+        seedOpencode([contextPath()]);
+        const { regenerateGlobalContext } = require('../../../src/core/context/regenerate');
+        regenerateGlobalContext(); // 1ª pasada: stale → refreshed, crea el archivo
+        const mtime1 = fs_1.default.statSync(contextPath()).mtimeMs;
+        const second = regenerateGlobalContext(); // 2ª pasada: ya injected → fresh
+        expect(second).toEqual([{ agent: 'opencode', action: 'fresh' }]);
+        expect(fs_1.default.statSync(contextPath()).mtimeMs).toBe(mtime1); // archivo intacto
+    });
+    it('does not throw when the registry has no using-awm skill (stale but unregenerable → skipped)', () => {
+        // registry con skills/ pero sin using-awm dentro; opencode stale
+        const awmHome = path_1.default.join(tmpHome, '.awm');
+        const contentRoot = path_1.default.join(awmHome, 'registries', 'baseline');
+        // Create skills/ dir (so capabilityRoot resolves) but omit using-awm/
+        fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'skills'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(awmHome, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: 'https://example.com/baseline.git' }], null, 2) + '\n');
+        seedOpencode([contextPath()]);
+        const { regenerateGlobalContext } = require('../../../src/core/context/regenerate');
+        expect(() => regenerateGlobalContext()).not.toThrow();
+        expect(regenerateGlobalContext()).toEqual([{ agent: 'opencode', action: 'skipped' }]);
+    });
+    it('skips agent when contextStatus throws an unexpected error', () => {
+        seedRegistry();
+        seedOpencode([contextPath()]);
+        const { regenerateGlobalContext } = require('../../../src/core/context/regenerate');
+        const { InjectionOrchestrator } = require('../../../src/core/context/orchestrator');
+        const brokenOrch = new InjectionOrchestrator();
+        brokenOrch.contextStatus = () => { throw new Error('unexpected orchestrator error'); };
+        expect(regenerateGlobalContext(brokenOrch)).toEqual([{ agent: 'opencode', action: 'skipped' }]);
+        expect(fs_1.default.existsSync(contextPath())).toBe(false); // installContext never called
+    });
+});

package/dist/tests/core/context/strategies/config-instructions.test.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// cli/tests/core/context/strategies/config-instructions.test.ts
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const config_instructions_1 = require("../../../../src/core/context/strategies/config-instructions");
+const provider_1 = require("../../../../src/core/context/provider");
+function setup(opencodeJson) {
+    const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-oc-'));
+    const configPath = path_1.default.join(dir, 'opencode.json');
+    if (opencodeJson)
+        fs_1.default.writeFileSync(configPath, JSON.stringify(opencodeJson, null, 2));
+    const absPath = path_1.default.join(dir, '.awm/context/awm-context.md');
+    fs_1.default.mkdirSync(path_1.default.dirname(absPath), { recursive: true });
+    fs_1.default.writeFileSync(absPath, 'CTX');
+    const provider = {
+        label: 'OpenCode', skill: { global: '', local: '' }, workflow: null, agent: null,
+        injection: { type: 'config-instructions', configPath, field: 'instructions' },
+    };
+    const input = {
+        ref: { absPath, scope: 'global', contentHash: (0, provider_1.sha256)('CTX') },
+        registryRoot: '/reg', installMethod: 'symlink', agent: 'opencode', scope: 'global',
+    };
+    return { configPath, absPath, provider, input };
+}
+const strat = new config_instructions_1.ConfigInstructionsStrategy();
+describe('ConfigInstructionsStrategy.inject', () => {
+    it('creates opencode.json with the sentinel when it does not exist', () => {
+        const { configPath, absPath, provider, input } = setup();
+        strat.inject(input, provider);
+        const cfg = JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
+        expect(cfg.instructions).toContain(absPath);
+        expect(cfg.$schema).toBe('https://opencode.ai/config.json');
+    });
+    it('preserves user instructions and is idempotent (no duplicate)', () => {
+        const { configPath, absPath, provider, input } = setup({ instructions: ['docs/rules.md'] });
+        strat.inject(input, provider);
+        strat.inject(input, provider);
+        const cfg = JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
+        expect(cfg.instructions).toContain('docs/rules.md');
+        expect(cfg.instructions.filter((e) => e === absPath)).toHaveLength(1);
+    });
+});
+describe('ConfigInstructionsStrategy.remove', () => {
+    it('removes only the sentinel, preserving user entries', () => {
+        const { configPath, absPath, provider, input } = setup({ instructions: ['docs/rules.md'] });
+        strat.inject(input, provider);
+        strat.remove(input, provider);
+        const cfg = JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
+        expect(cfg.instructions).toEqual(['docs/rules.md']);
+    });
+});
+describe('ConfigInstructionsStrategy.status', () => {
+    it('absent when no config / no entry', () => {
+        const { provider, input } = setup();
+        expect(strat.status(input, provider)).toBe('absent');
+    });
+    it('injected when entry present and materialized hash matches', () => {
+        const { provider, input } = setup();
+        strat.inject(input, provider);
+        expect(strat.status(input, provider)).toBe('injected');
+    });
+    it('stale when entry present but materialized file content drifted', () => {
+        const { absPath, provider, input } = setup();
+        strat.inject(input, provider);
+        fs_1.default.writeFileSync(absPath, 'DRIFTED');
+        expect(strat.status(input, provider)).toBe('stale');
+    });
+    it('stale when sentinel entry is present but the materialized file no longer exists', () => {
+        const { absPath, provider, input } = setup();
+        strat.inject(input, provider);
+        fs_1.default.rmSync(absPath);
+        expect(strat.status(input, provider)).toBe('stale');
+    });
+    it('throws actionable error on malformed opencode.json instead of clobbering', () => {
+        const { configPath, provider, input } = setup();
+        fs_1.default.writeFileSync(configPath, '{ not json');
+        expect(() => strat.inject(input, provider)).toThrow('not valid JSON');
+    });
+    it('throws when instructions is a non-array value instead of silently overwriting it', () => {
+        const { provider, input } = setup({ instructions: 'docs/rules.md' });
+        expect(() => strat.inject(input, provider)).toThrow("'instructions' field must be an array");
+    });
+});

package/dist/tests/core/context/strategies/hook-merge.test.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+// cli/tests/core/context/strategies/hook-merge.test.ts
+const hook_merge_1 = require("../../../../src/core/context/strategies/hook-merge");
+const install = __importStar(require("../../../../src/commands/hooks/install"));
+const uninstall = __importStar(require("../../../../src/commands/hooks/uninstall"));
+const status = __importStar(require("../../../../src/commands/hooks/status"));
+function input() {
+    return {
+        ref: { absPath: '/tmp/awm-context.md', scope: 'global', contentHash: 'h' },
+        registryRoot: '/reg', installMethod: 'symlink', agent: 'claude-code', scope: 'global',
+    };
+}
+const provider = {};
+const strat = new hook_merge_1.HookMergeStrategy();
+describe('HookMergeStrategy', () => {
+    it('inject delegates to installHook with agent/registryRoot/installMethod', () => {
+        const spy = jest.spyOn(install, 'installHook').mockReturnValue({});
+        strat.inject(input(), provider);
+        expect(spy).toHaveBeenCalledWith({ agent: 'claude-code', registryRoot: '/reg', installMethod: 'symlink' });
+        spy.mockRestore();
+    });
+    it('remove delegates to uninstallHook', () => {
+        const spy = jest.spyOn(uninstall, 'uninstallHook').mockReturnValue({});
+        strat.remove(input(), provider);
+        expect(spy).toHaveBeenCalledWith({ agent: 'claude-code' });
+        spy.mockRestore();
+    });
+    it.each([
+        ['HEALTHY', 'injected'],
+        ['DEGRADED', 'stale'],
+        ['NOT_INSTALLED', 'absent'],
+    ])('status maps hook overall %s → %s', (overall, expected) => {
+        const spy = jest.spyOn(status, 'computeHookStatus').mockReturnValue({ overall });
+        expect(strat.status(input(), provider)).toBe(expected);
+        spy.mockRestore();
+    });
+});

package/dist/tests/core/context/types.test.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+describe('context contracts', () => {
+    it('compiles AwmContext / MaterializedRef / InjectionInput with the expected shape', () => {
+        const ctx = { markdown: '# AWM', sourceVersion: '1.0.0', contentHash: 'abc' };
+        const ref = { absPath: '/tmp/awm-context.md', scope: 'global', contentHash: 'abc' };
+        const input = {
+            ref, registryRoot: '/reg', installMethod: 'symlink', agent: 'opencode', scope: 'global',
+        };
+        const states = ['injected', 'absent', 'stale'];
+        expect(ctx.contentHash).toBe(ref.contentHash);
+        expect(input.agent).toBe('opencode');
+        expect(states).toHaveLength(3);
+    });
+});