@devtrack-solution/codesdd 1.2.3 → 1.2.4-rc3

package/dist/core/sdd/agent-runtime-contract.js

@@ -0,0 +1,200 @@
+import { toJSONSchema, z } from 'zod';
+const JSON_SCHEMA_DRAFT = 'https://json-schema.org/draft/2020-12/schema';
+const FEATURE_REF_PATTERN = /^FEAT-\d{4}$/;
+export const agentRuntimeProviderSchema = z.enum(['deepagents', 'codex', 'opencode']);
+export const agentRuntimeModeSchema = z.enum(['read-only', 'plan', 'validate', 'apply-sandbox', 'apply-approved']);
+export const agentRuntimeSandboxSchema = z.enum(['read-only', 'workspace-write', 'danger-full-access']);
+export const agentRuntimeStatusSchema = z.enum(['planned', 'blocked']);
+export const opencodeExecutionStatusSchema = z.enum([
+    'planned',
+    'skipped',
+    'blocked',
+    'running',
+    'completed',
+    'failed',
+]);
+const agentRuntimeCommandSchema = z.object({
+    executable: z.string().min(1),
+    args: z.array(z.string()).default([]),
+    stdin: z.string().optional(),
+});
+const agentRuntimeEvidenceArtifactSchema = z.object({
+    kind: z.string().min(1),
+    ref: z.string().min(1),
+    path: z.string().min(1).optional(),
+    sha256: z.string().min(1).optional(),
+});
+const agentRuntimeRiskSchema = z.object({
+    id: z.string().min(1),
+    severity: z.enum(['low', 'medium', 'high', 'critical']),
+    summary: z.string().min(1),
+    mitigation: z.string().min(1).optional(),
+});
+export const agentRuntimeCommandPlanRequestSchema = z.object({
+    schema_version: z.literal(1).default(1),
+    feature_ref: z.string().regex(FEATURE_REF_PATTERN),
+    provider: agentRuntimeProviderSchema,
+    mode: agentRuntimeModeSchema.default('plan'),
+    instruction: z.string().min(1),
+    cwd: z.string().min(1).default('.'),
+    model: z.string().min(1).optional(),
+    sandbox: agentRuntimeSandboxSchema.default('read-only'),
+    output_schema: z.string().min(1).optional(),
+    output_last_message: z.string().min(1).optional(),
+    agent: z.string().min(1).optional(),
+    session: z.string().min(1).optional(),
+    files: z.array(z.string().min(1)).default([]),
+    approval_grants: z.array(z.enum(['maintainer', 'architecture-board', 'security'])).default([]),
+});
+export const agentRuntimeCommandPlanSchema = z.object({
+    schema_version: z.literal(1),
+    created_at: z.string().datetime(),
+    status: agentRuntimeStatusSchema,
+    request: agentRuntimeCommandPlanRequestSchema,
+    provider: agentRuntimeProviderSchema,
+    command: agentRuntimeCommandSchema.optional(),
+    evidence_contract: z.enum(['agent-runtime-v2/deepagents', 'agent-runtime-v2/codex-exec', 'agent-runtime-v2/opencode-run']),
+    structured_output: z.boolean(),
+    reasons: z.array(z.string()).default([]),
+    policy: z.object({
+        direct_state_write_allowed: z.literal(false),
+        requires_codesdd_finalize: z.literal(true),
+        mutating_modes_require_approval: z.literal(true),
+    }),
+});
+export const opencodeExecutionEvidenceSchema = z.object({
+    schema_version: z.literal(1),
+    contract: z.literal('agent-runtime-v2/opencode-run'),
+    provider: z.literal('opencode'),
+    feature_ref: z.string().regex(FEATURE_REF_PATTERN),
+    run_id: z.string().min(1),
+    created_at: z.string().datetime(),
+    mode: agentRuntimeModeSchema,
+    status: opencodeExecutionStatusSchema,
+    command: agentRuntimeCommandSchema.extend({
+        executable: z.literal('opencode'),
+    }),
+    command_plan_ref: z.string().min(1).optional(),
+    cwd: z.string().min(1).default('.'),
+    exit_code: z.number().int().nullable().default(null),
+    started_at: z.string().datetime().optional(),
+    completed_at: z.string().datetime().optional(),
+    duration_ms: z.number().int().nonnegative().optional(),
+    structured_output: z.record(z.string(), z.unknown()).default({}),
+    stdout_excerpt: z.string().max(8000).optional(),
+    stderr_excerpt: z.string().max(8000).optional(),
+    artifacts: z.array(agentRuntimeEvidenceArtifactSchema).default([]),
+    validations: z.array(z.string().min(1)).default([]),
+    redactions: z.array(z.string().min(1)).default([]),
+    risks: z.array(agentRuntimeRiskSchema).default([]),
+    policy: z.object({
+        direct_state_write_allowed: z.literal(false),
+        requires_codesdd_finalize: z.literal(true),
+        raw_secret_output_allowed: z.literal(false),
+        transcript_storage: z.enum(['forbidden', 'redacted-excerpts-only']).default('redacted-excerpts-only'),
+    }),
+    finalize_intent: z.boolean().default(false),
+});
+export function buildAgentRuntimeCommandPlan(request, createdAt = new Date().toISOString()) {
+    const parsed = agentRuntimeCommandPlanRequestSchema.parse(request);
+    const reasons = collectPolicyReasons(parsed);
+    const status = reasons.length > 0 ? 'blocked' : 'planned';
+    const command = status === 'planned' ? buildCommand(parsed) : undefined;
+    return agentRuntimeCommandPlanSchema.parse({
+        schema_version: 1,
+        created_at: createdAt,
+        status,
+        request: parsed,
+        provider: parsed.provider,
+        command,
+        evidence_contract: evidenceContract(parsed.provider),
+        structured_output: true,
+        reasons,
+        policy: {
+            direct_state_write_allowed: false,
+            requires_codesdd_finalize: true,
+            mutating_modes_require_approval: true,
+        },
+    });
+}
+export function buildOpenCodeExecutionEvidence(evidence) {
+    return opencodeExecutionEvidenceSchema.parse(evidence);
+}
+export function buildAgentRuntimeJsonSchemas() {
+    return {
+        'agent-runtime-command-plan.yaml': {
+            ...toJSONSchema(agentRuntimeCommandPlanSchema),
+            $schema: JSON_SCHEMA_DRAFT,
+            title: 'CodeSDD Agent Runtime Command Plan',
+            description: 'Provider-normalized command plan for DeepAgents, Codex exec, and OpenCode run agent runtimes.',
+        },
+        'agent-runtime-opencode-run-evidence.yaml': {
+            ...toJSONSchema(opencodeExecutionEvidenceSchema),
+            $schema: JSON_SCHEMA_DRAFT,
+            title: 'CodeSDD Agent Runtime OpenCode Run Evidence',
+            description: 'Machine-readable OpenCode run evidence with redacted excerpts, artifacts, validations, and finalize policy.',
+        },
+    };
+}
+function collectPolicyReasons(request) {
+    const reasons = [];
+    const mutating = request.mode === 'apply-sandbox' || request.mode === 'apply-approved';
+    if (mutating && request.approval_grants.length === 0) {
+        reasons.push(`Mode ${request.mode} requires explicit approval evidence before agent execution.`);
+    }
+    if (request.provider !== 'deepagents' && request.mode === 'apply-approved') {
+        reasons.push('Codex and OpenCode apply-approved execution is not enabled until plugin evidence ingestion is complete.');
+    }
+    if (request.provider === 'codex' && request.sandbox === 'danger-full-access') {
+        reasons.push('Codex danger-full-access sandbox is forbidden by the default CodeSDD agent runtime contract.');
+    }
+    return reasons;
+}
+function buildCommand(request) {
+    if (request.provider === 'deepagents') {
+        return {
+            executable: 'codesdd',
+            args: ['sdd', 'agent', 'run', request.feature_ref, '--provider', 'deepagents', '--mode', request.mode],
+        };
+    }
+    if (request.provider === 'codex') {
+        const args = ['exec', '--json', '--cd', request.cwd, '--sandbox', request.sandbox];
+        if (request.model)
+            args.push('--model', request.model);
+        if (request.output_schema)
+            args.push('--output-schema', request.output_schema);
+        if (request.output_last_message)
+            args.push('--output-last-message', request.output_last_message);
+        for (const file of request.files) {
+            args.push('--image', file);
+        }
+        args.push(request.instruction);
+        return {
+            executable: 'codex',
+            args,
+        };
+    }
+    const args = ['run', '--format', 'json', '--dir', request.cwd];
+    if (request.model)
+        args.push('--model', request.model);
+    if (request.agent)
+        args.push('--agent', request.agent);
+    if (request.session)
+        args.push('--session', request.session);
+    for (const file of request.files) {
+        args.push('--file', file);
+    }
+    args.push(request.instruction);
+    return {
+        executable: 'opencode',
+        args,
+    };
+}
+function evidenceContract(provider) {
+    if (provider === 'codex')
+        return 'agent-runtime-v2/codex-exec';
+    if (provider === 'opencode')
+        return 'agent-runtime-v2/opencode-run';
+    return 'agent-runtime-v2/deepagents';
+}
+//# sourceMappingURL=agent-runtime-contract.js.map

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

@@ -13,6 +13,8 @@ export interface SddCheckReport {
         backlog: number;
         techDebt: number;
         finalizeQueue: number;
+        finalizeQueuePending: number;
+        finalizeQueueDone: number;
         frontendEnabled: boolean;
         frontendGaps: number;
         frontendRoutes: number;

package/dist/core/sdd/check.js

@@ -4,7 +4,7 @@ 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';
@@ -122,6 +122,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 +179,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 +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/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

package/dist/core/sdd/coordination/redis-runtime.d.ts

@@ -0,0 +1,131 @@
+import type { GlobalConfig } from '../../global-config.js';
+import type { CoordinationCacheAdapter, CoordinationEvent, CoordinationEventBusAdapter, CoordinationLockAdapter, CoordinationQueueAdapter } from './coordination-adapters.js';
+import { type AcquireOptions } from '../state-lock.js';
+export type RedisRuntimeStatus = 'disabled' | 'requested-unavailable' | 'ready' | 'degraded' | 'blocked';
+export type RedisFallbackMode = 'filesystem' | 'none';
+export interface RedisRuntimeConfig {
+    requested: boolean;
+    enabled: boolean;
+    namespace: string;
+    url?: string;
+    redactedUrl?: string;
+    tls: boolean;
+    connectTimeoutMs: number;
+    commandTimeoutMs: number;
+    maxRetries: number;
+    fallback: RedisFallbackMode;
+    cacheDefaultTtlMs: number;
+    lockTtlMs: number;
+    streamMaxLen: number;
+    validationErrors: string[];
+    warnings: string[];
+}
+export interface RedisOperationalReport {
+    requested: boolean;
+    namespace: string;
+    status: RedisRuntimeStatus;
+    fallback: RedisFallbackMode;
+    redacted_url?: string;
+    latency_ms?: number;
+    reason: string;
+    validation_errors: string[];
+    warnings: string[];
+}
+export interface RedisCommandClient {
+    isReady?: boolean;
+    isOpen?: boolean;
+    connect(): Promise<RedisCommandClient>;
+    ping(): Promise<string>;
+    sendCommand<T = unknown>(args: ReadonlyArray<string>): Promise<T>;
+    close?(): Promise<void>;
+    destroy?(): void;
+    on?(event: 'error', listener: (error: Error) => void): RedisCommandClient;
+}
+export type RedisClientCreator = (config: RedisRuntimeConfig) => RedisCommandClient;
+export declare function redactRedisUrl(url: string | undefined): string | undefined;
+export declare function sanitizeRedisError(error: unknown, config?: Pick<RedisRuntimeConfig, 'url'>): string;
+export declare function hashRedisKey(input: string): string;
+export declare function buildRedisKey(config: RedisRuntimeConfig, projectFingerprint: string, domain: string, key: string): string;
+export declare function resolveRedisRuntimeConfig(env?: NodeJS.ProcessEnv, globalConfig?: Partial<GlobalConfig>): RedisRuntimeConfig;
+export declare function resolveRedisBoundaryConfig(env?: NodeJS.ProcessEnv, globalConfig?: Partial<GlobalConfig>): RedisRuntimeConfig;
+export declare class RedisClientFactory {
+    readonly config: RedisRuntimeConfig;
+    private readonly createClientImpl;
+    private client?;
+    private lastError?;
+    constructor(config: RedisRuntimeConfig, createClientImpl?: RedisClientCreator);
+    getClient(): Promise<RedisCommandClient>;
+    ping(): Promise<{
+        ok: boolean;
+        latencyMs?: number;
+        message: string;
+    }>;
+    command<T = unknown>(args: ReadonlyArray<string>): Promise<T>;
+    close(): Promise<void>;
+    getLastError(): string | undefined;
+}
+export declare function buildRedisOperationalReport(options?: {
+    env?: NodeJS.ProcessEnv;
+    globalConfig?: Partial<GlobalConfig>;
+    createClient?: RedisClientCreator;
+}): Promise<RedisOperationalReport>;
+export declare class RedisCoordinationCache implements CoordinationCacheAdapter {
+    private readonly redis;
+    private readonly fallback;
+    private readonly projectFingerprint;
+    private readonly domain;
+    constructor(redis: RedisClientFactory, fallback: CoordinationCacheAdapter, projectFingerprint: string, domain?: 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>;
+}
+export declare class RedisLockAdapter implements CoordinationLockAdapter {
+    private readonly redis;
+    private readonly fallback;
+    private readonly projectFingerprint;
+    constructor(redis: RedisClientFactory, fallback: CoordinationLockAdapter, projectFingerprint: string);
+    withLock<T>(scope: string, fn: () => Promise<T>, options?: AcquireOptions): Promise<T>;
+    extend(scope: string, ownerToken: string, ttlMs?: number): Promise<boolean>;
+    private release;
+}
+export declare class RedisQueueAdapter<T = unknown> implements CoordinationQueueAdapter<T> {
+    private readonly redis;
+    private readonly fallback;
+    private readonly projectFingerprint;
+    constructor(redis: RedisClientFactory, fallback: CoordinationQueueAdapter<T>, projectFingerprint: string);
+    enqueue(topic: string, item: T): Promise<void>;
+    dequeue(topic: string): Promise<T | undefined>;
+    size(topic: string): Promise<number>;
+}
+export declare class RedisEventBusAdapter implements CoordinationEventBusAdapter {
+    private readonly redis;
+    private readonly fallback;
+    private readonly projectFingerprint;
+    constructor(redis: RedisClientFactory, fallback: CoordinationEventBusAdapter, projectFingerprint: string);
+    publish(event: CoordinationEvent): Promise<void>;
+    drain(): Promise<CoordinationEvent[]>;
+}
+export declare class RedisWorkDeduper {
+    private readonly redis;
+    private readonly projectFingerprint;
+    constructor(redis: RedisClientFactory, projectFingerprint: string);
+    claim(key: string, ttlMs?: number): Promise<boolean>;
+}
+export declare function deleteKeysByPrefix(redis: RedisClientFactory, prefix: string): Promise<number>;
+export declare function runRedisBenchmark(options: {
+    env?: NodeJS.ProcessEnv;
+    globalConfig?: Partial<GlobalConfig>;
+    createClient?: RedisClientCreator;
+    iterations?: number;
+}): Promise<{
+    status: RedisRuntimeStatus;
+    namespace: string;
+    iterations: number;
+    p50_ms?: number;
+    p95_ms?: number;
+    reason: string;
+}>;
+//# sourceMappingURL=redis-runtime.d.ts.map