@devtrack-solution/codesdd 1.2.2 → 1.2.4-rc3

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

@@ -0,0 +1,212 @@
+import path from 'node:path';
+import { z } from 'zod';
+import { pluginManifestSchema } from './plugin-manifest.js';
+const APPROVAL_ORDER = ['none', 'maintainer', 'security', 'architecture-board'];
+const SENSITIVE_ENV_NAME_PATTERN = /(SECRET|TOKEN|PASSWORD|PRIVATE|KEY|CREDENTIAL)/;
+const SECRET_PATH_SEGMENTS = ['.env', 'secret', 'secrets', 'credential', 'credentials', 'token', '.aws', '.ssh', 'id_rsa'];
+export const pluginPolicyEvaluationRequestSchema = z.object({
+    capability: z.string().min(1),
+    mode: z.enum(['dry-run', 'apply', 'rollback']).default('dry-run'),
+    approval_grants: z.array(z.enum(['maintainer', 'security', 'architecture-board'])).default([]),
+    source_checksum: z.string().optional(),
+    requested_write_scope: z.array(z.string().min(1)).default([]),
+    planned_writes: z.array(z.string().min(1)).default([]),
+    requested_env: z.array(z.string().min(1)).default([]),
+    network_domains: z.array(z.string().min(1)).default([]),
+    process_spawn_requested: z.boolean().default(false),
+    filesystem_checks: z
+        .array(z.object({
+        path: z.string().min(1),
+        real_path: z.string().min(1),
+        project_root: z.string().min(1),
+        is_symlink: z.boolean().default(false),
+    }))
+        .default([]),
+});
+export const pluginPolicyIssueSchema = z.object({
+    code: z.string().min(1),
+    severity: z.enum(['deny', 'warn']),
+    message: z.string().min(1),
+    path: z.string().optional(),
+});
+export const pluginPolicyEvaluationSchema = z.object({
+    schema_version: z.literal(1),
+    plugin_ref: z.object({
+        id: z.string().min(1),
+        version: z.string().min(1),
+    }),
+    capability: z.string().min(1),
+    mode: z.enum(['dry-run', 'apply', 'rollback']),
+    decision: z.enum(['allow', 'warn', 'deny']),
+    issues: z.array(pluginPolicyIssueSchema).default([]),
+});
+export function evaluatePluginTrustPolicy(manifest, request) {
+    const parsedManifest = pluginManifestSchema.parse(manifest);
+    const parsedRequest = pluginPolicyEvaluationRequestSchema.parse(request);
+    const issues = [];
+    const capability = parsedManifest.capabilities.find((candidate) => candidate.name === parsedRequest.capability);
+    if (!capability) {
+        issues.push(deny('CAPABILITY_NOT_FOUND', `Capability ${parsedRequest.capability} is not declared by the plugin.`));
+    }
+    else {
+        issues.push(...evaluateCapabilityPolicy(parsedManifest, capability, parsedRequest));
+    }
+    issues.push(...evaluateManifestPolicy(parsedManifest, parsedRequest));
+    return pluginPolicyEvaluationSchema.parse({
+        schema_version: 1,
+        plugin_ref: {
+            id: parsedManifest.id,
+            version: parsedManifest.version,
+        },
+        capability: parsedRequest.capability,
+        mode: parsedRequest.mode,
+        decision: issues.some((issue) => issue.severity === 'deny')
+            ? 'deny'
+            : issues.some((issue) => issue.severity === 'warn')
+                ? 'warn'
+                : 'allow',
+        issues,
+    });
+}
+function evaluateCapabilityPolicy(manifest, capability, request) {
+    const issues = [];
+    if (request.mode === 'apply') {
+        if (!capability.supports_apply) {
+            issues.push(deny('APPLY_NOT_SUPPORTED', `Capability ${capability.name} does not support apply mode.`));
+        }
+        if (!capability.supports_dry_run) {
+            issues.push(deny('APPLY_WITHOUT_DRY_RUN', `Capability ${capability.name} cannot apply without dry-run support.`));
+        }
+        if (!hasApprovalGrant(capability.approval, request.approval_grants)) {
+            issues.push(deny('APPROVAL_REQUIRED', `Capability ${capability.name} requires ${capability.approval} approval before apply.`));
+        }
+    }
+    if (request.mode === 'rollback' && !capability.supports_rollback) {
+        issues.push(deny('ROLLBACK_NOT_SUPPORTED', `Capability ${capability.name} does not support rollback mode.`));
+    }
+    for (const writePath of [...request.requested_write_scope, ...request.planned_writes]) {
+        if (!isSafeRelativePath(writePath)) {
+            issues.push(deny('UNSAFE_WRITE_PATH', `Write path ${writePath} must be project-root relative.`, writePath));
+            continue;
+        }
+        if (isProtectedStatePath(writePath)) {
+            issues.push(deny('STATE_WRITE_FORBIDDEN', `Write path ${writePath} cannot mutate canonical state files.`, writePath));
+        }
+        if (isSecretPath(writePath)) {
+            issues.push(deny('SECRET_PATH_BLOCKED', `Write path ${writePath} was blocked by secret-path policy.`, writePath));
+        }
+        if (!isWithinDeclaredScopes(writePath, capability.write_scope)) {
+            issues.push(deny('UNDECLARED_CAPABILITY_WRITE', `Write path ${writePath} is outside capability write scope.`, writePath));
+        }
+        if (!isWithinDeclaredScopes(writePath, manifest.artifacts.writes)) {
+            issues.push(deny('UNDECLARED_ARTIFACT_WRITE', `Write path ${writePath} is outside manifest artifact writes.`, writePath));
+        }
+        if (isWithinDeclaredScopes(writePath, manifest.artifacts.forbidden_writes)) {
+            issues.push(deny('FORBIDDEN_ARTIFACT_WRITE', `Write path ${writePath} is explicitly forbidden.`, writePath));
+        }
+    }
+    return issues;
+}
+function evaluateManifestPolicy(manifest, request) {
+    const issues = [];
+    if (manifest.governance.trust_tier === 'blocked') {
+        issues.push(deny('PLUGIN_BLOCKED', `Plugin ${manifest.id} is blocked by governance trust tier.`));
+    }
+    else if (manifest.governance.trust_tier === 'experimental') {
+        issues.push(warn('PLUGIN_EXPERIMENTAL', `Plugin ${manifest.id} is marked experimental by governance trust tier.`));
+    }
+    if (manifest.supply_chain.checksum) {
+        if (!request.source_checksum) {
+            issues.push(deny('SOURCE_CHECKSUM_REQUIRED', `Plugin ${manifest.id} requires source checksum verification.`));
+        }
+        else if (request.source_checksum !== manifest.supply_chain.checksum) {
+            issues.push(deny('SOURCE_CHECKSUM_MISMATCH', `Plugin ${manifest.id} source checksum does not match manifest.`));
+        }
+    }
+    for (const envName of request.requested_env) {
+        if (isSensitiveEnvironmentVariable(envName)) {
+            issues.push(deny('SECRET_ENV_NOT_ALLOWED', `Environment variable ${envName} is classified as sensitive for plugin execution.`));
+        }
+        if (!manifest.execution.env_allowlist.includes(envName)) {
+            issues.push(deny('ENV_NOT_ALLOWED', `Environment variable ${envName} is not allowed by the plugin manifest.`));
+        }
+    }
+    issues.push(...evaluateNetworkPolicy(manifest, request));
+    if (request.process_spawn_requested && manifest.execution.process_spawn === 'forbidden') {
+        issues.push(deny('PROCESS_SPAWN_FORBIDDEN', `Plugin ${manifest.id} does not allow process spawning.`));
+    }
+    for (const check of request.filesystem_checks) {
+        if (!isSafeRelativePath(check.path)) {
+            issues.push(deny('UNSAFE_FILESYSTEM_PATH', `Filesystem check path ${check.path} is not project-root relative.`, check.path));
+            continue;
+        }
+        if (!isWithinRoot(check.real_path, check.project_root)) {
+            issues.push(deny('SYMLINK_ESCAPE', `Path ${check.path} resolves outside project root${check.is_symlink ? ' through a symlink' : ''}.`, check.path));
+        }
+    }
+    return issues;
+}
+function evaluateNetworkPolicy(manifest, request) {
+    if (request.network_domains.length === 0) {
+        return [];
+    }
+    if (manifest.execution.network === 'disabled') {
+        return request.network_domains.map((domain) => deny('NETWORK_DISABLED', `Network access to ${domain} is denied because plugin network is disabled.`));
+    }
+    if (manifest.execution.network !== 'restricted') {
+        return [];
+    }
+    return request.network_domains
+        .filter((domain) => !isAllowedDomain(domain, manifest.governance.allowed_domains))
+        .map((domain) => deny('NETWORK_DOMAIN_NOT_ALLOWED', `Network domain ${domain} is not allowed by governance policy.`));
+}
+function hasApprovalGrant(required, grants) {
+    if (required === 'none') {
+        return true;
+    }
+    const requiredRank = APPROVAL_ORDER.indexOf(required);
+    return grants.some((grant) => APPROVAL_ORDER.indexOf(grant) >= requiredRank);
+}
+function isAllowedDomain(domain, allowedDomains) {
+    return allowedDomains.some((allowedDomain) => domain === allowedDomain || domain.endsWith(`.${allowedDomain}`));
+}
+function isSafeRelativePath(value) {
+    if (value.startsWith('/') || /^[A-Za-z]:[\\/]/.test(value)) {
+        return false;
+    }
+    return !value.split(/[\\/]+/).some((segment) => segment === '..');
+}
+function isWithinDeclaredScopes(value, scopes) {
+    return scopes.some((scope) => value === scope || value.startsWith(`${scope}/`));
+}
+function isWithinRoot(realPath, projectRoot) {
+    const relative = path.relative(projectRoot, realPath);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+function isSensitiveEnvironmentVariable(envName) {
+    return SENSITIVE_ENV_NAME_PATTERN.test(envName);
+}
+function isProtectedStatePath(value) {
+    return value === '.sdd/state' || value.startsWith('.sdd/state/');
+}
+function isSecretPath(value) {
+    const lowerValue = value.toLowerCase();
+    return lowerValue.split(/[\\/]+/).some((segment) => SECRET_PATH_SEGMENTS.some((token) => segment.includes(token)));
+}
+function deny(code, message, issuePath) {
+    return {
+        code,
+        severity: 'deny',
+        message,
+        path: issuePath,
+    };
+}
+function warn(code, message, issuePath) {
+    return {
+        code,
+        severity: 'warn',
+        message,
+        path: issuePath,
+    };
+}
+//# sourceMappingURL=plugin-policy.js.map

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

@@ -0,0 +1,447 @@
+import { z } from 'zod';
+import { type PluginCapability, type PluginManifest } from './plugin-manifest.js';
+export declare const pluginRegistrySourceSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        workspace: "workspace";
+        local: "local";
+        "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>;
+        package_governance: z.ZodOptional<z.ZodObject<{
+            package_name: z.ZodString;
+            sdk_package: z.ZodDefault<z.ZodString>;
+            sdk_version: z.ZodDefault<z.ZodString>;
+            package_kind: z.ZodEnum<{
+                frontend: "frontend";
+                backend: "backend";
+                "full-stack": "full-stack";
+                generator: "generator";
+                validator: "validator";
+                evidence: "evidence";
+                "agent-adapter": "agent-adapter";
+                "policy-pack": "policy-pack";
+            }>;
+            versioning: z.ZodDefault<z.ZodLiteral<"semver">>;
+            registry: z.ZodDefault<z.ZodEnum<{
+                custom: "custom";
+                workspace: "workspace";
+                npm: "npm";
+                "private-npm": "private-npm";
+                "artifact-registry": "artifact-registry";
+            }>>;
+            keywords: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            internal_package: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        language_runtime: z.ZodOptional<z.ZodObject<{
+            language: z.ZodEnum<{
+                shell: "shell";
+                other: "other";
+                typescript: "typescript";
+                javascript: "javascript";
+                python: "python";
+                java: "java";
+                go: "go";
+                rust: "rust";
+                csharp: "csharp";
+                php: "php";
+                ruby: "ruby";
+            }>;
+            runtime: z.ZodString;
+            bridge: z.ZodEnum<{
+                "node-library": "node-library";
+                "stdio-json": "stdio-json";
+                "process-cli": "process-cli";
+                "http-local": "http-local";
+                container: "container";
+                wasm: "wasm";
+            }>;
+            input_transport: z.ZodEnum<{
+                "sdk-call": "sdk-call";
+                "stdin-json": "stdin-json";
+                "stdout-json": "stdout-json";
+                "file-envelope": "file-envelope";
+                "http-json": "http-json";
+            }>;
+            output_transport: z.ZodEnum<{
+                "sdk-call": "sdk-call";
+                "stdin-json": "stdin-json";
+                "stdout-json": "stdout-json";
+                "file-envelope": "file-envelope";
+                "http-json": "http-json";
+            }>;
+            command: z.ZodOptional<z.ZodString>;
+            args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            package_manager: z.ZodOptional<z.ZodString>;
+            min_versions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+            env_allowlist: z.ZodDefault<z.ZodArray<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";
+                enabled: "enabled";
+                restricted: "restricted";
+            }>>;
+            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<{
+            workspace: "workspace";
+            local: "local";
+            "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>;
+            package_governance: z.ZodOptional<z.ZodObject<{
+                package_name: z.ZodString;
+                sdk_package: z.ZodDefault<z.ZodString>;
+                sdk_version: z.ZodDefault<z.ZodString>;
+                package_kind: z.ZodEnum<{
+                    frontend: "frontend";
+                    backend: "backend";
+                    "full-stack": "full-stack";
+                    generator: "generator";
+                    validator: "validator";
+                    evidence: "evidence";
+                    "agent-adapter": "agent-adapter";
+                    "policy-pack": "policy-pack";
+                }>;
+                versioning: z.ZodDefault<z.ZodLiteral<"semver">>;
+                registry: z.ZodDefault<z.ZodEnum<{
+                    custom: "custom";
+                    workspace: "workspace";
+                    npm: "npm";
+                    "private-npm": "private-npm";
+                    "artifact-registry": "artifact-registry";
+                }>>;
+                keywords: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                internal_package: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            language_runtime: z.ZodOptional<z.ZodObject<{
+                language: z.ZodEnum<{
+                    shell: "shell";
+                    other: "other";
+                    typescript: "typescript";
+                    javascript: "javascript";
+                    python: "python";
+                    java: "java";
+                    go: "go";
+                    rust: "rust";
+                    csharp: "csharp";
+                    php: "php";
+                    ruby: "ruby";
+                }>;
+                runtime: z.ZodString;
+                bridge: z.ZodEnum<{
+                    "node-library": "node-library";
+                    "stdio-json": "stdio-json";
+                    "process-cli": "process-cli";
+                    "http-local": "http-local";
+                    container: "container";
+                    wasm: "wasm";
+                }>;
+                input_transport: z.ZodEnum<{
+                    "sdk-call": "sdk-call";
+                    "stdin-json": "stdin-json";
+                    "stdout-json": "stdout-json";
+                    "file-envelope": "file-envelope";
+                    "http-json": "http-json";
+                }>;
+                output_transport: z.ZodEnum<{
+                    "sdk-call": "sdk-call";
+                    "stdin-json": "stdin-json";
+                    "stdout-json": "stdout-json";
+                    "file-envelope": "file-envelope";
+                    "http-json": "http-json";
+                }>;
+                command: z.ZodOptional<z.ZodString>;
+                args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                package_manager: z.ZodOptional<z.ZodString>;
+                min_versions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+                env_allowlist: z.ZodDefault<z.ZodArray<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";
+                    enabled: "enabled";
+                    restricted: "restricted";
+                }>>;
+                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<{
+                workspace: "workspace";
+                local: "local";
+                "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