agentic-workflow-manager 2.0.0

package/dist/tests/core/executor.test.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// tests/core/executor.test.ts
+const executor_1 = require("../../src/core/executor");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+describe('Executor Engine', () => {
+    const sourceDir = path_1.default.join(__dirname, 'mock_source');
+    const targetDir = path_1.default.join(__dirname, 'mock_target');
+    beforeEach(() => {
+        fs_1.default.mkdirSync(sourceDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(sourceDir, 'test.txt'), 'hello');
+        fs_1.default.mkdirSync(targetDir, { recursive: true });
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(sourceDir, { recursive: true, force: true });
+        fs_1.default.rmSync(targetDir, { recursive: true, force: true });
+    });
+    it('creates a symlink successfully', () => {
+        const dest = path_1.default.join(targetDir, 'my-skill');
+        (0, executor_1.installArtifact)(sourceDir, dest, 'symlink');
+        expect(fs_1.default.lstatSync(dest).isSymbolicLink()).toBe(true);
+    });
+    it('copies the directory successfully', () => {
+        const dest = path_1.default.join(targetDir, 'my-copied-skill');
+        (0, executor_1.installArtifact)(sourceDir, dest, 'copy');
+        expect(fs_1.default.lstatSync(dest).isDirectory()).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(dest, 'test.txt'))).toBe(true);
+    });
+    it('removes an installed artifact', () => {
+        const dest = path_1.default.join(targetDir, 'to-remove');
+        (0, executor_1.installArtifact)(sourceDir, dest, 'symlink');
+        expect(fs_1.default.existsSync(dest)).toBe(true);
+        (0, executor_1.removeArtifact)(dest);
+        expect(fs_1.default.existsSync(dest)).toBe(false);
+    });
+    it('throws when removing a non-existent artifact', () => {
+        const dest = path_1.default.join(targetDir, 'does-not-exist');
+        expect(() => (0, executor_1.removeArtifact)(dest)).toThrow('Artifact not found');
+    });
+});

package/dist/tests/core/init/detector.test.js

@@ -0,0 +1,56 @@
+"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 detector_1 = require("../../../src/core/init/detector");
+function tmpRepo() {
+    return fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-detector-'));
+}
+describe('detectExtensions', () => {
+    let root;
+    beforeEach(() => { root = tmpRepo(); });
+    afterEach(() => { fs_1.default.rmSync(root, { recursive: true, force: true }); });
+    it('proposes frontend when package.json has a frontend dep', () => {
+        fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), JSON.stringify({ dependencies: { next: '14.0.0' } }));
+        const r = (0, detector_1.detectExtensions)(root);
+        expect(r.proposed).toContain('frontend');
+        expect(r.signals.some((s) => s.includes('next'))).toBe(true);
+    });
+    it('does NOT propose docs for a lone README', () => {
+        fs_1.default.mkdirSync(path_1.default.join(root, 'docs'));
+        fs_1.default.writeFileSync(path_1.default.join(root, 'docs', 'README.md'), '# readme');
+        expect((0, detector_1.detectExtensions)(root).proposed).not.toContain('docs');
+    });
+    it('proposes docs when a docs config is present', () => {
+        fs_1.default.writeFileSync(path_1.default.join(root, 'mkdocs.yml'), 'site_name: x');
+        expect((0, detector_1.detectExtensions)(root).proposed).toContain('docs');
+    });
+    it('proposes docs when docs/ has 2+ markdown files', () => {
+        fs_1.default.mkdirSync(path_1.default.join(root, 'docs'));
+        fs_1.default.writeFileSync(path_1.default.join(root, 'docs', 'a.md'), '# a');
+        fs_1.default.writeFileSync(path_1.default.join(root, 'docs', 'b.md'), '# b');
+        expect((0, detector_1.detectExtensions)(root).proposed).toContain('docs');
+    });
+    it('proposes nothing for a backend-only repo', () => {
+        fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), JSON.stringify({ dependencies: { express: '4.0.0' } }));
+        const r = (0, detector_1.detectExtensions)(root);
+        expect(r.proposed).toEqual([]);
+        expect(r.deferred).toEqual([]);
+    });
+    it('defers infra signals (no bundle yet)', () => {
+        fs_1.default.writeFileSync(path_1.default.join(root, 'Dockerfile'), 'FROM node');
+        const r = (0, detector_1.detectExtensions)(root);
+        expect(r.proposed).toEqual([]);
+        expect(r.deferred.some((d) => d.includes('infra'))).toBe(true);
+    });
+    it('proposes both for a combined repo (Next + real docs)', () => {
+        fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), JSON.stringify({ devDependencies: { astro: '4.0.0' } }));
+        fs_1.default.writeFileSync(path_1.default.join(root, 'docusaurus.config.js'), 'module.exports = {}');
+        const r = (0, detector_1.detectExtensions)(root);
+        expect(r.proposed).toEqual(expect.arrayContaining(['frontend', 'docs']));
+    });
+});

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

@@ -0,0 +1,122 @@
+"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"));
+// Siembra un registry baseline mínimo en <contentRoot> (= ~/.awm/registries/baseline).
+// El content root ES la raíz del registry — no hay subdir "registry/" en la nueva arquitectura.
+function seedRegistry(contentRoot) {
+    fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'skills', 'brainstorming'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'skills', 'brainstorming', 'SKILL.md'), '# brainstorming');
+    fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'skills', 'using-awm'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'skills', 'using-awm', 'SKILL.md'), '# using-awm');
+    fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'hooks'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'hooks', 'session-start'), '#!/bin/sh\n');
+    fs_1.default.chmodSync(path_1.default.join(contentRoot, 'hooks', 'session-start'), 0o755);
+    fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'hooks', 'run-hook.cmd'), '#!/bin/sh\n');
+    fs_1.default.chmodSync(path_1.default.join(contentRoot, 'hooks', 'run-hook.cmd'), 0o755);
+    fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'sensor-packs', 'js-ts'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'sensor-packs', 'js-ts', 'pack.json'), JSON.stringify({ sensors: { lint: { defaultCmd: 'eslint {{SOURCE_DIRS}}', fast: true } } }));
+    // catalog + bundle dev (baseline)
+    fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'catalog.json'), JSON.stringify({
+        version: 1, bundles: [{ name: 'dev', source: './bundles/dev', version: '1.0.0', scope: 'baseline' }],
+    }));
+    fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'bundles', 'dev'), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'bundles', 'dev', 'bundle.json'), JSON.stringify({
+        name: 'dev', version: '1.0.0', scope: 'baseline', dependsOn: [],
+        skills: [{ name: 'brainstorming' }, { name: 'using-awm' }], workflows: [], agents: [],
+    }));
+    // Seed .git in the content root so gatherMachine.registryCache.present is true.
+    fs_1.default.mkdirSync(path_1.default.join(contentRoot, '.git'), { recursive: true });
+}
+describe('runInitSteps — orchestrator', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-init-orch-'));
+        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;
+    });
+    function buildDeps(cwd) {
+        const { gatherContext } = require('../../../src/core/diagnostics/context');
+        const { discoverAllBundles } = require('../../../src/core/bundles');
+        const { contentRoots, REGISTRIES_DIR } = require('../../../src/core/registries');
+        const { defaultActions } = require('../../../src/core/init/steps');
+        // Seed content at ~/.awm/registries/baseline (content root IS the registry root).
+        const contentRoot = path_1.default.join(process.env.AWM_HOME, 'registries', 'baseline');
+        fs_1.default.mkdirSync(contentRoot, { recursive: true });
+        seedRegistry(contentRoot);
+        // Register the baseline registry in registries.json so contentRoots() picks it up.
+        const registriesJson = path_1.default.join(process.env.AWM_HOME, 'registries.json');
+        fs_1.default.writeFileSync(registriesJson, JSON.stringify([
+            { name: 'baseline', remote: 'https://example.com/baseline.git' },
+        ], null, 2));
+        const roots = contentRoots();
+        const bundles = discoverAllBundles(roots);
+        const contentDir = roots[0] ?? '';
+        const ctx = gatherContext({ cwd, bundles });
+        return {
+            cwd, ctx, bundles, agent: 'claude-code', installMethod: 'symlink',
+            registryRoot: contentRoot, contentDir, sensorPacksRoot: contentRoot,
+            confirmExtensions: async (p) => p,
+            // syncCache es no-op: el cache ya está sembrado en disco
+            actions: { ...defaultActions, syncCache: async () => { } },
+        };
+    }
+    it('machine-only on a bare cwd installs baseline + hook, reaches healthy machine', async () => {
+        const { runInitSteps } = require('../../../src/core/init/orchestrator');
+        const bareCwd = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-bare-'));
+        try {
+            const deps = buildDeps(bareCwd); // bareCwd no es repo → project null
+            deps.ctx.project = null;
+            const out = await runInitSteps(deps);
+            expect(out.applied).toBeGreaterThan(0);
+            expect(out.steps.some((s) => s.id === 'machine.devCore' && s.action === 'applied')).toBe(true);
+            expect(out.after.results.find((r) => r.id === 'machine.devCore').status).toBe('ok');
+        }
+        finally {
+            fs_1.default.rmSync(bareCwd, { recursive: true, force: true });
+        }
+    });
+    it('project repo: applies activation/sensors, flags constitution+context as pending', async () => {
+        const root = path_1.default.join(tmpHome, 'repo');
+        fs_1.default.mkdirSync(path_1.default.join(root, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), JSON.stringify({ dependencies: { next: '14.0.0' } }));
+        const deps = buildDeps(root);
+        const { runInitSteps } = require('../../../src/core/init/orchestrator');
+        const out = await runInitSteps(deps);
+        expect(out.steps.some((s) => s.id === 'project.sensors' && s.action === 'applied')).toBe(true);
+        expect(out.steps.find((s) => s.id === 'project.constitution').action).toBe('pending');
+        expect(out.steps.find((s) => s.id === 'project.context').action).toBe('pending');
+    });
+    it('is idempotent: a second run applies nothing and yields an identical after-report', async () => {
+        const root = path_1.default.join(tmpHome, 'repo2');
+        fs_1.default.mkdirSync(path_1.default.join(root, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), JSON.stringify({ dependencies: { next: '14.0.0' } }));
+        const { runInitSteps } = require('../../../src/core/init/orchestrator');
+        const out1 = await runInitSteps(buildDeps(root));
+        expect(out1.applied).toBeGreaterThan(0);
+        // segundo run: re-gather refleja el estado ya materializado
+        const out2 = await runInitSteps(buildDeps(root));
+        expect(out2.applied).toBe(0);
+        expect(out2.after).toEqual(out1.after);
+    });
+});

package/dist/tests/core/init/steps.test.js

@@ -0,0 +1,363 @@
+"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 steps_1 = require("../../../src/core/init/steps");
+const providers_1 = require("../../../src/providers");
+function bundle(name, scope, skills) {
+    return {
+        name, description: '', version: '1.0.0', scope, visibility: 'public',
+        dependsOn: [], skills: skills.map((s) => ({ name: s, onSignal: false })),
+        workflows: [], agents: [],
+    };
+}
+function machine() {
+    return {
+        registryCache: { present: true, gitState: 'clean' },
+        hook: { present: true, degraded: false },
+        devCore: { present: true, brokenLinks: [] },
+        ambient: { wanted: [], installed: [] },
+        contextInjection: [],
+        globalSkills: { valid: [], repairable: [], dead: [] },
+    };
+}
+function project(over = {}) {
+    return {
+        root: '/repo',
+        profile: { present: true, extensions: [] },
+        activeBundles: { expected: [], linked: [], broken: [] },
+        sensors: { present: true },
+        constitution: { present: true },
+        context: { present: true, file: 'CLAUDE.md' },
+        ...over,
+    };
+}
+function spies() {
+    return {
+        syncCache: jest.fn(async () => { }),
+        installHook: jest.fn(() => ({ status: 'installed' })),
+        installBundle: jest.fn(() => ({ installed: ['a'], skipped: [] })),
+        syncProfile: jest.fn(() => ({ installed: ['a'], skipped: [], extensions: ['frontend'] })),
+        initSensors: jest.fn(() => ({ detection: { pack: 'js-ts' } })),
+        addExtension: jest.fn(),
+        ensureProfile: jest.fn(),
+        gatherProject: jest.fn((_cwd, _bundles) => null),
+        contextStatus: jest.fn(() => 'absent'),
+        installContext: jest.fn(),
+        repairGlobalSkills: jest.fn(() => ({ relinked: [], pruned: [], failed: [] })),
+        injectProjectConstitution: jest.fn(() => 'injected'),
+    };
+}
+function deps(ctx, actions, over = {}) {
+    return {
+        cwd: '/repo', ctx, bundles: [bundle('dev', 'baseline', ['brainstorming'])],
+        agent: 'claude-code', installMethod: 'symlink',
+        registryRoot: '/cache', contentDir: '/cache/registry', sensorPacksRoot: '/cache/registry',
+        confirmExtensions: async (p) => p, actions, ...over,
+    };
+}
+describe('stepCache', () => {
+    it('skips when cli present and not behind', async () => {
+        const a = spies();
+        const r = await (0, steps_1.stepCache)(deps({ machine: machine(), project: null }, a));
+        expect(r.action).toBe('skipped');
+        expect(a.syncCache).not.toHaveBeenCalled();
+    });
+    it('syncs when registry cache absent', async () => {
+        const a = spies();
+        const m = machine();
+        m.registryCache = { present: false };
+        const r = await (0, steps_1.stepCache)(deps({ machine: m, project: null }, a));
+        expect(r.action).toBe('applied');
+        expect(a.syncCache).toHaveBeenCalled();
+    });
+    it('syncs when registry cache behind', async () => {
+        const a = spies();
+        const m = machine();
+        m.registryCache = { present: true, gitState: 'behind' };
+        expect((await (0, steps_1.stepCache)(deps({ machine: m, project: null }, a))).action).toBe('applied');
+    });
+    it('reports failed when syncCache throws (does not throw)', async () => {
+        const a = spies();
+        a.syncCache = jest.fn(async () => { throw new Error('net down'); });
+        const m = machine();
+        m.registryCache = { present: false };
+        const r = await (0, steps_1.stepCache)(deps({ machine: m, project: null }, a));
+        expect(r.action).toBe('failed');
+        expect(r.error).toContain('net down');
+    });
+});
+describe('stepHook / stepDevCore / stepAmbient', () => {
+    it('hook skips when present and healthy', () => {
+        const a = spies();
+        expect((0, steps_1.stepHook)(deps({ machine: machine(), project: null }, a)).action).toBe('skipped');
+        expect(a.installHook).not.toHaveBeenCalled();
+    });
+    it('hook installs when absent', () => {
+        const a = spies();
+        const m = machine();
+        m.hook = { present: false };
+        expect((0, steps_1.stepHook)(deps({ machine: m, project: null }, a)).action).toBe('applied');
+        expect(a.installHook).toHaveBeenCalled();
+    });
+    it('hook reinstalls when present but degraded', () => {
+        const a = spies();
+        const m = machine();
+        m.hook = { present: true, degraded: true };
+        expect((0, steps_1.stepHook)(deps({ machine: m, project: null }, a)).action).toBe('applied');
+        expect(a.installHook).toHaveBeenCalled();
+    });
+    it('devCore installs baseline when links broken', () => {
+        const a = spies();
+        const m = machine();
+        m.devCore = { present: true, brokenLinks: ['brainstorming'] };
+        expect((0, steps_1.stepDevCore)(deps({ machine: m, project: null }, a)).action).toBe('applied');
+        expect(a.installBundle).toHaveBeenCalled();
+    });
+    it('devCore installs when not present at all', () => {
+        const a = spies();
+        const m = machine();
+        m.devCore = { present: false, brokenLinks: [] };
+        expect((0, steps_1.stepDevCore)(deps({ machine: m, project: null }, a)).action).toBe('applied');
+        expect(a.installBundle).toHaveBeenCalled();
+    });
+    it('ambient installs only missing wanted', () => {
+        const a = spies();
+        const m = machine();
+        m.ambient = { wanted: ['personal-notion', 'docs'], installed: ['docs'] };
+        const r = (0, steps_1.stepAmbient)(deps({ machine: m, project: null }, a));
+        expect(r.action).toBe('applied');
+        expect(a.installBundle).toHaveBeenCalledTimes(1);
+    });
+    it('ambient skips when nothing wanted', () => {
+        const a = spies();
+        expect((0, steps_1.stepAmbient)(deps({ machine: machine(), project: null }, a)).action).toBe('skipped');
+    });
+});
+describe('stepProfile', () => {
+    it('adds confirmed extension when detector finds a match', async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-step-profile-'));
+        try {
+            fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), JSON.stringify({ dependencies: { next: '14.0.0' } }));
+            const a = spies();
+            const ctx = {
+                machine: machine(),
+                project: project({ root, profile: { present: true, extensions: [] } }),
+            };
+            const r = await (0, steps_1.stepProfile)(deps(ctx, a, { confirmExtensions: async (p) => p }));
+            expect(r.action).toBe('applied');
+            expect(a.addExtension).toHaveBeenCalledWith(root, 'frontend');
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('skips when confirm returns empty', async () => {
+        const a = spies();
+        const ctx = { machine: machine(), project: project() };
+        const r = await (0, steps_1.stepProfile)(deps(ctx, a, { confirmExtensions: async () => [] }));
+        expect(a.addExtension).not.toHaveBeenCalled();
+        expect(r.action).toBe('skipped');
+    });
+    it('does not invoke confirmExtensions when no new extensions are proposed (#1 guard)', async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-empty-ext-'));
+        try {
+            const a = spies();
+            const confirm = jest.fn(async (p) => p);
+            const ctx = {
+                machine: machine(),
+                project: project({ root, profile: { present: true, extensions: [] } }),
+            };
+            const r = await (0, steps_1.stepProfile)(deps(ctx, a, { confirmExtensions: confirm }));
+            expect(confirm).not.toHaveBeenCalled();
+            expect(r.action).toBe('skipped');
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('bootstraps an empty profile when none exists and no extensions are proposed', async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-bootstrap-profile-'));
+        try {
+            const a = spies();
+            const ctx = {
+                machine: machine(),
+                project: project({ root, profile: { present: false, extensions: [] } }),
+            };
+            const r = await (0, steps_1.stepProfile)(deps(ctx, a, { confirmExtensions: async (p) => p }));
+            expect(r.action).toBe('applied');
+            expect(a.ensureProfile).toHaveBeenCalledWith(root);
+            expect(a.addExtension).not.toHaveBeenCalled();
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('does not bootstrap when the profile already exists', async () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-existing-profile-'));
+        try {
+            const a = spies();
+            const ctx = {
+                machine: machine(),
+                project: project({ root, profile: { present: true, extensions: [] } }),
+            };
+            const r = await (0, steps_1.stepProfile)(deps(ctx, a));
+            expect(r.action).toBe('skipped');
+            expect(a.ensureProfile).not.toHaveBeenCalled();
+        }
+        finally {
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+        }
+    });
+});
+describe('stepActivation', () => {
+    it('skips when expected all linked and none broken', () => {
+        const a = spies();
+        a.gatherProject = jest.fn((_cwd, _bundles) => project({ activeBundles: { expected: ['x'], linked: ['x'], broken: [] } }));
+        const r = (0, steps_1.stepActivation)(deps({ machine: machine(), project: project() }, a));
+        expect(r.action).toBe('skipped');
+        expect(a.syncProfile).not.toHaveBeenCalled();
+    });
+    it('syncs when links missing', () => {
+        const a = spies();
+        a.gatherProject = jest.fn((_cwd, _bundles) => project({ activeBundles: { expected: ['x', 'y'], linked: ['x'], broken: [] } }));
+        const r = (0, steps_1.stepActivation)(deps({ machine: machine(), project: project() }, a));
+        expect(r.action).toBe('applied');
+        expect(a.syncProfile).toHaveBeenCalled();
+    });
+    it('passes target agent to gatherProject (#4 — project local skills scoped to agent)', () => {
+        const a = spies();
+        const m = machine();
+        m.devCore = { present: true, brokenLinks: [] };
+        const ctx = { machine: m, project: project() };
+        (0, steps_1.stepActivation)(deps(ctx, a, { agent: 'opencode' }));
+        expect(a.gatherProject).toHaveBeenCalledWith(expect.any(String), expect.any(Array), 'opencode');
+    });
+});
+describe('stepSensors', () => {
+    it('skips when sensors present', () => {
+        const a = spies();
+        expect((0, steps_1.stepSensors)(deps({ machine: machine(), project: project() }, a)).action).toBe('skipped');
+    });
+    it('inits sensors when absent', () => {
+        const a = spies();
+        const r = (0, steps_1.stepSensors)(deps({ machine: machine(), project: project({ sensors: { present: false } }) }, a));
+        expect(r.action).toBe('applied');
+        expect(a.initSensors).toHaveBeenCalledWith({ cwd: '/repo', registryRoot: '/cache/registry', configure: true }); // sensorPacksRoot='/cache/registry' from deps()
+    });
+});
+describe('stepConstitution / stepContext (frontera agente)', () => {
+    it('constitution pending + names the skill, never writes', () => {
+        const a = spies();
+        const r = (0, steps_1.stepConstitution)(deps({ machine: machine(), project: project({ constitution: { present: false } }) }, a));
+        expect(r.action).toBe('pending');
+        expect(r.detail).toContain('project-constitution');
+    });
+    it('context pending names project-context-init', () => {
+        const a = spies();
+        const r = (0, steps_1.stepContext)(deps({ machine: machine(), project: project({ context: { present: false } }) }, a));
+        expect(r.action).toBe('pending');
+        expect(r.detail).toContain('project-context-init');
+    });
+    it('both skip when present', () => {
+        const a = spies();
+        const ctx = { machine: machine(), project: project() };
+        expect((0, steps_1.stepConstitution)(deps(ctx, a)).action).toBe('skipped');
+        expect((0, steps_1.stepContext)(deps(ctx, a)).action).toBe('skipped');
+    });
+});
+describe('stepGlobalSkillsRepair', () => {
+    it('skips when nothing is broken', () => {
+        const a = spies();
+        const m = machine(); // globalSkills.repairable=[], dead=[] by default
+        const r = (0, steps_1.stepGlobalSkillsRepair)(deps({ machine: m, project: null }, a));
+        expect(r.action).toBe('skipped');
+        expect(a.repairGlobalSkills).not.toHaveBeenCalled();
+    });
+    it('applies repair when there are broken links', () => {
+        const a = spies();
+        a.repairGlobalSkills = jest.fn(() => ({ relinked: ['b'], pruned: ['c'], failed: [] }));
+        const m = machine();
+        m.globalSkills = { valid: ['a'], repairable: ['b'], dead: ['c'] };
+        const r = (0, steps_1.stepGlobalSkillsRepair)(deps({ machine: m, project: null }, a));
+        expect(r.action).toBe('applied');
+        expect(a.repairGlobalSkills).toHaveBeenCalledTimes(1);
+        expect(r.detail).toContain('re-linked 1');
+        expect(r.detail).toContain('pruned 1');
+    });
+    it('repairs the target agent skills dir, not Claude (#4)', () => {
+        const a = spies();
+        a.repairGlobalSkills = jest.fn(() => ({ relinked: ['b'], pruned: [], failed: [] }));
+        const m = machine();
+        m.globalSkills = { valid: [], repairable: ['b'], dead: [] };
+        const r = (0, steps_1.stepGlobalSkillsRepair)(deps({ machine: m, project: null }, a, { agent: 'opencode' }));
+        expect(r.action).toBe('applied');
+        expect(a.repairGlobalSkills).toHaveBeenCalledWith(providers_1.PROVIDERS['opencode'].skill.global, expect.any(Array));
+    });
+});
+describe('stepConstitutionInjection (#6)', () => {
+    it('injects for a config-instructions agent when CONSTITUTION.md is present', () => {
+        const a = spies();
+        const r = (0, steps_1.stepConstitutionInjection)(deps({ machine: machine(), project: project({ constitution: { present: true } }) }, a, { agent: 'opencode' }));
+        expect(r.action).toBe('applied');
+        expect(a.injectProjectConstitution).toHaveBeenCalledWith({ projectRoot: '/repo', agent: 'opencode' });
+    });
+    it('skips for Claude (delivered by the hook), never touching the action', () => {
+        const a = spies();
+        const r = (0, steps_1.stepConstitutionInjection)(deps({ machine: machine(), project: project({ constitution: { present: true } }) }, a, { agent: 'claude-code' }));
+        expect(r.action).toBe('skipped');
+        expect(a.injectProjectConstitution).not.toHaveBeenCalled();
+    });
+    it('skips when CONSTITUTION.md is absent', () => {
+        const a = spies();
+        const r = (0, steps_1.stepConstitutionInjection)(deps({ machine: machine(), project: project({ constitution: { present: false } }) }, a, { agent: 'opencode' }));
+        expect(r.action).toBe('skipped');
+        expect(a.injectProjectConstitution).not.toHaveBeenCalled();
+    });
+    it('maps already → skipped when CONSTITUTION.md was already in opencode.json', () => {
+        const a = spies();
+        a.injectProjectConstitution.mockReturnValue('already');
+        const r = (0, steps_1.stepConstitutionInjection)(deps({ machine: machine(), project: project({ constitution: { present: true } }) }, a, { agent: 'opencode' }));
+        expect(r.action).toBe('skipped');
+        expect(r.detail).toBe('already');
+    });
+});
+describe('stepContextInjection', () => {
+    it('skips claude-code (covered by stepHook)', () => {
+        const a = spies();
+        const r = (0, steps_1.stepContextInjection)(deps({ machine: machine(), project: null }, a, { agent: 'claude-code' }));
+        expect(r.action).toBe('skipped');
+        expect(a.installContext).not.toHaveBeenCalled();
+    });
+    it('skips an agent without an injection mechanism', () => {
+        const a = spies();
+        const r = (0, steps_1.stepContextInjection)(deps({ machine: machine(), project: null }, a, { agent: 'antigravity' }));
+        expect(r.action).toBe('skipped');
+        expect(a.installContext).not.toHaveBeenCalled();
+    });
+    it('skips opencode when already injected', () => {
+        const a = spies();
+        a.contextStatus = jest.fn(() => 'injected');
+        const r = (0, steps_1.stepContextInjection)(deps({ machine: machine(), project: null }, a, { agent: 'opencode' }));
+        expect(r.action).toBe('skipped');
+        expect(a.installContext).not.toHaveBeenCalled();
+    });
+    it('installs context for opencode when absent', () => {
+        const a = spies();
+        a.contextStatus = jest.fn(() => 'absent');
+        const r = (0, steps_1.stepContextInjection)(deps({ machine: machine(), project: null }, a, { agent: 'opencode' }));
+        expect(r.action).toBe('applied');
+        expect(a.installContext).toHaveBeenCalledWith(expect.objectContaining({ agent: 'opencode', scope: 'global' }));
+    });
+    it('installs context for opencode when stale', () => {
+        const a = spies();
+        a.contextStatus = jest.fn(() => 'stale');
+        const r = (0, steps_1.stepContextInjection)(deps({ machine: machine(), project: null }, a, { agent: 'opencode' }));
+        expect(r.action).toBe('applied');
+        expect(a.installContext).toHaveBeenCalled();
+    });
+});

package/dist/tests/core/ledger/gitignore.test.js

@@ -0,0 +1,13 @@
+"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"));
+test('.awm (and therefore .awm/ledger) is gitignored — raw ledger never committed', () => {
+    const gitignore = fs_1.default.readFileSync(path_1.default.join(__dirname, '../../../../.gitignore'), 'utf-8');
+    const lines = gitignore.split('\n').map(l => l.trim());
+    const coversAwm = lines.includes('.awm') || lines.includes('.awm/') || lines.includes('.awm/ledger') || lines.includes('.awm/ledger/');
+    expect(coversAwm).toBe(true);
+});