@devtrack-solution/codesdd 1.2.2 → 1.2.3

package/dist/core/sdd/backlog-provider-contract.js

@@ -0,0 +1,158 @@
+import { z } from 'zod';
+const SDD_REF_PATTERN = /^(INS|DEB|EPIC|FEAT)-\d{4}$/;
+const PROVIDER_ID_PATTERN = /^[a-z][a-z0-9-]*$/;
+const PROVIDER_FIELD_PATTERN = /^[A-Za-z][A-Za-z0-9_.-]*$/;
+export const backlogProviderIdSchema = z.enum([
+    'azure-devops',
+    'jira',
+    'trello',
+    'confluence',
+    'asana',
+    'generic',
+]);
+export const backlogEntityKindSchema = z.enum(['insight', 'debate', 'epic', 'feature', 'task']);
+export const backlogProviderOperationSchema = z.enum(['create', 'update', 'link', 'query']);
+export const backlogProjectionModeSchema = z.enum(['dry-run', 'apply']);
+export const backlogProjectionDirectionSchema = z.enum(['push', 'pull', 'bidirectional']);
+export const backlogAuthModeSchema = z.enum(['none', 'pat', 'oauth', 'managed-identity', 'app-installation']);
+export const backlogProviderCapabilitySchema = z
+    .object({
+    operation: backlogProviderOperationSchema,
+    entity_kinds: z.array(backlogEntityKindSchema).min(1),
+    dry_run: z.boolean().default(true),
+    apply: z.boolean().default(false),
+    idempotent: z.boolean().default(true),
+    required_fields: z.array(z.string().regex(PROVIDER_FIELD_PATTERN)).default([]),
+})
+    .superRefine((capability, context) => {
+    if (capability.apply && !capability.dry_run) {
+        context.addIssue({
+            code: 'custom',
+            path: ['dry_run'],
+            message: 'Apply-capable backlog provider operations must support dry-run.',
+        });
+    }
+});
+export const backlogProviderContractSchema = z
+    .object({
+    schema_version: z.literal(1).default(1),
+    provider: backlogProviderIdSchema,
+    adapter_id: z.string().regex(PROVIDER_ID_PATTERN),
+    label: z.string().min(2),
+    status: z.enum(['active', 'experimental', 'disabled']).default('experimental'),
+    auth: z.object({
+        mode: backlogAuthModeSchema,
+        required_env: z.array(z.string().min(1)).default([]),
+        secret_fields: z.array(z.string().min(1)).default([]),
+    }),
+    capabilities: z.array(backlogProviderCapabilitySchema).min(1),
+    mapping: z.object({
+        external_project_field: z.string().regex(PROVIDER_FIELD_PATTERN).optional(),
+        external_id_field: z.string().regex(PROVIDER_FIELD_PATTERN),
+        external_url_field: z.string().regex(PROVIDER_FIELD_PATTERN).optional(),
+        canonical_ref_field: z.string().regex(PROVIDER_FIELD_PATTERN),
+        parent_ref_field: z.string().regex(PROVIDER_FIELD_PATTERN).optional(),
+        entity_type_field: z.string().regex(PROVIDER_FIELD_PATTERN),
+        title_field: z.string().regex(PROVIDER_FIELD_PATTERN),
+        status_field: z.string().regex(PROVIDER_FIELD_PATTERN),
+    }),
+    canonical_state_boundary: z.object({
+        source_of_truth: z.literal('codesdd'),
+        state_paths: z.array(z.string().min(1)).default(['.sdd/state/*.yaml']),
+        external_state_authoritative: z.literal(false),
+        hidden_state_allowed: z.literal(false),
+    }),
+    governance: z.object({
+        owner: z.string().min(2),
+        sync_requires_dry_run: z.boolean().default(true),
+        mutation_requires_approval: z.boolean().default(true),
+        audit_event: z.string().min(1).default('codesdd.backlog.projection'),
+    }),
+})
+    .superRefine((contract, context) => {
+    const seenOperations = new Set();
+    for (const [index, capability] of contract.capabilities.entries()) {
+        const key = `${capability.operation}:${capability.entity_kinds.sort().join(',')}`;
+        if (seenOperations.has(key)) {
+            context.addIssue({
+                code: 'custom',
+                path: ['capabilities', index, 'operation'],
+                message: `Duplicate provider capability declaration: ${key}.`,
+            });
+        }
+        seenOperations.add(key);
+    }
+    if (contract.auth.mode === 'none' && contract.auth.required_env.length > 0) {
+        context.addIssue({
+            code: 'custom',
+            path: ['auth', 'required_env'],
+            message: 'Providers using auth mode none must not require credential environment variables.',
+        });
+    }
+});
+export const canonicalBacklogItemSchema = z.object({
+    ref: z.string().regex(SDD_REF_PATTERN),
+    kind: backlogEntityKindSchema.exclude(['task']),
+    title: z.string().min(1),
+    status: z.string().min(1),
+    parent_ref: z.string().regex(SDD_REF_PATTERN).optional(),
+    labels: z.array(z.string().min(1)).default([]),
+    url: z.string().url().optional(),
+});
+export const backlogProjectionItemSchema = z.object({
+    schema_version: z.literal(1).default(1),
+    provider: backlogProviderIdSchema,
+    canonical_ref: z.string().regex(SDD_REF_PATTERN),
+    entity_kind: backlogEntityKindSchema,
+    operation: z.enum(['create', 'update', 'link', 'noop']),
+    idempotency_key: z.string().min(1),
+    external_type: z.string().min(1),
+    fields: z.record(z.string().regex(PROVIDER_FIELD_PATTERN), z.union([z.string(), z.array(z.string())])),
+    links: z
+        .array(z.object({
+        rel: z.enum(['parent', 'trace', 'canonical']),
+        target_ref: z.string().regex(SDD_REF_PATTERN),
+    }))
+        .default([]),
+});
+export const backlogProjectionPlanSchema = z.object({
+    schema_version: z.literal(1).default(1),
+    created_at: z.string().datetime(),
+    provider: backlogProviderIdSchema,
+    mode: backlogProjectionModeSchema,
+    direction: backlogProjectionDirectionSchema,
+    source_of_truth: z.literal('codesdd'),
+    items: z.array(backlogProjectionItemSchema).default([]),
+    warnings: z.array(z.string()).default([]),
+});
+export function createBacklogProviderContract(input) {
+    return backlogProviderContractSchema.parse(input);
+}
+export function buildBacklogProjectionItem(input) {
+    const contract = createBacklogProviderContract(input.contract);
+    const item = canonicalBacklogItemSchema.parse(input.item);
+    const operation = input.operation ?? 'create';
+    const links = item.parent_ref ? [{ rel: 'parent', target_ref: item.parent_ref }] : [];
+    return backlogProjectionItemSchema.parse({
+        schema_version: 1,
+        provider: contract.provider,
+        canonical_ref: item.ref,
+        entity_kind: item.kind,
+        operation,
+        idempotency_key: `${contract.provider}:${item.ref}`,
+        external_type: input.external_type,
+        fields: {
+            [contract.mapping.canonical_ref_field]: item.ref,
+            [contract.mapping.entity_type_field]: item.kind,
+            [contract.mapping.title_field]: item.title,
+            [contract.mapping.status_field]: item.status,
+            ...(contract.mapping.parent_ref_field && item.parent_ref
+                ? { [contract.mapping.parent_ref_field]: item.parent_ref }
+                : {}),
+            ...(contract.mapping.external_url_field && item.url ? { [contract.mapping.external_url_field]: item.url } : {}),
+            labels: item.labels,
+        },
+        links,
+    });
+}
+//# sourceMappingURL=backlog-provider-contract.js.map

package/dist/core/sdd/bootstrap.js

@@ -114,7 +114,7 @@ function classifyRootEntry(name) {
         test: { kind: 'test', notes: 'Testes automatizados' },
         docs: { kind: 'docs', notes: 'Documentacao' },
         config: { kind: 'config', notes: 'Configuracoes' },
-        openspec: { kind: 'openspec', notes: 'Runtime do OpenSpec' },
+        codesdd: { kind: 'codesdd', notes: 'Runtime do CodeSDD' },
         package_json: { kind: 'manifest', notes: 'Manifesto principal' },
     };
     return map[name] || { kind: 'directory', notes: 'Diretorio detectado no projeto' };
@@ -131,7 +131,7 @@ async function inferRepoMap(projectRoot, deep) {
         'test',
         'docs',
         'config',
-        'openspec',
+        'codesdd',
     ];
     for (const candidate of rootCandidates) {
         if (await fileExists(path.join(projectRoot, candidate))) {

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

@@ -1,3 +1,5 @@
+import { type BacklogItem, type DiscoveryRecord, type FrontendGapRecord, type TechDebtRecord } from './types.js';
+import { type SddStateSnapshot } from './state.js';
 export interface SddCheckOptions {
     render?: boolean;
     strict?: boolean;
@@ -45,6 +47,46 @@ export interface SddCheckReport {
         };
     };
 }
+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 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;
+export declare function validateSkillOperationalIntegrity(snapshot: SddStateSnapshot, errors: string[]): void;
+export declare function computeGraphSummary(items: BacklogItem[]): {
+    readyForParallel: number;
+    blocked: number;
+    lockConflicts: number;
+};
+export declare function roundPercent(done: number, total: number): number;
+export declare function computeProgress(items: BacklogItem[]): {
+    progressGlobal: {
+        done: number;
+        total: number;
+        percent: number;
+    };
+    progressByRadar: Array<{
+        radar_id: string;
+        done: number;
+        total: number;
+        percent: number;
+    }>;
+};
+export declare function validateTechDebt(items: TechDebtRecord[], errors: string[]): void;
+export declare function validateFrontendReferences(gaps: FrontendGapRecord[], backlog: BacklogItem[], errors: string[], warnings: string[]): void;
+export declare function validateActiveTaskChecklist(activeDir: string, items: BacklogItem[], warnings: string[]): Promise<void>;
+export declare function validateWorkspaceCoherence(activeDir: string, archivedDir: string, items: BacklogItem[], warnings: string[]): Promise<void>;
+export declare function isPrivacyComplianceBacklogItem(item: BacklogItem): boolean;
+export declare function validatePrivacySourceRegistry(snapshot: SddStateSnapshot, warnings: string[]): void;
+export declare function validatePrivacyWorkspaceChecklist(activeDir: string, items: BacklogItem[], warnings: string[]): Promise<void>;
+export declare function validateTraceabilityWorkspaceChecklist(projectRoot: string, activeDir: string, items: BacklogItem[], warnings: string[]): Promise<void>;
+export declare function featureRequiresQualityContract(item: BacklogItem): boolean;
+export declare function detectMissingQualityArtifacts(activeDir: string, items: BacklogItem[]): Promise<string[]>;
+export declare function parseRouteToken(value: string): string | null;
+export declare function featureHasMetadataFrontendEvidence(item: BacklogItem): boolean;
+export declare function validateCanonicalSddStructure(memoryRoot: string, errors: string[]): Promise<void>;
 export declare class SddCheckCommand {
     execute(projectRoot: string, options?: SddCheckOptions): Promise<SddCheckReport>;
 }

package/dist/core/sdd/check.js

@@ -11,7 +11,7 @@ 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) ?? []);
@@ -133,7 +133,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) {
@@ -173,7 +173,7 @@ function validateSkillOperationalIntegrity(snapshot, errors) {
         }
     }
 }
-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 +226,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 +262,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 +285,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 +325,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 +342,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 +385,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 +433,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 +458,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 +477,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 +494,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 +506,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);

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

@@ -31,6 +31,11 @@ export interface RedisBoundaryConfig {
 }
 export interface SddCoordinationAdapters {
     mode: 'filesystem';
+    cacheTier: {
+        root: string;
+        projectFingerprint: string;
+        namespace: string;
+    };
     redis: RedisBoundaryConfig & {
         status: 'disabled' | 'requested-unavailable';
         reason: string;
@@ -54,6 +59,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>;
@@ -68,6 +103,9 @@ export declare class InMemoryCoordinationEventBus implements CoordinationEventBu
 export declare function resolveRedisBoundaryConfig(env?: NodeJS.ProcessEnv): RedisBoundaryConfig;
 export declare function createFilesystemFirstCoordinationAdapters(options: {
     stateDir: string;
+    projectRoot?: string;
+    configFingerprint?: string;
+    cacheRootDir?: string;
     env?: NodeJS.ProcessEnv;
 }): SddCoordinationAdapters;
 //# sourceMappingURL=coordination-adapters.d.ts.map