@ai-sdlc/orchestrator 0.5.0 → 0.9.0

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,63 @@
+/**
+ * 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. */
+    hcComposite: HcChannelBreakdown & {
+        value: number;
+    };
+}
+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,153 @@
+/**
+ * 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,
+        },
+    };
+    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/pipeline-cycle-detector.d.ts

@@ -0,0 +1,70 @@
+/**
+ * PipelineCycleDetector — tracks stage invocations per issue/PR across
+ * all workflow runs to detect infinite orchestration loops.
+ *
+ * Uses GitHub issue/PR comments as shared state (hidden HTML markers)
+ * to work across workflow boundaries.
+ */
+import type { IssueTracker } from '@ai-sdlc/reference';
+export type PipelineStage = 'admission' | 'triage' | 'agent' | 'review' | 'fix-ci' | 'fix-review';
+export interface CycleConfig {
+    /** Max invocations per stage (default: 3 for agent stages, 2 for fix stages). */
+    maxInvocations: Record<PipelineStage, number>;
+}
+export interface CycleDetectionResult {
+    cycleDetected: boolean;
+    loopingStages: Array<{
+        stage: PipelineStage;
+        count: number;
+        max: number;
+    }>;
+    totalInvocations: number;
+}
+/**
+ * Default max invocations per stage.
+ * These must be HIGHER than the per-stage retry limits (which are the
+ * primary guard). The cycle detector is a safety net for cross-stage
+ * loops, not a replacement for retry counting.
+ *
+ * Per-stage retry limits: fix-ci=2, fix-review=2
+ * Cycle limits: set to retry_limit + 2 to allow retries + headroom
+ */
+export declare const DEFAULT_CYCLE_LIMITS: Record<PipelineStage, number>;
+/**
+ * Generate HTML comment marker for a stage invocation.
+ * Format: <!-- ai-sdlc-cycle:{stage}:{timestamp} -->
+ */
+export declare function createStageMarker(stage: PipelineStage): string;
+/**
+ * Parse stage invocation markers from comment bodies.
+ * Returns a map of stage -> invocation count.
+ */
+export declare function parseStageInvocations(comments: string[]): Map<PipelineStage, number>;
+export declare class PipelineCycleDetector {
+    private config;
+    constructor(config?: Partial<CycleConfig>);
+    /**
+     * Check if a cycle exists for the given issue/PR by analyzing comment history.
+     * @param pendingStage — if set, adds +1 to this stage's count to account for the upcoming invocation
+     */
+    detectCycle(tracker: IssueTracker, issueOrPrId: string, pendingStage?: PipelineStage): Promise<CycleDetectionResult>;
+    /**
+     * Detect cycle from comment bodies (for testing without IssueTracker).
+     * @param pendingStage — if set, adds +1 to this stage's count for the pending invocation
+     */
+    detectCycleFromComments(comments: string[], pendingStage?: PipelineStage): CycleDetectionResult;
+    /**
+     * Record a stage invocation by creating a marker.
+     * The caller should append this to their comment.
+     */
+    recordInvocation(stage: PipelineStage): string;
+    /**
+     * Get the max invocation limit for a stage.
+     */
+    getMaxInvocations(stage: PipelineStage): number;
+    /**
+     * Update max invocations for specific stages.
+     */
+    updateMaxInvocations(overrides: Partial<Record<PipelineStage, number>>): void;
+}
+//# sourceMappingURL=pipeline-cycle-detector.d.ts.map

package/dist/pipeline-cycle-detector.js

@@ -0,0 +1,111 @@
+/**
+ * PipelineCycleDetector — tracks stage invocations per issue/PR across
+ * all workflow runs to detect infinite orchestration loops.
+ *
+ * Uses GitHub issue/PR comments as shared state (hidden HTML markers)
+ * to work across workflow boundaries.
+ */
+/**
+ * Default max invocations per stage.
+ * These must be HIGHER than the per-stage retry limits (which are the
+ * primary guard). The cycle detector is a safety net for cross-stage
+ * loops, not a replacement for retry counting.
+ *
+ * Per-stage retry limits: fix-ci=2, fix-review=2
+ * Cycle limits: set to retry_limit + 2 to allow retries + headroom
+ */
+export const DEFAULT_CYCLE_LIMITS = {
+    admission: 5,
+    triage: 5,
+    agent: 5,
+    review: 4,
+    'fix-ci': 4,
+    'fix-review': 4,
+};
+/**
+ * Generate HTML comment marker for a stage invocation.
+ * Format: <!-- ai-sdlc-cycle:{stage}:{timestamp} -->
+ */
+export function createStageMarker(stage) {
+    const timestamp = Date.now();
+    return `<!-- ai-sdlc-cycle:${stage}:${timestamp} -->`;
+}
+/**
+ * Parse stage invocation markers from comment bodies.
+ * Returns a map of stage -> invocation count.
+ */
+export function parseStageInvocations(comments) {
+    const counts = new Map();
+    // Non-backtracking pattern: stage names are alphanumeric with optional single hyphens
+    const markerPattern = /<!-- ai-sdlc-cycle:([a-z][a-z0-9-]{0,30}):(\d{1,15}) -->/g;
+    for (const body of comments) {
+        let match;
+        while ((match = markerPattern.exec(body)) !== null) {
+            const stage = match[1];
+            counts.set(stage, (counts.get(stage) ?? 0) + 1);
+        }
+    }
+    return counts;
+}
+export class PipelineCycleDetector {
+    config;
+    constructor(config) {
+        this.config = {
+            maxInvocations: { ...DEFAULT_CYCLE_LIMITS, ...config?.maxInvocations },
+        };
+    }
+    /**
+     * Check if a cycle exists for the given issue/PR by analyzing comment history.
+     * @param pendingStage — if set, adds +1 to this stage's count to account for the upcoming invocation
+     */
+    async detectCycle(tracker, issueOrPrId, pendingStage) {
+        const comments = await tracker.getComments(issueOrPrId);
+        const commentBodies = comments.map((c) => c.body);
+        return this.detectCycleFromComments(commentBodies, pendingStage);
+    }
+    /**
+     * Detect cycle from comment bodies (for testing without IssueTracker).
+     * @param pendingStage — if set, adds +1 to this stage's count for the pending invocation
+     */
+    detectCycleFromComments(comments, pendingStage) {
+        const invocations = parseStageInvocations(comments);
+        // Account for the pending invocation that hasn't been recorded yet
+        if (pendingStage) {
+            invocations.set(pendingStage, (invocations.get(pendingStage) ?? 0) + 1);
+        }
+        const loopingStages = [];
+        let totalInvocations = 0;
+        for (const [stage, count] of invocations.entries()) {
+            totalInvocations += count;
+            const max = this.config.maxInvocations[stage];
+            if (count >= max) {
+                loopingStages.push({ stage, count, max });
+            }
+        }
+        return {
+            cycleDetected: loopingStages.length > 0,
+            loopingStages,
+            totalInvocations,
+        };
+    }
+    /**
+     * Record a stage invocation by creating a marker.
+     * The caller should append this to their comment.
+     */
+    recordInvocation(stage) {
+        return createStageMarker(stage);
+    }
+    /**
+     * Get the max invocation limit for a stage.
+     */
+    getMaxInvocations(stage) {
+        return this.config.maxInvocations[stage];
+    }
+    /**
+     * Update max invocations for specific stages.
+     */
+    updateMaxInvocations(overrides) {
+        this.config.maxInvocations = { ...this.config.maxInvocations, ...overrides };
+    }
+}
+//# sourceMappingURL=pipeline-cycle-detector.js.map

package/dist/priority.d.ts

@@ -10,82 +10,13 @@
  *
  * RFC reference: PPA section (priority scoring).
  */
-export interface PriorityScore {
-    composite: number;
-    dimensions: {
-        soulAlignment: number;
-        demandPressure: number;
-        marketForce: number;
-        executionReality: number;
-        entropyTax: number;
-        humanCurve: number;
-        calibration: number;
-    };
-    confidence: number;
-    timestamp: string;
-    /** Present when the score was produced via override. */
-    override?: {
-        reason: string;
-        expiry?: string;
-    };
-}
-export interface PriorityInput {
-    /** Work item identifier */
-    itemId: string;
-    /** Work item title and description for semantic analysis */
-    title: string;
-    description: string;
-    /** Labels/tags on the work item */
-    labels?: string[];
-    /** Pre-computed soul alignment score, or undefined to skip */
-    soulAlignment?: number;
-    /** Number of customer requests for this feature */
-    customerRequestCount?: number;
-    /** Recency-weighted demand signal [0, 1] */
-    demandSignal?: number;
-    /** Bug severity if this is a bug (1-5, 5=critical) */
-    bugSeverity?: number;
-    /** Builder conviction / roadmap priority [0, 1] */
-    builderConviction?: number;
-    /** Technology inflection relevance [0, 1] */
-    techInflection?: number;
-    /** Competitive pressure relevance [0, 1] */
-    competitivePressure?: number;
-    /** Regulatory urgency [0, 1] */
-    regulatoryUrgency?: number;
-    /** Task complexity from parseComplexity() (1-10) */
-    complexity?: number;
-    /** Budget utilization percent from CostTracker */
-    budgetUtilization?: number;
-    /** Are dependencies clear? [0, 1] */
-    dependencyClearance?: number;
-    /** Competitive drift score [0, 1] */
-    competitiveDrift?: number;
-    /** Market divergence [0, 1] */
-    marketDivergence?: number;
-    /** Explicit priority from backlog tool [0, 1] */
-    explicitPriority?: number;
-    /** Team consensus signal (votes, watchers) [0, 1] */
-    teamConsensus?: number;
-    /** Meeting decision weight [0, 1] */
-    meetingDecision?: number;
-    /** Override flag — if true, bypasses algorithm */
-    override?: boolean;
-    /** Override reason (required when override=true) */
-    overrideReason?: string;
-    /** Override expiry ISO timestamp */
-    overrideExpiry?: string;
-}
-export interface PriorityConfig {
-    /** Weights for human curve sub-components */
-    humanCurveWeights?: {
-        explicit?: number;
-        consensus?: number;
-        decision?: number;
-    };
-    /** Calibration coefficient (default 1.0) */
-    calibrationCoefficient?: number;
-}
+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.
  *