@devtrack-solution/codesdd 1.2.2 → 1.2.3

package/dist/core/sdd/plugin-policy-pack.d.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+import { type PluginManifest } from './plugin-manifest.js';
+export declare const pluginPolicyPackSchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodString;
+    applies_to: z.ZodDefault<z.ZodObject<{
+        trust_tiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            experimental: "experimental";
+            blocked: "blocked";
+            "local-dev": "local-dev";
+            "enterprise-approved": "enterprise-approved";
+        }>>>;
+    }, z.core.$strip>>;
+    requirements: z.ZodDefault<z.ZodObject<{
+        max_risk_tier: z.ZodDefault<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>>;
+        supply_chain: z.ZodDefault<z.ZodObject<{
+            checksum: z.ZodDefault<z.ZodBoolean>;
+            signature_or_provenance: z.ZodDefault<z.ZodBoolean>;
+            sbom: z.ZodDefault<z.ZodBoolean>;
+            sbom_formats: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                custom: "custom";
+                cyclonedx: "cyclonedx";
+                spdx: "spdx";
+            }>>>;
+        }, z.core.$strip>>;
+        validation: z.ZodDefault<z.ZodObject<{
+            min_coverage: z.ZodDefault<z.ZodNumber>;
+            security_checks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            dependency_checks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        execution: z.ZodDefault<z.ZodObject<{
+            network: z.ZodOptional<z.ZodEnum<{
+                disabled: "disabled";
+                restricted: "restricted";
+                enabled: "enabled";
+            }>>;
+            process_spawn: z.ZodOptional<z.ZodEnum<{
+                forbidden: "forbidden";
+                declared: "declared";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const pluginPolicyPackIssueSchema: z.ZodObject<{
+    code: z.ZodString;
+    severity: z.ZodEnum<{
+        deny: "deny";
+        warn: "warn";
+    }>;
+    message: z.ZodString;
+    policy_pack: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const pluginPolicyPackEvaluationSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    plugin_ref: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>;
+    decision: z.ZodEnum<{
+        deny: "deny";
+        warn: "warn";
+        allow: "allow";
+    }>;
+    declared_policy_packs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    applied_policy_packs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    issues: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        severity: z.ZodEnum<{
+            deny: "deny";
+            warn: "warn";
+        }>;
+        message: z.ZodString;
+        policy_pack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type PluginPolicyPack = z.infer<typeof pluginPolicyPackSchema>;
+export type PluginPolicyPackIssue = z.infer<typeof pluginPolicyPackIssueSchema>;
+export type PluginPolicyPackEvaluation = z.infer<typeof pluginPolicyPackEvaluationSchema>;
+export declare const ENTERPRISE_DEFAULT_POLICY_PACK: PluginPolicyPack;
+export declare const DEVTRACK_API_FOUNDATION_POLICY_PACK: PluginPolicyPack;
+export declare function evaluatePluginPolicyPacks(manifest: PluginManifest, policyPacks: PluginPolicyPack[]): PluginPolicyPackEvaluation;
+//# sourceMappingURL=plugin-policy-pack.d.ts.map

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

@@ -0,0 +1,236 @@
+import { z } from 'zod';
+import { pluginManifestSchema } from './plugin-manifest.js';
+const SEMVER_PATTERN = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/;
+const riskRank = {
+    low: 1,
+    medium: 2,
+    high: 3,
+    critical: 4,
+};
+export const pluginPolicyPackSchema = z.object({
+    id: z.string().regex(/^[a-z][a-z0-9-]*$/),
+    version: z.string().regex(SEMVER_PATTERN),
+    description: z.string().min(20),
+    applies_to: z
+        .object({
+        trust_tiers: z
+            .array(z.enum(['local-dev', 'experimental', 'enterprise-approved', 'blocked']))
+            .default(['enterprise-approved']),
+    })
+        .default({ trust_tiers: ['enterprise-approved'] }),
+    requirements: z
+        .object({
+        max_risk_tier: z.enum(['low', 'medium', 'high', 'critical']).default('medium'),
+        supply_chain: z
+            .object({
+            checksum: z.boolean().default(false),
+            signature_or_provenance: z.boolean().default(false),
+            sbom: z.boolean().default(false),
+            sbom_formats: z.array(z.enum(['cyclonedx', 'spdx', 'custom'])).default([]),
+        })
+            .default({ checksum: false, signature_or_provenance: false, sbom: false, sbom_formats: [] }),
+        validation: z
+            .object({
+            min_coverage: z.number().min(0).max(100).default(0),
+            security_checks: z.array(z.string().min(1)).default([]),
+            dependency_checks: z.array(z.string().min(1)).default([]),
+        })
+            .default({ min_coverage: 0, security_checks: [], dependency_checks: [] }),
+        execution: z
+            .object({
+            network: z.enum(['disabled', 'restricted', 'enabled']).optional(),
+            process_spawn: z.enum(['forbidden', 'declared']).optional(),
+        })
+            .default({}),
+    })
+        .default({
+        max_risk_tier: 'medium',
+        supply_chain: { checksum: false, signature_or_provenance: false, sbom: false, sbom_formats: [] },
+        validation: { min_coverage: 0, security_checks: [], dependency_checks: [] },
+        execution: {},
+    }),
+});
+export const pluginPolicyPackIssueSchema = z.object({
+    code: z.string().min(1),
+    severity: z.enum(['deny', 'warn']),
+    message: z.string().min(1),
+    policy_pack: z.string().optional(),
+});
+export const pluginPolicyPackEvaluationSchema = z.object({
+    schema_version: z.literal(1),
+    plugin_ref: z.object({
+        id: z.string().min(1),
+        version: z.string().min(1),
+    }),
+    decision: z.enum(['allow', 'warn', 'deny']),
+    declared_policy_packs: z.array(z.string()).default([]),
+    applied_policy_packs: z.array(z.string()).default([]),
+    issues: z.array(pluginPolicyPackIssueSchema).default([]),
+});
+export const ENTERPRISE_DEFAULT_POLICY_PACK = pluginPolicyPackSchema.parse({
+    id: 'enterprise-default',
+    version: '1.0.0',
+    description: 'Default enterprise plugin policy for supply-chain, validation, and safe execution controls.',
+    applies_to: {
+        trust_tiers: ['enterprise-approved', 'local-dev', 'experimental'],
+    },
+    requirements: {
+        max_risk_tier: 'high',
+        supply_chain: {
+            checksum: true,
+            signature_or_provenance: true,
+            sbom: true,
+            sbom_formats: ['cyclonedx', 'spdx'],
+        },
+        validation: {
+            min_coverage: 95,
+            security_checks: ['dependency-audit'],
+            dependency_checks: ['lockfile-review'],
+        },
+        execution: {
+            network: 'disabled',
+            process_spawn: 'forbidden',
+        },
+    },
+});
+export const DEVTRACK_API_FOUNDATION_POLICY_PACK = pluginPolicyPackSchema.parse({
+    id: 'devtrack-api-foundation',
+    version: '1.0.0',
+    description: 'DevTrack API Foundation appliance policy for TypeORM-only dependency and structural validation.',
+    applies_to: {
+        trust_tiers: ['enterprise-approved'],
+    },
+    requirements: {
+        max_risk_tier: 'high',
+        supply_chain: {
+            checksum: true,
+            signature_or_provenance: true,
+            sbom: true,
+            sbom_formats: ['cyclonedx'],
+        },
+        validation: {
+            min_coverage: 95,
+            security_checks: ['dependency-audit', 'no-secret-fixtures', 'no-out-of-root-writes'],
+            dependency_checks: ['lockfile-review', 'typeorm-only-persistence'],
+        },
+        execution: {
+            network: 'disabled',
+            process_spawn: 'forbidden',
+        },
+    },
+});
+export function evaluatePluginPolicyPacks(manifest, policyPacks) {
+    const parsedManifest = pluginManifestSchema.parse(manifest);
+    const parsedPolicyPacks = policyPacks.map((pack) => pluginPolicyPackSchema.parse(pack));
+    const packById = new Map(parsedPolicyPacks.map((pack) => [pack.id, pack]));
+    const issues = [];
+    const appliedPolicyPacks = [];
+    if (parsedManifest.governance.policy_packs.length === 0) {
+        issues.push(warn('NO_POLICY_PACK_DECLARED', `Plugin ${parsedManifest.id} declares no policy packs.`));
+    }
+    for (const policyPackId of parsedManifest.governance.policy_packs) {
+        const policyPack = packById.get(policyPackId);
+        if (!policyPack) {
+            issues.push(deny('POLICY_PACK_NOT_AVAILABLE', `Policy pack ${policyPackId} is not available.`, policyPackId));
+            continue;
+        }
+        appliedPolicyPacks.push(policyPack.id);
+        issues.push(...evaluatePolicyPack(parsedManifest, policyPack));
+    }
+    return pluginPolicyPackEvaluationSchema.parse({
+        schema_version: 1,
+        plugin_ref: {
+            id: parsedManifest.id,
+            version: parsedManifest.version,
+        },
+        decision: issues.some((issue) => issue.severity === 'deny')
+            ? 'deny'
+            : issues.some((issue) => issue.severity === 'warn')
+                ? 'warn'
+                : 'allow',
+        declared_policy_packs: parsedManifest.governance.policy_packs,
+        applied_policy_packs: appliedPolicyPacks,
+        issues,
+    });
+}
+function evaluatePolicyPack(manifest, policyPack) {
+    const issues = [];
+    if (!policyPack.applies_to.trust_tiers.includes(manifest.governance.trust_tier)) {
+        issues.push(warn('POLICY_PACK_NOT_APPLICABLE', `Policy pack ${policyPack.id} does not target trust tier ${manifest.governance.trust_tier}.`, policyPack.id));
+    }
+    if (riskRank[manifest.governance.risk_tier] > riskRank[policyPack.requirements.max_risk_tier]) {
+        issues.push(deny('RISK_TIER_EXCEEDS_POLICY', `Plugin risk tier ${manifest.governance.risk_tier} exceeds policy maximum ${policyPack.requirements.max_risk_tier}.`, policyPack.id));
+    }
+    issues.push(...evaluateSupplyChainPolicy(manifest, policyPack));
+    issues.push(...evaluateValidationPolicy(manifest, policyPack));
+    issues.push(...evaluateExecutionPolicy(manifest, policyPack));
+    return issues;
+}
+function evaluateSupplyChainPolicy(manifest, policyPack) {
+    const requirements = policyPack.requirements.supply_chain;
+    const issues = [];
+    if (requirements.checksum && !manifest.supply_chain.checksum) {
+        issues.push(deny('CHECKSUM_REQUIRED', `Policy pack ${policyPack.id} requires a checksum.`, policyPack.id));
+    }
+    if (requirements.signature_or_provenance && !manifest.supply_chain.signature && !manifest.supply_chain.provenance) {
+        issues.push(deny('SIGNATURE_OR_PROVENANCE_REQUIRED', `Policy pack ${policyPack.id} requires signature or provenance.`, policyPack.id));
+    }
+    if (requirements.sbom && !manifest.supply_chain.sbom) {
+        issues.push(deny('SBOM_REQUIRED', `Policy pack ${policyPack.id} requires SBOM metadata.`, policyPack.id));
+    }
+    if (manifest.supply_chain.sbom && requirements.sbom_formats.length > 0) {
+        const format = resolveSbomFormat(manifest.supply_chain.sbom);
+        if (!requirements.sbom_formats.includes(format)) {
+            issues.push(deny('SBOM_FORMAT_NOT_ALLOWED', `SBOM format ${format} is not allowed by policy pack ${policyPack.id}.`, policyPack.id));
+        }
+    }
+    return issues;
+}
+function evaluateValidationPolicy(manifest, policyPack) {
+    const requirements = policyPack.requirements.validation;
+    const issues = [];
+    if (manifest.validation.coverage_target < requirements.min_coverage) {
+        issues.push(deny('COVERAGE_TARGET_TOO_LOW', `Coverage target ${manifest.validation.coverage_target}% is below policy minimum ${requirements.min_coverage}%.`, policyPack.id));
+    }
+    issues.push(...missingValues(requirements.security_checks, manifest.validation.security_checks).map((check) => deny('SECURITY_CHECK_REQUIRED', `Required security check ${check} is missing.`, policyPack.id)));
+    issues.push(...missingValues(requirements.dependency_checks, manifest.validation.dependency_checks).map((check) => deny('DEPENDENCY_CHECK_REQUIRED', `Required dependency check ${check} is missing.`, policyPack.id)));
+    return issues;
+}
+function evaluateExecutionPolicy(manifest, policyPack) {
+    const requirements = policyPack.requirements.execution;
+    const issues = [];
+    if (requirements.network && manifest.execution.network !== requirements.network) {
+        issues.push(deny('NETWORK_POLICY_MISMATCH', `Network policy ${manifest.execution.network} does not match required ${requirements.network}.`, policyPack.id));
+    }
+    if (requirements.process_spawn && manifest.execution.process_spawn !== requirements.process_spawn) {
+        issues.push(deny('PROCESS_SPAWN_POLICY_MISMATCH', `Process spawn policy ${manifest.execution.process_spawn} does not match required ${requirements.process_spawn}.`, policyPack.id));
+    }
+    return issues;
+}
+function resolveSbomFormat(sbom) {
+    const prefix = sbom.split(':', 1)[0]?.toLowerCase();
+    if (prefix === 'cyclonedx' || prefix === 'spdx') {
+        return prefix;
+    }
+    return 'custom';
+}
+function missingValues(required, actual) {
+    return required.filter((value) => !actual.includes(value));
+}
+function deny(code, message, policyPack) {
+    return {
+        code,
+        severity: 'deny',
+        message,
+        policy_pack: policyPack,
+    };
+}
+function warn(code, message, policyPack) {
+    return {
+        code,
+        severity: 'warn',
+        message,
+        policy_pack: policyPack,
+    };
+}
+//# sourceMappingURL=plugin-policy-pack.js.map

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

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { type PluginManifest } from './plugin-manifest.js';
+export declare const pluginPolicyEvaluationRequestSchema: z.ZodObject<{
+    capability: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<{
+        apply: "apply";
+        "dry-run": "dry-run";
+        rollback: "rollback";
+    }>>;
+    approval_grants: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        maintainer: "maintainer";
+        security: "security";
+        "architecture-board": "architecture-board";
+    }>>>;
+    source_checksum: z.ZodOptional<z.ZodString>;
+    requested_write_scope: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    planned_writes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    requested_env: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    network_domains: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    process_spawn_requested: z.ZodDefault<z.ZodBoolean>;
+    filesystem_checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        real_path: z.ZodString;
+        project_root: z.ZodString;
+        is_symlink: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const pluginPolicyIssueSchema: z.ZodObject<{
+    code: z.ZodString;
+    severity: z.ZodEnum<{
+        deny: "deny";
+        warn: "warn";
+    }>;
+    message: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const pluginPolicyEvaluationSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    plugin_ref: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>;
+    capability: z.ZodString;
+    mode: z.ZodEnum<{
+        apply: "apply";
+        "dry-run": "dry-run";
+        rollback: "rollback";
+    }>;
+    decision: z.ZodEnum<{
+        deny: "deny";
+        warn: "warn";
+        allow: "allow";
+    }>;
+    issues: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        severity: z.ZodEnum<{
+            deny: "deny";
+            warn: "warn";
+        }>;
+        message: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type PluginPolicyEvaluationRequest = z.infer<typeof pluginPolicyEvaluationRequestSchema>;
+export type PluginPolicyIssue = z.infer<typeof pluginPolicyIssueSchema>;
+export type PluginPolicyEvaluation = z.infer<typeof pluginPolicyEvaluationSchema>;
+export declare function evaluatePluginTrustPolicy(manifest: PluginManifest, request: PluginPolicyEvaluationRequest): PluginPolicyEvaluation;
+//# sourceMappingURL=plugin-policy.d.ts.map

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