@devtrack-solution/codesdd 1.2.2 → 1.2.4-rc3

package/dist/core/sdd/domain/post-active-validation.js

@@ -17,6 +17,65 @@ function relativePath(paths, targetPath) {
 function legacyArchiveRoot(paths) {
     return path.join(paths.memoryRoot, LEGACY_ARCHIVE_DIR);
 }
+async function listFiles(root) {
+    const entries = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await listFiles(fullPath)));
+        }
+        else if (entry.isFile()) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function archivedActiveReferenceNeedle(featureId) {
+    return `.sdd/active/${featureId}`;
+}
+function archivedFeatureReference(featureId) {
+    return `.sdd/archived/${featureId}`;
+}
+export async function normalizeArchivedFeatureActiveReferences(paths, featureId) {
+    const archivedFeaturePath = path.join(paths.archivedDir, featureId);
+    if (!(await exists(archivedFeaturePath))) {
+        return [];
+    }
+    const needle = archivedActiveReferenceNeedle(featureId);
+    const replacement = archivedFeatureReference(featureId);
+    const updated = [];
+    for (const filePath of await listFiles(archivedFeaturePath)) {
+        const content = await fs.readFile(filePath, 'utf-8').catch(() => '');
+        if (!content.includes(needle)) {
+            continue;
+        }
+        await fs.writeFile(filePath, content.split(needle).join(replacement), 'utf-8');
+        updated.push(relativePath(paths, filePath));
+    }
+    return updated;
+}
+export async function detectArchivedFeatureActiveReferences(paths, featureId) {
+    const archivedFeaturePath = path.join(paths.archivedDir, featureId);
+    if (!(await exists(archivedFeaturePath))) {
+        return [];
+    }
+    const needle = archivedActiveReferenceNeedle(featureId);
+    const references = [];
+    for (const filePath of await listFiles(archivedFeaturePath)) {
+        const content = await fs.readFile(filePath, 'utf-8').catch(() => '');
+        if (!content.includes(needle)) {
+            continue;
+        }
+        const relative = relativePath(paths, filePath);
+        references.push({
+            feature_id: featureId,
+            path: relative,
+            message: `${featureId} archived workspace file ${relative} references removed active workspace ${needle}.`,
+        });
+    }
+    return references;
+}
 export async function detectArchiveArchivedLifecycleCollisions(paths, featureId) {
     const legacyRoot = legacyArchiveRoot(paths);
     if (path.resolve(legacyRoot) === path.resolve(paths.archivedDir)) {
@@ -63,6 +122,8 @@ export async function validatePostActiveFeaturePlacement(paths, featureId) {
     }
     const collisions = await detectArchiveArchivedLifecycleCollisions(paths, featureId);
     reasons.push(...collisions.map((collision) => collision.message));
+    const activeReferences = await detectArchivedFeatureActiveReferences(paths, featureId);
+    reasons.push(...activeReferences.map((reference) => reference.message));
     return {
         ok: reasons.length === 0,
         reasons,

package/dist/core/sdd/domain/semantic-intent-classifier.d.ts

@@ -0,0 +1,29 @@
+import type { CapabilityDiffReport, CapabilityRiskReport } from './capability-diff.js';
+import type { ChangeSafetyOperation } from './change-safety-guardrails.js';
+export declare const SEMANTIC_INTENT_CLASSES: readonly ["incremental", "refactor", "replacement", "ambiguous"];
+export type SemanticIntentClass = (typeof SEMANTIC_INTENT_CLASSES)[number];
+export interface SemanticIntentClassifierInput {
+    objective?: string;
+    declared_operation?: ChangeSafetyOperation | '';
+    capability_diff?: CapabilityDiffReport;
+    deterministic_risk?: CapabilityRiskReport;
+}
+export interface SemanticIntentSignal {
+    code: string;
+    message: string;
+    weight: number;
+}
+export interface SemanticIntentClassification {
+    schema_version: 1;
+    contract: 'semantic-intent-classification/v1';
+    status: 'allowed' | 'blocked';
+    classification: SemanticIntentClass;
+    fail_closed: true;
+    triggered: boolean;
+    confidence: number;
+    reasons: string[];
+    signals: SemanticIntentSignal[];
+}
+export declare function shouldRunSemanticIntentClassifier(input: SemanticIntentClassifierInput): boolean;
+export declare function classifySemanticIntent(input: SemanticIntentClassifierInput): SemanticIntentClassification;
+//# sourceMappingURL=semantic-intent-classifier.d.ts.map

package/dist/core/sdd/domain/semantic-intent-classifier.js

@@ -0,0 +1,117 @@
+export const SEMANTIC_INTENT_CLASSES = ['incremental', 'refactor', 'replacement', 'ambiguous'];
+const REPLACEMENT_PATTERNS = [
+    /\breplace\b/iu,
+    /\brewrite\b/iu,
+    /\brebuild\b/iu,
+    /\bfrom scratch\b/iu,
+    /\boverwrite\b/iu,
+    /\bsubstitu(?:ir|icao|ição)\b/iu,
+    /\bsobrescrev/iu,
+    /\breescrev/iu,
+    /\bdo zero\b/iu,
+];
+const REFACTOR_PATTERNS = [/\brefactor\b/iu, /\brefator/iu, /\boptimi[sz]e\b/iu, /\botimiz/iu];
+const INCREMENTAL_PATTERNS = [
+    /\badd\b/iu,
+    /\bcreate\b/iu,
+    /\bextend\b/iu,
+    /\bincremental\b/iu,
+    /\bcriar\b/iu,
+    /\badicionar\b/iu,
+    /\bincrement/iu,
+];
+const HIGH_RISK_LEVELS = new Set(['high', 'critical']);
+export function shouldRunSemanticIntentClassifier(input) {
+    return Boolean(input.deterministic_risk && HIGH_RISK_LEVELS.has(input.deterministic_risk.level));
+}
+export function classifySemanticIntent(input) {
+    const triggered = shouldRunSemanticIntentClassifier(input);
+    const signals = collectSignals(input);
+    const classification = resolveClassification(input, signals);
+    const highRisk = Boolean(input.deterministic_risk && HIGH_RISK_LEVELS.has(input.deterministic_risk.level));
+    const blocked = triggered &&
+        (classification === 'replacement' ||
+            classification === 'ambiguous' ||
+            (highRisk && input.declared_operation === 'add' && hasRemovedCapability(input.capability_diff)));
+    return {
+        schema_version: 1,
+        contract: 'semantic-intent-classification/v1',
+        status: blocked ? 'blocked' : 'allowed',
+        classification,
+        fail_closed: true,
+        triggered,
+        confidence: confidenceFor(classification, signals),
+        reasons: blocked ? blockedReasons(classification, input) : [],
+        signals,
+    };
+}
+function collectSignals(input) {
+    const objective = input.objective ?? '';
+    const signals = [];
+    collectPatternSignals(objective, REPLACEMENT_PATTERNS, signals, 'replacement_language', 50);
+    collectPatternSignals(objective, REFACTOR_PATTERNS, signals, 'refactor_language', 30);
+    collectPatternSignals(objective, INCREMENTAL_PATTERNS, signals, 'incremental_language', 30);
+    if (input.declared_operation === 'replace' || input.declared_operation === 'remove') {
+        signals.push({
+            code: 'declared_replacement_operation',
+            message: `Declared operation ${input.declared_operation} is replacement-class.`,
+            weight: 60,
+        });
+    }
+    if (hasRemovedCapability(input.capability_diff)) {
+        signals.push({
+            code: 'removed_capability_present',
+            message: 'Capability diff contains removed capabilities.',
+            weight: 45,
+        });
+    }
+    if (input.deterministic_risk?.level === 'critical') {
+        signals.push({
+            code: 'critical_deterministic_risk',
+            message: 'Deterministic risk is critical.',
+            weight: 50,
+        });
+    }
+    return signals.sort((left, right) => right.weight - left.weight || left.code.localeCompare(right.code));
+}
+function collectPatternSignals(value, patterns, signals, code, weight) {
+    if (patterns.some((pattern) => pattern.test(value))) {
+        signals.push({ code, message: `Objective matched ${code}.`, weight });
+    }
+}
+function resolveClassification(input, signals) {
+    const hasReplacement = signals.some((signal) => ['replacement_language', 'declared_replacement_operation', 'removed_capability_present'].includes(signal.code));
+    const hasIncremental = signals.some((signal) => signal.code === 'incremental_language') || input.declared_operation === 'add';
+    const hasRefactor = signals.some((signal) => signal.code === 'refactor_language') || input.declared_operation === 'refactor';
+    if (hasReplacement && (hasIncremental || hasRefactor))
+        return 'ambiguous';
+    if (hasReplacement)
+        return 'replacement';
+    if (hasRefactor)
+        return 'refactor';
+    if (hasIncremental)
+        return 'incremental';
+    return input.deterministic_risk && HIGH_RISK_LEVELS.has(input.deterministic_risk.level) ? 'ambiguous' : 'incremental';
+}
+function hasRemovedCapability(diff) {
+    return Boolean(diff?.entries.some((entry) => entry.change === 'removed'));
+}
+function confidenceFor(classification, signals) {
+    if (classification === 'ambiguous')
+        return 50;
+    const total = Math.min(100, signals.filter((signal) => signal.weight > 0).reduce((sum, signal) => sum + signal.weight, 40));
+    return total;
+}
+function blockedReasons(classification, input) {
+    if (classification === 'replacement') {
+        return ['Semantic intent classifier fail-closed because the request is replacement-class.'];
+    }
+    if (classification === 'ambiguous') {
+        return ['Semantic intent classifier fail-closed because high-risk intent is ambiguous.'];
+    }
+    if (input.declared_operation === 'add' && hasRemovedCapability(input.capability_diff)) {
+        return ['Semantic intent classifier fail-closed because add intent conflicts with removed capabilities.'];
+    }
+    return [];
+}
+//# sourceMappingURL=semantic-intent-classifier.js.map

package/dist/core/sdd/domain/transition-engine.js

@@ -5,6 +5,7 @@ export class TransitionEngine {
             NEW: ['DEBATED', 'DISCARDED'],
         },
         DEB: {
+            DEBATED: ['APPROVED', 'DISCARDED'],
             OPEN: ['APPROVED', 'DISCARDED'],
         },
         EPIC: {

package/dist/core/sdd/entity-reference.d.ts

@@ -0,0 +1,5 @@
+export type SddEntityType = 'FEAT' | 'RAD' | 'EPIC' | 'FGAP' | 'TD';
+export declare function normalizeFeatRef(input: string): string | null;
+export declare function normalizeSddEntityRef(input: string): string;
+export declare function detectSddEntityType(input: string): SddEntityType | null;
+//# sourceMappingURL=entity-reference.d.ts.map

package/dist/core/sdd/entity-reference.js

@@ -0,0 +1,22 @@
+const FEAT_ALIAS_PATTERN = /^(?:FEAT|FEATS|FEATES)-(\d{3,})$/i;
+const CANONICAL_PATTERNS = [
+    ['FEAT', /^FEAT-\d{3,}$/],
+    ['EPIC', /^EPIC-\d{3,}$/],
+    ['RAD', /^RAD-\d{3,}$/],
+    ['FGAP', /^FGAP-\d{3,}$/],
+    ['TD', /^TD-\d{3,}$/],
+];
+export function normalizeFeatRef(input) {
+    const match = input.trim().match(FEAT_ALIAS_PATTERN);
+    if (!match)
+        return null;
+    return `FEAT-${match[1]}`;
+}
+export function normalizeSddEntityRef(input) {
+    return normalizeFeatRef(input) ?? input.trim();
+}
+export function detectSddEntityType(input) {
+    const normalized = normalizeSddEntityRef(input);
+    return CANONICAL_PATTERNS.find(([, pattern]) => pattern.test(normalized))?.[0] ?? null;
+}
+//# sourceMappingURL=entity-reference.js.map

package/dist/core/sdd/foundation-artifact-map-validator.d.ts

@@ -0,0 +1,16 @@
+import { type PluginArtifactMap } from './plugin-sdk-contract.js';
+export type FoundationArtifactMapFindingCode = 'FOUNDATION_ARTIFACT_SCHEMA_INVALID' | 'FOUNDATION_LAYER_PATH_MISMATCH' | 'FOUNDATION_DOMAIN_BO_PATH_INVALID' | 'FOUNDATION_DOMAIN_VO_PATH_INVALID' | 'FOUNDATION_APPLICATION_PORT_PATH_INVALID' | 'FOUNDATION_INFRASTRUCTURE_ENTITY_PATH_INVALID';
+export interface FoundationArtifactMapFinding {
+    code: FoundationArtifactMapFindingCode;
+    severity: 'warn';
+    path?: string;
+    message: string;
+    remediation: string;
+}
+export interface FoundationArtifactMapValidationResult {
+    status: 'passed' | 'warning';
+    artifact_map?: PluginArtifactMap;
+    findings: FoundationArtifactMapFinding[];
+}
+export declare function validateFoundationArtifactMapArchitecture(value: unknown): FoundationArtifactMapValidationResult;
+//# sourceMappingURL=foundation-artifact-map-validator.d.ts.map

package/dist/core/sdd/foundation-artifact-map-validator.js

@@ -0,0 +1,71 @@
+import { pluginArtifactMapSchema, } from './plugin-sdk-contract.js';
+const LAYER_PATH_PREFIXES = {
+    domain: 'src/domain/',
+    application: 'src/application/',
+    infrastructure: 'src/infrastructure/',
+    presentation: 'src/presentation/',
+    tests: 'test/',
+    docs: 'docs/',
+    sdd: '.sdd/',
+    config: '.',
+};
+const DOMAIN_BO_PATTERN = /^src\/domain\/[^/]+\/business-objects\/[^/]+\.bo\.ts$/u;
+const DOMAIN_VO_PATTERN = /^src\/domain\/[^/]+\/value-objects\/[^/]+\.vo\.ts$/u;
+const APPLICATION_PORT_PATTERN = /^src\/application\/business\/[^/]+\/ports\/out\/[^/]+\.port\.ts$/u;
+const INFRASTRUCTURE_ENTITY_PATTERN = /^src\/infrastructure\/adapters\/orm\/entities\/[^/]+\.orm-entity\.ts$/u;
+export function validateFoundationArtifactMapArchitecture(value) {
+    const parsed = pluginArtifactMapSchema.safeParse(value);
+    if (!parsed.success) {
+        return {
+            status: 'warning',
+            findings: [
+                {
+                    code: 'FOUNDATION_ARTIFACT_SCHEMA_INVALID',
+                    severity: 'warn',
+                    message: `Artifact map failed SDK schema validation: ${parsed.error.issues.map(formatIssue).join('; ')}`,
+                    remediation: 'Validate the artifact map with @devtrack-solution/codesdd-plugin-sdk before applying Foundation architecture checks.',
+                },
+            ],
+        };
+    }
+    const findings = parsed.data.artifacts.flatMap(validateEntry);
+    return {
+        status: findings.length > 0 ? 'warning' : 'passed',
+        artifact_map: parsed.data,
+        findings,
+    };
+}
+function validateEntry(entry) {
+    const findings = [];
+    const expectedPrefix = LAYER_PATH_PREFIXES[entry.layer];
+    if (expectedPrefix && !entry.path.startsWith(expectedPrefix)) {
+        findings.push(finding('FOUNDATION_LAYER_PATH_MISMATCH', entry, `Artifact declares layer "${entry.layer}" but path "${entry.path}" does not use the expected prefix "${expectedPrefix}".`, `Move the artifact under ${expectedPrefix} or correct the layer metadata before execution.`));
+    }
+    if (entry.layer === 'domain' && entry.role === 'business-object' && !DOMAIN_BO_PATTERN.test(entry.path)) {
+        findings.push(finding('FOUNDATION_DOMAIN_BO_PATH_INVALID', entry, `Domain business object path "${entry.path}" does not match the Foundation BO-pattern.`, 'Use src/domain/<context>/business-objects/<name>.bo.ts for new Foundation contexts.'));
+    }
+    if (entry.layer === 'domain' && entry.role === 'value-object' && !DOMAIN_VO_PATTERN.test(entry.path)) {
+        findings.push(finding('FOUNDATION_DOMAIN_VO_PATH_INVALID', entry, `Domain value object path "${entry.path}" does not match the Foundation VO-pattern.`, 'Use src/domain/<context>/value-objects/<name>.vo.ts for value objects.'));
+    }
+    if (entry.role === 'repository-port' && !APPLICATION_PORT_PATTERN.test(entry.path)) {
+        findings.push(finding('FOUNDATION_APPLICATION_PORT_PATH_INVALID', entry, `Repository port path "${entry.path}" does not match the Foundation application ports/out pattern.`, 'Use src/application/business/<context>/ports/out/<name>.port.ts for BO-pattern repository ports.'));
+    }
+    if (entry.layer === 'infrastructure' && entry.role === 'entity' && !INFRASTRUCTURE_ENTITY_PATTERN.test(entry.path)) {
+        findings.push(finding('FOUNDATION_INFRASTRUCTURE_ENTITY_PATH_INVALID', entry, `Infrastructure entity path "${entry.path}" does not match the centralized TypeORM entity pattern.`, 'Use src/infrastructure/adapters/orm/entities/<name>.orm-entity.ts for TypeORM entities.'));
+    }
+    return findings;
+}
+function finding(code, entry, message, remediation) {
+    return {
+        code,
+        severity: 'warn',
+        path: entry.path,
+        message,
+        remediation,
+    };
+}
+function formatIssue(issue) {
+    const issuePath = issue.path.length > 0 ? issue.path.join('.') : '<root>';
+    return `${issuePath}: ${issue.message}`;
+}
+//# sourceMappingURL=foundation-artifact-map-validator.js.map

package/dist/core/sdd/foundation-layer-manifest.d.ts

@@ -0,0 +1,24 @@
+export declare const CODESDD_FOUNDATION_LAYER_IDS: readonly ["domains", "applications", "infrastructures", "presentations", "shared"];
+export type CodesddFoundationLayerId = (typeof CODESDD_FOUNDATION_LAYER_IDS)[number];
+export interface CodesddFoundationLayerMapping {
+    layer: CodesddFoundationLayerId;
+    root: `src/${CodesddFoundationLayerId}`;
+    entrypoint: `src/${CodesddFoundationLayerId}/${string}`;
+    legacy_roots: string[];
+    role: string;
+    migration_status: 'active-facade' | 'legacy-source';
+}
+export interface CodesddFoundationLayerFinding {
+    code: 'FOUNDATION_LAYER_MISSING' | 'FOUNDATION_LAYER_ROOT_MISMATCH' | 'FOUNDATION_LAYER_ENTRYPOINT_MISMATCH' | 'FOUNDATION_LAYER_DUPLICATE' | 'FOUNDATION_LAYER_FORBIDDEN_PROJECT_RUNTIME';
+    layer?: string;
+    path?: string;
+    message: string;
+}
+export interface CodesddFoundationLayerValidationReport {
+    valid: boolean;
+    findings: CodesddFoundationLayerFinding[];
+}
+export declare const CODESDD_FOUNDATION_LAYER_MANIFEST: readonly CodesddFoundationLayerMapping[];
+export declare function listCodesddFoundationLayerRoots(manifest?: readonly CodesddFoundationLayerMapping[]): string[];
+export declare function validateCodesddFoundationLayerManifest(manifest?: readonly CodesddFoundationLayerMapping[]): CodesddFoundationLayerValidationReport;
+//# sourceMappingURL=foundation-layer-manifest.d.ts.map

package/dist/core/sdd/foundation-layer-manifest.js

@@ -0,0 +1,117 @@
+export const CODESDD_FOUNDATION_LAYER_IDS = [
+    'domains',
+    'applications',
+    'infrastructures',
+    'presentations',
+    'shared',
+];
+export const CODESDD_FOUNDATION_LAYER_MANIFEST = [
+    {
+        layer: 'domains',
+        root: 'src/domains',
+        entrypoint: 'src/domains/sdd/index.ts',
+        legacy_roots: ['src/core/sdd/domain'],
+        role: 'Pure CodeSDD lifecycle, traceability, title, transition, and guardrail domain rules.',
+        migration_status: 'active-facade',
+    },
+    {
+        layer: 'applications',
+        root: 'src/applications',
+        entrypoint: 'src/applications/sdd/index.ts',
+        legacy_roots: ['src/core/sdd/services'],
+        role: 'Use-case and orchestration services for CodeSDD lifecycle and command workflows.',
+        migration_status: 'active-facade',
+    },
+    {
+        layer: 'infrastructures',
+        root: 'src/infrastructures',
+        entrypoint: 'src/infrastructures/sdd/index.ts',
+        legacy_roots: ['src/core/sdd/store', 'src/core/sdd/coordination'],
+        role: 'Filesystem, YAML state, Redis, cache, lock, queue, and event adapters.',
+        migration_status: 'active-facade',
+    },
+    {
+        layer: 'presentations',
+        root: 'src/presentations',
+        entrypoint: 'src/presentations/cli/sdd/index.ts',
+        legacy_roots: ['src/commands', 'src/cli'],
+        role: 'CLI and operator-facing command surfaces.',
+        migration_status: 'active-facade',
+    },
+    {
+        layer: 'shared',
+        root: 'src/shared',
+        entrypoint: 'src/shared/sdd/index.ts',
+        legacy_roots: ['src/core/sdd/types.ts', 'src/core/sdd/workspace-schemas.ts', 'src/core/shared'],
+        role: 'Shared contracts, schema documents, and reusable utility boundaries.',
+        migration_status: 'active-facade',
+    },
+];
+export function listCodesddFoundationLayerRoots(manifest = CODESDD_FOUNDATION_LAYER_MANIFEST) {
+    return manifest.map((entry) => entry.root);
+}
+export function validateCodesddFoundationLayerManifest(manifest = CODESDD_FOUNDATION_LAYER_MANIFEST) {
+    const findings = [];
+    const seenLayers = new Set();
+    const seenRoots = new Set();
+    for (const layer of CODESDD_FOUNDATION_LAYER_IDS) {
+        if (!manifest.some((entry) => entry.layer === layer)) {
+            findings.push({
+                code: 'FOUNDATION_LAYER_MISSING',
+                layer,
+                message: `Foundation-like layer ${layer} must be declared.`,
+            });
+        }
+    }
+    for (const entry of manifest) {
+        if (seenLayers.has(entry.layer)) {
+            findings.push({
+                code: 'FOUNDATION_LAYER_DUPLICATE',
+                layer: entry.layer,
+                message: `Foundation-like layer ${entry.layer} is declared more than once.`,
+            });
+        }
+        seenLayers.add(entry.layer);
+        if (seenRoots.has(entry.root)) {
+            findings.push({
+                code: 'FOUNDATION_LAYER_DUPLICATE',
+                layer: entry.layer,
+                path: entry.root,
+                message: `Foundation-like root ${entry.root} is declared more than once.`,
+            });
+        }
+        seenRoots.add(entry.root);
+        const expectedRoot = `src/${entry.layer}`;
+        if (entry.root !== expectedRoot) {
+            findings.push({
+                code: 'FOUNDATION_LAYER_ROOT_MISMATCH',
+                layer: entry.layer,
+                path: entry.root,
+                message: `Layer ${entry.layer} must use plural root ${expectedRoot}.`,
+            });
+        }
+        if (!entry.entrypoint.startsWith(`${entry.root}/`)) {
+            findings.push({
+                code: 'FOUNDATION_LAYER_ENTRYPOINT_MISMATCH',
+                layer: entry.layer,
+                path: entry.entrypoint,
+                message: `Layer ${entry.layer} entrypoint must live under ${entry.root}.`,
+            });
+        }
+        for (const legacyRoot of entry.legacy_roots) {
+            if (legacyRoot.includes('/.codesdd') || legacyRoot.startsWith('.codesdd')) {
+                findings.push({
+                    code: 'FOUNDATION_LAYER_FORBIDDEN_PROJECT_RUNTIME',
+                    layer: entry.layer,
+                    path: legacyRoot,
+                    message: 'Foundation-like layer mappings must not use project-local .codesdd runtime paths.',
+                });
+            }
+        }
+    }
+    return {
+        valid: findings.length === 0,
+        findings,
+    };
+}
+//# sourceMappingURL=foundation-layer-manifest.js.map

package/dist/core/sdd/governance-backfill.d.ts

@@ -0,0 +1,31 @@
+type BackfillScope = 'discovery' | 'adr';
+export interface GovernanceBackfillException {
+    scope: BackfillScope;
+    file: string;
+    id: string;
+    reason: string;
+    severity: 'warning' | 'skipped';
+}
+export interface GovernanceBackfillBucket {
+    inspected: number;
+    updated: number;
+    skipped: number;
+    exceptions: GovernanceBackfillException[];
+}
+export interface GovernanceBackfillReport {
+    generated_at: string;
+    write: boolean;
+    discovery: GovernanceBackfillBucket;
+    adr: GovernanceBackfillBucket;
+}
+export interface GovernanceBackfillOptions {
+    projectRoot: string;
+    discovery?: boolean;
+    adr?: boolean;
+    write?: boolean;
+    reportPath?: string;
+    nowIso?: string;
+}
+export declare function backfillGovernanceFrontmatter(options: GovernanceBackfillOptions): Promise<GovernanceBackfillReport>;
+export {};
+//# sourceMappingURL=governance-backfill.d.ts.map