@devtrack-solution/codesdd 1.2.3 → 1.2.4

package/dist/core/sdd/services/finalize.service.js

@@ -10,12 +10,78 @@ import { normalizeArchivedFeatureActiveReferences, validatePostActiveFeaturePlac
 import { loadStateSnapshot, nowIso, saveStateTransaction } from "../state.js";
 import { syncSddGuideDocs } from "../docs-sync.js";
 import { mergeArchitectureNode, mergeFrontendDecisionRecord, mergeRepoMapRecord, mergeServiceRecord, mergeTechStackRecord, stableUniqueStrings, upsertByKey } from "../merge-catalog.js";
-import { getRuntime, persistAndRender, relProjectPath, coreDocRef, activeDocNamesForLayout, activeDocCandidateNames, unresolvedDependencies, updateDependencyMetadata, gitChangedFiles, detectFrontendImpactEvidence, maybeCreateAutomaticFrontendGap, buildFinalizeQueue, evaluateFeatureQuality, buildAdrMarkdown, applyLoggedTransition, gateSatisfied, pathExists, RADAR_TO_DISCOVERY_STATUS } from "../legacy-operations.js";
+import { getRuntime, persistAndRender, relProjectPath, coreDocRef, activeDocNamesForLayout, activeDocCandidateNames, unresolvedDependencies, updateDependencyMetadata, gitChangedFiles, detectFrontendImpactEvidence, maybeCreateAutomaticFrontendGap, buildFinalizeQueue, evaluateFeatureQuality, buildAdrMarkdown, applyLoggedTransition, gateSatisfied, pathExists, computeReadyFeatures, extractFeatureNumber, buildDependentsMap, scoreReadyItem, RADAR_TO_DISCOVERY_STATUS } from "../legacy-operations.js";
 import { SddWriteTransaction } from "../write-manifest.js";
 import { withStateLock } from "../state-lock.js";
 import { activeWorkspaceDeclaresMandatoryAdrImpact } from "../adr-policy.js";
 import { normalizeFeatRef } from "../entity-reference.js";
 import { parseWorkspaceYamlDocument, stringifyWorkspaceYamlDocument, } from "../workspace-schemas.js";
+function recordFinalizeHistory(history, item) {
+    const index = history.findIndex((entry) => entry.feature_id === item.feature_id);
+    if (index >= 0) {
+        history[index] = item;
+        return;
+    }
+    history.push(item);
+    history.sort((a, b) => a.feature_id.localeCompare(b.feature_id));
+}
+function moveCompletedFinalizeItemsToHistory(state) {
+    const activeItems = [];
+    for (const item of state.items) {
+        if (item.status === 'DONE') {
+            recordFinalizeHistory(state.history, {
+                feature_id: item.feature_id,
+                status: 'DONE',
+                summary: item.summary,
+                created_at: item.created_at,
+                completed_at: item.completed_at || item.created_at || '',
+            });
+        }
+        else {
+            activeItems.push(item);
+        }
+    }
+    state.items = activeItems;
+}
+export function reconcileAdrMarkdownForFinalize(existingAdr, now) {
+    return existingAdr
+        .replace(/^status:\s*IN_PROGRESS\b/m, 'status: DONE')
+        .replace(/^status:\s*DRAFT\b/m, 'status: DONE')
+        .replace(/^decision_status:\s*PROPOSED\b/m, 'decision_status: ACCEPTED')
+        .replace(/^updated_at:\s*["']?[\dTZ:.-]+["']?\s*$/m, `updated_at: ${now}`);
+}
+function buildPostFinalizeReplan(items, finalized, unlocked, generatedAt) {
+    const rank = 'impact';
+    const computed = computeReadyFeatures(items, { rank });
+    const dependentsMap = buildDependentsMap(items);
+    const ready = computed.ready
+        .map((item) => {
+        const scored = scoreReadyItem(item, items, dependentsMap, rank);
+        return {
+            id: item.id,
+            title: item.title,
+            recommended_skills: item.recommended_skills.slice(0, 3),
+            score: scored.score,
+            reasons: scored.reasons,
+        };
+    })
+        .sort((left, right) => {
+        if (right.score !== left.score)
+            return right.score - left.score;
+        return extractFeatureNumber(left.id) - extractFeatureNumber(right.id);
+    })
+        .slice(0, 10);
+    return {
+        rank,
+        generated_at: generatedAt,
+        finalized,
+        unlocked,
+        ready,
+        waves: computed.waves,
+        blocked_count: computed.blocked.length,
+        conflicts_count: computed.conflicts.length,
+    };
+}
 export class FinalizeService {
     stores;
     constructor(stores) {
@@ -25,6 +91,7 @@ export class FinalizeService {
         const { config, paths } = await getRuntime(projectRoot);
         return withStateLock(paths.stateDir, async () => {
             const snapshot = await loadStateSnapshot(paths, config);
+            moveCompletedFinalizeItemsToHistory(snapshot.finalizeQueue);
             snapshot.finalizeQueue.items = await buildFinalizeQueue(paths, snapshot.backlog.items, snapshot.finalizeQueue.items);
             const pending = snapshot.finalizeQueue.items.filter((item) => item.status === 'PENDING');
             const inferredRef = options?.allReady
@@ -47,6 +114,7 @@ export class FinalizeService {
                     finalized: [],
                     unblocked: [],
                     pending: pending.length,
+                    post_finalize_replan: buildPostFinalizeReplan(snapshot.backlog.items, [], [], nowIso()),
                     updated_core_docs: [],
                     updated_readme: false,
                     updated_agent_guide: false,
@@ -275,19 +343,14 @@ export class FinalizeService {
                     continue;
                 }
                 const queue = snapshot.finalizeQueue.items.find((item) => item.feature_id === featureId);
-                if (queue) {
-                    queue.status = 'DONE';
-                    queue.completed_at = now;
-                }
-                else {
-                    snapshot.finalizeQueue.items.push({
-                        feature_id: featureId,
-                        status: 'DONE',
-                        summary: `Finalizado manualmente: ${featureId}`,
-                        created_at: now,
-                        completed_at: now,
-                    });
-                }
+                snapshot.finalizeQueue.items = snapshot.finalizeQueue.items.filter((item) => item.feature_id !== featureId);
+                recordFinalizeHistory(snapshot.finalizeQueue.history, {
+                    feature_id: featureId,
+                    status: 'DONE',
+                    summary: queue?.summary || `Finalizado manualmente: ${featureId}`,
+                    created_at: queue?.created_at || now,
+                    completed_at: now,
+                });
                 if ((feature.origin_type === 'radar' || feature.origin_type === 'epic') && feature.origin_ref) {
                     const siblings = snapshot.backlog.items.filter((item) => (item.origin_type === 'radar' || item.origin_type === 'epic') && item.origin_ref === feature.origin_ref);
                     if (siblings.every((item) => item.status === 'DONE' || item.status === 'ARCHIVED')) {
@@ -395,7 +458,13 @@ export class FinalizeService {
                 if (!options?.noAdr && !feature.requires_adr) {
                     const adrPath = path.join(paths.coreDir, 'adrs', `ADR-${feature.id}.md`);
                     const tx = new SddWriteTransaction();
-                    tx.writeFile(adrPath, buildAdrMarkdown(feature, unlockedByFeature, now));
+                    try {
+                        const existingAdr = await fs.readFile(adrPath, 'utf-8');
+                        tx.writeFile(adrPath, reconcileAdrMarkdownForFinalize(existingAdr, now));
+                    }
+                    catch {
+                        tx.writeFile(adrPath, buildAdrMarkdown(feature, unlockedByFeature, now));
+                    }
                     await tx.commit(paths.projectRoot, paths.memoryRoot, 'finalize.service (ADR)');
                 }
                 await fs.mkdir(paths.archivedDir, { recursive: true });
@@ -421,6 +490,7 @@ export class FinalizeService {
                 });
             }
             updateDependencyMetadata(snapshot.backlog.items);
+            const postFinalizeReplan = buildPostFinalizeReplan(snapshot.backlog.items, finalized, Array.from(unblocked).sort(), now);
             const stateUpdates = {
                 discoveryIndex: snapshot.discoveryIndex,
                 backlog: snapshot.backlog,
@@ -454,6 +524,7 @@ export class FinalizeService {
                 finalized,
                 unblocked: Array.from(unblocked).sort(),
                 pending: remaining,
+                post_finalize_replan: postFinalizeReplan,
                 updated_core_docs: Array.from(updatedCoreDocs).sort(),
                 updated_readme: syncResult.updatedReadme,
                 updated_agent_guide: syncResult.updatedAgentGuide || syncResult.updatedRootAgents,
@@ -643,6 +714,7 @@ export async function evaluateWorkspaceQualityFeedback(paths, config, feature) {
     }
     const missingTargets = missingCoverageTargets(document);
     const missingSkills = missingSkillEvidence(document);
+    const criticalProvenanceReasons = missingCriticalEvidenceProvenance(document);
     const matrixReasons = evaluateQualityWitnessMatrix(document);
     const reasons = [];
     const maxRounds = document.remediation_policy.max_rounds;
@@ -670,6 +742,9 @@ export async function evaluateWorkspaceQualityFeedback(paths, config, feature) {
     if (missingSkills.length > 0) {
         reasons.push(`required skill evidence missing for ${missingSkills.join(', ')}`);
     }
+    if (criticalProvenanceReasons.length > 0) {
+        reasons.push(...criticalProvenanceReasons);
+    }
     if (matrixReasons.length > 0) {
         reasons.push(`quality-witness matrix blocked finalize: ${matrixReasons.join(' | ')}`);
     }
@@ -825,19 +900,65 @@ export function computeIntegrityAxis(document) {
             integritySignalScore(security.sensitive_data_exposure_review),
             integritySignalScore(security.incident_response_review),
         ].reduce((acc, value) => acc + value, 0) / 3);
-    const raw = round2(skillScore * 0.7 + securityScore * 0.3);
+    const runtimeQuality = computeRuntimeQualityAxis(document);
+    const raw = round2(skillScore * 0.55 + securityScore * 0.25 + runtimeQuality.raw_score * 0.2);
     return {
         raw_score: raw,
-        rationale: `skill_evidence=${skillScore.toFixed(2)} security_integrity=${securityScore.toFixed(2)}`,
+        rationale: `skill_evidence=${skillScore.toFixed(2)} security_integrity=${securityScore.toFixed(2)} runtime_quality=${runtimeQuality.raw_score.toFixed(2)} (${runtimeQuality.rationale})`,
+    };
+}
+export function computeRuntimeQualityAxis(document) {
+    const gates = document.runtime_quality_gates;
+    const performance = gates?.performance ?? [];
+    const flakiness = gates?.flakiness ?? [];
+    const entries = [
+        ...performance.map((entry) => ({ kind: 'performance', gate: entry.gate, evidence: entry.evidence_ref, score: runtimePerformanceScore(entry) })),
+        ...flakiness.map((entry) => ({ kind: 'flakiness', gate: entry.gate, evidence: entry.evidence_ref, score: runtimeFlakinessScore(entry) })),
+    ];
+    if (entries.length === 0) {
+        return {
+            raw_score: 100,
+            rationale: 'runtime quality telemetry not provided; neutral score applied',
+        };
+    }
+    const scores = entries.map((entry) => {
+        if (entry.gate === 'fail')
+            return Math.min(entry.score, 70);
+        if (entry.gate === 'warn')
+            return Math.min(entry.score, 85);
+        return entry.score;
+    });
+    const worst = Math.min(...scores);
+    const failed = entries.filter((entry) => entry.gate === 'fail').map((entry) => `${entry.kind}:${entry.evidence ?? 'runtime evidence'}`);
+    const warned = entries.filter((entry) => entry.gate === 'warn').map((entry) => `${entry.kind}:${entry.evidence ?? 'runtime evidence'}`);
+    const notes = [...failed.map((value) => `${value} failed`), ...warned.map((value) => `${value} warned`)];
+    return {
+        raw_score: worst,
+        rationale: `runtime quality gate scored ${worst.toFixed(2)}${notes.length > 0 ? `; ${notes.join('; ')}` : ''}`,
     };
 }
+function runtimePerformanceScore(entry) {
+    if (entry.actual !== undefined && entry.threshold !== undefined && entry.threshold > 0) {
+        return clampPercent((entry.threshold / Math.max(entry.actual, 1)) * 100);
+    }
+    return entry.gate === 'pass' ? 100 : entry.gate === 'warn' ? 85 : 70;
+}
+function runtimeFlakinessScore(entry) {
+    let failureRate = entry.failure_rate_percent;
+    if (failureRate === undefined && entry.attempts !== undefined && entry.failures !== undefined && entry.attempts > 0) {
+        failureRate = clampPercent((entry.failures / entry.attempts) * 100);
+    }
+    if (failureRate === undefined) {
+        return entry.gate === 'pass' ? 100 : entry.gate === 'warn' ? 85 : 70;
+    }
+    return clampPercent(100 - failureRate);
+}
 const LEGACY_NAMING_PATTERNS = [
     /\bcoachsdd\b/u,
     /\bcoach\s+sdd\b/u,
     /\bcoach-sdd\b/u,
     /\bcoach_sdd\b/u,
     /\bsdd\s+coach\b/u,
-    /\.codesdd\b/u,
 ];
 export function computeNamingAxis(feature, document) {
     let score = 100;
@@ -861,6 +982,10 @@ export function computeNamingAxis(feature, document) {
     };
 }
 export function computeTokenAxis(document) {
+    const structuredTelemetry = document.token_budget_gates?.telemetry ?? [];
+    if (structuredTelemetry.length > 0) {
+        return computeStructuredTokenAxis(document);
+    }
     const tokenEntries = document.evidence_log.filter((entry) => {
         const label = `${entry.kind} ${entry.result}`.toLowerCase();
         return label.includes('token');
@@ -893,6 +1018,59 @@ export function computeTokenAxis(document) {
         rationale: 'token evidence found but no numeric percentage; conservative score applied',
     };
 }
+export function computeStructuredTokenAxis(document) {
+    const gates = document.token_budget_gates;
+    const telemetry = gates?.telemetry ?? [];
+    const requireNumeric = gates?.require_numeric_efficiency ?? true;
+    const failBelow = gates?.fail_below_percent ?? 95;
+    const scores = [];
+    const reasons = [];
+    let hardFailure = false;
+    for (const entry of telemetry) {
+        let score = entry.efficiency_percent;
+        if (score === undefined && entry.budget_chars !== undefined && entry.actual_chars !== undefined) {
+            score = entry.actual_chars === 0 ? 100 : clampPercent((entry.budget_chars / entry.actual_chars) * 100);
+        }
+        if (score === undefined && entry.actual_chars !== undefined && gates?.max_context_chars !== undefined) {
+            score = entry.actual_chars === 0 ? 100 : clampPercent((gates.max_context_chars / entry.actual_chars) * 100);
+        }
+        if (score === undefined) {
+            if (requireNumeric) {
+                scores.push(70);
+                reasons.push(`${entry.evidence_ref ?? 'token telemetry'} lacks numeric efficiency`);
+            }
+            continue;
+        }
+        const normalized = clampPercent(score);
+        scores.push(normalized);
+        if (entry.gate === 'fail' || normalized < failBelow) {
+            hardFailure = true;
+            reasons.push(`${entry.evidence_ref ?? 'token telemetry'} below ${failBelow}%`);
+        }
+        else if (entry.gate === 'warn') {
+            reasons.push(`${entry.evidence_ref ?? 'token telemetry'} warned at ${normalized.toFixed(2)}%`);
+        }
+    }
+    if (scores.length === 0) {
+        return {
+            raw_score: requireNumeric ? 70 : 100,
+            rationale: requireNumeric
+                ? 'token budget gate requires numeric efficiency but no numeric telemetry was provided'
+                : 'token budget telemetry provided without numeric scoring requirement',
+        };
+    }
+    const worst = Math.min(...scores);
+    if (hardFailure) {
+        return {
+            raw_score: Math.min(worst, 70),
+            rationale: `token budget gate failed: ${reasons.join('; ')}`,
+        };
+    }
+    return {
+        raw_score: worst,
+        rationale: `token budget gate satisfied (${worst.toFixed(2)}% worst-case efficiency)${reasons.length > 0 ? `; ${reasons.join('; ')}` : ''}`,
+    };
+}
 export function extractCoveragePerformance(document, kind) {
     const target = kind === 'unit' ? document.coverage_targets.unit : document.coverage_targets.integration;
     const relevant = document.evidence_log.filter((entry) => {
@@ -1003,4 +1181,34 @@ export function missingSkillEvidence(document) {
         .filter(Boolean));
     return required.filter((skillId) => !provided.has(skillId.toLowerCase()));
 }
+export function missingCriticalEvidenceProvenance(document) {
+    const reasons = [];
+    document.evidence_log.forEach((entry, index) => {
+        if (entry.critical !== true) {
+            return;
+        }
+        const provenance = entry.provenance;
+        if (!provenance) {
+            reasons.push(`critical evidence_log[${index}] (${entry.kind}) missing provenance (command, exit_code, timestamp_iso, commit_sha, artifact_path, artifact_hash)`);
+            return;
+        }
+        const missingFields = [];
+        if (!provenance.command?.trim())
+            missingFields.push('command');
+        if (!Number.isInteger(provenance.exit_code))
+            missingFields.push('exit_code');
+        if (!provenance.timestamp_iso?.trim())
+            missingFields.push('timestamp_iso');
+        if (!provenance.commit_sha?.trim())
+            missingFields.push('commit_sha');
+        if (!provenance.artifact_path?.trim())
+            missingFields.push('artifact_path');
+        if (!provenance.artifact_hash?.trim())
+            missingFields.push('artifact_hash');
+        if (missingFields.length > 0) {
+            reasons.push(`critical evidence_log[${index}] (${entry.kind}) missing provenance fields: ${missingFields.join(', ')}`);
+        }
+    });
+    return reasons;
+}
 //# sourceMappingURL=finalize.service.js.map

package/dist/core/sdd/services/frontend-impact.service.d.ts

@@ -10,7 +10,7 @@ export declare class FrontendImpactService {
         render?: boolean;
     }): Promise<{
         feature_id: string;
-        frontend_impact_status: "unknown" | "none" | "required";
+        frontend_impact_status: "none" | "unknown" | "required";
         frontend_impact_reason: string;
         frontend_impact_declared_at: string;
         frontend_surface_tokens: string[];

package/dist/core/sdd/services/historical-quality-regression.service.d.ts

@@ -0,0 +1,35 @@
+export type HistoricalQualityRegressionMode = 'recent-window' | 'full-history';
+export type HistoricalQualityRegressionIssueCode = 'ACCEPTANCE_NOT_MET' | 'OPEN_RISK' | 'PLACEHOLDER_EVIDENCE' | 'MISSING_ADR' | 'FRONTEND_IMPACT_UNKNOWN' | 'MISSING_DONE_AT' | 'MISSING_ARCHIVED_AT' | 'STATE_CORE_DIVERGENCE';
+export interface HistoricalQualityRegressionIssue {
+    feature_id: string;
+    code: HistoricalQualityRegressionIssueCode;
+    message: string;
+    quality_path?: string;
+    backlog_path?: string;
+    adr_path?: string;
+}
+export interface HistoricalQualityRegressionReport {
+    generated_at: string;
+    mode: HistoricalQualityRegressionMode;
+    recent_window_size: number | null;
+    scanned: number;
+    considered: number;
+    analyzed: number;
+    grandfathered: number;
+    issue_count: number;
+    grandfathering: {
+        enabled: boolean;
+        max_feat_id: number;
+        policy: string;
+    };
+    issues: HistoricalQualityRegressionIssue[];
+}
+export interface HistoricalQualityRegressionOptions {
+    mode?: HistoricalQualityRegressionMode;
+    recentWindowSize?: number;
+    grandfatherMaxFeat?: number;
+}
+export declare class HistoricalQualityRegressionService {
+    execute(projectRoot: string, options?: HistoricalQualityRegressionOptions): Promise<HistoricalQualityRegressionReport>;
+}
+//# sourceMappingURL=historical-quality-regression.service.d.ts.map

package/dist/core/sdd/services/historical-quality-regression.service.js

@@ -0,0 +1,228 @@
+import { existsSync, promises as fs } from 'node:fs';
+import path from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { parseWorkspaceYamlDocument } from '../workspace-schemas.js';
+const PLACEHOLDER_PATTERNS = [
+    /\(fill in/i,
+    /\(placeholder/i,
+    /\btodo\b/i,
+    /\btbd\b/i,
+    /\bpending\b/i,
+    /\bmust implement\b/i,
+    /\bto be executed\b/i,
+    /\bplanned\b/i,
+    /\bwill be\b/i,
+    /\bto do\b/i,
+];
+const DEFAULT_RECENT_WINDOW_SIZE = 25;
+const DEFAULT_GRANDFATHER_MAX_FEAT = 451;
+function featNumericId(featureId) {
+    const match = featureId.match(/^FEAT-(\d{4,})$/);
+    if (!match)
+        return null;
+    return Number.parseInt(match[1] || '', 10);
+}
+function hasPlaceholderSignal(text) {
+    return PLACEHOLDER_PATTERNS.some((pattern) => pattern.test(text));
+}
+function hasPlaceholderEvidence(document) {
+    const evidenceTexts = [
+        ...document.evidence_log.flatMap((entry) => [entry.kind, entry.result, entry.artifact ?? '']),
+        ...document.acceptance_matrix.flatMap((entry) => [entry.criterion, entry.evidence]),
+    ];
+    return evidenceTexts.some((text) => text && hasPlaceholderSignal(text));
+}
+function sortFeaturesByRecency(featureIds) {
+    return [...featureIds].sort((left, right) => {
+        const leftNum = featNumericId(left);
+        const rightNum = featNumericId(right);
+        if (leftNum !== null && rightNum !== null && leftNum !== rightNum) {
+            return rightNum - leftNum;
+        }
+        if (leftNum !== null && rightNum === null)
+            return -1;
+        if (leftNum === null && rightNum !== null)
+            return 1;
+        return right.localeCompare(left);
+    });
+}
+async function loadBacklogEvidence(backlogPath) {
+    const map = new Map();
+    if (!existsSync(backlogPath))
+        return map;
+    const raw = await fs.readFile(backlogPath, 'utf-8').catch(() => '');
+    if (!raw.trim())
+        return map;
+    const parsed = parseYaml(raw);
+    for (const item of parsed.items ?? []) {
+        const id = typeof item.id === 'string' ? item.id : '';
+        if (!id.startsWith('FEAT-'))
+            continue;
+        map.set(id, {
+            id,
+            status: typeof item.status === 'string' ? item.status : undefined,
+            frontend_impact_status: typeof item.frontend_impact_status === 'string' ? item.frontend_impact_status : undefined,
+            done_at: typeof item.done_at === 'string' ? item.done_at : undefined,
+            archived_at: typeof item.archived_at === 'string' ? item.archived_at : undefined,
+        });
+    }
+    return map;
+}
+export class HistoricalQualityRegressionService {
+    async execute(projectRoot, options = {}) {
+        const mode = options.mode ?? 'recent-window';
+        const recentWindowSize = options.recentWindowSize ?? DEFAULT_RECENT_WINDOW_SIZE;
+        const grandfatherMaxFeat = options.grandfatherMaxFeat ?? DEFAULT_GRANDFATHER_MAX_FEAT;
+        const archivedDir = path.join(projectRoot, '.sdd', 'archived');
+        const backlogPath = path.join(projectRoot, '.sdd', 'state', 'backlog.yaml');
+        const adrsDir = path.join(projectRoot, '.sdd', 'core', 'adrs');
+        const backlogByFeature = await loadBacklogEvidence(backlogPath);
+        if (!existsSync(archivedDir)) {
+            return {
+                generated_at: new Date().toISOString(),
+                mode,
+                recent_window_size: mode === 'recent-window' ? recentWindowSize : null,
+                scanned: 0,
+                considered: 0,
+                analyzed: 0,
+                grandfathered: 0,
+                issue_count: 0,
+                grandfathering: {
+                    enabled: true,
+                    max_feat_id: grandfatherMaxFeat,
+                    policy: `Skip blocking regression checks for archived FEAT ids <= FEAT-${String(grandfatherMaxFeat).padStart(4, '0')}.`,
+                },
+                issues: [],
+            };
+        }
+        const entries = await fs.readdir(archivedDir, { withFileTypes: true });
+        const scannedFeatures = entries
+            .filter((entry) => entry.isDirectory() && entry.name.startsWith('FEAT-'))
+            .map((entry) => entry.name);
+        const orderedFeatures = sortFeaturesByRecency(scannedFeatures);
+        const consideredFeatures = mode === 'recent-window' ? orderedFeatures.slice(0, Math.max(1, recentWindowSize)) : orderedFeatures;
+        let analyzed = 0;
+        let grandfathered = 0;
+        const issues = [];
+        for (const featureId of consideredFeatures) {
+            const numericId = featNumericId(featureId);
+            if (numericId !== null && numericId <= grandfatherMaxFeat) {
+                grandfathered += 1;
+                continue;
+            }
+            const backlog = backlogByFeature.get(featureId);
+            const qualityPath = path.join(archivedDir, featureId, '5-quality.yaml');
+            const adrPath = path.join(adrsDir, `ADR-${featureId}.md`);
+            if (!backlog) {
+                issues.push({
+                    feature_id: featureId,
+                    code: 'STATE_CORE_DIVERGENCE',
+                    message: `${featureId} is archived but missing from .sdd/state/backlog.yaml.`,
+                    backlog_path: backlogPath,
+                });
+            }
+            if (backlog && backlog.status && !['DONE', 'ARCHIVED'].includes(backlog.status)) {
+                issues.push({
+                    feature_id: featureId,
+                    code: 'STATE_CORE_DIVERGENCE',
+                    message: `${featureId} is archived on disk but backlog status is ${backlog.status}.`,
+                    backlog_path: backlogPath,
+                });
+            }
+            if (backlog && (backlog.frontend_impact_status ?? 'unknown') === 'unknown') {
+                issues.push({
+                    feature_id: featureId,
+                    code: 'FRONTEND_IMPACT_UNKNOWN',
+                    message: `${featureId} has frontend_impact_status=unknown in backlog state.`,
+                    backlog_path: backlogPath,
+                });
+            }
+            if (backlog && !backlog.done_at) {
+                issues.push({
+                    feature_id: featureId,
+                    code: 'MISSING_DONE_AT',
+                    message: `${featureId} is archived without done_at in backlog state.`,
+                    backlog_path: backlogPath,
+                });
+            }
+            if (backlog && !backlog.archived_at) {
+                issues.push({
+                    feature_id: featureId,
+                    code: 'MISSING_ARCHIVED_AT',
+                    message: `${featureId} is archived without archived_at in backlog state.`,
+                    backlog_path: backlogPath,
+                });
+            }
+            if (!existsSync(adrPath)) {
+                issues.push({
+                    feature_id: featureId,
+                    code: 'MISSING_ADR',
+                    message: `${featureId} is missing required ADR file at .sdd/core/adrs/ADR-${featureId}.md.`,
+                    adr_path: adrPath,
+                });
+                issues.push({
+                    feature_id: featureId,
+                    code: 'STATE_CORE_DIVERGENCE',
+                    message: `${featureId} has no ADR in .sdd/core/adrs while archived state exists.`,
+                    adr_path: adrPath,
+                });
+            }
+            if (!existsSync(qualityPath)) {
+                continue;
+            }
+            const rawQuality = await fs.readFile(qualityPath, 'utf-8').catch(() => '');
+            if (!rawQuality.trim()) {
+                continue;
+            }
+            let quality;
+            try {
+                quality = parseWorkspaceYamlDocument('5-quality.yaml', rawQuality);
+            }
+            catch {
+                continue;
+            }
+            analyzed += 1;
+            if (quality.acceptance_matrix.some((entry) => entry.status === 'not_met')) {
+                issues.push({
+                    feature_id: featureId,
+                    code: 'ACCEPTANCE_NOT_MET',
+                    message: `${featureId} contains acceptance_matrix.status=not_met in archived quality evidence.`,
+                    quality_path: qualityPath,
+                });
+            }
+            if (quality.requirement_validation_evidence_risk_matrix.some((entry) => entry.risk_status === 'open')) {
+                issues.push({
+                    feature_id: featureId,
+                    code: 'OPEN_RISK',
+                    message: `${featureId} contains requirement risk_status=open in archived quality evidence.`,
+                    quality_path: qualityPath,
+                });
+            }
+            if (hasPlaceholderEvidence(quality)) {
+                issues.push({
+                    feature_id: featureId,
+                    code: 'PLACEHOLDER_EVIDENCE',
+                    message: `${featureId} still includes placeholder or future-tense evidence markers.`,
+                    quality_path: qualityPath,
+                });
+            }
+        }
+        return {
+            generated_at: new Date().toISOString(),
+            mode,
+            recent_window_size: mode === 'recent-window' ? recentWindowSize : null,
+            scanned: orderedFeatures.length,
+            considered: consideredFeatures.length,
+            analyzed,
+            grandfathered,
+            issue_count: issues.length,
+            grandfathering: {
+                enabled: true,
+                max_feat_id: grandfatherMaxFeat,
+                policy: `Skip blocking regression checks for archived FEAT ids <= FEAT-${String(grandfatherMaxFeat).padStart(4, '0')}.`,
+            },
+            issues,
+        };
+    }
+}
+//# sourceMappingURL=historical-quality-regression.service.js.map

package/dist/core/sdd/services/ingest-deposito.service.js

@@ -224,7 +224,7 @@ export class IngestDepositoService {
                 'frontend-extractor-sdd',
                 'planning-normalizer-sdd',
             ],
-            recommended_prompt: relProjectPath(paths, path.join(paths.promptsDir, '01-ingestao-deposito.md')),
+            recommended_prompt: relProjectPath(paths, path.join(paths.promptsDir, config.layout === 'en-US' ? '01-source-intake.md' : '01-ingestao-deposito.md')),
         };
     }
 }

package/dist/core/sdd/services/planning-execution-coherence.service.d.ts

@@ -0,0 +1,45 @@
+import { type WorkspaceChangelogDocument, type WorkspacePlanDocument, type WorkspaceQualityDocument, type WorkspaceSpecDocument, type WorkspaceTasksDocument } from '../workspace-schemas.js';
+export type PlanningExecutionCoherenceIssueCode = 'MISSING_FILE_EVIDENCE' | 'MISSING_COMMAND_EVIDENCE' | 'ACCEPTANCE_NOT_MET' | 'RISK_STATUS_OPEN' | 'ADR_MISSING';
+export interface PlanningExecutionCoherenceIssue {
+    code: PlanningExecutionCoherenceIssueCode;
+    severity: 'error' | 'warning';
+    message: string;
+    evidence: Record<string, unknown>;
+}
+export interface PlanningExecutionCoherenceReport {
+    schema_version: 1;
+    feature_id: string;
+    generated_at: string;
+    workspace_path: string;
+    adr_path: string;
+    healthy: boolean;
+    planned: {
+        files: string[];
+        commands: string[];
+    };
+    execution: {
+        files: string[];
+        commands: string[];
+    };
+    issues: PlanningExecutionCoherenceIssue[];
+}
+export interface EvaluatePlanningExecutionCoherenceInput {
+    featureId: string;
+    workspacePath: string;
+    adrPath: string;
+    adrExists: boolean;
+    spec: WorkspaceSpecDocument;
+    plan: WorkspacePlanDocument;
+    tasks: WorkspaceTasksDocument;
+    changelog: WorkspaceChangelogDocument;
+    quality: WorkspaceQualityDocument;
+    changedFiles: string[];
+}
+export interface PlanningExecutionCoherenceOptions {
+    changedFiles?: string[];
+}
+export declare function evaluatePlanningExecutionCoherence(input: EvaluatePlanningExecutionCoherenceInput): PlanningExecutionCoherenceReport;
+export declare class PlanningExecutionCoherenceService {
+    execute(projectRoot: string, featureId: string, options?: PlanningExecutionCoherenceOptions): Promise<PlanningExecutionCoherenceReport>;
+}
+//# sourceMappingURL=planning-execution-coherence.service.d.ts.map