@harness-engineering/intelligence 0.6.0 → 0.8.0

package/dist/index.mjs

@@ -2251,15 +2251,393 @@ function deriveRequiredTier(complexity, risk, policy, spend, escalationFloor, sk
   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
+import { z as z7 } from "zod";
+var DEFAULT_CONFIG = {
+  boundedScopeMax: 40,
+  dispatchConfidence: "medium",
+  precedentBlockRate: 0,
+  precedentMinSample: 1
+};
+var OpenDecisionsSchema = z7.object({
+  openDecisions: z7.array(z7.object({ question: z7.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: "scope-too-large" };
+  }
+  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 })));
+}
 export {
   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,
@@ -2268,7 +2646,9 @@ export {
   SENSITIVE_BLAST_THRESHOLD,
   STATIC_WEIGHTS,
   TIER_RANK,
+  V1_MAX_STAGE,
   acceptanceVerdictSchema,
+  aggregatePrecedent,
   applyBudgetClamp,
   baseTier,
   blastRadiusVeto,
@@ -2276,6 +2656,7 @@ export {
   buildSpecializationProfile,
   buildUserPrompt2 as buildUserPrompt,
   classify,
+  compareToPrediction,
   computeExpertiseLevel,
   computeHistoricalComplexity,
   computePersonaEffectiveness,
@@ -2284,11 +2665,14 @@ export {
   computeStructuralComplexity,
   createCanaryAdapter,
   decayWeight,
+  depthForLevel,
   deriveAcceptanceAuthority,
   deriveAuthority,
   deriveRequiredTier,
   detectBlindSpots,
+  dispatchableShapeKey,
   enrich,
+  extractEntities,
   findingSchema,
   githubToRawWorkItem,
   jiraToRawWorkItem,
@@ -2296,16 +2680,25 @@ export {
   llmTiebreak,
   loadProfiles,
   manualToRawWorkItem,
+  pilotScore,
+  precedentLookupFromRecords,
+  rankTriageCandidates,
   recommendPersona,
   refreshProfiles,
+  resolveGoNoGo,
+  resolveGoNoGoStaged,
   resolveSection,
+  resolveStage,
+  runAutoBrainstorm,
   runGraphOnlyChecks,
   runLlmSimulation,
+  runScopingProbe,
   runStaticPass,
   saveProfiles,
   score as scoreCML,
   scoreToConcernSignals,
   serializeSignals,
+  shapeKey,
   temporalSuccessRate,
   toRawWorkItem,
   verdictSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harness-engineering/intelligence",
-  "version": "0.6.0",
+  "version": "0.8.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/graph": "0.11.7",
-    "@harness-engineering/types": "0.21.0"
+    "@harness-engineering/graph": "0.11.8",
+    "@harness-engineering/types": "0.22.0"
   },
   "optionalDependencies": {
     "canary-test-cli": "^5.4.0"