@ai-sdlc/orchestrator 0.5.0 → 0.9.0

package/dist/admission-enrichment.js

@@ -0,0 +1,331 @@
+/**
+ * Bridge between stateless admission scoring and the stateful orchestrator
+ * (RFC-0008 Addendum A §A.2 – §A.5).
+ *
+ * `enrichAdmissionInput()` reads from the orchestrator's state store and
+ * resolved resources to populate the RFC-0008 context fields on
+ * `AdmissionInput`, then `computeDesignSystemReadiness()` produces the
+ * Eρ₄ scalar that feeds the admission composite in §A.6.
+ *
+ * Scope for AISDLC-43: implement C2 (Eρ₄) only. C3/C4/C5 are populated
+ * by later tasks (AISDLC-44/45/46).
+ */
+import { checkHasFrontendComponents } from './code-area-classifier.js';
+import { checkDesignAuthority } from './design-authority.js';
+/**
+ * Minimum data points required before `code_area_metrics` is trusted
+ * enough to drive defect-risk penalties (RFC-0008 §7.4 Open Question 4).
+ */
+export const CODE_AREA_METRICS_MIN_DATA_POINTS = 10;
+/** Default window (ms) for `getCodeAreaMetrics` lookups — 90 days. */
+const DEFAULT_METRICS_WINDOW_MS = 90 * 24 * 60 * 60 * 1000;
+/**
+ * Populate `designSystemContext` on the admission input using the
+ * resolved DSB and state store. Returns the input unchanged when no DSB
+ * is available (preDesignSystem phase — caller falls through to the
+ * stateless path).
+ */
+export function enrichAdmissionInput(input, ctx) {
+    const binding = ctx.designSystemBinding;
+    const codeAreaQuality = ctx.codeArea
+        ? buildCodeAreaQuality(ctx.codeArea, ctx.stateStore, ctx.now)
+        : undefined;
+    const autonomyContext = buildAutonomyContext(ctx);
+    const designAuthoritySignal = buildDesignAuthoritySignal(input, ctx);
+    if (!binding) {
+        const next = { ...input };
+        // When ctx.codeArea is set but buildCodeAreaQuality returns undefined
+        // (insufficient data), explicitly clear any stale value that may have
+        // been carried over from input — otherwise the spread above preserves
+        // it and drives a bogus defect-risk penalty.
+        if (ctx.codeArea)
+            next.codeAreaQuality = codeAreaQuality;
+        if (autonomyContext)
+            next.autonomyContext = autonomyContext;
+        if (designAuthoritySignal)
+            next.designAuthoritySignal = designAuthoritySignal;
+        return next;
+    }
+    const catalogCoverageRaw = binding.status?.catalogHealth?.coveragePercent;
+    const tokenComplianceRaw = binding.status?.tokenCompliance?.currentCoverage;
+    const catalogCoverage = normalizeCoverage(catalogCoverageRaw);
+    const tokenCompliance = normalizeCoverage(tokenComplianceRaw);
+    const baselineCoverage = ctx.stateStore
+        ? computeBaselineCoverage(ctx.stateStore, binding.metadata.name)
+        : 0;
+    const ageDays = computeDsbAgeDays(ctx.dsbAdoptedAt, ctx.now);
+    const phase = detectLifecyclePhase(binding, catalogCoverage, ageDays);
+    const context = {
+        catalogCoverage,
+        tokenCompliance,
+        inBootstrapPhase: phase === 'catalogBootstrap',
+        baselineCoverage,
+        catalogGaps: ctx.catalogGaps ?? [],
+    };
+    return {
+        ...input,
+        designSystemContext: context,
+        // When ctx.codeArea is set we always write codeAreaQuality — either
+        // the computed value or `undefined` — so stale input.codeAreaQuality
+        // can't silently drive a penalty under fresh enrichment context.
+        ...(ctx.codeArea ? { codeAreaQuality } : {}),
+        ...(autonomyContext ? { autonomyContext } : {}),
+        ...(designAuthoritySignal ? { designAuthoritySignal } : {}),
+    };
+}
+/**
+ * Read code-area metrics within the 90-day window and project them into
+ * the `CodeAreaQuality` shape. Returns undefined when the metric row is
+ * missing or has fewer than `CODE_AREA_METRICS_MIN_DATA_POINTS` samples —
+ * downstream defect-risk consumers treat "absent" as 0 penalty.
+ */
+function buildCodeAreaQuality(codeArea, store, now) {
+    if (!store) {
+        // No state → fall back to heuristic classification only.
+        return { hasFrontendComponents: checkHasFrontendComponents(codeArea) };
+    }
+    const windowStart = new Date((now ?? (() => Date.now()))() - DEFAULT_METRICS_WINDOW_MS).toISOString();
+    const metrics = store.getCodeAreaMetrics(codeArea, { since: windowStart });
+    if (!metrics || (metrics.dataPointCount ?? 0) < CODE_AREA_METRICS_MIN_DATA_POINTS) {
+        return undefined;
+    }
+    const designQuality = parseDesignQuality(metrics.designMetricsJson);
+    return {
+        defectDensity: metrics.defectDensity,
+        churnRate: metrics.churnRate,
+        prRejectionRate: metrics.prRejectionRate,
+        hasFrontendComponents: metrics.hasFrontendComponents ?? false,
+        ...(designQuality ? { designQuality } : {}),
+    };
+}
+function parseDesignQuality(json) {
+    if (!json)
+        return undefined;
+    try {
+        const parsed = JSON.parse(json);
+        if (parsed.designCIPassRate === undefined &&
+            parsed.designReviewRejectionRate === undefined &&
+            parsed.usabilitySimPassRate === undefined) {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Compute the C3 defect-risk factor per §A.5. Returns 0 when
+ * `codeAreaQuality` is absent (insufficient data → no penalty).
+ *
+ *   !hasFrontendComponents  → 0.5×dd + 0.3×churn + 0.2×prRej
+ *   hasFrontendComponents
+ *     no designQuality      → same as pure code (no blend target)
+ *     with designQuality    → 0.7 × code + 0.3 × design
+ *                              where design = 0.4×(1-ciPass)
+ *                                           + 0.4×reviewRej
+ *                                           + 0.2×(1-usabPass)
+ *
+ * Final value is clamped to [0, 0.5].
+ */
+export function computeDefectRiskFactor(quality) {
+    if (!quality)
+        return 0;
+    const code = 0.5 * (quality.defectDensity ?? 0) +
+        0.3 * (quality.churnRate ?? 0) +
+        0.2 * (quality.prRejectionRate ?? 0);
+    if (!quality.hasFrontendComponents || !quality.designQuality) {
+        return clamp(code, 0, 0.5);
+    }
+    const dq = quality.designQuality;
+    const ciPass = dq.designCIPassRate ?? 1;
+    const reviewRej = dq.designReviewRejectionRate ?? 0;
+    const usabPass = dq.usabilitySimPassRate ?? 1;
+    const design = 0.4 * (1 - ciPass) + 0.4 * reviewRej + 0.2 * (1 - usabPass);
+    const blended = 0.7 * code + 0.3 * design;
+    return clamp(blended, 0, 0.5);
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+// ── C4 Autonomy Factor ─────────────────────────────────────────────────
+/**
+ * Map task complexity to the required autonomy level per §A.4:
+ *   complexity ≤ 3  → level 1
+ *   complexity ≤ 6  → level 2
+ *   else            → level 3
+ */
+export function complexityToAutonomyLevel(complexity) {
+    if (complexity <= 3)
+        return 1;
+    if (complexity <= 6)
+        return 2;
+    return 3;
+}
+/**
+ * Compute the C4 autonomy factor per §A.5:
+ *   gap = requiredLevel - currentEarnedLevel
+ *   gap > 0  → max(0.1, 1.0 - gap × 0.4)
+ *   gap ≤ 0  → 1.0
+ */
+export function computeAutonomyFactor(ctx) {
+    if (!ctx)
+        return 1.0;
+    const gap = ctx.requiredLevel - ctx.currentEarnedLevel;
+    if (gap <= 0)
+        return 1.0;
+    return Math.max(0.1, 1.0 - gap * 0.4);
+}
+function buildAutonomyContext(ctx) {
+    if (!ctx.autonomyPolicy)
+        return undefined;
+    const agents = ctx.autonomyPolicy.status?.agents ?? [];
+    if (agents.length === 0)
+        return undefined;
+    const selected = ctx.agentName
+        ? agents.find((a) => a.name === ctx.agentName)
+        : pickMostPermissiveAgent(agents);
+    if (!selected)
+        return undefined;
+    const currentEarnedLevel = selected.currentLevel;
+    const requiredLevel = ctx.complexity !== undefined ? complexityToAutonomyLevel(ctx.complexity) : currentEarnedLevel;
+    return { currentEarnedLevel, requiredLevel };
+}
+function pickMostPermissiveAgent(agents) {
+    return agents.reduce((best, a) => (a.currentLevel > best.currentLevel ? a : best), agents[0]);
+}
+// ── C5 Design Authority Signal + HC_design ─────────────────────────────
+/** Base weights per signal type (§A.5) before compliance modulation. */
+const DESIGN_AUTHORITY_BASE_WEIGHT = Object.freeze({
+    'advances-design-coherence': 0.6,
+    'fills-catalog-gap': 0.6,
+    'fragments-component-catalog': -0.4,
+    'misaligned-with-brand': -0.4,
+    unspecified: 0.3,
+});
+/**
+ * Compute the C5 design-authority weight per §A.5.
+ *
+ *   non-authority           → 0.0
+ *   authority + positive    → +0.6 × modulation
+ *   authority + negative    → -0.4 × modulation
+ *   authority + no type     → +0.3 × modulation
+ *
+ * where `modulation = 1.2 - areaComplianceScore` when the score is
+ * supplied, else `1.0` (unmodulated base weight).
+ */
+export function computeDesignAuthorityWeight(signal) {
+    if (!signal || !signal.isDesignAuthority)
+        return 0;
+    const signalType = signal.signalType ?? 'unspecified';
+    const base = DESIGN_AUTHORITY_BASE_WEIGHT[signalType];
+    const modulation = signal.areaComplianceScore !== undefined ? 1.2 - signal.areaComplianceScore : 1;
+    return base * modulation;
+}
+function buildDesignAuthoritySignal(input, ctx) {
+    if (!ctx.designSystemBinding)
+        return undefined;
+    const { isDesignAuthority, signalType } = checkDesignAuthority({
+        authorLogin: input.authorLogin,
+        commenterLogins: input.commenterLogins,
+        labels: input.labels,
+    }, ctx.designSystemBinding);
+    if (!isDesignAuthority)
+        return { isDesignAuthority: false };
+    return {
+        isDesignAuthority: true,
+        signalType,
+        ...(ctx.areaComplianceScore !== undefined
+            ? { areaComplianceScore: ctx.areaComplianceScore }
+            : {}),
+    };
+}
+/**
+ * Compute the C2 Eρ₄ design-system readiness scalar in [0, 1] per §A.5.
+ *
+ *   preDesignSystem:   1.0 (no DSB → no penalty)
+ *   catalogBootstrap:  max(0.3, 0.4×cat + 0.3×tok + 0.3×baseline)
+ *   postDesignSystem:  0.4×cat + 0.3×tok + 0.3×baseline
+ */
+export function computeDesignSystemReadiness(ctx) {
+    const binding = ctx.designSystemBinding;
+    if (!binding)
+        return 1.0;
+    const catalogCoverage = normalizeCoverage(binding.status?.catalogHealth?.coveragePercent);
+    const tokenCompliance = normalizeCoverage(binding.status?.tokenCompliance?.currentCoverage);
+    const baselineCoverage = ctx.stateStore
+        ? computeBaselineCoverage(ctx.stateStore, binding.metadata.name)
+        : 0;
+    const ageDays = computeDsbAgeDays(ctx.dsbAdoptedAt, ctx.now);
+    const phase = detectLifecyclePhase(binding, catalogCoverage, ageDays);
+    const computed = 0.4 * catalogCoverage + 0.3 * tokenCompliance + 0.3 * baselineCoverage;
+    if (phase === 'catalogBootstrap')
+        return Math.max(0.3, computed);
+    return computed;
+}
+/**
+ * Compute the C2 Eρ₄ scalar directly from the DesignSystemContext
+ * already populated on an `AdmissionInput` (no DSB/state lookups).
+ *
+ *   undefined (preDesignSystem) → 1.0
+ *   inBootstrapPhase            → max(0.3, computed)
+ *   else                        → computed
+ *
+ * Used by the admission composite (§A.6) to avoid re-reading the state
+ * store on every score call.
+ */
+export function computeReadinessFromDesignSystemContext(context) {
+    if (!context)
+        return 1.0;
+    const catalogCoverage = normalizeCoverage(context.catalogCoverage);
+    const tokenCompliance = normalizeCoverage(context.tokenCompliance);
+    const baselineCoverage = normalizeCoverage(context.baselineCoverage);
+    const computed = 0.4 * catalogCoverage + 0.3 * tokenCompliance + 0.3 * baselineCoverage;
+    if (context.inBootstrapPhase)
+        return Math.max(0.3, computed);
+    return computed;
+}
+export function detectLifecyclePhase(binding, normalizedCatalogCoverage, ageDays) {
+    if (!binding)
+        return 'preDesignSystem';
+    if (normalizedCatalogCoverage < 0.2 && ageDays < 90)
+        return 'catalogBootstrap';
+    return 'postDesignSystem';
+}
+/**
+ * Days since the DSB was adopted. Returns 0 when no adoption timestamp
+ * is supplied — the conservative default (treats DSB as brand-new and
+ * favours the bootstrap floor).
+ */
+export function computeDsbAgeDays(adoptedAt, now) {
+    if (!adoptedAt)
+        return 0;
+    const adoptedMs = Date.parse(adoptedAt);
+    if (Number.isNaN(adoptedMs))
+        return 0;
+    const nowMs = (now ?? (() => Date.now()))();
+    const diffMs = Math.max(0, nowMs - adoptedMs);
+    return diffMs / (1000 * 60 * 60 * 24);
+}
+/**
+ * Fraction of the UI under visual-regression monitoring for this binding,
+ * derived from approved baselines in `visual_regression_results`.
+ *
+ * Definition (§A.5 proxy): `approvedBaselines / totalBaselines`. Returns
+ * 0 when no history exists (bootstrap protection: avoids over-crediting
+ * readiness when the monitor hasn't run yet).
+ */
+export function computeBaselineCoverage(store, bindingName) {
+    const history = store.getVisualRegressionResults(bindingName, 1000);
+    if (history.length === 0)
+        return 0;
+    const approved = history.filter((r) => Boolean(r.approved)).length;
+    return approved / history.length;
+}
+function normalizeCoverage(value) {
+    if (value === undefined || Number.isNaN(value))
+        return 0;
+    const clamped = value > 1 ? value / 100 : value;
+    return Math.min(1, Math.max(0, clamped));
+}
+//# sourceMappingURL=admission-enrichment.js.map

package/dist/admission-hc.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Admission-specific Human Curve composite (RFC-0008 §A.6, Amendment 4).
+ *
+ * The admission HC differs from the legacy PPA HC in two ways:
+ *   1. Four terms instead of three — HC_design enters at 0.10 weight.
+ *   2. Weights are (0.2, 0.45, 0.25, 0.10) rather than (0.5, 0.3, 0.2).
+ *
+ * HC_design flows through tanh alongside the other three components;
+ * it is NOT a direct soul-alignment modifier (Amendment 5 correction
+ * to the v3 draft).
+ *
+ * The `override` bypass on `PriorityInput` is still position-1: this
+ * module never runs when an override is active — the admission
+ * composite (AISDLC-48) short-circuits on override before calling
+ * `computeAdmissionHumanCurve`.
+ */
+import type { AdmissionInput, DesignAuthoritySignal } from './admission-score.js';
+/**
+ * Fixed §A.6 weights. Exposed for validation and for downstream callers
+ * that need to introspect the HC decomposition.
+ */
+export declare const HC_WEIGHTS: Readonly<{
+    explicit: 0.2;
+    consensus: 0.45;
+    decision: 0.25;
+    design: 0.1;
+}>;
+/** Sum of HC_WEIGHTS — must equal 1.0 exactly (AC #2). */
+export declare const HC_WEIGHT_SUM: number;
+export interface AdmissionHumanCurveResult {
+    /** Signed explicit-priority signal in [-1, 1]. */
+    hcExplicit: number;
+    /** Signed consensus signal in [-1, 1]. */
+    hcConsensus: number;
+    /** Signed meeting-decision signal in [-1, 1] (0 = neutral when absent). */
+    hcDecision: number;
+    /** Signed design-authority signal in [-1, 1]. */
+    hcDesign: number;
+    /** Weighted sum before tanh. */
+    hcRaw: number;
+    /** `tanh(hcRaw)` — the HC value consumed by the admission composite. */
+    hcComposite: number;
+}
+export declare function deriveHcExplicit(input: Pick<AdmissionInput, 'labels'>): number;
+export declare function deriveHcConsensus(input: Pick<AdmissionInput, 'reactionCount' | 'authorAssociation'>): number;
+/**
+ * HC_decision — meeting-decision signal in [-1, 1].
+ *
+ * AdmissionInput has no dedicated meeting-decision field. We return
+ * neutral (0) by default. Callers that later add a GitHub-comment
+ * parser for `/decide approve` / `/decide reject` can plumb it through
+ * via an optional AdmissionInput field without breaking this shape.
+ */
+export declare function deriveHcDecision(_input: AdmissionInput): number;
+export declare function deriveHcDesign(signal: DesignAuthoritySignal | undefined): number;
+/**
+ * Compute the admission HC composite from an `AdmissionInput`.
+ * Returns both the weighted pre-tanh sum and the tanh-compressed value
+ * for auditability.
+ */
+export declare function computeAdmissionHumanCurve(input: AdmissionInput): AdmissionHumanCurveResult;
+//# sourceMappingURL=admission-hc.d.ts.map

package/dist/admission-hc.js

@@ -0,0 +1,83 @@
+/**
+ * Admission-specific Human Curve composite (RFC-0008 §A.6, Amendment 4).
+ *
+ * The admission HC differs from the legacy PPA HC in two ways:
+ *   1. Four terms instead of three — HC_design enters at 0.10 weight.
+ *   2. Weights are (0.2, 0.45, 0.25, 0.10) rather than (0.5, 0.3, 0.2).
+ *
+ * HC_design flows through tanh alongside the other three components;
+ * it is NOT a direct soul-alignment modifier (Amendment 5 correction
+ * to the v3 draft).
+ *
+ * The `override` bypass on `PriorityInput` is still position-1: this
+ * module never runs when an override is active — the admission
+ * composite (AISDLC-48) short-circuits on override before calling
+ * `computeAdmissionHumanCurve`.
+ */
+import { computeDesignAuthorityWeight } from './admission-enrichment.js';
+/**
+ * Fixed §A.6 weights. Exposed for validation and for downstream callers
+ * that need to introspect the HC decomposition.
+ */
+export const HC_WEIGHTS = Object.freeze({
+    explicit: 0.2,
+    consensus: 0.45,
+    decision: 0.25,
+    design: 0.1,
+});
+/** Sum of HC_WEIGHTS — must equal 1.0 exactly (AC #2). */
+export const HC_WEIGHT_SUM = HC_WEIGHTS.explicit + HC_WEIGHTS.consensus + HC_WEIGHTS.decision + HC_WEIGHTS.design;
+const TRUSTED_ASSOCIATIONS = new Set(['OWNER', 'MEMBER', 'COLLABORATOR']);
+export function deriveHcExplicit(input) {
+    const labels = input.labels;
+    if (labels.includes('high') || labels.includes('P0') || labels.includes('critical')) {
+        return 1.0;
+    }
+    if (labels.includes('low') || labels.includes('backlog'))
+        return -1.0;
+    return 0;
+}
+export function deriveHcConsensus(input) {
+    const isTrusted = TRUSTED_ASSOCIATIONS.has(input.authorAssociation ?? 'NONE');
+    const reactionConsensus = Math.min(1, input.reactionCount / 5);
+    // Trusted authors carry implicit team consensus — floor at 0.5 before centering.
+    const base = isTrusted ? Math.max(0.5, reactionConsensus) : reactionConsensus;
+    // [0, 1] → [-1, 1]
+    return base * 2 - 1;
+}
+/**
+ * HC_decision — meeting-decision signal in [-1, 1].
+ *
+ * AdmissionInput has no dedicated meeting-decision field. We return
+ * neutral (0) by default. Callers that later add a GitHub-comment
+ * parser for `/decide approve` / `/decide reject` can plumb it through
+ * via an optional AdmissionInput field without breaking this shape.
+ */
+export function deriveHcDecision(_input) {
+    return 0;
+}
+export function deriveHcDesign(signal) {
+    const raw = computeDesignAuthorityWeight(signal);
+    return clamp(raw, -1, 1);
+}
+/**
+ * Compute the admission HC composite from an `AdmissionInput`.
+ * Returns both the weighted pre-tanh sum and the tanh-compressed value
+ * for auditability.
+ */
+export function computeAdmissionHumanCurve(input) {
+    const hcExplicit = deriveHcExplicit(input);
+    const hcConsensus = deriveHcConsensus(input);
+    const hcDecision = deriveHcDecision(input);
+    const hcDesign = deriveHcDesign(input.designAuthoritySignal);
+    const hcRaw = HC_WEIGHTS.explicit * hcExplicit +
+        HC_WEIGHTS.consensus * hcConsensus +
+        HC_WEIGHTS.decision * hcDecision +
+        HC_WEIGHTS.design * hcDesign;
+    const hcComposite = Math.tanh(hcRaw);
+    return { hcExplicit, hcConsensus, hcDecision, hcDesign, hcRaw, hcComposite };
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+//# sourceMappingURL=admission-hc.js.map

package/dist/admission-score.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Issue admission scoring — maps GitHub issue fields to PPA dimensions
+ * and determines whether an issue should enter the pipeline.
+ *
+ * Extracted from dogfood/scripts/ppa-score.ts for reuse across CLI
+ * scripts and workflows.
+ */
+import type { PriorityInput, PriorityScore, PriorityConfig } from './priority.js';
+import { type PillarBreakdown } from './pillar-breakdown.js';
+/**
+ * GitHub author_association values indicating trust level.
+ * OWNER/MEMBER/COLLABORATOR = trusted (project team)
+ * CONTRIBUTOR = semi-trusted (has had PRs merged)
+ * NONE = untrusted (external)
+ */
+export type AuthorAssociation = 'OWNER' | 'MEMBER' | 'COLLABORATOR' | 'CONTRIBUTOR' | 'FIRST_TIMER' | 'FIRST_TIME_CONTRIBUTOR' | 'NONE';
+export interface AdmissionInput {
+    issueNumber: number;
+    title: string;
+    body: string;
+    labels: string[];
+    /** Total thumbsUp + heart reactions. */
+    reactionCount: number;
+    /** Number of human comments. */
+    commentCount: number;
+    /** ISO timestamp of issue creation. */
+    createdAt: string;
+    /** GitHub author_association — determines trust-based signal boosting. */
+    authorAssociation?: AuthorAssociation;
+    /** GitHub login of the issue author (used by C5 principal match). */
+    authorLogin?: string;
+    /** GitHub logins of anyone who commented on the issue (C5 principal match). */
+    commenterLogins?: string[];
+    /** C2 Eρ₄ inputs — populated by enrichAdmissionInput() (AISDLC-43). */
+    designSystemContext?: DesignSystemContext;
+    /** C4 inputs — current earned autonomy vs. required level (AISDLC-45). */
+    autonomyContext?: AutonomyContext;
+    /** C3 inputs — defect/churn/rejection signals per code area (AISDLC-44). */
+    codeAreaQuality?: CodeAreaQuality;
+    /** C5 inputs — HC_design signal from design-authority principals (AISDLC-46). */
+    designAuthoritySignal?: DesignAuthoritySignal;
+    /**
+     * Backlog-task signals (RFC-0010 dual-workflow). Populated when the issue comes
+     * from a Backlog.md task instead of GitHub. Used to discriminate between tasks
+     * that share identical GitHub-style signals (no reactions / no comments / OWNER
+     * author) — typical for the internal backlog workflow.
+     */
+    backlogContext?: BacklogContext;
+}
+export interface BacklogContext {
+    /** Frontmatter `priority` field — operator's stated importance. */
+    priority?: 'critical' | 'high' | 'medium' | 'low';
+    /** Number of tasks this one is blocked by (frontmatter `dependencies`). */
+    dependencyCount?: number;
+    /** Number of file/RFC/URL references in the task body. */
+    referenceCount?: number;
+    /** Number of acceptance criteria — proxy for scope. */
+    acceptanceCriteriaCount?: number;
+    /** Frontmatter `status` value (e.g. "To Do", "Draft", "In Progress", "Done"). */
+    status?: string;
+}
+export interface DesignSystemContext {
+    /** Catalog coverage percent (0–100) from DSB.status.catalogHealth. */
+    catalogCoverage?: number;
+    /** Token compliance percent (0–100) from DSB.status.tokenCompliance. */
+    tokenCompliance?: number;
+    /** True when DSB is young or catalog coverage is below the bootstrap floor. */
+    inBootstrapPhase?: boolean;
+    /** Baseline coverage from visual_regression_results before DSB adoption. */
+    baselineCoverage?: number;
+    /** Component/token gaps preventing the issue from being built catalog-first. */
+    catalogGaps?: string[];
+}
+export interface AutonomyContext {
+    /** The AutonomyPolicy-issued earned level for the current agent (0–3). */
+    currentEarnedLevel: number;
+    /** Level required by the issue's complexity band (≤3→1, ≤6→2, else→3). */
+    requiredLevel: number;
+}
+export interface DesignQualityMetrics {
+    /** Fraction of design CI checks passing in the window (0–1). */
+    designCIPassRate?: number;
+    /** Fraction of PRs in the area rejected on design grounds (0–1). */
+    designReviewRejectionRate?: number;
+    /** Fraction of usability-sim tasks completed successfully (0–1). */
+    usabilitySimPassRate?: number;
+}
+export interface CodeAreaQuality {
+    defectDensity?: number;
+    churnRate?: number;
+    prRejectionRate?: number;
+    /** True when the code area produces frontend artifacts gated by the DSB. */
+    hasFrontendComponents: boolean;
+    /** Present only when `hasFrontendComponents === true`. */
+    designQuality?: DesignQualityMetrics;
+}
+export type DesignAuthoritySignalType = 'advances-design-coherence' | 'fills-catalog-gap' | 'fragments-component-catalog' | 'misaligned-with-brand' | 'unspecified';
+export interface DesignAuthoritySignal {
+    /** True when the issue author/commenter is a DSB designAuthority principal. */
+    isDesignAuthority: boolean;
+    /** The signal type parsed from labels or structured comments. */
+    signalType?: DesignAuthoritySignalType;
+    /** The issue's code area compliance score in [0, 1] (used to modulate weight). */
+    areaComplianceScore?: number;
+}
+export interface AdmissionThresholds {
+    minimumScore: number;
+    minimumConfidence: number;
+}
+export interface IssueAdmissionResult {
+    admitted: boolean;
+    score: PriorityScore;
+    reason: string;
+    suggestions?: string[];
+    /**
+     * RFC-0008 §A.6 — pillar attribution + tension flags. Required on
+     * every admission result so reviewers can act on pillar mismatches.
+     */
+    pillarBreakdown: PillarBreakdown;
+}
+/**
+ * Map GitHub issue fields to PPA PriorityInput dimensions.
+ *
+ * Heuristics (ported from dogfood/scripts/ppa-score.ts):
+ * - Labels → bug severity, soul alignment hints, builder conviction
+ * - Reactions → team consensus, customer request count
+ * - Comments → demand signal
+ * - Body complexity section → complexity score
+ * - Issue age → competitive drift
+ */
+export declare function mapIssueToPriorityInput(input: AdmissionInput): PriorityInput;
+/**
+ * Score a GitHub issue for pipeline admission using the RFC-0008 §A.6
+ * admission-subset composite.
+ *
+ *   P_admission = SA × D-pi_adjusted × ER × (1 + HC)
+ *
+ * M-phi, E-tau, C-kappa are deferred to runtime scoring — they apply
+ * when an admitted issue is picked up for execution, not at the gate.
+ *
+ * Returns whether the issue is admitted (score and confidence above
+ * thresholds) along with the full score and, if rejected, suggestions
+ * for improvement.
+ */
+export declare function scoreIssueForAdmission(input: AdmissionInput, thresholds: AdmissionThresholds, priorityConfig?: PriorityConfig, options?: import('./admission-composite.js').AdmissionCompositeOptions): IssueAdmissionResult;
+/** Map backlog frontmatter priority string to the typed BacklogContext shape. */
+export declare function normalizeBacklogPriority(p: string | null | undefined): BacklogContext['priority'];
+//# sourceMappingURL=admission-score.d.ts.map