@devtrack-solution/codesdd 1.2.3 → 1.2.4

package/dist/core/sdd/check.js

@@ -4,13 +4,14 @@ import path from 'node:path';
 import { parse as parseYaml } from 'yaml';
 import { CLI_NAME } from '../branding.js';
 import { ID_PATTERNS, } from './types.js';
-import { loadProjectSddConfig, loadStateSnapshot, resolveSddPaths, } from './state.js';
+import { buildDefaultSkillRoutingState, loadProjectSddConfig, loadStateSnapshot, resolveSddPaths, } from './state.js';
 import { DEFAULT_CURATED_SKILL_CATALOG } from './default-skills.js';
 import { renderViews } from './views.js';
 import { syncSddGuideDocs, validateSddGuideDocs } from './docs-sync.js';
 import { evaluateWorkspaceTraceability } from './domain/traceability.js';
 import { detectArchiveArchivedLifecycleCollisions } from './domain/post-active-validation.js';
 import { parseWorkspaceYamlDocument, workspaceTasksSchema, } from './workspace-schemas.js';
+import { scanArchiveQualityCoherence } from './services/archive-quality-coherence.service.js';
 export function checkUniqueIds(items, scope, errors) {
     const seen = new Set();
     for (const item of items) {
@@ -21,6 +22,7 @@ export function checkUniqueIds(items, scope, errors) {
     }
 }
 const FORBIDDEN_TITLE_PATTERNS = ['debate:', 'insight:', '(preencher', '(placeholder'];
+const CLOSED_BACKLOG_STATUSES = new Set(['DONE', 'ARCHIVED']);
 export function hasForbiddenTitleToken(title) {
     const lowered = title.toLowerCase();
     for (const token of FORBIDDEN_TITLE_PATTERNS) {
@@ -29,6 +31,258 @@ export function hasForbiddenTitleToken(title) {
     }
     return null;
 }
+export function summarizeFrontendGapHealth(gaps) {
+    let open = 0;
+    let planned = 0;
+    let inProgress = 0;
+    let resolved = 0;
+    let superseded = 0;
+    for (const gap of gaps) {
+        if (gap.status === 'OPEN')
+            open++;
+        if (gap.status === 'PLANNED')
+            planned++;
+        if (gap.status === 'IN_PROGRESS')
+            inProgress++;
+        if (gap.status === 'DONE')
+            resolved++;
+        if (gap.status === 'SUPERSEDED')
+            superseded++;
+    }
+    return {
+        total: gaps.length,
+        open,
+        planned,
+        in_progress: inProgress,
+        resolved,
+        superseded,
+        unresolved: gaps.length - resolved - superseded,
+    };
+}
+export function summarizeLockDomainHealth(items) {
+    const lockOwners = new Map();
+    for (const item of items) {
+        for (const lock of item.lock_domains) {
+            const owners = lockOwners.get(lock) || [];
+            owners.push(item);
+            lockOwners.set(lock, owners);
+        }
+    }
+    const shared = [];
+    for (const [lock, owners] of lockOwners.entries()) {
+        if (owners.length <= 1)
+            continue;
+        const activeOwners = owners.filter((owner) => !CLOSED_BACKLOG_STATUSES.has(owner.status));
+        const historicalOwners = owners.filter((owner) => CLOSED_BACKLOG_STATUSES.has(owner.status));
+        const severity = activeOwners.length > 1 ? 'active' : activeOwners.length === 1 ? 'mixed' : 'historical';
+        shared.push({
+            lock,
+            severity,
+            owners: owners.map((owner) => owner.id),
+            active_owners: activeOwners.map((owner) => owner.id),
+            historical_owners: historicalOwners.map((owner) => owner.id),
+        });
+    }
+    shared.sort((left, right) => left.lock.localeCompare(right.lock));
+    return {
+        shared_total: shared.length,
+        active_conflicts: shared.filter((item) => item.severity === 'active').length,
+        mixed_history: shared.filter((item) => item.severity === 'mixed').length,
+        historical: shared.filter((item) => item.severity === 'historical').length,
+        shared,
+    };
+}
+function normalizeCatalogPath(input) {
+    return input.trim().replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '');
+}
+export function hasRepoMapReference(repoPath, repoMapPaths) {
+    const normalizedRepoPath = normalizeCatalogPath(repoPath);
+    if (!normalizedRepoPath)
+        return false;
+    return repoMapPaths.some((repoMapPath) => {
+        const normalizedRepoMapPath = normalizeCatalogPath(repoMapPath);
+        if (!normalizedRepoMapPath)
+            return false;
+        return (normalizedRepoMapPath === normalizedRepoPath ||
+            normalizedRepoMapPath.startsWith(`${normalizedRepoPath}/`) ||
+            normalizedRepoPath.startsWith(`${normalizedRepoMapPath}/`));
+    });
+}
+export function hasIntegrationContract(contractRef, knownContracts) {
+    const normalizedContractRef = contractRef.trim();
+    if (!normalizedContractRef)
+        return false;
+    if (knownContracts.has(normalizedContractRef))
+        return true;
+    for (const knownContract of knownContracts) {
+        if (knownContract.startsWith(`${normalizedContractRef}::`)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function auditServiceCatalogMaturity(services, backlogItems, repoMapItems, integrationContracts) {
+    const backlogIds = new Set(backlogItems.map((item) => item.id));
+    const repoMapPaths = repoMapItems.map((item) => item.path);
+    const contracts = new Set(integrationContracts.map((item) => item.trim()).filter(Boolean));
+    const byLevel = { 1: 0, 2: 0, 3: 0, 4: 0, 5: 0 };
+    const below5 = [];
+    for (const service of services) {
+        const unmet = [];
+        const hasIdentity = Boolean(service.id.trim()) && Boolean(service.name.trim()) && Boolean((service.responsibility || '').trim());
+        if (!hasIdentity)
+            unmet.push('identity');
+        const hasOwners = service.owner_refs.length > 0 && service.owner_refs.every((ownerRef) => backlogIds.has(ownerRef));
+        if (!hasOwners)
+            unmet.push('owner_refs');
+        const hasRepoPaths = service.repo_paths.length > 0 && service.repo_paths.every((repoPath) => hasRepoMapReference(repoPath, repoMapPaths));
+        if (!hasRepoPaths)
+            unmet.push('repo_paths');
+        const hasContracts = service.contracts.length > 0 &&
+            service.contracts.every((contractRef) => hasIntegrationContract(contractRef, contracts));
+        if (!hasContracts)
+            unmet.push('contracts');
+        const hasExternalDependencies = Array.isArray(service.external_dependencies);
+        if (!hasExternalDependencies)
+            unmet.push('external_dependencies');
+        const level = !hasIdentity ? 1 : !hasOwners ? 2 : !hasRepoPaths ? 3 : !hasContracts || !hasExternalDependencies ? 4 : 5;
+        byLevel[level] += 1;
+        if (level < 5) {
+            below5.push({
+                id: service.id,
+                level,
+                unmet,
+            });
+        }
+    }
+    return {
+        serviceCount: services.length,
+        byLevel,
+        below5,
+    };
+}
+export async function validateAdrConsistency(adrsDir, backlogItems, errors, warnings, isStrict) {
+    const backlogStatus = new Map();
+    for (const item of backlogItems) {
+        backlogStatus.set(item.id, item.status);
+    }
+    let filenames;
+    try {
+        filenames = await fs.readdir(adrsDir);
+    }
+    catch {
+        return;
+    }
+    const adrs = filenames.filter((f) => f.startsWith('ADR-') && f.endsWith('.md'));
+    for (const filename of adrs) {
+        let content;
+        try {
+            content = await fs.readFile(path.join(adrsDir, filename), 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        const frontmatterMatch = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
+        if (!frontmatterMatch)
+            continue;
+        let frontmatter;
+        try {
+            frontmatter = parseYaml(frontmatterMatch[1]) ?? {};
+        }
+        catch {
+            continue;
+        }
+        const adrStatus = typeof frontmatter.status === 'string' ? frontmatter.status : '';
+        const featureId = typeof frontmatter.feature_id === 'string' ? frontmatter.feature_id : '';
+        const adrId = typeof frontmatter.id === 'string' ? frontmatter.id : filename;
+        if (!featureId || !adrStatus)
+            continue;
+        const featureStatus = backlogStatus.get(featureId);
+        if (!featureStatus)
+            continue;
+        const featureDone = featureStatus === 'DONE' || featureStatus === 'ARCHIVED';
+        const adrUnresolved = adrStatus === 'IN_PROGRESS' || adrStatus === 'DRAFT';
+        if (featureDone && adrUnresolved) {
+            const message = `ADR consistency gate failed: ${adrId} status is ${adrStatus} but feature ${featureId} is ${featureStatus} in backlog`;
+            if (isStrict) {
+                errors.push(message);
+            }
+            else {
+                warnings.push(message);
+            }
+        }
+    }
+}
+export function validateInsightMinimums(insightTitle, insightBody, errors) {
+    if ((insightTitle || '').trim().length < 50) {
+        errors.push(`INSIGHT quality gate: title must be >=50 characters (current: ${(insightTitle || '').trim().length}). Expand the title to describe the problem and expected impact.`);
+    }
+    const bodyLower = (insightBody || '').toLowerCase();
+    const missingKeywords = [];
+    if (!/\bproblem|\bproblema|\bissue\b/.test(bodyLower))
+        missingKeywords.push('problem description');
+    if (!/\bscope|\bescopo|\bboundary\b/.test(bodyLower))
+        missingKeywords.push('scope definition');
+    if (!/\bimpact|\bimpacto|\boutcome\b/.test(bodyLower))
+        missingKeywords.push('expected impact');
+    if (missingKeywords.length > 0) {
+        errors.push(`INSIGHT quality gate: body must describe problem, scope, and impact. Missing: ${missingKeywords.join(', ')}.`);
+    }
+}
+export function validateEpicMinimums(epicBody, epicTitle, errors) {
+    const bodyClean = (epicBody || '').replace(/^---[\s\S]*?---\r?\n?/, '').trim();
+    if (bodyClean.length < 500) {
+        errors.push(`EPIC quality gate: expanded plan must be >=500 characters (current: ${bodyClean.length}). Add feature breakdown, dependency map, risk matrix, and DoD.`);
+    }
+    const featMatches = bodyClean.match(/FEAT-\d{4}/g) || [];
+    const uniqueFeats = new Set(featMatches).size;
+    if (uniqueFeats < 3) {
+        errors.push(`EPIC quality gate: must reference >=3 estimated features (current: ${uniqueFeats}). Expand the breakdown plan with concrete feature estimates.`);
+    }
+    const hasDependencyMap = /\bupstream\b|\bdownstream\b|\bdependencies\b|\bdependency map\b/i.test(bodyClean);
+    if (!hasDependencyMap) {
+        errors.push(`EPIC quality gate: must include a dependency map with upstream and downstream references.`);
+    }
+}
+export function validateTransitionLogConsistency(transitionLogEvents, backlogItems, errors, warnings, isStrict) {
+    if (transitionLogEvents.length === 0)
+        return;
+    const oldestEventTs = Math.min(...transitionLogEvents.map((e) => e.timestamp ? Date.parse(String(e.timestamp)) : Infinity));
+    const backlogStatus = new Map(backlogItems.map((item) => [item.id, item.status]));
+    const finalizeEvents = new Set();
+    for (const event of transitionLogEvents) {
+        const action = event.action || event.to || '';
+        if (action === 'finalized' || action === 'archived' || action === 'DONE' || action === 'ARCHIVED') {
+            finalizeEvents.add(event.entity_id);
+        }
+    }
+    for (const item of backlogItems) {
+        const isDone = item.status === 'DONE' || item.status === 'ARCHIVED';
+        if (!isDone)
+            continue;
+        if (finalizeEvents.has(item.id))
+            continue;
+        const itemDoneAt = item.done_at || item.archived_at || '';
+        if (itemDoneAt && oldestEventTs !== Infinity && Date.parse(itemDoneAt) < oldestEventTs) {
+            continue;
+        }
+        const message = `Transition-log consistency: ${item.id} is ${item.status} in backlog but has no finalized event in transition-log`;
+        warnings.push(message);
+    }
+    for (const eventId of finalizeEvents) {
+        const status = backlogStatus.get(eventId);
+        if (!status) {
+            warnings.push(`Transition-log consistency: transition-log has finalized event for ${eventId} but no matching backlog item`);
+        }
+        else if (status !== 'DONE' && status !== 'ARCHIVED') {
+            const message = `Transition-log consistency: ${eventId} has finalized event in transition-log but backlog status is ${status}`;
+            if (isStrict)
+                errors.push(message);
+            else
+                warnings.push(message);
+        }
+    }
+}
 export function validateDiscoveryRecords(records, errors) {
     for (const record of records) {
         if (record.type === 'INS' && !ID_PATTERNS.insight.test(record.id)) {
@@ -53,7 +307,6 @@ export function validateDiscoveryRecords(records, errors) {
 }
 export function validateBacklog(items, errors, warnings) {
     const ids = new Set(items.map((item) => item.id));
-    const lockOwners = new Map();
     for (const item of items) {
         const forbidden = hasForbiddenTitleToken(item.title);
         if (forbidden) {
@@ -67,15 +320,10 @@ export function validateBacklog(items, errors, warnings) {
                 warnings.push(`Item de backlog ${item.id} bloqueado por referencia inexistente: ${dep}`);
             }
         }
-        for (const lock of item.lock_domains) {
-            const owners = lockOwners.get(lock) || [];
-            owners.push(item.id);
-            lockOwners.set(lock, owners);
-        }
     }
-    for (const [lock, owners] of lockOwners.entries()) {
-        if (owners.length > 1) {
-            warnings.push(`Lock domain "${lock}" compartilhado por: ${owners.join(', ')}`);
+    for (const sharedLock of summarizeLockDomainHealth(items).shared) {
+        if (sharedLock.severity === 'active') {
+            warnings.push(`Lock domain "${sharedLock.lock}" compartilhado por FEATs ativas: ${sharedLock.active_owners.join(', ')}`);
         }
     }
 }
@@ -122,6 +370,13 @@ export function validateReferentialIntegrity(snapshot, errors, warnings, isStric
             }
         }
     }
+    if (snapshot.finalizeQueue?.history) {
+        for (const fq of snapshot.finalizeQueue.history) {
+            if (!backlogIds.has(fq.feature_id)) {
+                record(`Finalize history has entry for feature_id="${fq.feature_id}" blocked by an unknown feature.`);
+            }
+        }
+    }
     if (snapshot.unblockEvents?.events) {
         for (const ev of snapshot.unblockEvents.events) {
             if (!backlogIds.has(ev.feature_id)) {
@@ -172,6 +427,26 @@ export function validateSkillOperationalIntegrity(snapshot, errors) {
             }
         }
     }
+    const currentRoutes = new Map((snapshot.skillRouting?.routes || []).map((route) => [route.domain, route]));
+    for (const defaultRoute of buildDefaultSkillRoutingState().routes) {
+        const currentRoute = currentRoutes.get(defaultRoute.domain);
+        if (!currentRoute) {
+            errors.push(`Default skill route "${defaultRoute.domain}" is missing from skill-routing.yaml`);
+            continue;
+        }
+        const currentSkills = currentRoute.skills || [];
+        const currentBundles = currentRoute.bundles || [];
+        for (const skillId of defaultRoute.skills) {
+            if (!currentSkills.includes(skillId)) {
+                errors.push(`Default skill route "${defaultRoute.domain}" is missing skill "${skillId}"`);
+            }
+        }
+        for (const bundleId of defaultRoute.bundles) {
+            if (!currentBundles.includes(bundleId)) {
+                errors.push(`Default skill route "${defaultRoute.domain}" is missing bundle "${bundleId}"`);
+            }
+        }
+    }
 }
 export function computeGraphSummary(items) {
     const byId = new Map(items.map((item) => [item.id, item]));
@@ -541,6 +816,8 @@ export class SddCheckCommand {
                     backlog: 0,
                     techDebt: 0,
                     finalizeQueue: 0,
+                    finalizeQueuePending: 0,
+                    finalizeQueueDone: 0,
                     frontendEnabled: false,
                     frontendGaps: 0,
                     frontendRoutes: 0,
@@ -618,6 +895,8 @@ export class SddCheckCommand {
                     backlog: 0,
                     techDebt: 0,
                     finalizeQueue: 0,
+                    finalizeQueuePending: 0,
+                    finalizeQueueDone: 0,
                     frontendEnabled: config.frontend.enabled,
                     frontendGaps: 0,
                     frontendRoutes: 0,
@@ -658,6 +937,8 @@ export class SddCheckCommand {
                     backlog: 0,
                     techDebt: 0,
                     finalizeQueue: 0,
+                    finalizeQueuePending: 0,
+                    finalizeQueueDone: 0,
                     frontendEnabled: config.frontend.enabled,
                     frontendGaps: 0,
                     frontendRoutes: 0,
@@ -706,6 +987,15 @@ export class SddCheckCommand {
         validatePrivacySourceRegistry(snapshot, warnings);
         await validatePrivacyWorkspaceChecklist(paths.activeDir, snapshot.backlog.items, warnings);
         await validateTraceabilityWorkspaceChecklist(paths.projectRoot, paths.activeDir, snapshot.backlog.items, warnings);
+        await validateAdrConsistency(path.join(paths.coreDir, 'adrs'), snapshot.backlog.items, errors, warnings, isStrict);
+        validateTransitionLogConsistency(snapshot.transitionLog?.events || [], snapshot.backlog.items, errors, warnings, isStrict);
+        const archiveQualityCoherence = await scanArchiveQualityCoherence(paths.archivedDir);
+        for (const issue of archiveQualityCoherence.issues) {
+            errors.push(issue.message);
+        }
+        if (archiveQualityCoherence.grandfathered > 0) {
+            warnings.push(`Archive quality coherence grandfathered ${archiveQualityCoherence.grandfathered} archived FEAT workspaces (<= FEAT-0451).`);
+        }
         const featuresMissingFrontendDeclaration = config.frontend.enabled
             ? snapshot.backlog.items
                 .filter((item) => item.status !== 'ARCHIVED' && item.status !== 'DONE')
@@ -747,6 +1037,22 @@ export class SddCheckCommand {
         if (snapshot.repoMap.items.length === 0) {
             missingArchitectureFields.push('repo-map.items vazio');
         }
+        const serviceCatalogMaturityAudit = auditServiceCatalogMaturity(snapshot.serviceCatalog.services, snapshot.backlog.items, snapshot.repoMap.items, snapshot.integrationContracts.contracts);
+        if (serviceCatalogMaturityAudit.below5.length > 0) {
+            const sample = serviceCatalogMaturityAudit.below5
+                .slice(0, 10)
+                .map((entry) => `${entry.id}(L${entry.level}: ${entry.unmet.join(', ')})`)
+                .join('; ');
+            const remainder = serviceCatalogMaturityAudit.below5.length - Math.min(10, serviceCatalogMaturityAudit.below5.length);
+            const suffix = remainder > 0 ? `; +${remainder} service(s)` : '';
+            const message = `Service catalog maturity gate failed: ${serviceCatalogMaturityAudit.below5.length}/${serviceCatalogMaturityAudit.serviceCount} services are below level 5. ${sample}${suffix}`;
+            if (isStrict) {
+                errors.push(message);
+            }
+            else {
+                warnings.push(message);
+            }
+        }
         const hasFrontendDecisionDemand = config.frontend.enabled &&
             ((snapshot.frontendGaps?.items.length ?? 0) > 0 ||
                 snapshot.backlog.items.some((item) => featureHasMetadataFrontendEvidence(item)));
@@ -796,6 +1102,11 @@ export class SddCheckCommand {
             featuresMissingFgapLink.length === 0;
         const qualityContractSync = featuresMissingQualityContract.length === 0 &&
             featuresMissingQualityArtifact.length === 0;
+        const finalizeQueuePending = snapshot.finalizeQueue.items.filter((item) => item.status === 'PENDING').length;
+        const finalizeQueueDone = snapshot.finalizeQueue.history.length +
+            snapshot.finalizeQueue.items.filter((item) => item.status === 'DONE').length;
+        const frontendGapsSummary = summarizeFrontendGapHealth(snapshot.frontendGaps?.items ?? []);
+        const lockDomainHealth = summarizeLockDomainHealth(snapshot.backlog.items);
         return {
             valid: errors.length === 0,
             errors,
@@ -804,15 +1115,19 @@ export class SddCheckCommand {
                 discovery: snapshot.discoveryIndex.records.length,
                 backlog: snapshot.backlog.items.length,
                 techDebt: snapshot.techDebt.items.length,
-                finalizeQueue: snapshot.finalizeQueue.items.length,
+                finalizeQueue: finalizeQueuePending,
+                finalizeQueuePending,
+                finalizeQueueDone,
                 frontendEnabled: config.frontend.enabled,
                 frontendGaps: snapshot.frontendGaps?.items.length ?? 0,
+                frontendGapsSummary,
                 frontendRoutes: snapshot.frontendMap?.routes.length ?? 0,
                 progress_global: progress.progressGlobal,
                 progress_by_radar: progress.progressByRadar,
                 ready_for_parallel: graph.readyForParallel,
                 blocked: graph.blocked,
                 lock_conflicts: graph.lockConflicts,
+                lock_domain_health: lockDomainHealth,
                 documentation_sync: docsValidation.documentationSync,
                 core_views_stale: coreViewsStale,
                 missing_architecture_fields: missingArchitectureFields,

package/dist/core/sdd/coordination/coordination-adapters.d.ts

@@ -1,4 +1,7 @@
 import { type AcquireOptions } from '../state-lock.js';
+import { type GlobalConfig } from '../../global-config.js';
+import { type RedisRuntimeConfig, type RedisRuntimeStatus } from './redis-runtime.js';
+export { resolveRedisBoundaryConfig } from './redis-runtime.js';
 export interface CoordinationLockAdapter {
     withLock<T>(scope: string, fn: () => Promise<T>, options?: AcquireOptions): Promise<T>;
 }
@@ -24,20 +27,16 @@ export interface CoordinationEventBusAdapter {
     publish(event: CoordinationEvent): Promise<void>;
     drain(): Promise<CoordinationEvent[]>;
 }
-export interface RedisBoundaryConfig {
-    requested: boolean;
-    namespace: string;
-    url?: string;
-}
+export type RedisBoundaryConfig = RedisRuntimeConfig;
 export interface SddCoordinationAdapters {
-    mode: 'filesystem';
+    mode: 'filesystem' | 'redis' | 'hybrid';
     cacheTier: {
         root: string;
         projectFingerprint: string;
         namespace: string;
     };
     redis: RedisBoundaryConfig & {
-        status: 'disabled' | 'requested-unavailable';
+        status: RedisRuntimeStatus;
         reason: string;
     };
     locks: CoordinationLockAdapter;
@@ -100,12 +99,20 @@ export declare class InMemoryCoordinationEventBus implements CoordinationEventBu
     publish(event: CoordinationEvent): Promise<void>;
     drain(): Promise<CoordinationEvent[]>;
 }
-export declare function resolveRedisBoundaryConfig(env?: NodeJS.ProcessEnv): RedisBoundaryConfig;
 export declare function createFilesystemFirstCoordinationAdapters(options: {
     stateDir: string;
     projectRoot?: string;
     configFingerprint?: string;
     cacheRootDir?: string;
     env?: NodeJS.ProcessEnv;
+    globalConfig?: Partial<GlobalConfig>;
 }): SddCoordinationAdapters;
+export declare function createSddCoordinationAdapters(options: {
+    stateDir: string;
+    projectRoot?: string;
+    configFingerprint?: string;
+    cacheRootDir?: string;
+    env?: NodeJS.ProcessEnv;
+    globalConfig?: Partial<GlobalConfig>;
+}): Promise<SddCoordinationAdapters>;
 //# sourceMappingURL=coordination-adapters.d.ts.map

package/dist/core/sdd/coordination/coordination-adapters.js

@@ -3,6 +3,8 @@ import { createHash } from 'node:crypto';
 import path from 'node:path';
 import { promises as fs } from 'node:fs';
 import { createProjectFingerprint, ensureGlobalCacheLayout, getGlobalCacheDir } from '../../global-config.js';
+import { buildRedisOperationalReport, RedisClientFactory, RedisCoordinationCache, RedisEventBusAdapter, RedisLockAdapter, RedisQueueAdapter, resolveRedisBoundaryConfig, } from './redis-runtime.js';
+export { resolveRedisBoundaryConfig } from './redis-runtime.js';
 export class FileSystemLockAdapter {
     stateDir;
     constructor(stateDir) {
@@ -186,21 +188,11 @@ export class InMemoryCoordinationEventBus {
         return this.events.splice(0, this.events.length);
     }
 }
-export function resolveRedisBoundaryConfig(env = process.env) {
-    const url = env.CODESDD_REDIS_URL?.trim() || env.REDIS_URL?.trim() || undefined;
-    const requestedByFlag = env.CODESDD_REDIS_ENABLED === 'true';
-    const namespace = env.CODESDD_REDIS_NAMESPACE?.trim() || 'codesdd';
-    return {
-        requested: Boolean(url || requestedByFlag),
-        namespace,
-        url,
-    };
-}
 export function createFilesystemFirstCoordinationAdapters(options) {
     if (!options.cacheRootDir) {
         ensureGlobalCacheLayout();
     }
-    const redis = resolveRedisBoundaryConfig(options.env);
+    const redis = resolveRedisBoundaryConfig(options.env, options.globalConfig);
     const cache = new MultiTierCoordinationCache({
         projectRoot: options.projectRoot ?? process.cwd(),
         configFingerprint: options.configFingerprint,
@@ -211,10 +203,12 @@ export function createFilesystemFirstCoordinationAdapters(options) {
         cacheTier: cache.describeTierState(),
         redis: {
             ...redis,
-            status: redis.requested ? 'requested-unavailable' : 'disabled',
-            reason: redis.requested
-                ? 'Redis adapter boundary is configured but no Redis client adapter is installed; filesystem-first defaults remain authoritative.'
-                : 'Redis is optional and disabled; filesystem-first defaults are authoritative.',
+            status: redis.validationErrors.length > 0 ? 'blocked' : redis.requested ? 'requested-unavailable' : 'disabled',
+            reason: redis.validationErrors.length > 0
+                ? 'Redis configuration is invalid and was blocked fail-closed.'
+                : redis.requested
+                    ? 'Redis is requested but unavailable; filesystem-first defaults remain authoritative.'
+                    : 'Redis is optional and disabled; filesystem-first defaults are authoritative.',
         },
         locks: new FileSystemLockAdapter(options.stateDir),
         cache,
@@ -222,4 +216,38 @@ export function createFilesystemFirstCoordinationAdapters(options) {
         events: new InMemoryCoordinationEventBus(),
     };
 }
+export async function createSddCoordinationAdapters(options) {
+    const filesystem = createFilesystemFirstCoordinationAdapters(options);
+    const projectRoot = options.projectRoot ?? process.cwd();
+    const redis = resolveRedisBoundaryConfig(options.env, options.globalConfig);
+    const report = await buildRedisOperationalReport({
+        env: options.env,
+        globalConfig: options.globalConfig,
+    });
+    if (report.status !== 'ready' || !redis.url) {
+        return {
+            ...filesystem,
+            redis: {
+                ...redis,
+                status: report.status,
+                reason: report.reason,
+            },
+        };
+    }
+    const projectFingerprint = createProjectFingerprint(projectRoot);
+    const factory = new RedisClientFactory(redis);
+    return {
+        ...filesystem,
+        mode: redis.fallback === 'filesystem' ? 'hybrid' : 'redis',
+        redis: {
+            ...redis,
+            status: 'ready',
+            reason: report.reason,
+        },
+        cache: new RedisCoordinationCache(factory, filesystem.cache, projectFingerprint),
+        locks: new RedisLockAdapter(factory, filesystem.locks, projectFingerprint),
+        queues: new RedisQueueAdapter(factory, filesystem.queues, projectFingerprint),
+        events: new RedisEventBusAdapter(factory, filesystem.events, projectFingerprint),
+    };
+}
 //# sourceMappingURL=coordination-adapters.js.map

package/dist/core/sdd/coordination/index.d.ts

@@ -1,2 +1,3 @@
 export * from './coordination-adapters.js';
+export * from './redis-runtime.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/sdd/coordination/index.js

@@ -1,2 +1,3 @@
 export * from './coordination-adapters.js';
+export * from './redis-runtime.js';
 //# sourceMappingURL=index.js.map