@devtrack-solution/codesdd 1.2.2 → 1.2.3

package/dist/core/sdd/plugin-registry.d.ts

@@ -0,0 +1,311 @@
+import { z } from 'zod';
+import { type PluginCapability, type PluginManifest } from './plugin-manifest.js';
+export declare const pluginRegistrySourceSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        local: "local";
+        workspace: "workspace";
+        "enterprise-catalog": "enterprise-catalog";
+    }>;
+    uri: z.ZodString;
+    checksum: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const pluginRegistryEntrySchema: z.ZodObject<{
+    manifest: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        version: z.ZodString;
+        contract_version: z.ZodLiteral<1>;
+        vendor: z.ZodString;
+        codesdd_compat: z.ZodObject<{
+            versions: z.ZodString;
+            sdd_contract_versions: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strip>;
+        technology: z.ZodObject<{
+            language: z.ZodString;
+            framework: z.ZodOptional<z.ZodString>;
+            runtime: z.ZodOptional<z.ZodString>;
+            package_manager: z.ZodOptional<z.ZodString>;
+            min_versions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>;
+        capabilities: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            input_schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            output_schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            deterministic: z.ZodBoolean;
+            idempotent: z.ZodBoolean;
+            supports_dry_run: z.ZodBoolean;
+            supports_apply: z.ZodBoolean;
+            supports_rollback: z.ZodDefault<z.ZodBoolean>;
+            write_scope: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            risk_tier: z.ZodDefault<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                critical: "critical";
+            }>>;
+            approval: z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                maintainer: "maintainer";
+                security: "security";
+                "architecture-board": "architecture-board";
+            }>>;
+        }, z.core.$strip>>;
+        execution: z.ZodObject<{
+            command: z.ZodString;
+            args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            timeout_seconds: z.ZodDefault<z.ZodNumber>;
+            env_allowlist: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            network: z.ZodDefault<z.ZodEnum<{
+                disabled: "disabled";
+                restricted: "restricted";
+                enabled: "enabled";
+            }>>;
+            process_spawn: z.ZodDefault<z.ZodEnum<{
+                forbidden: "forbidden";
+                declared: "declared";
+            }>>;
+            working_directory: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>;
+        artifacts: z.ZodObject<{
+            writes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            forbidden_writes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            naming_conventions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        supply_chain: z.ZodObject<{
+            checksum: z.ZodOptional<z.ZodString>;
+            signature: z.ZodOptional<z.ZodString>;
+            provenance: z.ZodOptional<z.ZodString>;
+            sbom: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        governance: z.ZodObject<{
+            owner: z.ZodString;
+            support_sla: z.ZodString;
+            deprecation_window: z.ZodString;
+            policy_packs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            trust_tier: z.ZodEnum<{
+                experimental: "experimental";
+                blocked: "blocked";
+                "local-dev": "local-dev";
+                "enterprise-approved": "enterprise-approved";
+            }>;
+            allowed_domains: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            risk_tier: z.ZodDefault<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                critical: "critical";
+            }>>;
+        }, z.core.$strip>;
+        validation: z.ZodObject<{
+            commands: z.ZodArray<z.ZodString>;
+            coverage_target: z.ZodDefault<z.ZodNumber>;
+            security_checks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            dependency_checks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        compression: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            engine: z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                rtk: "rtk";
+                headroom: "headroom";
+                builtin: "builtin";
+            }>>;
+            mode: z.ZodDefault<z.ZodLiteral<"pretooluse">>;
+            exclude_commands: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            tee: z.ZodDefault<z.ZodEnum<{
+                never: "never";
+                failures: "failures";
+                always: "always";
+            }>>;
+            max_output_tokens: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    source: z.ZodObject<{
+        type: z.ZodEnum<{
+            local: "local";
+            workspace: "workspace";
+            "enterprise-catalog": "enterprise-catalog";
+        }>;
+        uri: z.ZodString;
+        checksum: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    status: z.ZodDefault<z.ZodEnum<{
+        disabled: "disabled";
+        active: "active";
+        blocked: "blocked";
+        deprecated: "deprecated";
+    }>>;
+    registered_at: z.ZodString;
+    notes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const pluginRegistryStateSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    generated_at: z.ZodString;
+    entries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        manifest: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            version: z.ZodString;
+            contract_version: z.ZodLiteral<1>;
+            vendor: z.ZodString;
+            codesdd_compat: z.ZodObject<{
+                versions: z.ZodString;
+                sdd_contract_versions: z.ZodArray<z.ZodNumber>;
+            }, z.core.$strip>;
+            technology: z.ZodObject<{
+                language: z.ZodString;
+                framework: z.ZodOptional<z.ZodString>;
+                runtime: z.ZodOptional<z.ZodString>;
+                package_manager: z.ZodOptional<z.ZodString>;
+                min_versions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strip>;
+            capabilities: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+                input_schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                output_schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                deterministic: z.ZodBoolean;
+                idempotent: z.ZodBoolean;
+                supports_dry_run: z.ZodBoolean;
+                supports_apply: z.ZodBoolean;
+                supports_rollback: z.ZodDefault<z.ZodBoolean>;
+                write_scope: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                risk_tier: z.ZodDefault<z.ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    critical: "critical";
+                }>>;
+                approval: z.ZodDefault<z.ZodEnum<{
+                    none: "none";
+                    maintainer: "maintainer";
+                    security: "security";
+                    "architecture-board": "architecture-board";
+                }>>;
+            }, z.core.$strip>>;
+            execution: z.ZodObject<{
+                command: z.ZodString;
+                args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                timeout_seconds: z.ZodDefault<z.ZodNumber>;
+                env_allowlist: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                network: z.ZodDefault<z.ZodEnum<{
+                    disabled: "disabled";
+                    restricted: "restricted";
+                    enabled: "enabled";
+                }>>;
+                process_spawn: z.ZodDefault<z.ZodEnum<{
+                    forbidden: "forbidden";
+                    declared: "declared";
+                }>>;
+                working_directory: z.ZodDefault<z.ZodString>;
+            }, z.core.$strip>;
+            artifacts: z.ZodObject<{
+                writes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                forbidden_writes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                naming_conventions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>;
+            supply_chain: z.ZodObject<{
+                checksum: z.ZodOptional<z.ZodString>;
+                signature: z.ZodOptional<z.ZodString>;
+                provenance: z.ZodOptional<z.ZodString>;
+                sbom: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            governance: z.ZodObject<{
+                owner: z.ZodString;
+                support_sla: z.ZodString;
+                deprecation_window: z.ZodString;
+                policy_packs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                trust_tier: z.ZodEnum<{
+                    experimental: "experimental";
+                    blocked: "blocked";
+                    "local-dev": "local-dev";
+                    "enterprise-approved": "enterprise-approved";
+                }>;
+                allowed_domains: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                risk_tier: z.ZodDefault<z.ZodEnum<{
+                    low: "low";
+                    medium: "medium";
+                    high: "high";
+                    critical: "critical";
+                }>>;
+            }, z.core.$strip>;
+            validation: z.ZodObject<{
+                commands: z.ZodArray<z.ZodString>;
+                coverage_target: z.ZodDefault<z.ZodNumber>;
+                security_checks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                dependency_checks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>;
+            compression: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                engine: z.ZodDefault<z.ZodEnum<{
+                    none: "none";
+                    rtk: "rtk";
+                    headroom: "headroom";
+                    builtin: "builtin";
+                }>>;
+                mode: z.ZodDefault<z.ZodLiteral<"pretooluse">>;
+                exclude_commands: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                tee: z.ZodDefault<z.ZodEnum<{
+                    never: "never";
+                    failures: "failures";
+                    always: "always";
+                }>>;
+                max_output_tokens: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        source: z.ZodObject<{
+            type: z.ZodEnum<{
+                local: "local";
+                workspace: "workspace";
+                "enterprise-catalog": "enterprise-catalog";
+            }>;
+            uri: z.ZodString;
+            checksum: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        status: z.ZodDefault<z.ZodEnum<{
+            disabled: "disabled";
+            active: "active";
+            blocked: "blocked";
+            deprecated: "deprecated";
+        }>>;
+        registered_at: z.ZodString;
+        notes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type PluginRegistrySource = z.infer<typeof pluginRegistrySourceSchema>;
+export type PluginRegistryEntry = z.infer<typeof pluginRegistryEntrySchema>;
+export type PluginRegistryState = z.infer<typeof pluginRegistryStateSchema>;
+export type PluginTrustTier = PluginManifest['governance']['trust_tier'];
+export type PluginRiskTier = PluginManifest['governance']['risk_tier'];
+export type PluginRegistryStatus = PluginRegistryEntry['status'];
+export interface RegisterPluginInput {
+    manifest: PluginManifest;
+    source: PluginRegistrySource;
+    status?: PluginRegistryStatus;
+    registered_at?: string;
+    notes?: string[];
+}
+export interface PluginCapabilityResolutionRequest {
+    capability: string;
+    trust_tiers?: PluginTrustTier[];
+    statuses?: PluginRegistryStatus[];
+    technology?: {
+        language?: string;
+        framework?: string;
+    };
+    require_apply?: boolean;
+    require_dry_run?: boolean;
+}
+export type PluginCapabilityResolution = {
+    status: 'resolved';
+    entry: PluginRegistryEntry;
+    capability: PluginCapability;
+    reasons: string[];
+} | {
+    status: 'unresolved';
+    reasons: string[];
+};
+export declare function createPluginRegistryState(plugins: RegisterPluginInput[], generatedAt?: string): PluginRegistryState;
+export declare function resolvePluginCapability(registryState: PluginRegistryState, request: PluginCapabilityResolutionRequest): PluginCapabilityResolution;
+//# sourceMappingURL=plugin-registry.d.ts.map

package/dist/core/sdd/plugin-registry.js

@@ -0,0 +1,138 @@
+import { z } from 'zod';
+import { pluginCapabilitySchema, pluginManifestSchema, } from './plugin-manifest.js';
+const TRUST_RANK = {
+    'enterprise-approved': 3,
+    'local-dev': 2,
+    experimental: 1,
+    blocked: 0,
+};
+const RISK_RANK = {
+    low: 4,
+    medium: 3,
+    high: 2,
+    critical: 1,
+};
+export const pluginRegistrySourceSchema = z.object({
+    type: z.enum(['local', 'workspace', 'enterprise-catalog']),
+    uri: z.string().min(1),
+    checksum: z.string().optional(),
+});
+export const pluginRegistryEntrySchema = z.object({
+    manifest: pluginManifestSchema,
+    source: pluginRegistrySourceSchema,
+    status: z.enum(['active', 'disabled', 'blocked', 'deprecated']).default('active'),
+    registered_at: z.string().datetime(),
+    notes: z.array(z.string()).default([]),
+});
+export const pluginRegistryStateSchema = z
+    .object({
+    schema_version: z.literal(1),
+    generated_at: z.string().datetime(),
+    entries: z.array(pluginRegistryEntrySchema).default([]),
+})
+    .superRefine((state, context) => {
+    const seen = new Set();
+    for (const [index, entry] of state.entries.entries()) {
+        const key = `${entry.manifest.id}@${entry.manifest.version}`;
+        if (seen.has(key)) {
+            context.addIssue({
+                code: 'custom',
+                path: ['entries', index, 'manifest', 'id'],
+                message: `Duplicate plugin registration: ${key}.`,
+            });
+        }
+        seen.add(key);
+    }
+});
+export function createPluginRegistryState(plugins, generatedAt = new Date().toISOString()) {
+    return pluginRegistryStateSchema.parse({
+        schema_version: 1,
+        generated_at: generatedAt,
+        entries: plugins.map((plugin) => ({
+            manifest: plugin.manifest,
+            source: plugin.source,
+            status: plugin.status ?? 'active',
+            registered_at: plugin.registered_at ?? generatedAt,
+            notes: plugin.notes ?? [],
+        })),
+    });
+}
+export function resolvePluginCapability(registryState, request) {
+    const registry = pluginRegistryStateSchema.parse(registryState);
+    const statuses = request.statuses ?? ['active'];
+    const trustTiers = request.trust_tiers ?? ['enterprise-approved', 'local-dev', 'experimental'];
+    const requireDryRun = request.require_dry_run ?? true;
+    const reasons = [];
+    const candidates = [];
+    for (const entry of registry.entries) {
+        const pluginRef = `${entry.manifest.id}@${entry.manifest.version}`;
+        const entryReasons = collectEntryRejectionReasons(entry, request, statuses, trustTiers);
+        if (entryReasons.length > 0) {
+            reasons.push(...entryReasons.map((reason) => `${pluginRef}: ${reason}`));
+            continue;
+        }
+        const capability = entry.manifest.capabilities.find((candidate) => candidate.name === request.capability);
+        if (!capability) {
+            reasons.push(`${pluginRef}: capability ${request.capability} is not advertised.`);
+            continue;
+        }
+        const capabilityReasons = collectCapabilityRejectionReasons(capability, request, requireDryRun);
+        if (capabilityReasons.length > 0) {
+            reasons.push(...capabilityReasons.map((reason) => `${pluginRef}/${capability.name}: ${reason}`));
+            continue;
+        }
+        candidates.push({
+            entry,
+            capability: pluginCapabilitySchema.parse(capability),
+            score: scoreCandidate(entry, capability),
+        });
+    }
+    const [winner] = candidates.sort((left, right) => {
+        if (right.score !== left.score) {
+            return right.score - left.score;
+        }
+        return `${left.entry.manifest.id}@${left.entry.manifest.version}`.localeCompare(`${right.entry.manifest.id}@${right.entry.manifest.version}`);
+    });
+    if (!winner) {
+        return {
+            status: 'unresolved',
+            reasons: reasons.length > 0 ? reasons : [`No registered plugins are available for ${request.capability}.`],
+        };
+    }
+    return {
+        status: 'resolved',
+        entry: winner.entry,
+        capability: winner.capability,
+        reasons: [`Resolved ${request.capability} to ${winner.entry.manifest.id}@${winner.entry.manifest.version}.`],
+    };
+}
+function collectEntryRejectionReasons(entry, request, statuses, trustTiers) {
+    const reasons = [];
+    if (!statuses.includes(entry.status)) {
+        reasons.push(`status ${entry.status} is not eligible.`);
+    }
+    if (!trustTiers.includes(entry.manifest.governance.trust_tier)) {
+        reasons.push(`trust tier ${entry.manifest.governance.trust_tier} is not eligible.`);
+    }
+    if (request.technology?.language && entry.manifest.technology.language !== request.technology.language) {
+        reasons.push(`language ${entry.manifest.technology.language} does not match ${request.technology.language}.`);
+    }
+    if (request.technology?.framework && entry.manifest.technology.framework !== request.technology.framework) {
+        reasons.push(`framework ${entry.manifest.technology.framework ?? '<none>'} does not match ${request.technology.framework}.`);
+    }
+    return reasons;
+}
+function collectCapabilityRejectionReasons(capability, request, requireDryRun) {
+    const reasons = [];
+    if (request.require_apply && !capability.supports_apply) {
+        reasons.push('apply mode is required but not supported.');
+    }
+    if (requireDryRun && !capability.supports_dry_run) {
+        reasons.push('dry-run mode is required but not supported.');
+    }
+    return reasons;
+}
+function scoreCandidate(entry, capability) {
+    return TRUST_RANK[entry.manifest.governance.trust_tier] * 100 + RISK_RANK[capability.risk_tier] * 10;
+}
+//# sourceMappingURL=plugin-registry.js.map

package/dist/core/sdd/plugin-skill-binding.d.ts

@@ -0,0 +1,151 @@
+import { z } from 'zod';
+import { type PluginRegistryState } from './plugin-registry.js';
+export declare const pluginSkillBindingSchema: z.ZodObject<{
+    schema_version: z.ZodDefault<z.ZodLiteral<1>>;
+    skill_id: z.ZodString;
+    plugin_id: z.ZodString;
+    plugin_version: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodArray<z.ZodString>;
+    operations: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    priority: z.ZodDefault<z.ZodNumber>;
+    status: z.ZodDefault<z.ZodEnum<{
+        disabled: "disabled";
+        active: "active";
+        deprecated: "deprecated";
+    }>>;
+    rationale: z.ZodOptional<z.ZodString>;
+    technology: z.ZodOptional<z.ZodObject<{
+        language: z.ZodOptional<z.ZodString>;
+        framework: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const pluginSkillBindingResolutionRequestSchema: z.ZodObject<{
+    schema_version: z.ZodDefault<z.ZodLiteral<1>>;
+    feature_ref: z.ZodString;
+    recommended_skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    requested_operation: z.ZodOptional<z.ZodString>;
+    requested_capability: z.ZodOptional<z.ZodString>;
+    explicit_plugin_id: z.ZodOptional<z.ZodString>;
+    technology: z.ZodOptional<z.ZodObject<{
+        language: z.ZodOptional<z.ZodString>;
+        framework: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    trust_tiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        experimental: "experimental";
+        blocked: "blocked";
+        "local-dev": "local-dev";
+        "enterprise-approved": "enterprise-approved";
+    }>>>;
+    statuses: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        disabled: "disabled";
+        active: "active";
+        blocked: "blocked";
+        deprecated: "deprecated";
+    }>>>;
+    require_apply: z.ZodDefault<z.ZodBoolean>;
+    require_dry_run: z.ZodDefault<z.ZodBoolean>;
+    created_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const pluginSkillBindingCandidateSchema: z.ZodObject<{
+    source: z.ZodEnum<{
+        "explicit-plugin": "explicit-plugin";
+        "skill-binding": "skill-binding";
+        "capability-match": "capability-match";
+    }>;
+    skill_id: z.ZodOptional<z.ZodString>;
+    plugin_ref: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>;
+    capability: z.ZodString;
+    operation: z.ZodOptional<z.ZodString>;
+    binding_priority: z.ZodOptional<z.ZodNumber>;
+    rank: z.ZodNumber;
+    reasons: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const pluginSkillBindingResolutionSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    created_at: z.ZodString;
+    status: z.ZodEnum<{
+        resolved: "resolved";
+        fallback: "fallback";
+    }>;
+    request: z.ZodObject<{
+        schema_version: z.ZodDefault<z.ZodLiteral<1>>;
+        feature_ref: z.ZodString;
+        recommended_skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        requested_operation: z.ZodOptional<z.ZodString>;
+        requested_capability: z.ZodOptional<z.ZodString>;
+        explicit_plugin_id: z.ZodOptional<z.ZodString>;
+        technology: z.ZodOptional<z.ZodObject<{
+            language: z.ZodOptional<z.ZodString>;
+            framework: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        trust_tiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            experimental: "experimental";
+            blocked: "blocked";
+            "local-dev": "local-dev";
+            "enterprise-approved": "enterprise-approved";
+        }>>>;
+        statuses: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            disabled: "disabled";
+            active: "active";
+            blocked: "blocked";
+            deprecated: "deprecated";
+        }>>>;
+        require_apply: z.ZodDefault<z.ZodBoolean>;
+        require_dry_run: z.ZodDefault<z.ZodBoolean>;
+        created_at: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    selected: z.ZodOptional<z.ZodObject<{
+        source: z.ZodEnum<{
+            "explicit-plugin": "explicit-plugin";
+            "skill-binding": "skill-binding";
+            "capability-match": "capability-match";
+        }>;
+        skill_id: z.ZodOptional<z.ZodString>;
+        plugin_ref: z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strip>;
+        capability: z.ZodString;
+        operation: z.ZodOptional<z.ZodString>;
+        binding_priority: z.ZodOptional<z.ZodNumber>;
+        rank: z.ZodNumber;
+        reasons: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    candidates: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        source: z.ZodEnum<{
+            "explicit-plugin": "explicit-plugin";
+            "skill-binding": "skill-binding";
+            "capability-match": "capability-match";
+        }>;
+        skill_id: z.ZodOptional<z.ZodString>;
+        plugin_ref: z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strip>;
+        capability: z.ZodString;
+        operation: z.ZodOptional<z.ZodString>;
+        binding_priority: z.ZodOptional<z.ZodNumber>;
+        rank: z.ZodNumber;
+        reasons: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    reasons: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    fallback: z.ZodOptional<z.ZodObject<{
+        strategy: z.ZodEnum<{
+            "manual-selection": "manual-selection";
+            "llm-guidance": "llm-guidance";
+            "no-compatible-plugin": "no-compatible-plugin";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PluginSkillBinding = z.infer<typeof pluginSkillBindingSchema>;
+export type PluginSkillBindingResolutionRequest = z.infer<typeof pluginSkillBindingResolutionRequestSchema>;
+export type PluginSkillBindingCandidate = z.infer<typeof pluginSkillBindingCandidateSchema>;
+export type PluginSkillBindingResolution = z.infer<typeof pluginSkillBindingResolutionSchema>;
+export type PluginSkillBindingInput = z.input<typeof pluginSkillBindingSchema>;
+export type PluginSkillBindingResolutionRequestInput = z.input<typeof pluginSkillBindingResolutionRequestSchema>;
+export declare function resolvePluginSkillBinding(registryState: PluginRegistryState, bindings: PluginSkillBindingInput[], request: PluginSkillBindingResolutionRequestInput): PluginSkillBindingResolution;
+//# sourceMappingURL=plugin-skill-binding.d.ts.map