vgxness 1.17.2 → 1.18.0

package/dist/mcp/validation.js

@@ -14,6 +14,12 @@ const runOutcomes = ['success', 'partial', 'failure', 'blocked', 'cancelled'];
 const permissionDecisions = ['allow', 'ask', 'deny'];
 const payloadModes = ['compact', 'verbose'];
 const contextCockpitLevels = ['compact', 'expanded', '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 providerChangePlanProviders = ['opencode', 'claude', 'antigravity', 'custom'];
 const providerChangePlanTypes = ['opencode-mcp-install', 'claude-mcp-install', 'setup', 'install', 'config-preparation'];
 const providerInstallTargets = ['user-global'];
@@ -86,8 +92,34 @@ export function validateVgxMcpToolCall(call) {
             return validationSuccess(tool.value, validateManagerProfileSetInput(input, tool.value));
         case 'vgxness_skill_index':
             return validationSuccess(tool.value, validateSkillIndexInput(input, tool.value));
+        case 'vgxness_skill_search':
+            return validationSuccess(tool.value, validateSkillSearchInput(input, tool.value));
+        case 'vgxness_skill_get':
+            return validationSuccess(tool.value, validateSkillGetInput(input, tool.value));
+        case 'vgxness_skill_status':
+            return validationSuccess(tool.value, validateSkillStatusInput(input, tool.value));
         case 'vgxness_skill_payload':
             return validationSuccess(tool.value, validateSkillPayloadInput(input, tool.value));
+        case 'vgxness_skill_activate':
+            return validationSuccess(tool.value, validateSkillActivateInput(input, tool.value));
+        case 'vgxness_skill_record_usage':
+            return validationSuccess(tool.value, validateSkillRecordUsageInput(input, tool.value));
+        case 'vgxness_skill_propose_improvement':
+            return validationSuccess(tool.value, validateSkillProposeImprovementInput(input, tool.value));
+        case 'vgxness_skill_list_improvement_proposals':
+            return validationSuccess(tool.value, validateSkillListImprovementProposalsInput(input, tool.value));
+        case 'vgxness_skill_request_evaluation':
+            return validationSuccess(tool.value, validateSkillRequestEvaluationInput(input, tool.value));
+        case 'vgxness_skill_list_evaluations':
+            return validationSuccess(tool.value, validateSkillListEvaluationsInput(input, tool.value));
+        case 'vgxness_skill_get_evaluation':
+            return validationSuccess(tool.value, validateSkillGetEvaluationInput(input, tool.value));
+        case 'vgxness_skill_create_draft':
+            return validationSuccess(tool.value, validateSkillCreateDraftInput(input, tool.value));
+        case 'vgxness_skill_update_draft':
+            return validationSuccess(tool.value, validateSkillUpdateDraftInput(input, tool.value));
+        case 'vgxness_skill_publish_version':
+            return validationSuccess(tool.value, validateSkillPublishVersionInput(input, tool.value));
         case 'vgxness_opencode_manager_payload':
             return validationSuccess(tool.value, validateOpenCodeManagerPayloadInput(input, tool.value));
         case 'vgxness_opencode_handoff_preview':
@@ -601,6 +633,97 @@ function validateSkillIndexInput(input, tool) {
         return scope;
     return { ok: true, value: { project: project.value, scope: scope.value } };
 }
+function validateSkillSearchInput(input, tool) {
+    const record = inputRecord(input, tool, ['project', 'scope', 'query', 'status', 'sourceKind', 'limit']);
+    if (!record.ok)
+        return record;
+    const project = readNonEmptyString(record.value, 'project', tool);
+    if (!project.ok)
+        return project;
+    const result = { project: project.value };
+    const scope = readOptionalOneOf(record.value, 'scope', scopes, tool);
+    if (!scope.ok)
+        return scope;
+    if (scope.value !== undefined)
+        result.scope = scope.value;
+    const query = readOptionalNonEmptyString(record.value, 'query', tool);
+    if (!query.ok)
+        return query;
+    if (query.value !== undefined)
+        result.query = query.value;
+    const status = readOptionalOneOf(record.value, 'status', skillVersionStatuses, tool);
+    if (!status.ok)
+        return status;
+    if (status.value !== undefined)
+        result.status = status.value;
+    const sourceKind = readOptionalOneOf(record.value, 'sourceKind', skillSourceKinds, tool);
+    if (!sourceKind.ok)
+        return sourceKind;
+    if (sourceKind.value !== undefined)
+        result.sourceKind = sourceKind.value;
+    if (record.value.limit !== undefined) {
+        const limit = record.value.limit;
+        if (typeof limit !== 'number' || !Number.isSafeInteger(limit) || limit < 1 || limit > 100)
+            return validationFailure('limit must be an integer between 1 and 100', tool);
+        result.limit = limit;
+    }
+    return { ok: true, value: result };
+}
+function validateSkillGetInput(input, tool) {
+    const record = inputRecord(input, tool, ['project', 'scope', 'id', 'name', 'includeUsage']);
+    if (!record.ok)
+        return record;
+    const project = readNonEmptyString(record.value, 'project', tool);
+    if (!project.ok)
+        return project;
+    const result = { project: project.value };
+    const scope = readOptionalOneOf(record.value, 'scope', scopes, tool);
+    if (!scope.ok)
+        return scope;
+    if (scope.value !== undefined)
+        result.scope = scope.value;
+    const id = readOptionalNonEmptyString(record.value, 'id', tool);
+    if (!id.ok)
+        return id;
+    if (id.value !== undefined)
+        result.id = id.value;
+    const name = readOptionalNonEmptyString(record.value, 'name', tool);
+    if (!name.ok)
+        return name;
+    if (name.value !== undefined)
+        result.name = name.value;
+    if (result.id === undefined && result.name === undefined)
+        return validationFailure('Either id or name is required', tool);
+    if (record.value.includeUsage !== undefined) {
+        if (typeof record.value.includeUsage !== 'boolean')
+            return validationFailure('includeUsage must be boolean', tool);
+        result.includeUsage = record.value.includeUsage;
+    }
+    return { ok: true, value: result };
+}
+function validateSkillStatusInput(input, tool) {
+    const record = inputRecord(input, tool, ['project', 'scope', 'provider', 'mode', 'agent']);
+    if (!record.ok)
+        return record;
+    const project = readNonEmptyString(record.value, 'project', tool);
+    if (!project.ok)
+        return project;
+    const result = { project: project.value };
+    const scope = readOptionalOneOf(record.value, 'scope', scopes, tool);
+    if (!scope.ok)
+        return scope;
+    if (scope.value !== undefined)
+        result.scope = scope.value;
+    const mode = readOptionalOneOf(record.value, 'mode', agentModes, tool);
+    if (!mode.ok)
+        return mode;
+    if (mode.value !== undefined)
+        result.mode = mode.value;
+    const copied = copyOptionalStrings(result, record.value, tool, ['provider', 'agent']);
+    if (!copied.ok)
+        return copied;
+    return { ok: true, value: result };
+}
 function validateSessionStartInput(input, tool) {
     const record = inputRecord(input, tool, ['id', 'project', 'directory']);
     if (!record.ok)
@@ -787,6 +910,483 @@ function validateSkillPayloadInput(input, tool) {
     }
     return { ok: true, value: result };
 }
+function validateSkillActivateInput(input, tool) {
+    const record = inputRecord(input, tool, [
+        'project',
+        'scope',
+        'skillId',
+        'name',
+        'versionId',
+        'version',
+        'runId',
+        'agentId',
+        'workflow',
+        'phase',
+        'providerAdapter',
+        'intent',
+        'reason',
+        'workspaceRoot',
+        'maxSourceBytes',
+        'mode',
+    ]);
+    if (!record.ok)
+        return record;
+    const project = readNonEmptyString(record.value, 'project', tool);
+    if (!project.ok)
+        return project;
+    const result = { project: project.value };
+    const copied = copyOptionalStrings(result, record.value, tool, [
+        'skillId',
+        'name',
+        'versionId',
+        'version',
+        'runId',
+        'agentId',
+        'workflow',
+        'phase',
+        'providerAdapter',
+        'reason',
+        'workspaceRoot',
+    ]);
+    if (!copied.ok)
+        return copied;
+    if (result.skillId === undefined && result.name === undefined)
+        return validationFailure('Either skillId or name is required', tool);
+    if (result.versionId !== undefined && result.version !== undefined)
+        return validationFailure('Use either versionId or version, not both', tool);
+    const scope = readOptionalOneOf(record.value, 'scope', scopes, tool);
+    if (!scope.ok)
+        return scope;
+    if (scope.value !== undefined)
+        result.scope = scope.value;
+    const mode = readOptionalOneOf(record.value, 'mode', payloadModes, tool);
+    if (!mode.ok)
+        return mode;
+    if (mode.value !== undefined)
+        result.mode = mode.value;
+    const intent = readOptionalJsonObject(record.value, 'intent', tool);
+    if (!intent.ok)
+        return intent;
+    if (intent.value !== undefined)
+        result.intent = intent.value;
+    if (record.value.maxSourceBytes !== undefined) {
+        const maxSourceBytes = record.value.maxSourceBytes;
+        if (typeof maxSourceBytes !== 'number' || !Number.isSafeInteger(maxSourceBytes) || maxSourceBytes <= 0)
+            return validationFailure('maxSourceBytes must be a positive safe integer', tool);
+        result.maxSourceBytes = maxSourceBytes;
+    }
+    return { ok: true, value: result };
+}
+function validateSkillRecordUsageInput(input, tool) {
+    const record = inputRecord(input, tool, [
+        'skillId',
+        'versionId',
+        'runId',
+        'targetType',
+        'targetKey',
+        'outcome',
+        'notes',
+        'workflow',
+        'phase',
+        'providerAdapter',
+        'agentId',
+        'intent',
+        'evidence',
+    ]);
+    if (!record.ok)
+        return record;
+    const skillId = readNonEmptyString(record.value, 'skillId', tool);
+    if (!skillId.ok)
+        return skillId;
+    const outcome = readRequiredOneOf(record.value, 'outcome', skillUsageOutcomes, tool);
+    if (!outcome.ok)
+        return outcome;
+    const result = { skillId: skillId.value, outcome: outcome.value };
+    const copied = copyOptionalStrings(result, record.value, tool, ['versionId', 'runId', 'targetKey', 'notes', 'workflow', 'phase', 'providerAdapter', 'agentId']);
+    if (!copied.ok)
+        return copied;
+    const targetType = readOptionalOneOf(record.value, 'targetType', skillAttachmentTargetTypes, tool);
+    if (!targetType.ok)
+        return targetType;
+    if (targetType.value !== undefined)
+        result.targetType = targetType.value;
+    if (result.targetType !== undefined && result.targetKey === undefined)
+        return validationFailure('targetKey is required when targetType is set', tool);
+    if (result.targetType === undefined && result.targetKey !== undefined)
+        return validationFailure('targetType is required when targetKey is set', tool);
+    const intent = readOptionalJsonObject(record.value, 'intent', tool);
+    if (!intent.ok)
+        return intent;
+    if (intent.value !== undefined)
+        result.intent = intent.value;
+    const evidence = readOptionalJsonObject(record.value, 'evidence', tool);
+    if (!evidence.ok)
+        return evidence;
+    if (evidence.value !== undefined)
+        result.evidence = evidence.value;
+    return { ok: true, value: result };
+}
+function validateSkillProposeImprovementInput(input, tool) {
+    const record = inputRecord(input, tool, [
+        'project',
+        'scope',
+        'skillId',
+        'name',
+        'baseVersionId',
+        'baseVersion',
+        'proposedVersion',
+        'proposedSource',
+        'proposedCompatibility',
+        'title',
+        'problem',
+        'suggestedChange',
+        'sourceContext',
+        'runId',
+        'agentId',
+        'workflow',
+        'phase',
+        'providerAdapter',
+        'evidenceRefs',
+        'evidence',
+        'actor',
+    ]);
+    if (!record.ok)
+        return record;
+    const result = {};
+    const copied = copyRequiredStrings(result, record.value, tool, ['project', 'proposedVersion', 'title', 'problem', 'suggestedChange']);
+    if (!copied.ok)
+        return copied;
+    const optional = copyOptionalStrings(result, record.value, tool, ['skillId', 'name', 'baseVersionId', 'baseVersion', 'runId', 'agentId', 'workflow', 'phase', 'providerAdapter', 'actor']);
+    if (!optional.ok)
+        return optional;
+    if (result.skillId === undefined && result.name === undefined)
+        return validationFailure('Either skillId or name is required', tool);
+    if (result.baseVersionId !== undefined && result.baseVersion !== undefined)
+        return validationFailure('Use either baseVersionId or baseVersion, not both', tool);
+    const scope = readOptionalOneOf(record.value, 'scope', scopes, tool);
+    if (!scope.ok)
+        return scope;
+    if (scope.value !== undefined)
+        result.scope = scope.value;
+    const source = readSkillSource(record.value, 'proposedSource', tool);
+    if (!source.ok)
+        return source;
+    result.proposedSource = source.value;
+    const compatibility = readOptionalJsonObject(record.value, 'proposedCompatibility', tool);
+    if (!compatibility.ok)
+        return compatibility;
+    if (compatibility.value !== undefined) {
+        const proposedCompatibility = compatibility.value;
+        if (proposedCompatibility !== undefined)
+            result.proposedCompatibility = proposedCompatibility;
+    }
+    const sourceContext = readOptionalJsonObject(record.value, 'sourceContext', tool);
+    if (!sourceContext.ok)
+        return sourceContext;
+    if (sourceContext.value !== undefined)
+        result.sourceContext = sourceContext.value;
+    const evidence = readOptionalJsonObject(record.value, 'evidence', tool);
+    if (!evidence.ok)
+        return evidence;
+    if (evidence.value !== undefined)
+        result.evidence = evidence.value;
+    const evidenceRefs = readOptionalStringArray(record.value, 'evidenceRefs', tool);
+    if (!evidenceRefs.ok)
+        return evidenceRefs;
+    if (evidenceRefs.value !== undefined)
+        result.evidenceRefs = evidenceRefs.value;
+    return { ok: true, value: result };
+}
+function validateSkillListImprovementProposalsInput(input, tool) {
+    const record = inputRecord(input, tool, ['project', 'scope', 'skillId', 'name', 'baseVersionId', 'status', 'runId', 'agentId', 'limit']);
+    if (!record.ok)
+        return record;
+    const project = readNonEmptyString(record.value, 'project', tool);
+    if (!project.ok)
+        return project;
+    const result = { project: project.value };
+    const copied = copyOptionalStrings(result, record.value, tool, ['skillId', 'name', 'baseVersionId', 'runId', 'agentId']);
+    if (!copied.ok)
+        return copied;
+    const scope = readOptionalOneOf(record.value, 'scope', scopes, tool);
+    if (!scope.ok)
+        return scope;
+    if (scope.value !== undefined)
+        result.scope = scope.value;
+    const status = readOptionalOneOf(record.value, 'status', skillImprovementProposalStatuses, tool);
+    if (!status.ok)
+        return status;
+    if (status.value !== undefined)
+        result.status = status.value;
+    const limit = readOptionalBoundedLimit(record.value, tool);
+    if (!limit.ok)
+        return limit;
+    if (limit.value !== undefined)
+        result.limit = limit.value;
+    return { ok: true, value: result };
+}
+function validateSkillRequestEvaluationInput(input, tool) {
+    const record = inputRecord(input, tool, [
+        'project',
+        'scope',
+        'skillId',
+        'name',
+        'versionId',
+        'version',
+        'scenarioId',
+        'proposalId',
+        'requestedBy',
+        'runId',
+        'agentId',
+        'workflow',
+        'phase',
+        'providerAdapter',
+        'risk',
+        'preflight',
+    ]);
+    if (!record.ok)
+        return record;
+    const result = {};
+    const copied = copyRequiredStrings(result, record.value, tool, ['project', 'requestedBy']);
+    if (!copied.ok)
+        return copied;
+    const optional = copyOptionalStrings(result, record.value, tool, ['skillId', 'name', 'versionId', 'version', 'scenarioId', 'proposalId', 'runId', 'agentId', 'workflow', 'phase', 'providerAdapter']);
+    if (!optional.ok)
+        return optional;
+    if (result.skillId === undefined && result.name === undefined)
+        return validationFailure('Either skillId or name is required', tool);
+    if (result.versionId !== undefined && result.version !== undefined)
+        return validationFailure('Use either versionId or version, not both', tool);
+    const scope = readOptionalOneOf(record.value, 'scope', scopes, tool);
+    if (!scope.ok)
+        return scope;
+    if (scope.value !== undefined)
+        result.scope = scope.value;
+    const risk = readOptionalJsonObject(record.value, 'risk', tool);
+    if (!risk.ok)
+        return risk;
+    if (risk.value !== undefined)
+        result.risk = risk.value;
+    const preflight = readOptionalJsonObject(record.value, 'preflight', tool);
+    if (!preflight.ok)
+        return preflight;
+    if (preflight.value !== undefined)
+        result.preflight = preflight.value;
+    return { ok: true, value: result };
+}
+function validateSkillListEvaluationsInput(input, tool) {
+    const record = inputRecord(input, tool, ['project', 'scope', 'skillId', 'name', 'versionId', 'scenarioId', 'proposalId', 'status', 'runId', 'agentId', 'limit']);
+    if (!record.ok)
+        return record;
+    const project = readNonEmptyString(record.value, 'project', tool);
+    if (!project.ok)
+        return project;
+    const result = { project: project.value };
+    const copied = copyOptionalStrings(result, record.value, tool, ['skillId', 'name', 'versionId', 'scenarioId', 'proposalId', 'runId', 'agentId']);
+    if (!copied.ok)
+        return copied;
+    const scope = readOptionalOneOf(record.value, 'scope', scopes, tool);
+    if (!scope.ok)
+        return scope;
+    if (scope.value !== undefined)
+        result.scope = scope.value;
+    const status = readOptionalOneOf(record.value, 'status', skillEvaluationRequestStatuses, tool);
+    if (!status.ok)
+        return status;
+    if (status.value !== undefined)
+        result.status = status.value;
+    const limit = readOptionalBoundedLimit(record.value, tool);
+    if (!limit.ok)
+        return limit;
+    if (limit.value !== undefined)
+        result.limit = limit.value;
+    return { ok: true, value: result };
+}
+function validateSkillGetEvaluationInput(input, tool) {
+    const record = inputRecord(input, tool, ['project', 'scope', 'id']);
+    if (!record.ok)
+        return record;
+    const project = readNonEmptyString(record.value, 'project', tool);
+    if (!project.ok)
+        return project;
+    const id = readNonEmptyString(record.value, 'id', tool);
+    if (!id.ok)
+        return id;
+    const result = { project: project.value, id: id.value };
+    const scope = readOptionalOneOf(record.value, 'scope', scopes, tool);
+    if (!scope.ok)
+        return scope;
+    if (scope.value !== undefined)
+        result.scope = scope.value;
+    return { ok: true, value: result };
+}
+function validateSkillCreateDraftInput(input, tool) {
+    const record = inputRecord(input, tool, [
+        'project',
+        'scope',
+        'name',
+        'description',
+        'version',
+        'source',
+        'compatibility',
+        'draftParentVersionId',
+        'actor',
+        'reason',
+        'runId',
+        'agentId',
+        'evidence',
+        'governance',
+    ]);
+    if (!record.ok)
+        return record;
+    const result = {};
+    const required = copyRequiredStrings(result, record.value, tool, ['project', 'name', 'description', 'version']);
+    if (!required.ok)
+        return required;
+    const optional = copyOptionalStrings(result, record.value, tool, ['draftParentVersionId', 'reason', 'runId', 'agentId']);
+    if (!optional.ok)
+        return optional;
+    const scope = readOptionalOneOf(record.value, 'scope', scopes, tool);
+    if (!scope.ok)
+        return scope;
+    if (scope.value !== undefined)
+        result.scope = scope.value;
+    const source = readSkillSource(record.value, 'source', tool);
+    if (!source.ok)
+        return source;
+    result.source = source.value;
+    const actor = readSkillLifecycleActor(record.value, tool);
+    if (!actor.ok)
+        return actor;
+    result.actor = actor.value;
+    const compatibility = readOptionalJsonObject(record.value, 'compatibility', tool);
+    if (!compatibility.ok)
+        return compatibility;
+    if (compatibility.value !== undefined)
+        result.compatibility = compatibility.value;
+    const evidence = readOptionalJsonObject(record.value, 'evidence', tool);
+    if (!evidence.ok)
+        return evidence;
+    if (evidence.value !== undefined)
+        result.evidence = evidence.value;
+    const governance = readOptionalJsonObject(record.value, 'governance', tool);
+    if (!governance.ok)
+        return governance;
+    if (governance.value !== undefined)
+        result.governance = governance.value;
+    return { ok: true, value: result };
+}
+function validateSkillUpdateDraftInput(input, tool) {
+    const record = inputRecord(input, tool, [
+        'project',
+        'scope',
+        'skillId',
+        'name',
+        'versionId',
+        'version',
+        'source',
+        'compatibility',
+        'expectedDraftRevision',
+        'actor',
+        'reason',
+        'runId',
+        'agentId',
+        'evidence',
+        'governance',
+    ]);
+    if (!record.ok)
+        return record;
+    const result = {};
+    const required = copyRequiredStrings(result, record.value, tool, ['project']);
+    if (!required.ok)
+        return required;
+    const optional = copyOptionalStrings(result, record.value, tool, ['skillId', 'name', 'versionId', 'version', 'reason', 'runId', 'agentId']);
+    if (!optional.ok)
+        return optional;
+    if (result.skillId === undefined && result.name === undefined)
+        return validationFailure('Either skillId or name is required', tool);
+    if (result.versionId === undefined && result.version === undefined)
+        return validationFailure('Either versionId or version is required', tool);
+    if (result.versionId !== undefined && result.version !== undefined)
+        return validationFailure('Use either versionId or version, not both', tool);
+    const scope = readOptionalOneOf(record.value, 'scope', scopes, tool);
+    if (!scope.ok)
+        return scope;
+    if (scope.value !== undefined)
+        result.scope = scope.value;
+    const actor = readSkillLifecycleActor(record.value, tool);
+    if (!actor.ok)
+        return actor;
+    result.actor = actor.value;
+    if (record.value.source !== undefined) {
+        const source = readSkillSource(record.value, 'source', tool);
+        if (!source.ok)
+            return source;
+        result.source = source.value;
+    }
+    const compatibility = readOptionalJsonObject(record.value, 'compatibility', tool);
+    if (!compatibility.ok)
+        return compatibility;
+    if (compatibility.value !== undefined)
+        result.compatibility = compatibility.value;
+    if (record.value.expectedDraftRevision !== undefined) {
+        const revision = record.value.expectedDraftRevision;
+        if (typeof revision !== 'number' || !Number.isSafeInteger(revision) || revision < 1)
+            return validationFailure('expectedDraftRevision must be a positive safe integer', tool);
+        result.expectedDraftRevision = revision;
+    }
+    const evidence = readOptionalJsonObject(record.value, 'evidence', tool);
+    if (!evidence.ok)
+        return evidence;
+    if (evidence.value !== undefined)
+        result.evidence = evidence.value;
+    const governance = readOptionalJsonObject(record.value, 'governance', tool);
+    if (!governance.ok)
+        return governance;
+    if (governance.value !== undefined)
+        result.governance = governance.value;
+    if (result.source === undefined && result.compatibility === undefined && result.governance === undefined)
+        return validationFailure('At least one draft update field is required', tool);
+    return { ok: true, value: result };
+}
+function validateSkillPublishVersionInput(input, tool) {
+    const record = inputRecord(input, tool, ['project', 'scope', 'skillId', 'name', 'versionId', 'version', 'actor', 'reason', 'runId', 'agentId', 'evidence', 'governance']);
+    if (!record.ok)
+        return record;
+    const result = {};
+    const required = copyRequiredStrings(result, record.value, tool, ['project', 'reason']);
+    if (!required.ok)
+        return required;
+    const optional = copyOptionalStrings(result, record.value, tool, ['skillId', 'name', 'versionId', 'version', 'runId', 'agentId']);
+    if (!optional.ok)
+        return optional;
+    if (result.skillId === undefined && result.name === undefined)
+        return validationFailure('Either skillId or name is required', tool);
+    if (result.versionId === undefined && result.version === undefined)
+        return validationFailure('Either versionId or version is required', tool);
+    if (result.versionId !== undefined && result.version !== undefined)
+        return validationFailure('Use either versionId or version, not both', tool);
+    const scope = readOptionalOneOf(record.value, 'scope', scopes, tool);
+    if (!scope.ok)
+        return scope;
+    if (scope.value !== undefined)
+        result.scope = scope.value;
+    const actor = readSkillLifecycleActor(record.value, tool);
+    if (!actor.ok)
+        return actor;
+    result.actor = actor.value;
+    const evidence = readOptionalJsonObject(record.value, 'evidence', tool);
+    if (!evidence.ok)
+        return evidence;
+    if (evidence.value !== undefined)
+        result.evidence = evidence.value;
+    const governance = readOptionalJsonObject(record.value, 'governance', tool);
+    if (!governance.ok)
+        return governance;
+    if (governance.value !== undefined)
+        result.governance = governance.value;
+    return { ok: true, value: result };
+}
 function validateManagerProfileGetInput(input, tool) {
     const record = inputRecord(input, tool, ['project', 'scope', 'managerName']);
     if (!record.ok)
@@ -1150,6 +1750,14 @@ function readJsonValue(record, field, tool) {
         return validationFailure(`${field} must be JSON-compatible`, tool);
     return { ok: true, value: record[field] };
 }
+function readOptionalJsonObject(record, field, tool) {
+    if (record[field] === undefined)
+        return { ok: true, value: undefined };
+    const value = record[field];
+    if (!isJsonValue(value) || typeof value !== 'object' || value === null || Array.isArray(value))
+        return validationFailure(`${field} must be a JSON object`, tool);
+    return { ok: true, value: value };
+}
 function isJsonValue(value) {
     if (value === null)
         return true;
@@ -1282,6 +1890,60 @@ function readBoundedLimit(record, tool) {
         return validationFailure('limit must be between 1 and 100', tool);
     return { ok: true, value: limit };
 }
+function readOptionalBoundedLimit(record, tool) {
+    if (record.limit === undefined)
+        return { ok: true, value: undefined };
+    return readBoundedLimit(record, tool);
+}
+function readSkillSource(record, field, tool) {
+    const source = asRecord(record[field], tool, `${field} must be an object`);
+    if (!source.ok)
+        return source;
+    const kind = readRequiredOneOf(source.value, 'kind', skillSourceKinds, tool);
+    if (!kind.ok)
+        return kind;
+    const result = { kind: kind.value };
+    const path = readOptionalNonEmptyString(source.value, 'path', tool);
+    if (!path.ok)
+        return path;
+    if (path.value !== undefined)
+        result.path = path.value;
+    const url = readOptionalNonEmptyString(source.value, 'url', tool);
+    if (!url.ok)
+        return url;
+    if (url.value !== undefined)
+        result.url = url.value;
+    const inlineMetadata = readOptionalJsonObject(source.value, 'inlineMetadata', tool);
+    if (!inlineMetadata.ok)
+        return inlineMetadata;
+    if (inlineMetadata.value !== undefined)
+        result.inlineMetadata = inlineMetadata.value;
+    if (result.kind === 'path' && result.path === undefined)
+        return validationFailure('proposedSource.path is required when proposedSource.kind is path', tool);
+    if (result.kind === 'url' && result.url === undefined)
+        return validationFailure('proposedSource.url is required when proposedSource.kind is url', tool);
+    if (result.kind === 'inline' && (result.path !== undefined || result.url !== undefined))
+        return validationFailure('Inline proposedSource cannot include path or url', tool);
+    return { ok: true, value: result };
+}
+function readSkillLifecycleActor(record, tool) {
+    const actorRecord = asRecord(record.actor, tool, 'actor must be an object');
+    if (!actorRecord.ok)
+        return actorRecord;
+    const type = readRequiredOneOf(actorRecord.value, 'type', ['human', 'agent', 'system'], tool);
+    if (!type.ok)
+        return type;
+    const id = readNonEmptyString(actorRecord.value, 'id', tool);
+    if (!id.ok)
+        return id;
+    const actor = { type: type.value, id: id.value };
+    const displayName = readOptionalNonEmptyString(actorRecord.value, 'displayName', tool);
+    if (!displayName.ok)
+        return displayName;
+    if (displayName.value !== undefined)
+        actor.displayName = displayName.value;
+    return { ok: true, value: actor };
+}
 function readOptionalStringArray(record, field, tool) {
     if (record[field] === undefined)
         return { ok: true, value: undefined };