@devtrack-solution/codesdd 1.2.2 → 1.2.4-rc3

package/dist/core/sdd/sanitize.d.ts

@@ -1,4 +1,6 @@
-import { type StructuralDiagnosticReport, type StructuralSanitizerReport, type StructuralSanitizerTransactionManifest } from './structural-health.js';
+import { type StructuralDiagnosticReport, type StructuralSanitizerReport, type StructuralSanitizerTransactionManifest, type StructuralSanitizerTransactionOperation } from './structural-health.js';
+export type Finding = StructuralDiagnosticReport['findings'][number];
+export type SanitizerAction = StructuralSanitizerReport['actions'][number];
 export interface SddSanitizeCommandOptions {
     dryRun?: boolean;
     apply?: boolean;
@@ -27,6 +29,33 @@ export declare class SddSanitizeOptionsError extends Error {
 export declare class SddSanitizeApplyError extends Error {
     constructor(message: string);
 }
+export declare function actionToken(input: string): string;
+export declare function createSourceReportId(report: StructuralDiagnosticReport): string;
+export declare function isInsidePath(rootPath: string, candidatePath: string): boolean;
+export declare function toAuditTimestampToken(value?: Date): string;
+export declare function createTransactionId(sourceReportId: string, value?: Date): string;
+export declare function pathExists(targetPath: string): Promise<boolean>;
+export declare function hashPath(targetPath: string): Promise<string | undefined>;
+export declare function resolveInSddRoot(projectRoot: string, memoryRoot: string, candidatePath: string, label: string): Promise<string>;
+export declare function transactionDirs(projectRoot: string, transactionId: string): {
+    sanitizeRoot: string;
+    backupRoot: string;
+    manifestPath: string;
+    auditLogPath: string;
+};
+export declare function backupPath(targetPath: string, backupRoot: string): Promise<string | undefined>;
+export declare function removePathSafely(targetPath: string): Promise<void>;
+export declare function toLifecycleTargetPath(finding: Finding): string | undefined;
+export declare function toQuarantinePath(location?: string): string | undefined;
+export declare function toWorkspaceBackupPath(location?: string): string | undefined;
+export declare function inferOperation(finding: Finding): SanitizerAction['operation'];
+export declare function makeActionFromFinding(finding: Finding, index: number): SanitizerAction;
+export declare function buildSanitizerDryRunReport(report: StructuralDiagnosticReport): StructuralSanitizerReport;
+export declare function manifestSummary(operations: StructuralSanitizerTransactionOperation[]): StructuralSanitizerTransactionManifest['summary'];
+export declare function writeAuditLog(auditLogPath: string, lines: Array<Record<string, unknown>>): Promise<void>;
+export declare function rollbackOperation(projectRoot: string, memoryRoot: string, rollback: StructuralSanitizerTransactionOperation['rollback']): Promise<void>;
+export declare function applySanitizerPlan(projectRoot: string, source: 'diagnose' | 'report', diagnosticReport: StructuralDiagnosticReport, dryRunReport: StructuralSanitizerReport): Promise<SddSanitizeResult>;
+export declare function loadDiagnosticReportFromFile(projectRoot: string, reportPath: string): Promise<StructuralDiagnosticReport>;
 export declare function formatSanitizerText(report: StructuralSanitizerReport): string;
 export declare class SddSanitizeCommand {
     execute(projectRoot: string, options?: SddSanitizeCommandOptions): Promise<SddSanitizeResult>;

package/dist/core/sdd/sanitize.js

@@ -19,11 +19,11 @@ export class SddSanitizeApplyError extends Error {
         this.name = 'SddSanitizeApplyError';
     }
 }
-function actionToken(input) {
+export function actionToken(input) {
     const normalized = input.toUpperCase().replace(/[^A-Z0-9]+/g, '-').replace(/^-+|-+$/g, '');
     return normalized.length > 0 ? normalized : 'GENERIC';
 }
-function createSourceReportId(report) {
+export function createSourceReportId(report) {
     const digest = createHash('sha1')
         .update(JSON.stringify({
         root_path: report.root_path,
@@ -43,19 +43,19 @@ function createSourceReportId(report) {
         .toUpperCase();
     return `SH-REPORT-${digest}`;
 }
-function isInsidePath(rootPath, candidatePath) {
+export function isInsidePath(rootPath, candidatePath) {
     const relative = path.relative(rootPath, candidatePath);
     return relative === '' || (!!relative && !relative.startsWith('..') && !path.isAbsolute(relative));
 }
-function toAuditTimestampToken(value = new Date()) {
+export function toAuditTimestampToken(value = new Date()) {
     return value.toISOString().replace(/[-:]/g, '').replace(/\.\d{3}Z$/, 'Z');
 }
-function createTransactionId(sourceReportId, value = new Date()) {
+export function createTransactionId(sourceReportId, value = new Date()) {
     const timestamp = toAuditTimestampToken(value);
     const suffix = createHash('sha1').update(`${sourceReportId}:${value.toISOString()}`).digest('hex').slice(0, 8).toUpperCase();
     return `SAN-${timestamp}-${suffix}`;
 }
-async function pathExists(targetPath) {
+export async function pathExists(targetPath) {
     try {
         await lstat(targetPath);
         return true;
@@ -64,7 +64,7 @@ async function pathExists(targetPath) {
         return false;
     }
 }
-async function hashPath(targetPath) {
+export async function hashPath(targetPath) {
     let stat;
     try {
         stat = await lstat(targetPath);
@@ -88,7 +88,7 @@ async function hashPath(targetPath) {
     }
     return `other:${stat.mode}`;
 }
-async function resolveInSddRoot(projectRoot, memoryRoot, candidatePath, label) {
+export async function resolveInSddRoot(projectRoot, memoryRoot, candidatePath, label) {
     try {
         return await RootResolver.verifyRealpathContainment(projectRoot, memoryRoot, candidatePath, label);
     }
@@ -99,7 +99,7 @@ async function resolveInSddRoot(projectRoot, memoryRoot, candidatePath, label) {
         throw error;
     }
 }
-function transactionDirs(projectRoot, transactionId) {
+export function transactionDirs(projectRoot, transactionId) {
     const sanitizeRoot = path.resolve(projectRoot, '.sdd', 'reports', 'sanitize');
     const backupRoot = path.join(sanitizeRoot, transactionId, 'backups');
     return {
@@ -109,7 +109,7 @@ function transactionDirs(projectRoot, transactionId) {
         auditLogPath: path.join(sanitizeRoot, `${transactionId}-audit.jsonl`),
     };
 }
-async function backupPath(targetPath, backupRoot) {
+export async function backupPath(targetPath, backupRoot) {
     if (!(await pathExists(targetPath)))
         return undefined;
     const suffix = createHash('sha1').update(targetPath).digest('hex').slice(0, 10);
@@ -118,7 +118,7 @@ async function backupPath(targetPath, backupRoot) {
     await cp(targetPath, backupPathResolved, { recursive: true });
     return backupPathResolved;
 }
-async function removePathSafely(targetPath) {
+export async function removePathSafely(targetPath) {
     const stat = await lstat(targetPath).catch(() => null);
     if (!stat)
         return;
@@ -128,7 +128,7 @@ async function removePathSafely(targetPath) {
     }
     await unlink(targetPath);
 }
-function toLifecycleTargetPath(finding) {
+export function toLifecycleTargetPath(finding) {
     const evidence = finding.evidence;
     const expectedRoot = typeof evidence.expected_root === 'string' ? evidence.expected_root : undefined;
     const itemId = typeof evidence.id === 'string' ? evidence.id : undefined;
@@ -143,19 +143,19 @@ function toLifecycleTargetPath(finding) {
     }
     return undefined;
 }
-function toQuarantinePath(location) {
+export function toQuarantinePath(location) {
     if (!location)
         return undefined;
     const baseName = path.posix.basename(location);
     return path.posix.join('.sdd', 'quarantine', baseName);
 }
-function toWorkspaceBackupPath(location) {
+export function toWorkspaceBackupPath(location) {
     if (!location)
         return undefined;
     const normalized = location.replace(/\\/g, '/').replace(/^\.sdd\//, '');
     return path.posix.join('.sdd', 'backup', normalized);
 }
-function inferOperation(finding) {
+export function inferOperation(finding) {
     switch (finding.rule_id) {
         case 'SH-RULE-MISSING-DIRECTORY':
             return 'mkdir';
@@ -179,7 +179,7 @@ function inferOperation(finding) {
             return 'manual_review';
     }
 }
-function makeActionFromFinding(finding, index) {
+export function makeActionFromFinding(finding, index) {
     const operation = inferOperation(finding);
     const actionId = `SH-ACTION-${actionToken(finding.finding_id)}-${actionToken(operation)}-${index + 1}`;
     const candidate = {
@@ -216,7 +216,7 @@ function makeActionFromFinding(finding, index) {
         const id = typeof evidence.id === 'string' ? evidence.id : undefined;
         const hasLegacyMarkdown = evidence.has_legacy_markdown === true;
         candidate.notes = hasLegacyMarkdown && id
-            ? `${candidate.notes} Suggested migration: opensdd sdd migrate-workspace --feat ${id}.`
+            ? `${candidate.notes} Suggested migration: codesdd sdd migrate-workspace --feat ${id}.`
             : `${candidate.notes} Suggested repair: manually edit the YAML to satisfy the workspace schema.`;
     }
     if (finding.rule_id === 'SH-RULE-LIFECYCLE-VIOLATION') {
@@ -233,7 +233,7 @@ function makeActionFromFinding(finding, index) {
     }
     return StructuralSanitizerActionSchema.parse(candidate);
 }
-function buildSanitizerDryRunReport(report) {
+export function buildSanitizerDryRunReport(report) {
     const actions = [];
     const blockedActions = [];
     report.findings.forEach((finding, index) => {
@@ -253,7 +253,7 @@ function buildSanitizerDryRunReport(report) {
         blocked_actions: blockedActions,
     });
 }
-function manifestSummary(operations) {
+export function manifestSummary(operations) {
     return {
         applied: operations.filter((item) => item.status === 'applied').length,
         skipped: operations.filter((item) => item.status === 'skipped').length,
@@ -261,7 +261,7 @@ function manifestSummary(operations) {
         rolled_back: operations.filter((item) => item.status === 'rolled_back').length,
     };
 }
-async function writeAuditLog(auditLogPath, lines) {
+export async function writeAuditLog(auditLogPath, lines) {
     await mkdir(path.dirname(auditLogPath), { recursive: true });
     if (lines.length === 0) {
         await writeFile(auditLogPath, '', 'utf-8');
@@ -270,7 +270,7 @@ async function writeAuditLog(auditLogPath, lines) {
     const payload = `${lines.map((line) => JSON.stringify(line)).join('\n')}\n`;
     await writeFile(auditLogPath, payload, 'utf-8');
 }
-async function rollbackOperation(projectRoot, memoryRoot, rollback) {
+export async function rollbackOperation(projectRoot, memoryRoot, rollback) {
     const operation = StructuralSanitizerRollbackOperationSchema.parse(rollback);
     if (operation.operation === 'noop')
         return;
@@ -302,7 +302,7 @@ async function rollbackOperation(projectRoot, memoryRoot, rollback) {
         await cp(backup, target, { recursive: true });
     }
 }
-async function applySanitizerPlan(projectRoot, source, diagnosticReport, dryRunReport) {
+export async function applySanitizerPlan(projectRoot, source, diagnosticReport, dryRunReport) {
     const config = await loadProjectSddConfig(projectRoot);
     const paths = resolveSddPaths(path.resolve(projectRoot), config);
     const transactionId = createTransactionId(dryRunReport.source_report_id);
@@ -581,7 +581,7 @@ async function applySanitizerPlan(projectRoot, source, diagnosticReport, dryRunR
         transaction: manifest,
     };
 }
-async function loadDiagnosticReportFromFile(projectRoot, reportPath) {
+export async function loadDiagnosticReportFromFile(projectRoot, reportPath) {
     const absolutePath = path.resolve(projectRoot, reportPath);
     let raw;
     try {

package/dist/core/sdd/sdk-agent-plugin-quality-gates.d.ts

@@ -0,0 +1,150 @@
+import { z } from 'zod';
+export declare const sdkAgentPluginCoverageScopeSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    metrics: z.ZodObject<{
+        statements: z.ZodOptional<z.ZodNumber>;
+        branches: z.ZodOptional<z.ZodNumber>;
+        functions: z.ZodOptional<z.ZodNumber>;
+        lines: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    target: z.ZodOptional<z.ZodObject<{
+        statements: z.ZodOptional<z.ZodNumber>;
+        branches: z.ZodOptional<z.ZodNumber>;
+        functions: z.ZodOptional<z.ZodNumber>;
+        lines: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const sdkAgentPluginQualityGateInputSchema: z.ZodObject<{
+    schema_version: z.ZodDefault<z.ZodLiteral<1>>;
+    generated_at: z.ZodString;
+    feature_ref: z.ZodOptional<z.ZodString>;
+    package_governance: z.ZodOptional<z.ZodUnknown>;
+    language_runtime: z.ZodOptional<z.ZodUnknown>;
+    artifact_map: z.ZodOptional<z.ZodUnknown>;
+    agent_runtime_plans: z.ZodDefault<z.ZodArray<z.ZodUnknown>>;
+    plugin_compliance_indexes: z.ZodDefault<z.ZodArray<z.ZodUnknown>>;
+    coverage_scopes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        metrics: z.ZodObject<{
+            statements: z.ZodOptional<z.ZodNumber>;
+            branches: z.ZodOptional<z.ZodNumber>;
+            functions: z.ZodOptional<z.ZodNumber>;
+            lines: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        target: z.ZodOptional<z.ZodObject<{
+            statements: z.ZodOptional<z.ZodNumber>;
+            branches: z.ZodOptional<z.ZodNumber>;
+            functions: z.ZodOptional<z.ZodNumber>;
+            lines: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    required_agent_providers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        codex: "codex";
+        opencode: "opencode";
+        deepagents: "deepagents";
+    }>>>;
+    coverage_target: z.ZodDefault<z.ZodObject<{
+        statements: z.ZodOptional<z.ZodNumber>;
+        branches: z.ZodOptional<z.ZodNumber>;
+        functions: z.ZodOptional<z.ZodNumber>;
+        lines: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const sdkAgentPluginQualityGateIssueSchema: z.ZodObject<{
+    code: z.ZodString;
+    severity: z.ZodEnum<{
+        fail: "fail";
+        warn: "warn";
+    }>;
+    message: z.ZodString;
+    remediation: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const sdkAgentPluginQualityGateSchema: z.ZodObject<{
+    id: z.ZodString;
+    domain: z.ZodEnum<{
+        coverage: "coverage";
+        "agent-runtime": "agent-runtime";
+        "plugin-sdk": "plugin-sdk";
+        "plugin-compliance": "plugin-compliance";
+        "foundation-architecture": "foundation-architecture";
+    }>;
+    status: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        warn: "warn";
+    }>;
+    severity: z.ZodEnum<{
+        info: "info";
+        fail: "fail";
+        warn: "warn";
+    }>;
+    evidence: z.ZodString;
+    issues: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        severity: z.ZodEnum<{
+            fail: "fail";
+            warn: "warn";
+        }>;
+        message: z.ZodString;
+        remediation: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const sdkAgentPluginQualityGateReportSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    generated_at: z.ZodString;
+    feature_ref: z.ZodOptional<z.ZodString>;
+    decision: z.ZodEnum<{
+        warning: "warning";
+        failed: "failed";
+        passed: "passed";
+    }>;
+    summary: z.ZodObject<{
+        total: z.ZodNumber;
+        passed: z.ZodNumber;
+        warned: z.ZodNumber;
+        failed: z.ZodNumber;
+    }, z.core.$strip>;
+    gates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        domain: z.ZodEnum<{
+            coverage: "coverage";
+            "agent-runtime": "agent-runtime";
+            "plugin-sdk": "plugin-sdk";
+            "plugin-compliance": "plugin-compliance";
+            "foundation-architecture": "foundation-architecture";
+        }>;
+        status: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            warn: "warn";
+        }>;
+        severity: z.ZodEnum<{
+            info: "info";
+            fail: "fail";
+            warn: "warn";
+        }>;
+        evidence: z.ZodString;
+        issues: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            severity: z.ZodEnum<{
+                fail: "fail";
+                warn: "warn";
+            }>;
+            message: z.ZodString;
+            remediation: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SdkAgentPluginCoverageScope = z.infer<typeof sdkAgentPluginCoverageScopeSchema>;
+export type SdkAgentPluginQualityGateInput = z.input<typeof sdkAgentPluginQualityGateInputSchema>;
+export type SdkAgentPluginQualityGateIssue = z.infer<typeof sdkAgentPluginQualityGateIssueSchema>;
+export type SdkAgentPluginQualityGate = z.infer<typeof sdkAgentPluginQualityGateSchema>;
+export type SdkAgentPluginQualityGateReport = z.infer<typeof sdkAgentPluginQualityGateReportSchema>;
+export declare function buildSdkAgentPluginQualityGateReport(value: SdkAgentPluginQualityGateInput): SdkAgentPluginQualityGateReport;
+export declare function buildSdkAgentPluginQualityGateJsonSchemas(): Record<string, unknown>;
+//# sourceMappingURL=sdk-agent-plugin-quality-gates.d.ts.map

package/dist/core/sdd/sdk-agent-plugin-quality-gates.js

@@ -0,0 +1,258 @@
+import { toJSONSchema, z } from 'zod';
+import { agentRuntimeCommandPlanSchema, agentRuntimeProviderSchema, } from './agent-runtime-contract.js';
+import { validateFoundationArtifactMapArchitecture } from './foundation-artifact-map-validator.js';
+import { pluginComplianceIndexSchema } from './plugin-evidence.js';
+import { pluginArtifactMapSchema, pluginLanguageRuntimeSchema, pluginPackageGovernanceSchema, } from './plugin-sdk-contract.js';
+const JSON_SCHEMA_DRAFT = 'https://json-schema.org/draft/2020-12/schema';
+const FEATURE_REF_PATTERN = /^FEAT-\d{4}$/;
+const ISSUE_CODE_PATTERN = /^[A-Z][A-Z0-9_]*$/;
+const coverageMetricsSchema = z
+    .object({
+    statements: z.number().min(0).max(100).optional(),
+    branches: z.number().min(0).max(100).optional(),
+    functions: z.number().min(0).max(100).optional(),
+    lines: z.number().min(0).max(100).optional(),
+})
+    .refine((metrics) => Object.keys(metrics).length > 0, {
+    message: 'At least one coverage metric is required.',
+});
+export const sdkAgentPluginCoverageScopeSchema = z.object({
+    id: z.string().min(1),
+    label: z.string().min(1),
+    metrics: coverageMetricsSchema,
+    target: coverageMetricsSchema.optional(),
+});
+export const sdkAgentPluginQualityGateInputSchema = z.object({
+    schema_version: z.literal(1).default(1),
+    generated_at: z.string().datetime(),
+    feature_ref: z.string().regex(FEATURE_REF_PATTERN).optional(),
+    package_governance: z.unknown().optional(),
+    language_runtime: z.unknown().optional(),
+    artifact_map: z.unknown().optional(),
+    agent_runtime_plans: z.array(z.unknown()).default([]),
+    plugin_compliance_indexes: z.array(z.unknown()).default([]),
+    coverage_scopes: z.array(sdkAgentPluginCoverageScopeSchema).default([]),
+    required_agent_providers: z.array(agentRuntimeProviderSchema).default(['deepagents', 'codex', 'opencode']),
+    coverage_target: coverageMetricsSchema.default({
+        statements: 95,
+        branches: 85,
+        functions: 95,
+        lines: 95,
+    }),
+});
+export const sdkAgentPluginQualityGateIssueSchema = z.object({
+    code: z.string().regex(ISSUE_CODE_PATTERN),
+    severity: z.enum(['warn', 'fail']),
+    message: z.string().min(1),
+    remediation: z.string().min(1),
+    path: z.string().min(1).optional(),
+});
+export const sdkAgentPluginQualityGateSchema = z.object({
+    id: z.string().min(1),
+    domain: z.enum([
+        'plugin-sdk',
+        'agent-runtime',
+        'plugin-compliance',
+        'foundation-architecture',
+        'coverage',
+    ]),
+    status: z.enum(['pass', 'warn', 'fail']),
+    severity: z.enum(['info', 'warn', 'fail']),
+    evidence: z.string().min(1),
+    issues: z.array(sdkAgentPluginQualityGateIssueSchema).default([]),
+});
+export const sdkAgentPluginQualityGateReportSchema = z.object({
+    schema_version: z.literal(1),
+    generated_at: z.string().datetime(),
+    feature_ref: z.string().regex(FEATURE_REF_PATTERN).optional(),
+    decision: z.enum(['passed', 'warning', 'failed']),
+    summary: z.object({
+        total: z.number().int().nonnegative(),
+        passed: z.number().int().nonnegative(),
+        warned: z.number().int().nonnegative(),
+        failed: z.number().int().nonnegative(),
+    }),
+    gates: z.array(sdkAgentPluginQualityGateSchema).min(1),
+});
+const COVERAGE_METRICS = ['statements', 'branches', 'functions', 'lines'];
+export function buildSdkAgentPluginQualityGateReport(value) {
+    const input = sdkAgentPluginQualityGateInputSchema.parse(value);
+    const gates = [
+        packageGovernanceGate(input.package_governance),
+        languageRuntimeGate(input.language_runtime),
+        artifactMapGate(input.artifact_map),
+        agentRuntimeGate(input.agent_runtime_plans, input.required_agent_providers),
+        pluginComplianceGate(input.plugin_compliance_indexes),
+        coverageGate(input.coverage_scopes, input.coverage_target),
+    ];
+    const summary = {
+        total: gates.length,
+        passed: gates.filter((gate) => gate.status === 'pass').length,
+        warned: gates.filter((gate) => gate.status === 'warn').length,
+        failed: gates.filter((gate) => gate.status === 'fail').length,
+    };
+    return sdkAgentPluginQualityGateReportSchema.parse({
+        schema_version: 1,
+        generated_at: input.generated_at,
+        feature_ref: input.feature_ref,
+        decision: summary.failed > 0 ? 'failed' : summary.warned > 0 ? 'warning' : 'passed',
+        summary,
+        gates,
+    });
+}
+export function buildSdkAgentPluginQualityGateJsonSchemas() {
+    return {
+        'sdk-agent-plugin-quality-gate-input.yaml': normalizeJsonSchema(sdkAgentPluginQualityGateInputSchema, 'CodeSDD SDK Agent Plugin Quality Gate Input', 'Input contract for validating plugin SDK, agent runtime, plugin compliance, Foundation artifact map, and coverage evidence together.'),
+        'sdk-agent-plugin-quality-gate-report.yaml': normalizeJsonSchema(sdkAgentPluginQualityGateReportSchema, 'CodeSDD SDK Agent Plugin Quality Gate Report', 'Machine-readable quality gate report for SDK contracts, agent runtimes, plugin compliance indexes, Foundation artifact maps, and coverage scopes.'),
+    };
+}
+function packageGovernanceGate(value) {
+    if (value === undefined) {
+        return gate('plugin-sdk.package-governance', 'plugin-sdk', [
+            issue('SDK_PACKAGE_GOVERNANCE_MISSING', 'fail', 'Plugin package governance evidence is missing.', 'Attach package_governance from @devtrack-solution/codesdd-plugin-sdk before accepting the plugin package.'),
+        ], 'No package governance evidence was provided.');
+    }
+    const parsed = pluginPackageGovernanceSchema.safeParse(value);
+    if (!parsed.success) {
+        return gate('plugin-sdk.package-governance', 'plugin-sdk', [
+            issue('SDK_PACKAGE_GOVERNANCE_INVALID', 'fail', `Package governance failed validation: ${formatIssues(parsed.error.issues)}`, 'Use the @devtrack-solution/codesdd-plugin-* package prefix, SemVer, package kind, and required discovery keywords.'),
+        ], 'Package governance evidence failed SDK validation.');
+    }
+    return gate('plugin-sdk.package-governance', 'plugin-sdk', [], `Package governance passed for ${parsed.data.package_name}.`);
+}
+function languageRuntimeGate(value) {
+    if (value === undefined) {
+        return gate('plugin-sdk.language-runtime', 'plugin-sdk', [
+            issue('SDK_LANGUAGE_RUNTIME_MISSING', 'fail', 'Plugin language runtime evidence is missing.', 'Declare language_runtime with bridge and transport metadata before planning standalone plugin execution.'),
+        ], 'No language runtime evidence was provided.');
+    }
+    const parsed = pluginLanguageRuntimeSchema.safeParse(value);
+    if (!parsed.success) {
+        return gate('plugin-sdk.language-runtime', 'plugin-sdk', [
+            issue('SDK_LANGUAGE_RUNTIME_INVALID', 'fail', `Language runtime failed validation: ${formatIssues(parsed.error.issues)}`, 'Use a valid bridge for the plugin language and declare commands for process-backed runtimes.'),
+        ], 'Language runtime evidence failed SDK validation.');
+    }
+    return gate('plugin-sdk.language-runtime', 'plugin-sdk', [], `Language runtime passed for ${parsed.data.language} through ${parsed.data.bridge}.`);
+}
+function artifactMapGate(value) {
+    if (value === undefined) {
+        return gate('foundation.artifact-map', 'foundation-architecture', [
+            issue('SDK_ARTIFACT_MAP_MISSING', 'fail', 'Plugin artifact map evidence is missing.', 'Attach a typed artifact map before accepting generated or modified project files.'),
+        ], 'No artifact map evidence was provided.');
+    }
+    const sdkParsed = pluginArtifactMapSchema.safeParse(value);
+    if (!sdkParsed.success) {
+        return gate('foundation.artifact-map', 'foundation-architecture', [
+            issue('SDK_ARTIFACT_MAP_INVALID', 'fail', `Artifact map failed SDK validation: ${formatIssues(sdkParsed.error.issues)}`, 'Validate artifact maps with the CodeSDD plugin SDK before Foundation architecture checks run.'),
+        ], 'Artifact map failed SDK schema validation.');
+    }
+    const foundation = validateFoundationArtifactMapArchitecture(sdkParsed.data);
+    const issues = foundation.findings.map((finding) => issue(finding.code, 'warn', finding.message, finding.remediation, finding.path));
+    return gate('foundation.artifact-map', 'foundation-architecture', issues, `Artifact map contains ${sdkParsed.data.artifacts.length} artifacts; Foundation architecture status is ${foundation.status}.`);
+}
+function agentRuntimeGate(values, requiredProviders) {
+    const plansByProvider = new Map();
+    const issues = [];
+    values.forEach((value, index) => {
+        const parsed = agentRuntimeCommandPlanSchema.safeParse(value);
+        if (!parsed.success) {
+            issues.push(issue('AGENT_RUNTIME_PLAN_INVALID', 'fail', `Agent runtime plan at index ${index} failed validation: ${formatIssues(parsed.error.issues)}`, 'Build agent execution through the Agent Runtime v2 command-plan contract.', `agent_runtime_plans.${index}`));
+            return;
+        }
+        const plan = parsed.data;
+        plansByProvider.set(plan.provider, (plansByProvider.get(plan.provider) ?? 0) + 1);
+        if (plan.status === 'blocked') {
+            issues.push(issue('AGENT_RUNTIME_PLAN_BLOCKED', 'fail', `${plan.provider} plan is blocked: ${plan.reasons.join('; ') || 'no reason provided'}`, 'Resolve runtime policy findings or keep the agent outside executable apply flows.', `agent_runtime_plans.${index}`));
+        }
+    });
+    for (const provider of requiredProviders) {
+        if (!plansByProvider.has(provider)) {
+            issues.push(issue('AGENT_RUNTIME_PROVIDER_MISSING', 'fail', `Required agent runtime provider ${provider} has no command plan.`, 'Attach command plans for DeepAgents, Codex exec, and OpenCode run before closing agent-runtime coverage.', provider));
+        }
+    }
+    return gate('agent-runtime.v2-command-plans', 'agent-runtime', issues, `Validated ${values.length} agent runtime plans across ${plansByProvider.size} providers.`);
+}
+function pluginComplianceGate(values) {
+    const issues = [];
+    if (values.length === 0) {
+        issues.push(issue('PLUGIN_COMPLIANCE_INDEX_MISSING', 'fail', 'No plugin compliance index was attached.', 'Attach at least one compliance index generated from plugin evidence before accepting plugin quality gates.'));
+    }
+    values.forEach((value, index) => {
+        const parsed = pluginComplianceIndexSchema.safeParse(value);
+        if (!parsed.success) {
+            issues.push(issue('PLUGIN_COMPLIANCE_INDEX_INVALID', 'fail', `Plugin compliance index at index ${index} failed validation: ${formatIssues(parsed.error.issues)}`, 'Build compliance indexes through the plugin evidence contract.', `plugin_compliance_indexes.${index}`));
+            return;
+        }
+        if (parsed.data.decision === 'non-compliant') {
+            issues.push(issue('PLUGIN_COMPLIANCE_NON_COMPLIANT', 'fail', `${parsed.data.plugin_ref.id}@${parsed.data.plugin_ref.version} is non-compliant with score ${parsed.data.score}.`, 'Resolve failing compliance criteria before enabling plugin execution.', `plugin_compliance_indexes.${index}`));
+        }
+        else if (parsed.data.decision === 'warning') {
+            issues.push(issue('PLUGIN_COMPLIANCE_WARNING', 'warn', `${parsed.data.plugin_ref.id}@${parsed.data.plugin_ref.version} has warning compliance with score ${parsed.data.score}.`, 'Record the accepted residual risk or improve plugin evidence before apply modes.', `plugin_compliance_indexes.${index}`));
+        }
+    });
+    return gate('plugin-compliance.indexes', 'plugin-compliance', issues, `Validated ${values.length} plugin compliance indexes.`);
+}
+function coverageGate(scopes, defaultTarget) {
+    const issues = [];
+    if (scopes.length === 0) {
+        issues.push(issue('COVERAGE_SCOPE_MISSING', 'fail', 'No coverage scope evidence was attached.', 'Attach coverage metrics for touched SDK, agent runtime, and plugin modules.'));
+    }
+    for (const scope of scopes) {
+        const target = { ...defaultTarget, ...scope.target };
+        for (const metric of COVERAGE_METRICS) {
+            const targetValue = target[metric];
+            if (targetValue === undefined)
+                continue;
+            const actual = scope.metrics[metric];
+            if (actual === undefined) {
+                issues.push(issue('COVERAGE_METRIC_MISSING', 'fail', `Coverage scope ${scope.id} is missing ${metric} coverage.`, `Record ${metric} coverage or remove ${metric} from the scope target.`, scope.id));
+            }
+            else if (actual < targetValue) {
+                issues.push(issue('COVERAGE_TARGET_MISSED', 'fail', `Coverage scope ${scope.id} has ${metric} ${formatPercent(actual)}, below target ${formatPercent(targetValue)}.`, 'Add tests for the touched contract or record a formal CodeSDD exception with compensating controls.', scope.id));
+            }
+        }
+    }
+    return gate('coverage.touched-contracts', 'coverage', issues, `Validated ${scopes.length} coverage scopes against touched-contract targets.`);
+}
+function gate(id, domain, issues, evidence) {
+    const status = issues.some((item) => item.severity === 'fail')
+        ? 'fail'
+        : issues.length > 0
+            ? 'warn'
+            : 'pass';
+    return sdkAgentPluginQualityGateSchema.parse({
+        id,
+        domain,
+        status,
+        severity: status === 'pass' ? 'info' : status,
+        evidence,
+        issues,
+    });
+}
+function issue(code, severity, message, remediation, path) {
+    return sdkAgentPluginQualityGateIssueSchema.parse({
+        code,
+        severity,
+        message,
+        remediation,
+        path,
+    });
+}
+function normalizeJsonSchema(schema, title, description) {
+    return {
+        ...toJSONSchema(schema),
+        $schema: JSON_SCHEMA_DRAFT,
+        title,
+        description,
+    };
+}
+function formatIssues(issues) {
+    return issues.map((item) => {
+        const issuePath = item.path.length > 0 ? item.path.join('.') : '<root>';
+        return `${issuePath}: ${item.message}`;
+    }).join('; ');
+}
+function formatPercent(value) {
+    return `${value.toFixed(2)} percent`;
+}
+//# sourceMappingURL=sdk-agent-plugin-quality-gates.js.map