@ai-sdlc/orchestrator 0.6.0 → 0.10.0

package/dist/models/registry.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Model alias registry per RFC-0010 §11. Maps short aliases (haiku, sonnet, opus, opus[1m])
+ * to physical model IDs and tracks deprecation lifecycle (deprecatedAt / removedAt /
+ * replacementAlias). Resolution is performed once at pipeline-load and pinned per run
+ * (RFC §11.1) so model swaps cannot occur underneath an in-flight pipeline.
+ */
+export interface ModelEntry {
+    /** Short alias used in pipeline YAML (e.g., 'haiku'). */
+    alias: string;
+    /** Physical model ID dispatched to the harness (e.g., 'claude-haiku-4-5-20251001'). */
+    modelId: string;
+    /** ISO 8601 date when the vendor announced deprecation; null if active. */
+    deprecatedAt: string | null;
+    /** ISO 8601 date when the vendor will (or did) remove the model; null if not scheduled. */
+    removedAt: string | null;
+    /** Alias to migrate to when this entry is deprecated; required when deprecatedAt is set. */
+    replacementAlias: string | null;
+    /** Documentation hint, surfaced by cli-model-bump. */
+    use?: string;
+}
+export interface ResolutionContext {
+    /** Source of `now` for deprecation comparisons; defaults to system clock. */
+    now?: () => Date;
+}
+export type ResolutionEvent = {
+    type: 'ok';
+    alias: string;
+    modelId: string;
+} | {
+    type: 'ModelDeprecated';
+    alias: string;
+    modelId: string;
+    removedAt: string | null;
+    replacementAlias: string | null;
+} | {
+    type: 'ModelDeprecationGracePeriod';
+    alias: string;
+    removedAt: string;
+};
+export interface ResolutionResult {
+    modelId: string;
+    events: ResolutionEvent[];
+}
+export declare class ModelRemovedError extends Error {
+    readonly alias: string;
+    readonly modelId: string;
+    readonly removedAt: string;
+    constructor(alias: string, modelId: string, removedAt: string);
+}
+export declare class UnknownAliasError extends Error {
+    readonly alias: string;
+    constructor(alias: string);
+}
+/**
+ * Default registry shipped with the orchestrator. Maintainers update deprecatedAt /
+ * removedAt / replacementAlias from public vendor announcements (see operator-runbook).
+ */
+export declare const DEFAULT_REGISTRY: readonly ModelEntry[];
+export declare class ModelRegistry {
+    private readonly entries;
+    constructor(entries?: readonly ModelEntry[]);
+    list(): ModelEntry[];
+    get(alias: string): ModelEntry | undefined;
+    /**
+     * Resolve an alias to a physical model ID at pipeline-load. Throws ModelRemovedError
+     * if the model has been removed; emits ModelDeprecated event otherwise (informational).
+     * Within `GRACE_PERIOD_DAYS` of the removal date, additionally emits
+     * ModelDeprecationGracePeriod for escalated operator notification.
+     */
+    resolve(alias: string, ctx?: ResolutionContext): ResolutionResult;
+    /**
+     * Bulk-resolve a set of stage aliases. Emits one ResolutionResult per (stage, alias).
+     * Used at pipeline-load to pin model resolution for the whole pipeline run.
+     */
+    resolveAll(stageAliases: ReadonlyArray<{
+        stage: string;
+        alias: string;
+    }>, ctx?: ResolutionContext): Map<string, ResolutionResult>;
+    /**
+     * Operator-facing dry-run helper: for each currently deprecated alias, report what
+     * would happen if a pipeline started today. Used by cli-model-bump --dry-run.
+     */
+    bumpPlan(stageAliases: ReadonlyArray<{
+        stage: string;
+        alias: string;
+    }>, ctx?: ResolutionContext): Array<{
+        stage: string;
+        alias: string;
+        currentModelId: string;
+        deprecatedAt: string | null;
+        removedAt: string | null;
+        replacementAlias: string | null;
+        replacementModelId: string | null;
+        inGracePeriod: boolean;
+    }>;
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/models/registry.js

@@ -0,0 +1,173 @@
+/**
+ * Model alias registry per RFC-0010 §11. Maps short aliases (haiku, sonnet, opus, opus[1m])
+ * to physical model IDs and tracks deprecation lifecycle (deprecatedAt / removedAt /
+ * replacementAlias). Resolution is performed once at pipeline-load and pinned per run
+ * (RFC §11.1) so model swaps cannot occur underneath an in-flight pipeline.
+ */
+export class ModelRemovedError extends Error {
+    alias;
+    modelId;
+    removedAt;
+    constructor(alias, modelId, removedAt) {
+        super(`Model alias '${alias}' resolves to '${modelId}', which was removed at ${removedAt}`);
+        this.alias = alias;
+        this.modelId = modelId;
+        this.removedAt = removedAt;
+        this.name = 'ModelRemovedError';
+    }
+}
+export class UnknownAliasError extends Error {
+    alias;
+    constructor(alias) {
+        super(`Unknown model alias: ${alias}`);
+        this.alias = alias;
+        this.name = 'UnknownAliasError';
+    }
+}
+const GRACE_PERIOD_DAYS = 30;
+/**
+ * Default registry shipped with the orchestrator. Maintainers update deprecatedAt /
+ * removedAt / replacementAlias from public vendor announcements (see operator-runbook).
+ */
+export const DEFAULT_REGISTRY = [
+    {
+        alias: 'haiku',
+        modelId: 'claude-haiku-4-5-20251001',
+        deprecatedAt: null,
+        removedAt: null,
+        replacementAlias: null,
+        use: 'Classification, routing, formatting, structured-output extraction',
+    },
+    {
+        alias: 'sonnet',
+        modelId: 'claude-sonnet-4-6',
+        deprecatedAt: null,
+        removedAt: null,
+        replacementAlias: null,
+        use: 'Code review, refactoring, validation, default for everything else',
+    },
+    {
+        alias: 'opus',
+        modelId: 'claude-opus-4-7',
+        deprecatedAt: null,
+        removedAt: null,
+        replacementAlias: null,
+        use: 'Complex implementation, multi-file refactors, design work',
+    },
+    {
+        alias: 'opus[1m]',
+        modelId: 'claude-opus-4-7[1m]',
+        deprecatedAt: null,
+        removedAt: null,
+        replacementAlias: null,
+        use: 'Implementation against a large codebase context (>200K tokens)',
+    },
+];
+export class ModelRegistry {
+    entries;
+    constructor(entries = DEFAULT_REGISTRY) {
+        this.entries = new Map(entries.map((e) => [e.alias, { ...e }]));
+    }
+    list() {
+        return Array.from(this.entries.values()).map((e) => ({ ...e }));
+    }
+    get(alias) {
+        const e = this.entries.get(alias);
+        return e ? { ...e } : undefined;
+    }
+    /**
+     * Resolve an alias to a physical model ID at pipeline-load. Throws ModelRemovedError
+     * if the model has been removed; emits ModelDeprecated event otherwise (informational).
+     * Within `GRACE_PERIOD_DAYS` of the removal date, additionally emits
+     * ModelDeprecationGracePeriod for escalated operator notification.
+     */
+    resolve(alias, ctx = {}) {
+        const entry = this.entries.get(alias);
+        if (!entry)
+            throw new UnknownAliasError(alias);
+        const now = (ctx.now ?? (() => new Date()))();
+        const events = [];
+        if (entry.removedAt) {
+            const removedAt = new Date(entry.removedAt);
+            if (now.getTime() >= removedAt.getTime()) {
+                throw new ModelRemovedError(alias, entry.modelId, entry.removedAt);
+            }
+        }
+        if (entry.deprecatedAt) {
+            const deprecatedAt = new Date(entry.deprecatedAt);
+            if (now.getTime() >= deprecatedAt.getTime()) {
+                events.push({
+                    type: 'ModelDeprecated',
+                    alias,
+                    modelId: entry.modelId,
+                    removedAt: entry.removedAt,
+                    replacementAlias: entry.replacementAlias,
+                });
+                if (entry.removedAt) {
+                    const removedAt = new Date(entry.removedAt);
+                    const graceCutoff = removedAt.getTime() - GRACE_PERIOD_DAYS * 24 * 60 * 60 * 1000;
+                    if (now.getTime() >= graceCutoff) {
+                        events.push({
+                            type: 'ModelDeprecationGracePeriod',
+                            alias,
+                            removedAt: entry.removedAt,
+                        });
+                    }
+                }
+            }
+        }
+        if (events.length === 0) {
+            events.push({ type: 'ok', alias, modelId: entry.modelId });
+        }
+        return { modelId: entry.modelId, events };
+    }
+    /**
+     * Bulk-resolve a set of stage aliases. Emits one ResolutionResult per (stage, alias).
+     * Used at pipeline-load to pin model resolution for the whole pipeline run.
+     */
+    resolveAll(stageAliases, ctx = {}) {
+        const out = new Map();
+        for (const { stage, alias } of stageAliases) {
+            out.set(stage, this.resolve(alias, ctx));
+        }
+        return out;
+    }
+    /**
+     * Operator-facing dry-run helper: for each currently deprecated alias, report what
+     * would happen if a pipeline started today. Used by cli-model-bump --dry-run.
+     */
+    bumpPlan(stageAliases, ctx = {}) {
+        const now = (ctx.now ?? (() => new Date()))();
+        const result = [];
+        for (const { stage, alias } of stageAliases) {
+            const entry = this.entries.get(alias);
+            if (!entry || !entry.deprecatedAt)
+                continue;
+            if (new Date(entry.deprecatedAt).getTime() > now.getTime())
+                continue;
+            let replacementModelId = null;
+            if (entry.replacementAlias) {
+                const replacement = this.entries.get(entry.replacementAlias);
+                replacementModelId = replacement?.modelId ?? null;
+            }
+            let inGracePeriod = false;
+            if (entry.removedAt) {
+                const removedAt = new Date(entry.removedAt);
+                const graceCutoff = removedAt.getTime() - GRACE_PERIOD_DAYS * 24 * 60 * 60 * 1000;
+                inGracePeriod = now.getTime() >= graceCutoff;
+            }
+            result.push({
+                stage,
+                alias,
+                currentModelId: entry.modelId,
+                deprecatedAt: entry.deprecatedAt,
+                removedAt: entry.removedAt,
+                replacementAlias: entry.replacementAlias,
+                replacementModelId,
+                inGracePeriod,
+            });
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/pillar-breakdown.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Pillar breakdown & tension detection (RFC-0008 §A.6 + Amendment 6).
+ *
+ * The admission composite produces a single scalar, but downstream
+ * reviewers (product, design, engineering) want to see *which pillar*
+ * the score came from — so they can act on a mismatch between a
+ * strong product signal and a weak design or engineering one.
+ *
+ * This module takes the `AdmissionComposite.breakdown` emitted by
+ * `computeAdmissionComposite` and produces:
+ *   - three `PillarContribution`s (product/design/engineering)
+ *   - `SharedDimensions` (SA-3 placeholder + HC channel map)
+ *   - tension flags detected from pillar mismatch
+ */
+import type { AdmissionComposite } from './admission-composite.js';
+export type PillarName = 'product' | 'design' | 'engineering';
+export type TensionFlagType = 'PRODUCT_HIGH_DESIGN_LOW' | 'PRODUCT_HIGH_ENGINEERING_LOW' | 'DESIGN_HIGH_PRODUCT_LOW' | 'ENGINEERING_HIGH_PRODUCT_LOW' | 'ALL_MEDIUM';
+export interface PillarContribution {
+    pillar: PillarName;
+    /** PPA/RFC dimension labels attributed to this pillar at admission time. */
+    governedDimensions: string[];
+    /** Aggregate pillar signal in [0, 1]. */
+    signal: number;
+    /** Stable human-readable interpretation (snapshot-tested). */
+    interpretation: string;
+}
+export interface HcChannelBreakdown {
+    explicit: number;
+    consensus: number;
+    decision: number;
+    design: number;
+}
+export interface SharedDimensions {
+    /**
+     * SA-3 (shared intent) — unavailable at admission in Phase 1; M5
+     * populates this once the SA-1/SA-2/SA-3 decomposition lands.
+     */
+    saAlpha3?: number;
+    /**
+     * Per-channel HC breakdown with the tanh composite for reference.
+     *
+     * `designAuthorityConfigured` (AISDLC-171) — diagnostic flag set when
+     * the resolved DSB declares any `stewardship.designAuthority.principals`
+     * entries, regardless of whether one of them participated in the issue.
+     * Lets operators distinguish three pillarBreakdown states for the design
+     * channel:
+     *   - `design = 0` and `configured === undefined` → no DSB resolved
+     *     (preDesignSystem). HC_design intentionally inert.
+     *   - `design = 0` and `configured === true`     → DSB declares design
+     *     authority but no principal participated as author/commenter.
+     *     HC_design intentionally 0 per RFC-0008 §14.2 (only principals
+     *     emit full-weight HC_design signals; non-principal opinions route
+     *     through HC_consensus, not HC_design).
+     *   - `design ≠ 0` and `configured === true`     → a principal
+     *     participated; signal weight reflects label-derived signalType.
+     *
+     * The `false` case (DSB exists but `principals` is empty) is also
+     * surfaced for completeness — a DSB without designAuthority principals
+     * cannot ever fire HC_design and operators should know.
+     */
+    hcComposite: HcChannelBreakdown & {
+        value: number;
+        designAuthorityConfigured?: boolean;
+    };
+}
+export interface TensionFlag {
+    type: TensionFlagType;
+    /** Stable suggestion string per tension type (snapshot-tested). */
+    suggestedAction: string;
+}
+export interface PillarBreakdown {
+    product: PillarContribution;
+    design: PillarContribution;
+    engineering: PillarContribution;
+    shared: SharedDimensions;
+    tensions: TensionFlag[];
+}
+export declare function computePillarBreakdown(composite: AdmissionComposite): PillarBreakdown;
+export declare function detectTensions(breakdown: PillarBreakdown): TensionFlag[];
+/**
+ * Aggregate pillar signal in [0, 1]. Exposed so consumers can compute
+ * pillar scores without needing the full `AdmissionComposite`.
+ */
+export declare function pillarSignalScore(signals: readonly number[]): number;
+//# sourceMappingURL=pillar-breakdown.d.ts.map

package/dist/pillar-breakdown.js

@@ -0,0 +1,162 @@
+/**
+ * Pillar breakdown & tension detection (RFC-0008 §A.6 + Amendment 6).
+ *
+ * The admission composite produces a single scalar, but downstream
+ * reviewers (product, design, engineering) want to see *which pillar*
+ * the score came from — so they can act on a mismatch between a
+ * strong product signal and a weak design or engineering one.
+ *
+ * This module takes the `AdmissionComposite.breakdown` emitted by
+ * `computeAdmissionComposite` and produces:
+ *   - three `PillarContribution`s (product/design/engineering)
+ *   - `SharedDimensions` (SA-3 placeholder + HC channel map)
+ *   - tension flags detected from pillar mismatch
+ */
+// ── Thresholds ─────────────────────────────────────────────────────────
+const HIGH_THRESHOLD = 0.7;
+const LOW_THRESHOLD = 0.3;
+const MEDIUM_LOW = 0.3;
+const MEDIUM_HIGH = 0.5;
+// ── Suggested actions (stable) ─────────────────────────────────────────
+const SUGGESTED_ACTIONS = Object.freeze({
+    PRODUCT_HIGH_DESIGN_LOW: 'Product intent is strong but design-system readiness is weak; consider catalog-first work or route through design authority before building.',
+    PRODUCT_HIGH_ENGINEERING_LOW: 'Product intent is strong but engineering signal is weak; address the defect-density, autonomy gap, or complexity before building.',
+    DESIGN_HIGH_PRODUCT_LOW: 'Design signal is strong but product demand is low; confirm product alignment before scheduling.',
+    ENGINEERING_HIGH_PRODUCT_LOW: 'Engineering area health is strong but product demand is weak; surface more demand evidence before scheduling.',
+    ALL_MEDIUM: 'All pillars are in the neutral band; the score is likely noise — gather more evidence or defer.',
+});
+// ── Public API ─────────────────────────────────────────────────────────
+export function computePillarBreakdown(composite) {
+    const b = composite.breakdown;
+    // Product: SA-1 (soulAlignment proxy), D-pi, HC_explicit
+    const productSignal = mean([
+        b.soulAlignment,
+        b.demandPressureAdjusted,
+        normalizeSigned(b.humanCurve.hcExplicit),
+    ]);
+    const product = {
+        pillar: 'product',
+        governedDimensions: ['SA-1', 'D-pi', 'HC_explicit'],
+        signal: productSignal,
+        interpretation: interpret('Product', productSignal, 'mission alignment, demand, and explicit priority'),
+    };
+    // Design: ER-4 (designSystemReadiness) + HC_design; SA-2 deferred to M5.
+    const designSignal = mean([b.designSystemReadiness, normalizeSigned(b.humanCurve.hcDesign)]);
+    const design = {
+        pillar: 'design',
+        governedDimensions: ['ER-4', 'HC_design'],
+        signal: designSignal,
+        interpretation: interpret('Design', designSignal, 'design-system readiness and design-authority signal'),
+    };
+    // Engineering: ER-1 (baseER), ER-2 (autonomyFactor), defectRiskFactor inverse.
+    // defectRiskFactor is clamped upstream to [0, 0.5]; the clamp01 here is
+    // a defence-in-depth guard so a regression in the upstream clamp can't
+    // feed a negative value into `mean()` and corrupt the engineering signal.
+    const engineeringSignal = mean([
+        b.baseExecutionReality,
+        b.autonomyFactor,
+        clamp01(1 - 2 * b.defectRiskFactor),
+    ]);
+    const engineering = {
+        pillar: 'engineering',
+        governedDimensions: ['ER-1', 'ER-2', 'ER-3'],
+        signal: engineeringSignal,
+        interpretation: interpret('Engineering', engineeringSignal, 'complexity feasibility, autonomy gap, and code-area defect risk'),
+    };
+    const shared = {
+        hcComposite: {
+            explicit: b.humanCurve.hcExplicit,
+            consensus: b.humanCurve.hcConsensus,
+            decision: b.humanCurve.hcDecision,
+            design: b.humanCurve.hcDesign,
+            value: b.humanCurve.hcComposite,
+            // AISDLC-171: only include the flag when the underlying signal
+            // populated it (i.e., a DSB was resolved). Leaving it `undefined`
+            // when no DSB was supplied keeps the preDesignSystem state
+            // distinct from the "configured but inactive" state at the API
+            // surface — operators inspecting `pillarBreakdown.shared` can
+            // tell the three states apart without reading the DSB themselves.
+            ...(b.humanCurve.designAuthorityConfigured !== undefined
+                ? { designAuthorityConfigured: b.humanCurve.designAuthorityConfigured }
+                : {}),
+        },
+    };
+    const tensions = detectTensions({ product, design, engineering, shared, tensions: [] });
+    return { product, design, engineering, shared, tensions };
+}
+export function detectTensions(breakdown) {
+    const flags = [];
+    const p = breakdown.product.signal;
+    const d = breakdown.design.signal;
+    const e = breakdown.engineering.signal;
+    if (p > HIGH_THRESHOLD && d < LOW_THRESHOLD) {
+        flags.push({
+            type: 'PRODUCT_HIGH_DESIGN_LOW',
+            suggestedAction: SUGGESTED_ACTIONS.PRODUCT_HIGH_DESIGN_LOW,
+        });
+    }
+    if (p > HIGH_THRESHOLD && e < LOW_THRESHOLD) {
+        flags.push({
+            type: 'PRODUCT_HIGH_ENGINEERING_LOW',
+            suggestedAction: SUGGESTED_ACTIONS.PRODUCT_HIGH_ENGINEERING_LOW,
+        });
+    }
+    if (d > HIGH_THRESHOLD && p < LOW_THRESHOLD) {
+        flags.push({
+            type: 'DESIGN_HIGH_PRODUCT_LOW',
+            suggestedAction: SUGGESTED_ACTIONS.DESIGN_HIGH_PRODUCT_LOW,
+        });
+    }
+    if (e > HIGH_THRESHOLD && p < LOW_THRESHOLD) {
+        flags.push({
+            type: 'ENGINEERING_HIGH_PRODUCT_LOW',
+            suggestedAction: SUGGESTED_ACTIONS.ENGINEERING_HIGH_PRODUCT_LOW,
+        });
+    }
+    // ALL_MEDIUM: all three pillars strictly inside [MEDIUM_LOW, MEDIUM_HIGH]
+    if (inMediumBand(p) && inMediumBand(d) && inMediumBand(e)) {
+        flags.push({
+            type: 'ALL_MEDIUM',
+            suggestedAction: SUGGESTED_ACTIONS.ALL_MEDIUM,
+        });
+    }
+    return flags;
+}
+/**
+ * Aggregate pillar signal in [0, 1]. Exposed so consumers can compute
+ * pillar scores without needing the full `AdmissionComposite`.
+ */
+export function pillarSignalScore(signals) {
+    return mean(signals);
+}
+// ── Helpers ────────────────────────────────────────────────────────────
+function mean(values) {
+    if (values.length === 0)
+        return 0;
+    const sum = values.reduce((acc, v) => acc + v, 0);
+    return clamp01(sum / values.length);
+}
+function clamp01(value) {
+    return Math.min(1, Math.max(0, value));
+}
+/** Map a signed [-1, 1] HC channel onto the pillar's unsigned [0, 1] scale. */
+function normalizeSigned(value) {
+    return clamp01((value + 1) / 2);
+}
+function interpret(pillar, signal, what) {
+    const band = signalBand(signal);
+    return `${band} ${pillar} signal (${signal.toFixed(2)}) from ${what}`;
+}
+function signalBand(signal) {
+    if (signal >= HIGH_THRESHOLD)
+        return 'strong';
+    if (signal >= MEDIUM_HIGH)
+        return 'moderate';
+    if (signal >= MEDIUM_LOW)
+        return 'neutral';
+    return 'weak';
+}
+function inMediumBand(value) {
+    return value >= MEDIUM_LOW && value <= MEDIUM_HIGH;
+}
+//# sourceMappingURL=pillar-breakdown.js.map

package/dist/priority.d.ts

@@ -12,6 +12,11 @@
  */
 import type { PriorityScore, PriorityInput, PriorityConfig } from '@ai-sdlc/reference';
 export type { PriorityScore, PriorityInput, PriorityConfig };
+/**
+ * Compute a confidence score [0, 1] based on the fraction of optional
+ * input fields that were explicitly provided (not defaulted).
+ */
+export declare function computeConfidence(input: PriorityInput): number;
 /**
  * Compute the PPA composite priority score for a single work item.
  *

package/dist/priority.js

@@ -132,10 +132,23 @@ function computeHumanCurve(input, weights) {
 }
 /**
  * Cκ — Calibration Coefficient [0.7, 1.3].
- * A tuning knob that lets operators scale the final score up or down.
+ *
+ * Category-scoped (RFC-0008 §10 Amendment 6) when `categoryResolver`
+ * and `categoryCoefficients` are both present: resolver returns a
+ * category label, coefficient is looked up, scalar fallback applies
+ * when the category has no entry. Otherwise uses the scalar path
+ * unchanged.
  */
-function computeCalibration(config) {
-    const coeff = config?.calibrationCoefficient ?? 1.0;
+function computeCalibration(input, config) {
+    let coeff = config?.calibrationCoefficient ?? 1.0;
+    const resolver = config?.categoryResolver;
+    const table = config?.categoryCoefficients;
+    if (resolver && table) {
+        const category = resolver(input);
+        if (category && table[category] !== undefined) {
+            coeff = table[category];
+        }
+    }
     return clamp(coeff, CALIBRATION_MIN, CALIBRATION_MAX);
 }
 // ── Confidence ──────────────────────────────────────────────────────
@@ -143,7 +156,7 @@ function computeCalibration(config) {
  * Compute a confidence score [0, 1] based on the fraction of optional
  * input fields that were explicitly provided (not defaulted).
  */
-function computeConfidence(input) {
+export function computeConfidence(input) {
     let provided = 0;
     for (const field of SCORABLE_FIELDS) {
         if (input[field] !== undefined) {
@@ -194,7 +207,7 @@ export function computePriority(input, config) {
     const executionReality = computeExecutionReality(input);
     const entropyTax = computeEntropyTax(input);
     const humanCurve = computeHumanCurve(input, hcWeights);
-    const calibration = computeCalibration(config);
+    const calibration = computeCalibration(input, config);
     // ── Composite ─────────────────────────────────────────────────
     const composite = soulAlignment *
         demandPressure *

package/dist/review-meta.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Meta-review pass — filters medium-confidence findings through a
+ * lightweight LLM call (Haiku) to reduce false positives.
+ *
+ * Flow:
+ *   High confidence (>0.8)  → post directly
+ *   Medium (0.5-0.8)        → meta-review decides keep/drop
+ *   Low (<0.5)              → already suppressed by parseVerdict()
+ */
+import type { ReviewVerdict, ReviewFinding } from './runners/review-agent.js';
+export interface MetaReviewDecision {
+    keep: boolean;
+    adjustedSeverity?: ReviewFinding['severity'];
+    reason: string;
+}
+export interface MetaReviewResult {
+    /** The filtered verdict with medium-confidence findings reviewed. */
+    verdict: ReviewVerdict;
+    /** Decisions for each medium-confidence finding. */
+    decisions: Array<{
+        finding: ReviewFinding;
+        decision: MetaReviewDecision;
+    }>;
+    /** Count of findings suppressed by meta-review. */
+    suppressed: number;
+}
+/**
+ * Run a meta-review pass on medium-confidence findings.
+ *
+ * @param verdict - The original verdict from a review agent
+ * @param principles - Review principles text for context
+ * @param callLLM - Function to make a single-turn LLM call (injectable for testing)
+ */
+export declare function metaReview(verdict: ReviewVerdict, principles: string, callLLM: (prompt: string) => Promise<string>): Promise<MetaReviewResult>;
+export interface ReviewFeedback {
+    /** PR number. */
+    prNumber: number;
+    /** Finding that was posted. */
+    finding: ReviewFinding;
+    /** Human response. */
+    signal: 'accepted' | 'dismissed' | 'ignored';
+    /** Timestamp. */
+    timestamp: string;
+}
+/**
+ * Store for tracking human feedback on review findings.
+ * Used to calibrate confidence thresholds over time.
+ */
+export declare class ReviewFeedbackStore {
+    private entries;
+    record(feedback: ReviewFeedback): void;
+    /** Get all feedback entries. */
+    getAll(): ReviewFeedback[];
+    /** Get precision: accepted / (accepted + dismissed). */
+    precision(): number;
+    /** Get feedback by category. */
+    byCategory(): Record<string, {
+        accepted: number;
+        dismissed: number;
+        ignored: number;
+    }>;
+    /** Categories with high false-positive rate (dismissed > 50%). */
+    highFalsePositiveCategories(): string[];
+}
+//# sourceMappingURL=review-meta.d.ts.map