@ai-sdlc/orchestrator 0.5.0 → 0.9.0

package/dist/design-authority.js

@@ -0,0 +1,71 @@
+/**
+ * C5 — Design authority signal detection (RFC-0008 §A.5).
+ *
+ * Determines whether the issue's author or any commenter is listed as a
+ * `designAuthority` principal on the resolved DesignSystemBinding, and
+ * parses the explicit signal type from issue labels (preferred) or
+ * structured comment markers.
+ */
+/**
+ * Label-encoded design signal types. Short, stable slugs keep GitHub
+ * label names readable; the map below converts them to the
+ * `DesignAuthoritySignalType` used downstream.
+ */
+const LABEL_TO_SIGNAL = Object.freeze({
+    'design/advances-coherence': 'advances-design-coherence',
+    'design/fills-gap': 'fills-catalog-gap',
+    'design/fragments-catalog': 'fragments-component-catalog',
+    'design/misaligned-brand': 'misaligned-with-brand',
+});
+/**
+ * Determine whether the issue author or any commenter is a
+ * designAuthority principal, and resolve the signal type from labels.
+ * Returns `{ isDesignAuthority: false, signalType: 'unspecified' }`
+ * when no DSB is present.
+ */
+export function checkDesignAuthority(input, binding) {
+    const principals = binding?.spec.stewardship.designAuthority.principals ?? [];
+    const authorityParticipants = collectAuthorityParticipants(input, principals);
+    const isDesignAuthority = authorityParticipants.length > 0;
+    const signalType = parseDesignSignalType(input.labels);
+    return { isDesignAuthority, signalType };
+}
+function collectAuthorityParticipants(input, principals) {
+    if (principals.length === 0)
+        return [];
+    const principalSet = new Set(principals.map((p) => p.toLowerCase()));
+    const participants = [];
+    if (input.authorLogin && principalSet.has(input.authorLogin.toLowerCase())) {
+        participants.push(input.authorLogin);
+    }
+    for (const c of input.commenterLogins ?? []) {
+        if (principalSet.has(c.toLowerCase()))
+            participants.push(c);
+    }
+    return participants;
+}
+/**
+ * Resolve the design-signal type from issue labels.
+ *
+ * Priority order mirrors the RFC's weighting (positive signals first),
+ * so an issue tagged with both a positive and a negative label resolves
+ * to the positive one. This is deliberate: design authorities shouldn't
+ * dual-tag in practice, but if they do, we don't want to default to the
+ * punitive path.
+ */
+export function parseDesignSignalType(labels) {
+    const priority = [
+        'advances-design-coherence',
+        'fills-catalog-gap',
+        'fragments-component-catalog',
+        'misaligned-with-brand',
+    ];
+    const lowered = labels.map((l) => l.toLowerCase());
+    for (const target of priority) {
+        const label = Object.entries(LABEL_TO_SIGNAL).find(([, v]) => v === target)?.[0];
+        if (label && lowered.includes(label))
+            return target;
+    }
+    return 'unspecified';
+}
+//# sourceMappingURL=design-authority.js.map

package/dist/design-lookahead.d.ts

@@ -0,0 +1,64 @@
+/**
+ * C7 — Design Lookahead Notification (RFC-0008 §11 + Amendment 6).
+ *
+ * Fires a notification when a backlog item has:
+ *   1. Stayed in the top-10 of the prioritized backlog for ≥48h
+ *      (OQ-7 stability threshold against priority churn)
+ *   2. Design-system impact (any of: frontend code area, catalog gaps,
+ *      or `PRODUCT_HIGH_DESIGN_LOW` tension flag)
+ *   3. Not been notified within the last 7 days
+ *      (dedupe via `design_lookahead_notifications` table)
+ *
+ * The payload is the full `PillarBreakdown` plus gap and tension
+ * information — design reviewers need the structured context to decide
+ * whether to unblock, reprioritize, or flag the item.
+ */
+import type { StateStore } from './state/store.js';
+import type { PillarBreakdown, TensionFlag } from './pillar-breakdown.js';
+export interface DesignLookaheadConfig {
+    /** Min time an issue must have been in top-N to qualify. Default 48h. */
+    stabilityThresholdMs: number;
+    /** Min time since last notification before re-notifying. Default 7d. */
+    dedupeExpiryMs: number;
+    /** Cutoff for "top" (ignored when `items` is already pre-filtered). */
+    topN: number;
+}
+export declare const DEFAULT_LOOKAHEAD_CONFIG: DesignLookaheadConfig;
+export interface BacklogItem {
+    issueNumber: number;
+    /** Composite score that placed this item in top-N. */
+    composite: number;
+    /** Pillar breakdown from the admission composite. */
+    pillarBreakdown: PillarBreakdown;
+    /** When the item first entered the top-N (ISO timestamp). */
+    enteredTop10At?: string;
+    /** Whether the code area has frontend components (C3 classifier). */
+    hasFrontendComponents?: boolean;
+    /** Catalog gaps surfaced during enrichment (C2). */
+    catalogGaps?: string[];
+}
+export type DesignImpactReason = 'frontend-components' | 'catalog-gaps' | 'product-design-tension';
+export interface DesignLookaheadNotification {
+    type: 'DesignLookaheadNotification';
+    issueNumber: number;
+    notifiedAt: string;
+    /** Reasons this item was flagged (ordered as detected). */
+    reasons: DesignImpactReason[];
+    pillarBreakdown: PillarBreakdown;
+    catalogGaps: string[];
+    tensionFlags: TensionFlag[];
+}
+export declare function detectDesignImpactReasons(item: BacklogItem): DesignImpactReason[];
+export interface DesignLookaheadDetectorDeps {
+    stateStore: StateStore;
+    now?: () => number;
+    config?: Partial<DesignLookaheadConfig>;
+}
+/**
+ * Run one scheduler tick. `items` should already be the top-N backlog
+ * items in descending composite order; caller is responsible for
+ * tracking `enteredTop10At` across ticks. Returns the notifications
+ * to emit + persist for this tick.
+ */
+export declare function detectDesignLookaheadNotifications(items: readonly BacklogItem[], deps: DesignLookaheadDetectorDeps): DesignLookaheadNotification[];
+//# sourceMappingURL=design-lookahead.d.ts.map

package/dist/design-lookahead.js

@@ -0,0 +1,86 @@
+/**
+ * C7 — Design Lookahead Notification (RFC-0008 §11 + Amendment 6).
+ *
+ * Fires a notification when a backlog item has:
+ *   1. Stayed in the top-10 of the prioritized backlog for ≥48h
+ *      (OQ-7 stability threshold against priority churn)
+ *   2. Design-system impact (any of: frontend code area, catalog gaps,
+ *      or `PRODUCT_HIGH_DESIGN_LOW` tension flag)
+ *   3. Not been notified within the last 7 days
+ *      (dedupe via `design_lookahead_notifications` table)
+ *
+ * The payload is the full `PillarBreakdown` plus gap and tension
+ * information — design reviewers need the structured context to decide
+ * whether to unblock, reprioritize, or flag the item.
+ */
+// ── Thresholds ─────────────────────────────────────────────────────────
+const DEFAULT_STABILITY_MS = 48 * 60 * 60 * 1000;
+const DEFAULT_DEDUPE_EXPIRY_MS = 7 * 24 * 60 * 60 * 1000;
+const DEFAULT_TOP_N = 10;
+export const DEFAULT_LOOKAHEAD_CONFIG = {
+    stabilityThresholdMs: DEFAULT_STABILITY_MS,
+    dedupeExpiryMs: DEFAULT_DEDUPE_EXPIRY_MS,
+    topN: DEFAULT_TOP_N,
+};
+// ── Impact detection ───────────────────────────────────────────────────
+export function detectDesignImpactReasons(item) {
+    const reasons = [];
+    if (item.hasFrontendComponents)
+        reasons.push('frontend-components');
+    if ((item.catalogGaps ?? []).length > 0)
+        reasons.push('catalog-gaps');
+    if (item.pillarBreakdown.tensions.some((t) => t.type === 'PRODUCT_HIGH_DESIGN_LOW')) {
+        reasons.push('product-design-tension');
+    }
+    return reasons;
+}
+/**
+ * Run one scheduler tick. `items` should already be the top-N backlog
+ * items in descending composite order; caller is responsible for
+ * tracking `enteredTop10At` across ticks. Returns the notifications
+ * to emit + persist for this tick.
+ */
+export function detectDesignLookaheadNotifications(items, deps) {
+    const config = { ...DEFAULT_LOOKAHEAD_CONFIG, ...deps.config };
+    const nowMs = (deps.now ?? (() => Date.now()))();
+    const topItems = items.slice(0, config.topN);
+    const emissions = [];
+    for (const item of topItems) {
+        // 1. Stability check — must have been in top-N ≥ stabilityThresholdMs.
+        if (!item.enteredTop10At)
+            continue;
+        const enteredMs = Date.parse(item.enteredTop10At);
+        if (Number.isNaN(enteredMs))
+            continue;
+        if (nowMs - enteredMs < config.stabilityThresholdMs)
+            continue;
+        // 2. Design-system impact.
+        const reasons = detectDesignImpactReasons(item);
+        if (reasons.length === 0)
+            continue;
+        // 3. Dedupe via notification table.
+        const existing = deps.stateStore.getDesignLookaheadNotification(item.issueNumber);
+        if (existing?.lastNotifiedAt) {
+            const lastMs = Date.parse(existing.lastNotifiedAt);
+            if (!Number.isNaN(lastMs) && nowMs - lastMs < config.dedupeExpiryMs)
+                continue;
+        }
+        // 4. Emit + record.
+        const notification = {
+            type: 'DesignLookaheadNotification',
+            issueNumber: item.issueNumber,
+            notifiedAt: new Date(nowMs).toISOString(),
+            reasons,
+            pillarBreakdown: item.pillarBreakdown,
+            catalogGaps: item.catalogGaps ?? [],
+            tensionFlags: item.pillarBreakdown.tensions,
+        };
+        emissions.push(notification);
+        deps.stateStore.upsertDesignLookaheadNotification({
+            issueNumber: item.issueNumber,
+            pillarBreakdownJson: JSON.stringify(item.pillarBreakdown),
+        });
+    }
+    return emissions;
+}
+//# sourceMappingURL=design-lookahead.js.map

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