@devtrack-solution/codesdd 1.2.3 → 1.2.4

package/dist/core/sdd/artifact-id-allocator.js

@@ -0,0 +1,510 @@
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+export const artifactIdAllocatorTypeSchema = z.enum(['INS', 'DEB', 'EPIC', 'FEAT', 'FGAP', 'TD']);
+export const allocatorActorSchema = z.object({
+    agent_id: z.string().min(1),
+    agent_kind: z.string().min(1).optional(),
+});
+export const artifactIdReserveRequestSchema = z.object({
+    schema_version: z.literal(1),
+    project_id: z.string().min(1),
+    tenant_id: z.string().min(1).optional(),
+    artifact_type: artifactIdAllocatorTypeSchema,
+    title_canonical: z.string().min(1).optional(),
+    origin_ref: z.string().min(1).optional(),
+    requested_by: allocatorActorSchema,
+    client_request_id: z.string().min(1).optional(),
+    idempotency_key: z.string().min(16),
+});
+export const artifactIdReservationSchema = z.object({
+    schema_version: z.literal(1),
+    artifact_id: z.string().regex(/^(INS|DEB|EPIC|FEAT|FGAP|TD)-\d{4}$/),
+    artifact_type: artifactIdAllocatorTypeSchema,
+    sequence: z.number().int().positive(),
+    project_id: z.string().min(1),
+    tenant_id: z.string().min(1).optional(),
+    idempotency_key: z.string().min(16),
+    request_fingerprint: z.string().min(16),
+    revision: z.number().int().positive(),
+    reserved_at: z.string().datetime(),
+});
+export const artifactIdReserveResponseSchema = z.object({
+    schema_version: z.literal(1),
+    status: z.enum(['reserved', 'replayed']),
+    reservation: artifactIdReservationSchema,
+});
+export const artifactAllocatorLeaseRequestSchema = z.object({
+    schema_version: z.literal(1),
+    project_id: z.string().min(1),
+    tenant_id: z.string().min(1).optional(),
+    artifact_type: artifactIdAllocatorTypeSchema,
+    holder: allocatorActorSchema,
+    ttl_ms: z.number().int().positive(),
+    idempotency_key: z.string().min(16),
+});
+export const artifactAllocatorLeaseSchema = z.object({
+    schema_version: z.literal(1),
+    lease_id: z.string().min(16),
+    project_id: z.string().min(1),
+    tenant_id: z.string().min(1).optional(),
+    artifact_type: artifactIdAllocatorTypeSchema,
+    holder: allocatorActorSchema,
+    fencing_token: z.number().int().positive(),
+    idempotency_key: z.string().min(16),
+    request_fingerprint: z.string().min(16),
+    acquired_at: z.string().datetime(),
+    expires_at: z.string().datetime(),
+});
+export const artifactAllocatorLeaseResponseSchema = z.object({
+    schema_version: z.literal(1),
+    status: z.enum(['acquired', 'replayed']),
+    lease: artifactAllocatorLeaseSchema,
+});
+export const artifactAllocatorAuditEventSchema = z.object({
+    schema_version: z.literal(1),
+    event_id: z.string().min(16),
+    event_type: z.enum([
+        'lease_acquired',
+        'lease_replayed',
+        'lease_conflict',
+        'reservation_created',
+        'reservation_replayed',
+        'canonical_write_committed',
+        'canonical_write_replayed',
+        'canonical_write_rejected',
+    ]),
+    project_id: z.string().min(1),
+    tenant_id: z.string().min(1).optional(),
+    artifact_type: artifactIdAllocatorTypeSchema,
+    actor: allocatorActorSchema,
+    idempotency_key: z.string().min(16),
+    lease_id: z.string().min(16).optional(),
+    fencing_token: z.number().int().positive().optional(),
+    occurred_at: z.string().datetime(),
+    result: z.enum(['accepted', 'replayed', 'blocked']),
+});
+export const canonicalArtifactWriteRequestSchema = z.object({
+    schema_version: z.literal(1),
+    artifact_id: z.string().regex(/^(INS|DEB|EPIC|FEAT|FGAP|TD)-\d{4}$/),
+    project_id: z.string().min(1),
+    tenant_id: z.string().min(1).optional(),
+    actor: allocatorActorSchema,
+    lease_id: z.string().min(16),
+    fencing_token: z.number().int().positive(),
+    expected_revision: z.number().int().min(0),
+    idempotency_key: z.string().min(16),
+});
+export const canonicalArtifactWriteRecordSchema = z.object({
+    schema_version: z.literal(1),
+    artifact_id: z.string().regex(/^(INS|DEB|EPIC|FEAT|FGAP|TD)-\d{4}$/),
+    project_id: z.string().min(1),
+    tenant_id: z.string().min(1).optional(),
+    revision: z.number().int().positive(),
+    previous_revision: z.number().int().min(0),
+    lease_id: z.string().min(16),
+    fencing_token: z.number().int().positive(),
+    idempotency_key: z.string().min(16),
+    request_fingerprint: z.string().min(16),
+    committed_at: z.string().datetime(),
+});
+export const canonicalArtifactWriteResponseSchema = z.object({
+    schema_version: z.literal(1),
+    status: z.enum(['committed', 'replayed']),
+    write: canonicalArtifactWriteRecordSchema,
+});
+export const noncanonicalDraftSchema = z.object({
+    schema_version: z.literal(1),
+    draft_id: z.string().regex(/^draft_(INS|DEB|EPIC|FEAT|FGAP|TD)_[a-f0-9]{16}$/),
+    artifact_type: artifactIdAllocatorTypeSchema,
+    project_id: z.string().min(1),
+    tenant_id: z.string().min(1).optional(),
+    title_canonical: z.string().min(1),
+    created_by: allocatorActorSchema,
+    created_at: z.string().datetime(),
+    converted_artifact_id: z.string().regex(/^(INS|DEB|EPIC|FEAT|FGAP|TD)-\d{4}$/).optional(),
+    converted_at: z.string().datetime().optional(),
+});
+export const draftConversionResponseSchema = z.object({
+    schema_version: z.literal(1),
+    status: z.enum(['converted', 'replayed']),
+    draft: noncanonicalDraftSchema,
+    reservation: artifactIdReservationSchema,
+});
+export function createEmptyArtifactIdAllocatorState() {
+    return {
+        counters: {},
+        reservations: [],
+        leases: [],
+        audit_log: [],
+        next_fencing_token: 1,
+        canonical_revisions: {},
+        canonical_writes: [],
+        drafts: [],
+    };
+}
+export function buildArtifactIdAllocatorIdempotencyKey(input) {
+    return `alloc_${hashStableJson({
+        project_id: input.project_id,
+        tenant_id: input.tenant_id ?? null,
+        artifact_type: input.artifact_type,
+        title_canonical: input.title_canonical ?? null,
+        origin_ref: input.origin_ref ?? null,
+        requested_by: input.requested_by,
+        client_request_id: input.client_request_id ?? null,
+    })}`;
+}
+export function reserveArtifactId(state, requestInput, options = {}) {
+    const request = artifactIdReserveRequestSchema.parse(requestInput);
+    const requestFingerprint = buildReserveRequestFingerprint(request);
+    const existing = state.reservations.find((reservation) => reservation.idempotency_key === request.idempotency_key);
+    if (existing) {
+        if (existing.request_fingerprint !== requestFingerprint) {
+            throw new Error(`Allocator idempotency key conflict for ${request.idempotency_key}: request fingerprint does not match the existing reservation.`);
+        }
+        const response = artifactIdReserveResponseSchema.parse({
+            schema_version: 1,
+            status: 'replayed',
+            reservation: existing,
+        });
+        appendAuditEvent(state, {
+            event_type: 'reservation_replayed',
+            project_id: request.project_id,
+            tenant_id: request.tenant_id,
+            artifact_type: request.artifact_type,
+            actor: request.requested_by,
+            idempotency_key: request.idempotency_key,
+            occurred_at: options.now ?? new Date().toISOString(),
+            result: 'replayed',
+        });
+        return response;
+    }
+    const current = state.counters[request.artifact_type] ?? 0;
+    const sequence = current + 1;
+    const reservation = artifactIdReservationSchema.parse({
+        schema_version: 1,
+        artifact_id: `${request.artifact_type}-${String(sequence).padStart(4, '0')}`,
+        artifact_type: request.artifact_type,
+        sequence,
+        project_id: request.project_id,
+        tenant_id: request.tenant_id,
+        idempotency_key: request.idempotency_key,
+        request_fingerprint: requestFingerprint,
+        revision: 1,
+        reserved_at: options.now ?? new Date().toISOString(),
+    });
+    state.counters[request.artifact_type] = sequence;
+    state.reservations.push(reservation);
+    appendAuditEvent(state, {
+        event_type: 'reservation_created',
+        project_id: request.project_id,
+        tenant_id: request.tenant_id,
+        artifact_type: request.artifact_type,
+        actor: request.requested_by,
+        idempotency_key: request.idempotency_key,
+        occurred_at: reservation.reserved_at,
+        result: 'accepted',
+    });
+    return artifactIdReserveResponseSchema.parse({
+        schema_version: 1,
+        status: 'reserved',
+        reservation,
+    });
+}
+export function acquireArtifactAllocatorLease(state, requestInput, options = {}) {
+    const request = artifactAllocatorLeaseRequestSchema.parse(requestInput);
+    const now = options.now ?? new Date().toISOString();
+    const requestFingerprint = buildLeaseRequestFingerprint(request);
+    const existing = state.leases.find((lease) => lease.idempotency_key === request.idempotency_key);
+    if (existing) {
+        if (existing.request_fingerprint !== requestFingerprint) {
+            appendAuditEvent(state, {
+                event_type: 'lease_conflict',
+                project_id: request.project_id,
+                tenant_id: request.tenant_id,
+                artifact_type: request.artifact_type,
+                actor: request.holder,
+                idempotency_key: request.idempotency_key,
+                occurred_at: now,
+                result: 'blocked',
+            });
+            throw new Error(`Allocator lease idempotency key conflict for ${request.idempotency_key}: request fingerprint does not match the existing lease.`);
+        }
+        appendAuditEvent(state, {
+            event_type: 'lease_replayed',
+            project_id: request.project_id,
+            tenant_id: request.tenant_id,
+            artifact_type: request.artifact_type,
+            actor: request.holder,
+            idempotency_key: request.idempotency_key,
+            lease_id: existing.lease_id,
+            fencing_token: existing.fencing_token,
+            occurred_at: now,
+            result: 'replayed',
+        });
+        return artifactAllocatorLeaseResponseSchema.parse({
+            schema_version: 1,
+            status: 'replayed',
+            lease: existing,
+        });
+    }
+    const activeLease = state.leases.find((lease) => lease.project_id === request.project_id &&
+        lease.tenant_id === request.tenant_id &&
+        lease.artifact_type === request.artifact_type &&
+        isAllocatorLeaseActive(lease, now));
+    if (activeLease) {
+        appendAuditEvent(state, {
+            event_type: 'lease_conflict',
+            project_id: request.project_id,
+            tenant_id: request.tenant_id,
+            artifact_type: request.artifact_type,
+            actor: request.holder,
+            idempotency_key: request.idempotency_key,
+            lease_id: activeLease.lease_id,
+            fencing_token: activeLease.fencing_token,
+            occurred_at: now,
+            result: 'blocked',
+        });
+        throw new Error(`Active allocator lease already exists for ${request.project_id}/${request.artifact_type}.`);
+    }
+    const fencingToken = state.next_fencing_token;
+    state.next_fencing_token += 1;
+    const lease = artifactAllocatorLeaseSchema.parse({
+        schema_version: 1,
+        lease_id: `lease_${hashStableJson({ request, fencingToken }).slice(0, 24)}`,
+        project_id: request.project_id,
+        tenant_id: request.tenant_id,
+        artifact_type: request.artifact_type,
+        holder: request.holder,
+        fencing_token: fencingToken,
+        idempotency_key: request.idempotency_key,
+        request_fingerprint: requestFingerprint,
+        acquired_at: now,
+        expires_at: new Date(new Date(now).getTime() + request.ttl_ms).toISOString(),
+    });
+    state.leases.push(lease);
+    appendAuditEvent(state, {
+        event_type: 'lease_acquired',
+        project_id: request.project_id,
+        tenant_id: request.tenant_id,
+        artifact_type: request.artifact_type,
+        actor: request.holder,
+        idempotency_key: request.idempotency_key,
+        lease_id: lease.lease_id,
+        fencing_token: lease.fencing_token,
+        occurred_at: now,
+        result: 'accepted',
+    });
+    return artifactAllocatorLeaseResponseSchema.parse({
+        schema_version: 1,
+        status: 'acquired',
+        lease,
+    });
+}
+export function isAllocatorLeaseActive(lease, now) {
+    return new Date(lease.expires_at).getTime() > new Date(now).getTime();
+}
+export function validateAllocatorFencingToken(lease, input) {
+    if (!isAllocatorLeaseActive(lease, input.now)) {
+        return { valid: false, reason: 'expired' };
+    }
+    if (lease.fencing_token !== input.fencing_token) {
+        return { valid: false, reason: 'stale-token' };
+    }
+    return { valid: true, reason: 'valid' };
+}
+export function commitCanonicalArtifactWrite(state, requestInput, options = {}) {
+    const request = canonicalArtifactWriteRequestSchema.parse(requestInput);
+    const now = options.now ?? new Date().toISOString();
+    const requestFingerprint = buildCanonicalWriteRequestFingerprint(request);
+    const existing = state.canonical_writes.find((write) => write.idempotency_key === request.idempotency_key);
+    if (existing) {
+        if (existing.request_fingerprint !== requestFingerprint) {
+            appendAuditEvent(state, buildCanonicalWriteAudit(request, now, 'canonical_write_rejected', 'blocked'));
+            throw new Error(`Canonical write idempotency key conflict for ${request.idempotency_key}.`);
+        }
+        appendAuditEvent(state, buildCanonicalWriteAudit(request, now, 'canonical_write_replayed', 'replayed'));
+        return canonicalArtifactWriteResponseSchema.parse({
+            schema_version: 1,
+            status: 'replayed',
+            write: existing,
+        });
+    }
+    const lease = state.leases.find((candidate) => candidate.lease_id === request.lease_id);
+    if (!lease) {
+        appendAuditEvent(state, buildCanonicalWriteAudit(request, now, 'canonical_write_rejected', 'blocked'));
+        throw new Error(`Canonical write rejected: lease ${request.lease_id} was not found.`);
+    }
+    const artifactType = artifactIdAllocatorTypeSchema.parse(request.artifact_id.split('-')[0]);
+    if (lease.project_id !== request.project_id ||
+        lease.tenant_id !== request.tenant_id ||
+        lease.artifact_type !== artifactType) {
+        appendAuditEvent(state, buildCanonicalWriteAudit(request, now, 'canonical_write_rejected', 'blocked'));
+        throw new Error('Canonical write rejected: allocator lease scope does not match artifact write request.');
+    }
+    const fencing = validateAllocatorFencingToken(lease, {
+        fencing_token: request.fencing_token,
+        now,
+    });
+    if (!fencing.valid) {
+        appendAuditEvent(state, buildCanonicalWriteAudit(request, now, 'canonical_write_rejected', 'blocked'));
+        throw new Error(`Canonical write rejected: allocator fencing token is ${fencing.reason}.`);
+    }
+    const currentRevision = state.canonical_revisions[request.artifact_id] ?? 0;
+    if (currentRevision !== request.expected_revision) {
+        appendAuditEvent(state, buildCanonicalWriteAudit(request, now, 'canonical_write_rejected', 'blocked'));
+        throw new Error(`Canonical write rejected: expected revision ${request.expected_revision} does not match current revision ${currentRevision}.`);
+    }
+    const write = canonicalArtifactWriteRecordSchema.parse({
+        schema_version: 1,
+        artifact_id: request.artifact_id,
+        project_id: request.project_id,
+        tenant_id: request.tenant_id,
+        revision: currentRevision + 1,
+        previous_revision: currentRevision,
+        lease_id: request.lease_id,
+        fencing_token: request.fencing_token,
+        idempotency_key: request.idempotency_key,
+        request_fingerprint: requestFingerprint,
+        committed_at: now,
+    });
+    state.canonical_revisions[request.artifact_id] = write.revision;
+    state.canonical_writes.push(write);
+    appendAuditEvent(state, buildCanonicalWriteAudit(request, now, 'canonical_write_committed', 'accepted'));
+    return canonicalArtifactWriteResponseSchema.parse({
+        schema_version: 1,
+        status: 'committed',
+        write,
+    });
+}
+export function createNoncanonicalDraft(state, input, options = {}) {
+    const createdAt = options.now ?? new Date().toISOString();
+    const draft = noncanonicalDraftSchema.parse({
+        schema_version: 1,
+        draft_id: `draft_${input.artifact_type}_${hashStableJson({ input, createdAt }).slice(0, 16)}`,
+        artifact_type: input.artifact_type,
+        project_id: input.project_id,
+        tenant_id: input.tenant_id,
+        title_canonical: input.title_canonical,
+        created_by: input.created_by,
+        created_at: createdAt,
+    });
+    state.drafts.push(draft);
+    return draft;
+}
+export function convertDraftToCanonicalArtifact(state, input, options = {}) {
+    const draft = state.drafts.find((candidate) => candidate.draft_id === input.draft_id);
+    if (!draft) {
+        throw new Error(`Draft ${input.draft_id} was not found.`);
+    }
+    if (draft.converted_artifact_id) {
+        return draftConversionResponseSchema.parse({
+            schema_version: 1,
+            status: 'replayed',
+            draft,
+            reservation: input.reservation,
+        });
+    }
+    if (draft.artifact_type !== input.reservation.artifact_type ||
+        draft.project_id !== input.reservation.project_id ||
+        draft.tenant_id !== input.reservation.tenant_id) {
+        throw new Error('Draft conversion rejected: reservation does not match draft artifact type, project, or tenant.');
+    }
+    draft.converted_artifact_id = input.reservation.artifact_id;
+    draft.converted_at = options.now ?? new Date().toISOString();
+    appendAuditEvent(state, {
+        event_type: 'reservation_replayed',
+        project_id: draft.project_id,
+        tenant_id: draft.tenant_id,
+        artifact_type: draft.artifact_type,
+        actor: input.converted_by,
+        idempotency_key: input.reservation.idempotency_key,
+        occurred_at: draft.converted_at,
+        result: 'accepted',
+    });
+    return draftConversionResponseSchema.parse({
+        schema_version: 1,
+        status: 'converted',
+        draft,
+        reservation: input.reservation,
+    });
+}
+export function buildReserveRequestFingerprint(request) {
+    return hashStableJson({
+        schema_version: request.schema_version,
+        project_id: request.project_id,
+        tenant_id: request.tenant_id ?? null,
+        artifact_type: request.artifact_type,
+        title_canonical: request.title_canonical ?? null,
+        origin_ref: request.origin_ref ?? null,
+        requested_by: request.requested_by,
+        client_request_id: request.client_request_id ?? null,
+    });
+}
+export function buildArtifactAllocatorLeaseIdempotencyKey(input) {
+    return `lease_${hashStableJson({
+        project_id: input.project_id,
+        tenant_id: input.tenant_id ?? null,
+        artifact_type: input.artifact_type,
+        holder: input.holder,
+        ttl_ms: input.ttl_ms,
+    })}`;
+}
+export function buildLeaseRequestFingerprint(request) {
+    return hashStableJson({
+        schema_version: request.schema_version,
+        project_id: request.project_id,
+        tenant_id: request.tenant_id ?? null,
+        artifact_type: request.artifact_type,
+        holder: request.holder,
+        ttl_ms: request.ttl_ms,
+    });
+}
+export function buildCanonicalWriteRequestFingerprint(request) {
+    return hashStableJson({
+        schema_version: request.schema_version,
+        artifact_id: request.artifact_id,
+        project_id: request.project_id,
+        tenant_id: request.tenant_id ?? null,
+        actor: request.actor,
+        lease_id: request.lease_id,
+        fencing_token: request.fencing_token,
+        expected_revision: request.expected_revision,
+    });
+}
+function buildCanonicalWriteAudit(request, occurredAt, eventType, result) {
+    return {
+        event_type: eventType,
+        project_id: request.project_id,
+        tenant_id: request.tenant_id,
+        artifact_type: artifactIdAllocatorTypeSchema.parse(request.artifact_id.split('-')[0]),
+        actor: request.actor,
+        idempotency_key: request.idempotency_key,
+        lease_id: request.lease_id,
+        fencing_token: request.fencing_token,
+        occurred_at: occurredAt,
+        result,
+    };
+}
+function appendAuditEvent(state, input) {
+    state.audit_log.push(artifactAllocatorAuditEventSchema.parse({
+        schema_version: 1,
+        event_id: `audit_${hashStableJson({ input, index: state.audit_log.length }).slice(0, 24)}`,
+        ...input,
+    }));
+}
+function hashStableJson(value) {
+    return createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableStringify(entry)).join(',')}]`;
+    }
+    if (value && typeof value === 'object') {
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entryValue]) => `${JSON.stringify(key)}:${stableStringify(entryValue)}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+//# sourceMappingURL=artifact-id-allocator.js.map

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

@@ -1,9 +1,33 @@
-import { type BacklogItem, type DiscoveryRecord, type FrontendGapRecord, type TechDebtRecord } from './types.js';
+import { type BacklogItem, type DiscoveryRecord, type FrontendGapRecord, type RepoMapRecord, type ServiceRecord, type TechDebtRecord } from './types.js';
 import { type SddStateSnapshot } from './state.js';
 export interface SddCheckOptions {
     render?: boolean;
     strict?: boolean;
 }
+export interface FrontendGapHealthSummary {
+    total: number;
+    open: number;
+    planned: number;
+    in_progress: number;
+    resolved: number;
+    superseded: number;
+    unresolved: number;
+}
+export type SharedLockDomainSeverity = 'active' | 'mixed' | 'historical';
+export interface SharedLockDomainHealth {
+    lock: string;
+    severity: SharedLockDomainSeverity;
+    owners: string[];
+    active_owners: string[];
+    historical_owners: string[];
+}
+export interface LockDomainHealthSummary {
+    shared_total: number;
+    active_conflicts: number;
+    mixed_history: number;
+    historical: number;
+    shared: SharedLockDomainHealth[];
+}
 export interface SddCheckReport {
     valid: boolean;
     errors: string[];
@@ -13,8 +37,11 @@ export interface SddCheckReport {
         backlog: number;
         techDebt: number;
         finalizeQueue: number;
+        finalizeQueuePending: number;
+        finalizeQueueDone: number;
         frontendEnabled: boolean;
         frontendGaps: number;
+        frontendGapsSummary?: FrontendGapHealthSummary;
         frontendRoutes: number;
         progress_global: {
             done: number;
@@ -30,6 +57,7 @@ export interface SddCheckReport {
         ready_for_parallel: number;
         blocked: number;
         lock_conflicts: number;
+        lock_domain_health?: LockDomainHealthSummary;
         documentation_sync: boolean;
         core_views_stale: boolean;
         missing_architecture_fields: string[];
@@ -47,10 +75,33 @@ export interface SddCheckReport {
         };
     };
 }
+export interface ServiceCatalogMaturityRow {
+    id: string;
+    level: number;
+    unmet: string[];
+}
+export interface ServiceCatalogMaturityAudit {
+    serviceCount: number;
+    byLevel: Record<number, number>;
+    below5: ServiceCatalogMaturityRow[];
+}
 export declare function checkUniqueIds<T extends {
     id: string;
 }>(items: T[], scope: string, errors: string[]): void;
 export declare function hasForbiddenTitleToken(title: string): string | null;
+export declare function summarizeFrontendGapHealth(gaps: FrontendGapRecord[]): FrontendGapHealthSummary;
+export declare function summarizeLockDomainHealth(items: BacklogItem[]): LockDomainHealthSummary;
+export declare function hasRepoMapReference(repoPath: string, repoMapPaths: string[]): boolean;
+export declare function hasIntegrationContract(contractRef: string, knownContracts: Set<string>): boolean;
+export declare function auditServiceCatalogMaturity(services: ServiceRecord[], backlogItems: BacklogItem[], repoMapItems: RepoMapRecord[], integrationContracts: string[]): ServiceCatalogMaturityAudit;
+export declare function validateAdrConsistency(adrsDir: string, backlogItems: BacklogItem[], errors: string[], warnings: string[], isStrict: boolean): Promise<void>;
+export declare function validateInsightMinimums(insightTitle: string, insightBody: string, errors: string[]): void;
+export declare function validateEpicMinimums(epicBody: string, epicTitle: string, errors: string[]): void;
+export declare function validateTransitionLogConsistency(transitionLogEvents: Array<{
+    entity_id: string;
+    to?: string;
+    action?: string;
+}>, backlogItems: BacklogItem[], errors: string[], warnings: string[], isStrict: boolean): void;
 export declare function validateDiscoveryRecords(records: DiscoveryRecord[], errors: string[]): void;
 export declare function validateBacklog(items: BacklogItem[], errors: string[], warnings: string[]): void;
 export declare function validateReferentialIntegrity(snapshot: SddStateSnapshot, errors: string[], warnings: string[], isStrict: boolean): void;