agentic-workflow-manager 3.1.0 → 3.2.1

package/dist/tests/core/init/mutation-targets.test.js

@@ -0,0 +1,235 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Direct, focused tests for planInitMutationTargets (mutation-targets.ts).
+//
+// Previously this module was only exercised indirectly via
+// tests/commands/init.test.ts's broader init-flow tests, which happen to hit
+// the hooks.settingsPath branch but not the ambient/baseline/project-extension
+// branches, nor the Finding-1 fix (global skills directory) directly.
+//
+// registries.ts computes AWM_HOME at module-require time (not call time), so
+// every test here sets HOME/AWM_HOME BEFORE requiring
+// core/init/mutation-targets.ts, and calls jest.resetModules() first — the
+// same pattern used throughout tests/commands/hooks/install.test.ts and
+// tests/core/skill-integrity.test.ts. Per CLAUDE.md, no test may touch the
+// real ~/.awm.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+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: [],
+    };
+}
+let tmpHome;
+let originalHome;
+let originalAwmHome;
+let extraDirs;
+beforeEach(() => {
+    tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-mutation-targets-'));
+    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();
+    extraDirs = [];
+});
+afterEach(() => {
+    fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+    for (const dir of extraDirs)
+        fs_1.default.rmSync(dir, { 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;
+});
+/**
+ * Loads a fresh copy of the module under test (and providerFor, which needs
+ * the same env-var-driven paths) AFTER env vars are set for this test.
+ */
+function load() {
+    const mutationTargets = require('../../../src/core/init/mutation-targets');
+    const providers = require('../../../src/providers');
+    return {
+        planInitMutationTargets: mutationTargets.planInitMutationTargets,
+        providerFor: providers.providerFor,
+    };
+}
+/** A cwd guaranteed to have no project-root marker (.git/package.json/.awm) in its ancestry. */
+function bareCwd() {
+    const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-mutation-targets-cwd-'));
+    extraDirs.push(dir);
+    return dir;
+}
+describe('planInitMutationTargets', () => {
+    it('always includes preferences.json and the artifact-state file', () => {
+        const { planInitMutationTargets } = load();
+        const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'claude-code', bundles: [] });
+        expect(targets).toContain(path_1.default.join(tmpHome, '.awm', 'preferences.json'));
+        expect(targets).toContain(path_1.default.join(tmpHome, '.awm', 'state', 'artifacts.json'));
+    });
+    describe('hooks', () => {
+        it('includes hooks.settingsPath and hooks.scriptsDir for an agent with a hook config (claude-code)', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            const provider = providerFor('claude-code');
+            const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'claude-code', bundles: [] });
+            expect(provider.hooks).toBeDefined();
+            expect(targets).toContain(provider.hooks.settingsPath);
+            expect(targets).toContain(provider.hooks.scriptsDir);
+        });
+        it('includes hooks.json + scriptsDir for codex (its own hook config shape)', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            const provider = providerFor('codex');
+            const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'codex', bundles: [] });
+            expect(targets).toContain(provider.hooks.settingsPath);
+            expect(targets).toContain(provider.hooks.scriptsDir);
+        });
+        it('includes no hook paths for an agent with no hook config (antigravity)', () => {
+            const { planInitMutationTargets } = load();
+            const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'antigravity', bundles: [] });
+            // antigravity has neither hooks nor injection — its only entries are
+            // the two always-present machine paths.
+            expect(targets).toEqual([
+                path_1.default.join(tmpHome, '.awm', 'preferences.json'),
+                path_1.default.join(tmpHome, '.awm', 'state', 'artifacts.json'),
+                path_1.default.join(tmpHome, '.gemini', 'antigravity', 'skills'),
+            ]);
+        });
+    });
+    describe('injection', () => {
+        it('includes the config-instructions path for opencode', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            const provider = providerFor('opencode');
+            const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'opencode', bundles: [] });
+            expect(provider.injection?.type).toBe('config-instructions');
+            expect(targets).toContain(provider.injection.configPath);
+        });
+        it('includes the managed-agents-md global path for codex', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            const provider = providerFor('codex');
+            const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'codex', bundles: [] });
+            expect(provider.injection?.type).toBe('managed-agents-md');
+            expect(targets).toContain(provider.injection.globalPath);
+        });
+        it('adds no separate injection path for claude-code (cc-settings-merge is covered by the hook)', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            const provider = providerFor('claude-code');
+            const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'claude-code', bundles: [] });
+            expect(provider.injection?.type).toBe('cc-settings-merge');
+            // Every target should be explainable by preferences/state/hooks/skills-dir —
+            // none of them should be a bespoke injection config file.
+            expect(targets).toEqual([
+                path_1.default.join(tmpHome, '.awm', 'preferences.json'),
+                path_1.default.join(tmpHome, '.awm', 'state', 'artifacts.json'),
+                provider.hooks.settingsPath,
+                provider.hooks.scriptsDir,
+                provider.skill.global,
+            ]);
+        });
+    });
+    describe('machine-level bundle targets (baseline + ambient)', () => {
+        it('includes physical skill targets for baseline and ambient bundles, but not a project-scope bundle', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            const bundles = [
+                bundle('dev-core', 'baseline', ['using-awm']),
+                bundle('ambient-pack', 'ambient', ['ambient-skill']),
+                bundle('project-only', 'project', ['project-skill']),
+            ];
+            const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'claude-code', bundles });
+            const skillsDir = providerFor('claude-code').skill.global;
+            expect(targets).toContain(path_1.default.join(skillsDir, 'using-awm'));
+            expect(targets).toContain(path_1.default.join(skillsDir, 'ambient-skill'));
+            // project-scope bundles are only enumerated via .awm/profile.json
+            // extensions below, never from the machine-level baseline/ambient pass.
+            expect(targets).not.toContain(path_1.default.join(skillsDir, 'project-skill'));
+        });
+    });
+    describe('project-level targets', () => {
+        function makeProjectRoot() {
+            const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-mutation-targets-project-'));
+            fs_1.default.mkdirSync(path_1.default.join(root, '.git')); // project-root marker for findProjectRoot
+            extraDirs.push(root);
+            return root;
+        }
+        it('includes profile.json, sensors.json, and extension bundle targets when a project root is found', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            const projectRoot = makeProjectRoot();
+            fs_1.default.mkdirSync(path_1.default.join(projectRoot, '.awm'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(projectRoot, '.awm', 'profile.json'), JSON.stringify({ extensions: ['frontend'] }));
+            const bundles = [bundle('frontend', 'project', ['frontend-skill'])];
+            const targets = planInitMutationTargets({ cwd: projectRoot, agent: 'claude-code', bundles });
+            expect(targets).toContain(path_1.default.join(projectRoot, '.awm', 'profile.json'));
+            expect(targets).toContain(path_1.default.join(projectRoot, '.awm', 'sensors.json'));
+            // frontend is a project-scope bundle -> installs locally under the project root
+            const localSkillsDir = path_1.default.join(projectRoot, providerFor('claude-code').skill.local);
+            expect(targets).toContain(path_1.default.join(localSkillsDir, 'frontend-skill'));
+        });
+        it('includes the project injection file for config-instructions agents (opencode)', () => {
+            const { planInitMutationTargets } = load();
+            const projectRoot = makeProjectRoot();
+            const targets = planInitMutationTargets({ cwd: projectRoot, agent: 'opencode', bundles: [] });
+            expect(targets).toContain(path_1.default.join(projectRoot, 'opencode.json'));
+        });
+        it('includes the project injection file (AGENTS.md) for managed-agents-md agents (codex)', () => {
+            const { planInitMutationTargets } = load();
+            const projectRoot = makeProjectRoot();
+            const targets = planInitMutationTargets({ cwd: projectRoot, agent: 'codex', bundles: [] });
+            expect(targets).toContain(path_1.default.join(projectRoot, 'AGENTS.md'));
+        });
+        it('omits every project-level target when no project root is found', () => {
+            const { planInitMutationTargets } = load();
+            const cwd = bareCwd(); // no .git/package.json/.awm ancestor
+            const targets = planInitMutationTargets({ cwd, agent: 'claude-code', bundles: [] });
+            expect(targets.some((t) => t.endsWith(path_1.default.join('.awm', 'profile.json')))).toBe(false);
+            expect(targets.some((t) => t.endsWith(path_1.default.join('.awm', 'sensors.json')))).toBe(false);
+        });
+        it('ignores an extension named in the profile that no longer resolves to a known bundle', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            const projectRoot = makeProjectRoot();
+            fs_1.default.mkdirSync(path_1.default.join(projectRoot, '.awm'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(projectRoot, '.awm', 'profile.json'), JSON.stringify({ extensions: ['stale-bundle'] }));
+            const targets = planInitMutationTargets({ cwd: projectRoot, agent: 'claude-code', bundles: [] });
+            const localSkillsDir = path_1.default.join(projectRoot, providerFor('claude-code').skill.local);
+            // No target should be produced under the local skills dir for a bundle
+            // that isn't in the (empty) known-bundles list passed in.
+            expect(targets.some((t) => t.startsWith(localSkillsDir))).toBe(false);
+        });
+    });
+    describe('Finding 1 fix — global skills directory itself', () => {
+        it('includes providerFor(agent).skill.global for every agent, independent of the bundle catalog', () => {
+            const { planInitMutationTargets, providerFor } = load();
+            for (const agent of ['claude-code', 'codex', 'opencode', 'antigravity']) {
+                const targets = planInitMutationTargets({ cwd: bareCwd(), agent, bundles: [] });
+                expect(targets).toContain(providerFor(agent).skill.global);
+            }
+        });
+        it('the skills-directory target covers orphaned entries repairGlobalSkills would mutate, not just bundle-derived subpaths', () => {
+            // Regression guard for the logic gap: before the fix, only
+            // bundle-DERIVED skill paths (e.g. .../skills/using-awm) were
+            // enumerated. An orphaned symlink like .../skills/some-old-skill
+            // (belonging to no currently-known bundle — the exact condition
+            // that makes repairGlobalSkills classify it as repairable/dead)
+            // would never appear in the bundle-driven enumeration. The parent
+            // directory itself must be present so beginBackupSession snapshots
+            // the whole tree.
+            const { planInitMutationTargets, providerFor } = load();
+            const bundles = [bundle('dev-core', 'baseline', ['using-awm'])];
+            const targets = planInitMutationTargets({ cwd: bareCwd(), agent: 'claude-code', bundles });
+            const skillsDir = providerFor('claude-code').skill.global;
+            expect(targets).toContain(skillsDir);
+            // Sanity: the orphan path itself is a child of the now-covered dir,
+            // even though it is never separately enumerated.
+            const orphanPath = path_1.default.join(skillsDir, 'some-old-orphaned-skill');
+            expect(orphanPath.startsWith(skillsDir)).toBe(true);
+        });
+    });
+});

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

@@ -74,7 +74,7 @@ describe('runInitSteps — orchestrator', () => {
         const contentDir = roots[0] ?? '';
         const ctx = gatherContext({ cwd, bundles });
         return {
-            cwd, ctx, bundles, agent: 'claude-code', installMethod: 'symlink',
+            cwd, ctx, bundles, agent: 'claude-code', enabledAgents: ['claude-code'], installMethod: 'symlink',
             registryRoot: contentRoot, contentDir, sensorPacksRoot: contentRoot,
             confirmExtensions: async (p) => p,
             // syncCache es no-op: el cache ya está sembrado en disco

package/dist/tests/core/init/provider-facts.test.js

@@ -0,0 +1,177 @@
+"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"));
+describe('gatherProviderFacts / assertClaudeBaselinePreserved', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-provider-facts-'));
+        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;
+    });
+    it('two snapshots of untouched state are identical (no false positive)', () => {
+        const { gatherProviderFacts, assertClaudeBaselinePreserved } = require('../../../src/core/init/provider-facts');
+        const before = gatherProviderFacts('claude-code');
+        const after = gatherProviderFacts('claude-code');
+        expect(() => assertClaudeBaselinePreserved(before, after)).not.toThrow();
+        expect(before.hash).toBe(after.hash);
+    });
+    it('detects a top-level file change under a managed directory', () => {
+        const { gatherProviderFacts, assertClaudeBaselinePreserved } = require('../../../src/core/init/provider-facts');
+        const skillsDir = path_1.default.join(tmpHome, '.claude', 'skills');
+        fs_1.default.mkdirSync(skillsDir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(skillsDir, 'SKILL.md'), 'original');
+        const before = gatherProviderFacts('claude-code');
+        fs_1.default.writeFileSync(path_1.default.join(skillsDir, 'SKILL.md'), 'mutated');
+        const after = gatherProviderFacts('claude-code');
+        expect(before.hash).not.toBe(after.hash);
+        expect(() => assertClaudeBaselinePreserved(before, after)).toThrow(/must never happen \(R19\)/);
+    });
+    it('detects a content-only change two levels deep under a managed directory', () => {
+        const { gatherProviderFacts, assertClaudeBaselinePreserved } = require('../../../src/core/init/provider-facts');
+        const skillsDir = path_1.default.join(tmpHome, '.claude', 'skills');
+        // .claude/skills/some-skill/nested/deep.md — two directory levels below skills/
+        const nested = path_1.default.join(skillsDir, 'some-skill', 'nested');
+        fs_1.default.mkdirSync(nested, { recursive: true });
+        const deepFile = path_1.default.join(nested, 'deep.md');
+        fs_1.default.writeFileSync(deepFile, 'original deep content');
+        const before = gatherProviderFacts('claude-code');
+        // Content-only mutation — no rename, no size-preserving trick needed;
+        // this alone would have been invisible to a top-level-only stat digest.
+        fs_1.default.writeFileSync(deepFile, 'mutated deep content');
+        const after = gatherProviderFacts('claude-code');
+        expect(before.hash).not.toBe(after.hash);
+        expect(() => assertClaudeBaselinePreserved(before, after)).toThrow(/must never happen \(R19\)/);
+    });
+    it('detects an added file three levels deep without touching any existing file', () => {
+        const { gatherProviderFacts } = require('../../../src/core/init/provider-facts');
+        const skillsDir = path_1.default.join(tmpHome, '.claude', 'skills');
+        const nested = path_1.default.join(skillsDir, 'pkg', 'a', 'b');
+        fs_1.default.mkdirSync(nested, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(nested, 'existing.md'), 'unchanged');
+        const before = gatherProviderFacts('claude-code');
+        fs_1.default.writeFileSync(path_1.default.join(nested, 'new-file.md'), 'new');
+        const after = gatherProviderFacts('claude-code');
+        expect(before.hash).not.toBe(after.hash);
+    });
+    it('throws a distinct message when comparing facts for mismatched agents', () => {
+        const { gatherProviderFacts, assertClaudeBaselinePreserved } = require('../../../src/core/init/provider-facts');
+        const claude = gatherProviderFacts('claude-code');
+        const codex = gatherProviderFacts('codex');
+        expect(() => assertClaudeBaselinePreserved(claude, codex)).toThrow('mismatched agents');
+    });
+    // -----------------------------------------------------------------------
+    // Nested-scriptsDir exclusion (Task 9 fix) — Codex's hook scriptsDir
+    // (~/.awm/hooks/codex) is physically nested inside Claude's own hook
+    // scriptsDir (~/.awm/hooks — providers/index.ts). A naive recursive hash
+    // of Claude's scriptsDir would pick up every Codex hook write as a
+    // "Claude baseline changed" false positive. These two tests pin that
+    // exclusion directly, rather than relying only on the E2E's indirect
+    // before/after tree-snapshot check.
+    // -----------------------------------------------------------------------
+    it('does NOT flag a write inside Codex\'s nested scriptsDir as a Claude baseline change', () => {
+        const { gatherProviderFacts, assertClaudeBaselinePreserved } = require('../../../src/core/init/provider-facts');
+        // Seed Claude's own scriptsDir first (mirrors a real prior Claude hook install).
+        const claudeScripts = path_1.default.join(tmpHome, '.awm', 'hooks');
+        fs_1.default.mkdirSync(claudeScripts, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(claudeScripts, 'session-start'), '#!/bin/sh\n');
+        fs_1.default.writeFileSync(path_1.default.join(claudeScripts, 'run-hook.cmd'), '#!/bin/sh\n');
+        const before = gatherProviderFacts('claude-code');
+        // Codex's own scriptsDir is nested one level inside Claude's — simulate a
+        // real Codex hook install writing there for the first time.
+        const codexScripts = path_1.default.join(tmpHome, '.awm', 'hooks', 'codex');
+        fs_1.default.mkdirSync(codexScripts, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(codexScripts, 'session-start'), '#!/bin/sh\necho codex\n');
+        const afterAdd = gatherProviderFacts('claude-code');
+        expect(afterAdd.hash).toBe(before.hash);
+        expect(() => assertClaudeBaselinePreserved(before, afterAdd)).not.toThrow();
+        // Modifying the Codex-owned nested file's content must also stay invisible.
+        fs_1.default.writeFileSync(path_1.default.join(codexScripts, 'session-start'), '#!/bin/sh\necho codex v2\n');
+        const afterModify = gatherProviderFacts('claude-code');
+        expect(afterModify.hash).toBe(before.hash);
+        expect(() => assertClaudeBaselinePreserved(before, afterModify)).not.toThrow();
+    });
+    // -----------------------------------------------------------------------
+    // Codex-only bootstrap: Claude's scriptsDir has NEVER existed.
+    //
+    // Every nested-exclusion test above seeds ~/.awm/hooks first, so they only
+    // ever exercise the present→present transition. On a fresh Codex-only
+    // machine (a cloud box, the actual rollout target) that directory does not
+    // exist, and installing the Codex hook creates it as a side effect of
+    // `mkdirSync(dirname, {recursive:true})` in syncExecutable — flipping
+    // Claude's own scriptsDir from absent to present-but-empty. That is not a
+    // change to anything Claude owns, but it moved the hash and aborted init.
+    // -----------------------------------------------------------------------
+    it('does NOT flag Codex creating its nested scriptsDir when Claude\'s has never existed', () => {
+        const { gatherProviderFacts, assertClaudeBaselinePreserved } = require('../../../src/core/init/provider-facts');
+        const claudeScripts = path_1.default.join(tmpHome, '.awm', 'hooks');
+        expect(fs_1.default.existsSync(claudeScripts)).toBe(false);
+        const before = gatherProviderFacts('claude-code');
+        // Exactly what syncExecutable does for the Codex hook: one recursive
+        // mkdir that necessarily materializes Claude's hooks/ as the parent.
+        const codexScripts = path_1.default.join(claudeScripts, 'codex');
+        fs_1.default.mkdirSync(codexScripts, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(codexScripts, 'session-start'), '#!/bin/sh\necho codex\n');
+        const after = gatherProviderFacts('claude-code');
+        expect(after.hash).toBe(before.hash);
+        expect(() => assertClaudeBaselinePreserved(before, after)).not.toThrow();
+    });
+    it('still flags real Claude content appearing where the directory did not exist', () => {
+        const { gatherProviderFacts, assertClaudeBaselinePreserved } = require('../../../src/core/init/provider-facts');
+        const before = gatherProviderFacts('claude-code');
+        // The guard must not be relaxed into blindness: an absent directory
+        // gaining Claude-owned content is still a genuine baseline change.
+        const claudeScripts = path_1.default.join(tmpHome, '.awm', 'hooks');
+        fs_1.default.mkdirSync(claudeScripts, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(claudeScripts, 'session-start'), '#!/bin/sh\n');
+        const after = gatherProviderFacts('claude-code');
+        expect(after.hash).not.toBe(before.hash);
+        expect(() => assertClaudeBaselinePreserved(before, after)).toThrow(/must never happen \(R19\)/);
+    });
+    it('still flags Claude content being emptied out of an existing directory', () => {
+        const { gatherProviderFacts, assertClaudeBaselinePreserved } = require('../../../src/core/init/provider-facts');
+        const claudeScripts = path_1.default.join(tmpHome, '.awm', 'hooks');
+        fs_1.default.mkdirSync(claudeScripts, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(claudeScripts, 'session-start'), '#!/bin/sh\n');
+        const before = gatherProviderFacts('claude-code');
+        fs_1.default.rmSync(path_1.default.join(claudeScripts, 'session-start'));
+        const after = gatherProviderFacts('claude-code');
+        expect(after.hash).not.toBe(before.hash);
+        expect(() => assertClaudeBaselinePreserved(before, after)).toThrow(/must never happen \(R19\)/);
+    });
+    it('still flags a genuinely Claude-owned change alongside an untouched Codex nested dir', () => {
+        const { gatherProviderFacts, assertClaudeBaselinePreserved } = require('../../../src/core/init/provider-facts');
+        const claudeScripts = path_1.default.join(tmpHome, '.awm', 'hooks');
+        const codexScripts = path_1.default.join(claudeScripts, 'codex');
+        fs_1.default.mkdirSync(codexScripts, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(claudeScripts, 'session-start'), '#!/bin/sh\n');
+        fs_1.default.writeFileSync(path_1.default.join(codexScripts, 'session-start'), '#!/bin/sh\necho codex\n');
+        const before = gatherProviderFacts('claude-code');
+        // A genuinely Claude-owned file (a sibling of the codex/ subdir, not inside it)
+        // changes — the exclusion must not swallow this.
+        fs_1.default.writeFileSync(path_1.default.join(claudeScripts, 'session-start'), '#!/bin/sh\necho mutated claude script\n');
+        const after = gatherProviderFacts('claude-code');
+        expect(after.hash).not.toBe(before.hash);
+        expect(() => assertClaudeBaselinePreserved(before, after)).toThrow(/must never happen \(R19\)/);
+    });
+});

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

@@ -55,7 +55,7 @@ function spies() {
 function deps(ctx, actions, over = {}) {
     return {
         cwd: '/repo', ctx, bundles: [bundle('dev', 'baseline', ['brainstorming'])],
-        agent: 'claude-code', installMethod: 'symlink',
+        agent: 'claude-code', enabledAgents: ['claude-code'], installMethod: 'symlink',
         registryRoot: '/cache', contentDir: '/cache/registry', sensorPacksRoot: '/cache/registry',
         confirmExtensions: async (p) => p, actions, ...over,
     };
@@ -111,6 +111,22 @@ describe('stepHook / stepDevCore / stepAmbient', () => {
         expect((0, steps_1.stepHook)(deps({ machine: m, project: null }, a)).action).toBe('applied');
         expect(a.installHook).toHaveBeenCalled();
     });
+    // Regression: a real (unstubbed) `awm init --agent opencode` used to throw
+    // "hooks not supported for agent target: opencode" from installHook,
+    // because stepHook never checked whether the target agent has a hook
+    // mechanism at all before calling installHook (providers/index.ts:
+    // OpenCode/Antigravity have no `hooks` config). Found while building the
+    // real Codex+OpenCode coexistence E2E test — mirrors provider-checks.ts's
+    // `hookTrustCheck`, which already treats a missing `hooks` config as "not
+    // applicable" rather than a failure.
+    it('hook skips (not calls installHook) for an agent with no hook mechanism', () => {
+        const a = spies();
+        const m = machine();
+        m.hook = { present: false };
+        const r = (0, steps_1.stepHook)(deps({ machine: m, project: null }, a, { agent: 'opencode', enabledAgents: ['opencode'] }));
+        expect(r.action).toBe('skipped');
+        expect(a.installHook).not.toHaveBeenCalled();
+    });
     it('devCore installs baseline when links broken', () => {
         const a = spies();
         const m = machine();
@@ -137,6 +153,56 @@ describe('stepHook / stepDevCore / stepAmbient', () => {
         const a = spies();
         expect((0, steps_1.stepAmbient)(deps({ machine: machine(), project: null }, a)).action).toBe('skipped');
     });
+    // Regression coverage for the BLOCKER found in post-implementation QA:
+    // stepDevCore/stepAmbient used to pass a `[d.agent]` singleton as
+    // `agents`, which install-planner.ts's `assertCompleteSharedGroup` (R14)
+    // refuses whenever a co-owner sharing the same physical skill directory
+    // (OpenCode and Codex both resolve to ~/.agents/skills) is independently
+    // enabled — making `awm init --agent codex` structurally fail once
+    // OpenCode was already enabled, and vice versa.
+    it('devCore includes a co-enabled agent sharing the same skill target (codex + opencode)', () => {
+        const a = spies();
+        const m = machine();
+        m.devCore = { present: false, brokenLinks: [] };
+        const r = (0, steps_1.stepDevCore)(deps({ machine: m, project: null }, a, {
+            agent: 'codex', enabledAgents: ['claude-code', 'opencode', 'codex'],
+        }));
+        expect(r.action).toBe('applied');
+        expect(a.installBundle).toHaveBeenCalledWith(expect.objectContaining({ agents: expect.arrayContaining(['codex', 'opencode']) }));
+        const call = a.installBundle.mock.calls[0][0];
+        expect(call.agents).toHaveLength(2); // claude-code is NOT included — it doesn't share the skill target
+    });
+    it('devCore does not add a co-owner that is not currently enabled', () => {
+        const a = spies();
+        const m = machine();
+        m.devCore = { present: false, brokenLinks: [] };
+        const r = (0, steps_1.stepDevCore)(deps({ machine: m, project: null }, a, {
+            agent: 'codex', enabledAgents: ['claude-code', 'codex'],
+        }));
+        expect(r.action).toBe('applied');
+        expect(a.installBundle).toHaveBeenCalledWith(expect.objectContaining({ agents: ['codex'] }));
+    });
+    it('devCore never adds a co-owner for claude-code (its skill dir is never shared)', () => {
+        const a = spies();
+        const m = machine();
+        m.devCore = { present: false, brokenLinks: [] };
+        const r = (0, steps_1.stepDevCore)(deps({ machine: m, project: null }, a, {
+            agent: 'claude-code', enabledAgents: ['claude-code', 'opencode', 'codex'],
+        }));
+        expect(r.action).toBe('applied');
+        expect(a.installBundle).toHaveBeenCalledWith(expect.objectContaining({ agents: ['claude-code'] }));
+    });
+    it('ambient includes a co-enabled agent sharing the same skill target (codex + opencode)', () => {
+        const a = spies();
+        const m = machine();
+        m.ambient = { wanted: ['docs'], installed: [] };
+        const r = (0, steps_1.stepAmbient)(deps({ machine: m, project: null }, a, {
+            agent: 'opencode', enabledAgents: ['claude-code', 'opencode', 'codex'],
+        }));
+        expect(r.action).toBe('applied');
+        const call = a.installBundle.mock.calls[0][0];
+        expect(call.agents.sort()).toEqual(['codex', 'opencode']);
+    });
 });
 describe('stepProfile', () => {
     it('adds confirmed extension when detector finds a match', async () => {
@@ -237,6 +303,31 @@ describe('stepActivation', () => {
         (0, steps_1.stepActivation)(deps(ctx, a, { agent: 'opencode' }));
         expect(a.gatherProject).toHaveBeenCalledWith(expect.any(String), expect.any(Array), 'opencode');
     });
+    // Same class of bug as stepDevCore/stepAmbient's shared-group regression
+    // above, in the LOCAL-scope (project) code path: OpenCode and Codex share
+    // both their global AND local skill directories, so a project extension
+    // with a skill artifact hits the identical R14 refusal whenever
+    // syncProfile is called with a `[d.agent]` singleton and a co-owner is
+    // independently enabled.
+    it('activation includes a co-enabled agent sharing the same LOCAL skill target (codex + opencode)', () => {
+        const a = spies();
+        a.gatherProject = jest.fn((_cwd, _bundles) => project({ activeBundles: { expected: ['x'], linked: [], broken: [] } }));
+        const r = (0, steps_1.stepActivation)(deps({ machine: machine(), project: project() }, a, {
+            agent: 'codex', enabledAgents: ['claude-code', 'opencode', 'codex'],
+        }));
+        expect(r.action).toBe('applied');
+        const call = a.syncProfile.mock.calls[0][0];
+        expect(call.agents.sort()).toEqual(['codex', 'opencode']);
+    });
+    it('activation does not add a co-owner that is not currently enabled', () => {
+        const a = spies();
+        a.gatherProject = jest.fn((_cwd, _bundles) => project({ activeBundles: { expected: ['x'], linked: [], broken: [] } }));
+        const r = (0, steps_1.stepActivation)(deps({ machine: machine(), project: project() }, a, {
+            agent: 'codex', enabledAgents: ['claude-code', 'codex'],
+        }));
+        expect(r.action).toBe('applied');
+        expect(a.syncProfile).toHaveBeenCalledWith(expect.objectContaining({ agents: ['codex'] }));
+    });
 });
 describe('stepSensors', () => {
     it('skips when sensors present', () => {
@@ -296,7 +387,7 @@ describe('stepGlobalSkillsRepair', () => {
         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));
+        expect(a.repairGlobalSkills).toHaveBeenCalledWith((0, providers_1.providerFor)('opencode').skill.global, expect.any(Array));
     });
 });
 describe('stepConstitutionInjection (#6)', () => {
@@ -318,6 +409,12 @@ describe('stepConstitutionInjection (#6)', () => {
         expect(r.action).toBe('skipped');
         expect(a.injectProjectConstitution).not.toHaveBeenCalled();
     });
+    it('installs Codex project guidance before CONSTITUTION.md exists', () => {
+        const a = spies();
+        const r = (0, steps_1.stepConstitutionInjection)(deps({ machine: machine(), project: project({ constitution: { present: false } }) }, a, { agent: 'codex' }));
+        expect(r.action).toBe('applied');
+        expect(a.injectProjectConstitution).toHaveBeenCalledWith({ projectRoot: '/repo', agent: 'codex' });
+    });
     it('maps already → skipped when CONSTITUTION.md was already in opencode.json', () => {
         const a = spies();
         a.injectProjectConstitution.mockReturnValue('already');
@@ -360,4 +457,11 @@ describe('stepContextInjection', () => {
         expect(r.action).toBe('applied');
         expect(a.installContext).toHaveBeenCalled();
     });
+    it('installs the Codex global managed block when absent', () => {
+        const a = spies();
+        a.contextStatus.mockReturnValue('absent');
+        const r = (0, steps_1.stepContextInjection)(deps({ machine: machine(), project: null }, a, { agent: 'codex' }));
+        expect(r.action).toBe('applied');
+        expect(a.installContext).toHaveBeenCalledWith(expect.objectContaining({ agent: 'codex', scope: 'global' }));
+    });
 });