@devtrack-solution/codesdd 1.2.2 → 1.2.4-rc3

package/dist/core/sdd/check.js

@@ -4,14 +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';
-function checkUniqueIds(items, scope, errors) {
+export function checkUniqueIds(items, scope, errors) {
     const seen = new Set();
     for (const item of items) {
         if (seen.has(item.id)) {
@@ -21,7 +21,7 @@ function checkUniqueIds(items, scope, errors) {
     }
 }
 const FORBIDDEN_TITLE_PATTERNS = ['debate:', 'insight:', '(preencher', '(placeholder'];
-function hasForbiddenTitleToken(title) {
+export function hasForbiddenTitleToken(title) {
     const lowered = title.toLowerCase();
     for (const token of FORBIDDEN_TITLE_PATTERNS) {
         if (lowered.includes(token))
@@ -29,7 +29,7 @@ function hasForbiddenTitleToken(title) {
     }
     return null;
 }
-function validateDiscoveryRecords(records, errors) {
+export function validateDiscoveryRecords(records, errors) {
     for (const record of records) {
         if (record.type === 'INS' && !ID_PATTERNS.insight.test(record.id)) {
             errors.push(`Discovery record ${record.id} is INS but does not follow INS-####`);
@@ -51,7 +51,7 @@ function validateDiscoveryRecords(records, errors) {
         }
     }
 }
-function validateBacklog(items, errors, warnings) {
+export function validateBacklog(items, errors, warnings) {
     const ids = new Set(items.map((item) => item.id));
     const lockOwners = new Map();
     for (const item of items) {
@@ -79,7 +79,7 @@ function validateBacklog(items, errors, warnings) {
         }
     }
 }
-function validateReferentialIntegrity(snapshot, errors, warnings, isStrict) {
+export function validateReferentialIntegrity(snapshot, errors, warnings, isStrict) {
     const discoveryIds = new Set(snapshot.discoveryIndex.records.map((record) => record.id));
     const backlogIds = new Set(snapshot.backlog.items.map((item) => item.id));
     const frontendGapIds = new Set(snapshot.frontendGaps?.items.map((gap) => gap.id) ?? []);
@@ -122,6 +122,13 @@ function validateReferentialIntegrity(snapshot, errors, warnings, isStrict) {
             }
         }
     }
+    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)) {
@@ -133,7 +140,7 @@ function validateReferentialIntegrity(snapshot, errors, warnings, isStrict) {
         }
     }
 }
-function validateSkillOperationalIntegrity(snapshot, errors) {
+export function validateSkillOperationalIntegrity(snapshot, errors) {
     const knownSkills = new Set((snapshot.skillCatalog?.skills || []).map((skill) => skill.id));
     const currentBundles = new Map((snapshot.skillCatalog?.bundles || []).map((bundle) => [bundle.id, bundle]));
     for (const defaultSkill of DEFAULT_CURATED_SKILL_CATALOG.skills) {
@@ -172,8 +179,28 @@ 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}"`);
+            }
+        }
+    }
 }
-function computeGraphSummary(items) {
+export function computeGraphSummary(items) {
     const byId = new Map(items.map((item) => [item.id, item]));
     const runnable = items.filter((item) => {
         if (item.status === 'DONE' || item.status === 'ARCHIVED')
@@ -226,12 +253,12 @@ function computeGraphSummary(items) {
         lockConflicts: conflictingIds.size,
     };
 }
-function roundPercent(done, total) {
+export function roundPercent(done, total) {
     if (total <= 0)
         return 0;
     return Math.round((done / total) * 100);
 }
-function computeProgress(items) {
+export function computeProgress(items) {
     const activeItems = items.filter((item) => item.status !== 'ARCHIVED');
     const total = activeItems.length;
     const done = activeItems.filter((item) => item.status === 'DONE').length;
@@ -262,14 +289,14 @@ function computeProgress(items) {
         progressByRadar,
     };
 }
-function validateTechDebt(items, errors) {
+export function validateTechDebt(items, errors) {
     for (const item of items) {
         if (!ID_PATTERNS.techDebt.test(item.id)) {
             errors.push(`Technical debt item ${item.id} does not follow TD-###`);
         }
     }
 }
-function validateFrontendReferences(gaps, backlog, errors, warnings) {
+export function validateFrontendReferences(gaps, backlog, errors, warnings) {
     const gapIds = new Set(gaps.map((g) => g.id));
     for (const item of backlog) {
         for (const gapRef of item.frontend_gap_refs) {
@@ -285,7 +312,7 @@ function validateFrontendReferences(gaps, backlog, errors, warnings) {
         }
     }
 }
-async function validateActiveTaskChecklist(activeDir, items, warnings) {
+export async function validateActiveTaskChecklist(activeDir, items, warnings) {
     for (const item of items) {
         if (item.status !== 'IN_PROGRESS')
             continue;
@@ -325,7 +352,7 @@ async function validateActiveTaskChecklist(activeDir, items, warnings) {
         }
     }
 }
-async function validateWorkspaceCoherence(activeDir, archivedDir, items, warnings) {
+export async function validateWorkspaceCoherence(activeDir, archivedDir, items, warnings) {
     for (const item of items) {
         const activePath = path.join(activeDir, item.id);
         const archivedPath = path.join(archivedDir, item.id);
@@ -342,13 +369,13 @@ async function validateWorkspaceCoherence(activeDir, archivedDir, items, warning
         }
     }
 }
-function isPrivacyComplianceBacklogItem(item) {
+export function isPrivacyComplianceBacklogItem(item) {
     if (item.origin_ref === 'EPIC-0020' || item.origin_ref === 'EPIC-0021')
         return true;
     const refs = new Set(item.acceptance_refs || []);
     return refs.has('EPIC-0020') || refs.has('EPIC-0021') || refs.has('DEB-0021') || refs.has('INS-0021');
 }
-function validatePrivacySourceRegistry(snapshot, warnings) {
+export function validatePrivacySourceRegistry(snapshot, warnings) {
     const privacyItems = snapshot.backlog.items.filter((item) => item.status !== 'DONE' && item.status !== 'ARCHIVED' && isPrivacyComplianceBacklogItem(item));
     if (privacyItems.length === 0)
         return;
@@ -385,7 +412,7 @@ function validatePrivacySourceRegistry(snapshot, warnings) {
         warnings.push(`Privacy source registry metadata incomplete for: ${missingMetadata.slice(0, 12).join(', ')}${missingMetadata.length > 12 ? ' ...' : ''}`);
     }
 }
-async function validatePrivacyWorkspaceChecklist(activeDir, items, warnings) {
+export async function validatePrivacyWorkspaceChecklist(activeDir, items, warnings) {
     const privacyItems = items.filter((item) => item.status === 'IN_PROGRESS' && isPrivacyComplianceBacklogItem(item));
     for (const item of privacyItems) {
         const specPath = path.join(activeDir, item.id, '1-spec.yaml');
@@ -433,7 +460,7 @@ async function validatePrivacyWorkspaceChecklist(activeDir, items, warnings) {
         }
     }
 }
-async function validateTraceabilityWorkspaceChecklist(projectRoot, activeDir, items, warnings) {
+export async function validateTraceabilityWorkspaceChecklist(projectRoot, activeDir, items, warnings) {
     const traceabilityItems = items.filter((item) => item.status === 'IN_PROGRESS');
     for (const item of traceabilityItems) {
         const specPath = path.join(activeDir, item.id, '1-spec.yaml');
@@ -458,12 +485,12 @@ async function validateTraceabilityWorkspaceChecklist(projectRoot, activeDir, it
         }
     }
 }
-function featureRequiresQualityContract(item) {
+export function featureRequiresQualityContract(item) {
     if (item.status === 'ARCHIVED' || item.status === 'DONE')
         return false;
     return Boolean(item.quality_contract) || item.status === 'IN_PROGRESS' || item.origin_ref === 'EPIC-0013';
 }
-async function detectMissingQualityArtifacts(activeDir, items) {
+export async function detectMissingQualityArtifacts(activeDir, items) {
     const missing = [];
     for (const item of items) {
         if (item.status !== 'IN_PROGRESS')
@@ -477,7 +504,7 @@ async function detectMissingQualityArtifacts(activeDir, items) {
     }
     return missing;
 }
-function parseRouteToken(value) {
+export function parseRouteToken(value) {
     const token = value.trim();
     if (!token)
         return null;
@@ -494,7 +521,7 @@ function parseRouteToken(value) {
         return inlineRoute[0];
     return null;
 }
-function featureHasMetadataFrontendEvidence(item) {
+export function featureHasMetadataFrontendEvidence(item) {
     const routes = [
         ...item.produces.map(parseRouteToken),
         ...item.consumes.map(parseRouteToken),
@@ -506,7 +533,7 @@ function featureHasMetadataFrontendEvidence(item) {
         item.touches.includes('frontend') ||
         item.execution_kind === 'frontend_coverage');
 }
-async function validateCanonicalSddStructure(memoryRoot, errors) {
+export async function validateCanonicalSddStructure(memoryRoot, errors) {
     const forbiddenTopLevelDirs = ['backlog', 'features', 'finalize', 'queue'];
     for (const dirName of forbiddenTopLevelDirs) {
         const candidate = path.join(memoryRoot, dirName);
@@ -541,6 +568,8 @@ export class SddCheckCommand {
                     backlog: 0,
                     techDebt: 0,
                     finalizeQueue: 0,
+                    finalizeQueuePending: 0,
+                    finalizeQueueDone: 0,
                     frontendEnabled: false,
                     frontendGaps: 0,
                     frontendRoutes: 0,
@@ -618,6 +647,8 @@ export class SddCheckCommand {
                     backlog: 0,
                     techDebt: 0,
                     finalizeQueue: 0,
+                    finalizeQueuePending: 0,
+                    finalizeQueueDone: 0,
                     frontendEnabled: config.frontend.enabled,
                     frontendGaps: 0,
                     frontendRoutes: 0,
@@ -658,6 +689,8 @@ export class SddCheckCommand {
                     backlog: 0,
                     techDebt: 0,
                     finalizeQueue: 0,
+                    finalizeQueuePending: 0,
+                    finalizeQueueDone: 0,
                     frontendEnabled: config.frontend.enabled,
                     frontendGaps: 0,
                     frontendRoutes: 0,
@@ -796,6 +829,9 @@ 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;
         return {
             valid: errors.length === 0,
             errors,
@@ -804,7 +840,9 @@ 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,
                 frontendRoutes: snapshot.frontendMap?.routes.length ?? 0,

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

@@ -0,0 +1,13 @@
+export declare const CURRENT_SDD_STATE_VERSION = 3;
+export declare const CURRENT_SDD_CONTRACT_NAME = "codesdd-sdd";
+export declare const CURRENT_CODESDD_MIN_CLI_VERSION = "1.2.2";
+export declare const CURRENT_SDD_LEGACY_COMPATIBILITY = "migration-only";
+export interface SddContractConfig {
+    name: string;
+    version: number;
+    min_cli_version: string;
+    legacy_compatibility: string;
+}
+export declare function buildSddContractConfig(): SddContractConfig;
+export declare function sddContractMismatchReasons(value: unknown): string[];
+//# sourceMappingURL=contract.d.ts.map

package/dist/core/sdd/contract.js

@@ -0,0 +1,36 @@
+export const CURRENT_SDD_STATE_VERSION = 3;
+export const CURRENT_SDD_CONTRACT_NAME = 'codesdd-sdd';
+export const CURRENT_CODESDD_MIN_CLI_VERSION = '1.2.2';
+export const CURRENT_SDD_LEGACY_COMPATIBILITY = 'migration-only';
+export function buildSddContractConfig() {
+    return {
+        name: CURRENT_SDD_CONTRACT_NAME,
+        version: CURRENT_SDD_STATE_VERSION,
+        min_cli_version: CURRENT_CODESDD_MIN_CLI_VERSION,
+        legacy_compatibility: CURRENT_SDD_LEGACY_COMPATIBILITY,
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function sddContractMismatchReasons(value) {
+    if (!isRecord(value)) {
+        return ['sdd_contract ausente'];
+    }
+    const expected = buildSddContractConfig();
+    const reasons = [];
+    if (value.name !== expected.name) {
+        reasons.push(`name=${String(value.name || '') || '<empty>'}`);
+    }
+    if (value.version !== expected.version) {
+        reasons.push(`version=${String(value.version || '') || '<empty>'}`);
+    }
+    if (value.min_cli_version !== expected.min_cli_version) {
+        reasons.push(`min_cli_version=${String(value.min_cli_version || '') || '<empty>'}`);
+    }
+    if (value.legacy_compatibility !== expected.legacy_compatibility) {
+        reasons.push(`legacy_compatibility=${String(value.legacy_compatibility || '') || '<empty>'}`);
+    }
+    return reasons;
+}
+//# sourceMappingURL=contract.js.map

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,15 +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;
@@ -54,6 +58,36 @@ export declare class InMemoryCoordinationCache implements CoordinationCacheAdapt
     delete(key: string): Promise<void>;
     clear(): Promise<void>;
 }
+export declare class MultiTierCoordinationCache implements CoordinationCacheAdapter {
+    private readonly l1Cache;
+    private readonly projectFingerprint;
+    private readonly configFingerprint;
+    private readonly namespace;
+    private readonly l2Root;
+    constructor(options: {
+        projectRoot: string;
+        namespace?: string;
+        configFingerprint?: string;
+        cacheRootDir?: string;
+    });
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, options?: {
+        ttlMs?: number;
+    }): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    pruneExpired(): Promise<number>;
+    describeTierState(): {
+        root: string;
+        projectFingerprint: string;
+        namespace: string;
+    };
+    private toEntryPath;
+    private remainingTtlMs;
+    private listEntryFiles;
+    private readEntry;
+    private safeUnlink;
+}
 export declare class InMemoryCoordinationQueue<T = unknown> implements CoordinationQueueAdapter<T> {
     private readonly topics;
     enqueue(topic: string, item: T): Promise<void>;
@@ -65,9 +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

@@ -1,4 +1,10 @@
 import { withStateLock } from '../state-lock.js';
+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) {
@@ -31,6 +37,131 @@ export class InMemoryCoordinationCache {
         this.entries.clear();
     }
 }
+export class MultiTierCoordinationCache {
+    l1Cache = new InMemoryCoordinationCache();
+    projectFingerprint;
+    configFingerprint;
+    namespace;
+    l2Root;
+    constructor(options) {
+        this.projectFingerprint = createProjectFingerprint(options.projectRoot);
+        this.configFingerprint = options.configFingerprint ?? 'default';
+        this.namespace = options.namespace ?? 'coordination';
+        this.l2Root = path.join(options.cacheRootDir ?? getGlobalCacheDir(), 'projects', this.projectFingerprint, this.namespace);
+    }
+    async get(key) {
+        const l1Value = await this.l1Cache.get(key);
+        if (typeof l1Value !== 'undefined') {
+            return l1Value;
+        }
+        const filePath = this.toEntryPath(key);
+        const diskEntry = await this.readEntry(filePath);
+        if (!diskEntry) {
+            return undefined;
+        }
+        const ttlMs = this.remainingTtlMs(diskEntry.expires_at);
+        if (ttlMs === 0) {
+            await this.safeUnlink(filePath);
+            return undefined;
+        }
+        await this.l1Cache.set(key, diskEntry.value, ttlMs > 0 ? { ttlMs } : {});
+        return diskEntry.value;
+    }
+    async set(key, value, options = {}) {
+        await this.l1Cache.set(key, value, options);
+        await fs.mkdir(this.l2Root, { recursive: true });
+        const entry = {
+            schema_version: 1,
+            key,
+            value,
+            created_at: new Date().toISOString(),
+            expires_at: options.ttlMs ? new Date(Date.now() + options.ttlMs).toISOString() : undefined,
+            project_fingerprint: this.projectFingerprint,
+            config_fingerprint: this.configFingerprint,
+            namespace: this.namespace,
+        };
+        await fs.writeFile(this.toEntryPath(key), JSON.stringify(entry), 'utf-8');
+    }
+    async delete(key) {
+        await this.l1Cache.delete(key);
+        await this.safeUnlink(this.toEntryPath(key));
+    }
+    async clear() {
+        await this.l1Cache.clear();
+        await fs.rm(this.l2Root, { recursive: true, force: true });
+    }
+    async pruneExpired() {
+        const files = await this.listEntryFiles();
+        let pruned = 0;
+        for (const filePath of files) {
+            const entry = await this.readEntry(filePath);
+            if (!entry) {
+                continue;
+            }
+            if (this.remainingTtlMs(entry.expires_at) === 0) {
+                await this.safeUnlink(filePath);
+                pruned += 1;
+            }
+        }
+        return pruned;
+    }
+    describeTierState() {
+        return {
+            root: this.l2Root,
+            projectFingerprint: this.projectFingerprint,
+            namespace: this.namespace,
+        };
+    }
+    toEntryPath(key) {
+        const hashedKey = createHash('sha256').update(key).digest('hex');
+        return path.join(this.l2Root, `${hashedKey}.json`);
+    }
+    remainingTtlMs(expiresAtIso) {
+        if (!expiresAtIso) {
+            return -1;
+        }
+        const expiresAt = Date.parse(expiresAtIso);
+        if (Number.isNaN(expiresAt)) {
+            return 0;
+        }
+        const remaining = expiresAt - Date.now();
+        return remaining > 0 ? remaining : 0;
+    }
+    async listEntryFiles() {
+        try {
+            const files = await fs.readdir(this.l2Root);
+            return files
+                .filter((fileName) => fileName.endsWith('.json'))
+                .map((fileName) => path.join(this.l2Root, fileName));
+        }
+        catch {
+            return [];
+        }
+    }
+    async readEntry(filePath) {
+        try {
+            const raw = await fs.readFile(filePath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (parsed.schema_version !== 1 ||
+                parsed.project_fingerprint !== this.projectFingerprint ||
+                parsed.config_fingerprint !== this.configFingerprint) {
+                return undefined;
+            }
+            return parsed;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async safeUnlink(filePath) {
+        try {
+            await fs.unlink(filePath);
+        }
+        catch {
+            // best effort cleanup
+        }
+    }
+}
 export class InMemoryCoordinationQueue {
     topics = new Map();
     async enqueue(topic, item) {
@@ -57,31 +188,66 @@ 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) {
-    const redis = resolveRedisBoundaryConfig(options.env);
+    if (!options.cacheRootDir) {
+        ensureGlobalCacheLayout();
+    }
+    const redis = resolveRedisBoundaryConfig(options.env, options.globalConfig);
+    const cache = new MultiTierCoordinationCache({
+        projectRoot: options.projectRoot ?? process.cwd(),
+        configFingerprint: options.configFingerprint,
+        cacheRootDir: options.cacheRootDir,
+    });
     return {
         mode: 'filesystem',
+        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: new InMemoryCoordinationCache(),
+        cache,
         queues: new InMemoryCoordinationQueue(),
         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