vgxness 1.20.5 → 1.20.7

package/dist/skills/skill-resolver.js

@@ -1,368 +1 @@
-import { resolveAgentSelector } from '../agents/agent-selector-resolver.js';
-import { canonicalDefaultAgentName } from '../agents/canonical-agent-manifest.js';
-import { normalizeSddPhaseInput } from '../sdd/schema.js';
-import { skillLookupContexts } from './personal-skills.js';
-export class SkillResolver {
-    skills;
-    agents;
-    constructor(skills, agents) {
-        this.skills = skills;
-        this.agents = agents;
-    }
-    resolve(input) {
-        const agent = this.resolveAgent(input);
-        if (!agent.ok)
-            return agent;
-        const contextProject = input.project ?? agent.value.agent?.project;
-        const contextScope = input.scope ?? agent.value.agent?.scope ?? 'project';
-        const targetCandidates = this.targetCandidates(input, agent.value.agent);
-        const attachmentCandidates = this.attachmentCandidates(targetCandidates);
-        if (!attachmentCandidates.ok)
-            return attachmentCandidates;
-        const candidates = [...this.agentSkillCandidates(agent.value.agent), ...attachmentCandidates.value];
-        const bySkill = new Map();
-        const skipped = [];
-        const diagnosticSkills = new Map();
-        const diagnostics = [];
-        const provider = input.providerAdapter ?? 'unknown';
-        const providerState = provider === 'opencode' ? 'preview-only' : 'unknown';
-        for (const candidate of candidates) {
-            const skillResult = this.resolveSkill(candidate, contextProject, contextScope);
-            if (!skillResult.ok) {
-                skipped.push(skippedResolution(candidate.source, skillResult.error.message, candidate.skillId, candidate.name));
-                addSkippedDiagnostic(diagnosticSkills, diagnostics, candidate, skillResult.error.message, providerState, skillResult.error.code === 'not_found' ? 'unknown' : 'inactive');
-                continue;
-            }
-            const versionResult = this.resolveVersion(skillResult.value, candidate.versionId);
-            if (!versionResult.ok) {
-                skipped.push({ source: candidate.source, skillId: skillResult.value.id, name: skillResult.value.name, reason: versionResult.error.message });
-                addSkippedDiagnostic(diagnosticSkills, diagnostics, candidate, versionResult.error.message, providerState, 'inactive', skillResult.value.name);
-                continue;
-            }
-            const existing = bySkill.get(skillResult.value.id);
-            if (existing !== undefined) {
-                existing.sources.push(candidate.source);
-                const status = diagnosticSkills.get(skillResult.value.name);
-                if (status !== undefined) {
-                    status.attachments.declared += 1;
-                    status.attachments.resolved += 1;
-                }
-                continue;
-            }
-            bySkill.set(skillResult.value.id, { skill: skillResult.value, version: versionResult.value, sources: [candidate.source] });
-            diagnosticSkills.set(skillResult.value.name, {
-                name: skillResult.value.name,
-                registryState: 'active',
-                activeVersion: versionResult.value.version,
-                payloadState: 'preview-only',
-                providerState,
-                included: true,
-                reason: null,
-                attachments: { declared: 1, resolved: 1, missing: 0 },
-            });
-        }
-        if (providerState === 'preview-only') {
-            diagnostics.push({
-                code: 'SKILL_PROVIDER_PREVIEW_ONLY',
-                severity: 'info',
-                message: 'Skill payload is preview/context-only for OpenCode and does not install or native-load skills.',
-                details: { provider, providerState },
-            });
-            diagnostics.push({
-                code: 'SKILL_PROVIDER_NATIVE_UNSUPPORTED',
-                severity: 'info',
-                message: 'OpenCode native skill loading is not implemented by VGXNESS for this payload.',
-                details: { provider, providerState, installsNativeSkills: false, mutatesProviderConfig: false },
-            });
-        }
-        let usageRecorded = 0;
-        if (input.runId !== undefined && input.recordUsage !== undefined) {
-            for (const resolved of bySkill.values()) {
-                const usage = this.recordResolvedUsage(resolved, input.runId, input.recordUsage);
-                if (!usage.ok)
-                    return usage;
-                usageRecorded += 1;
-            }
-        }
-        return ok({
-            context: {
-                ...(contextProject !== undefined ? { project: contextProject } : {}),
-                ...(contextScope !== undefined ? { scope: contextScope } : {}),
-                ...(agent.value.agent?.id !== undefined ? { agentId: agent.value.agent.id } : {}),
-                ...(agent.value.agent?.name !== undefined ? { agentName: agent.value.agent.name } : {}),
-                ...(input.workflow !== undefined ? { workflow: input.workflow } : {}),
-                ...(input.phase !== undefined ? { phase: input.phase } : {}),
-                ...(input.intentSignals !== undefined && input.intentSignals.length > 0 ? { intentSignals: normalizedIntentSignals(input.intentSignals) } : {}),
-                ...(input.providerAdapter !== undefined ? { providerAdapter: input.providerAdapter } : {}),
-                ...(input.runId !== undefined ? { runId: input.runId } : {}),
-            },
-            skills: [...bySkill.values()].map(toResolvedSkill),
-            skipped,
-            skillDiagnostics: buildDiagnosticsSummary(provider, providerState, diagnosticSkills, diagnostics),
-            ...(agent.value.warning !== undefined ? { warnings: [agent.value.warning] } : {}),
-            usageRecorded,
-        });
-    }
-    resolveAgent(input) {
-        if (input.agentId !== undefined) {
-            if (input.project === undefined) {
-                const byId = this.agents.getById(input.agentId);
-                return byId.ok ? ok({ agent: byId.value }) : byId;
-            }
-            const selected = resolveAgentSelector({ selector: input.agentId, project: input.project, scope: input.scope ?? 'project' }, { getById: (id) => this.agents.getById(id), getByName: (project, scope, name) => this.agents.getByName(project, scope, name) });
-            if (selected.ok)
-                return ok({ agent: selected.value.agent, ...(selected.value.warning !== undefined ? { warning: selected.value.warning } : {}) });
-            if (selected.error.code !== 'not_found')
-                return selected;
-            const fallback = this.resolveAgentNameFallback(input);
-            if (fallback.ok && fallback.value.agent !== undefined) {
-                const warning = `AGENT_SELECTOR_PROVIDER_ALIAS_FALLBACK: selector "${input.agentId}" did not match a VGXNESS registry agent; resolved display/provider name to canonical agent "${fallback.value.agent.name}" (${fallback.value.agent.id}).`;
-                return ok({ agent: fallback.value.agent, warning });
-            }
-            return selected;
-        }
-        if (input.agentName === undefined)
-            return ok({});
-        if (input.project === undefined)
-            return validationFailure('--project is required when resolving by agent name');
-        return this.resolveAgentNameFallback(input);
-    }
-    resolveAgentNameFallback(input) {
-        if (input.project === undefined)
-            return validationFailure('--project is required when resolving by agent name');
-        for (const name of providerAgentNameCandidates(input.agentName, input.agentId)) {
-            const selected = resolveAgentSelector({ selector: name, project: input.project, scope: input.scope ?? 'project' }, { getById: (id) => this.agents.getById(id), getByName: (project, scope, agentName) => this.agents.getByName(project, scope, agentName) });
-            if (selected.ok)
-                return ok({ agent: selected.value.agent });
-            if (selected.error.code !== 'not_found')
-                return selected;
-        }
-        if (input.agentName === undefined)
-            return ok({});
-        const exact = this.agents.getByName(input.project, input.scope ?? 'project', input.agentName);
-        return exact.ok ? ok({ agent: exact.value }) : exact;
-    }
-    targetCandidates(input, agent) {
-        const targets = [];
-        if (agent !== undefined) {
-            targets.push({ targetType: agent.mode, targetKey: agent.id });
-            targets.push({ targetType: agent.mode, targetKey: agent.name });
-            targets.push({ targetType: agent.mode, targetKey: `${agent.project}/${agent.scope}/${agent.name}` });
-        }
-        const phases = phaseTargetKeys(input.workflow, input.phase);
-        if (input.workflow !== undefined) {
-            for (const phase of phases)
-                targets.push({ targetType: 'workflow-phase', targetKey: `${input.workflow}:${phase}` });
-        }
-        for (const phase of phases)
-            targets.push({ targetType: 'workflow-phase', targetKey: phase });
-        for (const signal of normalizedIntentSignals(input.intentSignals))
-            targets.push({ targetType: 'intent-signal', targetKey: signal });
-        if (input.providerAdapter !== undefined)
-            targets.push({ targetType: 'provider-adapter', targetKey: input.providerAdapter });
-        return dedupeTargets(targets);
-    }
-    agentSkillCandidates(agent) {
-        if (agent === undefined)
-            return [];
-        return agent.skills.map((name) => ({
-            name,
-            source: { kind: 'agent-definition', targetType: agent.mode, targetKey: agent.id, reason: 'agent.skills' },
-        }));
-    }
-    attachmentCandidates(targets) {
-        const attachments = this.skills.listAttachmentsForTargets(targets);
-        if (!attachments.ok)
-            return attachments;
-        return ok(attachments.value.map((attachment) => {
-            const candidate = { skillId: attachment.skillId, source: attachmentSource(attachment) };
-            if (attachment.versionId !== undefined)
-                candidate.versionId = attachment.versionId;
-            return candidate;
-        }));
-    }
-    resolveSkill(candidate, project, scope) {
-        if (candidate.skillId !== undefined)
-            return this.skills.getById(candidate.skillId);
-        if (candidate.name === undefined)
-            return validationFailure('Resolved skill candidate has neither skill id nor name');
-        if (project === undefined)
-            return validationFailure(`Skill ${candidate.name} needs a project context`);
-        let lastMissing;
-        for (const context of skillLookupContexts(project, scope)) {
-            const result = this.skills.getByName(context.project, context.scope, candidate.name);
-            if (result.ok)
-                return result;
-            if (result.error.code !== 'not_found')
-                return result;
-            lastMissing = result;
-        }
-        return lastMissing ?? this.skills.getByName(project, scope, candidate.name);
-    }
-    resolveVersion(skill, candidateVersionId) {
-        const versionId = candidateVersionId ?? skill.currentVersionId;
-        if (versionId === undefined)
-            return validationFailure(`Skill ${skill.name} has no current version`);
-        const version = this.skills.getVersion(versionId);
-        if (!version.ok)
-            return version;
-        if (version.value.status !== 'active')
-            return validationFailure(`Skill ${skill.name} version ${version.value.version} is ${version.value.status}, not active`);
-        return version;
-    }
-    recordResolvedUsage(resolved, runId, outcome) {
-        const firstAttachment = resolved.sources.find((source) => source.kind === 'attachment');
-        const input = {
-            skillId: resolved.skill.id,
-            versionId: resolved.version.id,
-            runId,
-            outcome,
-            notes: `skill resolution v1 ${outcome}`,
-        };
-        if (firstAttachment?.targetType !== undefined && firstAttachment.targetKey !== undefined) {
-            input.targetType = firstAttachment.targetType;
-            input.targetKey = firstAttachment.targetKey;
-        }
-        return this.skills.recordUsage(input);
-    }
-}
-function toResolvedSkill(value) {
-    const sourceMetadata = value.version.source.inlineMetadata ?? {};
-    const summary = stringMetadata(sourceMetadata.summary);
-    const content = stringMetadata(sourceMetadata.content);
-    return {
-        skillId: value.skill.id,
-        name: value.skill.name,
-        description: value.skill.description,
-        versionId: value.version.id,
-        version: value.version.version,
-        source: value.version.source,
-        sourceMetadata,
-        ...(summary !== undefined ? { summary } : {}),
-        ...(content !== undefined ? { content } : {}),
-        attachmentSources: value.sources,
-    };
-}
-function attachmentSource(attachment) {
-    const reason = stringMetadata(attachment.metadata.reason);
-    return {
-        kind: 'attachment',
-        targetType: attachment.targetType,
-        targetKey: attachment.targetKey,
-        ...(reason !== undefined ? { reason } : {}),
-    };
-}
-function dedupeTargets(targets) {
-    const seen = new Set();
-    return targets.filter((target) => {
-        const key = `${target.targetType}:${target.targetKey}`;
-        if (seen.has(key))
-            return false;
-        seen.add(key);
-        return true;
-    });
-}
-function phaseTargetKeys(workflow, phase) {
-    if (phase === undefined)
-        return [];
-    if (!isSddWorkflow(workflow))
-        return [phase];
-    const normalized = normalizeSddPhaseInput(phase);
-    if (normalized === 'apply-progress')
-        return ['apply-progress', 'apply'];
-    return normalized === undefined || normalized === phase ? [phase] : [normalized, phase];
-}
-function isSddWorkflow(workflow) {
-    return workflow?.trim().toLowerCase() === 'sdd';
-}
-function normalizedIntentSignals(signals) {
-    return [...new Set((signals ?? []).map((signal) => signal.trim().toLowerCase()).filter(Boolean))];
-}
-function providerAgentNameCandidates(agentName, agentId) {
-    const candidates = [];
-    const add = (value) => {
-        const normalized = value?.trim();
-        if (normalized === undefined || normalized.length === 0 || candidates.includes(normalized))
-            return;
-        candidates.push(normalized);
-    };
-    add(agentName);
-    add(slugAgentDisplayName(agentName));
-    if (isProviderManagerAlias(agentId) || isProviderManagerAlias(agentName))
-        add(canonicalDefaultAgentName);
-    return candidates;
-}
-function slugAgentDisplayName(value) {
-    const normalized = value
-        ?.trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '');
-    return normalized === undefined || normalized.length === 0 ? undefined : normalized;
-}
-function isProviderManagerAlias(value) {
-    const normalized = slugAgentDisplayName(value);
-    return normalized === 'main-manager' || normalized === 'vgxness-manager' || normalized === 'vgxness-main-manager';
-}
-function stringMetadata(value) {
-    return typeof value === 'string' && value.trim() ? value : undefined;
-}
-function skippedResolution(source, reason, skillId, name) {
-    const skipped = { source, reason };
-    if (skillId !== undefined)
-        skipped.skillId = skillId;
-    if (name !== undefined)
-        skipped.name = name;
-    return skipped;
-}
-function addSkippedDiagnostic(statuses, diagnostics, candidate, reason, providerState, registryState, resolvedName) {
-    const name = resolvedName ?? candidate.name ?? candidate.skillId ?? 'unknown-skill';
-    const code = candidate.source.kind === 'attachment' && candidate.skillId !== undefined && registryState === 'unknown'
-        ? 'SKILL_ATTACHMENT_MISSING'
-        : registryState === 'unknown'
-            ? 'SKILL_UNKNOWN'
-            : 'SKILL_INACTIVE';
-    statuses.set(name, {
-        name,
-        registryState,
-        activeVersion: null,
-        payloadState: 'unavailable',
-        providerState,
-        included: false,
-        reason,
-        attachments: { declared: 1, resolved: 0, missing: 1 },
-    });
-    diagnostics.push({
-        code,
-        severity: 'warning',
-        skill: name,
-        message: code === 'SKILL_ATTACHMENT_MISSING'
-            ? `Skill attachment references ${name}, but the registry skill could not be resolved.`
-            : code === 'SKILL_UNKNOWN'
-                ? `Skill ${name} is not registered for the requested project/scope and was not included.`
-                : `Skill ${name} is registered but has no active resolvable version and was not included.`,
-        details: { registryState, payloadState: 'unavailable', providerState, reason },
-    });
-}
-function buildDiagnosticsSummary(provider, providerState, statuses, diagnostics) {
-    const skills = [...statuses.values()];
-    return {
-        provider,
-        providerState,
-        summary: {
-            declared: skills.length,
-            resolved: skills.filter((skill) => skill.included).length,
-            skipped: skills.filter((skill) => !skill.included).length,
-            warnings: diagnostics.filter((diagnostic) => diagnostic.severity === 'warning').length,
-            errors: diagnostics.filter((diagnostic) => diagnostic.severity === 'error').length,
-        },
-        skills,
-        diagnostics,
-    };
-}
-function ok(value) {
-    return { ok: true, value };
-}
-function validationFailure(message) {
-    return { ok: false, error: { code: 'validation_failed', message } };
-}
+export * from '../application/skills/skill-resolver.js';

package/dist/skills/skill-seed-service.js

@@ -1,242 +1 @@
-import { readFileSync } from 'node:fs';
-import { SkillRegistryService } from './skill-registry-service.js';
-const defaultManifestPath = new URL('../../seeds/skills/skill-seed-v1.json', import.meta.url);
-const registryBoundaryText = 'registry/context skill content only';
-const forbiddenMetadataKeys = ['path', 'url', 'sourcePath', 'sourceUrl', 'skills.paths', 'installPath', 'generatedPath', 'remoteUrl'];
-export class SkillSeedService {
-    database;
-    registry;
-    constructor(database) {
-        this.database = database;
-        this.registry = new SkillRegistryService(database);
-    }
-    seedFromDefaultManifest(path = defaultManifestPath) {
-        try {
-            return this.seedFromManifest(JSON.parse(readFileSync(path, 'utf8')));
-        }
-        catch (cause) {
-            return fail('Failed to load skill seed manifest', cause);
-        }
-    }
-    seedFromManifest(manifest) {
-        const validation = validateManifest(manifest);
-        if (!validation.ok)
-            return validation;
-        const existingNames = new Map();
-        const existingVersions = new Map();
-        const existingAttachments = new Map();
-        for (const seed of manifest.skills) {
-            const existing = this.registry.getSkillByName(manifest.project, manifest.scope, seed.name);
-            existingNames.set(seed.name, existing.ok);
-            if (existing.ok) {
-                const details = this.registry.getSkillDetails(existing.value.id);
-                if (!details.ok)
-                    return details;
-                existingVersions.set(seed.name, details.value.versions.some((version) => version.version === seed.version));
-                for (const attachment of details.value.attachments)
-                    existingAttachments.set(`${seed.name}:${attachment.targetType}:${attachment.targetKey}`, true);
-            }
-        }
-        const transaction = this.database.transaction(() => {
-            const skillVersionIds = new Map();
-            let skillsCreated = 0;
-            let skillsUpdated = 0;
-            let versionsCreated = 0;
-            let versionsSkipped = 0;
-            let attachmentsCreated = 0;
-            let attachmentsSkipped = 0;
-            for (const seed of manifest.skills) {
-                const skill = this.registry.registerSkill({ project: manifest.project, scope: manifest.scope, name: seed.name, description: seed.description });
-                if (!skill.ok)
-                    throw new SeedLoadError(skill.error);
-                if (existingNames.get(seed.name))
-                    skillsUpdated += 1;
-                else
-                    skillsCreated += 1;
-                const existingVersion = existingVersions.get(seed.name) === true;
-                const version = this.registry.addSkillVersion({
-                    skillId: skill.value.id,
-                    version: seed.version,
-                    source: { kind: 'inline', inlineMetadata: { ...seed.metadata, content: seed.content, seededBy: 'vgxness' } },
-                    compatibility: compatibilityFor(seed, manifest.attachments),
-                    activate: true,
-                });
-                if (!version.ok)
-                    throw new SeedLoadError(version.error);
-                skillVersionIds.set(seed.name, version.value.id);
-                if (existingVersion)
-                    versionsSkipped += 1;
-                else
-                    versionsCreated += 1;
-            }
-            for (const attachment of manifest.attachments) {
-                const skill = this.registry.getSkillByName(manifest.project, manifest.scope, attachment.skill);
-                if (!skill.ok)
-                    throw new SeedLoadError(skill.error);
-                const targetType = attachmentTargetType(attachment);
-                const targetKey = attachmentTargetKey(attachment);
-                const key = `${attachment.skill}:${targetType}:${targetKey}`;
-                const attachInput = {
-                    skillId: skill.value.id,
-                    targetType,
-                    targetKey,
-                    metadata: attachmentMetadata(attachment),
-                };
-                const versionId = skillVersionIds.get(attachment.skill);
-                const attached = this.registry.attachSkill(versionId === undefined ? attachInput : { ...attachInput, versionId });
-                if (!attached.ok)
-                    throw new SeedLoadError(attached.error);
-                if (existingAttachments.get(key))
-                    attachmentsSkipped += 1;
-                else
-                    attachmentsCreated += 1;
-            }
-            return {
-                manifestVersion: manifest.version,
-                skillsCreated,
-                skillsUpdated,
-                versionsCreated,
-                versionsSkipped,
-                attachmentsCreated,
-                attachmentsSkipped,
-                diagnostics: [
-                    {
-                        level: 'info',
-                        code: 'SKILL_SEED_REGISTRY_CONTEXT_ONLY',
-                        message: 'Seeded VGXNESS registry/context skills only; no provider-native skill installation was performed.',
-                    },
-                ],
-            };
-        });
-        if (!transaction.ok && transaction.error.cause instanceof SeedLoadError)
-            return { ok: false, error: transaction.error.cause.failure };
-        return transaction;
-    }
-}
-function validateManifest(manifest) {
-    if (manifest.version !== 1)
-        return validationFailure('Skill seed manifest version must be 1');
-    if (!manifest.project?.trim())
-        return validationFailure('Skill seed manifest project is required');
-    if (manifest.scope !== 'project' && manifest.scope !== 'personal')
-        return validationFailure('Skill seed manifest scope must be project or personal');
-    if (!Array.isArray(manifest.skills))
-        return validationFailure('Skill seed manifest skills must be an array');
-    if (!Array.isArray(manifest.attachments))
-        return validationFailure('Skill seed manifest attachments must be an array');
-    const names = new Set();
-    for (const skill of manifest.skills) {
-        const validation = validateSkillSeed(skill);
-        if (!validation.ok)
-            return validation;
-        if (names.has(skill.name))
-            return validationFailure(`Duplicate skill seed name: ${skill.name}`);
-        names.add(skill.name);
-    }
-    const attachments = new Set();
-    for (const attachment of manifest.attachments) {
-        const validation = validateAttachmentSeed(attachment, names);
-        if (!validation.ok)
-            return validation;
-        const key = `${attachmentTargetType(attachment)}:${attachmentTargetKey(attachment)}:${attachment.skill}`;
-        if (attachments.has(key))
-            return validationFailure(`Duplicate skill seed attachment: ${key}`);
-        attachments.add(key);
-    }
-    return { ok: true, value: undefined };
-}
-function validateSkillSeed(skill) {
-    if (!skill.name?.trim())
-        return validationFailure('Skill seed name is required');
-    if (!skill.description?.trim())
-        return validationFailure(`Skill seed ${skill.name} description is required`);
-    if (!skill.version?.trim())
-        return validationFailure(`Skill seed ${skill.name} version is required`);
-    if (!skill.content?.trim())
-        return validationFailure(`Skill seed ${skill.name} inline content is required`);
-    if (!skill.content.includes(registryBoundaryText))
-        return validationFailure(`Skill seed ${skill.name} must declare registry/context-only boundary`);
-    return rejectUnsupportedNativeInputs(skill.name, skill.metadata);
-}
-function validateAttachmentSeed(attachment, names) {
-    if (attachment.targetType !== undefined && !isSkillAttachmentTargetType(attachment.targetType))
-        return validationFailure(`Skill seed attachment targetType is invalid: ${String(attachment.targetType)}`);
-    const targetType = attachmentTargetType(attachment);
-    if (targetType === 'workflow-phase') {
-        if (!attachment.workflow?.trim())
-            return validationFailure('Skill seed attachment workflow is required');
-        if (!attachment.phase?.trim())
-            return validationFailure('Skill seed attachment phase is required');
-    }
-    else if (!attachment.targetKey?.trim()) {
-        return validationFailure(`Skill seed attachment targetKey is required for ${targetType}`);
-    }
-    if (!attachment.skill?.trim())
-        return validationFailure('Skill seed attachment skill is required');
-    if (!names.has(attachment.skill))
-        return validationFailure(`Skill seed attachment references unknown skill: ${attachment.skill}`);
-    return rejectUnsupportedNativeInputs(attachment.skill, attachment.metadata);
-}
-function rejectUnsupportedNativeInputs(name, metadata) {
-    if (metadata === undefined)
-        return { ok: true, value: undefined };
-    for (const key of Object.keys(metadata)) {
-        if (forbiddenMetadataKeys.includes(key))
-            return validationFailure(`Skill seed ${name} cannot include provider-native or remote field: ${key}`);
-    }
-    const encoded = JSON.stringify(metadata);
-    if (/https?:\/\//i.test(encoded))
-        return validationFailure(`Skill seed ${name} cannot include URL or remote skill loading metadata`);
-    if (/skills\.paths|\.opencode|SKILL\.md|generated/i.test(encoded))
-        return validationFailure(`Skill seed ${name} cannot include provider-native install metadata`);
-    return { ok: true, value: undefined };
-}
-function compatibilityFor(seed, attachments) {
-    const matching = attachments.filter((attachment) => attachment.skill === seed.name);
-    return {
-        targets: [...new Set(matching.map(attachmentTargetType))],
-        adapters: ['opencode'],
-        workflows: [...new Set(matching.map((attachment) => attachment.workflow).filter((workflow) => workflow !== undefined))],
-        phases: [...new Set(matching.map((attachment) => attachment.phase).filter((phase) => phase !== undefined))],
-    };
-}
-function attachmentMetadata(attachment) {
-    const metadata = {
-        ...(attachment.metadata ?? {}),
-        ...(attachment.order !== undefined ? { order: attachment.order } : {}),
-        seededBy: 'vgxness',
-        targetType: attachmentTargetType(attachment),
-        targetKey: attachmentTargetKey(attachment),
-    };
-    if (attachment.workflow !== undefined)
-        metadata.workflow = attachment.workflow;
-    if (attachment.phase !== undefined)
-        metadata.phase = attachment.phase;
-    return metadata;
-}
-function attachmentTargetType(attachment) {
-    return attachment.targetType ?? 'workflow-phase';
-}
-function attachmentTargetKey(attachment) {
-    const targetType = attachmentTargetType(attachment);
-    return targetType === 'workflow-phase' ? `${attachment.workflow}:${attachment.phase}` : attachment.targetKey ?? '';
-}
-function isSkillAttachmentTargetType(value) {
-    return value === 'agent' || value === 'subagent' || value === 'workflow-phase' || value === 'provider-adapter' || value === 'intent-signal';
-}
-function validationFailure(message) {
-    return { ok: false, error: { code: 'validation_failed', message } };
-}
-function fail(message, cause) {
-    const error = { code: 'validation_failed', message };
-    if (cause !== undefined)
-        error.cause = cause;
-    return { ok: false, error };
-}
-class SeedLoadError extends Error {
-    failure;
-    constructor(failure) {
-        super(failure.message);
-        this.failure = failure;
-    }
-}
+export * from '../application/skills/skill-seed-service.js';