vgxness 1.20.4 → 1.20.6

package/dist/interfaces/mcp/control-plane/types.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/mcp/control-plane.js

@@ -0,0 +1,235 @@
+import { OpenCodeHandoffPreviewService } from '../../adapters/opencode/install/opencode-handoff-preview.js';
+import { AgentActivationService } from '../../agents/agent-activation-service.js';
+import { AgentRegistryService } from '../../agents/agent-registry-service.js';
+import { ManagerProfileOverlayService } from '../../agents/manager-profile-overlay-service.js';
+import { ManagerProfileOverlayRepository } from '../../agents/repositories/manager-profile-overlays.js';
+import { ProviderChangePlanService } from '../../application/provider-setup/provider-change-plan.js';
+import { ProviderDoctorService } from '../../application/provider-setup/provider-doctor.js';
+import { ProviderStatusService } from '../../application/provider-setup/provider-status.js';
+import { MemoryService } from '../../memory/memory-service.js';
+import { openMemoryDatabase } from '../../memory/sqlite/database.js';
+import { prepareMemoryDatabasePath, resolveMemoryDatabasePath } from '../../memory/storage-paths.js';
+import { OpenCodeManagerPayloadService } from '../../providers/opencode/manager-payload.js';
+import { RunService } from '../../runs/run-service.js';
+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 { agentActivateEnvelope, agentResolveEnvelope, managerProfileGetEnvelope, managerProfileSetEnvelope, opencodeHandoffPreviewEnvelope, opencodeManagerPayloadEnvelope, } from './control-plane/handlers/agents.js';
+import { contextCockpitEnvelope, resumeContextEnvelope } from './control-plane/handlers/context.js';
+import { memoryGetEnvelope, memorySaveEnvelope, memorySearchEnvelope, memoryUpdateEnvelope } from './control-plane/handlers/memory.js';
+import { providerChangePlanEnvelope, providerDoctorEnvelope, providerStatusEnvelope } from './control-plane/handlers/providers.js';
+import { runCheckpointEnvelope, runFinalizeEnvelope, runGetEnvelope, runListEnvelope, runPreflightEnvelope, runResumeCandidatesEnvelope, runResumeGateEnvelope, runResumeInspectEnvelope, runStartEnvelope, runTaskGrantCreateEnvelope, runTaskGrantGetEnvelope, runTaskGrantListEnvelope, runTaskGrantPreviewMatchEnvelope, runTaskGrantRevokeEnvelope, } from './control-plane/handlers/runs.js';
+import { governanceReportEnvelope, sddAcceptArtifactEnvelope, sddCockpitEnvelope, sddContinueEnvelope, sddGetArtifactEnvelope, sddGetReadinessEnvelope, sddListArtifactsEnvelope, sddNextEnvelope, sddReadyEnvelope, sddReopenArtifactEnvelope, sddSaveArtifactEnvelope, sddStatusEnvelope, } from './control-plane/handlers/sdd.js';
+import { sessionAppendActivityEnvelope, sessionCloseEnvelope, sessionRestoreEnvelope, sessionStartEnvelope } from './control-plane/handlers/sessions.js';
+import { skillActivateEnvelope, skillCreateDraftEnvelope, skillGetEnvelope, skillGetEvaluationEnvelope, skillIndexEnvelope, skillListEvaluationsEnvelope, skillListImprovementProposalsEnvelope, skillPayloadEnvelope, skillProposeImprovementEnvelope, skillPublishVersionEnvelope, skillRecordUsageEnvelope, skillRequestEvaluationEnvelope, skillSearchEnvelope, skillStatusEnvelope, skillUpdateDraftEnvelope, } from './control-plane/handlers/skills.js';
+import { verificationPlanEnvelope } from './control-plane/handlers/verification.js';
+import { errorEnvelope, successEnvelope, } from './schema.js';
+import { validateVgxMcpToolCall } from './validation.js';
+export function callVgxTool(call, services) {
+    const validated = validateVgxMcpToolCall(call);
+    if (!validated.ok)
+        return validated;
+    switch (validated.tool) {
+        case 'vgxness_sdd_status':
+            return sddStatusEnvelope(validated.input, services);
+        case 'vgxness_sdd_ready':
+            return sddReadyEnvelope(validated.input, services);
+        case 'vgxness_sdd_get_readiness':
+            return sddGetReadinessEnvelope(validated.input, services);
+        case 'vgxness_sdd_save_artifact':
+            return sddSaveArtifactEnvelope(validated.input, services);
+        case 'vgxness_sdd_accept_artifact':
+            return sddAcceptArtifactEnvelope(validated.input, services);
+        case 'vgxness_sdd_reopen_artifact':
+            return sddReopenArtifactEnvelope(validated.input, services);
+        case 'vgxness_sdd_get_artifact':
+            return sddGetArtifactEnvelope(validated.input, services);
+        case 'vgxness_sdd_list_artifacts':
+            return sddListArtifactsEnvelope(validated.input, services);
+        case 'vgxness_sdd_next':
+            return sddNextEnvelope(validated.input, services);
+        case 'vgxness_sdd_cockpit':
+            return sddCockpitEnvelope(validated.input, services);
+        case 'vgxness_sdd_continue':
+            return sddContinueEnvelope(validated.input, services);
+        case 'vgxness_governance_report':
+            return governanceReportEnvelope(validated.input, services);
+        case 'vgxness_memory_save':
+            return memorySaveEnvelope(validated.input, services);
+        case 'vgxness_memory_search':
+            return memorySearchEnvelope(validated.input, services);
+        case 'vgxness_memory_get':
+            return memoryGetEnvelope(validated.input, services);
+        case 'vgxness_memory_update':
+            return memoryUpdateEnvelope(validated.input, services);
+        case 'vgxness_session_start':
+            return sessionStartEnvelope(validated.input, services);
+        case 'vgxness_session_append_activity':
+            return sessionAppendActivityEnvelope(validated.input, services);
+        case 'vgxness_session_close':
+            return sessionCloseEnvelope(validated.input, services);
+        case 'vgxness_session_restore':
+            return sessionRestoreEnvelope(validated.input, services);
+        case 'vgxness_context_cockpit':
+            return contextCockpitEnvelope(validated.input, services);
+        case 'vgxness_resume_context':
+            return resumeContextEnvelope(validated.input, services);
+        case 'vgxness_agent_resolve':
+            return agentResolveEnvelope(validated.input, services);
+        case 'vgxness_agent_activate':
+            return agentActivateEnvelope(validated.input, services);
+        case 'vgxness_manager_profile_get':
+            return managerProfileGetEnvelope(validated.input, services);
+        case 'vgxness_manager_profile_set':
+            return managerProfileSetEnvelope(validated.input, services);
+        case 'vgxness_skill_index':
+            return skillIndexEnvelope(validated.input, services);
+        case 'vgxness_skill_search':
+            return skillSearchEnvelope(validated.input, services);
+        case 'vgxness_skill_get':
+            return skillGetEnvelope(validated.input, services);
+        case 'vgxness_skill_status':
+            return skillStatusEnvelope(validated.input, services);
+        case 'vgxness_skill_payload':
+            return skillPayloadEnvelope(validated.input, services);
+        case 'vgxness_skill_activate':
+            return skillActivateEnvelope(validated.input, services);
+        case 'vgxness_skill_record_usage':
+            return skillRecordUsageEnvelope(validated.input, services);
+        case 'vgxness_skill_propose_improvement':
+            return skillProposeImprovementEnvelope(validated.input, services);
+        case 'vgxness_skill_list_improvement_proposals':
+            return skillListImprovementProposalsEnvelope(validated.input, services);
+        case 'vgxness_skill_request_evaluation':
+            return skillRequestEvaluationEnvelope(validated.input, services);
+        case 'vgxness_skill_list_evaluations':
+            return skillListEvaluationsEnvelope(validated.input, services);
+        case 'vgxness_skill_get_evaluation':
+            return skillGetEvaluationEnvelope(validated.input, services);
+        case 'vgxness_skill_create_draft':
+            return skillCreateDraftEnvelope(validated.input, services);
+        case 'vgxness_skill_update_draft':
+            return skillUpdateDraftEnvelope(validated.input, services);
+        case 'vgxness_skill_publish_version':
+            return skillPublishVersionEnvelope(validated.input, services);
+        case 'vgxness_opencode_manager_payload':
+            return opencodeManagerPayloadEnvelope(validated.input, services);
+        case 'vgxness_opencode_handoff_preview':
+            return opencodeHandoffPreviewEnvelope(validated.input, services);
+        case 'vgxness_run_list':
+            return runListEnvelope(validated.input, services);
+        case 'vgxness_run_get':
+            return runGetEnvelope(validated.input, services);
+        case 'vgxness_run_preflight':
+            return runPreflightEnvelope(validated.input, services);
+        case 'vgxness_run_task_grant_create':
+            return runTaskGrantCreateEnvelope(validated.input, services);
+        case 'vgxness_run_task_grant_list':
+            return runTaskGrantListEnvelope(validated.input, services);
+        case 'vgxness_run_task_grant_get':
+            return runTaskGrantGetEnvelope(validated.input, services);
+        case 'vgxness_run_task_grant_revoke':
+            return runTaskGrantRevokeEnvelope(validated.input, services);
+        case 'vgxness_run_task_grant_preview_match':
+            return runTaskGrantPreviewMatchEnvelope(validated.input, services);
+        case 'vgxness_run_start':
+            return runStartEnvelope(validated.input, services);
+        case 'vgxness_run_checkpoint':
+            return runCheckpointEnvelope(validated.input, services);
+        case 'vgxness_run_finalize':
+            return runFinalizeEnvelope(validated.input, services);
+        case 'vgxness_run_resume_candidates':
+            return runResumeCandidatesEnvelope(validated.input, services);
+        case 'vgxness_run_resume_inspect':
+            return runResumeInspectEnvelope(validated.input, services);
+        case 'vgxness_run_resume_gate':
+            return runResumeGateEnvelope(validated.input, services);
+        case 'vgxness_provider_status':
+            return providerStatusEnvelope(validated.input, services);
+        case 'vgxness_provider_doctor':
+            return providerDoctorEnvelope(validated.input, services);
+        case 'vgxness_provider_change_plan':
+            return providerChangePlanEnvelope(validated.input, services);
+        case 'vgxness_verification_plan':
+            return verificationPlanEnvelope(validated.input, services);
+    }
+    return errorEnvelope('validation_failed', 'Tool dispatch is not implemented');
+}
+export function createVgxMcpControlPlane(options = {}) {
+    const databasePath = resolveControlPlaneDatabasePath(options);
+    if (!databasePath.ok)
+        throw new VgxMcpControlPlaneError(databasePath.error);
+    const prepared = prepareMemoryDatabasePath(databasePath.value);
+    if (!prepared.ok)
+        throw new VgxMcpControlPlaneError(prepared.error);
+    const opened = openMemoryDatabase({ path: databasePath.value });
+    if (!opened.ok)
+        throw new VgxMcpControlPlaneError(opened.error);
+    const database = opened.value;
+    const services = createServices(database);
+    let closed = false;
+    return {
+        callVgxTool: (tool, input) => callVgxTool({ tool, input }, services),
+        database,
+        close: () => {
+            if (closed)
+                return;
+            closed = true;
+            database.close();
+        },
+    };
+}
+export class VgxMcpControlPlaneError extends Error {
+    code;
+    cause;
+    constructor(failure) {
+        super(failure.message);
+        this.name = 'VgxMcpControlPlaneError';
+        this.code = failure.code;
+        if (failure.cause !== undefined)
+            this.cause = failure.cause;
+    }
+}
+function createServices(database) {
+    const memory = new MemoryService(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 });
+    const sdd = new SddWorkflowService(memory, { actor: 'mcp-control-plane' });
+    const providerStatus = new ProviderStatusService({ sdd });
+    const providerDoctor = new ProviderDoctorService();
+    return {
+        sdd,
+        memory,
+        agents,
+        managerProfiles,
+        skills,
+        skillIndex,
+        skillStatus,
+        seedBuiltInSkills: () => runBootSkillSeed(database),
+        opencodeManagerPayload,
+        opencodeHandoffPreview: new OpenCodeHandoffPreviewService({ managerPayload: opencodeManagerPayload, sdd, providerStatus }),
+        activation: new AgentActivationService({ agents, managerProfiles, runs, opencodeManagerPayload }),
+        runs,
+        providerStatus,
+        providerDoctor,
+        providerChangePlan: new ProviderChangePlanService({ providerStatus, providerDoctor }),
+        verificationPlan: new VerificationPlanService(),
+    };
+}
+function _toEnvelope(tool, result) {
+    return result.ok ? successEnvelope(tool, result.value) : errorEnvelope(result.error.code, result.error.message, tool);
+}
+function resolveControlPlaneDatabasePath(options) {
+    if (options.databasePath !== undefined)
+        return { ok: true, value: options.databasePath };
+    const resolved = resolveMemoryDatabasePath({ cwd: process.cwd(), env: process.env });
+    return resolved.ok ? { ok: true, value: resolved.value.path } : resolved;
+}

package/dist/interfaces/mcp/schema.js

@@ -0,0 +1,174 @@
+import { z } from 'zod';
+import { AGENTS_MCP_TOOL_INPUT_SCHEMAS, CONTEXT_MCP_TOOL_INPUT_SCHEMAS, GOVERNANCE_MCP_TOOL_INPUT_SCHEMAS, MEMORY_MCP_TOOL_INPUT_SCHEMAS, PROVIDERS_MCP_TOOL_INPUT_SCHEMAS, RUNS_MCP_TOOL_INPUT_SCHEMAS, SDD_MCP_TOOL_INPUT_SCHEMAS, SESSIONS_MCP_TOOL_INPUT_SCHEMAS, SKILLS_MCP_TOOL_INPUT_SCHEMAS, VERIFICATION_MCP_TOOL_INPUT_SCHEMAS, } from './schemas/inputs/index.js';
+import { buildProviderMcpToolOutputSchemas, buildSddMcpToolOutputSchemas } from './schemas/outputs/index.js';
+export const SUPPORTED_VGX_MCP_TOOL_NAMES = [
+    'vgxness_sdd_status',
+    'vgxness_sdd_ready',
+    'vgxness_sdd_get_readiness',
+    'vgxness_sdd_save_artifact',
+    'vgxness_sdd_accept_artifact',
+    'vgxness_sdd_reopen_artifact',
+    'vgxness_sdd_get_artifact',
+    'vgxness_sdd_list_artifacts',
+    'vgxness_sdd_next',
+    'vgxness_sdd_cockpit',
+    'vgxness_sdd_continue',
+    'vgxness_governance_report',
+    'vgxness_memory_save',
+    'vgxness_memory_search',
+    'vgxness_memory_get',
+    'vgxness_memory_update',
+    'vgxness_session_start',
+    'vgxness_session_append_activity',
+    'vgxness_session_close',
+    'vgxness_session_restore',
+    'vgxness_context_cockpit',
+    'vgxness_resume_context',
+    'vgxness_agent_resolve',
+    'vgxness_agent_activate',
+    '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',
+    'vgxness_run_get',
+    'vgxness_run_preflight',
+    'vgxness_run_task_grant_create',
+    'vgxness_run_task_grant_list',
+    'vgxness_run_task_grant_get',
+    'vgxness_run_task_grant_revoke',
+    'vgxness_run_task_grant_preview_match',
+    'vgxness_run_start',
+    'vgxness_run_checkpoint',
+    'vgxness_run_finalize',
+    'vgxness_run_resume_candidates',
+    'vgxness_run_resume_inspect',
+    'vgxness_run_resume_gate',
+    'vgxness_provider_status',
+    'vgxness_provider_doctor',
+    'vgxness_provider_change_plan',
+    'vgxness_verification_plan',
+];
+export const EXPOSED_VGX_MCP_TOOL_NAMES = [
+    'sdd_status',
+    'sdd_ready',
+    'sdd_get_readiness',
+    'sdd_save_artifact',
+    'sdd_accept_artifact',
+    'sdd_reopen_artifact',
+    'sdd_get_artifact',
+    'sdd_list_artifacts',
+    'sdd_next',
+    'sdd_cockpit',
+    'sdd_continue',
+    'governance_report',
+    'memory_save',
+    'memory_search',
+    'memory_get',
+    'memory_update',
+    'session_start',
+    'session_append_activity',
+    'session_close',
+    'session_restore',
+    'context_cockpit',
+    'resume_context',
+    'agent_resolve',
+    'agent_activate',
+    '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',
+    'run_get',
+    'run_preflight',
+    'run_task_grant_create',
+    'run_task_grant_list',
+    'run_task_grant_get',
+    'run_task_grant_revoke',
+    'run_task_grant_preview_match',
+    'run_start',
+    'run_checkpoint',
+    'run_finalize',
+    'run_resume_candidates',
+    'run_resume_inspect',
+    'run_resume_gate',
+    'provider_status',
+    'provider_doctor',
+    'provider_change_plan',
+    'verification_plan',
+];
+const EXPOSED_TO_INTERNAL_TOOL_NAMES = Object.fromEntries(SUPPORTED_VGX_MCP_TOOL_NAMES.map((toolName) => [toExposedVgxMcpToolName(toolName), toolName]));
+export function toExposedVgxMcpToolName(toolName) {
+    return toolName.replace(/^vgxness_/, '');
+}
+export function toInternalVgxMcpToolName(toolName) {
+    return EXPOSED_TO_INTERNAL_TOOL_NAMES[toolName];
+}
+const mcpSuccessOutputSchema = (value) => z
+    .object({
+    ok: z.literal(true),
+    tool: z.enum(SUPPORTED_VGX_MCP_TOOL_NAMES),
+    value,
+})
+    .passthrough();
+export const VGX_MCP_TOOL_INPUT_SCHEMAS = {
+    ...SDD_MCP_TOOL_INPUT_SCHEMAS,
+    ...GOVERNANCE_MCP_TOOL_INPUT_SCHEMAS,
+    ...MEMORY_MCP_TOOL_INPUT_SCHEMAS,
+    ...SESSIONS_MCP_TOOL_INPUT_SCHEMAS,
+    ...CONTEXT_MCP_TOOL_INPUT_SCHEMAS,
+    ...AGENTS_MCP_TOOL_INPUT_SCHEMAS,
+    ...SKILLS_MCP_TOOL_INPUT_SCHEMAS,
+    ...RUNS_MCP_TOOL_INPUT_SCHEMAS,
+    ...PROVIDERS_MCP_TOOL_INPUT_SCHEMAS,
+    ...VERIFICATION_MCP_TOOL_INPUT_SCHEMAS,
+};
+export const VGX_MCP_TOOL_OUTPUT_SCHEMAS = {
+    ...buildSddMcpToolOutputSchemas(mcpSuccessOutputSchema),
+    ...buildProviderMcpToolOutputSchemas(mcpSuccessOutputSchema),
+};
+export function successEnvelope(tool, value) {
+    return { ok: true, tool, value };
+}
+export function errorEnvelope(code, message, tool, details) {
+    const error = { code, message };
+    if (details !== undefined)
+        error.details = details;
+    const result = { ok: false, error };
+    if (tool !== undefined)
+        result.tool = tool;
+    return result;
+}
+export function isVgxMcpToolName(value) {
+    return typeof value === 'string' && SUPPORTED_VGX_MCP_TOOL_NAMES.includes(value);
+}

package/dist/interfaces/mcp/schemas/common.js

@@ -0,0 +1,121 @@
+import { z } from 'zod';
+import { permissionCategories } from '../../../permissions/schema.js';
+import { sddPhases } from '../../../sdd/schema.js';
+import { workflowIds } from '../../../workflows/schema.js';
+export { permissionCategories, workflowIds };
+export const scopes = ['project', 'personal'];
+export const providerInstallTargets = ['user-global'];
+export const agentModes = ['agent', 'subagent'];
+export const memoryTypes = ['architecture', 'decision', 'bugfix', 'pattern', 'config', 'discovery', 'learning', 'preference', 'manual'];
+export const activityKinds = ['prompt', 'tool_call', 'artifact', 'summary', 'error'];
+export const runStatuses = ['created', 'planned', 'running', 'needs-human', 'completed', 'failed', 'blocked', 'cancelled'];
+export const taskGrantStatuses = ['active', 'revoked', 'expired', 'exhausted'];
+export const taskGrantCategories = ['shell', 'test-run', 'git'];
+export const finalRunStatuses = ['completed', 'failed', 'blocked', 'cancelled'];
+export const runOutcomes = ['success', 'partial', 'failure', 'blocked', 'cancelled'];
+export const payloadModes = ['compact', 'verbose'];
+export const skillVersionStatuses = ['draft', 'active', 'deprecated', 'archived'];
+export const skillImprovementProposalStatuses = ['draft', 'pending-approval', 'approved', 'rejected', 'cancelled', 'applied'];
+export const skillEvaluationRequestStatuses = ['requested', 'planned', 'running', 'completed', 'failed', 'cancelled', 'skipped'];
+export const skillSourceKinds = ['path', 'url', 'inline'];
+export const skillUsageOutcomes = ['selected', 'injected', 'helped', 'failed', 'neutral'];
+export const skillAttachmentTargetTypes = ['agent', 'subagent', 'workflow-phase', 'provider-adapter', 'intent-signal'];
+export const jsonRecordSchema = z.record(z.string(), z.unknown());
+export const explicitRequestInputSchema = z
+    .object({
+    version: z.literal(1),
+    actor: z
+        .object({
+        type: z.literal('human'),
+        id: z.string().min(1).optional(),
+        displayName: z.string().min(1).optional(),
+    })
+        .strict(),
+    request: z
+        .object({
+        id: z.string().min(1).optional(),
+        source: z.enum(['chat', 'mcp', 'cli', 'provider', 'unknown']),
+        utteranceRef: z.string().min(1).optional(),
+        excerpt: z.string().min(1).optional(),
+        requestedAt: z.string().min(1),
+        sessionId: z.string().min(1).optional(),
+        runId: z.string().min(1).optional(),
+    })
+        .strict(),
+    requestedOperation: z
+        .object({
+        category: z.enum(permissionCategories),
+        operation: z.string().min(1),
+        commandId: z.string().min(1).optional(),
+        providerToolName: z.string().min(1).optional(),
+        targetPath: z.string().min(1).optional(),
+        targetPaths: z.array(z.string().min(1)).optional(),
+        cwd: z.string().min(1).optional(),
+        workspaceRoot: z.string().min(1).optional(),
+        scopeSummary: z.string().min(1),
+    })
+        .strict(),
+    riskAttributes: z
+        .object({
+        destructive: z.boolean().optional(),
+        privileged: z.boolean().optional(),
+        external: z.boolean().optional(),
+        ambiguous: z.boolean().optional(),
+        secrets: z.boolean().optional(),
+        providerConfigMutation: z.boolean().optional(),
+        globalConfigMutation: z.boolean().optional(),
+        network: z.boolean().optional(),
+        install: z.boolean().optional(),
+    })
+        .strict(),
+    parser: z
+        .object({
+        exact: z.boolean(),
+        confidence: z.enum(['high', 'medium', 'low']).optional(),
+        ambiguityReasons: z.array(z.string().min(1)).optional(),
+        expansionReasons: z.array(z.string().min(1)).optional(),
+    })
+        .strict(),
+})
+    .strict();
+export const skillLifecycleActorSchema = z
+    .object({
+    type: z.enum(['human', 'agent', 'system']),
+    id: z.string().min(1),
+    displayName: z.string().min(1).optional(),
+})
+    .passthrough();
+export const skillSourceSchema = z
+    .object({
+    kind: z.enum(skillSourceKinds),
+    path: z.string().min(1).optional(),
+    url: z.string().min(1).optional(),
+    inlineMetadata: jsonRecordSchema.optional(),
+})
+    .passthrough();
+export const contextCockpitLevels = ['compact', 'expanded', 'verbose'];
+export const providerChangePlanProviders = ['opencode', 'claude', 'antigravity', 'custom'];
+export const providerChangePlanTypes = ['opencode-mcp-install', 'claude-mcp-install', 'setup', 'install', 'config-preparation'];
+export const sddPhaseInputSchema = z.union([z.enum(sddPhases), z.literal('apply')]);
+export const sddPhaseSchema = z.enum(sddPhases);
+export const jsonValueSchema = z.lazy(() => z.union([z.string(), z.number().finite(), z.boolean(), z.null(), z.array(jsonValueSchema), z.record(z.string(), jsonValueSchema)]));
+export const taskGrantHumanActorInputSchema = z
+    .object({
+    type: z.literal('human'),
+    id: z.string().min(1),
+    displayName: z.string().min(1).optional(),
+})
+    .strict();
+export const taskGrantRevocationActorInputSchema = z
+    .object({
+    type: z.enum(['human', 'system']),
+    id: z.string().min(1),
+    displayName: z.string().min(1).optional(),
+})
+    .strict();
+export const taskGrantCommandPolicyInputSchema = z
+    .object({
+    kind: z.literal('allowlisted-command-ids'),
+    ids: z.array(z.string().min(1)).min(1),
+})
+    .strict();

package/dist/interfaces/mcp/schemas/inputs/agents.js

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { agentModes, payloadModes, scopes, sddPhaseInputSchema } from '../common.js';
+export const AGENTS_MCP_TOOL_INPUT_SCHEMAS = {
+    vgxness_agent_resolve: z
+        .object({
+        project: z.string().min(1).optional(),
+        scope: z.enum(scopes).optional(),
+        taskDescription: z.string().min(1).optional(),
+        intent: z.string().min(1).optional(),
+        desiredCapabilities: z.array(z.string().min(1)).optional(),
+        workflow: z.string().min(1).optional(),
+        phase: z.string().min(1).optional(),
+        providerAdapter: z.string().min(1).optional(),
+        mode: z.enum(agentModes).optional(),
+    })
+        .passthrough(),
+    vgxness_agent_activate: z
+        .object({
+        project: z.string().min(1),
+        scope: z.enum(scopes).optional(),
+        agentId: z.string().min(1).optional(),
+        userIntent: z.string().min(1),
+        workflow: z.string().min(1).optional(),
+        phase: z.string().min(1).optional(),
+        workspaceRoot: z.string().min(1).optional(),
+        maxSourceBytes: z.number().int().positive().optional(),
+        providerAdapter: z.string().min(1).optional(),
+        payloadMode: z.enum(payloadModes).optional(),
+    })
+        .passthrough(),
+    vgxness_manager_profile_get: z
+        .object({
+        project: z.string().min(1),
+        scope: z.enum(scopes).optional(),
+        managerName: z.string().min(1).optional(),
+    })
+        .passthrough(),
+    vgxness_manager_profile_set: z
+        .object({
+        project: z.string().min(1),
+        scope: z.enum(scopes),
+        managerName: z.string().min(1),
+        instructions: z.string().min(1),
+    })
+        .passthrough(),
+    vgxness_opencode_manager_payload: z
+        .object({
+        project: z.string().min(1),
+        scope: z.enum(scopes).optional(),
+        agentId: z.string().min(1).optional(),
+        agentName: z.string().min(1).optional(),
+        workspaceRoot: z.string().min(1).optional(),
+        maxSourceBytes: z.number().int().positive().optional(),
+        payloadMode: z.enum(payloadModes).optional(),
+    })
+        .passthrough(),
+    vgxness_opencode_handoff_preview: z
+        .object({
+        project: z.string().min(1),
+        scope: z.enum(scopes).optional(),
+        agentId: z.string().min(1).optional(),
+        agentName: z.string().min(1).optional(),
+        workspaceRoot: z.string().min(1).optional(),
+        maxSourceBytes: z.number().int().positive().optional(),
+        change: z.string().min(1).optional(),
+        phase: sddPhaseInputSchema.optional(),
+    })
+        .passthrough(),
+};

package/dist/interfaces/mcp/schemas/inputs/context.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { contextCockpitLevels, payloadModes } from '../common.js';
+export const CONTEXT_MCP_TOOL_INPUT_SCHEMAS = {
+    vgxness_context_cockpit: z
+        .object({
+        project: z.string().min(1),
+        change: z.preprocess((value) => (value === '' ? undefined : value), z
+            .string()
+            .min(1)
+            .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/)
+            .optional()),
+        directory: z.string().min(1).optional(),
+        limit: z.number().int().min(1).max(100).optional(),
+        level: z.enum(contextCockpitLevels).optional(),
+    })
+        .passthrough(),
+    vgxness_resume_context: z
+        .object({
+        project: z.string().min(1),
+        directory: z.string().min(1).optional(),
+        workspaceRoot: z.string().min(1).optional(),
+        userPrompt: z.string().optional(),
+        explicitChange: z.preprocess((value) => (typeof value === 'string' && value.trim().length === 0 ? undefined : value), z
+            .string()
+            .min(1)
+            .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/)
+            .optional()),
+        limit: z.number().int().min(1).max(25).optional(),
+        payloadMode: z.enum(payloadModes).optional(),
+    })
+        .passthrough(),
+};

package/dist/interfaces/mcp/schemas/inputs/governance.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { agentModes, payloadModes, scopes } from '../common.js';
+export const GOVERNANCE_MCP_TOOL_INPUT_SCHEMAS = {
+    vgxness_governance_report: z
+        .object({
+        project: z.string().min(1),
+        change: z.string().min(1).optional(),
+        runId: z.string().min(1).optional(),
+        workflow: z.string().min(1).optional(),
+        phase: z.string().min(1).optional(),
+        agentId: z.string().min(1).optional(),
+        payloadMode: z.enum(payloadModes).optional(),
+        agent: z
+            .object({
+            id: z.string().min(1).optional(),
+            name: z.string().min(1).optional(),
+            mode: z.enum(agentModes).optional(),
+            scope: z.enum(scopes).optional(),
+        })
+            .optional(),
+    })
+        .passthrough(),
+};

package/dist/interfaces/mcp/schemas/inputs/index.js

@@ -0,0 +1,10 @@
+export { AGENTS_MCP_TOOL_INPUT_SCHEMAS } from './agents.js';
+export { CONTEXT_MCP_TOOL_INPUT_SCHEMAS } from './context.js';
+export { GOVERNANCE_MCP_TOOL_INPUT_SCHEMAS } from './governance.js';
+export { MEMORY_MCP_TOOL_INPUT_SCHEMAS } from './memory.js';
+export { PROVIDERS_MCP_TOOL_INPUT_SCHEMAS } from './providers.js';
+export { RUNS_MCP_TOOL_INPUT_SCHEMAS } from './runs.js';
+export { SDD_MCP_TOOL_INPUT_SCHEMAS } from './sdd.js';
+export { SESSIONS_MCP_TOOL_INPUT_SCHEMAS } from './sessions.js';
+export { SKILLS_MCP_TOOL_INPUT_SCHEMAS } from './skills.js';
+export { VERIFICATION_MCP_TOOL_INPUT_SCHEMAS } from './verification.js';