@devtrack-solution/codesdd 1.2.3 → 1.2.4-rc3

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

@@ -10,12 +10,71 @@ 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;
+}
+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 +84,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 +107,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 +336,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')) {
@@ -421,6 +477,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 +511,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,
@@ -825,12 +883,59 @@ 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,
@@ -861,6 +966,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 +1002,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) => {

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/semantic-intent-classifier.service.d.ts

@@ -0,0 +1,6 @@
+import { type SemanticIntentClassification, type SemanticIntentClassifierInput } from '../domain/semantic-intent-classifier.js';
+export type SemanticIntentClassifierServiceResult = SemanticIntentClassification;
+export declare class SemanticIntentClassifierService {
+    execute(input: SemanticIntentClassifierInput): SemanticIntentClassifierServiceResult;
+}
+//# sourceMappingURL=semantic-intent-classifier.service.d.ts.map

package/dist/core/sdd/services/semantic-intent-classifier.service.js

@@ -0,0 +1,7 @@
+import { classifySemanticIntent, } from '../domain/semantic-intent-classifier.js';
+export class SemanticIntentClassifierService {
+    execute(input) {
+        return classifySemanticIntent(input);
+    }
+}
+//# sourceMappingURL=semantic-intent-classifier.service.js.map

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

@@ -24,6 +24,7 @@ export interface SddRuntimeConfig {
         autoRender: boolean;
     };
 }
+export declare function buildDefaultSkillRoutingState(): SkillRoutingState;
 export interface SddPaths {
     projectRoot: string;
     memoryRoot: string;

package/dist/core/sdd/state.js

@@ -9,6 +9,254 @@ import { CURRENT_SDD_STATE_VERSION, buildSddContractConfig } from './contract.js
 import { DEFAULT_CURATED_SKILL_CATALOG, BUILT_IN_SDD_SKILLS, buildCuratedBundlesMarkdown, buildCuratedBundlesCurationData, } from './default-skills.js';
 import { buildSddInternalReadme, PROMPT_00_COMECE_POR_AQUI_MD, PROMPT_01_INGESTAO_DEPOSITO_MD, PROMPT_02_NORMALIZAR_PLANEJAMENTO_MD, PROMPT_03_EXECUCAO_FEATURE_MD, PROMPT_04_CONSOLIDACAO_FINALIZE_MD, PROMPTS_README_MD, TEMPLATE_1_SPEC_MD, TEMPLATE_2_PLAN_MD, TEMPLATE_QUALITY_MD, TEMPLATE_3_TASKS_MD, TEMPLATE_4_CHANGELOG_MD, } from './default-bootstrap-files.js';
 import { SddWriteTransaction } from './transaction.js';
+export function buildDefaultSkillRoutingState() {
+    return {
+        version: 1,
+        default_skills: ['architecture', 'concise-planning', 'context-window-management'],
+        routes: [
+            {
+                domain: 'backend',
+                skills: ['devtrack-api', 'architecture', 'api-design-principles'],
+                bundles: ['architecture-backend'],
+            },
+            {
+                domain: 'api',
+                skills: ['devtrack-api', 'api-design-principles'],
+                bundles: ['architecture-backend'],
+            },
+            {
+                domain: 'nestjs',
+                skills: ['devtrack-api', 'architecture'],
+                bundles: ['architecture-backend'],
+            },
+            {
+                domain: 'typeorm',
+                skills: ['devtrack-api', 'database-design'],
+                bundles: ['architecture-backend'],
+            },
+            {
+                domain: 'devtrack',
+                skills: ['devtrack-api'],
+                bundles: ['architecture-backend'],
+            },
+            {
+                domain: 'python',
+                skills: ['api-clean-flask-langgraph', 'architecture'],
+                bundles: ['python-agentic-backend'],
+            },
+            {
+                domain: 'flask',
+                skills: ['api-clean-flask-langgraph'],
+                bundles: ['python-agentic-backend'],
+            },
+            {
+                domain: 'frontend',
+                skills: ['frontend-design', 'react-patterns'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'angular',
+                skills: ['frontend-design', 'frontend-security-coder'],
+                bundles: ['frontend-product', 'security-quality'],
+            },
+            {
+                domain: 'flutter',
+                skills: ['devtrack-flutter', 'mobile-design', 'frontend-design'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'dart',
+                skills: ['devtrack-flutter', 'architecture'],
+                bundles: ['frontend-product', 'architecture-backend'],
+            },
+            {
+                domain: 'cross-platform',
+                skills: ['devtrack-flutter', 'mobile-design'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'flutter-ui',
+                skills: ['devtrack-flutter', 'frontend-design'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'flutter-layout',
+                skills: ['devtrack-flutter', 'frontend-design'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'flutter-routing',
+                skills: ['devtrack-flutter', 'architecture'],
+                bundles: ['frontend-product', 'architecture-backend'],
+            },
+            {
+                domain: 'flutter-l10n',
+                skills: ['devtrack-flutter'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'flutter-http',
+                skills: ['devtrack-flutter', 'frontend-security-coder'],
+                bundles: ['frontend-product', 'security-quality'],
+            },
+            {
+                domain: 'flutter-json',
+                skills: ['devtrack-flutter'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'widget-preview',
+                skills: ['devtrack-flutter', 'frontend-design'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'widget-test',
+                skills: ['devtrack-flutter'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'integration-test',
+                skills: ['devtrack-flutter'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'go-router',
+                skills: ['devtrack-flutter', 'architecture'],
+                bundles: ['frontend-product', 'architecture-backend'],
+            },
+            {
+                domain: 'arb',
+                skills: ['devtrack-flutter'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'l10n',
+                skills: ['devtrack-flutter'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'admin',
+                skills: ['devtrack-angular', 'frontend-design', 'frontend-security-coder'],
+                bundles: ['frontend-product', 'security-quality'],
+            },
+            {
+                domain: 'angular-admin',
+                skills: ['devtrack-angular', 'frontend-design', 'frontend-security-coder'],
+                bundles: ['frontend-product', 'security-quality'],
+            },
+            {
+                domain: 'backoffice',
+                skills: ['devtrack-angular', 'frontend-design', 'frontend-security-coder'],
+                bundles: ['frontend-product', 'security-quality'],
+            },
+            {
+                domain: 'dashboard',
+                skills: ['devtrack-angular', 'frontend-design'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'crud',
+                skills: ['devtrack-angular', 'architecture'],
+                bundles: ['frontend-product', 'architecture-backend'],
+            },
+            {
+                domain: 'data-grid',
+                skills: ['devtrack-angular', 'frontend-design'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'formly',
+                skills: ['frontend-design'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'ngxs',
+                skills: ['architecture'],
+                bundles: ['frontend-product', 'architecture-backend'],
+            },
+            {
+                domain: 'admin-formly',
+                skills: ['devtrack-angular', 'frontend-design'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'admin-state',
+                skills: ['devtrack-angular', 'architecture'],
+                bundles: ['frontend-product', 'architecture-backend'],
+            },
+            {
+                domain: 'ngxs-admin',
+                skills: ['devtrack-angular', 'architecture'],
+                bundles: ['frontend-product', 'architecture-backend'],
+            },
+            {
+                domain: 'uiux',
+                skills: ['frontend-design', 'ui-ux-pro-max'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'permissions',
+                skills: ['devtrack-angular', 'frontend-security-coder'],
+                bundles: ['frontend-product', 'security-quality'],
+            },
+            {
+                domain: 'reports',
+                skills: ['devtrack-angular', 'frontend-design'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'workflow',
+                skills: ['devtrack-angular', 'architecture'],
+                bundles: ['frontend-product', 'architecture-backend'],
+            },
+            {
+                domain: 'realtime',
+                skills: ['architecture'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'rtc',
+                skills: ['architecture'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'chat',
+                skills: ['frontend-design'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'admin-realtime',
+                skills: ['devtrack-angular', 'architecture'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'admin-chat',
+                skills: ['devtrack-angular', 'frontend-design'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'mobile',
+                skills: ['mobile-design'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'ionic',
+                skills: ['mobile-design'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'nativescript',
+                skills: ['mobile-design'],
+                bundles: ['frontend-product'],
+            },
+            {
+                domain: 'infra',
+                skills: ['terraform-specialist', 'docker-expert'],
+                bundles: [],
+            },
+        ],
+    };
+}
 const LEGACY_LAYOUT_FOLDERS = {
     discovery: 'discovery',
     planning: 'pendencias',
@@ -606,7 +854,7 @@ export async function ensureBaseFiles(paths, config) {
     });
     await writeYamlIfMissing(paths.stateFiles.backlog, { version: 1, items: [] });
     await writeYamlIfMissing(paths.stateFiles.techDebt, { version: 1, items: [] });
-    await writeYamlIfMissing(paths.stateFiles.finalizeQueue, { version: 1, items: [] });
+    await writeYamlIfMissing(paths.stateFiles.finalizeQueue, { version: 1, items: [], history: [] });
     await ensureCuratedSkillCatalog(paths.stateFiles.skillCatalog);
     await writeYamlIfMissing(paths.stateFiles.unblockEvents, { version: 1, events: [] });
     await writeYamlIfMissing(paths.stateFiles.transitionLog, { version: 1, events: [] });
@@ -623,21 +871,7 @@ export async function ensureBaseFiles(paths, config) {
         jurisdiction_profiles: [],
         control_catalog: [],
     });
-    await writeYamlIfMissing(paths.stateFiles.skillRouting, {
-        version: 1,
-        default_skills: ['architecture', 'concise-planning', 'context-window-management'],
-        routes: [
-            { domain: 'backend', skills: ['devtrack-api', 'architecture', 'api-design-principles'], bundles: ['architecture-backend'] },
-            { domain: 'api', skills: ['devtrack-api', 'api-design-principles'], bundles: ['architecture-backend'] },
-            { domain: 'python', skills: ['api-clean-flask-langgraph', 'architecture'], bundles: ['python-agentic-backend'] },
-            { domain: 'flask', skills: ['api-clean-flask-langgraph'], bundles: ['python-agentic-backend'] },
-            { domain: 'nestjs', skills: ['devtrack-api', 'architecture'], bundles: ['architecture-backend'] },
-            { domain: 'typeorm', skills: ['devtrack-api', 'database-design'], bundles: ['architecture-backend'] },
-            { domain: 'devtrack', skills: ['devtrack-api'], bundles: ['architecture-backend'] },
-            { domain: 'frontend', skills: ['frontend-design', 'react-patterns'], bundles: [] },
-            { domain: 'infra', skills: ['terraform-specialist', 'docker-expert'], bundles: [] }
-        ]
-    });
+    await writeYamlIfMissing(paths.stateFiles.skillRouting, buildDefaultSkillRoutingState());
     if (config.frontend.enabled) {
         await writeYamlIfMissing(paths.stateFiles.frontendGaps, { version: 1, items: [] });
         await writeYamlIfMissing(paths.stateFiles.frontendMap, { version: 1, routes: [] });
@@ -724,19 +958,7 @@ export async function loadStateSnapshot(paths, config) {
         skillRouting = SkillRoutingStateSchema.parse(await readYaml(paths.stateFiles.skillRouting));
     }
     catch (e) {
-        skillRouting = {
-            version: 1,
-            default_skills: ['architecture', 'concise-planning', 'context-window-management'],
-            routes: [
-                { domain: 'backend', skills: ['devtrack-api', 'architecture', 'api-design-principles'], bundles: ['architecture-backend'] },
-                { domain: 'api', skills: ['devtrack-api', 'api-design-principles'], bundles: ['architecture-backend'] },
-                { domain: 'python', skills: ['api-clean-flask-langgraph', 'architecture'], bundles: ['python-agentic-backend'] },
-                { domain: 'flask', skills: ['api-clean-flask-langgraph'], bundles: ['python-agentic-backend'] },
-                { domain: 'nestjs', skills: ['devtrack-api', 'architecture'], bundles: ['architecture-backend'] },
-                { domain: 'typeorm', skills: ['devtrack-api', 'database-design'], bundles: ['architecture-backend'] },
-                { domain: 'devtrack', skills: ['devtrack-api'], bundles: ['architecture-backend'] }
-            ]
-        };
+        skillRouting = buildDefaultSkillRoutingState();
     }
     let frontendGaps;
     let frontendMap;

package/dist/core/sdd/store/sdd-stores.js

@@ -7,7 +7,7 @@ export function createSddStores(paths) {
         discoveryIndex: new YamlFileAdapter(stateFiles.discoveryIndex, DiscoveryIndexStateSchema, () => ({ version: 1, counters: { INS: 0, DEB: 0, RAD: 0, EPIC: 0, FEAT: 0, FGAP: 0, TD: 0 }, records: [] })),
         backlog: new YamlFileAdapter(stateFiles.backlog, BacklogStateSchema, () => ({ version: 1, items: [] })),
         techDebt: new YamlFileAdapter(stateFiles.techDebt, TechDebtStateSchema, () => ({ version: 1, items: [] })),
-        finalizeQueue: new YamlFileAdapter(stateFiles.finalizeQueue, FinalizeQueueStateSchema, () => ({ version: 1, items: [] })),
+        finalizeQueue: new YamlFileAdapter(stateFiles.finalizeQueue, FinalizeQueueStateSchema, () => ({ version: 1, items: [], history: [] })),
         skillCatalog: new YamlFileAdapter(stateFiles.skillCatalog, SkillCatalogStateSchema, () => ({ version: 1, skills: [], bundles: [] })),
         unblockEvents: new YamlFileAdapter(stateFiles.unblockEvents, UnblockEventsStateSchema, () => ({ version: 1, events: [] })),
         transitionLog: new YamlFileAdapter(stateFiles.transitionLog, TransitionLogStateSchema, () => ({ version: 1, events: [] })),
@@ -34,7 +34,7 @@ export function createInMemorySddStores() {
         discoveryIndex: new InMemoryAdapter(DiscoveryIndexStateSchema, () => ({ version: 1, counters: { INS: 0, DEB: 0, RAD: 0, EPIC: 0, FEAT: 0, FGAP: 0, TD: 0 }, records: [] })),
         backlog: new InMemoryAdapter(BacklogStateSchema, () => ({ version: 1, items: [] })),
         techDebt: new InMemoryAdapter(TechDebtStateSchema, () => ({ version: 1, items: [] })),
-        finalizeQueue: new InMemoryAdapter(FinalizeQueueStateSchema, () => ({ version: 1, items: [] })),
+        finalizeQueue: new InMemoryAdapter(FinalizeQueueStateSchema, () => ({ version: 1, items: [], history: [] })),
         skillCatalog: new InMemoryAdapter(SkillCatalogStateSchema, () => ({ version: 1, skills: [], bundles: [] })),
         unblockEvents: new InMemoryAdapter(UnblockEventsStateSchema, () => ({ version: 1, events: [] })),
         transitionLog: new InMemoryAdapter(TransitionLogStateSchema, () => ({ version: 1, events: [] })),