@ai-sdlc/orchestrator 0.5.0 → 0.9.0

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

package/dist/design-system-metrics.js

@@ -0,0 +1,104 @@
+/**
+ * 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.
+ */
+// ── Metric Computation ───────────────────────────────────────────────
+/**
+ * Compute design review approval rate from review events.
+ */
+export function computeDesignReviewApprovalRate(events) {
+    if (events.length === 0)
+        return 1;
+    const approved = events.filter((e) => e.decision === 'approved' || e.decision === 'approved-with-comments').length;
+    return approved / events.length;
+}
+/**
+ * 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 function computeDesignReviewFirstPassRate(events) {
+    if (events.length === 0)
+        return 1;
+    const prGroups = new Map();
+    for (const e of events) {
+        if (e.prNumber === undefined)
+            continue;
+        const group = prGroups.get(e.prNumber) ?? [];
+        group.push(e);
+        prGroups.set(e.prNumber, group);
+    }
+    if (prGroups.size === 0)
+        return 1;
+    let firstPassCount = 0;
+    for (const [, group] of prGroups) {
+        // Sort by created_at, check if first is approved
+        const sorted = group.sort((a, b) => (a.createdAt ?? '').localeCompare(b.createdAt ?? ''));
+        if (sorted[0].decision === 'approved' || sorted[0].decision === 'approved-with-comments') {
+            firstPassCount++;
+        }
+    }
+    return firstPassCount / prGroups.size;
+}
+/**
+ * Compute usability simulation pass rate from simulation results.
+ */
+export function computeUsabilitySimulationPassRate(results) {
+    if (results.length === 0)
+        return 1;
+    const passed = results.filter((r) => r.completed).length;
+    return passed / results.length;
+}
+/**
+ * Compute token compliance trend from compliance history.
+ */
+export function computeTokenComplianceTrend(history) {
+    if (history.length === 0)
+        return { current: 0, trend: 'stable' };
+    if (history.length === 1)
+        return { current: history[0].coveragePercent, trend: 'stable' };
+    const sorted = [...history].sort((a, b) => (a.scannedAt ?? '').localeCompare(b.scannedAt ?? ''));
+    const current = sorted[sorted.length - 1].coveragePercent;
+    const previous = sorted[sorted.length - 2].coveragePercent;
+    const delta = current - previous;
+    let trend;
+    if (delta > 1)
+        trend = 'improving';
+    else if (delta < -1)
+        trend = 'declining';
+    else
+        trend = 'stable';
+    return { current, trend };
+}
+/**
+ * Compute visual regression pass rate from results.
+ */
+export function computeVisualRegressionPassRate(results) {
+    if (results.length === 0)
+        return 1;
+    const threshold = 0.01; // default diff threshold
+    const passed = results.filter((r) => r.diffPercentage <= threshold).length;
+    return passed / results.length;
+}
+/**
+ * Compute all six design metrics from state store data.
+ */
+export function computeDesignMetrics(data) {
+    const ciTotal = data.designCiTotalCount ?? 0;
+    const ciPass = data.designCiPassCount ?? ciTotal;
+    const ciAutoFix = data.designCiAutoFixCount ?? 0;
+    const ciFail = data.designCiFailCount ?? 0;
+    const findingsAccepted = data.findingsAccepted ?? 0;
+    const findingsDismissed = data.findingsDismissed ?? 0;
+    const findingsTotal = findingsAccepted + findingsDismissed;
+    return {
+        designCiPassRate: ciTotal > 0 ? ciPass / ciTotal : 1,
+        usabilitySimulationPassRate: computeUsabilitySimulationPassRate(data.usabilitySimulationResults),
+        designReviewApprovalRate: computeDesignReviewApprovalRate(data.reviewEvents),
+        designReviewFirstPassRate: computeDesignReviewFirstPassRate(data.reviewEvents),
+        designCiAutoFixRate: ciFail > 0 ? ciAutoFix / ciFail : 1,
+        usabilityFindingAccuracy: findingsTotal > 0 ? findingsAccepted / findingsTotal : 1,
+    };
+}
+//# sourceMappingURL=design-system-metrics.js.map

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

@@ -0,0 +1,22 @@
+/**
+ * Stewardship enforcement for DesignSystemBinding resources (RFC-0006 §5.3).
+ *
+ * Validates that changes to authority-scoped fields are submitted by
+ * authorized principals. Changes to sharedAuthority fields require
+ * approval from both disciplines when requireBothDisciplines is true.
+ */
+import type { DesignSystemBinding } from '@ai-sdlc/reference';
+export interface StewardshipDecision {
+    allowed: boolean;
+    reason: string;
+    requiredApprovals?: string[];
+}
+/**
+ * Enforce stewardship constraints on a proposed change to a DesignSystemBinding.
+ *
+ * @param changedFields - The field paths being modified
+ * @param principal - The identity of the person/agent making the change
+ * @param binding - The DesignSystemBinding being modified
+ */
+export declare function enforceStewardship(changedFields: string[], principal: string, binding: DesignSystemBinding): StewardshipDecision;
+//# sourceMappingURL=design-system-stewardship.d.ts.map

package/dist/design-system-stewardship.js

@@ -0,0 +1,85 @@
+/**
+ * Stewardship enforcement for DesignSystemBinding resources (RFC-0006 §5.3).
+ *
+ * Validates that changes to authority-scoped fields are submitted by
+ * authorized principals. Changes to sharedAuthority fields require
+ * approval from both disciplines when requireBothDisciplines is true.
+ */
+/**
+ * Determine which authority scope a field belongs to.
+ */
+function findAuthorityScope(stewardship, field) {
+    if (stewardship.sharedAuthority?.scope?.includes(field))
+        return 'shared';
+    if (stewardship.designAuthority.scope.includes(field))
+        return 'design';
+    if (stewardship.engineeringAuthority.scope.includes(field))
+        return 'engineering';
+    return 'none';
+}
+/**
+ * Check if a principal is authorized for a given authority scope.
+ */
+function isAuthorized(stewardship, principal, scope) {
+    const authorityType = findAuthorityScope(stewardship, scope);
+    switch (authorityType) {
+        case 'design':
+            return stewardship.designAuthority.principals.includes(principal);
+        case 'engineering':
+            return stewardship.engineeringAuthority.principals.includes(principal);
+        case 'shared':
+            return (stewardship.designAuthority.principals.includes(principal) ||
+                stewardship.engineeringAuthority.principals.includes(principal) ||
+                (stewardship.sharedAuthority?.principals?.includes(principal) ?? false));
+        case 'none':
+            return true; // Unscoped fields are unrestricted
+    }
+}
+/**
+ * Enforce stewardship constraints on a proposed change to a DesignSystemBinding.
+ *
+ * @param changedFields - The field paths being modified
+ * @param principal - The identity of the person/agent making the change
+ * @param binding - The DesignSystemBinding being modified
+ */
+export function enforceStewardship(changedFields, principal, binding) {
+    const stewardship = binding.spec.stewardship;
+    const requireBoth = stewardship.changeApproval?.requireBothDisciplines ?? true;
+    for (const field of changedFields) {
+        const scope = findAuthorityScope(stewardship, field);
+        // Shared authority fields may require both disciplines
+        if (scope === 'shared' && requireBoth) {
+            const isDesign = stewardship.designAuthority.principals.includes(principal);
+            const isEngineering = stewardship.engineeringAuthority.principals.includes(principal);
+            const isShared = stewardship.sharedAuthority?.principals?.includes(principal) ?? false;
+            if (!isDesign && !isEngineering && !isShared) {
+                return {
+                    allowed: false,
+                    reason: `Principal "${principal}" is not authorized for shared-authority field "${field}"`,
+                };
+            }
+            // Identify which discipline still needs to approve
+            const needed = [];
+            if (!isDesign && !isShared)
+                needed.push('design');
+            if (!isEngineering && !isShared)
+                needed.push('engineering');
+            if (needed.length > 0) {
+                return {
+                    allowed: false,
+                    reason: `Shared-authority field "${field}" requires approval from both disciplines. Pending: ${needed.join(', ')}`,
+                    requiredApprovals: needed,
+                };
+            }
+        }
+        // Design/engineering scoped fields
+        if (!isAuthorized(stewardship, principal, field)) {
+            return {
+                allowed: false,
+                reason: `Principal "${principal}" is not authorized for ${scope}-authority field "${field}"`,
+            };
+        }
+    }
+    return { allowed: true, reason: 'All changed fields are within principal authority' };
+}
+//# sourceMappingURL=design-system-stewardship.js.map

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

@@ -0,0 +1,37 @@
+/**
+ * Validates DesignSystemBinding inheritance constraints (RFC-0006 §5.6).
+ *
+ * Multi-brand inheritance uses the `extends` field. Validation enforces:
+ * - Child compliance thresholds >= parent thresholds
+ * - Child cannot remove parent disallowHardcoded categories
+ * - Inheritance depth limited to two levels (parent → child)
+ */
+import type { DesignSystemBinding } from '@ai-sdlc/reference';
+export interface InheritanceError {
+    field: string;
+    message: string;
+}
+export interface InheritanceValidationResult {
+    valid: boolean;
+    errors: InheritanceError[];
+}
+/**
+ * Resolve the parent binding from the collection by name.
+ */
+export declare function resolveParent(child: DesignSystemBinding, bindings: DesignSystemBinding[]): DesignSystemBinding | undefined;
+/**
+ * Validate that a child DesignSystemBinding conforms to its parent's constraints.
+ *
+ * Rules:
+ * 1. Child compliance.coverage.minimum >= parent compliance.coverage.minimum
+ * 2. Child compliance.coverage.target >= parent compliance.coverage.target (if both defined)
+ * 3. Child must not remove any parent disallowHardcoded categories
+ * 4. Two-level depth limit: parent must not itself have an `extends` field
+ */
+export declare function validateDesignSystemInheritance(child: DesignSystemBinding, parent: DesignSystemBinding): InheritanceValidationResult;
+/**
+ * Validate all DesignSystemBinding inheritance relationships in a collection.
+ * Returns errors for any invalid inheritance chains.
+ */
+export declare function validateAllInheritance(bindings: DesignSystemBinding[]): InheritanceValidationResult;
+//# sourceMappingURL=design-system-validation.d.ts.map

package/dist/design-system-validation.js

@@ -0,0 +1,88 @@
+/**
+ * Validates DesignSystemBinding inheritance constraints (RFC-0006 §5.6).
+ *
+ * Multi-brand inheritance uses the `extends` field. Validation enforces:
+ * - Child compliance thresholds >= parent thresholds
+ * - Child cannot remove parent disallowHardcoded categories
+ * - Inheritance depth limited to two levels (parent → child)
+ */
+/**
+ * Resolve the parent binding from the collection by name.
+ */
+export function resolveParent(child, bindings) {
+    if (!child.spec.extends)
+        return undefined;
+    return bindings.find((b) => b.metadata.name === child.spec.extends);
+}
+/**
+ * Validate that a child DesignSystemBinding conforms to its parent's constraints.
+ *
+ * Rules:
+ * 1. Child compliance.coverage.minimum >= parent compliance.coverage.minimum
+ * 2. Child compliance.coverage.target >= parent compliance.coverage.target (if both defined)
+ * 3. Child must not remove any parent disallowHardcoded categories
+ * 4. Two-level depth limit: parent must not itself have an `extends` field
+ */
+export function validateDesignSystemInheritance(child, parent) {
+    const errors = [];
+    // Depth limit: parent must not extend another binding
+    if (parent.spec.extends) {
+        errors.push({
+            field: 'extends',
+            message: `Inheritance depth exceeds two levels: "${child.metadata.name}" extends "${parent.metadata.name}" which extends "${parent.spec.extends}". Only parent → child is supported in v1alpha1.`,
+        });
+    }
+    // Coverage minimum: child >= parent
+    const parentMin = parent.spec.compliance.coverage.minimum;
+    const childMin = child.spec.compliance.coverage.minimum;
+    if (childMin < parentMin) {
+        errors.push({
+            field: 'compliance.coverage.minimum',
+            message: `Child minimum coverage (${childMin}) is less than parent minimum (${parentMin}). Child thresholds can only tighten, not loosen.`,
+        });
+    }
+    // Coverage target: child >= parent (if both defined)
+    const parentTarget = parent.spec.compliance.coverage.target;
+    const childTarget = child.spec.compliance.coverage.target;
+    if (parentTarget !== undefined && childTarget !== undefined && childTarget < parentTarget) {
+        errors.push({
+            field: 'compliance.coverage.target',
+            message: `Child target coverage (${childTarget}) is less than parent target (${parentTarget}). Child thresholds can only tighten, not loosen.`,
+        });
+    }
+    // disallowHardcoded: child must not remove parent categories
+    const parentCategories = new Set((parent.spec.compliance.disallowHardcoded ?? []).map((r) => r.category));
+    const childCategories = new Set((child.spec.compliance.disallowHardcoded ?? []).map((r) => r.category));
+    for (const category of parentCategories) {
+        if (!childCategories.has(category)) {
+            errors.push({
+                field: 'compliance.disallowHardcoded',
+                message: `Child removes parent disallowHardcoded category "${category}". Child bindings may add categories but must not remove parent categories.`,
+            });
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Validate all DesignSystemBinding inheritance relationships in a collection.
+ * Returns errors for any invalid inheritance chains.
+ */
+export function validateAllInheritance(bindings) {
+    const allErrors = [];
+    for (const binding of bindings) {
+        if (!binding.spec.extends)
+            continue;
+        const parent = resolveParent(binding, bindings);
+        if (!parent) {
+            allErrors.push({
+                field: 'extends',
+                message: `Binding "${binding.metadata.name}" extends "${binding.spec.extends}" but no binding with that name exists.`,
+            });
+            continue;
+        }
+        const result = validateDesignSystemInheritance(binding, parent);
+        allErrors.push(...result.errors);
+    }
+    return { valid: allErrors.length === 0, errors: allErrors };
+}
+//# sourceMappingURL=design-system-validation.js.map

package/dist/dispatch/index.d.ts

@@ -0,0 +1,4 @@
+export { runWorkerPool, type WorkItem, type WorkerPoolDeps, type WorkerPoolEvent, type WorkerPoolResult, } from './worker-pool.js';
+export { withMergeGate, forceReleaseMergeGate, isBranchUpToDate, MergeGateLockTimeoutError, type MergeGateDeps, } from './merge-gate.js';
+export { decideRequeue, appendTriageHistory, type FailureEvent, type RequeueTrigger, type RequeueDecision, type RequeueDecisionInput, type TriageHistoryEntry, type FailureClassification, } from './requeue.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/dispatch/index.js

@@ -0,0 +1,4 @@
+export { runWorkerPool, } from './worker-pool.js';
+export { withMergeGate, forceReleaseMergeGate, isBranchUpToDate, MergeGateLockTimeoutError, } from './merge-gate.js';
+export { decideRequeue, appendTriageHistory, } from './requeue.js';
+//# sourceMappingURL=index.js.map

package/dist/dispatch/merge-gate.d.ts

@@ -0,0 +1,46 @@
+/**
+ * File-based merge gate per RFC-0010 §10. Single mutex (<pool>/.merge-gate.lock)
+ * serializes the merge-eligibility/rebase step across parallel agents. Stale-base
+ * detection + rebase-on-conflict per §10.2.
+ *
+ * Per project policy (feedback_never_merge_prs.md): the orchestrator MUST NOT execute
+ * `gh pr merge`. The merge gate ensures a PR is in known-mergeable state when the
+ * human reviewer hits merge — it does NOT perform the merge itself.
+ */
+export declare class MergeGateLockTimeoutError extends Error {
+    readonly lockPath: string;
+    constructor(lockPath: string);
+}
+export interface MergeGateDeps {
+    /** Override for tests. */
+    now?: () => number;
+}
+/**
+ * Acquire the merge gate, run `work`, release. The lock is a sentinel file; if it
+ * already exists, the caller polls until it's released or the timeout elapses.
+ *
+ * Caveat: this is a cooperative file lock, not a kernel lock. Crashes can leave a
+ * stale lock; the caller is expected to forcibly remove and retry as a recovery step.
+ */
+export declare function withMergeGate<T>(poolDir: string, work: () => Promise<T>, options?: {
+    timeoutMs?: number;
+}, deps?: MergeGateDeps): Promise<T>;
+/**
+ * Force-remove a stale merge gate lock. Operators run this manually when an agent
+ * crashed mid-merge-gate and the lock file is orphaned.
+ */
+export declare function forceReleaseMergeGate(poolDir: string): Promise<void>;
+/**
+ * Test helper: write a sentinel lock file in an unexpected state (used by tests
+ * verifying the timeout path).
+ */
+export declare function _testWriteSentinel(poolDir: string): Promise<void>;
+/**
+ * Stale-base detection per RFC §10.2. Compares a branch's base SHA to the current
+ * remote target's HEAD; returns true when the branch is up-to-date.
+ *
+ * The actual git logic is delegated to the caller via `headOfRemote` so this stays
+ * unit-testable without shelling out.
+ */
+export declare function isBranchUpToDate(branchBaseSha: string, targetBranch: string, headOfRemote: (target: string) => Promise<string>): Promise<boolean>;
+//# sourceMappingURL=merge-gate.d.ts.map