@ai-sdlc/orchestrator 0.10.0 → 0.13.0

package/dist/sa-scoring/layer3-llm.js

@@ -180,7 +180,12 @@ export function buildSa2Prompt(ctx) {
 }
 /** Extract the first JSON object from a raw LLM reply. */
 export function extractJson(raw) {
-    const fenced = raw.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    // Drop the leading optional-whitespace group entirely: any `[ \t]*`/`\s*`
+    // before the lazy `[\s\S]*?` capture overlaps it (both match space/tab),
+    // which is the polynomial-backtracking source (CodeQL js/polynomial-redos).
+    // The bounded `\n?` (0-or-1, not a `*`) is safe, and `.trim()` below absorbs
+    // any residual leading whitespace the capture picks up.
+    const fenced = raw.match(/```(?:json)?\n?([\s\S]*?)```/i);
     const candidate = fenced ? fenced[1] : raw;
     try {
         return JSON.parse(candidate.trim());

package/dist/sa-scoring/revision-proposal-config.d.ts

@@ -0,0 +1,178 @@
+/**
+ * Per-org calibration.yaml configuration for RFC-0031 DIDRevisionProposal
+ * mechanism (Refit AISDLC-310).
+ *
+ * Exposes OQ-12.1 (confidence thresholds) and OQ-12.5 (rejection weights +
+ * penalty floor) as per-org configurable values. Defaults match the values
+ * shipped by AISDLC-271 / PR #476 and operator-affirmed during the 2026-05-16
+ * audit (RFC-0031 §12.1 + §12.5 resolutions).
+ *
+ * Usage:
+ *   1. Load the `.ai-sdlc/calibration.yaml` file.
+ *   2. Call `parseRevisionProposalCalibrationYaml(content)` — validates +
+ *      returns a fully-resolved config with all defaults filled in.
+ *   3. Pass the resolved config to `computeConfidence()`,
+ *      `recordRejection()`, and `computeRejectionPrecedentFactor()`.
+ *
+ * Validation rules (enforced at load time):
+ *   - `highSampleSize > lowSampleSize > 0`
+ *   - All weights in `[0, 1]`
+ *   - `confidencePenaltyFloor` in `[0, 1]`
+ */
+/** Minimum total signals (dismiss + escalate + drift) for HIGH confidence. */
+export declare const DEFAULT_CONFIDENCE_HIGH_SAMPLE_SIZE = 20;
+/** Below this total signal count the proposal is LOW confidence. */
+export declare const DEFAULT_CONFIDENCE_LOW_SAMPLE_SIZE = 5;
+/** Rejection precedent weight applied when the rejected proposal had HIGH confidence. */
+export declare const DEFAULT_REJECTION_WEIGHT_HIGH = 0.8;
+/** Rejection precedent weight applied when the rejected proposal had MEDIUM confidence. */
+export declare const DEFAULT_REJECTION_WEIGHT_MEDIUM = 0.5;
+/** Rejection precedent weight applied when the rejected proposal had LOW confidence. */
+export declare const DEFAULT_REJECTION_WEIGHT_LOW = 0.2;
+/**
+ * Minimum value for the rejection precedent factor.
+ * 0.2 = at most 80% suppression of future proposal confidence.
+ */
+export declare const DEFAULT_CONFIDENCE_PENALTY_FLOOR = 0.2;
+/**
+ * Confidence threshold configuration (OQ-12.1).
+ *
+ * Sample size = `dismissSignals + escalateSignals + driftEvents`.
+ */
+export interface ConfidenceThresholdsConfig {
+    /**
+     * Total signal count ≥ this value contributes toward HIGH confidence
+     * (alongside non-ambiguous classification and `evolving` identityClass).
+     *
+     * @default 20
+     */
+    highSampleSize: number;
+    /**
+     * Total signal count < this value forces LOW confidence.
+     *
+     * Must be < `highSampleSize`.
+     * @default 5
+     */
+    lowSampleSize: number;
+}
+/**
+ * Rejection precedent weights (OQ-12.5).
+ *
+ * These weights are stored on each `ProposalRejectionRecord` and averaged
+ * by `computeRejectionPrecedentFactor()` to suppress future proposal
+ * confidence for repeatedly-rejected fields.
+ */
+export interface RejectionPrecedentWeightsConfig {
+    /**
+     * Weight when the rejected proposal had HIGH confidence.
+     * Higher weight = stronger suppression of future proposals.
+     * @default 0.8
+     */
+    highConfidenceRejection: number;
+    /**
+     * Weight when the rejected proposal had MEDIUM confidence.
+     * @default 0.5
+     */
+    mediumConfidenceRejection: number;
+    /**
+     * Weight when the rejected proposal had LOW confidence.
+     * @default 0.2
+     */
+    lowConfidenceRejection: number;
+}
+/**
+ * Rejection precedent configuration block (OQ-12.5).
+ */
+export interface RejectionPrecedentConfig {
+    weights: RejectionPrecedentWeightsConfig;
+    /**
+     * Minimum value returned by `computeRejectionPrecedentFactor()`.
+     * Prevents the precedent factor from suppressing proposals entirely.
+     *
+     * Formula: `factor = max(confidencePenaltyFloor, 1.0 - avgWeight × 0.5)`
+     * @default 0.2
+     */
+    confidencePenaltyFloor: number;
+}
+/**
+ * Raw (partial) calibration config shape as it appears in `calibration.yaml`.
+ * All fields are optional; missing values fall back to defaults.
+ */
+export interface RevisionProposalCalibrationConfig {
+    /** Fields that should never receive auto-proposals (OQ-12.3 — existing). */
+    lockNoProposal?: string[];
+    /** Override confidence thresholds (OQ-12.1). */
+    confidenceThresholds?: Partial<ConfidenceThresholdsConfig>;
+    /** Override rejection precedent weights + floor (OQ-12.5). */
+    rejectionPrecedent?: {
+        weights?: Partial<RejectionPrecedentWeightsConfig>;
+        confidencePenaltyFloor?: number;
+    };
+}
+/**
+ * Fully-resolved calibration config — all optional fields replaced with
+ * defaults. This is the shape passed to the revision-proposal functions.
+ */
+export interface ResolvedRevisionProposalCalibrationConfig {
+    lockNoProposal: string[];
+    confidenceThresholds: ConfidenceThresholdsConfig;
+    rejectionPrecedent: RejectionPrecedentConfig;
+}
+/** The compile-time default resolved config (shipped AISDLC-271 values). */
+export declare const DEFAULT_RESOLVED_CALIBRATION_CONFIG: ResolvedRevisionProposalCalibrationConfig;
+export interface ConfigValidationError {
+    field: string;
+    message: string;
+}
+export type ConfigValidationResult = {
+    valid: true;
+} | {
+    valid: false;
+    errors: ConfigValidationError[];
+};
+/**
+ * Validate a partial calibration config against the RFC-0031 §12.6 rules.
+ *
+ * Rules:
+ *   - `highSampleSize > lowSampleSize > 0`
+ *   - all weights in `[0, 1]`
+ *   - `confidencePenaltyFloor` in `[0, 1]`
+ *
+ * Missing fields default to the shipped values and are not validated
+ * (a partial config that omits a field is always valid for that field).
+ */
+export declare function validateRevisionProposalCalibrationConfig(config: RevisionProposalCalibrationConfig): ConfigValidationResult;
+/**
+ * Merge a partial `RevisionProposalCalibrationConfig` with defaults to
+ * produce a fully-resolved config. Does NOT validate — call
+ * `validateRevisionProposalCalibrationConfig()` first if you need to
+ * surface errors to the operator.
+ */
+export declare function resolveRevisionProposalCalibrationConfig(config?: RevisionProposalCalibrationConfig): ResolvedRevisionProposalCalibrationConfig;
+/**
+ * Parse and validate a `.ai-sdlc/calibration.yaml` file's content.
+ *
+ * Expected top-level shape:
+ * ```yaml
+ * calibration:
+ *   lockNoProposal: [...]
+ *   confidenceThresholds:
+ *     highSampleSize: 20
+ *     lowSampleSize: 5
+ *   rejectionPrecedent:
+ *     weights:
+ *       highConfidenceRejection: 0.8
+ *       mediumConfidenceRejection: 0.5
+ *       lowConfidenceRejection: 0.2
+ *     confidencePenaltyFloor: 0.2
+ * ```
+ *
+ * Missing fields are filled with defaults. Validation failures throw with
+ * a descriptive message listing all constraint violations.
+ *
+ * @param yamlContent Raw UTF-8 content of `calibration.yaml`.
+ * @returns Fully-resolved config ready to pass to revision-proposal functions.
+ * @throws {Error} When the YAML fails RFC-0031 §12.6 validation rules.
+ */
+export declare function parseRevisionProposalCalibrationYaml(yamlContent: string): ResolvedRevisionProposalCalibrationConfig;
+//# sourceMappingURL=revision-proposal-config.d.ts.map

package/dist/sa-scoring/revision-proposal-config.js

@@ -0,0 +1,198 @@
+/**
+ * Per-org calibration.yaml configuration for RFC-0031 DIDRevisionProposal
+ * mechanism (Refit AISDLC-310).
+ *
+ * Exposes OQ-12.1 (confidence thresholds) and OQ-12.5 (rejection weights +
+ * penalty floor) as per-org configurable values. Defaults match the values
+ * shipped by AISDLC-271 / PR #476 and operator-affirmed during the 2026-05-16
+ * audit (RFC-0031 §12.1 + §12.5 resolutions).
+ *
+ * Usage:
+ *   1. Load the `.ai-sdlc/calibration.yaml` file.
+ *   2. Call `parseRevisionProposalCalibrationYaml(content)` — validates +
+ *      returns a fully-resolved config with all defaults filled in.
+ *   3. Pass the resolved config to `computeConfidence()`,
+ *      `recordRejection()`, and `computeRejectionPrecedentFactor()`.
+ *
+ * Validation rules (enforced at load time):
+ *   - `highSampleSize > lowSampleSize > 0`
+ *   - All weights in `[0, 1]`
+ *   - `confidencePenaltyFloor` in `[0, 1]`
+ */
+import { parse as parseYaml } from 'yaml';
+// ── Default constants ─────────────────────────────────────────────────
+/** Minimum total signals (dismiss + escalate + drift) for HIGH confidence. */
+export const DEFAULT_CONFIDENCE_HIGH_SAMPLE_SIZE = 20;
+/** Below this total signal count the proposal is LOW confidence. */
+export const DEFAULT_CONFIDENCE_LOW_SAMPLE_SIZE = 5;
+/** Rejection precedent weight applied when the rejected proposal had HIGH confidence. */
+export const DEFAULT_REJECTION_WEIGHT_HIGH = 0.8;
+/** Rejection precedent weight applied when the rejected proposal had MEDIUM confidence. */
+export const DEFAULT_REJECTION_WEIGHT_MEDIUM = 0.5;
+/** Rejection precedent weight applied when the rejected proposal had LOW confidence. */
+export const DEFAULT_REJECTION_WEIGHT_LOW = 0.2;
+/**
+ * Minimum value for the rejection precedent factor.
+ * 0.2 = at most 80% suppression of future proposal confidence.
+ */
+export const DEFAULT_CONFIDENCE_PENALTY_FLOOR = 0.2;
+/** The compile-time default resolved config (shipped AISDLC-271 values). */
+export const DEFAULT_RESOLVED_CALIBRATION_CONFIG = {
+    lockNoProposal: [],
+    confidenceThresholds: {
+        highSampleSize: DEFAULT_CONFIDENCE_HIGH_SAMPLE_SIZE,
+        lowSampleSize: DEFAULT_CONFIDENCE_LOW_SAMPLE_SIZE,
+    },
+    rejectionPrecedent: {
+        weights: {
+            highConfidenceRejection: DEFAULT_REJECTION_WEIGHT_HIGH,
+            mediumConfidenceRejection: DEFAULT_REJECTION_WEIGHT_MEDIUM,
+            lowConfidenceRejection: DEFAULT_REJECTION_WEIGHT_LOW,
+        },
+        confidencePenaltyFloor: DEFAULT_CONFIDENCE_PENALTY_FLOOR,
+    },
+};
+/**
+ * Validate a partial calibration config against the RFC-0031 §12.6 rules.
+ *
+ * Rules:
+ *   - `highSampleSize > lowSampleSize > 0`
+ *   - all weights in `[0, 1]`
+ *   - `confidencePenaltyFloor` in `[0, 1]`
+ *
+ * Missing fields default to the shipped values and are not validated
+ * (a partial config that omits a field is always valid for that field).
+ */
+export function validateRevisionProposalCalibrationConfig(config) {
+    const errors = [];
+    // ── Confidence thresholds ────────────────────────────────────────
+    const thresholds = config.confidenceThresholds;
+    if (thresholds !== undefined) {
+        const high = thresholds.highSampleSize ?? DEFAULT_CONFIDENCE_HIGH_SAMPLE_SIZE;
+        const low = thresholds.lowSampleSize ?? DEFAULT_CONFIDENCE_LOW_SAMPLE_SIZE;
+        if (thresholds.lowSampleSize !== undefined && thresholds.lowSampleSize <= 0) {
+            errors.push({
+                field: 'confidenceThresholds.lowSampleSize',
+                message: `must be > 0 (got ${thresholds.lowSampleSize})`,
+            });
+        }
+        if (thresholds.highSampleSize !== undefined && thresholds.highSampleSize <= 0) {
+            errors.push({
+                field: 'confidenceThresholds.highSampleSize',
+                message: `must be > 0 (got ${thresholds.highSampleSize})`,
+            });
+        }
+        // highSampleSize must be strictly greater than lowSampleSize
+        if (high <= low) {
+            errors.push({
+                field: 'confidenceThresholds',
+                message: `highSampleSize (${high}) must be > lowSampleSize (${low})`,
+            });
+        }
+    }
+    // ── Rejection precedent ──────────────────────────────────────────
+    const rp = config.rejectionPrecedent;
+    if (rp !== undefined) {
+        const weights = rp.weights;
+        if (weights !== undefined) {
+            const weightFields = [
+                ['highConfidenceRejection', weights.highConfidenceRejection],
+                ['mediumConfidenceRejection', weights.mediumConfidenceRejection],
+                ['lowConfidenceRejection', weights.lowConfidenceRejection],
+            ];
+            for (const [key, value] of weightFields) {
+                if (value !== undefined && (value < 0 || value > 1)) {
+                    errors.push({
+                        field: `rejectionPrecedent.weights.${key}`,
+                        message: `must be in [0, 1] (got ${value})`,
+                    });
+                }
+            }
+        }
+        if (rp.confidencePenaltyFloor !== undefined &&
+            (rp.confidencePenaltyFloor < 0 || rp.confidencePenaltyFloor > 1)) {
+            errors.push({
+                field: 'rejectionPrecedent.confidencePenaltyFloor',
+                message: `must be in [0, 1] (got ${rp.confidencePenaltyFloor})`,
+            });
+        }
+    }
+    if (errors.length > 0)
+        return { valid: false, errors };
+    return { valid: true };
+}
+// ── Resolution (merge partial config with defaults) ───────────────────
+/**
+ * Merge a partial `RevisionProposalCalibrationConfig` with defaults to
+ * produce a fully-resolved config. Does NOT validate — call
+ * `validateRevisionProposalCalibrationConfig()` first if you need to
+ * surface errors to the operator.
+ */
+export function resolveRevisionProposalCalibrationConfig(config = {}) {
+    const d = DEFAULT_RESOLVED_CALIBRATION_CONFIG;
+    return {
+        lockNoProposal: config.lockNoProposal ?? d.lockNoProposal,
+        confidenceThresholds: {
+            highSampleSize: config.confidenceThresholds?.highSampleSize ?? d.confidenceThresholds.highSampleSize,
+            lowSampleSize: config.confidenceThresholds?.lowSampleSize ?? d.confidenceThresholds.lowSampleSize,
+        },
+        rejectionPrecedent: {
+            weights: {
+                highConfidenceRejection: config.rejectionPrecedent?.weights?.highConfidenceRejection ??
+                    d.rejectionPrecedent.weights.highConfidenceRejection,
+                mediumConfidenceRejection: config.rejectionPrecedent?.weights?.mediumConfidenceRejection ??
+                    d.rejectionPrecedent.weights.mediumConfidenceRejection,
+                lowConfidenceRejection: config.rejectionPrecedent?.weights?.lowConfidenceRejection ??
+                    d.rejectionPrecedent.weights.lowConfidenceRejection,
+            },
+            confidencePenaltyFloor: config.rejectionPrecedent?.confidencePenaltyFloor ??
+                d.rejectionPrecedent.confidencePenaltyFloor,
+        },
+    };
+}
+// ── YAML loading ──────────────────────────────────────────────────────
+/**
+ * Parse and validate a `.ai-sdlc/calibration.yaml` file's content.
+ *
+ * Expected top-level shape:
+ * ```yaml
+ * calibration:
+ *   lockNoProposal: [...]
+ *   confidenceThresholds:
+ *     highSampleSize: 20
+ *     lowSampleSize: 5
+ *   rejectionPrecedent:
+ *     weights:
+ *       highConfidenceRejection: 0.8
+ *       mediumConfidenceRejection: 0.5
+ *       lowConfidenceRejection: 0.2
+ *     confidencePenaltyFloor: 0.2
+ * ```
+ *
+ * Missing fields are filled with defaults. Validation failures throw with
+ * a descriptive message listing all constraint violations.
+ *
+ * @param yamlContent Raw UTF-8 content of `calibration.yaml`.
+ * @returns Fully-resolved config ready to pass to revision-proposal functions.
+ * @throws {Error} When the YAML fails RFC-0031 §12.6 validation rules.
+ */
+export function parseRevisionProposalCalibrationYaml(yamlContent) {
+    const doc = parseYaml(yamlContent);
+    const raw = (doc?.calibration ?? {});
+    const config = {
+        lockNoProposal: Array.isArray(raw.lockNoProposal) ? raw.lockNoProposal : undefined,
+        confidenceThresholds: raw.confidenceThresholds !== null && typeof raw.confidenceThresholds === 'object'
+            ? raw.confidenceThresholds
+            : undefined,
+        rejectionPrecedent: raw.rejectionPrecedent !== null && typeof raw.rejectionPrecedent === 'object'
+            ? raw.rejectionPrecedent
+            : undefined,
+    };
+    const validation = validateRevisionProposalCalibrationConfig(config);
+    if (!validation.valid) {
+        const lines = validation.errors.map((e) => `  ${e.field}: ${e.message}`).join('\n');
+        throw new Error(`calibration.yaml validation failed (RFC-0031 §12.6):\n${lines}`);
+    }
+    return resolveRevisionProposalCalibrationConfig(config);
+}
+//# sourceMappingURL=revision-proposal-config.js.map

package/dist/sa-scoring/revision-proposal.d.ts

@@ -0,0 +1,285 @@
+/**
+ * DIDRevisionProposal mechanism (RFC-0031).
+ *
+ * Implements the calibration-driven proposal mechanism that fires when the
+ * PPA flywheel accumulates sufficient evidence that a DID field has drifted
+ * from observed reality.
+ *
+ * What ships here:
+ *   - DIDRevisionProposal event shape + classification logic (§3, §5)
+ *   - SoulHealthDiagnostic event for unhealthy-drift path (§7)
+ *   - Approval routing by identityClass (§8)
+ *   - 14-day expiry + DIDRevisionProposalExpired event (§9)
+ *   - lockNoProposal opt-out per field from calibration config (OQ-12.3)
+ *   - Rejection learnings flowing back into the calibration log (OQ-12.5)
+ *   - Multi-field bundling explicitly deferred to v2 (OQ-12.2)
+ *   - Confidence derived from sample size + classification clarity + identityClass (OQ-12.1)
+ *   - PPA generates proposal regardless of pillar; pillar lead approves (OQ-12.4)
+ *
+ * Trigger entry point: `evaluateRevisionProposal()` — called after drift
+ * is detected (i.e., a `SoulDriftDetected` event fires). One call per
+ * field; bundling is v2.
+ *
+ * Scope: Shard-DID only. Platform-level DID changes are human-initiated.
+ */
+import { type ResolvedRevisionProposalCalibrationConfig } from './revision-proposal-config.js';
+export type { ResolvedRevisionProposalCalibrationConfig };
+export { type RevisionProposalCalibrationConfig, type ConfidenceThresholdsConfig, type RejectionPrecedentConfig, type RejectionPrecedentWeightsConfig, type ConfigValidationResult, type ConfigValidationError, DEFAULT_CONFIDENCE_HIGH_SAMPLE_SIZE, DEFAULT_CONFIDENCE_LOW_SAMPLE_SIZE, DEFAULT_REJECTION_WEIGHT_HIGH, DEFAULT_REJECTION_WEIGHT_MEDIUM, DEFAULT_REJECTION_WEIGHT_LOW, DEFAULT_CONFIDENCE_PENALTY_FLOOR, DEFAULT_RESOLVED_CALIBRATION_CONFIG, validateRevisionProposalCalibrationConfig, resolveRevisionProposalCalibrationConfig, parseRevisionProposalCalibrationYaml, } from './revision-proposal-config.js';
+/** Default trigger thresholds (§6). Configurable per deployment. */
+export declare const DEFAULT_DISMISS_THRESHOLD = 10;
+export declare const DEFAULT_DEMAND_MISALIGNMENT_THRESHOLD = 0.3;
+export declare const DEFAULT_DRIFT_EVENTS_THRESHOLD = 3;
+export declare const DEFAULT_TRIGGER_WINDOW_DAYS = 60;
+export declare const DEFAULT_PROPOSAL_EXPIRY_DAYS = 14;
+/** Classification thresholds per §7. */
+export declare const HEALTHY_ICP_MATCH_MIN = 0.6;
+export declare const UNHEALTHY_ICP_MATCH_MAX = 0.3;
+export type DriftClassification = 'healthy' | 'unhealthy' | 'ambiguous';
+export type IdentityClass = 'core' | 'evolving';
+export type ApprovalPath = 'triad' | 'pillarLead';
+export type ProposalStatus = 'pending' | 'approved' | 'rejected' | 'expired';
+export type ProposalConfidence = 'high' | 'medium' | 'low';
+export interface ClassificationEvidence {
+    /** [0,1]; high = healthy signal source (ICP-matched demand clusters). */
+    demandClusterICPMatchRate: number;
+    /** [0,1]; high = validated loss signal (churn-correlated demand). */
+    demandClusterChurnCorrelation: number;
+    /** High dismiss + low escalate = DID is stale (healthy evolution). */
+    dismissToEscalateRatio: number;
+    /** True = core identity field affected; more caution warranted. */
+    coreDIDFieldsAffected: boolean;
+}
+export interface TriggerEvidence {
+    /** Dismiss-signal count over the trigger window. */
+    dismissSignals: number;
+    escalateSignals: number;
+    /** SA gap between demand clusters and DID field (0=aligned, 1=fully misaligned). */
+    demandMisalignment: number;
+    /** SoulDriftDetected events attributable to this field. */
+    driftEvents: number;
+    /** ISO-8601 duration string for the evaluation window, e.g. "P60D". */
+    triggerWindow: string;
+}
+export interface DIDRevisionProposalEvent {
+    type: 'DIDRevisionProposal';
+    proposalId: string;
+    /** MUST be 'shard' — platform proposals are not generated. */
+    scope: 'shard';
+    shardId: string;
+    field: string;
+    currentValue: unknown;
+    proposedValue: unknown;
+    identityClass: IdentityClass | undefined;
+    classification: DriftClassification;
+    classificationEvidence: ClassificationEvidence;
+    triggerEvidence: TriggerEvidence;
+    confidence: ProposalConfidence;
+    approvalPath: ApprovalPath;
+    expiresAt: string;
+    createdAt: string;
+    /** Current lifecycle status. */
+    status: ProposalStatus;
+}
+/** Emitted on unhealthy drift (§7) instead of a DIDRevisionProposalEvent. */
+export interface SoulHealthDiagnosticEvent {
+    type: 'SoulHealthDiagnostic';
+    proposalId: string;
+    shardId: string;
+    field: string;
+    classification: 'unhealthy';
+    classificationEvidence: ClassificationEvidence;
+    triggerEvidence: TriggerEvidence;
+    /** Recommendation for unhealthy drift — tighten admission or review demand source. */
+    recommendation: 'tighten-admission-threshold' | 'review-demand-source';
+    createdAt: string;
+}
+/** Emitted by `archiveExpiredProposals()` for each expired proposal. */
+export interface DIDRevisionProposalExpiredEvent {
+    type: 'DIDRevisionProposalExpired';
+    proposalId: string;
+    shardId: string;
+    field: string;
+    classification: DriftClassification;
+    createdAt: string;
+    expiredAt: string;
+}
+/** Emitted when a proposal is rejected; flows back into the calibration log. */
+export interface ProposalRejectionRecord {
+    proposalId: string;
+    shardId: string;
+    field: string;
+    rejectedBy: string;
+    rationale: string;
+    rejectedAt: string;
+    classification: DriftClassification;
+    /** Confidence weight carried forward into future trigger evaluations. */
+    rejectionPrecedentWeight: number;
+}
+/**
+ * Classify drift as healthy / unhealthy / ambiguous per RFC-0031 §7.
+ *
+ * ```
+ * healthy:    icpMatchRate > 0.6  AND NOT coreDIDFieldsAffected
+ * unhealthy:  icpMatchRate < 0.3  OR (coreDIDFieldsAffected AND dismissToEscalateRatio < 1.0)
+ * ambiguous:  everything else
+ * ```
+ */
+export declare function classifyDrift(evidence: ClassificationEvidence): DriftClassification;
+/**
+ * Derive approval path from identityClass per RFC-0031 §8.
+ *
+ * - `core` → `triad` (all three pillar leads required)
+ * - `evolving` → `pillarLead` (owning lead + one other)
+ * - `undefined` → `triad` (default-tighten when class is undeclared)
+ * - ambiguous classification always → `triad` (§7 override)
+ */
+export declare function deriveApprovalPath(identityClass: IdentityClass | undefined, classification: DriftClassification): ApprovalPath;
+/**
+ * Compute proposal confidence from trigger evidence + classification clarity
+ * + identityClass (OQ-12.1 resolved position: confidence = f(sample size,
+ * classification clarity, identityClass)).
+ *
+ * Thresholds are per-org configurable via `.ai-sdlc/calibration.yaml`
+ * (Refit AISDLC-310). Defaults match the shipped AISDLC-271 values:
+ *
+ * - high:   sampleSize ≥ highSampleSize (default 20) AND classification != 'ambiguous' AND identityClass = 'evolving'
+ * - low:    sampleSize < lowSampleSize  (default 5)  OR classification = 'ambiguous'   OR identityClass = 'core'
+ * - medium: everything else
+ *
+ * @param calibrationConfig Optional resolved config from `parseRevisionProposalCalibrationYaml()`.
+ *   When omitted, shipped defaults (20 / 5) are used.
+ */
+export declare function computeConfidence(triggerEvidence: TriggerEvidence, classification: DriftClassification, identityClass: IdentityClass | undefined, calibrationConfig?: ResolvedRevisionProposalCalibrationConfig): ProposalConfidence;
+export interface TriggerConditions {
+    /** Dismiss-signal count over the last `triggerWindowDays`. */
+    dismissSignals: number;
+    escalateSignals: number;
+    /** SA gap between demand clusters and DID field — sustained over 3 sprints. */
+    demandMisalignment: number;
+    /** SoulDriftDetected events attributable to this field (indefinite window). */
+    driftEvents: number;
+}
+export interface TriggerConfig {
+    dismissThreshold?: number;
+    demandMisalignmentThreshold?: number;
+    driftEventsThreshold?: number;
+    triggerWindowDays?: number;
+}
+/**
+ * Returns true if ANY trigger condition fires per RFC-0031 §6.
+ */
+export declare function triggerConditionMet(conditions: TriggerConditions, config?: TriggerConfig): boolean;
+export interface CalibrationLockConfig {
+    /** List of JSON-path field identifiers that should never receive auto-proposals. */
+    lockNoProposal?: string[];
+}
+/**
+ * Returns true if the given field is locked from auto-proposals per OQ-12.3.
+ *
+ * Proposal generation SKIPS locked fields. Operators remove entries from
+ * `lockNoProposal` to opt back in.
+ */
+export declare function isFieldLocked(field: string, lockConfig: CalibrationLockConfig): boolean;
+export interface EvaluateRevisionProposalInput {
+    shardId: string;
+    /** JSON path for the DID field being evaluated, e.g. "soulPurpose.mission". */
+    field: string;
+    currentValue: unknown;
+    /** PPA's best inferred proposed value based on flywheel evidence. */
+    proposedValue: unknown;
+    identityClass: IdentityClass | undefined;
+    triggerConditions: TriggerConditions;
+    classificationEvidence: ClassificationEvidence;
+    lockConfig?: CalibrationLockConfig;
+    config?: TriggerConfig & {
+        expiryDays?: number;
+    };
+    /**
+     * Per-org calibration config loaded from `.ai-sdlc/calibration.yaml`.
+     * When omitted, shipped AISDLC-271 defaults are used for confidence
+     * thresholds (Refit AISDLC-310 / RFC-0031 §12.6).
+     */
+    calibrationConfig?: ResolvedRevisionProposalCalibrationConfig;
+    /** Clock injection for tests. */
+    now?: () => number;
+}
+export type EvaluateRevisionProposalResult = {
+    kind: 'proposal';
+    event: DIDRevisionProposalEvent;
+} | {
+    kind: 'diagnostic';
+    event: SoulHealthDiagnosticEvent;
+} | {
+    kind: 'ambiguous';
+    proposal: DIDRevisionProposalEvent;
+    diagnostic: SoulHealthDiagnosticEvent;
+} | {
+    kind: 'skipped';
+    reason: 'locked' | 'no-trigger';
+};
+/**
+ * Evaluate whether a DIDRevisionProposal should be generated for a given
+ * DID field. Entry point called once per field (one-field-per-proposal in
+ * v1 per OQ-12.2).
+ *
+ * Returns a discriminated union describing what was produced:
+ * - `proposal`   — healthy drift; one DIDRevisionProposalEvent
+ * - `diagnostic` — unhealthy drift; one SoulHealthDiagnosticEvent
+ * - `ambiguous`  — both events produced, both flagged for triad review
+ * - `skipped`    — field is locked or trigger conditions not met
+ */
+export declare function evaluateRevisionProposal(input: EvaluateRevisionProposalInput): EvaluateRevisionProposalResult;
+/**
+ * Check whether a proposal has passed its `expiresAt` timestamp.
+ *
+ * AISDLC-271 PR #476 round-2: validates expiresAt is parseable. Pre-fix
+ * a malformed (or attacker-mutated) expiresAt would silently NEVER
+ * expire because Date.parse returns NaN and `NaN <= now` is always false.
+ */
+export declare function isProposalExpired(proposal: DIDRevisionProposalEvent, nowMs?: number): boolean;
+/**
+ * Archive expired proposals and emit `DIDRevisionProposalExpired` events.
+ * Returns the list of expiry events for caller to process (persist / alert).
+ *
+ * Per §9: expiry without resolution emits the event — operator alert, not
+ * silent dismissal. Auto-archives by setting status to 'expired'.
+ */
+export declare function archiveExpiredProposals(proposals: DIDRevisionProposalEvent[], nowMs?: number): {
+    expired: DIDRevisionProposalExpiredEvent[];
+    remaining: DIDRevisionProposalEvent[];
+};
+/**
+ * Record a proposal rejection and compute the `rejectionPrecedentWeight`
+ * to feed back into future trigger evaluations (OQ-12.5 resolved position:
+ * rejection rationale captured in calibration log; future trigger evaluations
+ * weight rejection-precedent into confidence).
+ *
+ * Weight formula (defaults from AISDLC-271, per-org configurable via
+ * `calibration.yaml` — Refit AISDLC-310 / RFC-0031 §12.6):
+ *   - high-confidence proposals that were rejected → 0.8 (default)
+ *   - medium-confidence → 0.5 (default)
+ *   - low-confidence → 0.2 default (expected noise level, lower weight)
+ *
+ * Callers persist this record to their calibration log; the next trigger
+ * evaluation should factor it in by reducing effective confidence.
+ *
+ * @param calibrationConfig Optional resolved config from `parseRevisionProposalCalibrationYaml()`.
+ *   When omitted, shipped AISDLC-271 weights (0.8 / 0.5 / 0.2) are used.
+ */
+export declare function recordRejection(proposal: DIDRevisionProposalEvent, rejectedBy: string, rationale: string, now?: () => number, calibrationConfig?: ResolvedRevisionProposalCalibrationConfig): ProposalRejectionRecord;
+/**
+ * Apply rejection precedent to reduce effective trigger confidence.
+ * When a field has prior rejection records, the aggregated precedent
+ * weight penalises future proposals for the same field.
+ *
+ * Formula (RFC-0031 §12.6): `factor = max(floor, 1.0 - avgWeight × 0.5)`
+ * where `floor` is `confidencePenaltyFloor` from calibration config
+ * (default 0.2 — at most 80% suppression).
+ *
+ * Returns a factor in `[floor, 1.0]`. Callers decide how to interpret.
+ *
+ * @param calibrationConfig Optional resolved config from `parseRevisionProposalCalibrationYaml()`.
+ *   When omitted, shipped AISDLC-271 floor (0.2) is used.
+ */
+export declare function computeRejectionPrecedentFactor(field: string, rejections: readonly ProposalRejectionRecord[], calibrationConfig?: ResolvedRevisionProposalCalibrationConfig): number;
+//# sourceMappingURL=revision-proposal.d.ts.map