@harness-engineering/intelligence 0.5.0 → 0.6.0

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import * as _harness_engineering_types from '@harness-engineering/types';
-import { Issue, ConcernSignal, ScopeTier, EscalationConfig } from '@harness-engineering/types';
+import { Issue, ConcernSignal, ScopeTier, EscalationConfig, ComplexityLevel, ComplexityVerdict, CapabilityTier, RoutingRisk, RoutingPolicy } from '@harness-engineering/types';
 import { z } from 'zod';
 import { GraphStore } from '@harness-engineering/graph';
 
@@ -1342,4 +1342,153 @@ declare function saveProfiles(projectRoot: string, store: ProfileStore): void;
  */
 declare function refreshProfiles(projectRoot: string, graphStore: GraphStore, opts?: Omit<SpecializationOptions, 'persona'>): ProfileStore;
 
-export { ACCEPTANCE_EVAL_SYSTEM_PROMPT, type AcceptanceEvalInput, AcceptanceEvaluator, type AcceptanceEvaluatorOptions, type AcceptanceVerdict, type AffectedSystem, type AnalysisProvider, type AnalysisRequest, type AnalysisResponse, AnthropicAnalysisProvider, type Authority, type BlastRadius, type BlindSpot, type CanaryAdapter, type CanaryDegradeReason, type CanaryExec, type CanaryFinding, type CanaryProbe, ClaudeCliAnalysisProvider, type ComplexityScore, type Confidence, type EnrichedSpec, type ExecutionOutcome, ExecutionOutcomeConnector, type ExpertiseLevel, type Finding, type FrameworkRecommendation, type GitHubIssue, GraphValidator, IntelligencePipeline, type JiraIssue, type JudgedAgainst, type LinearIssue, type LlmAcceptanceVerdict, type LlmVerdict, type ManualInput, type Measurability, OUTCOME_EVAL_SYSTEM_PROMPT, OpenAICompatibleAnalysisProvider, type OutcomeEvalInput, OutcomeEvaluator, type OutcomeEvaluatorOptions, type OutcomeIngestResult, type OutcomeVerdict, type PersonaEffectivenessScore, type PersonaRecommendation, PeslSimulator, type PreprocessResult, type ProfileStore, type RawWorkItem, type ResolvedSection, type SimulationResult, type SpecializationEntry, type SpecializationProfile, type SpecializationScore, type TaskType, type TemporalConfig, type Verdict, type WeightedRecommendation, acceptanceVerdictSchema, buildUserPrompt as buildAcceptanceUserPrompt, buildSpecializationProfile, buildUserPrompt$1 as buildUserPrompt, computeExpertiseLevel, computeHistoricalComplexity, computePersonaEffectiveness, computeSemanticComplexity, computeSpecialization, computeStructuralComplexity, createCanaryAdapter, decayWeight, deriveAcceptanceAuthority, deriveAuthority, detectBlindSpots, enrich, findingSchema, githubToRawWorkItem, jiraToRawWorkItem, linearToRawWorkItem, loadProfiles, manualToRawWorkItem, recommendPersona, refreshProfiles, resolveSection, runGraphOnlyChecks, runLlmSimulation, saveProfiles, score as scoreCML, scoreToConcernSignals, temporalSuccessRate, toRawWorkItem, verdictSchema, weightedRecommendPersona };
+/** Which signal set is available at this invocation phase (S3-001). */
+type Phase = 'pre-diff' | 'post-diff';
+/** Raw signals gathered for the static pass. Diff-based fields are undefined pre-diff. */
+interface ComplexitySignals {
+    /** Files touched by the diff/target. Undefined pre-diff. */
+    filesTouched?: number;
+    /** Distinct architectural layers touched. Undefined pre-diff. */
+    layersTouched?: number;
+    /** compute_blast_radius result. Undefined pre-diff. */
+    blastRadius?: number;
+    /** hotspot × churn heat. Undefined pre-diff. */
+    hotspotChurn?: number;
+    /** Text-only fallback signals (always available). */
+    descriptionLength: number;
+    specExists: boolean;
+    acceptanceMeasurable: boolean;
+}
+/** Provisional static verdict before any LLM tie-break. */
+interface StaticVerdict {
+    level: ComplexityLevel;
+    confidence: 'high' | 'medium' | 'low';
+    /** Serialized subset of signals for the ComplexityVerdict.signals map. */
+    signals: Record<string, number | boolean | string>;
+}
+
+/** Inputs to the cheap-first complexity cascade (D4). */
+interface ClassifyInput {
+    signals: ComplexitySignals;
+    phase: Phase;
+    /** Whether the invocation's risk band is high (drives standard-tier escalation). */
+    riskHigh: boolean;
+    /** Prompt handed to the LLM tie-break / escalation. */
+    prompt: string;
+}
+/**
+ * D4 cascade: static pass → (if low confidence) fast-tier tie-break → (if still
+ * low AND risk high) standard-tier escalation. Emits a `ComplexityVerdict` whose
+ * `source` records which stage produced it. The static-only path resolves
+ * without any LLM call ("never pay strong to route"); when `provider` is absent
+ * the classifier stays fully offline and returns the static verdict.
+ *
+ * The LLM only sets `level`/`confidence`; the tier is always TS-derived (D3).
+ */
+declare function classify(input: ClassifyInput, provider?: AnalysisProvider, models?: {
+    fast?: string;
+    standard?: string;
+}): Promise<ComplexityVerdict>;
+
+/**
+ * Documented seed weights for the free static pass (D4a). Each raw signal is
+ * normalized against a reference maximum, multiplied by its weight, and the
+ * weighted contributions are summed and re-normalized to a [0,1] score.
+ *
+ * Diff-based signals dominate post-diff; text-only signals carry the pre-diff
+ * pass. Weights are tunable (DEFERRABLE per plan) — this is a documented seed.
+ */
+declare const STATIC_WEIGHTS: {
+    readonly filesTouched: 0.25;
+    readonly layersTouched: 0.2;
+    readonly blastRadius: 0.3;
+    readonly hotspotChurn: 0.1;
+    /** Text-only signals — the only inputs available pre-diff. */
+    readonly descriptionLength: 0.1;
+    /** A present spec / measurable acceptance *lowers* complexity (well-scoped). */
+    readonly specExists: 0.025;
+    readonly acceptanceMeasurable: 0.025;
+};
+/**
+ * D4a: free static pass. Phase-aware (S3-001): pre-diff uses text-only signals
+ * and caps confidence at `medium`; post-diff uses the full signal set. Pure —
+ * never calls an LLM. `source` is stamped by the classifier, not here.
+ */
+declare function runStaticPass(signals: ComplexitySignals, phase: Phase): StaticVerdict;
+
+interface TiebreakResult {
+    level: ComplexityLevel;
+    confidence: 'high' | 'medium' | 'low';
+}
+/** D4b: fast-tier structured tie-break. Never sets a tier; falls back conservatively on error. */
+declare function llmTiebreak(provider: AnalysisProvider, prompt: string, fastModel?: string): Promise<TiebreakResult>;
+
+declare const TIER_RANK: {
+    fast: number;
+    standard: number;
+    strong: number;
+};
+declare const RANK_TIER: readonly ["fast", "standard", "strong"];
+/**
+ * Documented seed threshold for the D5 high-blast veto. The spec lists
+ * sensitive-path / core|types layer / public API explicitly but pins no numeric
+ * blast threshold, so this is a plan-chosen seed — overridable later.
+ */
+declare const SENSITIVE_BLAST_THRESHOLD = 25;
+/**
+ * D5: any sensitive-path / core|types layer / public API / high blast → force
+ * `strong`, regardless of complexity (SC5). This is a HARD floor; downstream
+ * budget clamping (D8) must not undercut it.
+ */
+declare function blastRadiusVeto(risk?: RoutingRisk): boolean;
+/**
+ * Pre-budget tier resolution (Task 7): skillTierOverride → matrix → D5 veto →
+ * low-confidence bump. Pure; the LLM never influences it (mirrors
+ * outcome-eval/authority.ts). Task 8's `deriveRequiredTier` calls this then
+ * applies the D8 budget clamp and D10 escalation floor.
+ *
+ * SC6: a `low`-confidence verdict degrades the tier UP one step (never below the
+ * matrix default and never to a cheaper tier) — uncertainty routes to a more
+ * capable model, never a Tier-A cheap one.
+ */
+declare function baseTier(complexity: ComplexityVerdict, risk: RoutingRisk | undefined, policy: RoutingPolicy, skillKey?: string): CapabilityTier;
+/** Default budget degrade threshold (% of cap) when policy omits one (D8). */
+declare const DEFAULT_DEGRADE_AT_PCT = 90;
+/**
+ * D8: budget-pressure tier clamp. Two thresholds:
+ *
+ * - **Soft (`degradeAtPct`, default 90%):** clamp the tier DOWN one step
+ *   (`strong→standard→fast`, `fast→fast`) — a lagging degrade signal.
+ * - **Hard (100% of `capUsd`):** for `degrade`/`pause` policies, force the tier
+ *   all the way to `fast` — the strongest sound floor on the routing DECISION
+ *   (it is not an admission gate; the monotonic accumulator lags under
+ *   concurrency, so it cannot prevent overshoot, only route the cheapest tier
+ *   once the read crosses the cap). `human` mode is handled one layer up in
+ *   `AdaptiveRouter.route()`, which surfaces the unit to a steward instead of
+ *   routing; here it falls through to the soft one-step degrade.
+ *
+ * The D5 blast-radius veto is a HARD `strong` floor the clamp must NOT undercut
+ * (SC5 says sensitive-path / core|types / publicApi force `strong` "regardless"),
+ * so a vetoed request stays `strong` even at the hard cap — the veto guard sits
+ * ABOVE both the hard-floor and the soft-step branches. No budget block ⇒ no clamp.
+ */
+declare function applyBudgetClamp(tier: CapabilityTier, risk: RoutingRisk | undefined, policy: RoutingPolicy, spend: {
+    spentUsd: number;
+}): CapabilityTier;
+/**
+ * Pure (complexity × risk × policy × spend × floor) → required tier.
+ *
+ * `baseTier` resolves override → matrix → D5 veto → low-confidence bump; the D8
+ * budget clamp lowers one step under budget pressure (never below the veto
+ * floor); the D10 escalation floor raises the result but never lowers it. The
+ * LLM never influences this — mirrors outcome-eval/authority.ts (TS-derived
+ * authority). Referentially transparent; never mutates `policy`.
+ */
+declare function deriveRequiredTier(complexity: ComplexityVerdict, risk: RoutingRisk | undefined, policy: RoutingPolicy, spend: {
+    spentUsd: number;
+}, escalationFloor: CapabilityTier, skillKey?: string): CapabilityTier;
+
+/** Flatten signals into the ComplexityVerdict.signals map, dropping undefined fields. */
+declare function serializeSignals(s: ComplexitySignals): Record<string, number | boolean | string>;
+
+export { ACCEPTANCE_EVAL_SYSTEM_PROMPT, type AcceptanceEvalInput, AcceptanceEvaluator, type AcceptanceEvaluatorOptions, type AcceptanceVerdict, type AffectedSystem, type AnalysisProvider, type AnalysisRequest, type AnalysisResponse, AnthropicAnalysisProvider, type Authority, type BlastRadius, type BlindSpot, type CanaryAdapter, type CanaryDegradeReason, type CanaryExec, type CanaryFinding, type CanaryProbe, type ClassifyInput, ClaudeCliAnalysisProvider, type ComplexityScore, type ComplexitySignals, type Confidence, DEFAULT_DEGRADE_AT_PCT, type EnrichedSpec, type ExecutionOutcome, ExecutionOutcomeConnector, type ExpertiseLevel, type Finding, type FrameworkRecommendation, type GitHubIssue, GraphValidator, IntelligencePipeline, type JiraIssue, type JudgedAgainst, type LinearIssue, type LlmAcceptanceVerdict, type LlmVerdict, type ManualInput, type Measurability, OUTCOME_EVAL_SYSTEM_PROMPT, OpenAICompatibleAnalysisProvider, type OutcomeEvalInput, OutcomeEvaluator, type OutcomeEvaluatorOptions, type OutcomeIngestResult, type OutcomeVerdict, type PersonaEffectivenessScore, type PersonaRecommendation, PeslSimulator, type Phase, type PreprocessResult, type ProfileStore, RANK_TIER, type RawWorkItem, type ResolvedSection, SENSITIVE_BLAST_THRESHOLD, STATIC_WEIGHTS, type SimulationResult, type SpecializationEntry, type SpecializationProfile, type SpecializationScore, type StaticVerdict, TIER_RANK, type TaskType, type TemporalConfig, type TiebreakResult, type Verdict, type WeightedRecommendation, acceptanceVerdictSchema, applyBudgetClamp, baseTier, blastRadiusVeto, buildUserPrompt as buildAcceptanceUserPrompt, buildSpecializationProfile, buildUserPrompt$1 as buildUserPrompt, classify, computeExpertiseLevel, computeHistoricalComplexity, computePersonaEffectiveness, computeSemanticComplexity, computeSpecialization, computeStructuralComplexity, createCanaryAdapter, decayWeight, deriveAcceptanceAuthority, deriveAuthority, deriveRequiredTier, detectBlindSpots, enrich, findingSchema, githubToRawWorkItem, jiraToRawWorkItem, linearToRawWorkItem, llmTiebreak, loadProfiles, manualToRawWorkItem, recommendPersona, refreshProfiles, resolveSection, runGraphOnlyChecks, runLlmSimulation, runStaticPass, saveProfiles, score as scoreCML, scoreToConcernSignals, serializeSignals, temporalSuccessRate, toRawWorkItem, verdictSchema, weightedRecommendPersona };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _harness_engineering_types from '@harness-engineering/types';
-import { Issue, ConcernSignal, ScopeTier, EscalationConfig } from '@harness-engineering/types';
+import { Issue, ConcernSignal, ScopeTier, EscalationConfig, ComplexityLevel, ComplexityVerdict, CapabilityTier, RoutingRisk, RoutingPolicy } from '@harness-engineering/types';
 import { z } from 'zod';
 import { GraphStore } from '@harness-engineering/graph';
 
@@ -1342,4 +1342,153 @@ declare function saveProfiles(projectRoot: string, store: ProfileStore): void;
  */
 declare function refreshProfiles(projectRoot: string, graphStore: GraphStore, opts?: Omit<SpecializationOptions, 'persona'>): ProfileStore;
 
-export { ACCEPTANCE_EVAL_SYSTEM_PROMPT, type AcceptanceEvalInput, AcceptanceEvaluator, type AcceptanceEvaluatorOptions, type AcceptanceVerdict, type AffectedSystem, type AnalysisProvider, type AnalysisRequest, type AnalysisResponse, AnthropicAnalysisProvider, type Authority, type BlastRadius, type BlindSpot, type CanaryAdapter, type CanaryDegradeReason, type CanaryExec, type CanaryFinding, type CanaryProbe, ClaudeCliAnalysisProvider, type ComplexityScore, type Confidence, type EnrichedSpec, type ExecutionOutcome, ExecutionOutcomeConnector, type ExpertiseLevel, type Finding, type FrameworkRecommendation, type GitHubIssue, GraphValidator, IntelligencePipeline, type JiraIssue, type JudgedAgainst, type LinearIssue, type LlmAcceptanceVerdict, type LlmVerdict, type ManualInput, type Measurability, OUTCOME_EVAL_SYSTEM_PROMPT, OpenAICompatibleAnalysisProvider, type OutcomeEvalInput, OutcomeEvaluator, type OutcomeEvaluatorOptions, type OutcomeIngestResult, type OutcomeVerdict, type PersonaEffectivenessScore, type PersonaRecommendation, PeslSimulator, type PreprocessResult, type ProfileStore, type RawWorkItem, type ResolvedSection, type SimulationResult, type SpecializationEntry, type SpecializationProfile, type SpecializationScore, type TaskType, type TemporalConfig, type Verdict, type WeightedRecommendation, acceptanceVerdictSchema, buildUserPrompt as buildAcceptanceUserPrompt, buildSpecializationProfile, buildUserPrompt$1 as buildUserPrompt, computeExpertiseLevel, computeHistoricalComplexity, computePersonaEffectiveness, computeSemanticComplexity, computeSpecialization, computeStructuralComplexity, createCanaryAdapter, decayWeight, deriveAcceptanceAuthority, deriveAuthority, detectBlindSpots, enrich, findingSchema, githubToRawWorkItem, jiraToRawWorkItem, linearToRawWorkItem, loadProfiles, manualToRawWorkItem, recommendPersona, refreshProfiles, resolveSection, runGraphOnlyChecks, runLlmSimulation, saveProfiles, score as scoreCML, scoreToConcernSignals, temporalSuccessRate, toRawWorkItem, verdictSchema, weightedRecommendPersona };
+/** Which signal set is available at this invocation phase (S3-001). */
+type Phase = 'pre-diff' | 'post-diff';
+/** Raw signals gathered for the static pass. Diff-based fields are undefined pre-diff. */
+interface ComplexitySignals {
+    /** Files touched by the diff/target. Undefined pre-diff. */
+    filesTouched?: number;
+    /** Distinct architectural layers touched. Undefined pre-diff. */
+    layersTouched?: number;
+    /** compute_blast_radius result. Undefined pre-diff. */
+    blastRadius?: number;
+    /** hotspot × churn heat. Undefined pre-diff. */
+    hotspotChurn?: number;
+    /** Text-only fallback signals (always available). */
+    descriptionLength: number;
+    specExists: boolean;
+    acceptanceMeasurable: boolean;
+}
+/** Provisional static verdict before any LLM tie-break. */
+interface StaticVerdict {
+    level: ComplexityLevel;
+    confidence: 'high' | 'medium' | 'low';
+    /** Serialized subset of signals for the ComplexityVerdict.signals map. */
+    signals: Record<string, number | boolean | string>;
+}
+
+/** Inputs to the cheap-first complexity cascade (D4). */
+interface ClassifyInput {
+    signals: ComplexitySignals;
+    phase: Phase;
+    /** Whether the invocation's risk band is high (drives standard-tier escalation). */
+    riskHigh: boolean;
+    /** Prompt handed to the LLM tie-break / escalation. */
+    prompt: string;
+}
+/**
+ * D4 cascade: static pass → (if low confidence) fast-tier tie-break → (if still
+ * low AND risk high) standard-tier escalation. Emits a `ComplexityVerdict` whose
+ * `source` records which stage produced it. The static-only path resolves
+ * without any LLM call ("never pay strong to route"); when `provider` is absent
+ * the classifier stays fully offline and returns the static verdict.
+ *
+ * The LLM only sets `level`/`confidence`; the tier is always TS-derived (D3).
+ */
+declare function classify(input: ClassifyInput, provider?: AnalysisProvider, models?: {
+    fast?: string;
+    standard?: string;
+}): Promise<ComplexityVerdict>;
+
+/**
+ * Documented seed weights for the free static pass (D4a). Each raw signal is
+ * normalized against a reference maximum, multiplied by its weight, and the
+ * weighted contributions are summed and re-normalized to a [0,1] score.
+ *
+ * Diff-based signals dominate post-diff; text-only signals carry the pre-diff
+ * pass. Weights are tunable (DEFERRABLE per plan) — this is a documented seed.
+ */
+declare const STATIC_WEIGHTS: {
+    readonly filesTouched: 0.25;
+    readonly layersTouched: 0.2;
+    readonly blastRadius: 0.3;
+    readonly hotspotChurn: 0.1;
+    /** Text-only signals — the only inputs available pre-diff. */
+    readonly descriptionLength: 0.1;
+    /** A present spec / measurable acceptance *lowers* complexity (well-scoped). */
+    readonly specExists: 0.025;
+    readonly acceptanceMeasurable: 0.025;
+};
+/**
+ * D4a: free static pass. Phase-aware (S3-001): pre-diff uses text-only signals
+ * and caps confidence at `medium`; post-diff uses the full signal set. Pure —
+ * never calls an LLM. `source` is stamped by the classifier, not here.
+ */
+declare function runStaticPass(signals: ComplexitySignals, phase: Phase): StaticVerdict;
+
+interface TiebreakResult {
+    level: ComplexityLevel;
+    confidence: 'high' | 'medium' | 'low';
+}
+/** D4b: fast-tier structured tie-break. Never sets a tier; falls back conservatively on error. */
+declare function llmTiebreak(provider: AnalysisProvider, prompt: string, fastModel?: string): Promise<TiebreakResult>;
+
+declare const TIER_RANK: {
+    fast: number;
+    standard: number;
+    strong: number;
+};
+declare const RANK_TIER: readonly ["fast", "standard", "strong"];
+/**
+ * Documented seed threshold for the D5 high-blast veto. The spec lists
+ * sensitive-path / core|types layer / public API explicitly but pins no numeric
+ * blast threshold, so this is a plan-chosen seed — overridable later.
+ */
+declare const SENSITIVE_BLAST_THRESHOLD = 25;
+/**
+ * D5: any sensitive-path / core|types layer / public API / high blast → force
+ * `strong`, regardless of complexity (SC5). This is a HARD floor; downstream
+ * budget clamping (D8) must not undercut it.
+ */
+declare function blastRadiusVeto(risk?: RoutingRisk): boolean;
+/**
+ * Pre-budget tier resolution (Task 7): skillTierOverride → matrix → D5 veto →
+ * low-confidence bump. Pure; the LLM never influences it (mirrors
+ * outcome-eval/authority.ts). Task 8's `deriveRequiredTier` calls this then
+ * applies the D8 budget clamp and D10 escalation floor.
+ *
+ * SC6: a `low`-confidence verdict degrades the tier UP one step (never below the
+ * matrix default and never to a cheaper tier) — uncertainty routes to a more
+ * capable model, never a Tier-A cheap one.
+ */
+declare function baseTier(complexity: ComplexityVerdict, risk: RoutingRisk | undefined, policy: RoutingPolicy, skillKey?: string): CapabilityTier;
+/** Default budget degrade threshold (% of cap) when policy omits one (D8). */
+declare const DEFAULT_DEGRADE_AT_PCT = 90;
+/**
+ * D8: budget-pressure tier clamp. Two thresholds:
+ *
+ * - **Soft (`degradeAtPct`, default 90%):** clamp the tier DOWN one step
+ *   (`strong→standard→fast`, `fast→fast`) — a lagging degrade signal.
+ * - **Hard (100% of `capUsd`):** for `degrade`/`pause` policies, force the tier
+ *   all the way to `fast` — the strongest sound floor on the routing DECISION
+ *   (it is not an admission gate; the monotonic accumulator lags under
+ *   concurrency, so it cannot prevent overshoot, only route the cheapest tier
+ *   once the read crosses the cap). `human` mode is handled one layer up in
+ *   `AdaptiveRouter.route()`, which surfaces the unit to a steward instead of
+ *   routing; here it falls through to the soft one-step degrade.
+ *
+ * The D5 blast-radius veto is a HARD `strong` floor the clamp must NOT undercut
+ * (SC5 says sensitive-path / core|types / publicApi force `strong` "regardless"),
+ * so a vetoed request stays `strong` even at the hard cap — the veto guard sits
+ * ABOVE both the hard-floor and the soft-step branches. No budget block ⇒ no clamp.
+ */
+declare function applyBudgetClamp(tier: CapabilityTier, risk: RoutingRisk | undefined, policy: RoutingPolicy, spend: {
+    spentUsd: number;
+}): CapabilityTier;
+/**
+ * Pure (complexity × risk × policy × spend × floor) → required tier.
+ *
+ * `baseTier` resolves override → matrix → D5 veto → low-confidence bump; the D8
+ * budget clamp lowers one step under budget pressure (never below the veto
+ * floor); the D10 escalation floor raises the result but never lowers it. The
+ * LLM never influences this — mirrors outcome-eval/authority.ts (TS-derived
+ * authority). Referentially transparent; never mutates `policy`.
+ */
+declare function deriveRequiredTier(complexity: ComplexityVerdict, risk: RoutingRisk | undefined, policy: RoutingPolicy, spend: {
+    spentUsd: number;
+}, escalationFloor: CapabilityTier, skillKey?: string): CapabilityTier;
+
+/** Flatten signals into the ComplexityVerdict.signals map, dropping undefined fields. */
+declare function serializeSignals(s: ComplexitySignals): Record<string, number | boolean | string>;
+
+export { ACCEPTANCE_EVAL_SYSTEM_PROMPT, type AcceptanceEvalInput, AcceptanceEvaluator, type AcceptanceEvaluatorOptions, type AcceptanceVerdict, type AffectedSystem, type AnalysisProvider, type AnalysisRequest, type AnalysisResponse, AnthropicAnalysisProvider, type Authority, type BlastRadius, type BlindSpot, type CanaryAdapter, type CanaryDegradeReason, type CanaryExec, type CanaryFinding, type CanaryProbe, type ClassifyInput, ClaudeCliAnalysisProvider, type ComplexityScore, type ComplexitySignals, type Confidence, DEFAULT_DEGRADE_AT_PCT, type EnrichedSpec, type ExecutionOutcome, ExecutionOutcomeConnector, type ExpertiseLevel, type Finding, type FrameworkRecommendation, type GitHubIssue, GraphValidator, IntelligencePipeline, type JiraIssue, type JudgedAgainst, type LinearIssue, type LlmAcceptanceVerdict, type LlmVerdict, type ManualInput, type Measurability, OUTCOME_EVAL_SYSTEM_PROMPT, OpenAICompatibleAnalysisProvider, type OutcomeEvalInput, OutcomeEvaluator, type OutcomeEvaluatorOptions, type OutcomeIngestResult, type OutcomeVerdict, type PersonaEffectivenessScore, type PersonaRecommendation, PeslSimulator, type Phase, type PreprocessResult, type ProfileStore, RANK_TIER, type RawWorkItem, type ResolvedSection, SENSITIVE_BLAST_THRESHOLD, STATIC_WEIGHTS, type SimulationResult, type SpecializationEntry, type SpecializationProfile, type SpecializationScore, type StaticVerdict, TIER_RANK, type TaskType, type TemporalConfig, type TiebreakResult, type Verdict, type WeightedRecommendation, acceptanceVerdictSchema, applyBudgetClamp, baseTier, blastRadiusVeto, buildUserPrompt as buildAcceptanceUserPrompt, buildSpecializationProfile, buildUserPrompt$1 as buildUserPrompt, classify, computeExpertiseLevel, computeHistoricalComplexity, computePersonaEffectiveness, computeSemanticComplexity, computeSpecialization, computeStructuralComplexity, createCanaryAdapter, decayWeight, deriveAcceptanceAuthority, deriveAuthority, deriveRequiredTier, detectBlindSpots, enrich, findingSchema, githubToRawWorkItem, jiraToRawWorkItem, linearToRawWorkItem, llmTiebreak, loadProfiles, manualToRawWorkItem, recommendPersona, refreshProfiles, resolveSection, runGraphOnlyChecks, runLlmSimulation, runStaticPass, saveProfiles, score as scoreCML, scoreToConcernSignals, serializeSignals, temporalSuccessRate, toRawWorkItem, verdictSchema, weightedRecommendPersona };

package/dist/index.js

@@ -34,6 +34,7 @@ __export(index_exports, {
   AcceptanceEvaluator: () => AcceptanceEvaluator,
   AnthropicAnalysisProvider: () => AnthropicAnalysisProvider,
   ClaudeCliAnalysisProvider: () => ClaudeCliAnalysisProvider,
+  DEFAULT_DEGRADE_AT_PCT: () => DEFAULT_DEGRADE_AT_PCT,
   ExecutionOutcomeConnector: () => ExecutionOutcomeConnector,
   GraphValidator: () => GraphValidator,
   IntelligencePipeline: () => IntelligencePipeline,
@@ -41,10 +42,18 @@ __export(index_exports, {
   OpenAICompatibleAnalysisProvider: () => OpenAICompatibleAnalysisProvider,
   OutcomeEvaluator: () => OutcomeEvaluator,
   PeslSimulator: () => PeslSimulator,
+  RANK_TIER: () => RANK_TIER,
+  SENSITIVE_BLAST_THRESHOLD: () => SENSITIVE_BLAST_THRESHOLD,
+  STATIC_WEIGHTS: () => STATIC_WEIGHTS,
+  TIER_RANK: () => TIER_RANK,
   acceptanceVerdictSchema: () => acceptanceVerdictSchema,
+  applyBudgetClamp: () => applyBudgetClamp,
+  baseTier: () => baseTier,
+  blastRadiusVeto: () => blastRadiusVeto,
   buildAcceptanceUserPrompt: () => buildUserPrompt3,
   buildSpecializationProfile: () => buildSpecializationProfile,
   buildUserPrompt: () => buildUserPrompt2,
+  classify: () => classify,
   computeExpertiseLevel: () => computeExpertiseLevel,
   computeHistoricalComplexity: () => computeHistoricalComplexity,
   computePersonaEffectiveness: () => computePersonaEffectiveness,
@@ -55,12 +64,14 @@ __export(index_exports, {
   decayWeight: () => decayWeight,
   deriveAcceptanceAuthority: () => deriveAcceptanceAuthority,
   deriveAuthority: () => deriveAuthority,
+  deriveRequiredTier: () => deriveRequiredTier,
   detectBlindSpots: () => detectBlindSpots,
   enrich: () => enrich,
   findingSchema: () => findingSchema,
   githubToRawWorkItem: () => githubToRawWorkItem,
   jiraToRawWorkItem: () => jiraToRawWorkItem,
   linearToRawWorkItem: () => linearToRawWorkItem,
+  llmTiebreak: () => llmTiebreak,
   loadProfiles: () => loadProfiles,
   manualToRawWorkItem: () => manualToRawWorkItem,
   recommendPersona: () => recommendPersona,
@@ -68,9 +79,11 @@ __export(index_exports, {
   resolveSection: () => resolveSection,
   runGraphOnlyChecks: () => runGraphOnlyChecks,
   runLlmSimulation: () => runLlmSimulation,
+  runStaticPass: () => runStaticPass,
   saveProfiles: () => saveProfiles,
   scoreCML: () => score,
   scoreToConcernSignals: () => scoreToConcernSignals,
+  serializeSignals: () => serializeSignals,
   temporalSuccessRate: () => temporalSuccessRate,
   toRawWorkItem: () => toRawWorkItem,
   verdictSchema: () => verdictSchema,
@@ -2120,12 +2133,224 @@ function refreshProfiles(projectRoot, graphStore, opts) {
   saveProfiles(projectRoot, store);
   return store;
 }
+
+// src/complexity/signals.ts
+function serializeSignals(s) {
+  const out = {
+    descriptionLength: s.descriptionLength,
+    specExists: s.specExists,
+    acceptanceMeasurable: s.acceptanceMeasurable
+  };
+  if (s.filesTouched !== void 0) out.filesTouched = s.filesTouched;
+  if (s.layersTouched !== void 0) out.layersTouched = s.layersTouched;
+  if (s.blastRadius !== void 0) out.blastRadius = s.blastRadius;
+  if (s.hotspotChurn !== void 0) out.hotspotChurn = s.hotspotChurn;
+  return out;
+}
+
+// src/complexity/static-pass.ts
+var STATIC_WEIGHTS = {
+  filesTouched: 0.25,
+  layersTouched: 0.2,
+  blastRadius: 0.3,
+  hotspotChurn: 0.1,
+  /** Text-only signals — the only inputs available pre-diff. */
+  descriptionLength: 0.1,
+  /** A present spec / measurable acceptance *lowers* complexity (well-scoped). */
+  specExists: 0.025,
+  acceptanceMeasurable: 0.025
+};
+var REF_MAX = {
+  filesTouched: 20,
+  layersTouched: 4,
+  blastRadius: 40,
+  hotspotChurn: 1,
+  descriptionLength: 500
+};
+var CONFIDENCE_RANK = {
+  low: 0,
+  medium: 1,
+  high: 2
+};
+function clamp01(n) {
+  return Math.max(0, Math.min(1, n));
+}
+function scoreToLevel(score2) {
+  if (score2 < 0.2) return "trivial";
+  if (score2 < 0.45) return "simple";
+  if (score2 < 0.7) return "moderate";
+  return "complex";
+}
+function scoreToConfidence(score2) {
+  const boundaries = [0.2, 0.45, 0.7];
+  const nearest = Math.min(...boundaries.map((b) => Math.abs(score2 - b)));
+  const atExtremeEnd = score2 < 0.2 || score2 >= 0.7;
+  if (nearest < 0.1) return "low";
+  if (nearest < 0.18 && !atExtremeEnd) return "medium";
+  return "high";
+}
+function runStaticPass(signals, phase) {
+  const isPostDiff = phase === "post-diff";
+  const contributions = [];
+  const weightsUsed = [];
+  if (isPostDiff) {
+    if (signals.filesTouched !== void 0) {
+      contributions.push(
+        clamp01(signals.filesTouched / REF_MAX.filesTouched) * STATIC_WEIGHTS.filesTouched
+      );
+      weightsUsed.push(STATIC_WEIGHTS.filesTouched);
+    }
+    if (signals.layersTouched !== void 0) {
+      contributions.push(
+        clamp01(signals.layersTouched / REF_MAX.layersTouched) * STATIC_WEIGHTS.layersTouched
+      );
+      weightsUsed.push(STATIC_WEIGHTS.layersTouched);
+    }
+    if (signals.blastRadius !== void 0) {
+      contributions.push(
+        clamp01(signals.blastRadius / REF_MAX.blastRadius) * STATIC_WEIGHTS.blastRadius
+      );
+      weightsUsed.push(STATIC_WEIGHTS.blastRadius);
+    }
+    if (signals.hotspotChurn !== void 0) {
+      contributions.push(
+        clamp01(signals.hotspotChurn / REF_MAX.hotspotChurn) * STATIC_WEIGHTS.hotspotChurn
+      );
+      weightsUsed.push(STATIC_WEIGHTS.hotspotChurn);
+    }
+  }
+  contributions.push(
+    clamp01(signals.descriptionLength / REF_MAX.descriptionLength) * STATIC_WEIGHTS.descriptionLength
+  );
+  weightsUsed.push(STATIC_WEIGHTS.descriptionLength);
+  const scopeReduction = (signals.specExists ? STATIC_WEIGHTS.specExists : 0) + (signals.acceptanceMeasurable ? STATIC_WEIGHTS.acceptanceMeasurable : 0);
+  const totalWeight = weightsUsed.reduce((a, b) => a + b, 0);
+  const rawScore = contributions.reduce((a, b) => a + b, 0);
+  const normalized = totalWeight > 0 ? rawScore / totalWeight : 0;
+  const score2 = clamp01(normalized - scopeReduction);
+  const level = scoreToLevel(score2);
+  let confidence = scoreToConfidence(score2);
+  if (!isPostDiff && CONFIDENCE_RANK[confidence] > CONFIDENCE_RANK.medium) {
+    confidence = "medium";
+  }
+  return {
+    level,
+    confidence,
+    signals: serializeSignals(signals)
+  };
+}
+
+// src/complexity/tiebreak.ts
+var import_zod6 = require("zod");
+var TiebreakSchema = import_zod6.z.object({
+  level: import_zod6.z.enum(["trivial", "simple", "moderate", "complex"]),
+  confidence: import_zod6.z.enum(["high", "medium", "low"])
+});
+async function llmTiebreak(provider, prompt, fastModel) {
+  try {
+    const { result } = await provider.analyze({
+      prompt,
+      responseSchema: TiebreakSchema,
+      // Only include `model` when supplied (exactOptionalPropertyTypes).
+      ...fastModel !== void 0 ? { model: fastModel } : {},
+      maxTokens: 256
+    });
+    return result;
+  } catch {
+    return { level: "moderate", confidence: "low" };
+  }
+}
+
+// src/complexity/classifier.ts
+var CONFIDENCE_RANK2 = { low: 0, medium: 1, high: 2 };
+function capForPhase(confidence, phase) {
+  if (phase === "pre-diff" && CONFIDENCE_RANK2[confidence] > CONFIDENCE_RANK2.medium) {
+    return "medium";
+  }
+  return confidence;
+}
+async function classify(input, provider, models) {
+  const staticVerdict = runStaticPass(input.signals, input.phase);
+  if (staticVerdict.confidence !== "low" || provider === void 0) {
+    return {
+      level: staticVerdict.level,
+      confidence: staticVerdict.confidence,
+      signals: staticVerdict.signals,
+      source: "static"
+    };
+  }
+  const tiebreak = await llmTiebreak(provider, input.prompt, models?.fast);
+  if (tiebreak.confidence === "low" && input.riskHigh) {
+    const escalated = await llmTiebreak(provider, input.prompt, models?.standard);
+    return {
+      level: escalated.level,
+      confidence: capForPhase(escalated.confidence, input.phase),
+      signals: staticVerdict.signals,
+      source: "escalated"
+    };
+  }
+  return {
+    level: tiebreak.level,
+    confidence: capForPhase(tiebreak.confidence, input.phase),
+    signals: staticVerdict.signals,
+    source: "llm-tiebreak"
+  };
+}
+
+// src/complexity/derive-tier.ts
+var TIER_RANK = { fast: 0, standard: 1, strong: 2 };
+var RANK_TIER = ["fast", "standard", "strong"];
+var SENSITIVE_BLAST_THRESHOLD = 25;
+var DEFAULT_MATRIX = {
+  trivial: "fast",
+  simple: "fast",
+  moderate: "standard",
+  complex: "strong"
+};
+function tierAtRank(rank) {
+  const clamped = Math.max(0, Math.min(RANK_TIER.length - 1, rank));
+  return RANK_TIER[clamped];
+}
+function blastRadiusVeto(risk) {
+  if (!risk) return false;
+  return risk.sensitivePath === true || risk.publicApi === true || risk.layer === "core" || risk.layer === "types" || typeof risk.blastRadius === "number" && risk.blastRadius >= SENSITIVE_BLAST_THRESHOLD;
+}
+function baseTier(complexity, risk, policy, skillKey) {
+  const veto = blastRadiusVeto(risk);
+  const override = skillKey !== void 0 ? policy.skillTierOverrides?.[skillKey] : void 0;
+  const matrix = policy.complexityTierMatrix ?? {};
+  const fromMatrix = matrix[complexity.level] ?? DEFAULT_MATRIX[complexity.level];
+  let rank = Math.max(override !== void 0 ? TIER_RANK[override] : 0, TIER_RANK[fromMatrix]);
+  if (complexity.confidence === "low") {
+    rank = rank + 1;
+  }
+  if (veto) rank = Math.max(rank, TIER_RANK.strong);
+  return tierAtRank(rank);
+}
+var DEFAULT_DEGRADE_AT_PCT = 90;
+function applyBudgetClamp(tier, risk, policy, spend) {
+  const budget = policy.budget;
+  if (!budget || budget.capUsd <= 0) return tier;
+  const degradeAt = (budget.degradeAtPct ?? DEFAULT_DEGRADE_AT_PCT) / 100;
+  const spentFraction = spend.spentUsd / budget.capUsd;
+  if (spentFraction < degradeAt) return tier;
+  if (blastRadiusVeto(risk)) return tier;
+  const mode = budget.onBudgetExhausted ?? "degrade";
+  if (spentFraction >= 1 && mode !== "human") return "fast";
+  return tierAtRank(TIER_RANK[tier] - 1);
+}
+function deriveRequiredTier(complexity, risk, policy, spend, escalationFloor, skillKey) {
+  const base = baseTier(complexity, risk, policy, skillKey);
+  const clamped = applyBudgetClamp(base, risk, policy, spend);
+  return tierAtRank(Math.max(TIER_RANK[escalationFloor], TIER_RANK[clamped]));
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCEPTANCE_EVAL_SYSTEM_PROMPT,
   AcceptanceEvaluator,
   AnthropicAnalysisProvider,
   ClaudeCliAnalysisProvider,
+  DEFAULT_DEGRADE_AT_PCT,
   ExecutionOutcomeConnector,
   GraphValidator,
   IntelligencePipeline,
@@ -2133,10 +2358,18 @@ function refreshProfiles(projectRoot, graphStore, opts) {
   OpenAICompatibleAnalysisProvider,
   OutcomeEvaluator,
   PeslSimulator,
+  RANK_TIER,
+  SENSITIVE_BLAST_THRESHOLD,
+  STATIC_WEIGHTS,
+  TIER_RANK,
   acceptanceVerdictSchema,
+  applyBudgetClamp,
+  baseTier,
+  blastRadiusVeto,
   buildAcceptanceUserPrompt,
   buildSpecializationProfile,
   buildUserPrompt,
+  classify,
   computeExpertiseLevel,
   computeHistoricalComplexity,
   computePersonaEffectiveness,
@@ -2147,12 +2380,14 @@ function refreshProfiles(projectRoot, graphStore, opts) {
   decayWeight,
   deriveAcceptanceAuthority,
   deriveAuthority,
+  deriveRequiredTier,
   detectBlindSpots,
   enrich,
   findingSchema,
   githubToRawWorkItem,
   jiraToRawWorkItem,
   linearToRawWorkItem,
+  llmTiebreak,
   loadProfiles,
   manualToRawWorkItem,
   recommendPersona,
@@ -2160,9 +2395,11 @@ function refreshProfiles(projectRoot, graphStore, opts) {
   resolveSection,
   runGraphOnlyChecks,
   runLlmSimulation,
+  runStaticPass,
   saveProfiles,
   scoreCML,
   scoreToConcernSignals,
+  serializeSignals,
   temporalSuccessRate,
   toRawWorkItem,
   verdictSchema,

package/dist/index.mjs

@@ -2040,11 +2040,223 @@ function refreshProfiles(projectRoot, graphStore, opts) {
   saveProfiles(projectRoot, store);
   return store;
 }
+
+// src/complexity/signals.ts
+function serializeSignals(s) {
+  const out = {
+    descriptionLength: s.descriptionLength,
+    specExists: s.specExists,
+    acceptanceMeasurable: s.acceptanceMeasurable
+  };
+  if (s.filesTouched !== void 0) out.filesTouched = s.filesTouched;
+  if (s.layersTouched !== void 0) out.layersTouched = s.layersTouched;
+  if (s.blastRadius !== void 0) out.blastRadius = s.blastRadius;
+  if (s.hotspotChurn !== void 0) out.hotspotChurn = s.hotspotChurn;
+  return out;
+}
+
+// src/complexity/static-pass.ts
+var STATIC_WEIGHTS = {
+  filesTouched: 0.25,
+  layersTouched: 0.2,
+  blastRadius: 0.3,
+  hotspotChurn: 0.1,
+  /** Text-only signals — the only inputs available pre-diff. */
+  descriptionLength: 0.1,
+  /** A present spec / measurable acceptance *lowers* complexity (well-scoped). */
+  specExists: 0.025,
+  acceptanceMeasurable: 0.025
+};
+var REF_MAX = {
+  filesTouched: 20,
+  layersTouched: 4,
+  blastRadius: 40,
+  hotspotChurn: 1,
+  descriptionLength: 500
+};
+var CONFIDENCE_RANK = {
+  low: 0,
+  medium: 1,
+  high: 2
+};
+function clamp01(n) {
+  return Math.max(0, Math.min(1, n));
+}
+function scoreToLevel(score2) {
+  if (score2 < 0.2) return "trivial";
+  if (score2 < 0.45) return "simple";
+  if (score2 < 0.7) return "moderate";
+  return "complex";
+}
+function scoreToConfidence(score2) {
+  const boundaries = [0.2, 0.45, 0.7];
+  const nearest = Math.min(...boundaries.map((b) => Math.abs(score2 - b)));
+  const atExtremeEnd = score2 < 0.2 || score2 >= 0.7;
+  if (nearest < 0.1) return "low";
+  if (nearest < 0.18 && !atExtremeEnd) return "medium";
+  return "high";
+}
+function runStaticPass(signals, phase) {
+  const isPostDiff = phase === "post-diff";
+  const contributions = [];
+  const weightsUsed = [];
+  if (isPostDiff) {
+    if (signals.filesTouched !== void 0) {
+      contributions.push(
+        clamp01(signals.filesTouched / REF_MAX.filesTouched) * STATIC_WEIGHTS.filesTouched
+      );
+      weightsUsed.push(STATIC_WEIGHTS.filesTouched);
+    }
+    if (signals.layersTouched !== void 0) {
+      contributions.push(
+        clamp01(signals.layersTouched / REF_MAX.layersTouched) * STATIC_WEIGHTS.layersTouched
+      );
+      weightsUsed.push(STATIC_WEIGHTS.layersTouched);
+    }
+    if (signals.blastRadius !== void 0) {
+      contributions.push(
+        clamp01(signals.blastRadius / REF_MAX.blastRadius) * STATIC_WEIGHTS.blastRadius
+      );
+      weightsUsed.push(STATIC_WEIGHTS.blastRadius);
+    }
+    if (signals.hotspotChurn !== void 0) {
+      contributions.push(
+        clamp01(signals.hotspotChurn / REF_MAX.hotspotChurn) * STATIC_WEIGHTS.hotspotChurn
+      );
+      weightsUsed.push(STATIC_WEIGHTS.hotspotChurn);
+    }
+  }
+  contributions.push(
+    clamp01(signals.descriptionLength / REF_MAX.descriptionLength) * STATIC_WEIGHTS.descriptionLength
+  );
+  weightsUsed.push(STATIC_WEIGHTS.descriptionLength);
+  const scopeReduction = (signals.specExists ? STATIC_WEIGHTS.specExists : 0) + (signals.acceptanceMeasurable ? STATIC_WEIGHTS.acceptanceMeasurable : 0);
+  const totalWeight = weightsUsed.reduce((a, b) => a + b, 0);
+  const rawScore = contributions.reduce((a, b) => a + b, 0);
+  const normalized = totalWeight > 0 ? rawScore / totalWeight : 0;
+  const score2 = clamp01(normalized - scopeReduction);
+  const level = scoreToLevel(score2);
+  let confidence = scoreToConfidence(score2);
+  if (!isPostDiff && CONFIDENCE_RANK[confidence] > CONFIDENCE_RANK.medium) {
+    confidence = "medium";
+  }
+  return {
+    level,
+    confidence,
+    signals: serializeSignals(signals)
+  };
+}
+
+// src/complexity/tiebreak.ts
+import { z as z6 } from "zod";
+var TiebreakSchema = z6.object({
+  level: z6.enum(["trivial", "simple", "moderate", "complex"]),
+  confidence: z6.enum(["high", "medium", "low"])
+});
+async function llmTiebreak(provider, prompt, fastModel) {
+  try {
+    const { result } = await provider.analyze({
+      prompt,
+      responseSchema: TiebreakSchema,
+      // Only include `model` when supplied (exactOptionalPropertyTypes).
+      ...fastModel !== void 0 ? { model: fastModel } : {},
+      maxTokens: 256
+    });
+    return result;
+  } catch {
+    return { level: "moderate", confidence: "low" };
+  }
+}
+
+// src/complexity/classifier.ts
+var CONFIDENCE_RANK2 = { low: 0, medium: 1, high: 2 };
+function capForPhase(confidence, phase) {
+  if (phase === "pre-diff" && CONFIDENCE_RANK2[confidence] > CONFIDENCE_RANK2.medium) {
+    return "medium";
+  }
+  return confidence;
+}
+async function classify(input, provider, models) {
+  const staticVerdict = runStaticPass(input.signals, input.phase);
+  if (staticVerdict.confidence !== "low" || provider === void 0) {
+    return {
+      level: staticVerdict.level,
+      confidence: staticVerdict.confidence,
+      signals: staticVerdict.signals,
+      source: "static"
+    };
+  }
+  const tiebreak = await llmTiebreak(provider, input.prompt, models?.fast);
+  if (tiebreak.confidence === "low" && input.riskHigh) {
+    const escalated = await llmTiebreak(provider, input.prompt, models?.standard);
+    return {
+      level: escalated.level,
+      confidence: capForPhase(escalated.confidence, input.phase),
+      signals: staticVerdict.signals,
+      source: "escalated"
+    };
+  }
+  return {
+    level: tiebreak.level,
+    confidence: capForPhase(tiebreak.confidence, input.phase),
+    signals: staticVerdict.signals,
+    source: "llm-tiebreak"
+  };
+}
+
+// src/complexity/derive-tier.ts
+var TIER_RANK = { fast: 0, standard: 1, strong: 2 };
+var RANK_TIER = ["fast", "standard", "strong"];
+var SENSITIVE_BLAST_THRESHOLD = 25;
+var DEFAULT_MATRIX = {
+  trivial: "fast",
+  simple: "fast",
+  moderate: "standard",
+  complex: "strong"
+};
+function tierAtRank(rank) {
+  const clamped = Math.max(0, Math.min(RANK_TIER.length - 1, rank));
+  return RANK_TIER[clamped];
+}
+function blastRadiusVeto(risk) {
+  if (!risk) return false;
+  return risk.sensitivePath === true || risk.publicApi === true || risk.layer === "core" || risk.layer === "types" || typeof risk.blastRadius === "number" && risk.blastRadius >= SENSITIVE_BLAST_THRESHOLD;
+}
+function baseTier(complexity, risk, policy, skillKey) {
+  const veto = blastRadiusVeto(risk);
+  const override = skillKey !== void 0 ? policy.skillTierOverrides?.[skillKey] : void 0;
+  const matrix = policy.complexityTierMatrix ?? {};
+  const fromMatrix = matrix[complexity.level] ?? DEFAULT_MATRIX[complexity.level];
+  let rank = Math.max(override !== void 0 ? TIER_RANK[override] : 0, TIER_RANK[fromMatrix]);
+  if (complexity.confidence === "low") {
+    rank = rank + 1;
+  }
+  if (veto) rank = Math.max(rank, TIER_RANK.strong);
+  return tierAtRank(rank);
+}
+var DEFAULT_DEGRADE_AT_PCT = 90;
+function applyBudgetClamp(tier, risk, policy, spend) {
+  const budget = policy.budget;
+  if (!budget || budget.capUsd <= 0) return tier;
+  const degradeAt = (budget.degradeAtPct ?? DEFAULT_DEGRADE_AT_PCT) / 100;
+  const spentFraction = spend.spentUsd / budget.capUsd;
+  if (spentFraction < degradeAt) return tier;
+  if (blastRadiusVeto(risk)) return tier;
+  const mode = budget.onBudgetExhausted ?? "degrade";
+  if (spentFraction >= 1 && mode !== "human") return "fast";
+  return tierAtRank(TIER_RANK[tier] - 1);
+}
+function deriveRequiredTier(complexity, risk, policy, spend, escalationFloor, skillKey) {
+  const base = baseTier(complexity, risk, policy, skillKey);
+  const clamped = applyBudgetClamp(base, risk, policy, spend);
+  return tierAtRank(Math.max(TIER_RANK[escalationFloor], TIER_RANK[clamped]));
+}
 export {
   ACCEPTANCE_EVAL_SYSTEM_PROMPT,
   AcceptanceEvaluator,
   AnthropicAnalysisProvider,
   ClaudeCliAnalysisProvider,
+  DEFAULT_DEGRADE_AT_PCT,
   ExecutionOutcomeConnector,
   GraphValidator,
   IntelligencePipeline,
@@ -2052,10 +2264,18 @@ export {
   OpenAICompatibleAnalysisProvider,
   OutcomeEvaluator,
   PeslSimulator,
+  RANK_TIER,
+  SENSITIVE_BLAST_THRESHOLD,
+  STATIC_WEIGHTS,
+  TIER_RANK,
   acceptanceVerdictSchema,
+  applyBudgetClamp,
+  baseTier,
+  blastRadiusVeto,
   buildUserPrompt3 as buildAcceptanceUserPrompt,
   buildSpecializationProfile,
   buildUserPrompt2 as buildUserPrompt,
+  classify,
   computeExpertiseLevel,
   computeHistoricalComplexity,
   computePersonaEffectiveness,
@@ -2066,12 +2286,14 @@ export {
   decayWeight,
   deriveAcceptanceAuthority,
   deriveAuthority,
+  deriveRequiredTier,
   detectBlindSpots,
   enrich,
   findingSchema,
   githubToRawWorkItem,
   jiraToRawWorkItem,
   linearToRawWorkItem,
+  llmTiebreak,
   loadProfiles,
   manualToRawWorkItem,
   recommendPersona,
@@ -2079,9 +2301,11 @@ export {
   resolveSection,
   runGraphOnlyChecks,
   runLlmSimulation,
+  runStaticPass,
   saveProfiles,
   score as scoreCML,
   scoreToConcernSignals,
+  serializeSignals,
   temporalSuccessRate,
   toRawWorkItem,
   verdictSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harness-engineering/intelligence",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Intelligence pipeline for spec enrichment, complexity modeling, and pre-execution simulation",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -40,8 +40,8 @@
     "@anthropic-ai/sdk": "^0.95.1",
     "openai": "^6.0.0",
     "zod": "^3.25.76",
-    "@harness-engineering/types": "0.20.0",
-    "@harness-engineering/graph": "0.11.6"
+    "@harness-engineering/graph": "0.11.7",
+    "@harness-engineering/types": "0.21.0"
   },
   "optionalDependencies": {
     "canary-test-cli": "^5.4.0"