loadout-ai 0.1.0

package/dist/src/core/active-policy.js

@@ -0,0 +1,233 @@
+import { applyActivationChange, formatActivationPlan, planActivationChange, } from "./active-set.js";
+import { scanProject } from "./recommend.js";
+import { readInstallState } from "./state.js";
+import { outcomeAdjustment, projectTaskFamilies, readLocalOutcomes, } from "./outcomes.js";
+const FOUNDATION = new Set([
+    "brainstorming",
+    "systematic-debugging",
+    "test-driven-development",
+    "verification-before-completion",
+    "writing-plans",
+    "requesting-code-review",
+    "receiving-code-review",
+    "find-docs",
+    "context7-docs",
+    "security-best-practices",
+    "security-threat-model",
+    "code-review-excellence",
+    "api-design-principles",
+    "architecture-patterns",
+    "accessibility-compliance",
+    "deployment-pipeline-design",
+    "documentation-writer",
+    "openai-docs",
+    "web-design-guidelines",
+]);
+const SPECIALIZED_WITHOUT_SIGNAL = /(?:appstore|backtesting|bats-|oracle|salesforce|power-bi|dataverse|qdrant|azure-|aws-|mcp-server-generator|sandbox-npm|migration)/;
+const SOURCE_PRIORITY = {
+    superpowers: 80,
+    context7: 75,
+    "openai-skills": 70,
+    "anthropic-skills": 70,
+    "vercel-agent-skills": 60,
+    "ui-ux-pro-max": 55,
+    "wshobson-agents": 45,
+    "openai-codex-skills": 40,
+    "awesome-copilot": 20,
+};
+const GENERAL = [
+    [/(?:security|threat|secrets|owasp)/, "security"],
+    [/(?:review|refactor)/, "code review"],
+    [/(?:debug|diagnos)/, "debugging"],
+    [/(?:test|playwright|coverage)/, "testing"],
+    [/(?:architect|api-design|openapi)/, "architecture"],
+    [/(?:docs|documentation|readme)/, "documentation"],
+    [/(?:github-actions|deployment-pipeline)/, "delivery"],
+];
+const SIGNAL_RULES = [
+    {
+        signal: (project) => project.languages.includes("javascript/typescript"),
+        pattern: /(?:javascript|typescript|nodejs|npm|webapp)/,
+        label: "JavaScript/TypeScript project",
+    },
+    {
+        signal: (project) => project.languages.includes("python"),
+        pattern: /(?:python|pytest|fastapi|jupyter)/,
+        label: "Python project",
+    },
+    {
+        signal: (project) => project.languages.includes("go"),
+        pattern: /(?:^|-)go(?:-|$)|golang/,
+        label: "Go project",
+    },
+    {
+        signal: (project) => project.languages.includes("rust"),
+        pattern: /rust|cargo/,
+        label: "Rust project",
+    },
+    {
+        signal: (project) => project.languages.includes("java"),
+        pattern: /java|spring/,
+        label: "Java project",
+    },
+    {
+        signal: (project) => project.languages.includes(".net"),
+        pattern: /dotnet|csharp|aspnet/,
+        label: ".NET project",
+    },
+    {
+        signal: (project) => project.frameworks.some((item) => ["react", "next.js", "vue", "svelte"].includes(item)),
+        pattern: /react|nextjs|frontend|web-design|ui-|design-system|responsive|accessibility|figma/,
+        label: "frontend framework",
+    },
+    {
+        signal: (project) => project.frameworks.includes("playwright"),
+        pattern: /playwright|e2e|webapp-testing/,
+        label: "Playwright project",
+    },
+];
+function selector(record) {
+    if (!record.unitId)
+        return undefined;
+    return `${record.packageId}/${record.unitId}`;
+}
+function scoreCandidate(record, project, pinned, outcomes, taskFamilies) {
+    const id = selector(record);
+    if (!id || !record.unitId)
+        return undefined;
+    const name = record.unitId.toLowerCase();
+    let score = 0;
+    const reasons = [];
+    if (pinned.has(id) || pinned.has(record.unitId)) {
+        score += 1000;
+        reasons.push("explicitly pinned");
+    }
+    const explicitlyPinned = score >= 1000;
+    if (!explicitlyPinned && SPECIALIZED_WITHOUT_SIGNAL.test(name))
+        return undefined;
+    if (FOUNDATION.has(name)) {
+        score += 100;
+        reasons.push("cross-project foundation");
+    }
+    for (const [pattern, label] of GENERAL)
+        if (pattern.test(name)) {
+            score += 18;
+            reasons.push(label);
+        }
+    for (const rule of SIGNAL_RULES)
+        if (rule.signal(project) && rule.pattern.test(name)) {
+            score += 55;
+            reasons.push(rule.label);
+        }
+    const local = outcomeAdjustment(outcomes, id, record.agent, taskFamilies);
+    if (!explicitlyPinned && local.score <= -35)
+        return undefined;
+    score += local.score;
+    reasons.push(...local.evidence);
+    // Capacity is a ceiling, never a quota. A generic word such as "test" or
+    // "review" is supporting evidence, but cannot activate a niche skill alone.
+    if (score < 50)
+        return undefined;
+    return {
+        selector: id,
+        packageId: record.packageId,
+        unitId: record.unitId,
+        score,
+        reasons: [...new Set(reasons)],
+    };
+}
+/** Deterministic, local-only active-set selection over the reviewed library. */
+export async function planProjectActivation(projectPath, options = {}) {
+    const limit = options.limit ?? 40;
+    if (!Number.isInteger(limit) || limit < 1 || limit > 200)
+        throw new Error("--limit must be an integer from 1 to 200");
+    const project = await scanProject(projectPath);
+    const state = await readInstallState();
+    const outcomes = await readLocalOutcomes();
+    const taskFamilies = projectTaskFamilies(project);
+    const relevant = (state.activations ?? []).filter((record) => record.installationState === "installed" &&
+        (!options.agents || options.agents.includes(record.agent)));
+    const byAgent = new Map();
+    for (const record of relevant)
+        if (record.activationState === "active")
+            byAgent.set(record.agent, (byAgent.get(record.agent) ?? 0) + 1);
+    const activeBefore = Math.max(0, ...byAgent.values());
+    const capacity = Math.max(0, limit - activeBefore);
+    const pins = new Set(options.pins ?? []);
+    const scored = relevant
+        .filter((record) => record.activationState === "disabled" &&
+        record.cacheState === "downloaded" &&
+        record.reviewState === "reviewed")
+        .map((record) => scoreCandidate(record, project, pins, outcomes, taskFamilies))
+        .filter((item) => Boolean(item))
+        .sort((left, right) => right.score - left.score ||
+        (SOURCE_PRIORITY[right.packageId] ?? 0) -
+            (SOURCE_PRIORITY[left.packageId] ?? 0) ||
+        left.unitId.localeCompare(right.unitId) ||
+        left.packageId.localeCompare(right.packageId));
+    // One capability name wins by evidence order; overlapping collections remain
+    // in the library and can still be explicitly pinned by full selector.
+    const unique = [];
+    const claimedUnits = new Set();
+    for (const item of scored) {
+        const fullPin = pins.has(item.selector);
+        if (!fullPin && claimedUnits.has(item.unitId))
+            continue;
+        claimedUnits.add(item.unitId);
+        unique.push(item);
+    }
+    const selected = unique.slice(0, capacity);
+    const alternatives = selected.flatMap((chosen) => {
+        const deferred = scored
+            .filter((candidate) => candidate.unitId === chosen.unitId &&
+            candidate.selector !== chosen.selector)
+            .map((candidate) => candidate.selector);
+        return deferred.length
+            ? [{ unitId: chosen.unitId, selected: chosen.selector, deferred }]
+            : [];
+    });
+    const warnings = [];
+    const known = new Set(relevant.flatMap((record) => {
+        const id = selector(record);
+        return id ? [id, record.unitId] : [];
+    }));
+    const unknownPins = [...pins].filter((pin) => !known.has(pin));
+    if (unknownPins.length)
+        warnings.push(`Pinned skill(s) are not in the managed library: ${unknownPins.join(", ")}`);
+    if (!capacity)
+        warnings.push(`Active-set limit ${limit} is already reached; disable skills or raise --limit.`);
+    const activation = selected.length
+        ? await planActivationChange("enable", selected.map((item) => item.selector), { ...(options.agents ? { agents: options.agents } : {}) })
+        : undefined;
+    return {
+        project,
+        limit,
+        ...(options.agents ? { agents: options.agents } : {}),
+        activeBefore,
+        capacity,
+        selected,
+        alternatives,
+        ...(activation ? { activation } : {}),
+        warnings,
+    };
+}
+export async function applyProjectActivation(plan) {
+    if (!plan.activation || !plan.selected.length)
+        throw new Error("No reviewed library skills were selected for activation");
+    return applyActivationChange(plan.activation);
+}
+export function formatProjectActivation(plan) {
+    const detected = [...plan.project.languages, ...plan.project.frameworks];
+    return [
+        `Project: ${plan.project.root}`,
+        `Detected: ${detected.join(", ") || "no known project signals"}`,
+        `Active-set budget: ${plan.activeBefore}/${plan.limit} active; ${plan.capacity} slot(s) available`,
+        `Proposed additions: ${plan.selected.length}`,
+        ...plan.selected.map((item) => `  + ${item.selector} [${item.score}] — ${item.reasons.join(", ")}`),
+        ...plan.alternatives.map((item) => `  = ${item.unitId}: selected ${item.selected}; deferred equivalent source(s): ${item.deferred.join(", ")}`),
+        ...(plan.activation
+            ? ["", "Exact activation delta:", formatActivationPlan(plan.activation)]
+            : []),
+        ...plan.warnings.map((warning) => `Warning: ${warning}`),
+    ].join("\n");
+}

package/dist/src/core/active-set.js

@@ -0,0 +1,382 @@
+import { createHash } from "node:crypto";
+import { cp, lstat, mkdir, readFile, readdir, rm } from "node:fs/promises";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import { agentSkillsDirectory, ensureDirectory } from "./paths.js";
+import { activationLibraryPath, installStatePath, readInstallState, writeInstallState, } from "./state.js";
+import { runMutationTransaction } from "./transaction.js";
+/** Resolve a managed file to its active location or disabled library copy. */
+export function managedFileReadPath(packageId, filePath, activations) {
+    const disabled = activations.find((activation) => activation.packageId === packageId &&
+        activation.installationState === "installed" &&
+        activation.activationState === "disabled" &&
+        activation.targets.some((target) => isInside(target.activePath, filePath)));
+    if (!disabled)
+        return filePath;
+    const target = disabled.targets.find((item) => isInside(item.activePath, filePath));
+    return join(disabled.libraryPath, target.libraryRelativePath, relative(target.activePath, filePath));
+}
+function isInside(root, candidate) {
+    const path = relative(resolve(root), resolve(candidate));
+    return path === "" || (!path.startsWith("..") && !path.startsWith(sep));
+}
+async function pathExists(path) {
+    try {
+        await lstat(path);
+        return true;
+    }
+    catch (error) {
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+async function hashTree(root) {
+    const files = [];
+    async function visit(path) {
+        const info = await lstat(path);
+        if (info.isSymbolicLink())
+            throw new Error(`Refusing symlink in managed active set: ${path}`);
+        if (info.isFile()) {
+            files.push({
+                path: relative(root, path).split(sep).join("/"),
+                sha256: createHash("sha256")
+                    .update(await readFile(path))
+                    .digest("hex"),
+            });
+            return;
+        }
+        if (!info.isDirectory())
+            throw new Error(`Refusing unsupported managed entry: ${path}`);
+        for (const entry of await readdir(path))
+            await visit(join(path, entry));
+    }
+    if (!(await pathExists(root)))
+        return [];
+    await visit(root);
+    return files.sort((left, right) => left.path.localeCompare(right.path));
+}
+function legacyTargets(record, agent) {
+    const root = agentSkillsDirectory(agent);
+    const withinAgent = record.files
+        .filter((file) => isInside(root, file.path) && basename(file.path) === "SKILL.md")
+        .map((file) => dirname(file.path));
+    if (withinAgent.length)
+        return [...new Set(withinAgent)].sort();
+    if (record.targetAgents.length === 1)
+        return [
+            ...new Set(record.files
+                .filter((file) => basename(file.path) === "SKILL.md")
+                .map((file) => dirname(file.path))),
+        ].sort();
+    return [];
+}
+function legacyActivations(installs, existing) {
+    const keys = new Set(existing.map((entry) => `${entry.packageId}\0${entry.agent}`));
+    return installs.flatMap((install) => install.targetAgents.flatMap((agent) => {
+        if (keys.has(`${install.packageId}\0${agent}`))
+            return [];
+        const targets = legacyTargets(install, agent);
+        if (!targets.length)
+            return [];
+        return [
+            {
+                packageId: install.packageId,
+                agent,
+                cacheState: "missing",
+                reviewState: "unreviewed",
+                installationState: "installed",
+                activationState: "active",
+                libraryPath: activationLibraryPath(install.packageId, agent),
+                targets: targets.map((activePath) => ({
+                    activePath,
+                    libraryRelativePath: basename(activePath),
+                })),
+                libraryFiles: [],
+                updatedAt: install.installedAt,
+            },
+        ];
+    }));
+}
+function allActivationRecords(installs, existing) {
+    return [...existing, ...legacyActivations(installs, existing)].sort((left, right) => left.packageId.localeCompare(right.packageId) ||
+        left.agent.localeCompare(right.agent) ||
+        (left.unitId ?? "").localeCompare(right.unitId ?? ""));
+}
+function exactTreeDifferences(expected, actual) {
+    const expectedMap = new Map(expected.map((file) => [file.path, file.sha256]));
+    const actualMap = new Map(actual.map((file) => [file.path, file.sha256]));
+    const missing = [...expectedMap].filter(([path]) => !actualMap.has(path));
+    const modified = [...expectedMap].filter(([path, digest]) => actualMap.get(path) && actualMap.get(path) !== digest);
+    const extra = [...actualMap].filter(([path]) => !expectedMap.has(path));
+    return [
+        ...(missing.length
+            ? [`${missing.length} expected file(s) are missing`]
+            : []),
+        ...(modified.length ? [`${modified.length} managed file(s) changed`] : []),
+        ...(extra.length
+            ? [`${extra.length} untracked file(s) would be affected`]
+            : []),
+    ];
+}
+function expectedActiveFiles(install, targets) {
+    return install.files
+        .filter((file) => targets.some((target) => isInside(target.activePath, file.path)))
+        .map((file) => ({ path: resolve(file.path), sha256: file.sha256 }))
+        .sort((left, right) => left.path.localeCompare(right.path));
+}
+function expectedLibraryFiles(install, targets) {
+    return install.files
+        .flatMap((file) => {
+        const target = targets.find((item) => isInside(item.activePath, file.path));
+        if (!target)
+            return [];
+        return [
+            {
+                path: join(target.libraryRelativePath, relative(target.activePath, file.path))
+                    .split(sep)
+                    .join("/"),
+                sha256: file.sha256,
+            },
+        ];
+    })
+        .sort((left, right) => left.path.localeCompare(right.path));
+}
+async function activeTreeFiles(targets) {
+    const files = await Promise.all(targets.map(async (target) => (await hashTree(target.activePath)).map((file) => ({
+        path: resolve(target.activePath, file.path),
+        sha256: file.sha256,
+    }))));
+    return files
+        .flat()
+        .sort((left, right) => left.path.localeCompare(right.path));
+}
+export async function buildLibraryStateReport() {
+    const state = await readInstallState();
+    const records = allActivationRecords(state.installs, state.activations ?? []);
+    return {
+        generatedAt: new Date().toISOString(),
+        records,
+        counts: {
+            packages: new Set(records.map((record) => record.packageId)).size,
+            downloaded: records.filter((record) => record.cacheState === "downloaded")
+                .length,
+            reviewed: records.filter((record) => record.reviewState === "reviewed")
+                .length,
+            quarantined: records.filter((record) => record.reviewState === "quarantined").length,
+            installed: records.filter((record) => record.installationState === "installed").length,
+            active: records.filter((record) => record.activationState === "active")
+                .length,
+            disabled: records.filter((record) => record.activationState === "disabled").length,
+            removed: records.filter((record) => record.installationState === "removed").length,
+        },
+        migrationPending: records.filter((record) => record.installationState === "installed" &&
+            record.cacheState === "missing").length,
+    };
+}
+export async function planActivationChange(action, packageIds, options = {}) {
+    const packages = [
+        ...new Set(packageIds.map((id) => id.trim()).filter(Boolean)),
+    ];
+    if (!packages.length)
+        throw new Error("At least one package id is required");
+    const state = await readInstallState();
+    const installs = new Map(state.installs.map((install) => [install.packageId, install]));
+    const selectors = packages.map((selector) => {
+        const separator = selector.indexOf("/");
+        return {
+            selector,
+            packageId: separator < 0 ? selector : selector.slice(0, separator),
+            unitId: separator < 0 ? undefined : selector.slice(separator + 1),
+        };
+    });
+    for (const selector of selectors)
+        if (!installs.has(selector.packageId))
+            throw new Error(`Package is not managed by Loadout: ${selector.packageId}`);
+    const records = allActivationRecords(state.installs, state.activations ?? []);
+    const changes = [];
+    const skipped = [];
+    for (const selector of selectors) {
+        const { packageId, unitId } = selector;
+        const candidates = records.filter((record) => record.packageId === packageId &&
+            (!unitId || record.unitId === unitId) &&
+            (!options.agents || options.agents.includes(record.agent)));
+        if (!candidates.length)
+            throw new Error(`No managed skill activation for '${selector.selector}' matches the requested agents`);
+        for (const record of candidates) {
+            const desired = action === "enable" ? "active" : "disabled";
+            if (record.activationState === desired) {
+                skipped.push({
+                    packageId,
+                    ...(record.unitId ? { unitId: record.unitId } : {}),
+                    agent: record.agent,
+                    reason: `already ${desired}`,
+                });
+                continue;
+            }
+            const change = {
+                packageId,
+                ...(record.unitId ? { unitId: record.unitId } : {}),
+                agent: record.agent,
+                from: record.activationState,
+                to: desired,
+                libraryPath: record.libraryPath,
+                targets: record.targets,
+                blockers: [],
+            };
+            const install = installs.get(packageId);
+            if (resolve(record.libraryPath) !==
+                resolve(activationLibraryPath(packageId, record.agent, record.unitId)))
+                change.blockers.push("the library path does not match Loadout's managed path");
+            const validRoots = new Set(install.files
+                .filter((file) => basename(file.path) === "SKILL.md")
+                .map((file) => resolve(dirname(file.path))));
+            if (change.targets.some((target) => !validRoots.has(resolve(target.activePath)) ||
+                target.libraryRelativePath !== basename(target.activePath) ||
+                target.libraryRelativePath === "." ||
+                target.libraryRelativePath === ".." ||
+                /[\\/]/.test(target.libraryRelativePath)))
+                change.blockers.push("one or more activation targets are not backed by the managed install record");
+            if (new Set(change.targets.map((target) => target.libraryRelativePath))
+                .size !== change.targets.length)
+                change.blockers.push("activation targets collide inside the library copy");
+            if (record.reviewState === "quarantined")
+                change.blockers.push("the reviewed library entry is quarantined");
+            if (record.installationState !== "installed")
+                change.blockers.push("the package has been removed");
+            if (action === "disable") {
+                const expected = expectedActiveFiles(install, change.targets);
+                const actual = await activeTreeFiles(change.targets);
+                change.blockers.push(...exactTreeDifferences(expected, actual));
+            }
+            else {
+                if (record.cacheState !== "downloaded" || !record.libraryFiles.length)
+                    change.blockers.push("no complete reviewed-library copy is available");
+                else {
+                    const libraryActual = await hashTree(record.libraryPath);
+                    change.blockers.push(...exactTreeDifferences(record.libraryFiles, libraryActual).map((message) => `library copy: ${message}`));
+                }
+                const occupied = (await Promise.all(change.targets.map((target) => pathExists(target.activePath)))).filter(Boolean).length;
+                if (occupied)
+                    change.blockers.push(`${occupied} active target(s) already exist and would be overwritten`);
+            }
+            changes.push(change);
+        }
+    }
+    const warnings = changes.flatMap((change) => change.blockers.map((blocker) => `${change.packageId}/${change.agent}: ${blocker}`));
+    return {
+        action,
+        packages,
+        ...(options.agents ? { requestedAgents: options.agents } : {}),
+        changes,
+        skipped,
+        blocked: warnings.length > 0,
+        warnings,
+    };
+}
+function activationKey(record) {
+    return `${record.packageId}\0${record.agent}\0${record.unitId ?? ""}`;
+}
+export async function applyActivationChange(plan) {
+    const applied = await runMutationTransaction(async () => {
+        const fresh = await planActivationChange(plan.action, plan.packages, {
+            ...(plan.requestedAgents ? { agents: plan.requestedAgents } : {}),
+        });
+        if (fresh.blocked)
+            throw new Error(fresh.warnings.join("; "));
+        if (!fresh.changes.length)
+            throw new Error(`Nothing to ${plan.action}; every selected activation is already ${plan.action === "enable" ? "active" : "disabled"}`);
+        const state = await readInstallState();
+        const records = allActivationRecords(state.installs, state.activations ?? []);
+        const targets = [
+            ...fresh.changes.flatMap((change) => change.targets.map((target) => target.activePath)),
+            ...(fresh.action === "disable"
+                ? fresh.changes.map((change) => change.libraryPath)
+                : []),
+            installStatePath(),
+        ];
+        return { targets, value: { fresh, state, records } };
+    }, async ({ fresh, state, records }, snapshot) => {
+        const replacements = new Map();
+        const installs = new Map(state.installs.map((install) => [install.packageId, install]));
+        for (const change of fresh.changes) {
+            const current = records.find((record) => activationKey(record) === activationKey(change));
+            if (fresh.action === "disable") {
+                await rm(change.libraryPath, { recursive: true, force: true });
+                await ensureDirectory(change.libraryPath);
+                for (const target of change.targets) {
+                    const destination = join(change.libraryPath, target.libraryRelativePath);
+                    await mkdir(dirname(destination), { recursive: true });
+                    await cp(target.activePath, destination, {
+                        recursive: true,
+                        errorOnExist: true,
+                        force: false,
+                    });
+                }
+                const libraryFiles = await hashTree(change.libraryPath);
+                const copyDifferences = exactTreeDifferences(expectedLibraryFiles(installs.get(change.packageId), change.targets), libraryFiles);
+                if (copyDifferences.length)
+                    throw new Error(`${change.packageId}/${change.agent}: copied library verification failed: ${copyDifferences.join("; ")}`);
+                for (const target of change.targets)
+                    await rm(target.activePath, { recursive: true, force: true });
+                replacements.set(activationKey(change), {
+                    ...current,
+                    cacheState: "downloaded",
+                    activationState: "disabled",
+                    libraryFiles,
+                    updatedAt: new Date().toISOString(),
+                    snapshotId: snapshot.id,
+                });
+            }
+            else {
+                for (const target of change.targets) {
+                    const source = join(change.libraryPath, target.libraryRelativePath);
+                    await mkdir(dirname(target.activePath), { recursive: true });
+                    await cp(source, target.activePath, {
+                        recursive: true,
+                        errorOnExist: true,
+                        force: false,
+                    });
+                }
+                const activeFiles = await activeTreeFiles(change.targets);
+                const copyDifferences = exactTreeDifferences(expectedActiveFiles(installs.get(change.packageId), change.targets), activeFiles);
+                if (copyDifferences.length)
+                    throw new Error(`${change.packageId}/${change.agent}: activated copy verification failed: ${copyDifferences.join("; ")}`);
+                replacements.set(activationKey(change), {
+                    ...current,
+                    activationState: "active",
+                    updatedAt: new Date().toISOString(),
+                    snapshotId: snapshot.id,
+                });
+            }
+        }
+        state.activations = records.map((record) => replacements.get(activationKey(record)) ?? record);
+        await writeInstallState(state);
+    });
+    return applied.snapshotId;
+}
+export function formatLibraryStateReport(report) {
+    if (!report.records.length)
+        return "No Loadout-managed skill activations exist.";
+    return [
+        `Managed library: ${report.counts.packages} package(s), ${report.counts.active} active, ${report.counts.disabled} disabled, ${report.counts.downloaded} cached`,
+        ...(report.migrationPending
+            ? [
+                `Migration pending: ${report.migrationPending} active installation(s) will be cached on first disable.`,
+            ]
+            : []),
+        ...report.records.map((record) => `${record.packageId}${record.unitId ? `/${record.unitId}` : ""} — ${record.agent} — cache:${record.cacheState} review:${record.reviewState} install:${record.installationState} activation:${record.activationState} — ${record.targets.length} target(s)`),
+    ].join("\n");
+}
+export function formatActivationPlan(plan) {
+    return [
+        `${plan.action === "enable" ? "Enable" : "Disable"} plan: ${plan.changes.length} change(s), ${plan.skipped.length} already in desired state`,
+        ...plan.changes.map((change) => `${change.packageId}${change.unitId ? `/${change.unitId}` : ""}/${change.agent}: ${change.from} -> ${change.to} (${change.targets.length} target(s))${change.blockers.length ? ` BLOCKED: ${change.blockers.join("; ")}` : ""}`),
+        ...plan.skipped.map((item) => `${item.packageId}${item.unitId ? `/${item.unitId}` : ""}/${item.agent}: skipped (${item.reason})`),
+        ...(plan.blocked
+            ? ["No changes can be applied until every blocker is resolved."]
+            : []),
+    ].join("\n");
+}