vgxness 1.17.2 → 1.18.0

package/dist/skills/skill-payload.js

@@ -92,9 +92,9 @@ function toPayloadItem(skill, index, workspaceRoot, maxSourceBytes, mode) {
 function loadContent(skill, workspaceRoot, maxSourceBytes, mode) {
     if (skill.source.kind === 'inline') {
         if (skill.content !== undefined)
-            return contentPayload(skill.content, skill.summary, inlineRef(skill), mode);
+            return inlineContentPayload(skill.content, skill.summary, inlineRef(skill), maxSourceBytes, mode);
         if (skill.summary !== undefined)
-            return contentPayload(skill.summary, skill.summary, inlineRef(skill), mode);
+            return inlineContentPayload(skill.summary, skill.summary, inlineRef(skill), maxSourceBytes, mode);
         return { status: 'unavailable', unavailableReason: 'inline_content_missing' };
     }
     if (skill.source.kind === 'url')
@@ -125,6 +125,13 @@ function loadContent(skill, workspaceRoot, maxSourceBytes, mode) {
         return { status: 'unavailable', unavailableReason: 'path_read_failed' };
     }
 }
+function inlineContentPayload(value, summary, ref, maxSourceBytes, mode) {
+    const byteSize = Buffer.byteLength(value, 'utf8');
+    if (mode === 'verbose' && byteSize > maxSourceBytes) {
+        return { status: 'unavailable', unavailableReason: 'inline_too_large', byteSize, ...(ref === undefined ? {} : { ref }) };
+    }
+    return contentPayload(value, summary, ref, mode, byteSize);
+}
 function compactPathContent(skill, byteSize) {
     const metadataHash = stringMetadata(skill.sourceMetadata.sha256) ?? stringMetadata(skill.sourceMetadata.hash) ?? stringMetadata(skill.sourceMetadata.contentHash);
     const metadataSummary = skill.summary ?? stringMetadata(skill.sourceMetadata.summary);

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

@@ -1,4 +1,5 @@
 import { AgentRepository } from '../agents/repositories/agents.js';
+import { SkillEvaluationRequestRepository, } from './repositories/skill-evaluation-requests.js';
 import { SkillEvaluationScenarioRepository, } from './repositories/skill-evaluation-scenarios.js';
 import { SkillImprovementProposalRepository, } from './repositories/skill-improvement-proposals.js';
 import { SkillRepository, } from './repositories/skills.js';
@@ -9,11 +10,13 @@ export class SkillRegistryService {
     skills;
     proposals;
     evaluationScenarios;
+    evaluationRequests;
     constructor(database) {
         this.database = database;
         this.skills = new SkillRepository(database);
         this.proposals = new SkillImprovementProposalRepository(database);
         this.evaluationScenarios = new SkillEvaluationScenarioRepository(database);
+        this.evaluationRequests = new SkillEvaluationRequestRepository(database);
     }
     registerSkill(input) {
         return this.skills.register(input);
@@ -30,8 +33,218 @@ export class SkillRegistryService {
     recordSkillUsage(input) {
         return this.skills.recordUsage(input);
     }
-    getSkill(id) {
-        return this.skills.getById(id);
+    createSkillDraft(input) {
+        const created = this.skills.createDraft(input);
+        if (!created.ok)
+            return created;
+        return ok({
+            kind: 'skill-draft-created',
+            version: 1,
+            project: input.project,
+            scope: input.scope ?? 'project',
+            skill: created.value.skill,
+            draft: created.value.version,
+            event: created.value.event,
+            safety: lifecycleSafety(false),
+            warnings: ['Draft creation does not publish, activate, approve, or human-accept a skill version.'],
+        });
+    }
+    updateSkillDraft(input) {
+        const updated = this.skills.updateDraft(input);
+        if (!updated.ok)
+            return updated;
+        return ok({
+            kind: 'skill-draft-updated',
+            version: 1,
+            project: input.project,
+            scope: input.scope ?? 'project',
+            skill: updated.value.skill,
+            draft: updated.value.version,
+            event: updated.value.event,
+            safety: lifecycleSafety(false),
+            warnings: ['Draft updates are limited to draft versions and do not mutate active, deprecated, or archived versions.'],
+        });
+    }
+    publishSkillVersion(input) {
+        if (!input.reason.trim())
+            return validationFailure('Publish reason is required');
+        const published = this.skills.publishVersion(input);
+        if (!published.ok)
+            return published;
+        return ok({
+            kind: 'skill-version-published',
+            version: 1,
+            project: input.project,
+            scope: input.scope ?? 'project',
+            skill: published.value.skill,
+            published: published.value.version,
+            previousCurrentVersionId: published.value.previousCurrentVersionId,
+            event: published.value.event,
+            safety: lifecycleSafety(true),
+            warnings: ['Publication updates the current active version; it is not skill activation, SDD artifact acceptance, or correctness proof.'],
+        });
+    }
+    activateSkill(input) {
+        const scope = input.scope ?? 'project';
+        if ((input.skillId === undefined || input.skillId.trim().length === 0) && (input.name === undefined || input.name.trim().length === 0)) {
+            return validationFailure('Either skill id or name is required');
+        }
+        const skill = input.skillId !== undefined ? this.skills.getById(input.skillId) : this.skills.getByName(input.project, scope, input.name ?? '');
+        if (!skill.ok)
+            return skill;
+        if (skill.value.project !== input.project || skill.value.scope !== scope)
+            return validationFailure('Skill does not belong to the requested project/scope');
+        const version = this.activationVersion(skill.value.id, input);
+        if (!version.ok)
+            return version;
+        if (version.value.status !== 'active')
+            return validationFailure(`Skill ${skill.value.name} version ${version.value.version} is ${version.value.status}, not active`);
+        const summary = stringMetadata(version.value.source.inlineMetadata?.summary);
+        const content = stringMetadata(version.value.source.inlineMetadata?.content);
+        const resolvedSkill = {
+            skillId: skill.value.id,
+            name: skill.value.name,
+            description: skill.value.description,
+            versionId: version.value.id,
+            version: version.value.version,
+            source: version.value.source,
+            sourceMetadata: version.value.source.inlineMetadata ?? {},
+            attachmentSources: [{ kind: 'attachment', targetType: 'intent-signal', targetKey: 'manual-skill-activation', reason: input.reason ?? 'skill activation requested' }],
+        };
+        if (summary !== undefined)
+            resolvedSkill.summary = summary;
+        if (content !== undefined)
+            resolvedSkill.content = content;
+        const resolution = {
+            context: {
+                project: input.project,
+                scope,
+                ...(input.agentId === undefined ? {} : { agentId: input.agentId }),
+                ...(input.workflow === undefined ? {} : { workflow: input.workflow }),
+                ...(input.phase === undefined ? {} : { phase: input.phase }),
+                ...(input.providerAdapter === undefined ? {} : { providerAdapter: input.providerAdapter }),
+                ...(input.runId === undefined ? {} : { runId: input.runId }),
+                ...(input.intent?.signals !== undefined && Array.isArray(input.intent.signals) ? { intentSignals: input.intent.signals.filter((value) => typeof value === 'string') } : {}),
+            },
+            skills: [resolvedSkill],
+            skipped: [],
+            skillDiagnostics: {
+                provider: input.providerAdapter ?? 'unknown',
+                providerState: input.providerAdapter === 'opencode' ? 'preview-only' : 'unknown',
+                summary: { declared: 1, resolved: 1, skipped: 0, warnings: input.providerAdapter === 'opencode' ? 2 : 0, errors: 0 },
+                skills: [
+                    {
+                        name: skill.value.name,
+                        registryState: 'active',
+                        activeVersion: version.value.version,
+                        payloadState: 'preview-only',
+                        providerState: input.providerAdapter === 'opencode' ? 'preview-only' : 'unknown',
+                        included: true,
+                        reason: null,
+                        attachments: { declared: 1, resolved: 1, missing: 0 },
+                    },
+                ],
+                diagnostics: input.providerAdapter === 'opencode'
+                    ? [
+                        {
+                            code: 'SKILL_PROVIDER_PREVIEW_ONLY',
+                            severity: 'info',
+                            message: 'Skill activation payload is preview/context-only for OpenCode and does not install or native-load skills.',
+                            details: { provider: 'opencode', providerState: 'preview-only' },
+                        },
+                        {
+                            code: 'SKILL_PROVIDER_NATIVE_UNSUPPORTED',
+                            severity: 'info',
+                            message: 'OpenCode native skill loading is not implemented by VGXNESS for this activation payload.',
+                            details: { provider: 'opencode', providerState: 'preview-only', installsNativeSkills: false, mutatesProviderConfig: false },
+                        },
+                    ]
+                    : [],
+            },
+            warnings: ['Skill activation is an audit and payload preparation event only; it is not approval, publication, or proof of correctness.'],
+            usageRecorded: 0,
+        };
+        const payload = buildSkillInjectionPayload(resolution, {
+            ...(input.workspaceRoot === undefined ? {} : { workspaceRoot: input.workspaceRoot }),
+            ...(input.maxSourceBytes === undefined ? {} : { maxSourceBytes: input.maxSourceBytes }),
+            ...(input.mode === undefined ? {} : { mode: input.mode }),
+        });
+        if (!payload.ok)
+            return payload;
+        const recordInput = {
+            project: input.project,
+            scope,
+            skillId: skill.value.id,
+            versionId: version.value.id,
+            ...(input.runId === undefined ? {} : { runId: input.runId }),
+            ...(input.agentId === undefined ? {} : { agentId: input.agentId }),
+            ...(input.workflow === undefined ? {} : { workflow: input.workflow }),
+            ...(input.phase === undefined ? {} : { phase: input.phase }),
+            ...(input.providerAdapter === undefined ? {} : { providerAdapter: input.providerAdapter }),
+            ...(input.intent === undefined ? {} : { intent: input.intent }),
+            ...(input.reason === undefined ? {} : { reason: input.reason }),
+            payloadMetadata: { itemCount: payload.value.items.length, mode: input.mode ?? 'compact', providerAgnostic: true },
+        };
+        const activation = this.skills.recordActivation(recordInput);
+        if (!activation.ok)
+            return activation;
+        return ok({
+            kind: 'skill-activation',
+            version: 1,
+            project: input.project,
+            scope,
+            activation: activation.value,
+            skill: { id: skill.value.id, name: skill.value.name, description: skill.value.description, versionId: version.value.id, version: version.value.version },
+            payload: payload.value,
+            safety: {
+                providerConfigWrites: false,
+                opencodeWrites: false,
+                nativeSkillFileWrites: false,
+                providerExecution: false,
+                approval: false,
+                publication: false,
+                correctnessProof: false,
+            },
+            warnings: ['Skill activation is not approval, publication, or proof of correctness.', ...payload.value.warnings],
+        });
+    }
+    getSkill(input) {
+        if (typeof input === 'string')
+            return this.skills.getById(input);
+        const scope = input.scope ?? 'project';
+        if ((input.id === undefined || input.id.trim().length === 0) && (input.name === undefined || input.name.trim().length === 0)) {
+            return validationFailure('Either skill id or name is required');
+        }
+        const base = input.id !== undefined ? this.skills.getById(input.id) : this.skills.getByName(input.project, scope, input.name ?? '');
+        if (!base.ok)
+            return base;
+        if (base.value.project !== input.project || base.value.scope !== scope)
+            return validationFailure('Skill does not belong to the requested project/scope');
+        const details = this.skills.getDetails(base.value.id);
+        if (!details.ok)
+            return details;
+        return ok({
+            kind: 'skill-get',
+            version: 1,
+            project: input.project,
+            scope,
+            skill: {
+                id: details.value.id,
+                project: details.value.project,
+                scope: details.value.scope,
+                name: details.value.name,
+                description: details.value.description,
+                currentVersionId: details.value.currentVersionId ?? null,
+                createdAt: details.value.createdAt,
+                updatedAt: details.value.updatedAt,
+                currentVersion: details.value.currentVersion ?? null,
+                versions: details.value.versions,
+                attachments: details.value.attachments,
+                usage: input.includeUsage === true ? details.value.usage.slice(0, 25) : [],
+            },
+            diagnostics: [],
+            safety: readOnlySafety(),
+        });
     }
     getSkillByName(project, scope, name) {
         return this.skills.getByName(project, scope, name);
@@ -42,6 +255,39 @@ export class SkillRegistryService {
     listSkills(filters = {}) {
         return this.skills.list(filters);
     }
+    searchSkills(input) {
+        const scope = input.scope ?? 'project';
+        const limit = normalizeLimit(input.limit);
+        const searchInput = { project: input.project, scope, limit };
+        if (input.query !== undefined)
+            searchInput.query = input.query;
+        if (input.status !== undefined)
+            searchInput.status = input.status;
+        if (input.sourceKind !== undefined)
+            searchInput.sourceKind = input.sourceKind;
+        const skills = this.skills.search(searchInput);
+        if (!skills.ok)
+            return skills;
+        const matched = this.skills.countSearchMatches(searchInput);
+        if (!matched.ok)
+            return matched;
+        return ok({
+            kind: 'skills-search',
+            version: 1,
+            project: input.project,
+            scope,
+            filters: {
+                query: input.query?.trim() || null,
+                status: input.status ?? null,
+                sourceKind: input.sourceKind ?? null,
+                limit,
+            },
+            totals: { matched: matched.value, returned: skills.value.length },
+            skills: skills.value,
+            diagnostics: [],
+            safety: readOnlySafety(),
+        });
+    }
     listSkillVersions(skillId) {
         return this.skills.listVersions(skillId);
     }
@@ -51,8 +297,106 @@ export class SkillRegistryService {
     createSkillImprovementProposal(input) {
         return this.proposals.create(input);
     }
-    listSkillImprovementProposals(filters = {}) {
-        return this.proposals.list(filters);
+    proposeSkillImprovement(input) {
+        const scope = input.scope ?? 'project';
+        if ((input.skillId === undefined || input.skillId.trim().length === 0) && (input.name === undefined || input.name.trim().length === 0)) {
+            return validationFailure('Either skillId or name is required');
+        }
+        if (input.baseVersionId !== undefined && input.baseVersion !== undefined)
+            return validationFailure('Use either baseVersionId or baseVersion, not both');
+        if (!input.title.trim())
+            return validationFailure('Proposal title is required');
+        if (!input.problem.trim())
+            return validationFailure('Proposal problem statement is required');
+        if (!input.suggestedChange.trim())
+            return validationFailure('Proposal suggested change is required');
+        const skill = input.skillId !== undefined ? this.skills.getById(input.skillId) : this.skills.getByName(input.project, scope, input.name ?? '');
+        if (!skill.ok)
+            return skill;
+        if (skill.value.project !== input.project || skill.value.scope !== scope)
+            return validationFailure('Skill does not belong to the requested project/scope');
+        const baseVersion = resolveProposalBaseVersion(this.skills, skill.value.id, input.baseVersionId, input.baseVersion);
+        if (!baseVersion.ok)
+            return baseVersion;
+        const sourceSignal = {
+            ...(input.sourceContext ?? {}),
+            ...(input.workflow === undefined ? {} : { workflow: input.workflow }),
+            ...(input.phase === undefined ? {} : { phase: input.phase }),
+            ...(input.providerAdapter === undefined ? {} : { providerAdapter: input.providerAdapter }),
+            ...(input.actor === undefined ? {} : { actor: input.actor }),
+        };
+        const evidence = input.evidenceRefs === undefined ? (input.evidence ?? {}) : { ...(input.evidence ?? {}), refs: input.evidenceRefs };
+        const proposal = this.proposals.create({
+            skillId: skill.value.id,
+            baseVersionId: baseVersion.value.id,
+            proposedVersion: input.proposedVersion,
+            proposedSource: input.proposedSource,
+            ...(input.proposedCompatibility === undefined ? {} : { proposedCompatibility: input.proposedCompatibility }),
+            rationale: `${input.problem.trim()}\n\nSuggested change: ${input.suggestedChange.trim()}`,
+            sourceSignal,
+            title: input.title.trim(),
+            problem: input.problem.trim(),
+            suggestedChange: input.suggestedChange.trim(),
+            ...(input.runId === undefined ? {} : { sourceRunId: input.runId }),
+            ...(input.agentId === undefined ? {} : { sourceAgentId: input.agentId }),
+            evidence,
+        });
+        if (!proposal.ok)
+            return proposal;
+        return ok({
+            kind: 'skill-improvement-proposal',
+            version: 1,
+            project: input.project,
+            scope,
+            skill: { id: skill.value.id, name: skill.value.name, versionId: baseVersion.value.id, version: baseVersion.value.version },
+            proposal: proposal.value,
+            safety: proposalSafety(),
+            warnings: ['Improvement proposal creation is non-destructive and does not mutate active or published skill content.'],
+        });
+    }
+    listSkillImprovementProposals(input = {}) {
+        if (isSkillListImprovementProposalsInput(input)) {
+            const scope = input.scope ?? 'project';
+            const limit = normalizeLimit(input.limit);
+            let skillId = input.skillId;
+            if (skillId === undefined && input.name !== undefined) {
+                const skill = this.skills.getByName(input.project, scope, input.name);
+                if (!skill.ok)
+                    return skill;
+                skillId = skill.value.id;
+            }
+            const proposals = this.proposals.list({
+                project: input.project,
+                scope,
+                ...(skillId === undefined ? {} : { skillId }),
+                ...(input.baseVersionId === undefined ? {} : { baseVersionId: input.baseVersionId }),
+                ...(input.status === undefined ? {} : { status: input.status }),
+                ...(input.runId === undefined ? {} : { runId: input.runId }),
+                ...(input.agentId === undefined ? {} : { agentId: input.agentId }),
+                limit,
+            });
+            if (!proposals.ok)
+                return proposals;
+            return ok({
+                kind: 'skill-improvement-proposals-list',
+                version: 1,
+                project: input.project,
+                scope,
+                filters: {
+                    skillId: skillId ?? null,
+                    name: input.name ?? null,
+                    baseVersionId: input.baseVersionId ?? null,
+                    status: input.status ?? null,
+                    runId: input.runId ?? null,
+                    agentId: input.agentId ?? null,
+                    limit,
+                },
+                totals: { returned: proposals.value.length, bounded: true },
+                proposals: proposals.value,
+                safety: { ...proposalSafety(), readOnly: true },
+            });
+        }
+        return this.proposals.list(input);
     }
     getSkillImprovementProposal(id) {
         return this.proposals.getById(id);
@@ -84,11 +428,217 @@ export class SkillRegistryService {
     listSkillEvaluationResults(filters = {}) {
         return this.evaluationScenarios.listResults(filters);
     }
+    createSkillEvaluationRequest(input) {
+        return this.evaluationRequests.create(input);
+    }
+    requestSkillEvaluation(input) {
+        const scope = input.scope ?? 'project';
+        if ((input.skillId === undefined || input.skillId.trim().length === 0) && (input.name === undefined || input.name.trim().length === 0)) {
+            return validationFailure('Either skillId or name is required');
+        }
+        if (input.versionId !== undefined && input.version !== undefined)
+            return validationFailure('Use either versionId or version, not both');
+        const skill = input.skillId !== undefined ? this.skills.getById(input.skillId) : this.skills.getByName(input.project, scope, input.name ?? '');
+        if (!skill.ok)
+            return skill;
+        if (skill.value.project !== input.project || skill.value.scope !== scope)
+            return validationFailure('Skill does not belong to the requested project/scope');
+        let versionId = input.versionId;
+        if (versionId === undefined && input.version !== undefined) {
+            const version = this.skills.getVersionBySkillVersion(skill.value.id, input.version);
+            if (!version.ok)
+                return version;
+            versionId = version.value.id;
+        }
+        const request = this.evaluationRequests.create({
+            project: input.project,
+            scope,
+            skillId: skill.value.id,
+            requestedBy: input.requestedBy,
+            ...(versionId === undefined ? {} : { versionId }),
+            ...(input.scenarioId === undefined ? {} : { scenarioId: input.scenarioId }),
+            ...(input.proposalId === undefined ? {} : { proposalId: input.proposalId }),
+            ...(input.runId === undefined ? {} : { runId: input.runId }),
+            ...(input.agentId === undefined ? {} : { agentId: input.agentId }),
+            ...(input.workflow === undefined ? {} : { workflow: input.workflow }),
+            ...(input.phase === undefined ? {} : { phase: input.phase }),
+            ...(input.providerAdapter === undefined ? {} : { providerAdapter: input.providerAdapter }),
+            ...(input.risk === undefined ? {} : { risk: input.risk }),
+            ...(input.preflight === undefined ? {} : { preflight: input.preflight }),
+        });
+        if (!request.ok)
+            return request;
+        return ok({
+            kind: 'skill-evaluation-request',
+            version: 1,
+            project: input.project,
+            scope,
+            request: request.value,
+            safety: evaluationRequestSafety(),
+            warnings: ['Skill evaluation request creation only queues a request; it does not execute an evaluator or provider.'],
+        });
+    }
+    listSkillEvaluationRequests(filters) {
+        return this.evaluationRequests.list(filters);
+    }
+    listSkillEvaluations(input) {
+        const scope = input.scope ?? 'project';
+        const limit = normalizeLimit(input.limit);
+        let skillId = input.skillId;
+        if (skillId === undefined && input.name !== undefined) {
+            const skill = this.skills.getByName(input.project, scope, input.name);
+            if (!skill.ok)
+                return skill;
+            skillId = skill.value.id;
+        }
+        const requests = this.evaluationRequests.list({
+            project: input.project,
+            scope,
+            ...(skillId === undefined ? {} : { skillId }),
+            ...(input.versionId === undefined ? {} : { versionId: input.versionId }),
+            ...(input.scenarioId === undefined ? {} : { scenarioId: input.scenarioId }),
+            ...(input.proposalId === undefined ? {} : { proposalId: input.proposalId }),
+            ...(input.status === undefined ? {} : { status: input.status }),
+            ...(input.runId === undefined ? {} : { runId: input.runId }),
+            ...(input.agentId === undefined ? {} : { agentId: input.agentId }),
+            limit,
+        });
+        if (!requests.ok)
+            return requests;
+        return ok({
+            kind: 'skill-evaluations-list',
+            version: 1,
+            project: input.project,
+            scope,
+            filters: {
+                skillId: skillId ?? null,
+                name: input.name ?? null,
+                versionId: input.versionId ?? null,
+                scenarioId: input.scenarioId ?? null,
+                proposalId: input.proposalId ?? null,
+                status: input.status ?? null,
+                runId: input.runId ?? null,
+                agentId: input.agentId ?? null,
+                limit,
+            },
+            totals: { returned: requests.value.length, bounded: true },
+            requests: requests.value,
+            safety: { ...evaluationRequestSafety(), readOnly: true },
+        });
+    }
+    getSkillEvaluationRequest(input) {
+        if (typeof input === 'string')
+            return this.evaluationRequests.getById(input);
+        const scope = input.scope ?? 'project';
+        const request = this.evaluationRequests.getById(input.id);
+        if (!request.ok)
+            return request;
+        if (request.value.project !== input.project || request.value.scope !== scope)
+            return validationFailure('Skill evaluation request does not belong to the requested project/scope');
+        return request;
+    }
     buildSkillPayload(input, options = {}) {
         const resolution = this.resolveSkills(input);
         return resolution.ok ? buildSkillInjectionPayload(resolution.value, options) : resolution;
     }
+    activationVersion(skillId, input) {
+        if (input.versionId !== undefined) {
+            const version = this.skills.getVersion(input.versionId);
+            if (!version.ok)
+                return version;
+            if (version.value.skillId !== skillId)
+                return validationFailure('Skill version must belong to the activated skill');
+            return version;
+        }
+        if (input.version !== undefined)
+            return this.skills.getVersionBySkillVersion(skillId, input.version);
+        const details = this.skills.getDetails(skillId);
+        if (!details.ok)
+            return details;
+        if (details.value.currentVersion === undefined)
+            return validationFailure(`Skill ${details.value.name} has no current version`);
+        return ok(details.value.currentVersion);
+    }
     close() {
         this.database.close();
     }
 }
+function isSkillListImprovementProposalsInput(input) {
+    return typeof input.project === 'string';
+}
+function readOnlySafety() {
+    return {
+        readOnly: true,
+        providerConfigWrites: false,
+        opencodeWrites: false,
+        nativeSkillFileWrites: false,
+        urlFetches: false,
+        usageRecords: false,
+        providerExecution: false,
+    };
+}
+function proposalSafety() {
+    return {
+        providerConfigWrites: false,
+        opencodeWrites: false,
+        nativeSkillFileWrites: false,
+        activeSkillContentMutation: false,
+        providerExecution: false,
+    };
+}
+function evaluationRequestSafety() {
+    return {
+        providerConfigWrites: false,
+        opencodeWrites: false,
+        nativeSkillFileWrites: false,
+        providerExecution: false,
+        evaluatorExecution: false,
+        runStarted: false,
+    };
+}
+function lifecycleSafety(activeVersionUpdated) {
+    return {
+        providerConfigWrites: false,
+        opencodeWrites: false,
+        nativeSkillFileWrites: false,
+        providerExecution: false,
+        activation: false,
+        approval: false,
+        humanAcceptance: false,
+        activeVersionUpdated,
+    };
+}
+function resolveProposalBaseVersion(skills, skillId, baseVersionId, baseVersion) {
+    if (baseVersionId !== undefined) {
+        const version = skills.getVersion(baseVersionId);
+        if (!version.ok)
+            return version;
+        if (version.value.skillId !== skillId)
+            return validationFailure('Base version must belong to the proposed skill');
+        return version;
+    }
+    if (baseVersion !== undefined)
+        return skills.getVersionBySkillVersion(skillId, baseVersion);
+    const details = skills.getDetails(skillId);
+    if (!details.ok)
+        return details;
+    if (details.value.currentVersion === undefined)
+        return validationFailure(`Skill ${details.value.name} has no current version`);
+    return ok(details.value.currentVersion);
+}
+function normalizeLimit(limit) {
+    if (limit === undefined)
+        return 25;
+    if (!Number.isSafeInteger(limit) || limit < 1)
+        return 25;
+    return Math.min(limit, 100);
+}
+function stringMetadata(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value : undefined;
+}
+function ok(value) {
+    return { ok: true, value };
+}
+function validationFailure(message) {
+    return { ok: false, error: { code: 'validation_failed', message } };
+}

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

@@ -39,6 +39,9 @@ export class SkillStatusService {
         const declared = agentItems.reduce((sum, item) => sum + item.declaredSkills.length, 0);
         const resolved = agentItems.reduce((sum, item) => sum + item.resolvedSkills.length, 0);
         const missing = agentItems.reduce((sum, item) => sum + item.missingSkills.length, 0);
+        const v2Counts = this.skills.skills.getV2Counts(input.project, scope);
+        if (!v2Counts.ok)
+            return v2Counts;
         return ok({
             kind: 'skills-status',
             version: 1,
@@ -65,7 +68,7 @@ export class SkillStatusService {
                 current: skill.currentVersionId !== null && skill.currentVersion !== null,
                 providerAvailable: false,
             })),
-            registry: { skills: registry.value },
+            registry: { skills: registry.value, v2: v2Counts.value },
             agents: { modes, declared, resolved, missing, items: agentItems },
             diagnostics,
             safety: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vgxness",
-  "version": "1.17.2",
+  "version": "1.18.0",
   "description": "CLI and MCP control plane for guided AI-agent workflows, SDD, memory, and OpenCode setup.",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {