@devtrack-solution/codesdd 1.2.3 → 1.2.4

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

@@ -0,0 +1,225 @@
+import path from 'node:path';
+import { existsSync, promises as fs } from 'node:fs';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { activeDocNamesForLayout, ensureMemoryInitialized, relProjectPath } from '../legacy-operations.js';
+import { loadProjectSddConfig, resolveSddPaths } from '../state.js';
+import { parseWorkspaceYamlDocument, } from '../workspace-schemas.js';
+const execFileAsync = promisify(execFile);
+function uniqueSorted(values) {
+    return Array.from(new Set(values.filter(Boolean))).sort((a, b) => a.localeCompare(b));
+}
+function normalizeCommand(value) {
+    return value.replace(/\s+/g, ' ').trim().toLowerCase();
+}
+function normalizePathForCoherence(value) {
+    const normalized = value.replace(/\\/g, '/').trim();
+    return normalized.replace(/\.sdd\/(planned|active|archived)\/(FEAT-\d{4})\//, '.sdd/*/$2/');
+}
+function pathCovered(plannedPath, evidencePaths) {
+    const planned = normalizePathForCoherence(plannedPath);
+    return evidencePaths.some((candidate) => {
+        const normalizedCandidate = normalizePathForCoherence(candidate);
+        return (normalizedCandidate === planned ||
+            normalizedCandidate.endsWith(`/${planned}`) ||
+            planned.endsWith(`/${normalizedCandidate}`));
+    });
+}
+function collectPlannedFiles(plan, tasks, quality) {
+    const includePath = (value) => {
+        const normalized = value.replace(/\\/g, '/');
+        if (normalized.startsWith('.sdd/state/'))
+            return false;
+        if (normalized.startsWith('.sdd/archived/'))
+            return false;
+        return true;
+    };
+    return uniqueSorted([
+        ...plan.execution_plan.command_sequence.flatMap((step) => step.expected_state_writes.filter(includePath)),
+        ...tasks.tasks
+            .filter((task) => task.phase !== 'finalization')
+            .flatMap((task) => task.files_touched.filter(includePath)),
+        ...quality.traceability.requirements.flatMap((req) => req.code_refs.map((ref) => ref.path)),
+    ]);
+}
+function collectPlannedCommands(plan, tasks, quality) {
+    return uniqueSorted([
+        ...plan.governance.validation_gates.map((gate) => gate.command),
+        ...tasks.tasks.flatMap((task) => task.test_scripts.map((script) => script.command)),
+        ...quality.validation_strategies.map((strategy) => strategy.command),
+    ]).map(normalizeCommand);
+}
+function collectExecutionFiles(quality, changelog, changedFiles) {
+    const changelogRefs = changelog.entries.flatMap((entry) => entry.refs);
+    return uniqueSorted([
+        ...changedFiles,
+        ...quality.evidence_log.map((entry) => entry.artifact ?? '').filter(Boolean),
+        ...quality.traceability.requirements.flatMap((req) => req.evidence_refs),
+        ...changelogRefs,
+    ]);
+}
+function collectExecutionCommands(quality) {
+    return uniqueSorted(quality.evidence_log
+        .map((entry) => entry.provenance?.command ?? '')
+        .filter(Boolean)
+        .map(normalizeCommand));
+}
+function expectsAdr(spec, tasks) {
+    const corpus = [spec.objective, spec.expected_outcome, ...tasks.tasks.map((task) => `${task.title} ${task.description}`)]
+        .join(' ')
+        .toLowerCase();
+    return corpus.includes('adr');
+}
+export function evaluatePlanningExecutionCoherence(input) {
+    const plannedFiles = collectPlannedFiles(input.plan, input.tasks, input.quality);
+    const plannedCommands = collectPlannedCommands(input.plan, input.tasks, input.quality);
+    const executionFiles = collectExecutionFiles(input.quality, input.changelog, input.changedFiles);
+    const executionCommands = collectExecutionCommands(input.quality);
+    const issues = [];
+    const missingFiles = plannedFiles.filter((plannedFile) => !pathCovered(plannedFile, executionFiles));
+    if (missingFiles.length > 0) {
+        issues.push({
+            code: 'MISSING_FILE_EVIDENCE',
+            severity: 'error',
+            message: 'Planned files are not reflected in diff/evidence artifacts.',
+            evidence: {
+                missing_files: missingFiles,
+            },
+        });
+    }
+    const missingCommands = plannedCommands.filter((command) => !executionCommands.includes(command));
+    if (missingCommands.length > 0) {
+        issues.push({
+            code: 'MISSING_COMMAND_EVIDENCE',
+            severity: 'warning',
+            message: 'Planned validation commands are missing from evidence provenance.',
+            evidence: {
+                missing_commands: missingCommands,
+            },
+        });
+    }
+    const notMetAcceptance = input.quality.acceptance_matrix.filter((entry) => entry.status === 'not_met');
+    if (notMetAcceptance.length > 0) {
+        issues.push({
+            code: 'ACCEPTANCE_NOT_MET',
+            severity: 'error',
+            message: 'Quality acceptance matrix still has not_met criteria.',
+            evidence: {
+                criteria: notMetAcceptance.map((entry) => entry.criterion),
+            },
+        });
+    }
+    const openRisks = input.quality.requirement_validation_evidence_risk_matrix.filter((entry) => entry.risk_status === 'open');
+    if (openRisks.length > 0) {
+        issues.push({
+            code: 'RISK_STATUS_OPEN',
+            severity: 'warning',
+            message: 'Requirement risk matrix still has open risk entries.',
+            evidence: {
+                requirements: openRisks.map((entry) => entry.requirement_ref),
+            },
+        });
+    }
+    if (expectsAdr(input.spec, input.tasks) && !input.adrExists) {
+        issues.push({
+            code: 'ADR_MISSING',
+            severity: 'error',
+            message: 'Planning requires ADR coherence but ADR file is missing.',
+            evidence: {
+                expected_adr: input.adrPath,
+            },
+        });
+    }
+    const healthy = !issues.some((issue) => issue.severity === 'error');
+    return {
+        schema_version: 1,
+        feature_id: input.featureId,
+        generated_at: new Date().toISOString(),
+        workspace_path: input.workspacePath,
+        adr_path: input.adrPath,
+        healthy,
+        planned: {
+            files: plannedFiles,
+            commands: plannedCommands,
+        },
+        execution: {
+            files: executionFiles,
+            commands: executionCommands,
+        },
+        issues,
+    };
+}
+async function listChangedFiles(projectRoot) {
+    try {
+        const { stdout } = await execFileAsync('git', ['status', '--porcelain'], {
+            cwd: projectRoot,
+            maxBuffer: 16 * 1024 * 1024,
+        });
+        return uniqueSorted(stdout
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => line.slice(3).trim())
+            .map((line) => (line.includes('->') ? line.split('->').pop() ?? line : line))
+            .map((line) => line.trim())
+            .filter(Boolean));
+    }
+    catch {
+        return [];
+    }
+}
+async function resolveWorkspacePath(projectRoot, featureId) {
+    const config = await loadProjectSddConfig(projectRoot);
+    const paths = resolveSddPaths(projectRoot, config);
+    await ensureMemoryInitialized(paths);
+    const roots = [paths.activeDir, paths.plannedDir, paths.archivedDir];
+    for (const root of roots) {
+        const workspacePath = path.join(root, featureId);
+        if (existsSync(workspacePath)) {
+            return {
+                workspacePath,
+                adrPath: path.join(paths.coreDir, 'adrs', `ADR-${featureId}.md`),
+            };
+        }
+    }
+    throw new Error(`Workspace not found for ${featureId}.`);
+}
+export class PlanningExecutionCoherenceService {
+    async execute(projectRoot, featureId, options = {}) {
+        if (!/^FEAT-\d{4}$/.test(featureId)) {
+            throw new Error('Invalid feature id. Use FEAT-####.');
+        }
+        const config = await loadProjectSddConfig(projectRoot);
+        const paths = resolveSddPaths(projectRoot, config);
+        const names = activeDocNamesForLayout(config);
+        const { workspacePath, adrPath } = await resolveWorkspacePath(projectRoot, featureId);
+        const readDoc = async (name) => {
+            const filePath = path.join(workspacePath, name);
+            if (!existsSync(filePath)) {
+                throw new Error(`${name} not found for ${featureId}.`);
+            }
+            return fs.readFile(filePath, 'utf-8');
+        };
+        const [specRaw, planRaw, tasksRaw, changelogRaw, qualityRaw] = await Promise.all([
+            readDoc(names.spec),
+            readDoc(names.plan),
+            readDoc(names.tasks),
+            readDoc(names.changelog),
+            readDoc(names.quality),
+        ]);
+        const report = evaluatePlanningExecutionCoherence({
+            featureId,
+            workspacePath: relProjectPath(paths, workspacePath),
+            adrPath: relProjectPath(paths, adrPath),
+            adrExists: existsSync(adrPath),
+            spec: parseWorkspaceYamlDocument('1-spec.yaml', specRaw),
+            plan: parseWorkspaceYamlDocument('2-plan.yaml', planRaw),
+            tasks: parseWorkspaceYamlDocument('3-tasks.yaml', tasksRaw),
+            changelog: parseWorkspaceYamlDocument('4-changelog.yaml', changelogRaw),
+            quality: parseWorkspaceYamlDocument('5-quality.yaml', qualityRaw),
+            changedFiles: options.changedFiles ?? (await listChangedFiles(projectRoot)),
+        });
+        return report;
+    }
+}
+//# sourceMappingURL=planning-execution-coherence.service.js.map

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',
@@ -57,9 +305,9 @@ export function defaultFoldersForLayout(layout) {
 const DEFAULT_SDD_CONFIG = {
     enabled: true,
     memoryDir: '.sdd',
-    language: 'pt-BR',
-    layout: 'legacy',
-    folders: defaultFoldersForLayout('legacy'),
+    language: 'en-US',
+    layout: 'en-US',
+    folders: defaultFoldersForLayout('en-US'),
     frontend: { enabled: false },
     views: { autoRender: true },
 };
@@ -110,8 +358,18 @@ export function mergeRuntimeConfig(raw) {
     }
     const frontend = isRecord(raw.frontend) ? raw.frontend : {};
     const views = isRecord(raw.views) ? raw.views : {};
-    const language = raw.language === 'en-US' ? 'en-US' : 'pt-BR';
-    const layout = raw.layout === 'pt-BR' ? 'pt-BR' : raw.layout === 'en-US' ? 'en-US' : 'legacy';
+    const language = raw.language === 'pt-BR'
+        ? 'pt-BR'
+        : raw.language === 'en-US'
+            ? 'en-US'
+            : DEFAULT_SDD_CONFIG.language;
+    const layout = raw.layout === 'pt-BR'
+        ? 'pt-BR'
+        : raw.layout === 'en-US'
+            ? 'en-US'
+            : raw.layout === 'legacy'
+                ? 'legacy'
+                : DEFAULT_SDD_CONFIG.layout;
     const folderDefaults = defaultFoldersForLayout(layout);
     const rawFolders = isRecord(raw.folders) ? raw.folders : {};
     // compatibilidade retroativa para nome legado "pendencias"
@@ -606,7 +864,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 +881,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 +968,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: [] })),