agentic-workflow-manager 3.1.0 → 3.2.0

package/dist/src/core/diagnostics/context.js

@@ -16,6 +16,7 @@ const profile_1 = require("../profile");
 const bundles_1 = require("../bundles");
 const skill_integrity_1 = require("../skill-integrity");
 const paths_1 = require("../paths");
+const provider_checks_1 = require("./provider-checks");
 // Estado de un artefacto en <dir>/<skill>: link vivo / symlink colgante / ausente.
 function linkState(dir, skill) {
     const p = path_1.default.join(dir, skill);
@@ -44,12 +45,12 @@ function classifyLinks(skillNames, dir) {
 }
 function detectGitState(repoDir) {
     try {
-        const porcelain = (0, child_process_1.execSync)('git status --porcelain', { cwd: repoDir, stdio: ['ignore', 'pipe', 'ignore'] })
+        const porcelain = (0, child_process_1.execFileSync)('git', ['status', '--porcelain'], { cwd: repoDir, stdio: ['ignore', 'pipe', 'ignore'], encoding: 'utf8' })
             .toString().trim();
         if (porcelain.length > 0)
             return 'dirty';
         try {
-            const behind = (0, child_process_1.execSync)('git rev-list --count HEAD..@{u}', { cwd: repoDir, stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000 })
+            const behind = (0, child_process_1.execFileSync)('git', ['rev-list', '--count', 'HEAD..@{u}'], { cwd: repoDir, stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000, encoding: 'utf8' })
                 .toString().trim();
             if (behind !== '' && behind !== '0')
                 return 'behind';
@@ -67,8 +68,8 @@ function detectGitState(repoDir) {
 function gatherContextInjection() {
     const out = [];
     const orch = new orchestrator_1.InjectionOrchestrator();
-    for (const agent of Object.keys(providers_1.PROVIDERS)) {
-        const inj = providers_1.PROVIDERS[agent].injection;
+    for (const agent of providers_1.AGENT_TARGETS) {
+        const inj = (0, providers_1.providerFor)(agent).injection;
         if (!inj || inj.type !== 'config-instructions')
             continue;
         if (!fs_1.default.existsSync(inj.configPath))
@@ -96,17 +97,22 @@ function gatherMachine(bundles, agent = 'claude-code') {
     const first = regs[0];
     const cachePresent = !!first && fs_1.default.existsSync(path_1.default.join(first.contentRoot, '.git'));
     const gitState = cachePresent ? detectGitState(first.contentRoot) : undefined;
-    // hook (reutiliza computeHookStatus)
+    // hook (reutiliza computeHookStatus) — Task 9 fix: this used to be hardcoded to
+    // 'claude-code' regardless of `agent`, so `awm init --agent codex`'s own hook
+    // precondition silently read CLAUDE's hook status instead of Codex's. Whenever
+    // Claude's hook was already installed, stepHook would then wrongly conclude
+    // Codex's hook was "already present" and skip installing it (R18 regression —
+    // caught while building this task's real end-to-end init test).
     let hookPresent = false;
     let hookDegraded = false;
     try {
-        const hs = (0, status_1.computeHookStatus)('claude-code');
+        const hs = (0, status_1.computeHookStatus)(agent);
         hookPresent = hs.checks.settingsEntry.ok;
         hookDegraded = hs.overall === 'DEGRADED';
     }
     catch { /* sin soporte de hooks → ausente */ }
     // devCore (bundle baseline)
-    const skillsDir = providers_1.PROVIDERS[agent].skill.global;
+    const skillsDir = (0, providers_1.providerFor)(agent).skill.global;
     const baseline = bundles.find((b) => b.scope === 'baseline');
     let devCorePresent = false;
     let brokenLinks = [];
@@ -116,6 +122,26 @@ function gatherMachine(bundles, agent = 'claude-code') {
         const absent = skillNames.filter((s) => !linked.includes(s) && !broken.includes(s));
         devCorePresent = skillNames.length > 0 && (linked.length + broken.length) > 0;
         brokenLinks = [...broken, ...absent];
+        // Agent-type artifacts are never shared across agents (R12/R13 —
+        // install-planner.ts — unlike skills, where OpenCode and Codex both
+        // resolve to ~/.agents/skills). A shared skill directory already
+        // linked by a co-owner agent must not make THIS agent's own native
+        // agent artifacts look "present" when they were never installed for
+        // it specifically — otherwise stepDevCore (init/steps.ts) would skip
+        // re-running and Codex would never get its .toml rendered on a
+        // machine where OpenCode was initialized first. Found while building
+        // the real Codex+OpenCode coexistence E2E test
+        // (tests/integration/codex-provider-isolated.test.ts).
+        const agentConfig = (0, providers_1.providerFor)(agent).agent;
+        if (agentConfig) {
+            const agentNames = (0, bundles_1.resolveBundleAgents)(baseline.name, bundles);
+            if (agentNames.length > 0) {
+                const filenames = agentNames.map((n) => agentConfig.renderer === 'codex-agent-toml' ? `${n}.toml` : n);
+                const { linked: agentLinked, broken: agentBroken } = classifyLinks(filenames, agentConfig.global);
+                const agentAbsent = filenames.filter((f) => !agentLinked.includes(f) && !agentBroken.includes(f));
+                brokenLinks = [...brokenLinks, ...agentBroken, ...agentAbsent];
+            }
+        }
     }
     // ambient (deseados desde ~/.awm/config.json)
     let wanted = [];
@@ -145,7 +171,7 @@ function gatherMachine(bundles, agent = 'claude-code') {
 function gatherProject(root, bundles, agent = 'claude-code') {
     const profile = (0, profile_1.readProfile)(root);
     const profilePresent = fs_1.default.existsSync(path_1.default.join(root, '.awm', 'profile.json'));
-    const localSkillsDir = path_1.default.join(root, providers_1.PROVIDERS[agent].skill.local);
+    const localSkillsDir = path_1.default.join(root, (0, providers_1.providerFor)(agent).skill.local);
     const expected = [];
     for (const ext of profile.extensions) {
         for (const s of (0, bundles_1.resolveBundleSkills)(ext, bundles))
@@ -172,8 +198,11 @@ function gatherContext(opts = {}) {
     const bundles = opts.bundles ?? (0, bundles_1.discoverAllBundles)();
     const agent = opts.agent ?? 'claude-code';
     const root = (0, profile_1.findProjectRoot)(cwd);
+    const agents = opts.agents ?? [agent];
+    const scanSkills = opts.scanSkills ?? ((dir) => (0, skill_integrity_1.classifyGlobalSkills)(dir, (0, registries_1.contentRoots)()));
     return {
         machine: gatherMachine(bundles, agent),
         project: root ? gatherProject(root, bundles, agent) : null,
+        providers: (0, provider_checks_1.gatherProviderChecks)(agents, scanSkills),
     };
 }

package/dist/src/core/diagnostics/provider-checks.js

@@ -0,0 +1,219 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gatherProviderChecks = gatherProviderChecks;
+// src/core/diagnostics/provider-checks.ts
+//
+// Builds the per-provider diagnostic matrix consumed by `awm doctor`
+// (Task 9). Kept in its own module (rather than growing context.ts or
+// checks.ts) because it has a distinct concern: turning raw provider state
+// (binary version, skill/agent dirs, hook trust, context injection) into a
+// small set of stable, JSON-friendly `ProviderCheck` rows — one per
+// provider, deduplicated for physical directories shared between providers
+// (today: OpenCode and Codex both read/write ~/.agents/skills).
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const providers_1 = require("../../providers");
+const provider_version_1 = require("../provider-version");
+const status_1 = require("../../commands/hooks/status");
+const orchestrator_1 = require("../context/orchestrator");
+const registries_1 = require("../registries");
+function binaryVersionCheck(agent) {
+    const provider = (0, providers_1.providerFor)(agent);
+    if (!provider.versionCommand || !provider.minimumVersion) {
+        // No version gate for this agent — nothing to enforce, treat as supported.
+        return { id: 'binary.version', state: 'supported' };
+    }
+    try {
+        const { version } = (0, provider_version_1.assertProviderSupported)(agent);
+        return { id: 'binary.version', state: 'supported', target: version ?? undefined };
+    }
+    catch (err) {
+        const message = err.message;
+        const missing = /not installed|not available on PATH/i.test(message);
+        return {
+            id: 'binary.version',
+            state: missing ? 'missing' : 'unsupported',
+            detail: message,
+            remediationCode: missing ? 'install-provider-binary' : 'upgrade-provider-binary',
+        };
+    }
+}
+function skillsGlobalCheck(dir, owners, integrity) {
+    const shared = owners.length > 1;
+    const broken = integrity.repairable.length + integrity.dead.length;
+    // Broken links are checked BEFORE shared: 'shared' is a non-degrading/OK state
+    // (see checks.ts's DEGRADING_PROVIDER_STATES), so if it were set unconditionally
+    // for a shared dir it would silently mask real broken/dead symlinks — a green
+    // checkmark next to "N broken links → repair-global-skills" would contradict its
+    // own trailing text, and `overall` would never degrade despite real breakage.
+    let state;
+    if (broken > 0) {
+        state = 'broken';
+    }
+    else if (shared) {
+        state = 'shared';
+    }
+    else if (!fs_1.default.existsSync(dir)) {
+        state = 'absent';
+    }
+    else {
+        state = 'healthy';
+    }
+    return {
+        id: 'skills.global',
+        state,
+        target: dir,
+        owners: shared ? owners : undefined,
+        detail: broken > 0 ? `${broken} broken links` : undefined,
+        remediationCode: broken > 0 ? 'repair-global-skills' : undefined,
+    };
+}
+/** R8: verify the Codex `.toml` agents this run's renderer would have produced still parse. */
+function tomlAgentsHealthy(dir, entries) {
+    const tomls = entries.filter((e) => e.endsWith('.toml'));
+    const broken = tomls.filter((file) => {
+        try {
+            const content = fs_1.default.readFileSync(path_1.default.join(dir, file), 'utf8');
+            // renderCodexAgent (Task 4) always emits this key — its absence means the
+            // file was hand-edited or truncated, not a shape `awm` would have written.
+            return !content.includes('developer_instructions = ');
+        }
+        catch {
+            return true;
+        }
+    }).length;
+    return { broken };
+}
+/**
+ * Returns `null` when a check doesn't structurally apply to `agent` (e.g. Antigravity
+ * has no `agent`/`hooks`/`injection` config; OpenCode has no hooks; Claude Code's global
+ * context rides its SessionStart hook, already covered by hook.trust). `null` rows are
+ * dropped by `gatherProviderChecks` — omitted entirely, not rendered as a failure. This
+ * is deliberately distinct from `state: 'unsupported'`, which `binaryVersionCheck` still
+ * uses for a genuine failure (an installed CLI version below the required minimum) — that
+ * state correctly degrades `overall` (see checks.ts's DEGRADING_PROVIDER_STATES) and must
+ * never be reused to mean "not applicable", or a fully-healthy single-provider `awm doctor`
+ * run (e.g. claude-code-only, opencode-only, antigravity-only) would always render
+ * inapplicable rows as red ✖ and `overall` could never be 'healthy'.
+ */
+function agentsNativeCheck(agent) {
+    const provider = (0, providers_1.providerFor)(agent);
+    if (!provider.agent)
+        return null;
+    const dir = provider.agent.global;
+    let entries;
+    try {
+        entries = fs_1.default.readdirSync(dir);
+    }
+    catch {
+        return { id: 'agents.native', state: 'absent', target: dir };
+    }
+    if (entries.length === 0)
+        return { id: 'agents.native', state: 'absent', target: dir };
+    if (provider.agent.renderer === 'codex-agent-toml') {
+        const { broken } = tomlAgentsHealthy(dir, entries);
+        return {
+            id: 'agents.native',
+            state: broken > 0 ? 'broken' : 'healthy',
+            target: dir,
+            detail: broken > 0 ? `${broken} malformed .toml` : undefined,
+            remediationCode: broken > 0 ? 'reinstall-native-agents' : undefined,
+        };
+    }
+    return { id: 'agents.native', state: 'healthy', target: dir };
+}
+function hookTrustCheck(agent) {
+    const provider = (0, providers_1.providerFor)(agent);
+    if (!provider.hooks)
+        return null;
+    let status;
+    try {
+        status = (0, status_1.computeHookStatus)(agent);
+    }
+    catch {
+        return { id: 'hook.trust', state: 'absent', remediationCode: 'awm-init' };
+    }
+    if (status.overall === 'NOT_INSTALLED') {
+        return { id: 'hook.trust', state: 'absent', remediationCode: 'awm-init' };
+    }
+    if (status.trust) {
+        // Codex: 'pending-trust' | 'healthy' | 'stale' map directly onto ProviderCheckState.
+        return {
+            id: 'hook.trust',
+            state: status.trust,
+            remediationCode: status.trust === 'pending-trust' ? 'open-hooks-trust' : undefined,
+        };
+    }
+    return { id: 'hook.trust', state: status.overall === 'HEALTHY' ? 'healthy' : 'broken' };
+}
+/** R7: reflects the provider's global context-delivery mechanism (config-instructions /
+ *  managed-agents-md). claude-code's context rides the SessionStart hook — already
+ *  covered by hook.trust, so this check is OMITTED (returns null) rather than reported,
+ *  to avoid double-reporting the same fact as a separate, redundant row. */
+function contextGlobalCheck(agent) {
+    const injection = (0, providers_1.providerFor)(agent).injection;
+    if (!injection || injection.type === 'cc-settings-merge') {
+        return null;
+    }
+    let state = 'absent';
+    try {
+        const orchestrator = new orchestrator_1.InjectionOrchestrator();
+        const result = orchestrator.contextStatus({
+            agent,
+            scope: 'global',
+            registryRoot: (0, registries_1.capabilityRoot)('skills') ?? '',
+            installMethod: 'symlink',
+            profileExtensions: [],
+        });
+        state = result === 'injected' ? 'delivered' : result === 'stale' ? 'stale' : 'absent';
+    }
+    catch {
+        state = 'absent';
+    }
+    return {
+        id: 'context.global',
+        state,
+        remediationCode: state === 'delivered' ? undefined : 'awm-init',
+    };
+}
+/**
+ * Builds one `ProviderFacts` row per requested agent. Physical skill directories shared
+ * between providers (OpenCode + Codex both use `~/.agents/skills`) are scanned exactly
+ * once via `scanSkills` and every owner's `skills.global` check is marked `state: 'shared'`
+ * — mirrors the dedup principle `install-planner.ts` (Task 5) already applies to writes.
+ *
+ * Named `gatherProviderChecks` (not `gatherProviderFacts`) to avoid colliding with the
+ * unrelated `gatherProviderFacts` in `core/init/provider-facts.ts` (Task 8, baseline-hash
+ * snapshot for rollback comparison — a different shape, a different purpose). No file
+ * currently imports both, but the names are close enough to trip up a future reader/editor.
+ */
+function gatherProviderChecks(agents, scanSkills) {
+    const ownersByDir = new Map();
+    for (const agent of agents) {
+        const dir = (0, providers_1.providerFor)(agent).skill.global;
+        const owners = ownersByDir.get(dir) ?? [];
+        owners.push(agent);
+        ownersByDir.set(dir, owners);
+    }
+    const scansByDir = new Map();
+    for (const dir of ownersByDir.keys()) {
+        scansByDir.set(dir, scanSkills(dir));
+    }
+    return agents.map((agent) => {
+        const provider = (0, providers_1.providerFor)(agent);
+        const dir = provider.skill.global;
+        const owners = ownersByDir.get(dir) ?? [agent];
+        const integrity = scansByDir.get(dir) ?? { valid: [], repairable: [], dead: [] };
+        const checks = [
+            binaryVersionCheck(agent),
+            skillsGlobalCheck(dir, owners, integrity),
+            agentsNativeCheck(agent),
+            hookTrustCheck(agent),
+            contextGlobalCheck(agent),
+        ].filter((check) => check !== null);
+        return { id: agent, label: provider.label, checks };
+    });
+}

package/dist/src/core/executor.js

@@ -4,6 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.removeArtifact = removeArtifact;
+exports.stageArtifact = stageArtifact;
+exports.replaceArtifact = replaceArtifact;
 exports.installArtifact = installArtifact;
 // src/core/executor.ts
 const fs_1 = __importDefault(require("fs"));
@@ -22,20 +24,39 @@ function removeArtifact(targetPath) {
     }
     fs_1.default.rmSync(targetPath, { recursive: true, force: true });
 }
-function installArtifact(sourcePath, targetPath, method) {
+/**
+ * Stages `sourcePath` next to `targetPath` (same parent directory) WITHOUT
+ * touching `targetPath` itself (R17): the live target is never removed until
+ * a stage has already succeeded. Returns the staged path, ready to be swapped
+ * in via `replaceArtifact`.
+ */
+function stageArtifact(sourcePath, targetPath, method) {
     if (!fs_1.default.existsSync(sourcePath)) {
         throw new Error(`Source path does not exist: ${sourcePath}`);
     }
-    const parentDir = path_1.default.dirname(targetPath);
-    if (!fs_1.default.existsSync(parentDir)) {
-        fs_1.default.mkdirSync(parentDir, { recursive: true });
-    }
-    // Clean up existing if it exists
-    fs_1.default.rmSync(targetPath, { recursive: true, force: true });
+    const parent = path_1.default.dirname(targetPath);
+    fs_1.default.mkdirSync(parent, { recursive: true });
+    const staged = path_1.default.join(parent, `.${path_1.default.basename(targetPath)}.${process.pid}.staged`);
+    fs_1.default.rmSync(staged, { recursive: true, force: true });
     if (method === 'symlink') {
-        fs_1.default.symlinkSync(sourcePath, targetPath, 'dir');
+        fs_1.default.symlinkSync(sourcePath, staged, 'dir');
     }
     else {
-        fs_1.default.cpSync(sourcePath, targetPath, { recursive: true });
+        fs_1.default.cpSync(sourcePath, staged, { recursive: true });
     }
+    return staged;
+}
+/** Atomically swaps a staged artifact into `targetPath`, replacing whatever is there. */
+function replaceArtifact(staged, targetPath) {
+    fs_1.default.rmSync(targetPath, { recursive: true, force: true });
+    fs_1.default.renameSync(staged, targetPath);
+}
+/**
+ * Convenience wrapper over `stageArtifact` + `replaceArtifact` for callers
+ * that don't need transactional multi-target coordination (see
+ * install-transaction.ts's `applyInstallPlan` for the transactional path).
+ */
+function installArtifact(sourcePath, targetPath, method) {
+    const staged = stageArtifact(sourcePath, targetPath, method);
+    replaceArtifact(staged, targetPath);
 }

package/dist/src/core/init/mutation-targets.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planInitMutationTargets = planInitMutationTargets;
+// src/core/init/mutation-targets.ts
+//
+// Enumerates, WITHOUT writing anything, every filesystem path a real `awm
+// init` run for a given agent is about to touch. `runInit` feeds this list to
+// `beginBackupSession` (install-transaction.ts) BEFORE any step runs, so a
+// failed init can roll every one of them back to its pre-run state.
+//
+// Deliberately generous rather than exhaustively precise: a path that ends up
+// unused this run (e.g. an ambient bundle whose signal isn't present) is
+// harmless to include — beginBackupSession just snapshots it (a no-op backup
+// entry when nothing exists there yet). The one failure mode that matters is
+// under-enumeration: a real write to a path NOT in this list would land
+// outside the backup session and survive a rollback.
+const path_1 = __importDefault(require("path"));
+const providers_1 = require("../../providers");
+const bundles_1 = require("../bundles");
+const bundle_install_1 = require("../bundle-install");
+const install_planner_1 = require("../install-planner");
+const artifact_state_1 = require("../artifact-state");
+const paths_1 = require("../paths");
+const profile_1 = require("../profile");
+const registries_1 = require("../registries");
+// Thin wrapper over install-planner.ts's `physicalTarget` (the single source
+// of truth for the dir+filename computation, including the `.toml` rename for
+// codex-agent-toml) — adapts its throw-on-unsupported contract to this
+// module's null-on-unsupported one, and drops the `renderer` field this
+// module's callers never needed.
+function physicalTarget(type, agent, scope, installName, projectRoot) {
+    try {
+        return (0, install_planner_1.physicalTarget)({ name: installName, installName, type, sourcePath: '' }, agent, scope, projectRoot ?? '').targetPath;
+    }
+    catch {
+        return null;
+    }
+}
+function addBundleTargets(targets, bundleName, bundles, agent, scope, projectRoot, contentDir) {
+    let intents;
+    try {
+        intents = (0, bundle_install_1.expandBundleArtifacts)({
+            bundleName,
+            bundles,
+            agents: [agent],
+            method: 'symlink',
+            projectRoot,
+            contentDir,
+        });
+    }
+    catch {
+        // Bundle not resolvable (e.g. missing dependency in a partially-seeded
+        // test registry) — nothing to enumerate for it, not a hard failure.
+        return;
+    }
+    for (const intent of intents) {
+        const p = physicalTarget(intent.type, agent, scope, intent.installName, projectRoot);
+        if (p)
+            targets.add(p);
+    }
+}
+/**
+ * Enumerates every path `runInitSteps` may write to for `agent`, given the
+ * discovered bundle catalog. Driven entirely by `agent` (the single target
+ * being initialized this run) and `bundles` — not by preferences, since
+ * enumeration never needs to know about any OTHER enabled agent's targets.
+ * Pure / read-only (does hit the filesystem to discover project root and
+ * read the project profile, but never writes).
+ */
+function planInitMutationTargets(params) {
+    const { cwd, agent, bundles } = params;
+    const targets = new Set();
+    // preferences.json + the artifact ownership ledger (state/artifacts.json)
+    targets.add(path_1.default.join((0, paths_1.awmHome)(), 'preferences.json'));
+    targets.add((0, artifact_state_1.artifactStateFile)());
+    const provider = (0, providers_1.providerFor)(agent);
+    // hook: settings file (or hooks.json for codex) + the scripts directory it points at
+    if (provider.hooks) {
+        targets.add(provider.hooks.settingsPath);
+        targets.add(provider.hooks.scriptsDir);
+    }
+    // Global skills directory itself, not just the bundle-derived skill
+    // subdirectories enumerated below. stepGlobalSkillsRepair (steps.ts) calls
+    // repairGlobalSkills, which readdirSync's the WHOLE skills dir and
+    // rm/symlinks individual entries classified as repairable/dead — i.e.
+    // entries that, by definition, don't belong to any currently-known
+    // bundle, so they can never be enumerated by addBundleTargets below.
+    // Adding the parent directory here makes beginBackupSession snapshot the
+    // whole tree (backupEntryFor does a recursive fs.cpSync for directory
+    // targets — verified in install-transaction.ts), covering any entry that
+    // repair might mutate. Broad-but-safe, per this module's own philosophy.
+    targets.add(provider.skill.global);
+    // global context / AGENTS.md injection (covered by the hook for claude-code)
+    const injection = provider.injection;
+    if (injection) {
+        if (injection.type === 'config-instructions')
+            targets.add(injection.configPath);
+        if (injection.type === 'managed-agents-md')
+            targets.add(injection.globalPath);
+    }
+    // machine-level bundle targets: baseline (dev-core) + ambient, global scope
+    const roots = (0, registries_1.contentRoots)();
+    const contentDir = roots[0] ?? '';
+    const machineBundles = bundles.filter((b) => b.scope === 'baseline' || b.scope === 'ambient');
+    for (const b of machineBundles) {
+        addBundleTargets(targets, b.name, bundles, agent, 'global', cwd, contentDir);
+    }
+    // project-level: profile, sensors manifest, project injection, and every
+    // extension currently recorded in .awm/profile.json
+    const projectRoot = (0, profile_1.findProjectRoot)(cwd);
+    if (projectRoot) {
+        targets.add(path_1.default.join(projectRoot, '.awm', 'profile.json'));
+        targets.add(path_1.default.join(projectRoot, '.awm', 'sensors.json'));
+        if (injection?.type === 'config-instructions') {
+            targets.add(path_1.default.join(projectRoot, path_1.default.basename(injection.configPath)));
+        }
+        if (injection?.type === 'managed-agents-md') {
+            targets.add(path_1.default.join(projectRoot, path_1.default.basename(injection.localFile)));
+        }
+        let profile;
+        try {
+            profile = (0, profile_1.readProfile)(projectRoot);
+        }
+        catch {
+            profile = { extensions: [] };
+        }
+        for (const ext of profile.extensions) {
+            const extBundle = bundles.find((b) => b.name === ext);
+            if (!extBundle)
+                continue;
+            const scope = (0, bundles_1.defaultScopeForBundle)(extBundle.scope);
+            addBundleTargets(targets, ext, bundles, agent, scope, projectRoot, contentDir);
+        }
+    }
+    return Array.from(targets);
+}