@harness-engineering/intelligence 0.5.0 → 0.7.0

package/dist/index.js

@@ -31,20 +31,39 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   ACCEPTANCE_EVAL_SYSTEM_PROMPT: () => ACCEPTANCE_EVAL_SYSTEM_PROMPT,
+  AUTO_EXECUTE_CATEGORIES: () => AUTO_EXECUTE_CATEGORIES,
   AcceptanceEvaluator: () => AcceptanceEvaluator,
   AnthropicAnalysisProvider: () => AnthropicAnalysisProvider,
+  BLAST_TOLERANCE_ABS: () => BLAST_TOLERANCE_ABS,
+  BLAST_TOLERANCE_FACTOR: () => BLAST_TOLERANCE_FACTOR,
   ClaudeCliAnalysisProvider: () => ClaudeCliAnalysisProvider,
+  DEFAULT_DEGRADE_AT_PCT: () => DEFAULT_DEGRADE_AT_PCT,
+  DEFAULT_RATCHET_CONFIG: () => DEFAULT_RATCHET_CONFIG,
+  DEFAULT_RETROSPECTIVE_CONFIG: () => DEFAULT_RETROSPECTIVE_CONFIG,
+  DEPTH_BY_LEVEL: () => DEPTH_BY_LEVEL,
   ExecutionOutcomeConnector: () => ExecutionOutcomeConnector,
   GraphValidator: () => GraphValidator,
   IntelligencePipeline: () => IntelligencePipeline,
+  LEVEL_RANK: () => LEVEL_RANK,
   OUTCOME_EVAL_SYSTEM_PROMPT: () => OUTCOME_EVAL_SYSTEM_PROMPT,
   OpenAICompatibleAnalysisProvider: () => OpenAICompatibleAnalysisProvider,
   OutcomeEvaluator: () => OutcomeEvaluator,
   PeslSimulator: () => PeslSimulator,
+  RANK_TIER: () => RANK_TIER,
+  SENSITIVE_BLAST_THRESHOLD: () => SENSITIVE_BLAST_THRESHOLD,
+  STATIC_WEIGHTS: () => STATIC_WEIGHTS,
+  TIER_RANK: () => TIER_RANK,
+  V1_MAX_STAGE: () => V1_MAX_STAGE,
   acceptanceVerdictSchema: () => acceptanceVerdictSchema,
+  aggregatePrecedent: () => aggregatePrecedent,
+  applyBudgetClamp: () => applyBudgetClamp,
+  baseTier: () => baseTier,
+  blastRadiusVeto: () => blastRadiusVeto,
   buildAcceptanceUserPrompt: () => buildUserPrompt3,
   buildSpecializationProfile: () => buildSpecializationProfile,
   buildUserPrompt: () => buildUserPrompt2,
+  classify: () => classify,
+  compareToPrediction: () => compareToPrediction,
   computeExpertiseLevel: () => computeExpertiseLevel,
   computeHistoricalComplexity: () => computeHistoricalComplexity,
   computePersonaEffectiveness: () => computePersonaEffectiveness,
@@ -53,24 +72,40 @@ __export(index_exports, {
   computeStructuralComplexity: () => computeStructuralComplexity,
   createCanaryAdapter: () => createCanaryAdapter,
   decayWeight: () => decayWeight,
+  depthForLevel: () => depthForLevel,
   deriveAcceptanceAuthority: () => deriveAcceptanceAuthority,
   deriveAuthority: () => deriveAuthority,
+  deriveRequiredTier: () => deriveRequiredTier,
   detectBlindSpots: () => detectBlindSpots,
+  dispatchableShapeKey: () => dispatchableShapeKey,
   enrich: () => enrich,
+  extractEntities: () => extractEntities,
   findingSchema: () => findingSchema,
   githubToRawWorkItem: () => githubToRawWorkItem,
   jiraToRawWorkItem: () => jiraToRawWorkItem,
   linearToRawWorkItem: () => linearToRawWorkItem,
+  llmTiebreak: () => llmTiebreak,
   loadProfiles: () => loadProfiles,
   manualToRawWorkItem: () => manualToRawWorkItem,
+  pilotScore: () => pilotScore,
+  precedentLookupFromRecords: () => precedentLookupFromRecords,
+  rankTriageCandidates: () => rankTriageCandidates,
   recommendPersona: () => recommendPersona,
   refreshProfiles: () => refreshProfiles,
+  resolveGoNoGo: () => resolveGoNoGo,
+  resolveGoNoGoStaged: () => resolveGoNoGoStaged,
   resolveSection: () => resolveSection,
+  resolveStage: () => resolveStage,
+  runAutoBrainstorm: () => runAutoBrainstorm,
   runGraphOnlyChecks: () => runGraphOnlyChecks,
   runLlmSimulation: () => runLlmSimulation,
+  runScopingProbe: () => runScopingProbe,
+  runStaticPass: () => runStaticPass,
   saveProfiles: () => saveProfiles,
   scoreCML: () => score,
   scoreToConcernSignals: () => scoreToConcernSignals,
+  serializeSignals: () => serializeSignals,
+  shapeKey: () => shapeKey,
   temporalSuccessRate: () => temporalSuccessRate,
   toRawWorkItem: () => toRawWorkItem,
   verdictSchema: () => verdictSchema,
@@ -2120,23 +2155,624 @@ 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]));
+}
+
+// src/triage/record.ts
+function shapeKey(labels, category, level) {
+  const sortedLabels = Array.from(
+    new Set(labels.map((l) => l.trim().replace(/[,|]/g, "")).filter((l) => l.length > 0))
+  ).sort();
+  return `${sortedLabels.join(",")}|${category}|${level}`;
+}
+function dispatchableShapeKey(labels, level) {
+  return shapeKey(labels, "dispatchable", level);
+}
+
+// src/triage/precedent.ts
+function aggregatePrecedent(records, shapeKey2) {
+  let matched = 0;
+  let total = 0;
+  for (const rec of records) {
+    if (rec.shapeKey !== shapeKey2) continue;
+    if (!rec.outcome) continue;
+    total += 1;
+    if (rec.outcome.matched) matched += 1;
+  }
+  if (total === 0) return { kind: "unknown" };
+  return { kind: "rate", matched, total, rate: matched / total };
+}
+function precedentLookupFromRecords(records) {
+  return {
+    rateForShape: (shapeKey2) => aggregatePrecedent(records, shapeKey2)
+  };
+}
+
+// src/triage/entities.ts
+var BACKTICKED_RE = /`([^`]+)`/g;
+var PATH_RE = /(?:\.\/)?(?:[A-Za-z0-9_@.-]+\/)+[A-Za-z0-9_.-]+/g;
+var CAMEL_RE = /\b([A-Z][a-z]+[A-Za-z0-9]*[A-Z][A-Za-z0-9]*|[a-z]+[A-Z][A-Za-z0-9]*)\b/g;
+var DOTTED_RE = /\b[A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)+\b/g;
+function extractEntities(text) {
+  if (typeof text !== "string") return [];
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  const add = (raw) => {
+    const token = raw.trim();
+    if (token.length === 0) return;
+    if (seen.has(token)) return;
+    seen.add(token);
+    result.push(token);
+  };
+  for (const m of trimmed.matchAll(BACKTICKED_RE)) {
+    const inner = m[1];
+    if (inner !== void 0) add(inner);
+  }
+  for (const m of trimmed.matchAll(PATH_RE)) add(m[0]);
+  for (const m of trimmed.matchAll(CAMEL_RE)) add(m[0]);
+  for (const m of trimmed.matchAll(DOTTED_RE)) add(m[0]);
+  return result;
+}
+
+// src/triage/probe.ts
+var import_zod7 = require("zod");
+var DEFAULT_CONFIG = {
+  boundedScopeMax: 40,
+  dispatchConfidence: "medium",
+  precedentBlockRate: 0,
+  precedentMinSample: 1
+};
+var OpenDecisionsSchema = import_zod7.z.object({
+  openDecisions: import_zod7.z.array(import_zod7.z.object({ question: import_zod7.z.string() })).describe(
+    "Choices requiring human judgment (API shape, product tradeoff, irreversible action)"
+  )
+});
+var OPEN_DECISIONS_SYSTEM_PROMPT = "You are triaging a backlog item for autonomous execution. Identify ONLY choices that genuinely require human judgment before an agent could safely proceed \u2014 API/interface shape, product tradeoffs, or irreversible/outward-facing actions. If the item is fully scoped and an agent could proceed without a human decision, return an empty array. Do not invent decisions; be conservative about what truly needs a human.";
+async function runScopingProbe(input, deps = {}) {
+  const config = { ...DEFAULT_CONFIG, ...deps.config };
+  const scope = await runScopeLever(input, deps.graph);
+  const semanticRead = await runSemanticReadLever(input, scope.value, deps);
+  const openDecisions = await runOpenDecisionsLever(input, deps.provider);
+  const precedent = runPrecedentLever(input, semanticRead.value, deps.precedent);
+  const levers = { scope, semanticRead, openDecisions, precedent };
+  const verdict = semanticRead.value === "unknown" ? { level: "moderate", confidence: "low", signals: {}, source: "static" } : semanticRead.value;
+  const { dispatchable, holdReason } = gate(levers, config);
+  const rationale = buildRationale(levers, dispatchable, holdReason);
+  return {
+    externalId: input.externalId,
+    verdict,
+    dispatchable,
+    ...holdReason !== void 0 ? { holdReason } : {},
+    levers,
+    rationale
+  };
+}
+async function runScopeLever(input, graph) {
+  if (graph === void 0) {
+    return { value: "unknown", reason: "scope: no graph seam available" };
+  }
+  try {
+    const resolved = [];
+    for (const candidate of input.entityCandidates) {
+      const hit = await graph.resolve(candidate);
+      if (hit) resolved.push(hit);
+    }
+    const blastRadius = resolved.reduce((max, r) => Math.max(max, r.blastRadius), 0);
+    const estimate = {
+      candidates: input.entityCandidates,
+      resolved,
+      blastRadius,
+      layersTouched: Math.min(resolved.length, 4),
+      filesTouched: resolved.length
+    };
+    const note = resolved.length === 0 ? "scope: no entity resolved in graph (unresolved-scope)" : `scope: ${resolved.length} entity(ies) resolved, blastRadius ${blastRadius}`;
+    return { value: estimate, reason: note };
+  } catch (err) {
+    return { value: "unknown", reason: `scope: graph lookup failed \u2014 ${errMsg(err)}` };
+  }
+}
+async function runSemanticReadLever(input, scope, deps) {
+  try {
+    const signals = {
+      descriptionLength: input.taskText.descriptionLength,
+      specExists: input.taskText.specExists,
+      acceptanceMeasurable: input.taskText.acceptanceMeasurable,
+      ...scope !== "unknown" && scope.resolved.length > 0 ? {
+        filesTouched: scope.filesTouched,
+        layersTouched: scope.layersTouched,
+        blastRadius: scope.blastRadius
+      } : {}
+    };
+    const phase = scope !== "unknown" && scope.resolved.length > 0 ? "post-diff" : "pre-diff";
+    const classifyInput = {
+      signals,
+      phase,
+      riskHigh: input.riskHigh === true,
+      prompt: input.taskText.prompt
+    };
+    const verdict = await classify(classifyInput, deps.provider, deps.models);
+    return { value: verdict, reason: `semantic-read: ${verdict.level}/${verdict.confidence}` };
+  } catch (err) {
+    return { value: "unknown", reason: `semantic-read: classify failed \u2014 ${errMsg(err)}` };
+  }
+}
+async function runOpenDecisionsLever(input, provider) {
+  if (provider === void 0) {
+    return { value: "unknown", reason: "open-decisions: no provider (offline)" };
+  }
+  try {
+    const { result } = await provider.analyze({
+      prompt: input.taskText.prompt,
+      systemPrompt: OPEN_DECISIONS_SYSTEM_PROMPT,
+      responseSchema: OpenDecisionsSchema,
+      maxTokens: 512
+    });
+    const decisions = result.openDecisions ?? [];
+    const note = decisions.length === 0 ? "open-decisions: none surfaced" : `open-decisions: ${decisions.length} requiring human judgment`;
+    return { value: decisions, reason: note };
+  } catch (err) {
+    return { value: "unknown", reason: `open-decisions: assessment failed \u2014 ${errMsg(err)}` };
+  }
+}
+function runPrecedentLever(input, verdict, precedent) {
+  if (precedent === void 0) {
+    return { value: "unknown", reason: "precedent: no store (cold-start)" };
+  }
+  try {
+    const level = verdict === "unknown" ? "moderate" : verdict.level;
+    const key = dispatchableShapeKey(input.labels, level);
+    const rate = precedent.rateForShape(key);
+    const note = rate.kind === "unknown" ? "precedent: unknown for this shape (no graded records)" : `precedent: ${rate.matched}/${rate.total} (${(rate.rate * 100).toFixed(0)}%)`;
+    return { value: rate, reason: note };
+  } catch (err) {
+    return { value: "unknown", reason: `precedent: lookup failed \u2014 ${errMsg(err)}` };
+  }
+}
+function gate(levers, config) {
+  const scope = levers.scope.value;
+  if (scope === "unknown" || scope.resolved.length === 0) {
+    return { dispatchable: false, holdReason: "unresolved-scope" };
+  }
+  if (scope.blastRadius > config.boundedScopeMax) {
+    return { dispatchable: false, holdReason: "unresolved-scope" };
+  }
+  const read = levers.semanticRead.value;
+  if (read === "unknown") {
+    return { dispatchable: false, holdReason: "not-in-band" };
+  }
+  const inBand = read.level === "trivial" || read.level === "simple";
+  const confidentEnough = CONFIDENCE_RANK[read.confidence] >= CONFIDENCE_RANK[config.dispatchConfidence];
+  if (!inBand || !confidentEnough) {
+    return { dispatchable: false, holdReason: "not-in-band" };
+  }
+  const decisions = levers.openDecisions.value;
+  if (decisions === "unknown") {
+    return { dispatchable: false, holdReason: "read-incomplete" };
+  }
+  if (decisions.length > 0) {
+    return { dispatchable: false, holdReason: "open-decision" };
+  }
+  const precedent = levers.precedent.value;
+  if (precedent !== "unknown" && precedent.kind === "rate" && precedent.total >= (config.precedentMinSample ?? 1) && precedent.rate <= (config.precedentBlockRate ?? 0)) {
+    return { dispatchable: false, holdReason: "precedent-contradicts" };
+  }
+  return { dispatchable: true };
+}
+function buildRationale(levers, dispatchable, holdReason) {
+  const parts = [];
+  for (const lever of [levers.scope, levers.semanticRead, levers.openDecisions, levers.precedent]) {
+    if (lever.reason) parts.push(lever.reason);
+  }
+  const decision = dispatchable ? "DISPATCHABLE \u2014 all levers corroborate." : `HELD (${holdReason}).`;
+  return `${decision} ${parts.join("; ")}`;
+}
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/triage/rank.ts
+function pilotScore(c) {
+  const effort = c.effort > 0 ? c.effort : 1e-6;
+  const score2 = c.impact * c.confidence / effort;
+  return Number.isFinite(score2) ? score2 : 0;
+}
+function rankTriageCandidates(candidates) {
+  return [...candidates].sort((a, b) => {
+    const sa = pilotScore(a);
+    const sb = pilotScore(b);
+    if (sa !== sb) return sb - sa;
+    if (a.impact !== b.impact) return b.impact - a.impact;
+    return a.externalId < b.externalId ? -1 : a.externalId > b.externalId ? 1 : 0;
+  });
+}
+
+// src/triage/brainstorm/types.ts
+var DEPTH_BY_LEVEL = {
+  trivial: { maxForks: 2 },
+  simple: { maxForks: 4 },
+  // moderate/complex are OUT of the eligible band (the probe holds them to human) — a depth
+  // is defined only so the mapping is total; the brainstorm should never run on them.
+  moderate: { maxForks: 4 },
+  complex: { maxForks: 4 }
+};
+function depthForLevel(level) {
+  return DEPTH_BY_LEVEL[level] ?? { maxForks: 2 };
+}
+
+// src/triage/brainstorm/runner.ts
+async function runAutoBrainstorm(input, generator, depth) {
+  const accepted = [];
+  const ceiling = Math.max(0, depth.maxForks);
+  for (let index = 0; index < ceiling; index++) {
+    let decision;
+    try {
+      decision = await generator.next(index, accepted);
+    } catch (err) {
+      return {
+        kind: "halted",
+        fork: { id: `fork-${index}`, question: "brainstorm errored before deciding", options: [] },
+        reason: "error",
+        detail: errMsg2(err)
+      };
+    }
+    if (decision === null || decision === void 0) break;
+    if (decision.confidence !== "high") {
+      return {
+        kind: "halted",
+        fork: decision.fork,
+        reason: "low-confidence",
+        detail: `fork '${decision.fork.id}' recommended '${decision.recommendation}' at confidence '${decision.confidence}' (below the 'high' bar) \u2014 ${decision.rationale}`
+      };
+    }
+    accepted.push(decision);
+  }
+  const spec = {
+    externalId: input.externalId,
+    title: input.title,
+    summary: input.summary,
+    decisions: accepted
+  };
+  return { kind: "completed", spec };
+}
+function errMsg2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/triage/retrospective.ts
+var LEVEL_RANK = {
+  trivial: 0,
+  simple: 1,
+  moderate: 2,
+  complex: 3
+};
+var BLAST_TOLERANCE_FACTOR = 1.5;
+var BLAST_TOLERANCE_ABS = 2;
+var DEFAULT_RETROSPECTIVE_CONFIG = { exceededByBands: 1 };
+function blockEscalate(exceededBy = 1) {
+  return { matched: false, exceededBy: Math.max(1, exceededBy), action: "block-escalate" };
+}
+function isLevel(value) {
+  return typeof value === "string" && Object.prototype.hasOwnProperty.call(LEVEL_RANK, value);
+}
+function blastRadiusOf(verdict) {
+  const raw = verdict.signals?.blastRadius;
+  return typeof raw === "number" && Number.isFinite(raw) ? raw : void 0;
+}
+function compareToPrediction(prediction, postDiffVerdict, config = DEFAULT_RETROSPECTIVE_CONFIG) {
+  if (prediction == null || postDiffVerdict == null) return blockEscalate();
+  const predictedLevel = prediction.verdict?.level;
+  const actualLevel = postDiffVerdict.level;
+  if (!isLevel(predictedLevel) || !isLevel(actualLevel)) return blockEscalate();
+  const levelDelta = LEVEL_RANK[actualLevel] - LEVEL_RANK[predictedLevel];
+  const bandThreshold = Math.max(1, Math.floor(config.exceededByBands));
+  if (levelDelta >= bandThreshold) return blockEscalate(levelDelta);
+  const predictedScope = typeof prediction.scopeEstimate === "number" && Number.isFinite(prediction.scopeEstimate) ? prediction.scopeEstimate : 0;
+  const actualBlast = blastRadiusOf(postDiffVerdict);
+  if (actualBlast !== void 0) {
+    const threshold = predictedScope * BLAST_TOLERANCE_FACTOR + BLAST_TOLERANCE_ABS;
+    if (actualBlast > threshold) return blockEscalate();
+  }
+  return { matched: true, exceededBy: 0, action: "verify" };
+}
+
+// src/triage/ratchet.ts
+var V1_MAX_STAGE = 2;
+var DEFAULT_RATCHET_CONFIG = {
+  threshold: 0.9,
+  minSample: 5,
+  window: 10
+};
+function resolveStage(history, config = DEFAULT_RATCHET_CONFIG) {
+  const window = Math.max(1, Math.floor(config.window));
+  const ordered = history.length > 1 ? [...history].sort((a, b) => (a.ts ?? "").localeCompare(b.ts ?? "")) : history;
+  const recent = ordered.slice(-window);
+  if (recent.length < config.minSample) return 1;
+  if (recent[recent.length - 1]?.matched === false) return 1;
+  const matched = recent.reduce((n, o) => o.matched ? n + 1 : n, 0);
+  const rate = matched / recent.length;
+  if (rate < config.threshold) return 1;
+  return Math.min(2, V1_MAX_STAGE);
+}
+
+// src/triage/gate.ts
+var AUTO_EXECUTE_CATEGORIES = /* @__PURE__ */ new Set([
+  "quick-fix",
+  "diagnostic"
+]);
+function resolveGoNoGoStaged(candidates) {
+  const approved = [];
+  const held = [];
+  for (const c of candidates) {
+    if (c.effectiveStage !== 1 && c.effectiveStage !== 2) {
+      held.push({
+        externalId: c.externalId,
+        category: c.category,
+        reason: "ratchet-stage-unsupported"
+      });
+      continue;
+    }
+    if (!AUTO_EXECUTE_CATEGORIES.has(c.category)) {
+      held.push({ externalId: c.externalId, category: c.category, reason: "not-auto-executable" });
+      continue;
+    }
+    if (!c.humanApproved) {
+      held.push({ externalId: c.externalId, category: c.category, reason: "awaiting-human-go" });
+      continue;
+    }
+    approved.push({ ...c, effectiveStage: c.effectiveStage });
+  }
+  return { approved, held };
+}
+function resolveGoNoGo(candidates, stage) {
+  return resolveGoNoGoStaged(candidates.map((c) => ({ ...c, effectiveStage: stage })));
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCEPTANCE_EVAL_SYSTEM_PROMPT,
+  AUTO_EXECUTE_CATEGORIES,
   AcceptanceEvaluator,
   AnthropicAnalysisProvider,
+  BLAST_TOLERANCE_ABS,
+  BLAST_TOLERANCE_FACTOR,
   ClaudeCliAnalysisProvider,
+  DEFAULT_DEGRADE_AT_PCT,
+  DEFAULT_RATCHET_CONFIG,
+  DEFAULT_RETROSPECTIVE_CONFIG,
+  DEPTH_BY_LEVEL,
   ExecutionOutcomeConnector,
   GraphValidator,
   IntelligencePipeline,
+  LEVEL_RANK,
   OUTCOME_EVAL_SYSTEM_PROMPT,
   OpenAICompatibleAnalysisProvider,
   OutcomeEvaluator,
   PeslSimulator,
+  RANK_TIER,
+  SENSITIVE_BLAST_THRESHOLD,
+  STATIC_WEIGHTS,
+  TIER_RANK,
+  V1_MAX_STAGE,
   acceptanceVerdictSchema,
+  aggregatePrecedent,
+  applyBudgetClamp,
+  baseTier,
+  blastRadiusVeto,
   buildAcceptanceUserPrompt,
   buildSpecializationProfile,
   buildUserPrompt,
+  classify,
+  compareToPrediction,
   computeExpertiseLevel,
   computeHistoricalComplexity,
   computePersonaEffectiveness,
@@ -2145,24 +2781,40 @@ function refreshProfiles(projectRoot, graphStore, opts) {
   computeStructuralComplexity,
   createCanaryAdapter,
   decayWeight,
+  depthForLevel,
   deriveAcceptanceAuthority,
   deriveAuthority,
+  deriveRequiredTier,
   detectBlindSpots,
+  dispatchableShapeKey,
   enrich,
+  extractEntities,
   findingSchema,
   githubToRawWorkItem,
   jiraToRawWorkItem,
   linearToRawWorkItem,
+  llmTiebreak,
   loadProfiles,
   manualToRawWorkItem,
+  pilotScore,
+  precedentLookupFromRecords,
+  rankTriageCandidates,
   recommendPersona,
   refreshProfiles,
+  resolveGoNoGo,
+  resolveGoNoGoStaged,
   resolveSection,
+  resolveStage,
+  runAutoBrainstorm,
   runGraphOnlyChecks,
   runLlmSimulation,
+  runScopingProbe,
+  runStaticPass,
   saveProfiles,
   scoreCML,
   scoreToConcernSignals,
+  serializeSignals,
+  shapeKey,
   temporalSuccessRate,
   toRawWorkItem,
   verdictSchema,