@ai-sdlc/orchestrator 0.6.0 → 0.9.0

package/dist/design-quality-trend.d.ts

@@ -0,0 +1,87 @@
+/**
+ * DesignQualityTrendDegrading detector (RFC-0008 Addendum A §A.8).
+ *
+ * Periodic monitor that analyses rolling windows over
+ * `code_area_metrics` (designMetricsJson) and `token_compliance_history`
+ * to catch degradation *before* it shows up in the admission hot path
+ * via the C3 defect-risk factor. Emits one event per code area on
+ * first detection and is hysteretic — does not re-fire until recovery.
+ */
+import type { DesignSystemBinding } from '@ai-sdlc/reference';
+import type { StateStore } from './state/store.js';
+import type { CodeAreaMetricsRecord, TokenComplianceRecord } from './state/types.js';
+export interface TrendAnalysisConfig {
+    /** Minimum number of data points in the recent window. */
+    windowPrs: number;
+    /** Maximum age of measurements to include (days). */
+    windowDays: number;
+    /** Drop in designCIPassRate (absolute) that triggers the condition. */
+    ciDropThreshold: number;
+    /** Rise in designReviewRejectionRate (absolute) that triggers. */
+    reviewIncreaseThreshold: number;
+    /** Minimum consecutive 'declining' compliance trends to trigger. */
+    consecutiveNegativeCompliance: number;
+}
+export declare const DEFAULT_TREND_CONFIG: TrendAnalysisConfig;
+export type TrendCondition = 'designCIPassRate' | 'designReviewRejectionRate' | 'tokenComplianceTrend';
+/**
+ * Partition the history into `recent` (newest `windowPrs` records or
+ * anything inside `windowDays`) and `baseline` (everything older). The
+ * recent window fills by whichever bound hits first — that gives us a
+ * consistent signal whether activity is sparse or bursty.
+ *
+ * History is assumed to be in descending `computed_at` order (as returned
+ * by `getCodeAreaMetricsHistory`).
+ */
+export declare function splitHistoryByWindow<T extends {
+    computedAt?: string;
+}>(history: readonly T[], config: Pick<TrendAnalysisConfig, 'windowPrs' | 'windowDays'>, nowMs: number): {
+    recent: T[];
+    baseline: T[];
+};
+export interface ConditionEvaluation {
+    triggered: boolean;
+    recentValue?: number;
+    baselineValue?: number;
+    delta?: number;
+}
+export declare function evaluateCiPassRate(recent: readonly CodeAreaMetricsRecord[], baseline: readonly CodeAreaMetricsRecord[], threshold: number): ConditionEvaluation;
+export declare function evaluateReviewRejectionRate(recent: readonly CodeAreaMetricsRecord[], baseline: readonly CodeAreaMetricsRecord[], threshold: number): ConditionEvaluation;
+export declare function evaluateTokenComplianceTrend(history: readonly TokenComplianceRecord[], minConsecutive: number): ConditionEvaluation;
+export interface TrendAnalysisResult {
+    codeArea: string;
+    triggered: boolean;
+    conditions: Partial<Record<TrendCondition, ConditionEvaluation>>;
+}
+export declare function analyzeTrend(codeArea: string, codeAreaHistory: readonly CodeAreaMetricsRecord[], tokenComplianceHistory: readonly TokenComplianceRecord[], nowMs: number, overrides?: Partial<TrendAnalysisConfig>): TrendAnalysisResult;
+export interface DesignQualityTrendDegradingEvent {
+    type: 'DesignQualityTrendDegrading';
+    codeArea: string;
+    bindingName?: string;
+    triggeredAt: string;
+    triggeredConditions: TrendCondition[];
+    conditions: TrendAnalysisResult['conditions'];
+    notifiedPrincipals: string[];
+    issueBodyMarkdown: string;
+}
+export interface DesignQualityTrendDetectorDeps {
+    stateStore: StateStore;
+    /** Resolve a code area to its owning DSB, if any. */
+    getBindingForCodeArea?: (codeArea: string) => DesignSystemBinding | undefined;
+    /** Timestamp of the last emission for this area (hysteresis state). */
+    getLastTriggerAt?: (codeArea: string) => string | undefined;
+    /** Required quiet window (ms) with no trigger before re-firing. */
+    hysteresisRecoveryMs?: number;
+    /** Clock injection (defaults to `Date.now`). */
+    now?: () => number;
+    /** Partial config override. */
+    config?: Partial<TrendAnalysisConfig>;
+}
+/**
+ * Run the trend analysis for one code area. Returns an event when the
+ * trend is currently degrading AND the hysteresis quiet window has
+ * elapsed since the last trigger (or no prior trigger). Returns
+ * undefined otherwise.
+ */
+export declare function detectDesignQualityTrendDegrading(codeArea: string, deps: DesignQualityTrendDetectorDeps): DesignQualityTrendDegradingEvent | undefined;
+//# sourceMappingURL=design-quality-trend.d.ts.map

package/dist/design-quality-trend.js

@@ -0,0 +1,190 @@
+/**
+ * DesignQualityTrendDegrading detector (RFC-0008 Addendum A §A.8).
+ *
+ * Periodic monitor that analyses rolling windows over
+ * `code_area_metrics` (designMetricsJson) and `token_compliance_history`
+ * to catch degradation *before* it shows up in the admission hot path
+ * via the C3 defect-risk factor. Emits one event per code area on
+ * first detection and is hysteretic — does not re-fire until recovery.
+ */
+export const DEFAULT_TREND_CONFIG = {
+    windowPrs: 10,
+    windowDays: 30,
+    ciDropThreshold: 0.15,
+    reviewIncreaseThreshold: 0.2,
+    consecutiveNegativeCompliance: 5,
+};
+function parseDesignMetrics(json) {
+    if (!json)
+        return undefined;
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return undefined;
+    }
+}
+// ── Window selection ───────────────────────────────────────────────────
+/**
+ * Partition the history into `recent` (newest `windowPrs` records or
+ * anything inside `windowDays`) and `baseline` (everything older). The
+ * recent window fills by whichever bound hits first — that gives us a
+ * consistent signal whether activity is sparse or bursty.
+ *
+ * History is assumed to be in descending `computed_at` order (as returned
+ * by `getCodeAreaMetricsHistory`).
+ */
+export function splitHistoryByWindow(history, config, nowMs) {
+    const cutoffMs = nowMs - config.windowDays * 24 * 60 * 60 * 1000;
+    const recent = [];
+    for (const row of history) {
+        if (recent.length >= config.windowPrs)
+            break;
+        const ts = row.computedAt ? Date.parse(row.computedAt) : NaN;
+        if (Number.isNaN(ts))
+            continue;
+        if (ts < cutoffMs)
+            break;
+        recent.push(row);
+    }
+    const baseline = history.slice(recent.length);
+    return { recent, baseline };
+}
+export function evaluateCiPassRate(recent, baseline, threshold) {
+    const recentMean = meanDesignMetric(recent, 'designCIPassRate');
+    const baselineMean = meanDesignMetric(baseline, 'designCIPassRate');
+    if (recentMean === undefined || baselineMean === undefined) {
+        return { triggered: false };
+    }
+    const delta = baselineMean - recentMean; // positive ⇒ dropped
+    return {
+        triggered: delta >= threshold,
+        recentValue: recentMean,
+        baselineValue: baselineMean,
+        delta,
+    };
+}
+export function evaluateReviewRejectionRate(recent, baseline, threshold) {
+    const recentMean = meanDesignMetric(recent, 'designReviewRejectionRate');
+    const baselineMean = meanDesignMetric(baseline, 'designReviewRejectionRate');
+    if (recentMean === undefined || baselineMean === undefined) {
+        return { triggered: false };
+    }
+    const delta = recentMean - baselineMean; // positive ⇒ rejections rising
+    return {
+        triggered: delta >= threshold,
+        recentValue: recentMean,
+        baselineValue: baselineMean,
+        delta,
+    };
+}
+export function evaluateTokenComplianceTrend(history, minConsecutive) {
+    // history is descending (newest first). Walk newest→oldest, counting
+    // a run of declining coverages.
+    let streak = 0;
+    for (let i = 0; i < history.length - 1; i++) {
+        if (history[i].coveragePercent < history[i + 1].coveragePercent)
+            streak++;
+        else
+            break;
+    }
+    return {
+        triggered: streak >= minConsecutive,
+        recentValue: streak,
+    };
+}
+function meanDesignMetric(rows, key) {
+    const values = [];
+    for (const row of rows) {
+        const blob = parseDesignMetrics(row.designMetricsJson);
+        const value = blob?.[key];
+        if (typeof value === 'number' && !Number.isNaN(value))
+            values.push(value);
+    }
+    if (values.length === 0)
+        return undefined;
+    return values.reduce((a, b) => a + b, 0) / values.length;
+}
+export function analyzeTrend(codeArea, codeAreaHistory, tokenComplianceHistory, nowMs, overrides = {}) {
+    const config = { ...DEFAULT_TREND_CONFIG, ...overrides };
+    const { recent, baseline } = splitHistoryByWindow(codeAreaHistory, config, nowMs);
+    const ci = evaluateCiPassRate(recent, baseline, config.ciDropThreshold);
+    const review = evaluateReviewRejectionRate(recent, baseline, config.reviewIncreaseThreshold);
+    const compliance = evaluateTokenComplianceTrend(tokenComplianceHistory, config.consecutiveNegativeCompliance);
+    const conditions = {};
+    if (ci.triggered)
+        conditions.designCIPassRate = ci;
+    if (review.triggered)
+        conditions.designReviewRejectionRate = review;
+    if (compliance.triggered)
+        conditions.tokenComplianceTrend = compliance;
+    return {
+        codeArea,
+        triggered: Object.keys(conditions).length > 0,
+        conditions,
+    };
+}
+/**
+ * Run the trend analysis for one code area. Returns an event when the
+ * trend is currently degrading AND the hysteresis quiet window has
+ * elapsed since the last trigger (or no prior trigger). Returns
+ * undefined otherwise.
+ */
+export function detectDesignQualityTrendDegrading(codeArea, deps) {
+    const nowMs = (deps.now ?? (() => Date.now()))();
+    // Hysteresis: skip if we've emitted recently within the recovery window.
+    const lastTriggerAt = deps.getLastTriggerAt?.(codeArea);
+    if (lastTriggerAt) {
+        const lastMs = Date.parse(lastTriggerAt);
+        const recoveryMs = deps.hysteresisRecoveryMs ?? 7 * 24 * 60 * 60 * 1000; // 7d default
+        if (!Number.isNaN(lastMs) && nowMs - lastMs < recoveryMs)
+            return undefined;
+    }
+    const history = deps.stateStore.getCodeAreaMetricsHistory(codeArea, { limit: 100 });
+    const binding = deps.getBindingForCodeArea?.(codeArea);
+    const tokenHistory = binding
+        ? deps.stateStore.getTokenComplianceHistory(binding.metadata.name)
+        : [];
+    const result = analyzeTrend(codeArea, history, tokenHistory, nowMs, deps.config);
+    if (!result.triggered)
+        return undefined;
+    const principals = binding ? gatherPrincipals(binding) : [];
+    const triggeredConditions = Object.keys(result.conditions);
+    return {
+        type: 'DesignQualityTrendDegrading',
+        codeArea,
+        bindingName: binding?.metadata.name,
+        triggeredAt: new Date(nowMs).toISOString(),
+        triggeredConditions,
+        conditions: result.conditions,
+        notifiedPrincipals: principals,
+        issueBodyMarkdown: renderIssueBody(result, binding),
+    };
+}
+function gatherPrincipals(binding) {
+    const design = binding.spec.stewardship.designAuthority.principals;
+    const engineering = binding.spec.stewardship.engineeringAuthority.principals;
+    const unique = new Set([...design, ...engineering]);
+    return Array.from(unique);
+}
+function renderIssueBody(result, binding) {
+    const lines = [
+        `## DesignQualityTrendDegrading — ${result.codeArea}`,
+        '',
+        binding
+            ? `Linked DesignSystemBinding: **${binding.metadata.name}**`
+            : 'No linked DesignSystemBinding',
+        '',
+        '### Triggered conditions',
+        '',
+    ];
+    for (const [name, evaluation] of Object.entries(result.conditions)) {
+        const baseline = evaluation.baselineValue !== undefined ? evaluation.baselineValue.toFixed(3) : 'n/a';
+        const current = evaluation.recentValue !== undefined ? evaluation.recentValue.toFixed(3) : 'n/a';
+        const delta = evaluation.delta !== undefined ? evaluation.delta.toFixed(3) : 'n/a';
+        lines.push(`- **${name}** — baseline ${baseline}, recent ${current}, delta ${delta}`);
+    }
+    lines.push('', '---', 'Investigate the code area and file follow-up tasks as needed.');
+    return lines.join('\n');
+}
+//# sourceMappingURL=design-quality-trend.js.map

package/dist/design-system-context.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Context strategy selection for design-system-aware agents (RFC-0006 §7.2).
+ *
+ * Implements the 5-step decision tree that determines how much design
+ * system context an agent receives.
+ */
+import type { ContextStrategy, DesignSystemBinding } from '@ai-sdlc/reference';
+export interface TaskContext {
+    /** The trigger event type (e.g., 'design-token.changed', 'issue.assigned'). */
+    triggerEvent?: string;
+    /** Whether the task involves modifying existing components. */
+    modifiesComponents?: boolean;
+    /** Whether the task creates a new component. */
+    createsNewComponent?: boolean;
+    /** Whether the task involves both tokens AND component composition. */
+    touchesTokensAndComponents?: boolean;
+    /** Reusability score from the design-context stage (0.0-1.0). */
+    reusabilityScore?: number;
+}
+export interface ContextStrategyResult {
+    strategy: ContextStrategy;
+    reason: string;
+}
+/**
+ * Select the context strategy using the 5-step decision tree from RFC-0006 §7.2.
+ *
+ * 1. Token-change trigger with no component mods → tokens-only
+ * 2. Modifying/composing existing components → manifest-first
+ * 3. Creating new component → full
+ * 4. Both tokens AND composition → full
+ * 5. Reusability score < 0.5 → full
+ *
+ * Falls back to manifest-first as the default.
+ */
+export declare function selectContextStrategy(task: TaskContext, binding: DesignSystemBinding): ContextStrategyResult;
+/**
+ * Re-evaluate context strategy after scope change (RFC-0006 §7.2 bottom).
+ * Called after design impact review if the approved scope differs from
+ * the initial scope.
+ */
+export declare function reEvaluateStrategy(originalTask: TaskContext, updatedTask: TaskContext, binding: DesignSystemBinding): {
+    changed: boolean;
+    result: ContextStrategyResult;
+    reason?: string;
+};
+//# sourceMappingURL=design-system-context.d.ts.map

package/dist/design-system-context.js

@@ -0,0 +1,80 @@
+/**
+ * Context strategy selection for design-system-aware agents (RFC-0006 §7.2).
+ *
+ * Implements the 5-step decision tree that determines how much design
+ * system context an agent receives.
+ */
+/**
+ * Select the context strategy using the 5-step decision tree from RFC-0006 §7.2.
+ *
+ * 1. Token-change trigger with no component mods → tokens-only
+ * 2. Modifying/composing existing components → manifest-first
+ * 3. Creating new component → full
+ * 4. Both tokens AND composition → full
+ * 5. Reusability score < 0.5 → full
+ *
+ * Falls back to manifest-first as the default.
+ */
+export function selectContextStrategy(task, binding) {
+    const agentConfig = binding.spec;
+    // If contextStrategyOverride is 'fixed', use the declared strategy
+    if (agentConfig.designSystem?.contextStrategyOverride === 'fixed') {
+        const fixed = (agentConfig.designSystem?.contextStrategy ??
+            'manifest-first');
+        return { strategy: fixed, reason: 'Fixed strategy override — using declared contextStrategy' };
+    }
+    // Step 1: Token-change trigger with no component modifications
+    if (task.triggerEvent === 'design-token.changed' &&
+        !task.modifiesComponents &&
+        !task.createsNewComponent) {
+        return {
+            strategy: 'tokens-only',
+            reason: 'Token-change trigger with no component modifications',
+        };
+    }
+    // Step 2: Modifying/composing existing components only
+    if (task.modifiesComponents && !task.createsNewComponent && !task.touchesTokensAndComponents) {
+        return {
+            strategy: 'manifest-first',
+            reason: 'Modifying existing components — manifest sufficient',
+        };
+    }
+    // Step 3: Creating a new component
+    if (task.createsNewComponent) {
+        return { strategy: 'full', reason: 'New component creation requires full context' };
+    }
+    // Step 4: Both tokens AND component composition
+    if (task.touchesTokensAndComponents) {
+        return {
+            strategy: 'full',
+            reason: 'Task touches both tokens and components — escalating to full',
+        };
+    }
+    // Step 5: Low reusability score
+    if (task.reusabilityScore !== undefined && task.reusabilityScore < 0.5) {
+        return {
+            strategy: 'full',
+            reason: `Reusability score ${task.reusabilityScore} < 0.5 — catalog insufficient`,
+        };
+    }
+    // Default
+    return { strategy: 'manifest-first', reason: 'Default strategy' };
+}
+/**
+ * Re-evaluate context strategy after scope change (RFC-0006 §7.2 bottom).
+ * Called after design impact review if the approved scope differs from
+ * the initial scope.
+ */
+export function reEvaluateStrategy(originalTask, updatedTask, binding) {
+    const original = selectContextStrategy(originalTask, binding);
+    const updated = selectContextStrategy(updatedTask, binding);
+    if (original.strategy !== updated.strategy) {
+        return {
+            changed: true,
+            result: updated,
+            reason: 'scope-changed-at-impact-review',
+        };
+    }
+    return { changed: false, result: original };
+}
+//# sourceMappingURL=design-system-context.js.map

package/dist/design-system-correction-loop.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Autonomous correction loop for design system gates (RFC-0006 §8.4)
+ * and Design Review feedback pipeline (RFC-0006 §8.5).
+ */
+import type { VisualRegressionFailure } from '@ai-sdlc/reference';
+export interface CorrectionIteration {
+    attempt: number;
+    failures: VisualRegressionFailure[];
+    codeDiff?: string;
+    visualDiff?: string;
+    costUsd: number;
+    tokenReferencesChanged: boolean;
+    timestamp: string;
+}
+export interface CorrectionLoopConfig {
+    maxRetries: number;
+    costSoftLimitUsd: number;
+}
+export type CorrectionExitReason = 'max-retries' | 'token-reference-changed' | 'cost-limit-exceeded' | 'design-review-triggered' | 'success';
+export interface CorrectionLoopResult {
+    converged: boolean;
+    exitReason: CorrectionExitReason;
+    iterations: CorrectionIteration[];
+    totalCostUsd: number;
+}
+/**
+ * Check whether the correction loop should exit.
+ */
+export declare function checkExitConditions(iterations: CorrectionIteration[], config: CorrectionLoopConfig, designReviewTriggered: boolean): CorrectionExitReason | null;
+/**
+ * Run the autonomous correction loop.
+ *
+ * @param runAttempt - Function that executes the agent and returns failures + cost
+ * @param config - Loop configuration (maxRetries, cost limit)
+ * @param checkDesignReviewTrigger - Function that checks if design review conditions are met
+ */
+export declare function runCorrectionLoop(runAttempt: (failures: VisualRegressionFailure[], attempt: number) => Promise<{
+    failures: VisualRegressionFailure[];
+    costUsd: number;
+    tokenReferencesChanged: boolean;
+    codeDiff?: string;
+}>, config: CorrectionLoopConfig, checkDesignReviewTrigger?: () => boolean): Promise<CorrectionLoopResult>;
+export type FeedbackSignal = 'accepted' | 'dismissed' | 'overridden' | 'escalated';
+export interface FeedbackEntry {
+    prNumber: number;
+    category: string;
+    signal: FeedbackSignal;
+    reviewer: string;
+    comment?: string;
+    timestamp: string;
+}
+export interface CategoryAnalysis {
+    category: string;
+    dismissRate: number;
+}
+export interface DesignReviewFeedbackStore {
+    record(entry: FeedbackEntry): void;
+    precision(): number;
+    highFalsePositiveCategories(): CategoryAnalysis[];
+    falseNegativeCategories(): CategoryAnalysis[];
+    getEntries(): FeedbackEntry[];
+}
+export declare function createDesignReviewFeedbackStore(): DesignReviewFeedbackStore;
+//# sourceMappingURL=design-system-correction-loop.d.ts.map

package/dist/design-system-correction-loop.js

@@ -0,0 +1,128 @@
+/**
+ * Autonomous correction loop for design system gates (RFC-0006 §8.4)
+ * and Design Review feedback pipeline (RFC-0006 §8.5).
+ */
+/**
+ * Check whether the correction loop should exit.
+ */
+export function checkExitConditions(iterations, config, designReviewTriggered) {
+    // Condition 1: maxRetries reached
+    if (iterations.length >= config.maxRetries) {
+        return 'max-retries';
+    }
+    // Condition 2: agent changed a token reference
+    const last = iterations[iterations.length - 1];
+    if (last?.tokenReferencesChanged) {
+        return 'token-reference-changed';
+    }
+    // Condition 3: cumulative cost exceeds soft limit
+    const totalCost = iterations.reduce((sum, it) => sum + it.costUsd, 0);
+    if (totalCost >= config.costSoftLimitUsd) {
+        return 'cost-limit-exceeded';
+    }
+    // Condition 4: design review trigger conditions met
+    if (designReviewTriggered) {
+        return 'design-review-triggered';
+    }
+    return null;
+}
+/**
+ * Run the autonomous correction loop.
+ *
+ * @param runAttempt - Function that executes the agent and returns failures + cost
+ * @param config - Loop configuration (maxRetries, cost limit)
+ * @param checkDesignReviewTrigger - Function that checks if design review conditions are met
+ */
+export async function runCorrectionLoop(runAttempt, config, checkDesignReviewTrigger = () => false) {
+    const iterations = [];
+    let currentFailures = [];
+    for (let attempt = 0; attempt < config.maxRetries; attempt++) {
+        const result = await runAttempt(currentFailures, attempt);
+        iterations.push({
+            attempt,
+            failures: result.failures,
+            codeDiff: result.codeDiff,
+            costUsd: result.costUsd,
+            tokenReferencesChanged: result.tokenReferencesChanged,
+            timestamp: new Date().toISOString(),
+        });
+        // Check if converged (no more failures)
+        if (result.failures.length === 0) {
+            return {
+                converged: true,
+                exitReason: 'success',
+                iterations,
+                totalCostUsd: iterations.reduce((s, it) => s + it.costUsd, 0),
+            };
+        }
+        currentFailures = result.failures;
+        // Check exit conditions
+        const exitReason = checkExitConditions(iterations, config, checkDesignReviewTrigger());
+        if (exitReason) {
+            return {
+                converged: false,
+                exitReason,
+                iterations,
+                totalCostUsd: iterations.reduce((s, it) => s + it.costUsd, 0),
+            };
+        }
+    }
+    return {
+        converged: false,
+        exitReason: 'max-retries',
+        iterations,
+        totalCostUsd: iterations.reduce((s, it) => s + it.costUsd, 0),
+    };
+}
+export function createDesignReviewFeedbackStore() {
+    const entries = [];
+    return {
+        record(entry) {
+            entries.push(entry);
+        },
+        precision() {
+            const accepted = entries.filter((e) => e.signal === 'accepted').length;
+            const dismissed = entries.filter((e) => e.signal === 'dismissed').length;
+            const total = accepted + dismissed;
+            return total > 0 ? accepted / total : 1;
+        },
+        highFalsePositiveCategories() {
+            const categoryStats = new Map();
+            for (const entry of entries) {
+                const stats = categoryStats.get(entry.category) ?? { dismissed: 0, total: 0 };
+                stats.total++;
+                if (entry.signal === 'dismissed')
+                    stats.dismissed++;
+                categoryStats.set(entry.category, stats);
+            }
+            return [...categoryStats.entries()]
+                .map(([category, stats]) => ({
+                category,
+                dismissRate: stats.total > 0 ? stats.dismissed / stats.total : 0,
+            }))
+                .filter((c) => c.dismissRate > 0)
+                .sort((a, b) => b.dismissRate - a.dismissRate);
+        },
+        falseNegativeCategories() {
+            const categoryStats = new Map();
+            for (const entry of entries) {
+                const stats = categoryStats.get(entry.category) ?? { escalated: 0, total: 0 };
+                stats.total++;
+                if (entry.signal === 'escalated')
+                    stats.escalated++;
+                categoryStats.set(entry.category, stats);
+            }
+            return [...categoryStats.entries()]
+                .map(([category, stats]) => ({
+                category,
+                dismissRate: stats.total > 0 ? stats.escalated / stats.total : 0,
+            }))
+                .filter((c) => c.dismissRate > 0)
+                .sort((a, b) => b.dismissRate - a.dismissRate);
+        },
+        getEntries() {
+            return [...entries];
+        },
+    };
+}
+//# sourceMappingURL=design-system-correction-loop.js.map

package/dist/design-system-metrics.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Design system metrics for autonomy promotion/demotion (RFC-0006 §13.2, §A.10).
+ *
+ * Computes six design review metrics from state store data and integrates
+ * them into the autonomy evaluation system.
+ */
+import type { DesignReviewEventRecord, TokenComplianceRecord, VisualRegressionResultRecord, UsabilitySimulationResultRecord } from './state/types.js';
+export interface DesignMetrics {
+    /** Percentage of Design CI runs that pass on first attempt. */
+    designCiPassRate: number;
+    /** Percentage of usability simulations that complete successfully. */
+    usabilitySimulationPassRate: number;
+    /** Percentage of design reviews approved (any decision except rejected). */
+    designReviewApprovalRate: number;
+    /** Percentage of design reviews approved without any rejection cycle. */
+    designReviewFirstPassRate: number;
+    /** Percentage of Design CI failures auto-fixed by correction loop. */
+    designCiAutoFixRate: number;
+    /** Precision of usability findings (accepted / (accepted + dismissed)). */
+    usabilityFindingAccuracy: number;
+}
+/**
+ * Compute design review approval rate from review events.
+ */
+export declare function computeDesignReviewApprovalRate(events: DesignReviewEventRecord[]): number;
+/**
+ * Compute design review first-pass rate (approved without rejection cycles).
+ * Groups events by PR and checks if the first review for each PR was an approval.
+ */
+export declare function computeDesignReviewFirstPassRate(events: DesignReviewEventRecord[]): number;
+/**
+ * Compute usability simulation pass rate from simulation results.
+ */
+export declare function computeUsabilitySimulationPassRate(results: UsabilitySimulationResultRecord[]): number;
+/**
+ * Compute token compliance trend from compliance history.
+ */
+export declare function computeTokenComplianceTrend(history: TokenComplianceRecord[]): {
+    current: number;
+    trend: 'improving' | 'stable' | 'declining';
+};
+/**
+ * Compute visual regression pass rate from results.
+ */
+export declare function computeVisualRegressionPassRate(results: VisualRegressionResultRecord[]): number;
+/**
+ * Compute all six design metrics from state store data.
+ */
+export declare function computeDesignMetrics(data: {
+    reviewEvents: DesignReviewEventRecord[];
+    complianceHistory: TokenComplianceRecord[];
+    visualRegressionResults: VisualRegressionResultRecord[];
+    usabilitySimulationResults: UsabilitySimulationResultRecord[];
+    designCiPassCount?: number;
+    designCiTotalCount?: number;
+    designCiAutoFixCount?: number;
+    designCiFailCount?: number;
+    findingsAccepted?: number;
+    findingsDismissed?: number;
+}): DesignMetrics;
+//# sourceMappingURL=design-system-metrics.d.ts.map