@devtrack-solution/codesdd 1.2.2

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

@@ -0,0 +1,237 @@
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { LENSES, validateDocumentAgainstLens } from "../lenses.js";
+import { adrFileName, generateAdrTemplate } from "../adr.js";
+import { evaluateFeatureStartGuardrails } from "../domain/lifecycle-guardrails.js";
+import { runLifecycleHooks } from "../domain/lifecycle-hooks.js";
+import { allocateEntityId, loadStateSnapshot, loadSkillCatalogState, nowIso, saveStateTransaction } from "../state.js";
+import { slugify, findDiscoveryRecord, ensureFeatureQualityContract, bundlesForSkills, syncCounterFromId, getRuntime, persistAndRender, activeDocNamesForLayout, ensureFeaturePlannedWorkspace, resolveRadar, resolveFeat, buildBacklogItem, classifyFeatureShape, stackContextTokens, updateDependencyMetadata, gitHeadCommit, resolveRoutedSkills, inferOriginType, applyLoggedTransition, pathExists } from "../legacy-operations.js";
+import { SddWriteTransaction } from "../write-manifest.js";
+import { withStateLock } from "../state-lock.js";
+import { featureDeclaresMandatoryAdrImpact } from "../adr-policy.js";
+export class StartService {
+    stores;
+    constructor(stores) {
+        this.stores = stores;
+    }
+    async execute(projectRoot, refOrText, options) {
+        const value = refOrText.trim();
+        if (!value) {
+            throw new Error('Informe uma referencia ou descricao para iniciar.');
+        }
+        const { config, paths } = await getRuntime(projectRoot);
+        return withStateLock(paths.stateDir, async () => {
+            const snapshot = await loadStateSnapshot(paths, config);
+            const catalog = await loadSkillCatalogState(paths);
+            const now = nowIso();
+            let feature;
+            if (/^FEAT-\d{3,}$/.test(value)) {
+                feature = resolveFeat(snapshot.backlog.items, value);
+            }
+            else if (/^(?:RAD|EPIC)-\d{3,}$/.test(value)) {
+                const existing = snapshot.backlog.items.find((item) => (item.origin_type === 'radar' || item.origin_type === 'epic') && item.origin_ref === value);
+                if (existing) {
+                    feature = existing;
+                }
+                else {
+                    const id = await allocateEntityId(paths, 'FEAT');
+                    syncCounterFromId(snapshot.discoveryIndex, id);
+                    const radar = findDiscoveryRecord(snapshot.discoveryIndex.records, value);
+                    resolveRadar(radar);
+                    const title = radar.title || `Feature de ${value}`;
+                    const shape = classifyFeatureShape(title, stackContextTokens(snapshot));
+                    const recommended = resolveRoutedSkills(snapshot, shape.touches);
+                    feature = buildBacklogItem(id, title, 'epic', value, options?.scale || 'STANDARD', recommended, {
+                        parallelGroup: `epic-${value.toLowerCase()}`,
+                        executionKind: shape.executionKind,
+                        planningMode: shape.planningMode,
+                        acceptanceRefs: [value],
+                        touches: shape.touches,
+                        lockDomains: shape.lockDomains,
+                        produces: shape.produces,
+                        consumes: shape.consumes,
+                        flowMode: options?.flowMode,
+                    });
+                    snapshot.backlog.items.push(feature);
+                }
+            }
+            else {
+                const id = await allocateEntityId(paths, 'FEAT');
+                syncCounterFromId(snapshot.discoveryIndex, id);
+                const shape = classifyFeatureShape(value, stackContextTokens(snapshot));
+                const recommended = resolveRoutedSkills(snapshot, shape.touches);
+                feature = buildBacklogItem(id, value, inferOriginType(value), /^([A-Z]+-\d{3,})$/.test(value) ? value : undefined, options?.scale || 'STANDARD', recommended, {
+                    executionKind: shape.executionKind,
+                    planningMode: shape.planningMode,
+                    touches: shape.touches,
+                    lockDomains: shape.lockDomains,
+                    produces: shape.produces,
+                    consumes: shape.consumes,
+                    flowMode: options?.flowMode,
+                });
+                snapshot.backlog.items.push(feature);
+            }
+            if (options?.flowMode) {
+                feature.flow_mode = options.flowMode;
+                if (options.flowMode === 'direto') {
+                    feature.gates.proposta.status = 'nao_exigida';
+                    feature.gates.planejamento.status = 'nao_exigida';
+                }
+            }
+            const startGuardrails = evaluateFeatureStartGuardrails(feature, snapshot.backlog.items, !!options?.force);
+            const unresolved = startGuardrails.blocked_check.unresolved;
+            const lockConflicts = startGuardrails.lock_check.conflicts;
+            if (unresolved.length > 0 && !options?.force) {
+                throw new Error(`Nao foi possivel iniciar ${feature.id}: blocked_by pendente (${unresolved.join(', ')}). Use --force para bypass explicito.`);
+            }
+            if (lockConflicts.length > 0 && !options?.force) {
+                throw new Error(`Nao foi possivel iniciar ${feature.id}: lock conflict com ${lockConflicts.join(', ')}. Use --force para bypass explicito.`);
+            }
+            if (!feature.change_name) {
+                const base = slugify(`${feature.id}-${feature.title}`).slice(0, 50).replace(/-+$/g, '') ||
+                    feature.id.toLowerCase();
+                // OpenSDD-native execution keeps this as a compatibility identifier only.
+                // It must not materialize legacy OpenSpec change directories.
+                feature.change_name = base;
+            }
+            await runLifecycleHooks('before-start', {
+                projectRoot,
+                featureId: feature.id,
+                entityId: feature.id,
+                options: options,
+                metadata: {
+                    start_guardrails: startGuardrails,
+                    current_status: feature.status,
+                },
+            });
+            let startLensViolations = [];
+            if (feature.origin_type === 'epic' && feature.origin_ref) {
+                const parentDir = paths.discoveryEpicDir;
+                const files = await fs.readdir(parentDir).catch(() => []);
+                const parentFile = files.find((f) => f.startsWith(`${feature.origin_ref}-`));
+                if (parentFile) {
+                    const content = await fs.readFile(path.join(parentDir, parentFile), 'utf-8').catch(() => '');
+                    if (content) {
+                        const miss = validateDocumentAgainstLens(content, LENSES.epic);
+                        startLensViolations.push(...miss.map((m) => `Epic: ${m}`));
+                    }
+                    else {
+                        startLensViolations.push(`Epic Original (${feature.origin_ref}) vazio ou inacessível.`);
+                    }
+                }
+                else {
+                    startLensViolations.push(`Epic Original (${feature.origin_ref}) não encontrado.`);
+                }
+            }
+            applyLoggedTransition(snapshot.transitionLog.events, 'FEAT', feature, 'IN_PROGRESS', {
+                sourceCommand: 'sdd start',
+                forceTransition: options?.forceTransition,
+                lensViolations: startLensViolations,
+                reason: `Feature iniciada em workspace ativo`,
+                timestamp: now,
+                afterTransition: (currentFeature) => {
+                    currentFeature.current_stage = 'execucao';
+                    currentFeature.last_sync_at = now;
+                },
+            });
+            if (!feature.start_commit_sha) {
+                feature.start_commit_sha = await gitHeadCommit(projectRoot);
+            }
+            if (feature.execution_kind === 'frontend_coverage' && feature.frontend_impact_status === 'unknown') {
+                feature.frontend_impact_status = 'required';
+            }
+            feature.recommended_skills = resolveRoutedSkills(snapshot, feature.touches);
+            if (options?.force && (unresolved.length > 0 || lockConflicts.length > 0)) {
+                const notes = [
+                    unresolved.length > 0 ? `FORCED blocked_by pendente: ${unresolved.join(', ')}` : '',
+                    lockConflicts.length > 0 ? `FORCED lock conflict: ${lockConflicts.join(', ')}` : '',
+                ].filter(Boolean);
+                feature.summary = [feature.summary || '', ...notes].filter(Boolean).join('\n');
+            }
+            if ((feature.origin_type === 'radar' || feature.origin_type === 'epic') && feature.origin_ref) {
+                const radar = findDiscoveryRecord(snapshot.discoveryIndex.records, feature.origin_ref);
+                if (radar && (radar.type === 'RAD' || radar.type === 'EPIC')) {
+                    const shouldPromoteParent = radar.status === 'READY' || radar.status === 'PLANNED';
+                    if (shouldPromoteParent) {
+                        applyLoggedTransition(snapshot.transitionLog.events, radar.type, radar, 'IN_PROGRESS', {
+                            sourceCommand: 'sdd start',
+                            reason: `Feature filha ${feature.id} iniciou execucao`,
+                            timestamp: now,
+                            afterTransition: (currentRadar) => {
+                                currentRadar.updated_at = now;
+                            },
+                        });
+                    }
+                }
+            }
+            const recommendedBundles = bundlesForSkills(catalog, feature.recommended_skills);
+            ensureFeatureQualityContract(feature, feature.origin_ref || feature.id);
+            if (featureDeclaresMandatoryAdrImpact(feature)) {
+                feature.requires_adr = true;
+            }
+            const plannedDir = path.join(paths.plannedDir, feature.id);
+            const activeDir = path.join(paths.activeDir, feature.id);
+            const docNames = activeDocNamesForLayout(config);
+            const activeWorkspace = {
+                activePath: activeDir,
+                generatedDocs: [
+                    path.relative(paths.projectRoot, path.join(activeDir, docNames.spec)),
+                    path.relative(paths.projectRoot, path.join(activeDir, docNames.plan)),
+                    path.relative(paths.projectRoot, path.join(activeDir, docNames.quality)),
+                    path.relative(paths.projectRoot, path.join(activeDir, docNames.tasks)),
+                    path.relative(paths.projectRoot, path.join(activeDir, docNames.changelog)),
+                ],
+                handoffSeedRefs: [feature.id, feature.origin_ref].filter((v) => Boolean(v)),
+            };
+            await fs.mkdir(paths.activeDir, { recursive: true });
+            if (!(await pathExists(activeDir))) {
+                let plannedWorkspace = await ensureFeaturePlannedWorkspace(paths, config, feature, recommendedBundles);
+                if (!(await pathExists(plannedWorkspace.plannedPath))) {
+                    plannedWorkspace = await ensureFeaturePlannedWorkspace(paths, config, feature, recommendedBundles);
+                }
+                await fs.rename(plannedWorkspace.plannedPath, activeDir);
+                activeWorkspace.handoffSeedRefs = plannedWorkspace.handoffSeedRefs;
+            }
+            if (feature.requires_adr) {
+                const adrDir = path.join(paths.coreDir, 'adrs');
+                const adrPath = path.join(adrDir, adrFileName(feature.id));
+                const adrExists = await pathExists(adrPath);
+                if (!adrExists) {
+                    const tx = new SddWriteTransaction();
+                    tx.writeFile(adrPath, generateAdrTemplate(feature, now));
+                    await tx.commit(paths.projectRoot, paths.memoryRoot, 'start.service (ADR)');
+                }
+            }
+            updateDependencyMetadata(snapshot.backlog.items);
+            await saveStateTransaction(paths, {
+                backlog: snapshot.backlog,
+                discoveryIndex: snapshot.discoveryIndex,
+                transitionLog: snapshot.transitionLog,
+            });
+            await persistAndRender(paths, config, options?.render);
+            await runLifecycleHooks('after-start', {
+                projectRoot,
+                featureId: feature.id,
+                entityId: feature.id,
+                options: options,
+                metadata: {
+                    start_guardrails: startGuardrails,
+                    active_path: path.relative(paths.projectRoot, activeWorkspace.activePath),
+                },
+            });
+            return {
+                featureId: feature.id,
+                changeName: feature.change_name,
+                status: feature.status,
+                start_guardrails: startGuardrails,
+                active_path: path.relative(paths.projectRoot, activeWorkspace.activePath),
+                generated_docs: activeWorkspace.generatedDocs,
+                recommended_bundles: recommendedBundles,
+                handoff_seed_refs: activeWorkspace.handoffSeedRefs,
+                flow_mode: feature.flow_mode,
+                start_commit_sha: feature.start_commit_sha || '',
+            };
+        });
+    }
+}
+//# sourceMappingURL=start.service.js.map

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

@@ -0,0 +1,15 @@
+import type { SkillCatalogEntry, SkillBundle, SkillCatalogState } from './types.js';
+export interface SkillSuggestFilters {
+    phase?: string;
+    domains?: string[];
+    bundles?: string[];
+    max?: number;
+}
+export interface RankedSkill {
+    skill: SkillCatalogEntry;
+    score: number;
+    reasons: string[];
+}
+export declare function listBundles(catalog: SkillCatalogState): SkillBundle[];
+export declare function suggestSkills(catalog: SkillCatalogState, filters?: SkillSuggestFilters): RankedSkill[];
+//# sourceMappingURL=skills.d.ts.map

package/dist/core/sdd/skills.js

@@ -0,0 +1,46 @@
+function normalize(values) {
+    if (!values)
+        return [];
+    return values.map((v) => v.trim().toLowerCase()).filter((v) => v.length > 0);
+}
+export function listBundles(catalog) {
+    return catalog.bundles.slice().sort((a, b) => a.id.localeCompare(b.id));
+}
+export function suggestSkills(catalog, filters = {}) {
+    const phase = filters.phase?.trim().toLowerCase();
+    const domains = normalize(filters.domains);
+    const bundles = normalize(filters.bundles);
+    const max = Math.max(1, Math.min(filters.max ?? 5, 20));
+    const ranked = catalog.skills.map((skill) => {
+        let score = skill.priority;
+        const reasons = [];
+        if (phase && skill.phases.map((p) => p.toLowerCase()).includes(phase)) {
+            score += 3;
+            reasons.push(`fase=${phase}`);
+        }
+        if (domains.length > 0) {
+            const skillDomains = skill.domains.map((d) => d.toLowerCase());
+            const hits = domains.filter((domain) => skillDomains.includes(domain));
+            if (hits.length > 0) {
+                score += hits.length * 2;
+                reasons.push(`dominios=${hits.join(',')}`);
+            }
+        }
+        if (bundles.length > 0) {
+            const skillBundles = skill.bundle_ids.map((b) => b.toLowerCase());
+            const hits = bundles.filter((bundle) => skillBundles.includes(bundle));
+            if (hits.length > 0) {
+                score += 4;
+                reasons.push(`bundle=${hits.join(',')}`);
+            }
+        }
+        return { skill, score, reasons };
+    });
+    ranked.sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        return a.skill.id.localeCompare(b.skill.id);
+    });
+    return ranked.slice(0, max);
+}
+//# sourceMappingURL=skills.js.map

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

@@ -0,0 +1,19 @@
+export interface LockMetadata {
+    pid: number;
+    hostname: string;
+    acquired_at: string;
+}
+export interface AcquireOptions {
+    timeoutMs?: number;
+    staleMs?: number;
+    signal?: AbortSignal;
+}
+export declare class StateLockTimeoutError extends Error {
+    readonly lockPath: string;
+    readonly holder?: LockMetadata | undefined;
+    constructor(lockPath: string, holder?: LockMetadata | undefined);
+}
+export declare function acquireStateLock(stateDir: string, options?: AcquireOptions): Promise<() => Promise<void>>;
+export declare function releaseStateLock(stateDir: string): Promise<void>;
+export declare function withStateLock<T>(stateDir: string, fn: () => Promise<T>, options?: AcquireOptions): Promise<T>;
+//# sourceMappingURL=state-lock.d.ts.map

package/dist/core/sdd/state-lock.js

@@ -0,0 +1,144 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+const LOCK_FILE_NAME = '.lock';
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_STALE_MS = 60_000;
+const RETRY_INTERVAL_MS = 100;
+export class StateLockTimeoutError extends Error {
+    lockPath;
+    holder;
+    constructor(lockPath, holder) {
+        const holderInfo = holder
+            ? ` held by pid=${holder.pid}@${holder.hostname} since ${holder.acquired_at}`
+            : '';
+        super(`Could not acquire SDD state lock at ${lockPath}${holderInfo}.`);
+        this.lockPath = lockPath;
+        this.holder = holder;
+        this.name = 'StateLockTimeoutError';
+    }
+}
+function lockPathFor(stateDir) {
+    return path.join(stateDir, LOCK_FILE_NAME);
+}
+function isProcessAlive(pid, hostname) {
+    if (hostname !== os.hostname())
+        return true;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ESRCH')
+            return false;
+        return true;
+    }
+}
+async function readHolder(lockPath) {
+    try {
+        const raw = await fs.readFile(lockPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed?.pid === 'number' &&
+            typeof parsed?.hostname === 'string' &&
+            typeof parsed?.acquired_at === 'string') {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+async function isStale(holder, staleMs) {
+    if (!holder)
+        return true;
+    const acquiredAt = Date.parse(holder.acquired_at);
+    if (Number.isNaN(acquiredAt))
+        return true;
+    if (Date.now() - acquiredAt > staleMs)
+        return true;
+    if (!isProcessAlive(holder.pid, holder.hostname))
+        return true;
+    return false;
+}
+async function tryClaim(lockPath) {
+    const metadata = {
+        pid: process.pid,
+        hostname: os.hostname(),
+        acquired_at: new Date().toISOString(),
+    };
+    try {
+        const handle = await fs.open(lockPath, 'wx');
+        try {
+            await handle.writeFile(JSON.stringify(metadata), 'utf-8');
+        }
+        finally {
+            await handle.close();
+        }
+        return true;
+    }
+    catch (err) {
+        if (err.code === 'EEXIST')
+            return false;
+        throw err;
+    }
+}
+async function breakStaleLock(lockPath) {
+    try {
+        await fs.unlink(lockPath);
+    }
+    catch {
+        /* swallow: another process may have already broken it */
+    }
+}
+export async function acquireStateLock(stateDir, options = {}) {
+    const lockPath = lockPathFor(stateDir);
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
+    const deadline = Date.now() + timeoutMs;
+    await fs.mkdir(stateDir, { recursive: true });
+    while (true) {
+        if (options.signal?.aborted) {
+            throw new StateLockTimeoutError(lockPath);
+        }
+        if (await tryClaim(lockPath)) {
+            return async () => {
+                await releaseStateLock(stateDir);
+            };
+        }
+        const holder = await readHolder(lockPath);
+        if (await isStale(holder, staleMs)) {
+            await breakStaleLock(lockPath);
+            continue;
+        }
+        if (Date.now() >= deadline) {
+            throw new StateLockTimeoutError(lockPath, holder ?? undefined);
+        }
+        await new Promise((resolve) => setTimeout(resolve, RETRY_INTERVAL_MS));
+    }
+}
+export async function releaseStateLock(stateDir) {
+    const lockPath = lockPathFor(stateDir);
+    const holder = await readHolder(lockPath);
+    if (holder && holder.pid === process.pid && holder.hostname === os.hostname()) {
+        try {
+            await fs.unlink(lockPath);
+        }
+        catch (err) {
+            const code = err.code;
+            if (code !== 'ENOENT')
+                throw err;
+        }
+    }
+}
+export async function withStateLock(stateDir, fn, options = {}) {
+    const release = await acquireStateLock(stateDir, options);
+    try {
+        return await fn();
+    }
+    finally {
+        await release();
+    }
+}
+//# sourceMappingURL=state-lock.js.map

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

@@ -0,0 +1,155 @@
+import { type NamingContractState, type ArchitectureState, type BacklogState, type DiscoveryIndexState, type FinalizeQueueState, type FrontendDecisionsState, type FrontendGapsState, type FrontendMapState, type IntegrationContractsState, type RepoMapState, type SourceIndexState, type SkillCatalogState, type SkillRoutingState, type ServiceCatalogState, type TechStackState, type TechDebtState, type UnblockEventsState, type TransitionLogState, type AuditHistoryState } from './types.js';
+export type SddLanguage = 'pt-BR' | 'en-US';
+export type SddLayout = 'legacy' | 'pt-BR' | 'en-US';
+export interface SddRuntimeConfig {
+    enabled: boolean;
+    memoryDir: string;
+    language: SddLanguage;
+    layout: SddLayout;
+    folders: {
+        discovery: string;
+        planning: string;
+        skills: string;
+        templates: string;
+        deposito: string;
+        planned: string;
+        active: string;
+        archived: string;
+    };
+    frontend: {
+        enabled: boolean;
+    };
+    views: {
+        autoRender: boolean;
+    };
+}
+export interface SddPaths {
+    projectRoot: string;
+    memoryRoot: string;
+    configFile: string;
+    coreDir: string;
+    discoveryDir: string;
+    pendenciasDir: string;
+    stateDir: string;
+    skillsDir: string;
+    skillsCuratedDir: string;
+    skillsBundlesDir: string;
+    skillsCuratedFolderName: string;
+    skillsBundlesFolderName: string;
+    templatesDir: string;
+    promptsDir: string;
+    depositoDir: string;
+    plannedDir: string;
+    activeDir: string;
+    archivedDir: string;
+    discoveryInsightsDir: string;
+    discoveryDebatesDir: string;
+    discoveryRadarDir: string;
+    discoveryEpicDir: string;
+    discoveryDiscardedDir: string;
+    stateFiles: {
+        discoveryIndex: string;
+        backlog: string;
+        techDebt: string;
+        finalizeQueue: string;
+        skillCatalog: string;
+        unblockEvents: string;
+        transitionLog: string;
+        auditHistory: string;
+        frontendGaps: string;
+        frontendMap: string;
+        architecture: string;
+        serviceCatalog: string;
+        techStack: string;
+        integrationContracts: string;
+        frontendDecisions: string;
+        repoMap: string;
+        sourceIndex: string;
+        skillRouting: string;
+        namingContract: string;
+    };
+}
+export interface SddStateSnapshot {
+    discoveryIndex: DiscoveryIndexState;
+    backlog: BacklogState;
+    techDebt: TechDebtState;
+    finalizeQueue: FinalizeQueueState;
+    skillCatalog: SkillCatalogState;
+    unblockEvents: UnblockEventsState;
+    transitionLog: TransitionLogState;
+    auditHistory: AuditHistoryState;
+    frontendGaps?: FrontendGapsState;
+    frontendMap?: FrontendMapState;
+    architecture: ArchitectureState;
+    serviceCatalog: ServiceCatalogState;
+    techStack: TechStackState;
+    integrationContracts: IntegrationContractsState;
+    frontendDecisions?: FrontendDecisionsState;
+    repoMap: RepoMapState;
+    sourceIndex: SourceIndexState;
+    skillRouting: SkillRoutingState;
+}
+export declare function loadProjectSddConfig(projectRoot: string): Promise<SddRuntimeConfig>;
+export declare function upsertProjectSddConfig(projectRoot: string, overrides?: {
+    frontendEnabled?: boolean;
+    language?: SddLanguage;
+    layout?: SddLayout;
+}): Promise<SddRuntimeConfig>;
+export declare function resolveSddPaths(projectRoot: string, config: SddRuntimeConfig): SddPaths;
+export declare function ensureBaseStructure(paths: SddPaths): Promise<void>;
+export declare function ensureBaseFiles(paths: SddPaths, config: SddRuntimeConfig): Promise<void>;
+export declare function loadStateSnapshot(paths: SddPaths, config: SddRuntimeConfig): Promise<SddStateSnapshot>;
+export declare function loadSkillCatalogState(paths: SddPaths): Promise<SkillCatalogState>;
+export type SddCounterType = 'INS' | 'DEB' | 'RAD' | 'EPIC' | 'FEAT' | 'FGAP' | 'TD';
+export declare function nowIso(): string;
+export declare function saveDiscoveryIndexState(paths: SddPaths, state: DiscoveryIndexState): Promise<void>;
+export declare function saveBacklogState(paths: SddPaths, state: BacklogState): Promise<void>;
+export declare function saveTechDebtState(paths: SddPaths, state: TechDebtState): Promise<void>;
+export declare function saveFinalizeQueueState(paths: SddPaths, state: FinalizeQueueState): Promise<void>;
+export declare function saveSkillCatalogState(paths: SddPaths, state: SkillCatalogState): Promise<void>;
+export declare function saveUnblockEventsState(paths: SddPaths, state: UnblockEventsState): Promise<void>;
+export declare function saveTransitionLogState(paths: SddPaths, state: TransitionLogState): Promise<void>;
+export declare function saveFrontendGapsState(paths: SddPaths, state: FrontendGapsState): Promise<void>;
+export declare function saveFrontendMapState(paths: SddPaths, state: FrontendMapState): Promise<void>;
+export declare function saveArchitectureState(paths: SddPaths, state: ArchitectureState): Promise<void>;
+export declare function saveServiceCatalogState(paths: SddPaths, state: ServiceCatalogState): Promise<void>;
+export declare function saveTechStackState(paths: SddPaths, state: TechStackState): Promise<void>;
+export declare function saveIntegrationContractsState(paths: SddPaths, state: IntegrationContractsState): Promise<void>;
+export declare function saveFrontendDecisionsState(paths: SddPaths, state: FrontendDecisionsState): Promise<void>;
+export declare function saveRepoMapState(paths: SddPaths, state: RepoMapState): Promise<void>;
+export declare function saveSourceIndexState(paths: SddPaths, state: SourceIndexState): Promise<void>;
+export declare function defaultNamingContractState(): NamingContractState;
+export declare function loadNamingContractState(paths: SddPaths): Promise<NamingContractState>;
+export declare function saveNamingContractState(paths: SddPaths, state: NamingContractState): Promise<void>;
+export interface SddStateWriteSet {
+    discoveryIndex?: DiscoveryIndexState;
+    backlog?: BacklogState;
+    techDebt?: TechDebtState;
+    finalizeQueue?: FinalizeQueueState;
+    skillCatalog?: SkillCatalogState;
+    unblockEvents?: UnblockEventsState;
+    transitionLog?: TransitionLogState;
+    auditHistory?: AuditHistoryState;
+    frontendGaps?: FrontendGapsState;
+    frontendMap?: FrontendMapState;
+    architecture?: ArchitectureState;
+    serviceCatalog?: ServiceCatalogState;
+    techStack?: TechStackState;
+    integrationContracts?: IntegrationContractsState;
+    frontendDecisions?: FrontendDecisionsState;
+    repoMap?: RepoMapState;
+    sourceIndex?: SourceIndexState;
+}
+export declare function saveStateTransaction(paths: SddPaths, updates: SddStateWriteSet): Promise<void>;
+/**
+ * Allocates a new entity ID with atomic reservation and collision detection.
+ * Verifies that the generated ID does not already exist in the discovery index
+ * records before persisting. Retries with the next counter value if collision
+ * is detected (defensive against manual edits or stale counters).
+ *
+ * @param paths - SDD directory paths
+ * @param type - Counter type (INS, DEB, RAD, EPIC, FEAT, FGAP, TD)
+ * @returns The reserved ID string
+ */
+export declare function allocateEntityId(paths: SddPaths, type: SddCounterType): Promise<string>;
+//# sourceMappingURL=state.d.ts.map