@devtrack-solution/codesdd 1.2.3 → 1.2.4-rc3

package/dist/core/sdd/domain/change-safety-guardrails.js

@@ -0,0 +1,333 @@
+export const CHANGE_SAFETY_OPERATIONS = ['add', 'modify', 'remove', 'replace', 'refactor', 'optimize'];
+const DESTRUCTIVE_ADD_OPERATIONS = new Set(['delete', 'replace', 'rename']);
+const GOVERNED_OVERRIDE_REQUIRED_FIELDS = [
+    'feature_id',
+    'intent',
+    'rationale',
+    'rollback_plan',
+    'compensating_control',
+    'approver',
+    'expires_at',
+];
+export function isChangeSafetyOperation(value) {
+    return CHANGE_SAFETY_OPERATIONS.includes(value);
+}
+export function evaluateChangeSafety(contract, plannedChanges, options = {}) {
+    const violations = [];
+    const operation = contract.explicit_modification_intent?.operation ?? contract.intent?.operation;
+    if (plannedChanges.length === 0) {
+        violations.push({
+            code: 'planned_changes_missing',
+            message: 'Mutating change requires at least one planned file change.',
+        });
+    }
+    if (!operation) {
+        violations.push({
+            code: 'intent_missing',
+            message: 'Mutating change requires explicit_modification_intent.operation.',
+        });
+    }
+    else if (!isChangeSafetyOperation(operation)) {
+        violations.push({
+            code: 'intent_invalid',
+            message: `Invalid explicit_modification_intent.operation "${operation}".`,
+        });
+    }
+    const normalizedOperation = isChangeSafetyOperation(operation) ? operation : '';
+    const contextLock = contract.context_lock ?? {};
+    const governedOverride = evaluateGovernedOverride(contract, plannedChanges, normalizedOperation, options);
+    violations.push(...governedOverride.violations);
+    const hasValidGovernedOverride = governedOverride.status === 'valid';
+    for (const change of plannedChanges) {
+        const normalizedPath = normalizeProjectPath(change.path);
+        const previousPath = change.previous_path ? normalizeProjectPath(change.previous_path) : '';
+        const pathsToCheck = previousPath ? [normalizedPath, previousPath] : [normalizedPath];
+        if (normalizedOperation === 'add' && DESTRUCTIVE_ADD_OPERATIONS.has(change.operation)) {
+            violations.push({
+                code: 'add_intent_destructive_change',
+                message: '`operation: add` cannot delete, rename, or replace existing files.',
+                path: normalizedPath,
+            });
+        }
+        for (const candidatePath of pathsToCheck) {
+            if (isOutsideAllowedPaths(candidatePath, contextLock.allowed_paths)) {
+                violations.push({
+                    code: 'context_lock_outside_allowed_paths',
+                    message: `Path "${candidatePath}" is outside context_lock.allowed_paths.`,
+                    path: candidatePath,
+                });
+            }
+            if (matchesAnyPattern(candidatePath, contextLock.forbidden_paths)) {
+                violations.push({
+                    code: 'context_lock_forbidden_path',
+                    message: `Path "${candidatePath}" matches context_lock.forbidden_paths.`,
+                    path: candidatePath,
+                });
+            }
+            if (matchesAnyPattern(candidatePath, contextLock.protected_core) && !hasValidGovernedOverride) {
+                violations.push({
+                    code: 'protected_core_change',
+                    message: `Path "${candidatePath}" matches context_lock.protected_core and requires explicit override.`,
+                    path: candidatePath,
+                });
+            }
+        }
+    }
+    const counts = countPlannedChanges(plannedChanges);
+    violations.push(...evaluateChangeBudget(contract.change_budget, counts));
+    return {
+        status: violations.length > 0 ? 'blocked' : 'allowed',
+        operation: normalizedOperation,
+        violations,
+        counts,
+        governed_override: governedOverride,
+    };
+}
+export function countPlannedChanges(plannedChanges) {
+    const changedPaths = new Set();
+    let newFiles = 0;
+    let deletedFiles = 0;
+    for (const change of plannedChanges) {
+        changedPaths.add(normalizeProjectPath(change.path));
+        if (change.previous_path) {
+            changedPaths.add(normalizeProjectPath(change.previous_path));
+        }
+        if (change.operation === 'create') {
+            newFiles += 1;
+        }
+        if (change.operation === 'delete' || change.operation === 'replace') {
+            deletedFiles += 1;
+        }
+        if (change.operation === 'rename') {
+            newFiles += 1;
+            deletedFiles += 1;
+        }
+    }
+    return {
+        files_changed: changedPaths.size,
+        new_files: newFiles,
+        deleted_files: deletedFiles,
+    };
+}
+export function normalizeProjectPath(value) {
+    return value
+        .replace(/\\/g, '/')
+        .replace(/^\.\/+/, '')
+        .split('/')
+        .filter((segment) => segment.length > 0 && segment !== '.')
+        .join('/');
+}
+function evaluateGovernedOverride(contract, plannedChanges, operation, options) {
+    const requiredPaths = collectGovernedOverrideRequiredPaths(contract.context_lock, plannedChanges);
+    if (requiredPaths.length === 0) {
+        return {
+            required: false,
+            status: 'not_required',
+            violations: [],
+        };
+    }
+    const override = contract.governed_override;
+    if (!override) {
+        return {
+            required: true,
+            status: 'invalid',
+            violations: [
+                {
+                    code: 'governed_override_required',
+                    message: 'Replacement or protected-core change requires change_safety.governed_override.',
+                },
+            ],
+        };
+    }
+    const violations = [];
+    for (const field of GOVERNED_OVERRIDE_REQUIRED_FIELDS) {
+        if (!isNonEmptyString(override[field])) {
+            violations.push({
+                code: 'governed_override_field_missing',
+                message: `change_safety.governed_override.${field} is required.`,
+            });
+        }
+    }
+    if (!Array.isArray(override.write_scope) || override.write_scope.length === 0) {
+        violations.push({
+            code: 'governed_override_field_missing',
+            message: 'change_safety.governed_override.write_scope must include at least one path pattern.',
+        });
+    }
+    if (!Array.isArray(override.expected_deletions)) {
+        violations.push({
+            code: 'governed_override_field_missing',
+            message: 'change_safety.governed_override.expected_deletions must be declared.',
+        });
+    }
+    if (options.feature_id && override.feature_id && override.feature_id !== options.feature_id) {
+        violations.push({
+            code: 'governed_override_feature_mismatch',
+            message: `change_safety.governed_override.feature_id "${override.feature_id}" does not match "${options.feature_id}".`,
+        });
+    }
+    if (operation && override.intent && override.intent !== operation) {
+        violations.push({
+            code: 'governed_override_intent_mismatch',
+            message: `change_safety.governed_override.intent "${override.intent}" does not match explicit intent "${operation}".`,
+        });
+    }
+    violations.push(...evaluateOverrideExpiration(override.expires_at, options.now));
+    const writeScope = override.write_scope ?? [];
+    for (const candidatePath of requiredPaths) {
+        if (!matchesAnyPattern(candidatePath, writeScope)) {
+            violations.push({
+                code: 'governed_override_scope_mismatch',
+                message: `Path "${candidatePath}" is outside change_safety.governed_override.write_scope.`,
+                path: candidatePath,
+            });
+        }
+    }
+    const expectedDeletions = override.expected_deletions;
+    if (Array.isArray(expectedDeletions)) {
+        const actualDeletions = collectDestructivePaths(plannedChanges);
+        const declaredDeletions = normalizeSortedUnique(expectedDeletions);
+        if (!sameStringList(actualDeletions, declaredDeletions)) {
+            violations.push({
+                code: 'governed_override_deletions_mismatch',
+                message: `change_safety.governed_override.expected_deletions must match planned destructive paths. Expected ${JSON.stringify(actualDeletions)}, received ${JSON.stringify(declaredDeletions)}.`,
+            });
+        }
+    }
+    return {
+        required: true,
+        status: violations.length === 0 ? 'valid' : 'invalid',
+        violations,
+    };
+}
+function collectGovernedOverrideRequiredPaths(contextLock, plannedChanges) {
+    const required = new Set();
+    for (const change of plannedChanges) {
+        const affectedPaths = getAffectedPaths(change);
+        if (change.operation === 'replace') {
+            affectedPaths.forEach((path) => required.add(path));
+        }
+        for (const candidatePath of affectedPaths) {
+            if (matchesAnyPattern(candidatePath, contextLock?.protected_core)) {
+                required.add(candidatePath);
+            }
+        }
+    }
+    return [...required].sort();
+}
+function collectDestructivePaths(plannedChanges) {
+    const paths = new Set();
+    for (const change of plannedChanges) {
+        if (change.operation === 'delete' || change.operation === 'replace') {
+            paths.add(normalizeProjectPath(change.path));
+        }
+        if (change.operation === 'rename') {
+            paths.add(normalizeProjectPath(change.previous_path ?? change.path));
+        }
+    }
+    return [...paths].sort();
+}
+function getAffectedPaths(change) {
+    const paths = [normalizeProjectPath(change.path)];
+    if (change.previous_path) {
+        paths.push(normalizeProjectPath(change.previous_path));
+    }
+    return paths;
+}
+function evaluateOverrideExpiration(expiresAt, now) {
+    if (!expiresAt)
+        return [];
+    const expiresAtMs = Date.parse(expiresAt);
+    if (!Number.isFinite(expiresAtMs)) {
+        return [
+            {
+                code: 'governed_override_expires_at_invalid',
+                message: 'change_safety.governed_override.expires_at must be a valid ISO timestamp.',
+            },
+        ];
+    }
+    const nowMs = now ? new Date(now).getTime() : Date.now();
+    if (expiresAtMs <= nowMs) {
+        return [
+            {
+                code: 'governed_override_expired',
+                message: 'change_safety.governed_override.expires_at has expired.',
+            },
+        ];
+    }
+    return [];
+}
+function normalizeSortedUnique(values) {
+    return [...new Set(values.map(normalizeProjectPath))].sort();
+}
+function sameStringList(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function evaluateChangeBudget(budget, counts) {
+    if (!budget)
+        return [];
+    const violations = [];
+    if (exceedsBudget(counts.files_changed, budget.max_files_changed)) {
+        violations.push({
+            code: 'change_budget_files_exceeded',
+            message: `Changed files count ${counts.files_changed} exceeds change_budget.max_files_changed ${budget.max_files_changed}.`,
+            limit: budget.max_files_changed,
+            actual: counts.files_changed,
+        });
+    }
+    if (exceedsBudget(counts.new_files, budget.max_new_files)) {
+        violations.push({
+            code: 'change_budget_new_files_exceeded',
+            message: `New files count ${counts.new_files} exceeds change_budget.max_new_files ${budget.max_new_files}.`,
+            limit: budget.max_new_files,
+            actual: counts.new_files,
+        });
+    }
+    if (exceedsBudget(counts.deleted_files, budget.max_deleted_files)) {
+        violations.push({
+            code: 'change_budget_deleted_files_exceeded',
+            message: `Deleted files count ${counts.deleted_files} exceeds change_budget.max_deleted_files ${budget.max_deleted_files}.`,
+            limit: budget.max_deleted_files,
+            actual: counts.deleted_files,
+        });
+    }
+    return violations;
+}
+function exceedsBudget(actual, limit) {
+    return typeof limit === 'number' && actual > limit;
+}
+function isOutsideAllowedPaths(candidatePath, allowedPatterns) {
+    if (!allowedPatterns || allowedPatterns.length === 0)
+        return false;
+    return !matchesAnyPattern(candidatePath, allowedPatterns);
+}
+function matchesAnyPattern(candidatePath, patterns) {
+    if (!patterns || patterns.length === 0)
+        return false;
+    return patterns.some((pattern) => pathMatchesPattern(candidatePath, pattern));
+}
+export function pathMatchesPattern(candidatePath, pattern) {
+    const normalizedPath = normalizeProjectPath(candidatePath);
+    const exactDirectory = /[\\/]$/.test(pattern);
+    const normalizedPattern = normalizeProjectPath(pattern);
+    if (!normalizedPattern)
+        return false;
+    if (exactDirectory) {
+        return normalizedPath === normalizedPattern || normalizedPath.startsWith(`${normalizedPattern}/`);
+    }
+    const regex = globToRegExp(normalizedPattern);
+    return regex.test(normalizedPath);
+}
+function globToRegExp(pattern) {
+    const placeholder = '\u0000';
+    const escaped = pattern
+        .split('**')
+        .map((part) => part.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '[^/]*'))
+        .join(placeholder);
+    const source = escaped.replaceAll(placeholder, '.*');
+    return new RegExp(`^${source}$`);
+}
+//# sourceMappingURL=change-safety-guardrails.js.map

package/dist/core/sdd/domain/semantic-intent-classifier.d.ts

@@ -0,0 +1,29 @@
+import type { CapabilityDiffReport, CapabilityRiskReport } from './capability-diff.js';
+import type { ChangeSafetyOperation } from './change-safety-guardrails.js';
+export declare const SEMANTIC_INTENT_CLASSES: readonly ["incremental", "refactor", "replacement", "ambiguous"];
+export type SemanticIntentClass = (typeof SEMANTIC_INTENT_CLASSES)[number];
+export interface SemanticIntentClassifierInput {
+    objective?: string;
+    declared_operation?: ChangeSafetyOperation | '';
+    capability_diff?: CapabilityDiffReport;
+    deterministic_risk?: CapabilityRiskReport;
+}
+export interface SemanticIntentSignal {
+    code: string;
+    message: string;
+    weight: number;
+}
+export interface SemanticIntentClassification {
+    schema_version: 1;
+    contract: 'semantic-intent-classification/v1';
+    status: 'allowed' | 'blocked';
+    classification: SemanticIntentClass;
+    fail_closed: true;
+    triggered: boolean;
+    confidence: number;
+    reasons: string[];
+    signals: SemanticIntentSignal[];
+}
+export declare function shouldRunSemanticIntentClassifier(input: SemanticIntentClassifierInput): boolean;
+export declare function classifySemanticIntent(input: SemanticIntentClassifierInput): SemanticIntentClassification;
+//# sourceMappingURL=semantic-intent-classifier.d.ts.map

package/dist/core/sdd/domain/semantic-intent-classifier.js

@@ -0,0 +1,117 @@
+export const SEMANTIC_INTENT_CLASSES = ['incremental', 'refactor', 'replacement', 'ambiguous'];
+const REPLACEMENT_PATTERNS = [
+    /\breplace\b/iu,
+    /\brewrite\b/iu,
+    /\brebuild\b/iu,
+    /\bfrom scratch\b/iu,
+    /\boverwrite\b/iu,
+    /\bsubstitu(?:ir|icao|ição)\b/iu,
+    /\bsobrescrev/iu,
+    /\breescrev/iu,
+    /\bdo zero\b/iu,
+];
+const REFACTOR_PATTERNS = [/\brefactor\b/iu, /\brefator/iu, /\boptimi[sz]e\b/iu, /\botimiz/iu];
+const INCREMENTAL_PATTERNS = [
+    /\badd\b/iu,
+    /\bcreate\b/iu,
+    /\bextend\b/iu,
+    /\bincremental\b/iu,
+    /\bcriar\b/iu,
+    /\badicionar\b/iu,
+    /\bincrement/iu,
+];
+const HIGH_RISK_LEVELS = new Set(['high', 'critical']);
+export function shouldRunSemanticIntentClassifier(input) {
+    return Boolean(input.deterministic_risk && HIGH_RISK_LEVELS.has(input.deterministic_risk.level));
+}
+export function classifySemanticIntent(input) {
+    const triggered = shouldRunSemanticIntentClassifier(input);
+    const signals = collectSignals(input);
+    const classification = resolveClassification(input, signals);
+    const highRisk = Boolean(input.deterministic_risk && HIGH_RISK_LEVELS.has(input.deterministic_risk.level));
+    const blocked = triggered &&
+        (classification === 'replacement' ||
+            classification === 'ambiguous' ||
+            (highRisk && input.declared_operation === 'add' && hasRemovedCapability(input.capability_diff)));
+    return {
+        schema_version: 1,
+        contract: 'semantic-intent-classification/v1',
+        status: blocked ? 'blocked' : 'allowed',
+        classification,
+        fail_closed: true,
+        triggered,
+        confidence: confidenceFor(classification, signals),
+        reasons: blocked ? blockedReasons(classification, input) : [],
+        signals,
+    };
+}
+function collectSignals(input) {
+    const objective = input.objective ?? '';
+    const signals = [];
+    collectPatternSignals(objective, REPLACEMENT_PATTERNS, signals, 'replacement_language', 50);
+    collectPatternSignals(objective, REFACTOR_PATTERNS, signals, 'refactor_language', 30);
+    collectPatternSignals(objective, INCREMENTAL_PATTERNS, signals, 'incremental_language', 30);
+    if (input.declared_operation === 'replace' || input.declared_operation === 'remove') {
+        signals.push({
+            code: 'declared_replacement_operation',
+            message: `Declared operation ${input.declared_operation} is replacement-class.`,
+            weight: 60,
+        });
+    }
+    if (hasRemovedCapability(input.capability_diff)) {
+        signals.push({
+            code: 'removed_capability_present',
+            message: 'Capability diff contains removed capabilities.',
+            weight: 45,
+        });
+    }
+    if (input.deterministic_risk?.level === 'critical') {
+        signals.push({
+            code: 'critical_deterministic_risk',
+            message: 'Deterministic risk is critical.',
+            weight: 50,
+        });
+    }
+    return signals.sort((left, right) => right.weight - left.weight || left.code.localeCompare(right.code));
+}
+function collectPatternSignals(value, patterns, signals, code, weight) {
+    if (patterns.some((pattern) => pattern.test(value))) {
+        signals.push({ code, message: `Objective matched ${code}.`, weight });
+    }
+}
+function resolveClassification(input, signals) {
+    const hasReplacement = signals.some((signal) => ['replacement_language', 'declared_replacement_operation', 'removed_capability_present'].includes(signal.code));
+    const hasIncremental = signals.some((signal) => signal.code === 'incremental_language') || input.declared_operation === 'add';
+    const hasRefactor = signals.some((signal) => signal.code === 'refactor_language') || input.declared_operation === 'refactor';
+    if (hasReplacement && (hasIncremental || hasRefactor))
+        return 'ambiguous';
+    if (hasReplacement)
+        return 'replacement';
+    if (hasRefactor)
+        return 'refactor';
+    if (hasIncremental)
+        return 'incremental';
+    return input.deterministic_risk && HIGH_RISK_LEVELS.has(input.deterministic_risk.level) ? 'ambiguous' : 'incremental';
+}
+function hasRemovedCapability(diff) {
+    return Boolean(diff?.entries.some((entry) => entry.change === 'removed'));
+}
+function confidenceFor(classification, signals) {
+    if (classification === 'ambiguous')
+        return 50;
+    const total = Math.min(100, signals.filter((signal) => signal.weight > 0).reduce((sum, signal) => sum + signal.weight, 40));
+    return total;
+}
+function blockedReasons(classification, input) {
+    if (classification === 'replacement') {
+        return ['Semantic intent classifier fail-closed because the request is replacement-class.'];
+    }
+    if (classification === 'ambiguous') {
+        return ['Semantic intent classifier fail-closed because high-risk intent is ambiguous.'];
+    }
+    if (input.declared_operation === 'add' && hasRemovedCapability(input.capability_diff)) {
+        return ['Semantic intent classifier fail-closed because add intent conflicts with removed capabilities.'];
+    }
+    return [];
+}
+//# sourceMappingURL=semantic-intent-classifier.js.map

package/dist/core/sdd/foundation-artifact-map-validator.d.ts

@@ -0,0 +1,16 @@
+import { type PluginArtifactMap } from './plugin-sdk-contract.js';
+export type FoundationArtifactMapFindingCode = 'FOUNDATION_ARTIFACT_SCHEMA_INVALID' | 'FOUNDATION_LAYER_PATH_MISMATCH' | 'FOUNDATION_DOMAIN_BO_PATH_INVALID' | 'FOUNDATION_DOMAIN_VO_PATH_INVALID' | 'FOUNDATION_APPLICATION_PORT_PATH_INVALID' | 'FOUNDATION_INFRASTRUCTURE_ENTITY_PATH_INVALID';
+export interface FoundationArtifactMapFinding {
+    code: FoundationArtifactMapFindingCode;
+    severity: 'warn';
+    path?: string;
+    message: string;
+    remediation: string;
+}
+export interface FoundationArtifactMapValidationResult {
+    status: 'passed' | 'warning';
+    artifact_map?: PluginArtifactMap;
+    findings: FoundationArtifactMapFinding[];
+}
+export declare function validateFoundationArtifactMapArchitecture(value: unknown): FoundationArtifactMapValidationResult;
+//# sourceMappingURL=foundation-artifact-map-validator.d.ts.map

package/dist/core/sdd/foundation-artifact-map-validator.js

@@ -0,0 +1,71 @@
+import { pluginArtifactMapSchema, } from './plugin-sdk-contract.js';
+const LAYER_PATH_PREFIXES = {
+    domain: 'src/domain/',
+    application: 'src/application/',
+    infrastructure: 'src/infrastructure/',
+    presentation: 'src/presentation/',
+    tests: 'test/',
+    docs: 'docs/',
+    sdd: '.sdd/',
+    config: '.',
+};
+const DOMAIN_BO_PATTERN = /^src\/domain\/[^/]+\/business-objects\/[^/]+\.bo\.ts$/u;
+const DOMAIN_VO_PATTERN = /^src\/domain\/[^/]+\/value-objects\/[^/]+\.vo\.ts$/u;
+const APPLICATION_PORT_PATTERN = /^src\/application\/business\/[^/]+\/ports\/out\/[^/]+\.port\.ts$/u;
+const INFRASTRUCTURE_ENTITY_PATTERN = /^src\/infrastructure\/adapters\/orm\/entities\/[^/]+\.orm-entity\.ts$/u;
+export function validateFoundationArtifactMapArchitecture(value) {
+    const parsed = pluginArtifactMapSchema.safeParse(value);
+    if (!parsed.success) {
+        return {
+            status: 'warning',
+            findings: [
+                {
+                    code: 'FOUNDATION_ARTIFACT_SCHEMA_INVALID',
+                    severity: 'warn',
+                    message: `Artifact map failed SDK schema validation: ${parsed.error.issues.map(formatIssue).join('; ')}`,
+                    remediation: 'Validate the artifact map with @devtrack-solution/codesdd-plugin-sdk before applying Foundation architecture checks.',
+                },
+            ],
+        };
+    }
+    const findings = parsed.data.artifacts.flatMap(validateEntry);
+    return {
+        status: findings.length > 0 ? 'warning' : 'passed',
+        artifact_map: parsed.data,
+        findings,
+    };
+}
+function validateEntry(entry) {
+    const findings = [];
+    const expectedPrefix = LAYER_PATH_PREFIXES[entry.layer];
+    if (expectedPrefix && !entry.path.startsWith(expectedPrefix)) {
+        findings.push(finding('FOUNDATION_LAYER_PATH_MISMATCH', entry, `Artifact declares layer "${entry.layer}" but path "${entry.path}" does not use the expected prefix "${expectedPrefix}".`, `Move the artifact under ${expectedPrefix} or correct the layer metadata before execution.`));
+    }
+    if (entry.layer === 'domain' && entry.role === 'business-object' && !DOMAIN_BO_PATTERN.test(entry.path)) {
+        findings.push(finding('FOUNDATION_DOMAIN_BO_PATH_INVALID', entry, `Domain business object path "${entry.path}" does not match the Foundation BO-pattern.`, 'Use src/domain/<context>/business-objects/<name>.bo.ts for new Foundation contexts.'));
+    }
+    if (entry.layer === 'domain' && entry.role === 'value-object' && !DOMAIN_VO_PATTERN.test(entry.path)) {
+        findings.push(finding('FOUNDATION_DOMAIN_VO_PATH_INVALID', entry, `Domain value object path "${entry.path}" does not match the Foundation VO-pattern.`, 'Use src/domain/<context>/value-objects/<name>.vo.ts for value objects.'));
+    }
+    if (entry.role === 'repository-port' && !APPLICATION_PORT_PATTERN.test(entry.path)) {
+        findings.push(finding('FOUNDATION_APPLICATION_PORT_PATH_INVALID', entry, `Repository port path "${entry.path}" does not match the Foundation application ports/out pattern.`, 'Use src/application/business/<context>/ports/out/<name>.port.ts for BO-pattern repository ports.'));
+    }
+    if (entry.layer === 'infrastructure' && entry.role === 'entity' && !INFRASTRUCTURE_ENTITY_PATTERN.test(entry.path)) {
+        findings.push(finding('FOUNDATION_INFRASTRUCTURE_ENTITY_PATH_INVALID', entry, `Infrastructure entity path "${entry.path}" does not match the centralized TypeORM entity pattern.`, 'Use src/infrastructure/adapters/orm/entities/<name>.orm-entity.ts for TypeORM entities.'));
+    }
+    return findings;
+}
+function finding(code, entry, message, remediation) {
+    return {
+        code,
+        severity: 'warn',
+        path: entry.path,
+        message,
+        remediation,
+    };
+}
+function formatIssue(issue) {
+    const issuePath = issue.path.length > 0 ? issue.path.join('.') : '<root>';
+    return `${issuePath}: ${issue.message}`;
+}
+//# sourceMappingURL=foundation-artifact-map-validator.js.map

package/dist/core/sdd/foundation-layer-manifest.d.ts

@@ -0,0 +1,24 @@
+export declare const CODESDD_FOUNDATION_LAYER_IDS: readonly ["domains", "applications", "infrastructures", "presentations", "shared"];
+export type CodesddFoundationLayerId = (typeof CODESDD_FOUNDATION_LAYER_IDS)[number];
+export interface CodesddFoundationLayerMapping {
+    layer: CodesddFoundationLayerId;
+    root: `src/${CodesddFoundationLayerId}`;
+    entrypoint: `src/${CodesddFoundationLayerId}/${string}`;
+    legacy_roots: string[];
+    role: string;
+    migration_status: 'active-facade' | 'legacy-source';
+}
+export interface CodesddFoundationLayerFinding {
+    code: 'FOUNDATION_LAYER_MISSING' | 'FOUNDATION_LAYER_ROOT_MISMATCH' | 'FOUNDATION_LAYER_ENTRYPOINT_MISMATCH' | 'FOUNDATION_LAYER_DUPLICATE' | 'FOUNDATION_LAYER_FORBIDDEN_PROJECT_RUNTIME';
+    layer?: string;
+    path?: string;
+    message: string;
+}
+export interface CodesddFoundationLayerValidationReport {
+    valid: boolean;
+    findings: CodesddFoundationLayerFinding[];
+}
+export declare const CODESDD_FOUNDATION_LAYER_MANIFEST: readonly CodesddFoundationLayerMapping[];
+export declare function listCodesddFoundationLayerRoots(manifest?: readonly CodesddFoundationLayerMapping[]): string[];
+export declare function validateCodesddFoundationLayerManifest(manifest?: readonly CodesddFoundationLayerMapping[]): CodesddFoundationLayerValidationReport;
+//# sourceMappingURL=foundation-layer-manifest.d.ts.map