@devtrack-solution/codesdd 1.2.2

package/dist/core/sdd/check.js

@@ -0,0 +1,831 @@
+import { existsSync } from 'node:fs';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { CLI_NAME } from '../branding.js';
+import { ID_PATTERNS, } from './types.js';
+import { loadProjectSddConfig, loadStateSnapshot, resolveSddPaths, } from './state.js';
+import { DEFAULT_CURATED_SKILL_CATALOG } from './default-skills.js';
+import { renderViews } from './views.js';
+import { syncSddGuideDocs, validateSddGuideDocs } from './docs-sync.js';
+import { evaluateWorkspaceTraceability } from './domain/traceability.js';
+import { detectArchiveArchivedLifecycleCollisions } from './domain/post-active-validation.js';
+import { parseWorkspaceYamlDocument, workspaceTasksSchema, } from './workspace-schemas.js';
+function checkUniqueIds(items, scope, errors) {
+    const seen = new Set();
+    for (const item of items) {
+        if (seen.has(item.id)) {
+            errors.push(`ID duplicado "${item.id}" em ${scope}`);
+        }
+        seen.add(item.id);
+    }
+}
+const FORBIDDEN_TITLE_PATTERNS = ['debate:', 'insight:', '(preencher', '(placeholder'];
+function hasForbiddenTitleToken(title) {
+    const lowered = title.toLowerCase();
+    for (const token of FORBIDDEN_TITLE_PATTERNS) {
+        if (lowered.includes(token))
+            return token;
+    }
+    return null;
+}
+function validateDiscoveryRecords(records, errors) {
+    for (const record of records) {
+        if (record.type === 'INS' && !ID_PATTERNS.insight.test(record.id)) {
+            errors.push(`Discovery record ${record.id} is INS but does not follow INS-####`);
+        }
+        if (record.type === 'DEB' && !ID_PATTERNS.debate.test(record.id)) {
+            errors.push(`Discovery record ${record.id} is DEB but does not follow DEB-####`);
+        }
+        if (record.type === 'RAD' && !ID_PATTERNS.epicOrRadar.test(record.id)) {
+            errors.push(`Discovery record ${record.id} is RAD but does not follow RAD-### or EPIC-####`);
+        }
+        if (record.type === 'EPIC' && !ID_PATTERNS.epicOrRadar.test(record.id)) {
+            errors.push(`Discovery record ${record.id} is EPIC but does not follow EPIC-#### (or legacy RAD-###)`);
+        }
+        if (record.type === 'EPIC') {
+            const forbidden = hasForbiddenTitleToken(record.title);
+            if (forbidden) {
+                errors.push(`EPIC ${record.id} possui titulo invalido com token proibido "${forbidden}": "${record.title}"`);
+            }
+        }
+    }
+}
+function validateBacklog(items, errors, warnings) {
+    const ids = new Set(items.map((item) => item.id));
+    const lockOwners = new Map();
+    for (const item of items) {
+        const forbidden = hasForbiddenTitleToken(item.title);
+        if (forbidden) {
+            errors.push(`FEAT ${item.id} possui titulo invalido com token proibido "${forbidden}": "${item.title}"`);
+        }
+        if (item.origin_type !== 'direct' && !item.origin_ref) {
+            warnings.push(`Item de backlog ${item.id} tem origin_type="${item.origin_type}" mas origin_ref vazio`);
+        }
+        for (const dep of item.blocked_by) {
+            if (!ids.has(dep)) {
+                warnings.push(`Item de backlog ${item.id} bloqueado por referencia inexistente: ${dep}`);
+            }
+        }
+        for (const lock of item.lock_domains) {
+            const owners = lockOwners.get(lock) || [];
+            owners.push(item.id);
+            lockOwners.set(lock, owners);
+        }
+    }
+    for (const [lock, owners] of lockOwners.entries()) {
+        if (owners.length > 1) {
+            warnings.push(`Lock domain "${lock}" compartilhado por: ${owners.join(', ')}`);
+        }
+    }
+}
+function validateReferentialIntegrity(snapshot, errors, warnings, isStrict) {
+    const discoveryIds = new Set(snapshot.discoveryIndex.records.map((record) => record.id));
+    const backlogIds = new Set(snapshot.backlog.items.map((item) => item.id));
+    const frontendGapIds = new Set(snapshot.frontendGaps?.items.map((gap) => gap.id) ?? []);
+    const techDebtIds = new Set(snapshot.techDebt.items.map((item) => item.id));
+    const record = (message) => {
+        if (isStrict)
+            errors.push(message);
+        else
+            warnings.push(`[LEGACY] ${message}`);
+    };
+    for (const item of snapshot.backlog.items || []) {
+        if ((item.origin_type === 'epic' || item.origin_type === 'radar') && item.origin_ref) {
+            if (!discoveryIds.has(item.origin_ref)) {
+                record(`FEAT ${item.id} points to origin_ref="${item.origin_ref}", which does not exist in the discovery index.`);
+            }
+        }
+        if (item.origin_type === 'frontend_gap' && item.origin_ref && !frontendGapIds.has(item.origin_ref)) {
+            record(`FEAT ${item.id} aponta para frontend gap origin_ref="${item.origin_ref}" inexistente.`);
+        }
+        if (item.origin_type === 'tech_debt' && item.origin_ref && !techDebtIds.has(item.origin_ref)) {
+            record(`FEAT ${item.id} aponta para tech debt origin_ref="${item.origin_ref}" inexistente.`);
+        }
+        for (const dep of item.blocked_by || []) {
+            if (!backlogIds.has(dep)) {
+                record(`FEAT ${item.id} bloqueada por referencia inexistente: ${dep}`);
+            }
+        }
+    }
+    for (const rec of snapshot.discoveryIndex.records || []) {
+        for (const rel of rec.related_ids || []) {
+            if (!discoveryIds.has(rel) && !backlogIds.has(rel)) {
+                record(`Discovery ${rec.id} has related_id="${rel}" referencing an unknown ID in the ecosystem (neither Discovery nor Backlog).`);
+            }
+        }
+    }
+    if (snapshot.finalizeQueue?.items) {
+        for (const fq of snapshot.finalizeQueue.items) {
+            if (!backlogIds.has(fq.feature_id)) {
+                record(`Finalize queue has entry for feature_id="${fq.feature_id}" blocked by an unknown feature.`);
+            }
+        }
+    }
+    if (snapshot.unblockEvents?.events) {
+        for (const ev of snapshot.unblockEvents.events) {
+            if (!backlogIds.has(ev.feature_id)) {
+                record(`Unblock event points to feature_id="${ev.feature_id}", which is no longer listed in the backlog.`);
+            }
+            if (ev.unblocked_by && !backlogIds.has(ev.unblocked_by)) {
+                record(`Unblock event was triggered by unblocked_by="${ev.unblocked_by}" pointing to an unknown FEAT.`);
+            }
+        }
+    }
+}
+function validateSkillOperationalIntegrity(snapshot, errors) {
+    const knownSkills = new Set((snapshot.skillCatalog?.skills || []).map((skill) => skill.id));
+    const currentBundles = new Map((snapshot.skillCatalog?.bundles || []).map((bundle) => [bundle.id, bundle]));
+    for (const defaultSkill of DEFAULT_CURATED_SKILL_CATALOG.skills) {
+        if (!knownSkills.has(defaultSkill.id)) {
+            errors.push(`Default curated skill "${defaultSkill.id}" is missing from skill-catalog.yaml`);
+        }
+    }
+    for (const bundle of snapshot.skillCatalog?.bundles || []) {
+        for (const skillId of bundle.skill_ids || []) {
+            if (!knownSkills.has(skillId)) {
+                errors.push(`Skill bundle "${bundle.id}" references unknown skill "${skillId}"`);
+            }
+        }
+    }
+    for (const defaultBundle of DEFAULT_CURATED_SKILL_CATALOG.bundles) {
+        const currentBundle = currentBundles.get(defaultBundle.id);
+        if (!currentBundle) {
+            errors.push(`Default skill bundle "${defaultBundle.id}" is missing from skill-catalog.yaml`);
+            continue;
+        }
+        for (const skillId of defaultBundle.skill_ids) {
+            if (!currentBundle.skill_ids.includes(skillId)) {
+                errors.push(`Default skill bundle "${defaultBundle.id}" is missing skill "${skillId}"`);
+            }
+        }
+    }
+    for (const skillId of snapshot.skillRouting?.default_skills || []) {
+        if (!knownSkills.has(skillId)) {
+            errors.push(`Skill routing default_skills references unknown skill "${skillId}"`);
+        }
+    }
+    for (const route of snapshot.skillRouting?.routes || []) {
+        for (const skillId of route.skills || []) {
+            if (!knownSkills.has(skillId)) {
+                errors.push(`Skill routing route "${route.domain}" references unknown skill "${skillId}"`);
+            }
+        }
+    }
+}
+function computeGraphSummary(items) {
+    const byId = new Map(items.map((item) => [item.id, item]));
+    const runnable = items.filter((item) => {
+        if (item.status === 'DONE' || item.status === 'ARCHIVED')
+            return false;
+        if (item.status === 'BLOCKED')
+            return false;
+        const unresolvedDeps = item.blocked_by.filter((depId) => {
+            const dep = byId.get(depId);
+            return !dep || dep.status !== 'DONE';
+        });
+        return unresolvedDeps.length === 0;
+    });
+    const lockOwners = new Map();
+    let blocked = 0;
+    let readyForParallel = 0;
+    for (const item of items) {
+        if (item.status === 'DONE' || item.status === 'ARCHIVED')
+            continue;
+        const unresolvedDeps = item.blocked_by.filter((depId) => {
+            const dep = byId.get(depId);
+            return !dep || dep.status !== 'DONE';
+        });
+        const isBlocked = item.status === 'BLOCKED' || unresolvedDeps.length > 0;
+        if (isBlocked)
+            blocked++;
+    }
+    for (const item of runnable) {
+        for (const lock of item.lock_domains) {
+            const owners = lockOwners.get(lock) || [];
+            owners.push(item.id);
+            lockOwners.set(lock, owners);
+        }
+    }
+    const conflictingIds = new Set();
+    for (const owners of lockOwners.values()) {
+        if (owners.length > 1) {
+            for (const id of owners)
+                conflictingIds.add(id);
+        }
+    }
+    for (const item of runnable) {
+        const hasConflict = conflictingIds.has(item.id);
+        if (item.status === 'READY' && !hasConflict) {
+            readyForParallel++;
+        }
+    }
+    return {
+        readyForParallel,
+        blocked,
+        lockConflicts: conflictingIds.size,
+    };
+}
+function roundPercent(done, total) {
+    if (total <= 0)
+        return 0;
+    return Math.round((done / total) * 100);
+}
+function computeProgress(items) {
+    const activeItems = items.filter((item) => item.status !== 'ARCHIVED');
+    const total = activeItems.length;
+    const done = activeItems.filter((item) => item.status === 'DONE').length;
+    const byRadar = new Map();
+    for (const item of activeItems) {
+        if ((item.origin_type !== 'radar' && item.origin_type !== 'epic') || !item.origin_ref)
+            continue;
+        const current = byRadar.get(item.origin_ref) || { done: 0, total: 0 };
+        current.total += 1;
+        if (item.status === 'DONE')
+            current.done += 1;
+        byRadar.set(item.origin_ref, current);
+    }
+    const progressByRadar = Array.from(byRadar.entries())
+        .sort((a, b) => a[0].localeCompare(b[0]))
+        .map(([radar_id, values]) => ({
+        radar_id,
+        done: values.done,
+        total: values.total,
+        percent: roundPercent(values.done, values.total),
+    }));
+    return {
+        progressGlobal: {
+            done,
+            total,
+            percent: roundPercent(done, total),
+        },
+        progressByRadar,
+    };
+}
+function validateTechDebt(items, errors) {
+    for (const item of items) {
+        if (!ID_PATTERNS.techDebt.test(item.id)) {
+            errors.push(`Technical debt item ${item.id} does not follow TD-###`);
+        }
+    }
+}
+function validateFrontendReferences(gaps, backlog, errors, warnings) {
+    const gapIds = new Set(gaps.map((g) => g.id));
+    for (const item of backlog) {
+        for (const gapRef of item.frontend_gap_refs) {
+            if (!gapIds.has(gapRef)) {
+                warnings.push(`Item de backlog ${item.id} referencia gap de frontend inexistente: ${gapRef}`);
+            }
+        }
+    }
+    const featureIds = new Set(backlog.map((b) => b.id));
+    for (const gap of gaps) {
+        if (gap.resolved_by_feature && !featureIds.has(gap.resolved_by_feature)) {
+            errors.push(`Frontend gap ${gap.id} has resolved_by_feature=${gap.resolved_by_feature}, which was not found in the backlog`);
+        }
+    }
+}
+async function validateActiveTaskChecklist(activeDir, items, warnings) {
+    for (const item of items) {
+        if (item.status !== 'IN_PROGRESS')
+            continue;
+        const taskDocPath = path.join(activeDir, item.id, '3-tasks.yaml');
+        if (!existsSync(taskDocPath)) {
+            warnings.push(`Task checklist missing for ${item.id} in .sdd/active.`);
+            continue;
+        }
+        const content = await fs.readFile(taskDocPath, 'utf-8').catch(() => '');
+        if (!content.trim()) {
+            warnings.push(`Task roadmap missing for ${item.id} in .sdd/active.`);
+            continue;
+        }
+        const parseResult = workspaceTasksSchema.safeParse(parseYaml(content));
+        if (!parseResult.success) {
+            warnings.push(`Task roadmap YAML invalid for ${item.id}: ${parseResult.error.message}`);
+            continue;
+        }
+        let taskRoadmap;
+        try {
+            taskRoadmap = parseWorkspaceYamlDocument('3-tasks.yaml', content);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warnings.push(`Task roadmap YAML invalid for ${item.id}: ${message}`);
+            continue;
+        }
+        const phases = new Set(taskRoadmap.tasks.map((task) => task.phase));
+        const missingPhases = ['preparation', 'implementation', 'testing', 'documentation', 'finalization'].filter((phase) => !phases.has(phase));
+        const testingTasksMissingScripts = taskRoadmap.tasks.some((task) => task.phase === 'testing' && task.test_scripts.length === 0);
+        if (missingPhases.length > 0 || testingTasksMissingScripts) {
+            const problems = [
+                missingPhases.length > 0 ? `missing phases ${missingPhases.join(', ')}` : '',
+                testingTasksMissingScripts ? 'testing tasks require test_scripts[]' : '',
+            ].filter(Boolean);
+            warnings.push(`Task roadmap incomplete for ${item.id}: ${problems.join('; ')}`);
+        }
+    }
+}
+async function validateWorkspaceCoherence(activeDir, archivedDir, items, warnings) {
+    for (const item of items) {
+        const activePath = path.join(activeDir, item.id);
+        const archivedPath = path.join(archivedDir, item.id);
+        const activeExists = existsSync(activePath);
+        const archivedExists = existsSync(archivedPath);
+        if (item.status === 'IN_PROGRESS' && !activeExists) {
+            warnings.push(`Feature ${item.id} em IN_PROGRESS sem workspace ativo em .sdd/active.`);
+        }
+        if ((item.status === 'DONE' || item.status === 'ARCHIVED') && activeExists) {
+            warnings.push(`Feature ${item.id} concluida ainda presente em .sdd/active.`);
+        }
+        if (item.status === 'IN_PROGRESS' && archivedExists) {
+            warnings.push(`Feature ${item.id} em IN_PROGRESS ja possui workspace em .sdd/archived.`);
+        }
+    }
+}
+function isPrivacyComplianceBacklogItem(item) {
+    if (item.origin_ref === 'EPIC-0020' || item.origin_ref === 'EPIC-0021')
+        return true;
+    const refs = new Set(item.acceptance_refs || []);
+    return refs.has('EPIC-0020') || refs.has('EPIC-0021') || refs.has('DEB-0021') || refs.has('INS-0021');
+}
+function validatePrivacySourceRegistry(snapshot, warnings) {
+    const privacyItems = snapshot.backlog.items.filter((item) => item.status !== 'DONE' && item.status !== 'ARCHIVED' && isPrivacyComplianceBacklogItem(item));
+    if (privacyItems.length === 0)
+        return;
+    if (snapshot.sourceIndex.jurisdiction_profiles.length === 0) {
+        warnings.push('Privacy compliance baseline incomplete: source-index.jurisdiction_profiles is empty while EPIC-0020/EPIC-0021 features are active.');
+    }
+    if (snapshot.sourceIndex.control_catalog.length === 0) {
+        warnings.push('Privacy compliance baseline incomplete: source-index.control_catalog is empty while EPIC-0020/EPIC-0021 features are active.');
+    }
+    if (snapshot.sourceIndex.version_events.length === 0) {
+        warnings.push('Privacy compliance baseline incomplete: source-index.version_events is empty while EPIC-0020/EPIC-0021 features are active.');
+    }
+    const activeRefs = new Set();
+    for (const item of privacyItems) {
+        activeRefs.add(item.id);
+        if (item.origin_ref)
+            activeRefs.add(item.origin_ref);
+    }
+    const missingMetadata = [];
+    for (const source of snapshot.sourceIndex.sources) {
+        const relevant = source.used_by.some((ref) => activeRefs.has(ref));
+        if (!relevant)
+            continue;
+        const hasAuthority = source.authority !== 'unknown';
+        const hasClassification = source.source_classification !== 'other';
+        const hasVerificationDate = Boolean((source.last_verified_at || '').trim());
+        const hasVersion = typeof source.source_version === 'number' && source.source_version > 0;
+        const hasFingerprint = Boolean((source.source_fingerprint || '').trim());
+        if (hasAuthority && hasClassification && hasVerificationDate && hasVersion && hasFingerprint)
+            continue;
+        missingMetadata.push(source.id);
+    }
+    if (missingMetadata.length > 0) {
+        warnings.push(`Privacy source registry metadata incomplete for: ${missingMetadata.slice(0, 12).join(', ')}${missingMetadata.length > 12 ? ' ...' : ''}`);
+    }
+}
+async function validatePrivacyWorkspaceChecklist(activeDir, items, warnings) {
+    const privacyItems = items.filter((item) => item.status === 'IN_PROGRESS' && isPrivacyComplianceBacklogItem(item));
+    for (const item of privacyItems) {
+        const specPath = path.join(activeDir, item.id, '1-spec.yaml');
+        const planPath = path.join(activeDir, item.id, '2-plan.yaml');
+        const qualityPath = path.join(activeDir, item.id, '5-quality.yaml');
+        if (!existsSync(specPath) || !existsSync(planPath) || !existsSync(qualityPath)) {
+            warnings.push(`Privacy checklist incomplete for ${item.id}: missing one of 1-spec/2-plan/5-quality YAML files.`);
+            continue;
+        }
+        try {
+            const spec = parseWorkspaceYamlDocument('1-spec.yaml', await fs.readFile(specPath, 'utf-8'));
+            const plan = parseWorkspaceYamlDocument('2-plan.yaml', await fs.readFile(planPath, 'utf-8'));
+            const quality = parseWorkspaceYamlDocument('5-quality.yaml', await fs.readFile(qualityPath, 'utf-8'));
+            const specRefs = spec.compliance_context?.source_refs || [];
+            const specJurisdictions = spec.compliance_context?.jurisdictions || [];
+            const planSources = plan.privacy_controls?.source_registry_refs || [];
+            const planProfiles = plan.privacy_controls?.jurisdiction_profiles || [];
+            const planControls = plan.privacy_controls?.control_ids || [];
+            const selectedSkills = plan.skill_conformance?.selected_skills || [];
+            const detectedConflicts = plan.skill_conformance?.detected_conflicts || [];
+            const architectureTree = (plan.skill_conformance?.architecture_tree_ascii || '').trim();
+            const hasSecurityIntegrity = Boolean(quality.security_integrity);
+            if (specRefs.length === 0 || specJurisdictions.length === 0) {
+                warnings.push(`Privacy checklist incomplete for ${item.id}: 1-spec.yaml missing compliance_context.source_refs/jurisdictions.`);
+            }
+            if (planSources.length === 0 || planProfiles.length === 0 || planControls.length === 0) {
+                warnings.push(`Privacy checklist incomplete for ${item.id}: 2-plan.yaml missing privacy_controls source/profile/control links.`);
+            }
+            if (selectedSkills.length === 0) {
+                warnings.push(`Privacy checklist incomplete for ${item.id}: 2-plan.yaml missing skill_conformance.selected_skills.`);
+            }
+            if (!architectureTree && item.execution_kind !== 'documentation') {
+                warnings.push(`Privacy checklist incomplete for ${item.id}: 2-plan.yaml missing skill_conformance.architecture_tree_ascii for code-impacting execution.`);
+            }
+            if (detectedConflicts.length > 0 && !(plan.skill_conformance?.resolution_adr_ref || '').trim()) {
+                warnings.push(`Privacy checklist incomplete for ${item.id}: detected skill conflicts require skill_conformance.resolution_adr_ref.`);
+            }
+            if (!hasSecurityIntegrity) {
+                warnings.push(`Privacy checklist incomplete for ${item.id}: 5-quality.yaml missing security_integrity validation block.`);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warnings.push(`Privacy checklist parse error for ${item.id}: ${message}`);
+        }
+    }
+}
+async function validateTraceabilityWorkspaceChecklist(projectRoot, activeDir, items, warnings) {
+    const traceabilityItems = items.filter((item) => item.status === 'IN_PROGRESS');
+    for (const item of traceabilityItems) {
+        const specPath = path.join(activeDir, item.id, '1-spec.yaml');
+        const changelogPath = path.join(activeDir, item.id, '4-changelog.yaml');
+        const qualityPath = path.join(activeDir, item.id, '5-quality.yaml');
+        if (!existsSync(specPath) || !existsSync(changelogPath) || !existsSync(qualityPath)) {
+            warnings.push(`Traceability checklist incomplete for ${item.id}: missing one of 1-spec/4-changelog/5-quality YAML files.`);
+            continue;
+        }
+        try {
+            const spec = parseWorkspaceYamlDocument('1-spec.yaml', await fs.readFile(specPath, 'utf-8'));
+            const changelog = parseWorkspaceYamlDocument('4-changelog.yaml', await fs.readFile(changelogPath, 'utf-8'));
+            const quality = parseWorkspaceYamlDocument('5-quality.yaml', await fs.readFile(qualityPath, 'utf-8'));
+            const result = evaluateWorkspaceTraceability(projectRoot, spec, changelog, quality);
+            if (!result.ok) {
+                warnings.push(`Traceability checklist incomplete for ${item.id}: ${result.reasons.join(' | ')}`);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warnings.push(`Traceability checklist parse error for ${item.id}: ${message}`);
+        }
+    }
+}
+function featureRequiresQualityContract(item) {
+    if (item.status === 'ARCHIVED' || item.status === 'DONE')
+        return false;
+    return Boolean(item.quality_contract) || item.status === 'IN_PROGRESS' || item.origin_ref === 'EPIC-0013';
+}
+async function detectMissingQualityArtifacts(activeDir, items) {
+    const missing = [];
+    for (const item of items) {
+        if (item.status !== 'IN_PROGRESS')
+            continue;
+        if (!item.quality_contract || item.quality_contract.enabled === false)
+            continue;
+        const qualityPath = path.join(activeDir, item.id, '5-quality.yaml');
+        if (!existsSync(qualityPath)) {
+            missing.push(item.id);
+        }
+    }
+    return missing;
+}
+function parseRouteToken(value) {
+    const token = value.trim();
+    if (!token)
+        return null;
+    if (token.startsWith('route:')) {
+        const raw = token.slice('route:'.length).trim();
+        if (!raw)
+            return null;
+        return raw.startsWith('/') ? raw : `/${raw}`;
+    }
+    if (token.startsWith('/'))
+        return token;
+    const inlineRoute = token.match(/\/[a-z0-9_\-/:]*/i);
+    if (inlineRoute && inlineRoute[0])
+        return inlineRoute[0];
+    return null;
+}
+function featureHasMetadataFrontendEvidence(item) {
+    const routes = [
+        ...item.produces.map(parseRouteToken),
+        ...item.consumes.map(parseRouteToken),
+        ...(item.frontend_surface_tokens || []).map(parseRouteToken),
+    ].filter((value) => Boolean(value));
+    const surfaces = (item.frontend_surface_tokens || []).map((value) => value.trim()).filter(Boolean);
+    return (routes.length > 0 ||
+        surfaces.length > 0 ||
+        item.touches.includes('frontend') ||
+        item.execution_kind === 'frontend_coverage');
+}
+async function validateCanonicalSddStructure(memoryRoot, errors) {
+    const forbiddenTopLevelDirs = ['backlog', 'features', 'finalize', 'queue'];
+    for (const dirName of forbiddenTopLevelDirs) {
+        const candidate = path.join(memoryRoot, dirName);
+        if (existsSync(candidate)) {
+            errors.push(`Non-canonical SDD structure detected: ${path.relative(process.cwd(), candidate)}. Use only state/, planning/, active/, and archived/.`);
+        }
+    }
+    const forbiddenNestedPaths = [path.join(memoryRoot, 'backlog', 'features')];
+    for (const candidate of forbiddenNestedPaths) {
+        if (existsSync(candidate)) {
+            errors.push(`Non-canonical SDD structure detected: ${path.relative(process.cwd(), candidate)}. Feature backlog must exist only in .sdd/state/backlog.yaml and rendered planning views.`);
+        }
+    }
+}
+export class SddCheckCommand {
+    async execute(projectRoot, options = {}) {
+        let config;
+        let paths;
+        const errors = [];
+        const warnings = [];
+        try {
+            config = await loadProjectSddConfig(projectRoot);
+            paths = resolveSddPaths(projectRoot, config);
+        }
+        catch (error) {
+            return {
+                valid: false,
+                errors: [error.message],
+                warnings,
+                summary: {
+                    discovery: 0,
+                    backlog: 0,
+                    techDebt: 0,
+                    finalizeQueue: 0,
+                    frontendEnabled: false,
+                    frontendGaps: 0,
+                    frontendRoutes: 0,
+                    progress_global: { done: 0, total: 0, percent: 0 },
+                    progress_by_radar: [],
+                    ready_for_parallel: 0,
+                    blocked: 0,
+                    lock_conflicts: 0,
+                    documentation_sync: false,
+                    core_views_stale: true,
+                    missing_architecture_fields: [],
+                    frontend_coverage_sync: true,
+                    quality_contract_sync: true,
+                    features_missing_frontend_declaration: [],
+                    features_with_frontend_conflict: [],
+                    features_missing_fgap_link: [],
+                    features_missing_quality_contract: [],
+                    features_missing_quality_artifact: [],
+                    graph: {
+                        readyForParallel: 0,
+                        blocked: 0,
+                        lockConflicts: 0,
+                    },
+                },
+            };
+        }
+        if (!existsSync(paths.memoryRoot)) {
+            throw new Error(`SDD memory directory not found at ${paths.memoryRoot}. Run "${CLI_NAME} sdd init".`);
+        }
+        await validateCanonicalSddStructure(paths.memoryRoot, errors);
+        const requiredFiles = [
+            paths.stateFiles.discoveryIndex,
+            paths.stateFiles.backlog,
+            paths.stateFiles.techDebt,
+            paths.stateFiles.finalizeQueue,
+            paths.stateFiles.skillCatalog,
+            paths.stateFiles.unblockEvents,
+            paths.stateFiles.sourceIndex,
+        ];
+        for (const filePath of requiredFiles) {
+            if (!existsSync(filePath)) {
+                errors.push(`Arquivo de estado obrigatorio ausente: ${path.relative(projectRoot, filePath)}`);
+            }
+        }
+        if (config.frontend.enabled) {
+            if (!existsSync(paths.stateFiles.frontendGaps)) {
+                errors.push(`Arquivo de estado de frontend ausente: ${path.relative(projectRoot, paths.stateFiles.frontendGaps)}`);
+            }
+            if (!existsSync(paths.stateFiles.frontendMap)) {
+                errors.push(`Arquivo de estado de frontend ausente: ${path.relative(projectRoot, paths.stateFiles.frontendMap)}`);
+            }
+        }
+        const canonicalFiles = [
+            paths.stateFiles.architecture,
+            paths.stateFiles.serviceCatalog,
+            paths.stateFiles.techStack,
+            paths.stateFiles.integrationContracts,
+            paths.stateFiles.repoMap,
+        ];
+        for (const filePath of canonicalFiles) {
+            if (!existsSync(filePath)) {
+                errors.push(`Missing canonical file: ${path.relative(projectRoot, filePath)}`);
+            }
+        }
+        if (config.frontend.enabled && !existsSync(paths.stateFiles.frontendDecisions)) {
+            errors.push(`Missing canonical frontend file: ${path.relative(projectRoot, paths.stateFiles.frontendDecisions)}`);
+        }
+        if (errors.length > 0) {
+            return {
+                valid: false,
+                errors,
+                warnings,
+                summary: {
+                    discovery: 0,
+                    backlog: 0,
+                    techDebt: 0,
+                    finalizeQueue: 0,
+                    frontendEnabled: config.frontend.enabled,
+                    frontendGaps: 0,
+                    frontendRoutes: 0,
+                    progress_global: { done: 0, total: 0, percent: 0 },
+                    progress_by_radar: [],
+                    ready_for_parallel: 0,
+                    blocked: 0,
+                    lock_conflicts: 0,
+                    documentation_sync: false,
+                    core_views_stale: true,
+                    missing_architecture_fields: [],
+                    frontend_coverage_sync: true,
+                    quality_contract_sync: true,
+                    features_missing_frontend_declaration: [],
+                    features_with_frontend_conflict: [],
+                    features_missing_fgap_link: [],
+                    features_missing_quality_contract: [],
+                    features_missing_quality_artifact: [],
+                    graph: {
+                        readyForParallel: 0,
+                        blocked: 0,
+                        lockConflicts: 0,
+                    },
+                },
+            };
+        }
+        let snapshot;
+        try {
+            snapshot = await loadStateSnapshot(paths, config);
+        }
+        catch (error) {
+            return {
+                valid: false,
+                errors: [`Schema de estado invalido: ${error.message}`],
+                warnings,
+                summary: {
+                    discovery: 0,
+                    backlog: 0,
+                    techDebt: 0,
+                    finalizeQueue: 0,
+                    frontendEnabled: config.frontend.enabled,
+                    frontendGaps: 0,
+                    frontendRoutes: 0,
+                    progress_global: { done: 0, total: 0, percent: 0 },
+                    progress_by_radar: [],
+                    ready_for_parallel: 0,
+                    blocked: 0,
+                    lock_conflicts: 0,
+                    documentation_sync: false,
+                    core_views_stale: true,
+                    missing_architecture_fields: [],
+                    frontend_coverage_sync: true,
+                    quality_contract_sync: true,
+                    features_missing_frontend_declaration: [],
+                    features_with_frontend_conflict: [],
+                    features_missing_fgap_link: [],
+                    features_missing_quality_contract: [],
+                    features_missing_quality_artifact: [],
+                    graph: {
+                        readyForParallel: 0,
+                        blocked: 0,
+                        lockConflicts: 0,
+                    },
+                },
+            };
+        }
+        checkUniqueIds(snapshot.discoveryIndex.records, 'discovery-index.records', errors);
+        checkUniqueIds(snapshot.backlog.items, 'backlog.items', errors);
+        checkUniqueIds(snapshot.techDebt.items, 'tech-debt.items', errors);
+        validateDiscoveryRecords(snapshot.discoveryIndex.records, errors);
+        validateBacklog(snapshot.backlog.items, errors, warnings);
+        validateTechDebt(snapshot.techDebt.items, errors);
+        const isStrict = options.strict ?? false;
+        validateReferentialIntegrity(snapshot, errors, warnings, isStrict);
+        validateSkillOperationalIntegrity(snapshot, errors);
+        const archiveCollisions = await detectArchiveArchivedLifecycleCollisions(paths);
+        for (const collision of archiveCollisions) {
+            errors.push(collision.message);
+        }
+        if (config.frontend.enabled && snapshot.frontendGaps) {
+            checkUniqueIds(snapshot.frontendGaps.items, 'frontend-gaps.items', errors);
+            validateFrontendReferences(snapshot.frontendGaps.items, snapshot.backlog.items, errors, warnings);
+        }
+        await validateActiveTaskChecklist(paths.activeDir, snapshot.backlog.items, warnings);
+        await validateWorkspaceCoherence(paths.activeDir, paths.archivedDir, snapshot.backlog.items, warnings);
+        validatePrivacySourceRegistry(snapshot, warnings);
+        await validatePrivacyWorkspaceChecklist(paths.activeDir, snapshot.backlog.items, warnings);
+        await validateTraceabilityWorkspaceChecklist(paths.projectRoot, paths.activeDir, snapshot.backlog.items, warnings);
+        const featuresMissingFrontendDeclaration = config.frontend.enabled
+            ? snapshot.backlog.items
+                .filter((item) => item.status !== 'ARCHIVED' && item.status !== 'DONE')
+                .filter((item) => (item.frontend_impact_status || 'unknown') === 'unknown')
+                .map((item) => item.id)
+            : [];
+        const featuresWithFrontendConflict = config.frontend.enabled
+            ? snapshot.backlog.items
+                .filter((item) => item.status !== 'ARCHIVED' && item.status !== 'DONE')
+                .filter((item) => (item.frontend_impact_status || 'unknown') === 'none')
+                .filter((item) => featureHasMetadataFrontendEvidence(item))
+                .map((item) => item.id)
+            : [];
+        const featuresMissingFgapLink = config.frontend.enabled
+            ? snapshot.backlog.items
+                .filter((item) => item.status !== 'ARCHIVED' && item.status !== 'DONE')
+                .filter((item) => (item.frontend_impact_status || 'unknown') === 'required')
+                .filter((item) => item.frontend_gap_refs.length === 0)
+                .map((item) => item.id)
+            : [];
+        const featuresMissingQualityContract = snapshot.backlog.items
+            .filter(featureRequiresQualityContract)
+            .filter((item) => !item.quality_contract || item.quality_contract.enabled === false)
+            .map((item) => item.id);
+        const featuresMissingQualityArtifact = await detectMissingQualityArtifacts(paths.activeDir, snapshot.backlog.items);
+        const missingArchitectureFields = [];
+        if (snapshot.architecture.nodes.length === 0) {
+            missingArchitectureFields.push('architecture.nodes vazio');
+        }
+        if (snapshot.serviceCatalog.services.length === 0) {
+            missingArchitectureFields.push('service-catalog.services vazio');
+        }
+        if (snapshot.techStack.items.length === 0) {
+            missingArchitectureFields.push('tech-stack.items vazio');
+        }
+        if (snapshot.integrationContracts.contracts.length === 0) {
+            missingArchitectureFields.push('integration-contracts.contracts vazio');
+        }
+        if (snapshot.repoMap.items.length === 0) {
+            missingArchitectureFields.push('repo-map.items vazio');
+        }
+        const hasFrontendDecisionDemand = config.frontend.enabled &&
+            ((snapshot.frontendGaps?.items.length ?? 0) > 0 ||
+                snapshot.backlog.items.some((item) => featureHasMetadataFrontendEvidence(item)));
+        if (hasFrontendDecisionDemand && (snapshot.frontendDecisions?.items.length ?? 0) === 0) {
+            missingArchitectureFields.push('frontend-decisions.items vazio');
+        }
+        const shouldRender = options.render ?? config.views.autoRender;
+        if (shouldRender && errors.length === 0) {
+            await renderViews(paths, config, snapshot);
+            await syncSddGuideDocs(projectRoot, paths, config);
+        }
+        const coreFiles = [
+            path.join(paths.coreDir, 'index.md'),
+            path.join(paths.coreDir, 'servicos.md'),
+            path.join(paths.coreDir, 'spec-tecnologica.md'),
+            path.join(paths.coreDir, 'repo-map.md'),
+        ];
+        if (config.frontend.enabled) {
+            coreFiles.push(path.join(paths.coreDir, 'frontend-map.md'));
+            coreFiles.push(path.join(paths.coreDir, 'frontend-sitemap.md'));
+            coreFiles.push(path.join(paths.coreDir, 'frontend-decisions.md'));
+        }
+        const coreViewsStale = coreFiles.some((file) => !existsSync(file));
+        const docsValidation = await validateSddGuideDocs(projectRoot, paths, config);
+        if (!docsValidation.documentationSync) {
+            warnings.push(`Onboarding blocks are not synchronized: ${docsValidation.missingBlocks.join(', ')}`);
+        }
+        if (featuresMissingFrontendDeclaration.length > 0) {
+            warnings.push(`Features sem declaracao de impacto frontend: ${featuresMissingFrontendDeclaration.join(', ')}`);
+        }
+        if (featuresWithFrontendConflict.length > 0) {
+            warnings.push(`Features com conflito de cobertura frontend: ${featuresWithFrontendConflict.join(', ')}`);
+        }
+        if (featuresMissingFgapLink.length > 0) {
+            warnings.push(`Features com frontend_impact=required sem FGAP vinculado: ${featuresMissingFgapLink.join(', ')}`);
+        }
+        if (featuresMissingQualityContract.length > 0) {
+            warnings.push(`Features missing quality_contract: ${featuresMissingQualityContract.join(', ')}`);
+        }
+        if (featuresMissingQualityArtifact.length > 0) {
+            warnings.push(`Features missing active 5-quality.yaml artifact: ${featuresMissingQualityArtifact.join(', ')}`);
+        }
+        const graph = computeGraphSummary(snapshot.backlog.items);
+        const progress = computeProgress(snapshot.backlog.items);
+        const frontendCoverageSync = featuresMissingFrontendDeclaration.length === 0 &&
+            featuresWithFrontendConflict.length === 0 &&
+            featuresMissingFgapLink.length === 0;
+        const qualityContractSync = featuresMissingQualityContract.length === 0 &&
+            featuresMissingQualityArtifact.length === 0;
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+            summary: {
+                discovery: snapshot.discoveryIndex.records.length,
+                backlog: snapshot.backlog.items.length,
+                techDebt: snapshot.techDebt.items.length,
+                finalizeQueue: snapshot.finalizeQueue.items.length,
+                frontendEnabled: config.frontend.enabled,
+                frontendGaps: snapshot.frontendGaps?.items.length ?? 0,
+                frontendRoutes: snapshot.frontendMap?.routes.length ?? 0,
+                progress_global: progress.progressGlobal,
+                progress_by_radar: progress.progressByRadar,
+                ready_for_parallel: graph.readyForParallel,
+                blocked: graph.blocked,
+                lock_conflicts: graph.lockConflicts,
+                documentation_sync: docsValidation.documentationSync,
+                core_views_stale: coreViewsStale,
+                missing_architecture_fields: missingArchitectureFields,
+                frontend_coverage_sync: frontendCoverageSync,
+                quality_contract_sync: qualityContractSync,
+                features_missing_frontend_declaration: featuresMissingFrontendDeclaration,
+                features_with_frontend_conflict: featuresWithFrontendConflict,
+                features_missing_fgap_link: featuresMissingFgapLink,
+                features_missing_quality_contract: featuresMissingQualityContract,
+                features_missing_quality_artifact: featuresMissingQualityArtifact,
+                graph,
+            },
+        };
+    }
+}
+//# sourceMappingURL=check.js.map