@devtrack-solution/codesdd 1.2.3 → 1.2.4

package/dist/core/sdd/domain/capability-diff.js

@@ -0,0 +1,200 @@
+import { createHash } from 'node:crypto';
+export const CAPABILITY_KINDS = [
+    'route',
+    'page',
+    'cli_command',
+    'public_contract',
+    'schema',
+    'event',
+    'core_flow',
+    'governance_state',
+];
+export const CAPABILITY_CHANGE_TYPES = ['added', 'removed', 'modified', 'unchanged'];
+export const CAPABILITY_RISK_LEVELS = ['none', 'low', 'medium', 'high', 'critical'];
+const PUBLIC_SURFACE_KINDS = new Set([
+    'route',
+    'page',
+    'cli_command',
+    'public_contract',
+    'schema',
+    'event',
+]);
+const CRITICAL_KIND_WEIGHTS = new Map([
+    ['core_flow', 'critical'],
+    ['governance_state', 'critical'],
+]);
+const RISK_SCORE = {
+    none: 0,
+    low: 25,
+    medium: 50,
+    high: 75,
+    critical: 100,
+};
+export function buildCapabilityInventory(items) {
+    return {
+        schema_version: 1,
+        contract: 'capability-inventory/v1',
+        items: normalizeCapabilityItems(items),
+    };
+}
+export function diffCapabilityInventories(before, after) {
+    const beforeByKey = indexByCapabilityKey(before.items);
+    const afterByKey = indexByCapabilityKey(after.items);
+    const keys = [...new Set([...beforeByKey.keys(), ...afterByKey.keys()])].sort();
+    const entries = keys.map((key) => {
+        const beforeItem = beforeByKey.get(key);
+        const afterItem = afterByKey.get(key);
+        const item = afterItem ?? beforeItem;
+        if (!item) {
+            throw new Error(`Capability key ${key} resolved without an inventory item.`);
+        }
+        if (!beforeItem)
+            return { kind: item.kind, id: item.id, change: 'added', after: afterItem };
+        if (!afterItem)
+            return { kind: item.kind, id: item.id, change: 'removed', before: beforeItem };
+        if (beforeItem.fingerprint !== afterItem.fingerprint) {
+            return { kind: item.kind, id: item.id, change: 'modified', before: beforeItem, after: afterItem };
+        }
+        return { kind: item.kind, id: item.id, change: 'unchanged', before: beforeItem, after: afterItem };
+    });
+    return {
+        schema_version: 1,
+        contract: 'capability-diff-report/v1',
+        entries,
+        counts: countDiffEntries(entries),
+    };
+}
+export function scoreCapabilityDiffRisk(input) {
+    const signals = [];
+    const presentKinds = new Set(input.diff.entries.map((entry) => entry.kind));
+    for (const requiredKind of input.required_kinds ?? []) {
+        if (!presentKinds.has(requiredKind)) {
+            signals.push({
+                code: 'required_capability_inventory_missing',
+                level: CRITICAL_KIND_WEIGHTS.get(requiredKind) ?? 'high',
+                message: `Required capability inventory kind ${requiredKind} is missing from before/after diff evidence.`,
+                capability_ref: requiredKind,
+            });
+        }
+    }
+    for (const entry of input.diff.entries) {
+        if (entry.change === 'removed') {
+            signals.push(riskForRemovedCapability(entry));
+        }
+        if (entry.change === 'modified' && PUBLIC_SURFACE_KINDS.has(entry.kind)) {
+            signals.push({
+                code: 'public_capability_modified',
+                level: 'medium',
+                message: `Public capability ${capabilityRef(entry)} changed.`,
+                capability_ref: capabilityRef(entry),
+                path: entry.after?.path ?? entry.before?.path,
+            });
+        }
+        if (entry.change === 'added' && PUBLIC_SURFACE_KINDS.has(entry.kind)) {
+            signals.push({
+                code: 'public_capability_added',
+                level: 'low',
+                message: `Public capability ${capabilityRef(entry)} was added.`,
+                capability_ref: capabilityRef(entry),
+                path: entry.after?.path,
+            });
+        }
+    }
+    if (input.change_safety?.status === 'blocked') {
+        signals.push(...input.change_safety.violations.map((violation) => ({
+            code: `change_safety_${violation.code}`,
+            level: 'critical',
+            message: violation.message,
+            path: violation.path,
+        })));
+    }
+    for (const plannedChange of input.planned_changes ?? []) {
+        if (plannedChange.operation === 'delete' || plannedChange.operation === 'rename' || plannedChange.operation === 'replace') {
+            signals.push({
+                code: 'destructive_planned_change',
+                level: 'high',
+                message: `Planned ${plannedChange.operation} change affects ${plannedChange.path}.`,
+                path: plannedChange.path,
+            });
+        }
+    }
+    const level = maxRiskLevel(signals.map((signal) => signal.level));
+    return {
+        schema_version: 1,
+        contract: 'deterministic-capability-risk/v1',
+        level,
+        score: RISK_SCORE[level],
+        signals: sortRiskSignals(signals),
+    };
+}
+export function capabilityKey(item) {
+    return `${item.kind}:${item.id}`;
+}
+function normalizeCapabilityItems(items) {
+    const byKey = new Map();
+    for (const item of items) {
+        const normalized = {
+            kind: item.kind,
+            id: item.id.trim(),
+            path: item.path?.trim(),
+            metadata: item.metadata ?? {},
+            fingerprint: item.fingerprint ?? fingerprintCapabilityItem(item),
+        };
+        byKey.set(capabilityKey(normalized), normalized);
+    }
+    return [...byKey.values()].sort((left, right) => capabilityKey(left).localeCompare(capabilityKey(right)));
+}
+function fingerprintCapabilityItem(item) {
+    const stable = stableStringify({
+        kind: item.kind,
+        id: item.id.trim(),
+        path: item.path?.trim() ?? '',
+        metadata: item.metadata ?? {},
+    });
+    return createHash('sha256').update(stable).digest('hex');
+}
+function indexByCapabilityKey(items) {
+    return new Map(items.map((item) => [capabilityKey(item), item]));
+}
+function countDiffEntries(entries) {
+    return entries.reduce((counts, entry) => {
+        counts[entry.change] += 1;
+        return counts;
+    }, { added: 0, removed: 0, modified: 0, unchanged: 0 });
+}
+function riskForRemovedCapability(entry) {
+    const criticalLevel = CRITICAL_KIND_WEIGHTS.get(entry.kind);
+    const level = criticalLevel ?? (PUBLIC_SURFACE_KINDS.has(entry.kind) ? 'high' : 'medium');
+    return {
+        code: 'capability_removed',
+        level,
+        message: `Capability ${capabilityRef(entry)} was removed.`,
+        capability_ref: capabilityRef(entry),
+        path: entry.before?.path,
+    };
+}
+function capabilityRef(entry) {
+    return `${entry.kind}:${entry.id}`;
+}
+function maxRiskLevel(levels) {
+    if (levels.length === 0)
+        return 'none';
+    return levels.reduce((max, level) => (RISK_SCORE[level] > RISK_SCORE[max] ? level : max), 'none');
+}
+function sortRiskSignals(signals) {
+    return [...signals].sort((left, right) => RISK_SCORE[right.level] - RISK_SCORE[left.level] ||
+        left.code.localeCompare(right.code) ||
+        (left.capability_ref ?? '').localeCompare(right.capability_ref ?? '') ||
+        (left.path ?? '').localeCompare(right.path ?? ''));
+}
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableStringify(entry)).join(',')}]`;
+    }
+    if (value && typeof value === 'object') {
+        const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right));
+        return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${stableStringify(entry)}`).join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+//# sourceMappingURL=capability-diff.js.map

package/dist/core/sdd/domain/change-safety-guardrails.d.ts

@@ -0,0 +1,74 @@
+export declare const CHANGE_SAFETY_OPERATIONS: readonly ["add", "modify", "remove", "replace", "refactor", "optimize"];
+export type ChangeSafetyOperation = (typeof CHANGE_SAFETY_OPERATIONS)[number];
+export type PlannedFileOperation = 'create' | 'modify' | 'delete' | 'rename' | 'replace';
+export interface ExplicitModificationIntent {
+    operation?: string;
+}
+export interface ContextLock {
+    allowed_paths?: string[];
+    forbidden_paths?: string[];
+    protected_core?: string[];
+}
+export interface ChangeBudget {
+    max_files_changed?: number;
+    max_new_files?: number;
+    max_deleted_files?: number;
+}
+export interface GovernedOverride {
+    feature_id?: string;
+    intent?: string;
+    rationale?: string;
+    write_scope?: string[];
+    expected_deletions?: string[];
+    rollback_plan?: string;
+    compensating_control?: string;
+    approver?: string;
+    expires_at?: string;
+}
+export interface PlannedFileChange {
+    path: string;
+    operation: PlannedFileOperation;
+    previous_path?: string;
+}
+export interface ChangeSafetyContract {
+    explicit_modification_intent?: ExplicitModificationIntent;
+    intent?: ExplicitModificationIntent;
+    context_lock?: ContextLock;
+    change_budget?: ChangeBudget;
+    governed_override?: GovernedOverride;
+}
+export type ChangeSafetyViolationCode = 'planned_changes_missing' | 'intent_missing' | 'intent_invalid' | 'add_intent_destructive_change' | 'context_lock_outside_allowed_paths' | 'context_lock_forbidden_path' | 'protected_core_change' | 'change_budget_files_exceeded' | 'change_budget_new_files_exceeded' | 'change_budget_deleted_files_exceeded' | 'governed_override_required' | 'governed_override_field_missing' | 'governed_override_feature_mismatch' | 'governed_override_intent_mismatch' | 'governed_override_expires_at_invalid' | 'governed_override_expired' | 'governed_override_scope_mismatch' | 'governed_override_deletions_mismatch';
+export interface ChangeSafetyViolation {
+    code: ChangeSafetyViolationCode;
+    message: string;
+    path?: string;
+    limit?: number;
+    actual?: number;
+}
+export interface ChangeSafetyCounts {
+    files_changed: number;
+    new_files: number;
+    deleted_files: number;
+}
+export interface ChangeSafetyEvaluation {
+    status: 'allowed' | 'blocked';
+    operation: ChangeSafetyOperation | '';
+    violations: ChangeSafetyViolation[];
+    counts: ChangeSafetyCounts;
+    governed_override: GovernedOverrideEvaluation;
+}
+export interface ChangeSafetyEvaluationOptions {
+    feature_id?: string;
+    now?: Date | string;
+}
+export interface GovernedOverrideEvaluation {
+    required: boolean;
+    status: 'not_required' | 'valid' | 'invalid';
+    violations: ChangeSafetyViolation[];
+}
+export declare function isChangeSafetyOperation(value: string | undefined): value is ChangeSafetyOperation;
+export declare function evaluateChangeSafety(contract: ChangeSafetyContract, plannedChanges: PlannedFileChange[], options?: ChangeSafetyEvaluationOptions): ChangeSafetyEvaluation;
+export declare function countPlannedChanges(plannedChanges: PlannedFileChange[]): ChangeSafetyCounts;
+export declare function normalizeProjectPath(value: string): string;
+export declare function pathMatchesPattern(candidatePath: string, pattern: string): boolean;
+//# sourceMappingURL=change-safety-guardrails.d.ts.map

package/dist/core/sdd/domain/change-safety-guardrails.js

@@ -0,0 +1,333 @@
+export const CHANGE_SAFETY_OPERATIONS = ['add', 'modify', 'remove', 'replace', 'refactor', 'optimize'];
+const DESTRUCTIVE_ADD_OPERATIONS = new Set(['delete', 'replace', 'rename']);
+const GOVERNED_OVERRIDE_REQUIRED_FIELDS = [
+    'feature_id',
+    'intent',
+    'rationale',
+    'rollback_plan',
+    'compensating_control',
+    'approver',
+    'expires_at',
+];
+export function isChangeSafetyOperation(value) {
+    return CHANGE_SAFETY_OPERATIONS.includes(value);
+}
+export function evaluateChangeSafety(contract, plannedChanges, options = {}) {
+    const violations = [];
+    const operation = contract.explicit_modification_intent?.operation ?? contract.intent?.operation;
+    if (plannedChanges.length === 0) {
+        violations.push({
+            code: 'planned_changes_missing',
+            message: 'Mutating change requires at least one planned file change.',
+        });
+    }
+    if (!operation) {
+        violations.push({
+            code: 'intent_missing',
+            message: 'Mutating change requires explicit_modification_intent.operation.',
+        });
+    }
+    else if (!isChangeSafetyOperation(operation)) {
+        violations.push({
+            code: 'intent_invalid',
+            message: `Invalid explicit_modification_intent.operation "${operation}".`,
+        });
+    }
+    const normalizedOperation = isChangeSafetyOperation(operation) ? operation : '';
+    const contextLock = contract.context_lock ?? {};
+    const governedOverride = evaluateGovernedOverride(contract, plannedChanges, normalizedOperation, options);
+    violations.push(...governedOverride.violations);
+    const hasValidGovernedOverride = governedOverride.status === 'valid';
+    for (const change of plannedChanges) {
+        const normalizedPath = normalizeProjectPath(change.path);
+        const previousPath = change.previous_path ? normalizeProjectPath(change.previous_path) : '';
+        const pathsToCheck = previousPath ? [normalizedPath, previousPath] : [normalizedPath];
+        if (normalizedOperation === 'add' && DESTRUCTIVE_ADD_OPERATIONS.has(change.operation)) {
+            violations.push({
+                code: 'add_intent_destructive_change',
+                message: '`operation: add` cannot delete, rename, or replace existing files.',
+                path: normalizedPath,
+            });
+        }
+        for (const candidatePath of pathsToCheck) {
+            if (isOutsideAllowedPaths(candidatePath, contextLock.allowed_paths)) {
+                violations.push({
+                    code: 'context_lock_outside_allowed_paths',
+                    message: `Path "${candidatePath}" is outside context_lock.allowed_paths.`,
+                    path: candidatePath,
+                });
+            }
+            if (matchesAnyPattern(candidatePath, contextLock.forbidden_paths)) {
+                violations.push({
+                    code: 'context_lock_forbidden_path',
+                    message: `Path "${candidatePath}" matches context_lock.forbidden_paths.`,
+                    path: candidatePath,
+                });
+            }
+            if (matchesAnyPattern(candidatePath, contextLock.protected_core) && !hasValidGovernedOverride) {
+                violations.push({
+                    code: 'protected_core_change',
+                    message: `Path "${candidatePath}" matches context_lock.protected_core and requires explicit override.`,
+                    path: candidatePath,
+                });
+            }
+        }
+    }
+    const counts = countPlannedChanges(plannedChanges);
+    violations.push(...evaluateChangeBudget(contract.change_budget, counts));
+    return {
+        status: violations.length > 0 ? 'blocked' : 'allowed',
+        operation: normalizedOperation,
+        violations,
+        counts,
+        governed_override: governedOverride,
+    };
+}
+export function countPlannedChanges(plannedChanges) {
+    const changedPaths = new Set();
+    let newFiles = 0;
+    let deletedFiles = 0;
+    for (const change of plannedChanges) {
+        changedPaths.add(normalizeProjectPath(change.path));
+        if (change.previous_path) {
+            changedPaths.add(normalizeProjectPath(change.previous_path));
+        }
+        if (change.operation === 'create') {
+            newFiles += 1;
+        }
+        if (change.operation === 'delete' || change.operation === 'replace') {
+            deletedFiles += 1;
+        }
+        if (change.operation === 'rename') {
+            newFiles += 1;
+            deletedFiles += 1;
+        }
+    }
+    return {
+        files_changed: changedPaths.size,
+        new_files: newFiles,
+        deleted_files: deletedFiles,
+    };
+}
+export function normalizeProjectPath(value) {
+    return value
+        .replace(/\\/g, '/')
+        .replace(/^\.\/+/, '')
+        .split('/')
+        .filter((segment) => segment.length > 0 && segment !== '.')
+        .join('/');
+}
+function evaluateGovernedOverride(contract, plannedChanges, operation, options) {
+    const requiredPaths = collectGovernedOverrideRequiredPaths(contract.context_lock, plannedChanges);
+    if (requiredPaths.length === 0) {
+        return {
+            required: false,
+            status: 'not_required',
+            violations: [],
+        };
+    }
+    const override = contract.governed_override;
+    if (!override) {
+        return {
+            required: true,
+            status: 'invalid',
+            violations: [
+                {
+                    code: 'governed_override_required',
+                    message: 'Replacement or protected-core change requires change_safety.governed_override.',
+                },
+            ],
+        };
+    }
+    const violations = [];
+    for (const field of GOVERNED_OVERRIDE_REQUIRED_FIELDS) {
+        if (!isNonEmptyString(override[field])) {
+            violations.push({
+                code: 'governed_override_field_missing',
+                message: `change_safety.governed_override.${field} is required.`,
+            });
+        }
+    }
+    if (!Array.isArray(override.write_scope) || override.write_scope.length === 0) {
+        violations.push({
+            code: 'governed_override_field_missing',
+            message: 'change_safety.governed_override.write_scope must include at least one path pattern.',
+        });
+    }
+    if (!Array.isArray(override.expected_deletions)) {
+        violations.push({
+            code: 'governed_override_field_missing',
+            message: 'change_safety.governed_override.expected_deletions must be declared.',
+        });
+    }
+    if (options.feature_id && override.feature_id && override.feature_id !== options.feature_id) {
+        violations.push({
+            code: 'governed_override_feature_mismatch',
+            message: `change_safety.governed_override.feature_id "${override.feature_id}" does not match "${options.feature_id}".`,
+        });
+    }
+    if (operation && override.intent && override.intent !== operation) {
+        violations.push({
+            code: 'governed_override_intent_mismatch',
+            message: `change_safety.governed_override.intent "${override.intent}" does not match explicit intent "${operation}".`,
+        });
+    }
+    violations.push(...evaluateOverrideExpiration(override.expires_at, options.now));
+    const writeScope = override.write_scope ?? [];
+    for (const candidatePath of requiredPaths) {
+        if (!matchesAnyPattern(candidatePath, writeScope)) {
+            violations.push({
+                code: 'governed_override_scope_mismatch',
+                message: `Path "${candidatePath}" is outside change_safety.governed_override.write_scope.`,
+                path: candidatePath,
+            });
+        }
+    }
+    const expectedDeletions = override.expected_deletions;
+    if (Array.isArray(expectedDeletions)) {
+        const actualDeletions = collectDestructivePaths(plannedChanges);
+        const declaredDeletions = normalizeSortedUnique(expectedDeletions);
+        if (!sameStringList(actualDeletions, declaredDeletions)) {
+            violations.push({
+                code: 'governed_override_deletions_mismatch',
+                message: `change_safety.governed_override.expected_deletions must match planned destructive paths. Expected ${JSON.stringify(actualDeletions)}, received ${JSON.stringify(declaredDeletions)}.`,
+            });
+        }
+    }
+    return {
+        required: true,
+        status: violations.length === 0 ? 'valid' : 'invalid',
+        violations,
+    };
+}
+function collectGovernedOverrideRequiredPaths(contextLock, plannedChanges) {
+    const required = new Set();
+    for (const change of plannedChanges) {
+        const affectedPaths = getAffectedPaths(change);
+        if (change.operation === 'replace') {
+            affectedPaths.forEach((path) => required.add(path));
+        }
+        for (const candidatePath of affectedPaths) {
+            if (matchesAnyPattern(candidatePath, contextLock?.protected_core)) {
+                required.add(candidatePath);
+            }
+        }
+    }
+    return [...required].sort();
+}
+function collectDestructivePaths(plannedChanges) {
+    const paths = new Set();
+    for (const change of plannedChanges) {
+        if (change.operation === 'delete' || change.operation === 'replace') {
+            paths.add(normalizeProjectPath(change.path));
+        }
+        if (change.operation === 'rename') {
+            paths.add(normalizeProjectPath(change.previous_path ?? change.path));
+        }
+    }
+    return [...paths].sort();
+}
+function getAffectedPaths(change) {
+    const paths = [normalizeProjectPath(change.path)];
+    if (change.previous_path) {
+        paths.push(normalizeProjectPath(change.previous_path));
+    }
+    return paths;
+}
+function evaluateOverrideExpiration(expiresAt, now) {
+    if (!expiresAt)
+        return [];
+    const expiresAtMs = Date.parse(expiresAt);
+    if (!Number.isFinite(expiresAtMs)) {
+        return [
+            {
+                code: 'governed_override_expires_at_invalid',
+                message: 'change_safety.governed_override.expires_at must be a valid ISO timestamp.',
+            },
+        ];
+    }
+    const nowMs = now ? new Date(now).getTime() : Date.now();
+    if (expiresAtMs <= nowMs) {
+        return [
+            {
+                code: 'governed_override_expired',
+                message: 'change_safety.governed_override.expires_at has expired.',
+            },
+        ];
+    }
+    return [];
+}
+function normalizeSortedUnique(values) {
+    return [...new Set(values.map(normalizeProjectPath))].sort();
+}
+function sameStringList(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function evaluateChangeBudget(budget, counts) {
+    if (!budget)
+        return [];
+    const violations = [];
+    if (exceedsBudget(counts.files_changed, budget.max_files_changed)) {
+        violations.push({
+            code: 'change_budget_files_exceeded',
+            message: `Changed files count ${counts.files_changed} exceeds change_budget.max_files_changed ${budget.max_files_changed}.`,
+            limit: budget.max_files_changed,
+            actual: counts.files_changed,
+        });
+    }
+    if (exceedsBudget(counts.new_files, budget.max_new_files)) {
+        violations.push({
+            code: 'change_budget_new_files_exceeded',
+            message: `New files count ${counts.new_files} exceeds change_budget.max_new_files ${budget.max_new_files}.`,
+            limit: budget.max_new_files,
+            actual: counts.new_files,
+        });
+    }
+    if (exceedsBudget(counts.deleted_files, budget.max_deleted_files)) {
+        violations.push({
+            code: 'change_budget_deleted_files_exceeded',
+            message: `Deleted files count ${counts.deleted_files} exceeds change_budget.max_deleted_files ${budget.max_deleted_files}.`,
+            limit: budget.max_deleted_files,
+            actual: counts.deleted_files,
+        });
+    }
+    return violations;
+}
+function exceedsBudget(actual, limit) {
+    return typeof limit === 'number' && actual > limit;
+}
+function isOutsideAllowedPaths(candidatePath, allowedPatterns) {
+    if (!allowedPatterns || allowedPatterns.length === 0)
+        return false;
+    return !matchesAnyPattern(candidatePath, allowedPatterns);
+}
+function matchesAnyPattern(candidatePath, patterns) {
+    if (!patterns || patterns.length === 0)
+        return false;
+    return patterns.some((pattern) => pathMatchesPattern(candidatePath, pattern));
+}
+export function pathMatchesPattern(candidatePath, pattern) {
+    const normalizedPath = normalizeProjectPath(candidatePath);
+    const exactDirectory = /[\\/]$/.test(pattern);
+    const normalizedPattern = normalizeProjectPath(pattern);
+    if (!normalizedPattern)
+        return false;
+    if (exactDirectory) {
+        return normalizedPath === normalizedPattern || normalizedPath.startsWith(`${normalizedPattern}/`);
+    }
+    const regex = globToRegExp(normalizedPattern);
+    return regex.test(normalizedPath);
+}
+function globToRegExp(pattern) {
+    const placeholder = '\u0000';
+    const escaped = pattern
+        .split('**')
+        .map((part) => part.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '[^/]*'))
+        .join(placeholder);
+    const source = escaped.replaceAll(placeholder, '.*');
+    return new RegExp(`^${source}$`);
+}
+//# sourceMappingURL=change-safety-guardrails.js.map

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