vgxness 1.17.1 → 1.18.0

package/README.md

@@ -8,7 +8,7 @@ This package is proprietary software. The npm package ships inspectable JavaScri
 
 OpenCode is the primary supported provider. Claude setup support is secondary. VGX-managed OpenCode and Claude provider configuration is user-global only; provider config writes require explicit CLI confirmation.
 
-VGXNESS is currently versioned from `package.json` (`1.17.1`). The latest full project health audit is the historical [v1.14.x snapshot](./docs/project-health-audit-v1.14.x.md), which documents the implemented CLI/MCP/SDD control plane, OpenCode-first workflow, release-readiness checks, and the remaining execution/recovery gaps at that point in time. [v1.10.x](./docs/project-health-audit-v1.10.x.md) and [v1.9.1](./docs/project-health-audit-v1.9.1.md) remain historical validation evidence for those releases.
+VGXNESS is currently versioned from `package.json` (`1.17.2`). The latest full project health audit is the historical [v1.14.x snapshot](./docs/project-health-audit-v1.14.x.md), which documents the implemented CLI/MCP/SDD control plane, OpenCode-first workflow, release-readiness checks, and the remaining execution/recovery gaps at that point in time. [v1.10.x](./docs/project-health-audit-v1.10.x.md) and [v1.9.1](./docs/project-health-audit-v1.9.1.md) remain historical validation evidence for those releases.
 
 ## Requirements
 

package/dist/mcp/control-plane.js

@@ -14,6 +14,7 @@ import { SddWorkflowService } from '../sdd/sdd-workflow-service.js';
 import { runBootSkillSeed } from '../skills/boot-seed.js';
 import { SkillIndexService } from '../skills/skill-index-service.js';
 import { SkillRegistryService } from '../skills/skill-registry-service.js';
+import { SkillStatusService } from '../skills/skill-status-service.js';
 import { VerificationPlanService } from '../verification/index.js';
 import { ProviderChangePlanService } from './provider-change-plan.js';
 import { ContextCockpitSnapshotService } from './control-plane-snapshot-service.js';
@@ -86,8 +87,60 @@ export function callVgxTool(call, services) {
             if (services.skillIndex === undefined)
                 return errorEnvelope('validation_failed', 'Skill index service is not available', validated.tool);
             return toEnvelope(validated.tool, services.skillIndex.getIndex(validated.input));
+        case 'vgxness_skill_search':
+            if (services.skills.searchSkills === undefined)
+                return errorEnvelope('validation_failed', 'Skill search service is not available', validated.tool);
+            return toEnvelope(validated.tool, services.skills.searchSkills(validated.input));
+        case 'vgxness_skill_get':
+            if (services.skills.getSkill === undefined)
+                return errorEnvelope('validation_failed', 'Skill get service is not available', validated.tool);
+            return toEnvelope(validated.tool, services.skills.getSkill(validated.input));
+        case 'vgxness_skill_status':
+            if (services.skillStatus === undefined)
+                return errorEnvelope('validation_failed', 'Skill status service is not available', validated.tool);
+            return toEnvelope(validated.tool, services.skillStatus.getStatus(validated.input));
         case 'vgxness_skill_payload':
             return buildSkillPayloadEnvelope(validated.input, services);
+        case 'vgxness_skill_activate':
+            if (services.skills.activateSkill === undefined)
+                return errorEnvelope('validation_failed', 'Skill activation service is not available', validated.tool);
+            return toEnvelope(validated.tool, services.skills.activateSkill(validated.input));
+        case 'vgxness_skill_record_usage':
+            if (services.skills.recordSkillUsage === undefined)
+                return errorEnvelope('validation_failed', 'Skill usage service is not available', validated.tool);
+            return toEnvelope(validated.tool, services.skills.recordSkillUsage(validated.input));
+        case 'vgxness_skill_propose_improvement':
+            if (services.skills.proposeSkillImprovement === undefined)
+                return errorEnvelope('validation_failed', 'Skill improvement proposal service is not available', validated.tool);
+            return toEnvelope(validated.tool, services.skills.proposeSkillImprovement(validated.input));
+        case 'vgxness_skill_list_improvement_proposals':
+            if (services.skills.listSkillImprovementProposals === undefined)
+                return errorEnvelope('validation_failed', 'Skill improvement proposal list service is not available', validated.tool);
+            return toEnvelope(validated.tool, services.skills.listSkillImprovementProposals(validated.input));
+        case 'vgxness_skill_request_evaluation':
+            if (services.skills.requestSkillEvaluation === undefined)
+                return errorEnvelope('validation_failed', 'Skill evaluation request service is not available', validated.tool);
+            return toEnvelope(validated.tool, services.skills.requestSkillEvaluation(validated.input));
+        case 'vgxness_skill_list_evaluations':
+            if (services.skills.listSkillEvaluations === undefined)
+                return errorEnvelope('validation_failed', 'Skill evaluation list service is not available', validated.tool);
+            return toEnvelope(validated.tool, services.skills.listSkillEvaluations(validated.input));
+        case 'vgxness_skill_get_evaluation':
+            if (services.skills.getSkillEvaluationRequest === undefined)
+                return errorEnvelope('validation_failed', 'Skill evaluation get service is not available', validated.tool);
+            return toEnvelope(validated.tool, services.skills.getSkillEvaluationRequest(validated.input));
+        case 'vgxness_skill_create_draft':
+            if (services.skills.createSkillDraft === undefined)
+                return errorEnvelope('validation_failed', 'Skill draft creation service is not available', validated.tool);
+            return toEnvelope(validated.tool, services.skills.createSkillDraft(validated.input));
+        case 'vgxness_skill_update_draft':
+            if (services.skills.updateSkillDraft === undefined)
+                return errorEnvelope('validation_failed', 'Skill draft update service is not available', validated.tool);
+            return toEnvelope(validated.tool, services.skills.updateSkillDraft(validated.input));
+        case 'vgxness_skill_publish_version':
+            if (services.skills.publishSkillVersion === undefined)
+                return errorEnvelope('validation_failed', 'Skill version publication service is not available', validated.tool);
+            return toEnvelope(validated.tool, services.skills.publishSkillVersion(validated.input));
         case 'vgxness_opencode_manager_payload':
             return toEnvelope(validated.tool, services.opencodeManagerPayload.build(validated.input));
         case 'vgxness_opencode_handoff_preview':
@@ -316,6 +369,7 @@ function createServices(database) {
     const agents = new AgentRegistryService(database);
     const skills = new SkillRegistryService(database);
     const skillIndex = new SkillIndexService(skills);
+    const skillStatus = new SkillStatusService(skills, agents);
     const runs = new RunService(database);
     const managerProfiles = new ManagerProfileOverlayService({ agents, overlays: new ManagerProfileOverlayRepository(database) });
     const opencodeManagerPayload = new OpenCodeManagerPayloadService({ agents, managerProfiles, skills });
@@ -329,6 +383,7 @@ function createServices(database) {
         managerProfiles,
         skills,
         skillIndex,
+        skillStatus,
         seedBuiltInSkills: () => runBootSkillSeed(database),
         opencodeManagerPayload,
         opencodeHandoffPreview: new OpenCodeHandoffPreviewService({ managerPayload: opencodeManagerPayload, sdd, providerStatus }),

package/dist/mcp/schema.js

@@ -30,7 +30,20 @@ export const SUPPORTED_VGX_MCP_TOOL_NAMES = [
     'vgxness_manager_profile_get',
     'vgxness_manager_profile_set',
     'vgxness_skill_index',
+    'vgxness_skill_search',
+    'vgxness_skill_get',
+    'vgxness_skill_status',
     'vgxness_skill_payload',
+    'vgxness_skill_activate',
+    'vgxness_skill_record_usage',
+    'vgxness_skill_propose_improvement',
+    'vgxness_skill_list_improvement_proposals',
+    'vgxness_skill_request_evaluation',
+    'vgxness_skill_list_evaluations',
+    'vgxness_skill_get_evaluation',
+    'vgxness_skill_create_draft',
+    'vgxness_skill_update_draft',
+    'vgxness_skill_publish_version',
     'vgxness_opencode_manager_payload',
     'vgxness_opencode_handoff_preview',
     'vgxness_run_list',
@@ -74,7 +87,20 @@ export const EXPOSED_VGX_MCP_TOOL_NAMES = [
     'manager_profile_get',
     'manager_profile_set',
     'skill_index',
+    'skill_search',
+    'skill_get',
+    'skill_status',
     'skill_payload',
+    'skill_activate',
+    'skill_record_usage',
+    'skill_propose_improvement',
+    'skill_list_improvement_proposals',
+    'skill_request_evaluation',
+    'skill_list_evaluations',
+    'skill_get_evaluation',
+    'skill_create_draft',
+    'skill_update_draft',
+    'skill_publish_version',
     'opencode_manager_payload',
     'opencode_handoff_preview',
     'run_list',
@@ -107,6 +133,28 @@ const runStatuses = ['created', 'planned', 'running', 'needs-human', 'completed'
 const finalRunStatuses = ['completed', 'failed', 'blocked', 'cancelled'];
 const runOutcomes = ['success', 'partial', 'failure', 'blocked', 'cancelled'];
 const payloadModes = ['compact', 'verbose'];
+const skillVersionStatuses = ['draft', 'active', 'deprecated', 'archived'];
+const skillImprovementProposalStatuses = ['draft', 'pending-approval', 'approved', 'rejected', 'cancelled', 'applied'];
+const skillEvaluationRequestStatuses = ['requested', 'planned', 'running', 'completed', 'failed', 'cancelled', 'skipped'];
+const skillSourceKinds = ['path', 'url', 'inline'];
+const skillUsageOutcomes = ['selected', 'injected', 'helped', 'failed', 'neutral'];
+const skillAttachmentTargetTypes = ['agent', 'subagent', 'workflow-phase', 'provider-adapter', 'intent-signal'];
+const jsonRecordSchema = z.record(z.string(), z.unknown());
+const skillLifecycleActorSchema = z
+    .object({
+    type: z.enum(['human', 'agent', 'system']),
+    id: z.string().min(1),
+    displayName: z.string().min(1).optional(),
+})
+    .passthrough();
+const skillSourceSchema = z
+    .object({
+    kind: z.enum(skillSourceKinds),
+    path: z.string().min(1).optional(),
+    url: z.string().min(1).optional(),
+    inlineMetadata: jsonRecordSchema.optional(),
+})
+    .passthrough();
 const contextCockpitLevels = ['compact', 'expanded', 'verbose'];
 const providerChangePlanProviders = ['opencode', 'claude', 'antigravity', 'custom'];
 const providerChangePlanTypes = ['opencode-mcp-install', 'claude-mcp-install', 'setup', 'install', 'config-preparation'];
@@ -483,6 +531,34 @@ export const VGX_MCP_TOOL_INPUT_SCHEMAS = {
         scope: z.enum(scopes),
     })
         .strict(),
+    vgxness_skill_search: z
+        .object({
+        project: z.string().min(1),
+        scope: z.enum(scopes).optional(),
+        query: z.string().min(1).optional(),
+        status: z.enum(skillVersionStatuses).optional(),
+        sourceKind: z.enum(skillSourceKinds).optional(),
+        limit: z.number().int().min(1).max(100).optional(),
+    })
+        .passthrough(),
+    vgxness_skill_get: z
+        .object({
+        project: z.string().min(1),
+        scope: z.enum(scopes).optional(),
+        id: z.string().min(1).optional(),
+        name: z.string().min(1).optional(),
+        includeUsage: z.boolean().optional(),
+    })
+        .passthrough(),
+    vgxness_skill_status: z
+        .object({
+        project: z.string().min(1),
+        scope: z.enum(scopes).optional(),
+        provider: z.string().min(1).optional(),
+        mode: z.enum(agentModes).optional(),
+        agent: z.string().min(1).optional(),
+    })
+        .passthrough(),
     vgxness_skill_payload: z
         .object({
         workspaceRoot: z.string().min(1),
@@ -499,6 +575,183 @@ export const VGX_MCP_TOOL_INPUT_SCHEMAS = {
         mode: z.enum(payloadModes).optional(),
     })
         .passthrough(),
+    vgxness_skill_activate: z
+        .object({
+        project: z.string().min(1),
+        scope: z.enum(scopes).optional(),
+        skillId: z.string().min(1).optional(),
+        name: z.string().min(1).optional(),
+        versionId: z.string().min(1).optional(),
+        version: z.string().min(1).optional(),
+        runId: z.string().min(1).optional(),
+        agentId: z.string().min(1).optional(),
+        workflow: z.string().min(1).optional(),
+        phase: z.string().min(1).optional(),
+        providerAdapter: z.string().min(1).optional(),
+        intent: jsonRecordSchema.optional(),
+        reason: z.string().min(1).optional(),
+        workspaceRoot: z.string().min(1).optional(),
+        maxSourceBytes: z.number().int().positive().optional(),
+        mode: z.enum(payloadModes).optional(),
+    })
+        .passthrough(),
+    vgxness_skill_record_usage: z
+        .object({
+        skillId: z.string().min(1),
+        versionId: z.string().min(1).optional(),
+        runId: z.string().min(1).optional(),
+        targetType: z.enum(skillAttachmentTargetTypes).optional(),
+        targetKey: z.string().min(1).optional(),
+        outcome: z.enum(skillUsageOutcomes),
+        notes: z.string().min(1).optional(),
+        workflow: z.string().min(1).optional(),
+        phase: z.string().min(1).optional(),
+        providerAdapter: z.string().min(1).optional(),
+        agentId: z.string().min(1).optional(),
+        intent: jsonRecordSchema.optional(),
+        evidence: jsonRecordSchema.optional(),
+    })
+        .passthrough(),
+    vgxness_skill_propose_improvement: z
+        .object({
+        project: z.string().min(1),
+        scope: z.enum(scopes).optional(),
+        skillId: z.string().min(1).optional(),
+        name: z.string().min(1).optional(),
+        baseVersionId: z.string().min(1).optional(),
+        baseVersion: z.string().min(1).optional(),
+        proposedVersion: z.string().min(1),
+        proposedSource: z
+            .object({
+            kind: z.enum(skillSourceKinds),
+            path: z.string().min(1).optional(),
+            url: z.string().min(1).optional(),
+            inlineMetadata: jsonRecordSchema.optional(),
+        })
+            .passthrough(),
+        proposedCompatibility: jsonRecordSchema.optional(),
+        title: z.string().min(1),
+        problem: z.string().min(1),
+        suggestedChange: z.string().min(1),
+        sourceContext: jsonRecordSchema.optional(),
+        runId: z.string().min(1).optional(),
+        agentId: z.string().min(1).optional(),
+        workflow: z.string().min(1).optional(),
+        phase: z.string().min(1).optional(),
+        providerAdapter: z.string().min(1).optional(),
+        evidenceRefs: z.array(z.string().min(1)).optional(),
+        evidence: jsonRecordSchema.optional(),
+        actor: z.string().min(1).optional(),
+    })
+        .passthrough(),
+    vgxness_skill_list_improvement_proposals: z
+        .object({
+        project: z.string().min(1),
+        scope: z.enum(scopes).optional(),
+        skillId: z.string().min(1).optional(),
+        name: z.string().min(1).optional(),
+        baseVersionId: z.string().min(1).optional(),
+        status: z.enum(skillImprovementProposalStatuses).optional(),
+        runId: z.string().min(1).optional(),
+        agentId: z.string().min(1).optional(),
+        limit: z.number().int().min(1).max(100).optional(),
+    })
+        .passthrough(),
+    vgxness_skill_request_evaluation: z
+        .object({
+        project: z.string().min(1),
+        scope: z.enum(scopes).optional(),
+        skillId: z.string().min(1).optional(),
+        name: z.string().min(1).optional(),
+        versionId: z.string().min(1).optional(),
+        version: z.string().min(1).optional(),
+        scenarioId: z.string().min(1).optional(),
+        proposalId: z.string().min(1).optional(),
+        requestedBy: z.string().min(1),
+        runId: z.string().min(1).optional(),
+        agentId: z.string().min(1).optional(),
+        workflow: z.string().min(1).optional(),
+        phase: z.string().min(1).optional(),
+        providerAdapter: z.string().min(1).optional(),
+        risk: jsonRecordSchema.optional(),
+        preflight: jsonRecordSchema.optional(),
+    })
+        .passthrough(),
+    vgxness_skill_list_evaluations: z
+        .object({
+        project: z.string().min(1),
+        scope: z.enum(scopes).optional(),
+        skillId: z.string().min(1).optional(),
+        name: z.string().min(1).optional(),
+        versionId: z.string().min(1).optional(),
+        scenarioId: z.string().min(1).optional(),
+        proposalId: z.string().min(1).optional(),
+        status: z.enum(skillEvaluationRequestStatuses).optional(),
+        runId: z.string().min(1).optional(),
+        agentId: z.string().min(1).optional(),
+        limit: z.number().int().min(1).max(100).optional(),
+    })
+        .passthrough(),
+    vgxness_skill_get_evaluation: z
+        .object({
+        project: z.string().min(1),
+        scope: z.enum(scopes).optional(),
+        id: z.string().min(1),
+    })
+        .passthrough(),
+    vgxness_skill_create_draft: z
+        .object({
+        project: z.string().min(1),
+        scope: z.enum(scopes).optional(),
+        name: z.string().min(1),
+        description: z.string().min(1),
+        version: z.string().min(1),
+        source: skillSourceSchema,
+        compatibility: jsonRecordSchema.optional(),
+        draftParentVersionId: z.string().min(1).optional(),
+        actor: skillLifecycleActorSchema,
+        reason: z.string().min(1).optional(),
+        runId: z.string().min(1).optional(),
+        agentId: z.string().min(1).optional(),
+        evidence: jsonRecordSchema.optional(),
+        governance: jsonRecordSchema.optional(),
+    })
+        .passthrough(),
+    vgxness_skill_update_draft: z
+        .object({
+        project: z.string().min(1),
+        scope: z.enum(scopes).optional(),
+        skillId: z.string().min(1).optional(),
+        name: z.string().min(1).optional(),
+        versionId: z.string().min(1).optional(),
+        version: z.string().min(1).optional(),
+        source: skillSourceSchema.optional(),
+        compatibility: jsonRecordSchema.optional(),
+        expectedDraftRevision: z.number().int().positive().optional(),
+        actor: skillLifecycleActorSchema,
+        reason: z.string().min(1).optional(),
+        runId: z.string().min(1).optional(),
+        agentId: z.string().min(1).optional(),
+        evidence: jsonRecordSchema.optional(),
+        governance: jsonRecordSchema.optional(),
+    })
+        .passthrough(),
+    vgxness_skill_publish_version: z
+        .object({
+        project: z.string().min(1),
+        scope: z.enum(scopes).optional(),
+        skillId: z.string().min(1).optional(),
+        name: z.string().min(1).optional(),
+        versionId: z.string().min(1).optional(),
+        version: z.string().min(1).optional(),
+        actor: skillLifecycleActorSchema,
+        reason: z.string().min(1),
+        runId: z.string().min(1).optional(),
+        agentId: z.string().min(1).optional(),
+        evidence: jsonRecordSchema.optional(),
+        governance: jsonRecordSchema.optional(),
+    })
+        .passthrough(),
     vgxness_opencode_manager_payload: z
         .object({
         project: z.string().min(1),

package/dist/mcp/stdio-server.js

@@ -69,6 +69,12 @@ function descriptionForTool(publicToolName) {
         return 'Read-only context cockpit for start/resume/recovery; returns latest restorable session plus bounded memory previews without traces, provider config writes, repository writes, runs, artifacts, or session mutations.';
     if (publicToolName === 'skill_index')
         return 'Read-only skill registry index for a project and scope; returns SkillIndexOutput without provider config writes, native skill file writes, URL fetches, usage records, startup refresh, or plugin refresh.';
+    if (publicToolName === 'skill_create_draft')
+        return 'Creates a draft skill version and lifecycle event without publishing, activation, provider config writes, or native skill installation.';
+    if (publicToolName === 'skill_update_draft')
+        return 'Updates only draft skill versions with optional optimistic revision checking; rejects active, deprecated, or archived version mutation.';
+    if (publicToolName === 'skill_publish_version')
+        return 'Publishes a draft skill version as active/current with explicit actor and reason; publication is not activation, SDD acceptance, or correctness proof.';
     if (publicToolName === 'sdd_cockpit')
         return 'Agent-callable read-only SDD cockpit summary; returns phase metadata/readModel without artifact bodies or state changes and preserves explicit human acceptance semantics. Use it to decide the next safe SDD action or blocker.';
     if (publicToolName === 'sdd_continue')