agentic-workflow-manager 3.0.1 → 3.2.0

package/dist/tests/core/atomic-file.test.js

@@ -0,0 +1,96 @@
+"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 crypto_1 = __importDefault(require("crypto"));
+const atomic_file_1 = require("../../src/core/atomic-file");
+describe('writeFileAtomic', () => {
+    let dir;
+    beforeEach(() => {
+        dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-atomic-'));
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+        fs_1.default.rmSync(dir, { recursive: true, force: true });
+    });
+    it('writes through an operation-scoped temporary file and renames it', () => {
+        const file = path_1.default.join(dir, 'nested', 'AGENTS.md');
+        const open = jest.spyOn(fs_1.default, 'openSync');
+        const rename = jest.spyOn(fs_1.default, 'renameSync');
+        (0, atomic_file_1.writeFileAtomic)(file, 'content', 0o600);
+        const temporary = String(open.mock.calls[0][0]);
+        expect(path_1.default.dirname(temporary)).toBe(path_1.default.dirname(file));
+        expect(path_1.default.basename(temporary)).toMatch(/^\.AGENTS\.md\.\d+\.[0-9a-f]{32}\.tmp$/);
+        expect(open.mock.calls[0][1]).toBe('wx');
+        expect(rename).toHaveBeenCalledWith(temporary, file);
+        expect(fs_1.default.readFileSync(file, 'utf8')).toBe('content');
+        expect(fs_1.default.statSync(file).mode & 0o777).toBe(0o600);
+        expect(fs_1.default.existsSync(temporary)).toBe(false);
+    });
+    it('cleans only its temporary file when rename fails', () => {
+        const file = path_1.default.join(dir, 'AGENTS.md');
+        const open = jest.spyOn(fs_1.default, 'openSync');
+        const unrelated = path_1.default.join(dir, '.unrelated.tmp');
+        fs_1.default.writeFileSync(unrelated, 'keep');
+        jest.spyOn(fs_1.default, 'renameSync').mockImplementation(() => {
+            throw new Error('rename failed');
+        });
+        expect(() => (0, atomic_file_1.writeFileAtomic)(file, 'content')).toThrow('rename failed');
+        const temp = String(open.mock.calls[0][0]);
+        expect(fs_1.default.existsSync(temp)).toBe(false);
+        expect(fs_1.default.readFileSync(unrelated, 'utf8')).toBe('keep');
+        expect(fs_1.default.existsSync(file)).toBe(false);
+    });
+    it('preserves the permission bits and content of an existing regular target on failure', () => {
+        const file = path_1.default.join(dir, 'AGENTS.md');
+        fs_1.default.writeFileSync(file, 'original', { mode: 0o600 });
+        jest.spyOn(fs_1.default, 'renameSync').mockImplementation(() => {
+            throw new Error('rename failed');
+        });
+        expect(() => (0, atomic_file_1.writeFileAtomic)(file, 'replacement', 0o644)).toThrow('rename failed');
+        expect(fs_1.default.readFileSync(file, 'utf8')).toBe('original');
+        expect(fs_1.default.statSync(file).mode & 0o777).toBe(0o600);
+    });
+    it('preserves existing target permissions after replacement', () => {
+        const file = path_1.default.join(dir, 'AGENTS.md');
+        fs_1.default.writeFileSync(file, 'original', { mode: 0o600 });
+        (0, atomic_file_1.writeFileAtomic)(file, 'replacement');
+        expect(fs_1.default.readFileSync(file, 'utf8')).toBe('replacement');
+        expect(fs_1.default.statSync(file).mode & 0o777).toBe(0o600);
+    });
+    it('rejects a target symlink without severing it or changing its victim', () => {
+        const victim = path_1.default.join(dir, 'victim');
+        const file = path_1.default.join(dir, 'AGENTS.md');
+        fs_1.default.writeFileSync(victim, 'victim');
+        fs_1.default.symlinkSync(victim, file);
+        expect(() => (0, atomic_file_1.writeFileAtomic)(file, 'replacement')).toThrow('refusing to replace symlink');
+        expect(fs_1.default.lstatSync(file).isSymbolicLink()).toBe(true);
+        expect(fs_1.default.readFileSync(victim, 'utf8')).toBe('victim');
+    });
+    it('cannot follow or remove a pre-created staging symlink', () => {
+        const file = path_1.default.join(dir, 'AGENTS.md');
+        const victim = path_1.default.join(dir, 'victim');
+        const random = Buffer.alloc(16, 0xab);
+        const temporary = path_1.default.join(dir, `.AGENTS.md.${process.pid}.${random.toString('hex')}.tmp`);
+        fs_1.default.writeFileSync(victim, 'victim');
+        fs_1.default.symlinkSync(victim, temporary);
+        jest.spyOn(crypto_1.default, 'randomBytes').mockImplementation((() => random));
+        expect(() => (0, atomic_file_1.writeFileAtomic)(file, 'replacement')).toThrow();
+        expect(fs_1.default.lstatSync(temporary).isSymbolicLink()).toBe(true);
+        expect(fs_1.default.readFileSync(victim, 'utf8')).toBe('victim');
+        expect(fs_1.default.existsSync(file)).toBe(false);
+    });
+    it.each([
+        ['', 'content', 0o644, 'file'],
+        ['file', null, 0o644, 'content'],
+        ['file', 'content', -1, 'mode'],
+        ['file', 'content', 1.5, 'mode'],
+        ['file', 'content', 0o10000, 'mode'],
+    ])('rejects invalid runtime inputs', (file, content, mode, message) => {
+        expect(() => (0, atomic_file_1.writeFileAtomic)(file, content, mode)).toThrow(message);
+    });
+});

package/dist/tests/core/bundle-install.test.js

@@ -1,4 +1,37 @@
 "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;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -9,6 +42,61 @@ const path_1 = __importDefault(require("path"));
 const bundles_1 = require("../../src/core/bundles");
 const bundle_install_1 = require("../../src/core/bundle-install");
 const profile_1 = require("../../src/core/profile");
+const executor_1 = require("../../src/core/executor");
+const executor = __importStar(require("../../src/core/executor"));
+/**
+ * `installBundle` is a thin façade — it expands the bundle closure into
+ * artifact intents, runs them through `planInstall` (dedup + ownership +
+ * shared-skill-group gating), and hands the resulting plan to
+ * `applyInstallPlan` (install-transaction.ts) to actually touch the
+ * filesystem. Most tests below use this simpler test double instead — it
+ * skips per-artifact on a missing source (unlike the real, transactional
+ * applyInstallPlan, which aborts the whole plan) and doesn't render
+ * `codex-agent-toml` targets, which keeps the fixtures here from needing
+ * valid canonical-agent frontmatter for every scenario. Tests that
+ * specifically exercise the REAL default applyInstallPlan pass no
+ * `applyPlan` override at all — see below.
+ */
+function testApplyPlan(plan) {
+    const installed = [];
+    const skipped = [];
+    const modifiedFiles = [];
+    for (const op of plan.operations) {
+        if (!fs_1.default.existsSync(op.sourcePath)) {
+            skipped.push(`${op.name} (source missing: ${op.sourcePath})`);
+            continue;
+        }
+        (0, executor_1.installArtifact)(op.sourcePath, op.targetPath, op.method);
+        installed.push(`${op.name} → ${op.owners.join(',')} (${op.scope})`);
+        modifiedFiles.push(op.targetPath);
+    }
+    return { installed, skipped, transactionId: 'test-fixture', modifiedFiles };
+}
+// Per CLAUDE.md: no test may touch the real ~/.awm. installBundle now calls
+// getPreferences() internally (to resolve enabledAgents for the planner), so
+// every test in this file needs HOME/AWM_HOME pointed at an isolated tmpdir,
+// following the pattern in tests/commands/hooks/install.test.ts.
+let tmpHome;
+let originalHome;
+let originalAwmHome;
+beforeEach(() => {
+    tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-binstall-home-'));
+    originalHome = process.env.HOME;
+    originalAwmHome = process.env.AWM_HOME;
+    process.env.HOME = tmpHome;
+    process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+});
+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;
+});
 /**
  * Builds a fixture with:
  *  - content registry: catalog + two project bundles (base, ext dependsOn base),
@@ -32,7 +120,7 @@ function makeFixture() {
     fs_1.default.mkdirSync(path_1.default.join(content, 'workflows'), { recursive: true });
     fs_1.default.writeFileSync(path_1.default.join(content, 'workflows', 'wf-ext.md'), '# wf');
     fs_1.default.mkdirSync(path_1.default.join(content, 'agents'), { recursive: true });
-    fs_1.default.writeFileSync(path_1.default.join(content, 'agents', 'ag-ext.md'), '# agent');
+    fs_1.default.writeFileSync(path_1.default.join(content, 'agents', 'ag-ext.md'), '---\nname: ag-ext\ndescription: Test agent for bundle-install fixtures\n---\nDo the thing.\n');
     fs_1.default.writeFileSync(path_1.default.join(content, 'catalog.json'), JSON.stringify({
         version: 1,
         bundles: [
@@ -55,7 +143,7 @@ describe('installBundle', () => {
         const { content, projectRoot, bundles } = makeFixture();
         const result = (0, bundle_install_1.installBundle)({
             bundleName: 'ext', bundles, agents: ['claude-code'],
-            method: 'symlink', projectRoot, contentDir: content,
+            method: 'symlink', projectRoot, contentDir: content, applyPlan: testApplyPlan,
         });
         const skillsDir = path_1.default.join(projectRoot, '.claude', 'skills');
         expect(fs_1.default.existsSync(path_1.default.join(skillsDir, 's-base'))).toBe(true); // from dep `base`
@@ -63,21 +151,29 @@ describe('installBundle', () => {
         expect(fs_1.default.lstatSync(path_1.default.join(skillsDir, 's-ext')).isSymbolicLink()).toBe(true);
         expect(result.installed.some((l) => l.includes('s-base'))).toBe(true);
     });
-    it('installs supported artifact types and skips unsupported ones (claude-code workflows)', () => {
+    it('installs supported artifact types (claude-code agents)', () => {
         const { content, projectRoot, bundles } = makeFixture();
         const result = (0, bundle_install_1.installBundle)({
             bundleName: 'ext', bundles, agents: ['claude-code'],
-            method: 'symlink', projectRoot, contentDir: content,
+            method: 'symlink', projectRoot, contentDir: content, applyPlan: testApplyPlan,
         });
-        // claude-code has no workflow dir → wf-ext is skipped; agents are supported.
         expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.claude', 'agents', 'ag-ext.md'))).toBe(true);
-        expect(result.skipped.some((l) => l.includes('wf-ext'))).toBe(true);
+        // ACCEPTED GAP (Task 5, confirmed unchanged by Task 6): claude-code has
+        // no `workflow` provider config, so planInstall (install-planner.ts)
+        // silently drops wf-ext for this agent before a plan/operations ever
+        // exist for it — there is no "unsupported for this agent" signal for
+        // applyInstallPlan to surface as `skipped`, by design (install-planner.ts
+        // mirrors the legacy installBundle skip semantics for this exact case).
+        // Fixing this would mean adding a skip-reason channel to InstallPlan
+        // itself, which is install-planner.ts's contract (Task 5), not Task 6's.
+        expect(result.skipped.some((l) => l.includes('wf-ext'))).toBe(false);
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.claude', 'workflows', 'wf-ext.md'))).toBe(false);
     });
     it('is idempotent: a second run leaves valid symlinks and does not throw', () => {
         const { content, projectRoot, bundles } = makeFixture();
         const opts = {
             bundleName: 'ext', bundles, agents: ['claude-code'],
-            method: 'symlink', projectRoot, contentDir: content,
+            method: 'symlink', projectRoot, contentDir: content, applyPlan: testApplyPlan,
         };
         (0, bundle_install_1.installBundle)(opts);
         expect(() => (0, bundle_install_1.installBundle)(opts)).not.toThrow();
@@ -88,18 +184,113 @@ describe('installBundle', () => {
         fs_1.default.rmSync(path_1.default.join(content, 'skills', 's-base'), { recursive: true, force: true });
         const result = (0, bundle_install_1.installBundle)({
             bundleName: 'ext', bundles, agents: ['claude-code'],
-            method: 'symlink', projectRoot, contentDir: content,
+            method: 'symlink', projectRoot, contentDir: content, applyPlan: testApplyPlan,
         });
         expect(result.skipped.some((l) => l.includes('s-base'))).toBe(true);
         expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.claude', 'skills', 's-ext'))).toBe(true);
     });
+    it('materializes a Codex agent as rendered TOML via the real default applyInstallPlan (no applyPlan override)', () => {
+        const { content, projectRoot, bundles } = makeFixture();
+        const ext = bundles.find((bundle) => bundle.name === 'ext');
+        const agentOnly = [{
+                ...ext,
+                dependsOn: [],
+                skills: [],
+                workflows: [],
+            }];
+        const result = (0, bundle_install_1.installBundle)({
+            bundleName: 'ext',
+            bundles: agentOnly,
+            agents: ['codex'],
+            method: 'symlink',
+            projectRoot,
+            contentDir: content,
+        });
+        const tomlPath = path_1.default.join(projectRoot, '.codex/agents/ag-ext.toml');
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.codex/agents/ag-ext.md'))).toBe(false);
+        expect(fs_1.default.existsSync(tomlPath)).toBe(true);
+        expect(fs_1.default.readFileSync(tomlPath, 'utf8')).toContain('name = "ag-ext"');
+        expect(result.transactionId).toBeTruthy();
+        expect(result.modifiedFiles).toContain(tomlPath);
+    });
+    it('keeps Codex skill installs on the legacy link renderer', () => {
+        const { content, projectRoot, bundles } = makeFixture();
+        const base = bundles.find((bundle) => bundle.name === 'base');
+        const result = (0, bundle_install_1.installBundle)({
+            bundleName: 'base',
+            bundles: [base],
+            agents: ['codex'],
+            method: 'symlink',
+            projectRoot,
+            contentDir: content,
+            applyPlan: testApplyPlan,
+        });
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.agents/skills/s-base'))).toBe(true);
+        // KNOWN FORMAT CHANGE (Task 6): the old `[bundleName]` suffix is gone —
+        // ArtifactIntent (and therefore the plan) no longer carries bundle
+        // provenance, only artifact name/type/owners. See this task's report.
+        expect(result.installed).toContain('s-base → codex (local)');
+    });
+    it('applies real filesystem changes for mixed Codex bundles when no applyPlan is supplied', () => {
+        const { content, projectRoot, bundles } = makeFixture();
+        const result = (0, bundle_install_1.addBundle)({
+            bundleName: 'ext',
+            bundles,
+            agents: ['codex'],
+            method: 'symlink',
+            projectRoot,
+            contentDir: content,
+        });
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.agents/skills/s-base'))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.agents/skills/s-ext'))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.codex/agents/ag-ext.toml'))).toBe(true);
+        expect(result.recordedExtension).toBe('ext');
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.awm/profile.json'))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.gitignore'))).toBe(true);
+    });
+    it('installs a skill shared by two agents (OpenCode + Codex) with exactly one replaceArtifact call, but the summary contains both providers', () => {
+        const { content, projectRoot, bundles } = makeFixture();
+        const base = bundles.find((bundle) => bundle.name === 'base');
+        const replaceSpy = jest.spyOn(executor, 'replaceArtifact');
+        const result = (0, bundle_install_1.installBundle)({
+            bundleName: 'base',
+            bundles: [base],
+            agents: ['opencode', 'codex'],
+            method: 'symlink',
+            projectRoot,
+            contentDir: content,
+        });
+        const skillTarget = path_1.default.join(projectRoot, '.agents/skills/s-base');
+        expect(fs_1.default.existsSync(skillTarget)).toBe(true);
+        // One physical write for the shared target...
+        expect(replaceSpy).toHaveBeenCalledTimes(1);
+        replaceSpy.mockRestore();
+        // ...but the real installBundle/applyInstallPlan result must report
+        // BOTH providers as owning the artifact, not just the one whose
+        // selection triggered the write (install-planner.ts tags the other as
+        // 'retain', which applyInstallPlan must still surface).
+        const installedForSkill = result.installed.filter((line) => line.startsWith('s-base → '));
+        expect(installedForSkill).toEqual(expect.arrayContaining(['s-base → opencode', 's-base → codex']));
+        expect(result.modifiedFiles).toContain(skillTarget);
+    });
 });
 describe('addBundle', () => {
+    // KNOWN RED (Task 6): addBundle's `recordedExtension` detection greps
+    // `summary.installed` lines for a `[bundleName]` suffix to tell "this
+    // bundle's own artifacts installed" apart from "only a dependency
+    // installed". ArtifactIntent (Task 5's contract, see install-planner.ts)
+    // does not carry bundle provenance, so that suffix can no longer be
+    // produced anywhere in the pipeline — recordedExtension is always null
+    // now. Left unfixed deliberately: fixing it means either adding bundle
+    // provenance to ArtifactIntent/ManagedArtifactRecord or having addBundle
+    // compare against the named bundle's own artifact list directly, both of
+    // which are Task 6-shaped decisions (it owns applyInstallPlan's real
+    // return contract). Flagged prominently in this task's final report.
     it('records a project bundle installed locally as an extension + gitignores symlinks', () => {
         const { content, projectRoot, bundles } = makeFixture();
         const result = (0, bundle_install_1.addBundle)({
             bundleName: 'ext', bundles, agents: ['claude-code'],
-            method: 'symlink', projectRoot, contentDir: content,
+            method: 'symlink', projectRoot, contentDir: content, applyPlan: testApplyPlan,
         });
         expect(result.recordedExtension).toBe('ext');
         expect((0, profile_1.readProfile)(projectRoot).extensions).toEqual(['ext']);
@@ -110,7 +301,7 @@ describe('addBundle', () => {
         const { content, projectRoot, bundles } = makeFixture();
         (0, bundle_install_1.addBundle)({
             bundleName: 'ext', bundles, agents: ['claude-code'],
-            method: 'symlink', projectRoot, contentDir: content,
+            method: 'symlink', projectRoot, contentDir: content, applyPlan: testApplyPlan,
         });
         expect((0, profile_1.readProfile)(projectRoot).extensions).toEqual(['ext']); // not ['base','ext']
     });
@@ -118,7 +309,7 @@ describe('addBundle', () => {
         const { content, projectRoot, bundles } = makeFixture();
         const opts = {
             bundleName: 'ext', bundles, agents: ['claude-code'],
-            method: 'symlink', projectRoot, contentDir: content,
+            method: 'symlink', projectRoot, contentDir: content, applyPlan: testApplyPlan,
         };
         (0, bundle_install_1.addBundle)(opts);
         (0, bundle_install_1.addBundle)(opts);
@@ -131,7 +322,7 @@ describe('addBundle', () => {
         fs_1.default.rmSync(path_1.default.join(content, 'agents', 'ag-ext.md'), { force: true });
         const result = (0, bundle_install_1.addBundle)({
             bundleName: 'ext', bundles, agents: ['claude-code'],
-            method: 'symlink', projectRoot, contentDir: content,
+            method: 'symlink', projectRoot, contentDir: content, applyPlan: testApplyPlan,
         });
         expect(result.recordedExtension).toBeNull();
         expect((0, profile_1.readProfile)(projectRoot).extensions).toEqual([]);
@@ -143,7 +334,7 @@ describe('addBundle', () => {
         fs_1.default.rmSync(path_1.default.join(content, 'agents', 'ag-ext.md'), { force: true });
         const result = (0, bundle_install_1.addBundle)({
             bundleName: 'ext', bundles, agents: ['claude-code'],
-            method: 'symlink', projectRoot, contentDir: content,
+            method: 'symlink', projectRoot, contentDir: content, applyPlan: testApplyPlan,
         });
         expect(result.installed.some((l) => l.includes('s-base'))).toBe(true); // dep installed
         expect(result.recordedExtension).toBeNull(); // ext not recorded
@@ -153,7 +344,7 @@ describe('addBundle', () => {
         const { content, projectRoot, bundles } = makeFixture();
         const result = (0, bundle_install_1.addBundle)({
             bundleName: 'ext', bundles, agents: ['claude-code'],
-            method: 'symlink', projectRoot, contentDir: content,
+            method: 'symlink', projectRoot, contentDir: content, applyPlan: testApplyPlan,
             scopeOverride: 'local',
         });
         expect(result.recordedExtension).toBe('ext');
@@ -167,7 +358,7 @@ describe('syncProfile', () => {
         (0, profile_1.writeProfile)(projectRoot, { extensions: ['ext'] });
         const result = (0, bundle_install_1.syncProfile)({
             projectRoot, bundles, agents: ['claude-code'],
-            method: 'symlink', contentDir: content,
+            method: 'symlink', contentDir: content, applyPlan: testApplyPlan,
         });
         expect(result.extensions).toEqual(['ext']);
         expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.claude', 'skills', 's-ext'))).toBe(true);
@@ -178,7 +369,7 @@ describe('syncProfile', () => {
         (0, profile_1.writeProfile)(projectRoot, { extensions: [] });
         const result = (0, bundle_install_1.syncProfile)({
             projectRoot, bundles, agents: ['claude-code'],
-            method: 'symlink', contentDir: content,
+            method: 'symlink', contentDir: content, applyPlan: testApplyPlan,
         });
         expect(result.extensions).toEqual([]);
         expect(result.installed).toEqual([]);
@@ -189,7 +380,7 @@ describe('syncProfile', () => {
         (0, profile_1.writeProfile)(projectRoot, { extensions: ['stale-bundle', 'ext'] });
         const result = (0, bundle_install_1.syncProfile)({
             projectRoot, bundles, agents: ['claude-code'],
-            method: 'symlink', contentDir: content,
+            method: 'symlink', contentDir: content, applyPlan: testApplyPlan,
         });
         expect(result.extensions).toEqual(['stale-bundle', 'ext']);
         expect(result.skipped.some((l) => l.includes('stale-bundle'))).toBe(true);

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

@@ -68,6 +68,18 @@ describe('resolveBundleSkills', () => {
         expect((0, bundles_1.resolveBundleSkills)('dev', bundles).sort()).toEqual(['architecture-advisor', 'brainstorming']);
     });
 });
+describe('resolveBundleAgents', () => {
+    it('follows dependsOn transitively and dedupes, mirroring resolveBundleSkills', () => {
+        const content = makeFixture();
+        const bundles = (0, bundles_1.discoverBundles)(content);
+        expect((0, bundles_1.resolveBundleAgents)('frontend', bundles)).toEqual(['development-process']); // via dep on 'dev'
+    });
+    it('returns own agents when no deps', () => {
+        const content = makeFixture();
+        const bundles = (0, bundles_1.discoverBundles)(content);
+        expect((0, bundles_1.resolveBundleAgents)('dev', bundles)).toEqual(['development-process']);
+    });
+});
 describe('defaultScopeForBundle', () => {
     it('maps baseline and ambient to global, project to local', () => {
         expect((0, bundles_1.defaultScopeForBundle)('baseline')).toBe('global');

package/dist/tests/core/context/managed-block.test.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const managed_block_1 = require("../../../src/core/context/managed-block");
+const body = 'Use AWM through the development-process skill.';
+const malformedBoundaries = [
+    `${managed_block_1.AWM_START}\n<!-- AWM:BOUNDARY prefix=9 suffix=1 -->\nowned\n${managed_block_1.AWM_END}`,
+    `${managed_block_1.AWM_START}\n<!-- AWM:BOUNDARY prefix=1 suffix=2 -->\nowned\n${managed_block_1.AWM_END}`,
+    `${managed_block_1.AWM_START}\n<!-- AWM:BOUNDARY prefix=1 suffix=1 -->\n<!-- AWM:BOUNDARY prefix=0 suffix=1 -->\nowned\n${managed_block_1.AWM_END}`,
+    `${managed_block_1.AWM_START}\nowned\n<!-- AWM:BOUNDARY prefix=1 suffix=1 -->\n${managed_block_1.AWM_END}`,
+    `${managed_block_1.AWM_START}\n<!-- AWM:BOUNDARY prefix=1\nowned\n${managed_block_1.AWM_END}`,
+    `${managed_block_1.AWM_START}\ninline <!-- AWM:BOUNDARY prefix=1 suffix=1 -->\nowned\n${managed_block_1.AWM_END}`,
+    `<!-- AWM:BOUNDARY prefix=0 suffix=1 -->\n${managed_block_1.AWM_START}\nowned\n${managed_block_1.AWM_END}`,
+];
+describe('mergeManagedBlock', () => {
+    it('appends exactly one block and preserves user content byte-for-byte', () => {
+        const original = '# My rules\n\nKeep this.\n';
+        const merged = (0, managed_block_1.mergeManagedBlock)(original, body);
+        expect(merged).toContain(original);
+        expect(merged.match(/<!-- AWM:START -->/g)).toHaveLength(1);
+        expect((0, managed_block_1.mergeManagedBlock)(merged, body)).toBe(merged);
+    });
+    it.each([
+        ['', `${managed_block_1.AWM_START}\n<!-- AWM:BOUNDARY prefix=0 suffix=1 -->\n${body}\n${managed_block_1.AWM_END}\n`],
+        ['user', `user\n\n${managed_block_1.AWM_START}\n<!-- AWM:BOUNDARY prefix=2 suffix=1 -->\n${body}\n${managed_block_1.AWM_END}\n`],
+        ['user\n', `user\n\n${managed_block_1.AWM_START}\n<!-- AWM:BOUNDARY prefix=1 suffix=1 -->\n${body}\n${managed_block_1.AWM_END}\n`],
+        ['user\n\n', `user\n\n${managed_block_1.AWM_START}\n<!-- AWM:BOUNDARY prefix=0 suffix=1 -->\n${body}\n${managed_block_1.AWM_END}\n`],
+    ])('uses a stable separator for original %j', (original, expected) => {
+        expect((0, managed_block_1.mergeManagedBlock)(original, body)).toBe(expected);
+    });
+    it('replaces a valid block while preserving every byte before and after it', () => {
+        const before = 'prefix\r\n\r\n';
+        const after = '\r\nsuffix\n';
+        const original = `${before}${managed_block_1.AWM_START}\nold\n${managed_block_1.AWM_END}${after}`;
+        expect((0, managed_block_1.mergeManagedBlock)(original, 'new\n')).toBe(`${before}${managed_block_1.AWM_START}\nnew\n${managed_block_1.AWM_END}${after}`);
+    });
+    it('normalizes only trailing newlines in the managed body and is idempotent', () => {
+        const once = (0, managed_block_1.mergeManagedBlock)('', `${body}\n\n`);
+        expect((0, managed_block_1.mergeManagedBlock)(once, `${body}\n`)).toBe(once);
+    });
+    it.each([
+        [`${managed_block_1.AWM_START}\nbody\n`, 'unmatched'],
+        [`${managed_block_1.AWM_END}\n`, 'unmatched'],
+        [`${managed_block_1.AWM_START}\na\n${managed_block_1.AWM_END}\n${managed_block_1.AWM_START}\nb\n${managed_block_1.AWM_END}`, 'duplicate'],
+        [`${managed_block_1.AWM_START}\n${managed_block_1.AWM_START}\n${managed_block_1.AWM_END}\n${managed_block_1.AWM_END}`, 'nested'],
+        [`${managed_block_1.AWM_END}\nbody\n${managed_block_1.AWM_START}`, 'reversed'],
+        ['<!-- AWM:STARTED -->\nuser', 'malformed'],
+        ['<!-- prefix AWM:END -->\nuser', 'malformed'],
+        ['<!-- AWM:START', 'incomplete'],
+        ['<!-- AWM:END', 'incomplete'],
+        [`inline ${managed_block_1.AWM_START}\nbody\n${managed_block_1.AWM_END}`, 'standalone'],
+        [`\`${managed_block_1.AWM_START}\` and \`${managed_block_1.AWM_END}\``, 'standalone'],
+        [`\`\`\`md\n${managed_block_1.AWM_START}\nbody\n${managed_block_1.AWM_END}\n\`\`\``, 'standalone'],
+    ])('rejects ambiguous markers in %j', (input, message) => {
+        expect(() => (0, managed_block_1.mergeManagedBlock)(input, body)).toThrow(message);
+    });
+    it.each([
+        [null, body, 'original'],
+        [undefined, body, 'original'],
+        [42, body, 'original'],
+        ['', null, 'body'],
+        ['', {}, 'body'],
+    ])('rejects invalid runtime input', (original, managedBody, message) => {
+        expect(() => (0, managed_block_1.mergeManagedBlock)(original, managedBody)).toThrow(message);
+    });
+    it.each(malformedBoundaries)('rejects ambiguous boundary metadata in %j', (original) => {
+        expect(() => (0, managed_block_1.mergeManagedBlock)(original, body)).toThrow('malformed AWM boundary metadata');
+    });
+});
+describe('removeManagedBlock', () => {
+    it.each([
+        '',
+        'user',
+        'user\n',
+        'user\n\n',
+        '# Rules\n\nKeep every byte.\n',
+    ])('restores original %j byte-for-byte after merge', (original) => {
+        expect((0, managed_block_1.removeManagedBlock)((0, managed_block_1.mergeManagedBlock)(original, body))).toBe(original);
+    });
+    it('removes only the valid block and preserves every surrounding byte', () => {
+        const original = `before\n\n${managed_block_1.AWM_START}\nowned\n${managed_block_1.AWM_END}\n\nafter`;
+        expect((0, managed_block_1.removeManagedBlock)(original)).toBe('before\n\n\n\nafter');
+    });
+    it('is unchanged when no block exists and rejects ambiguous markers', () => {
+        expect((0, managed_block_1.removeManagedBlock)('user only\n')).toBe('user only\n');
+        expect(() => (0, managed_block_1.removeManagedBlock)(`${managed_block_1.AWM_START}\nmissing end`)).toThrow('unmatched');
+    });
+    it.each(malformedBoundaries)('rejects ambiguous boundary metadata before removal in %j', (original) => {
+        expect(() => (0, managed_block_1.removeManagedBlock)(original)).toThrow('malformed AWM boundary metadata');
+    });
+});

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

@@ -25,7 +25,7 @@ function tmpRegistry() {
 }
 describe('InjectionOrchestrator (claude-code dispatch via HookMergeStrategy)', () => {
     const ccOverride = {
-        label: 'Claude Code', skill: { global: '', local: '' }, workflow: null, agent: null,
+        label: 'Claude Code', skill: { global: '', local: '', renderer: 'link' }, workflow: null, agent: null,
         injection: { type: 'cc-settings-merge' },
         hooks: { type: 'cc-settings-merge', settingsPath: '', scriptsDir: '', matcher: '', eventName: '' },
     };
@@ -61,7 +61,12 @@ describe('InjectionOrchestrator (claude-code dispatch via HookMergeStrategy)', (
         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 noInjection = {
+            label: 'Test',
+            skill: { global: '', local: '', renderer: 'link' },
+            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');
@@ -79,7 +84,7 @@ describe('InjectionOrchestrator (opencode, real strategy)', () => {
         registryRoot = tmpRegistry();
         orch = new orchestrator_1.InjectionOrchestrator({
             providerOverride: {
-                label: 'OpenCode', skill: { global: '', local: '' }, workflow: null, agent: null,
+                label: 'OpenCode', skill: { global: '', local: '', renderer: 'link' }, workflow: null, agent: null,
                 injection: { type: 'config-instructions', configPath, field: 'instructions' },
             },
             contextPathOverride: absPath,
@@ -125,3 +130,43 @@ describe('InjectionOrchestrator (opencode, real strategy)', () => {
         expect((cfg.instructions ?? []).includes(absPath)).toBe(false);
     });
 });
+describe('InjectionOrchestrator (codex, managed AGENTS.md strategy)', () => {
+    let roots;
+    beforeEach(() => {
+        roots = [];
+        jest.clearAllMocks();
+    });
+    afterEach(() => {
+        for (const root of roots)
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+    });
+    it('owns only the managed block and never dispatches to Claude hooks', () => {
+        const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-codex-orch-'));
+        const registryRoot = tmpRegistry();
+        roots.push(dir, registryRoot);
+        const agentsPath = path_1.default.join(dir, 'AGENTS.md');
+        const contextPath = path_1.default.join(dir, 'awm-context.md');
+        fs_1.default.writeFileSync(agentsPath, '# User rules\n');
+        const orch = new orchestrator_1.InjectionOrchestrator({
+            providerOverride: {
+                label: 'Codex', skill: { global: '', local: '', renderer: 'link' }, workflow: null, agent: null,
+                injection: { type: 'managed-agents-md', globalPath: agentsPath, localFile: 'AGENTS.md' },
+            },
+            contextPathOverride: contextPath,
+        });
+        const op = {
+            agent: 'codex',
+            scope: 'global',
+            registryRoot,
+            installMethod: 'copy',
+            profileExtensions: [],
+        };
+        orch.installContext(op);
+        expect(fs_1.default.readFileSync(agentsPath, 'utf8')).toContain('# User rules\n');
+        expect(fs_1.default.readFileSync(agentsPath, 'utf8')).toContain('BODY');
+        expect(install_1.installHook).not.toHaveBeenCalled();
+        expect(orch.contextStatus(op)).toBe('injected');
+        orch.uninstallContext(op);
+        expect(fs_1.default.readFileSync(agentsPath, 'utf8')).toBe('# User rules\n');
+    });
+});

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

@@ -100,7 +100,7 @@ describe('regenerateGlobalContext', () => {
         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(regenerateGlobalContext(undefined, brokenOrch)).toEqual([{ agent: 'opencode', action: 'skipped' }]);
         expect(fs_1.default.existsSync(contextPath())).toBe(false); // installContext never called
     });
 });